-
Notifications
You must be signed in to change notification settings - Fork 836
/
EventClient.h
351 lines (283 loc) · 12.1 KB
/
EventClient.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
/* This file is part of the Spring engine (GPL v2 or later), see LICENSE.html */
#ifndef EVENT_CLIENT_H
#define EVENT_CLIENT_H
#include <algorithm>
#include <typeinfo>
#include <string>
#include <vector>
#include "System/float3.h"
#include "System/Misc/SpringTime.h"
#ifdef __APPLE__
// defined in X11/X.h
#undef KeyPress
#undef KeyRelease
#endif
using std::string;
using std::vector;
class CUnit;
class CWeapon;
class CFeature;
class CProjectile;
struct Command;
class IArchive;
struct SRectangle;
struct UnitDef;
struct BuildInfo;
struct FeatureDef;
#ifndef zipFile
// might be defined through zip.h already
typedef void* zipFile;
#endif
enum DbgTimingInfoType {
TIMING_VIDEO,
TIMING_SIM,
TIMING_GC,
TIMING_SWAP,
TIMING_UNSYNCED
};
class CEventClient
{
public:
enum SpecialTeams {
NoAccessTeam = -1,
AllAccessTeam = -2,
MinSpecialTeam = AllAccessTeam
};
public:
inline const std::string& GetName() const { return name; }
inline int GetOrder() const { return order; }
inline bool GetSynced() const { return synced_; }
/**
* Used by the eventHandler to register
* call-ins when an EventClient is being added.
*/
virtual bool WantsEvent(const std::string& eventName);
// used by the eventHandler to route certain event types
virtual int GetReadAllyTeam() const { return NoAccessTeam; }
virtual bool GetFullRead() const { return GetReadAllyTeam() == AllAccessTeam; }
inline bool CanReadAllyTeam(int allyTeam) {
return (GetFullRead() || (GetReadAllyTeam() == allyTeam));
}
protected:
CEventClient(const std::string& name, int order, bool synced);
virtual ~CEventClient();
protected:
const std::string name;
const int order;
const bool synced_;
bool autoLinkEvents;
protected:
friend class CEventHandler;
typedef std::pair<std::string, bool> LinkPair;
std::vector<LinkPair> autoLinkedEvents;
template <class T>
void RegisterLinkedEvents(T* foo) {
#define SETUP_EVENT(eventname, props) \
autoLinkedEvents.push_back({#eventname, typeid(&T::eventname) != typeid(&CEventClient::eventname)});
#include "Events.def"
#undef SETUP_EVENT
std::stable_sort(autoLinkedEvents.begin(), autoLinkedEvents.end(), [](const LinkPair& a, const LinkPair& b) { return (a.first < b.first); });
}
public:
/**
* @name Synced_events
* @{
*/
virtual void Load(IArchive* archive) {}
virtual void GamePreload() {}
virtual void GameStart() {}
virtual void GameOver(const std::vector<unsigned char>& winningAllyTeams) {}
virtual void GamePaused(int playerID, bool paused) {}
virtual void GameFrame(int gameFrame) {}
virtual void GameID(const unsigned char* gameID, unsigned int numBytes) {}
virtual void TeamDied(int teamID) {}
virtual void TeamChanged(int teamID) {}
virtual void PlayerChanged(int playerID) {}
virtual void PlayerAdded(int playerID) {}
virtual void PlayerRemoved(int playerID, int reason) {}
virtual void UnitCreated(const CUnit* unit, const CUnit* builder) {}
virtual void UnitFinished(const CUnit* unit) {}
virtual void UnitReverseBuilt(const CUnit* unit) {}
virtual void UnitFromFactory(const CUnit* unit, const CUnit* factory, bool userOrders) {}
virtual void UnitDestroyed(const CUnit* unit, const CUnit* attacker) {}
virtual void UnitTaken(const CUnit* unit, int oldTeam, int newTeam) {}
virtual void UnitGiven(const CUnit* unit, int oldTeam, int newTeam) {}
virtual void UnitIdle(const CUnit* unit) {}
virtual void UnitCommand(const CUnit* unit, const Command& command) {}
virtual void UnitCmdDone(const CUnit* unit, const Command& command) {}
virtual void UnitDamaged(
const CUnit* unit,
const CUnit* attacker,
float damage,
int weaponDefID,
int projectileID,
bool paralyzer) {}
virtual void UnitStunned(const CUnit* unit, bool stunned) {}
virtual void UnitExperience(const CUnit* unit, float oldExperience) {}
virtual void UnitHarvestStorageFull(const CUnit* unit) {}
virtual void UnitSeismicPing(const CUnit* unit, int allyTeam,
const float3& pos, float strength) {}
virtual void UnitEnteredRadar(const CUnit* unit, int allyTeam) {}
virtual void UnitEnteredLos(const CUnit* unit, int allyTeam) {}
virtual void UnitLeftRadar(const CUnit* unit, int allyTeam) {}
virtual void UnitLeftLos(const CUnit* unit, int allyTeam) {}
virtual void UnitEnteredWater(const CUnit* unit) {}
virtual void UnitEnteredAir(const CUnit* unit) {}
virtual void UnitLeftWater(const CUnit* unit) {}
virtual void UnitLeftAir(const CUnit* unit) {}
virtual void UnitLoaded(const CUnit* unit, const CUnit* transport) {}
virtual void UnitUnloaded(const CUnit* unit, const CUnit* transport) {}
virtual void UnitCloaked(const CUnit* unit) {}
virtual void UnitDecloaked(const CUnit* unit) {}
virtual void RenderUnitCreated(const CUnit* unit, int cloaked) {}
virtual void RenderUnitDestroyed(const CUnit* unit) {}
virtual bool UnitUnitCollision(const CUnit* collider, const CUnit* collidee) { return false; }
virtual bool UnitFeatureCollision(const CUnit* collider, const CFeature* collidee) { return false; }
virtual void UnitMoved(const CUnit* unit) {}
virtual void UnitMoveFailed(const CUnit* unit) {}
virtual void FeatureCreated(const CFeature* feature) {}
virtual void FeatureDestroyed(const CFeature* feature) {}
virtual void FeatureDamaged(
const CFeature* feature,
const CUnit* attacker,
float damage,
int weaponDefID,
int projectileID) {}
virtual void FeatureMoved(const CFeature* feature, const float3& oldpos) {}
virtual void RenderFeatureCreated(const CFeature* feature) {}
virtual void RenderFeatureDestroyed(const CFeature* feature) {}
virtual void ProjectileCreated(const CProjectile* proj) {}
virtual void ProjectileDestroyed(const CProjectile* proj) {}
virtual void RenderProjectileCreated(const CProjectile* proj) {}
virtual void RenderProjectileDestroyed(const CProjectile* proj) {}
virtual void StockpileChanged(const CUnit* unit,
const CWeapon* weapon, int oldCount) {}
virtual bool Explosion(int weaponID, int projectileID, const float3& pos, const CUnit* owner) { return false; }
virtual bool CommandFallback(const CUnit* unit, const Command& cmd);
virtual bool AllowCommand(const CUnit* unit, const Command& cmd, bool fromSynced);
virtual bool AllowUnitCreation(const UnitDef* unitDef, const CUnit* builder, const BuildInfo* buildInfo);
virtual bool AllowUnitTransfer(const CUnit* unit, int newTeam, bool capture);
virtual bool AllowUnitBuildStep(const CUnit* builder, const CUnit* unit, float part);
virtual bool AllowUnitTransport(const CUnit* transporter, const CUnit* transportee);
virtual bool AllowFeatureCreation(const FeatureDef* featureDef, int allyTeamID, const float3& pos);
virtual bool AllowFeatureBuildStep(const CUnit* builder, const CFeature* feature, float part);
virtual bool AllowResourceLevel(int teamID, const string& type, float level);
virtual bool AllowResourceTransfer(int oldTeam, int newTeam, const string& type, float amount);
virtual bool AllowDirectUnitControl(int playerID, const CUnit* unit);
virtual bool AllowBuilderHoldFire(const CUnit* unit, int action);
virtual bool AllowStartPosition(int playerID, int teamID, unsigned char readyState, const float3& clampedPos, const float3& rawPickPos);
virtual bool TerraformComplete(const CUnit* unit, const CUnit* build);
virtual bool MoveCtrlNotify(const CUnit* unit, int data);
virtual int AllowWeaponTargetCheck(unsigned int attackerID, unsigned int attackerWeaponNum, unsigned int attackerWeaponDefID) { return -1; }
virtual bool AllowWeaponTarget(
unsigned int attackerID,
unsigned int targetID,
unsigned int attackerWeaponNum,
unsigned int attackerWeaponDefID,
float* targetPriority
) { return true; }
virtual bool AllowWeaponInterceptTarget(const CUnit* interceptorUnit, const CWeapon* interceptorWeapon, const CProjectile* interceptorTarget) { return true; }
virtual bool UnitPreDamaged(
const CUnit* unit,
const CUnit* attacker,
float damage,
int weaponDefID,
int projectileID,
bool paralyzer,
float* newDamage,
float* impulseMult
) { return false; }
virtual bool FeaturePreDamaged(
const CFeature* feature,
const CUnit* attacker,
float damage,
int weaponDefID,
int projectileID,
float* newDamage,
float* impulseMult
) { return false; }
virtual bool ShieldPreDamaged(
const CProjectile* projectile,
const CWeapon* shieldEmitter,
const CUnit* shieldCarrier,
bool bounceProjectile,
const CWeapon* beamEmitter,
const CUnit* beamCarrier,
const float3& startPos,
const float3& hitPos
) { return false; }
virtual bool SyncedActionFallback(const string& line, int playerID);
/// @}
/**
* @name Unsynced_events
* @{
*/
virtual void Save(zipFile archive);
virtual void Update();
virtual void UnsyncedHeightMapUpdate(const SRectangle& rect);
virtual bool KeyPress(int key, bool isRepeat);
virtual bool KeyRelease(int key);
virtual bool TextInput(const std::string& utf8);
virtual bool TextEditing(const std::string& utf8, unsigned int start, unsigned int length);
virtual bool MouseMove(int x, int y, int dx, int dy, int button);
virtual bool MousePress(int x, int y, int button);
virtual void MouseRelease(int x, int y, int button);
virtual bool MouseWheel(bool up, float value);
virtual void DownloadQueued(int ID, const string& archiveName, const string& archiveType);
virtual void DownloadStarted(int ID);
virtual void DownloadFinished(int ID);
virtual void DownloadFailed(int ID, int errorID);
virtual void DownloadProgress(int ID, long downloaded, long total);
virtual bool IsAbove(int x, int y);
virtual std::string GetTooltip(int x, int y);
virtual bool DefaultCommand(const CUnit* unit, const CFeature* feature, int& cmd);
virtual bool CommandNotify(const Command& cmd);
virtual bool AddConsoleLine(const std::string& msg, const std::string& section, int level);
virtual void LastMessagePosition(const float3& pos);
virtual bool GroupChanged(int groupID);
virtual bool GameSetup(const std::string& state, bool& ready,
const std::vector< std::pair<int, std::string> >& playerStates);
virtual std::string WorldTooltip(const CUnit* unit,
const CFeature* feature,
const float3* groundPos);
virtual bool MapDrawCmd(int playerID, int type,
const float3* pos0,
const float3* pos1,
const std::string* label);
virtual void SunChanged(); //FIXME add to lua
virtual void ViewResize();
virtual void DrawGenesis() {}
virtual void DrawWater() {}
virtual void DrawSky() {}
virtual void DrawSun() {}
virtual void DrawGrass() {}
virtual void DrawTrees() {}
virtual void DrawWorld() {}
virtual void DrawWorldPreUnit() {}
virtual void DrawWorldPreParticles() {}
virtual void DrawWorldShadow() {}
virtual void DrawWorldReflection() {}
virtual void DrawWorldRefraction() {}
virtual void DrawGroundPreForward() {}
virtual void DrawGroundPreDeferred() {}
virtual void DrawGroundPostDeferred() {}
virtual void DrawUnitsPostDeferred() {}
virtual void DrawFeaturesPostDeferred() {}
virtual void DrawScreenEffects() {}
virtual void DrawScreenPost() {}
virtual void DrawScreen() {}
virtual void DrawInMiniMap() {}
virtual void DrawInMiniMapBackground() {}
virtual bool DrawUnit(const CUnit* unit) { return false; }
virtual bool DrawFeature(const CFeature* feature) { return false; }
virtual bool DrawShield(const CUnit* unit, const CWeapon* weapon) { return false; }
virtual bool DrawProjectile(const CProjectile* projectile) { return false; }
virtual void GameProgress(int gameFrame);
virtual void DrawLoadScreen();
virtual void LoadProgress(const std::string& msg, const bool replace_lastline);
virtual void CollectGarbage();
virtual void DbgTimingInfo(DbgTimingInfoType type, const spring_time start, const spring_time end);
virtual void MetalMapChanged(const int x, const int z);
/// @}
};
#endif /* EVENT_CLIENT_H */