Emergency 20 Dokumentation  4.2.0
OperationMessages.h
Go to the documentation of this file.
1 // Copyright (C) 2012-2018 Promotion Software GmbH
2 
3 
4 //[-------------------------------------------------------]
5 //[ Header guard ]
6 //[-------------------------------------------------------]
7 #pragma once
8 
9 
10 //[-------------------------------------------------------]
11 //[ Includes ]
12 //[-------------------------------------------------------]
17 
19 
21 #include <qsf/base/StringHash.h>
22 #include <qsf/math/Color4.h>
23 #include <qsf/time/Time.h>
24 
25 #include <type_traits> // For std::underlying_type
26 #include <memory> // For std::make_unique
27 
28 
29 //[-------------------------------------------------------]
30 //[ Namespace ]
31 //[-------------------------------------------------------]
32 namespace em5
33 {
34  namespace multiplayer
35  {
36 
37 
38  //[-------------------------------------------------------]
39  //[ Public definitions ]
40  //[-------------------------------------------------------]
41  typedef boost::container::flat_map<qsf::NamedIdentifier, uint64> ContentAuthenticationChecksums;
42 
47  // Note: We use here enum class to avoid that the names of the enum pollutes the scope in which the enum was defined
48  // The only downside is: that an enum class type isn't implicit convertible into an integer type
49  // Please make sure that when adding new types to the list to put them at the end. Otherwise we might get into problems
50  // We support up to 254 operation messages
51  enum class OperationMessage : uint8
52  {
53  UNKNOWN,
54  // Pre game messages
57 
59 
62 
64 
65  DATA_UPDATE,
67 
71 
74 
75  CHAT_MESSAGE,
76 
77  // Other operation message combined with DATA_UPDATE message in one stream
80  UNIT_SPAWNED,
85  NEW_HINTS,
88  AUDIO_UPDATE,
91 
94 
96 
101 
102  // Other operation message combined with DATA_UPDATE message in one stream
103  LAYER_CHANGED,
104 
105  SERVER_PING,
107 
108  // Other operation message combined with DATA_UPDATE message in one stream
109  FADE_ENTITY,
110  MINIMAP_PING,
111 
113  };
114 
115  // Note: We use here enum class to avoid that the names of the enum pollutes the scope in which the enum was defined
116  // The only downside is: that an enum class type isn't implicit convertible into an integer type
117  enum class JoinResponse : uint8
118  {
119  UNKNOWN,
120  JOIN_SUCCESS,
125  };
126 
128  {
132  std::string playerName;
133 
134  // The following is for direct-connect only, but doesn't hurt to transport this information in a generic way
135  std::string sessionName;
140  };
141 
143  {
144  std::string playerName;
145  uint8 edition; // Enumerated by "VersionSwitch::Edition" enum definition
146  std::string password;
147  std::string gameModifications;
148  ContentAuthenticationChecksums checksums;
149  uint8 mapQualiy; // Enumerated by "qsf::RendererSettingsGroup::MapQuality" enum definition
150  };
151 
153  {
155 
157  mLocalAssetId(0)
158  {}
159 
161  mLocalAssetId(localAssetId)
162  {}
163  };
164 
166  {
173 
175  mSpawnedUnitEntityId(qsf::getUninitialized<uint64>()),
176  mPlayerIndex(qsf::getUninitialized<uint32>()),
177  mOrderInfoId(qsf::getUninitialized<uint32>()),
178  mContainerEntityId(qsf::getUninitialized<uint64>()),
179  mSpawnpointEntityId(qsf::getUninitialized<uint64>()),
180  mUserData(qsf::getUninitialized<uint64>())
181  {}
182 
183  UnitSpawnedData(uint64 spawnedUnitEntityId, uint32 playerIndex, uint32 orderInfoId, uint64 containerEntityId, uint64 spawnpointEntityId, uint64 userData) :
184  mSpawnedUnitEntityId(spawnedUnitEntityId),
185  mPlayerIndex(playerIndex),
186  mOrderInfoId(orderInfoId),
187  mContainerEntityId(containerEntityId),
188  mSpawnpointEntityId(spawnpointEntityId),
189  mUserData(userData)
190  {}
191  };
192 
194  {
197 
199  mPlayerId(qsf::getUninitialized<uint32>()),
200  mEntityId(qsf::getUninitialized<uint64>())
201  {
202  // Nothing to do in here
203  }
204 
206  mPlayerId(playerId),
207  mEntityId(entityId)
208  {
209  // Nothing to do in here
210  }
211  };
212 
214  {
217  glm::vec3 mTargetPosition;
219 
221  mPlayerIndex(qsf::getUninitialized<uint32>()),
222  mOrderInfoId(qsf::getUninitialized<uint32>())
223  {}
224 
225  OrderUnitData(uint32 playerIndex, uint32 orderInfoId, const glm::vec3& targetPosition, const OrderInfo::OrderPairList& orderPairList) :
226  mPlayerIndex(playerIndex),
227  mOrderInfoId(orderInfoId),
228  mTargetPosition(targetPosition),
229  mOrderPairList(orderPairList)
230  {}
231  };
232 
234  {
236  std::vector<uint64> mCallerIds;
239  boost::optional<glm::vec3> mTargetPosition;
240 
242  mCommandId(qsf::getUninitialized<uint32>()),
243  mTargetId(qsf::getUninitialized<uint64>()),
244  mAllowSelfExecution(false)
245  {}
246 
247  CommandExecutionData(const uint32 commandId, const uint64 targetId, const bool allowSelfExecution, const boost::optional<glm::vec3>& targetPosition) :
248  mCommandId(commandId),
249  mTargetId(targetId),
250  mAllowSelfExecution(allowSelfExecution),
251  mTargetPosition(targetPosition)
252  {}
253  };
254 
256  {
257  bool mSuccess;
259  std::vector<uint64> mCallerIds;
261  boost::optional<glm::vec3> mTargetPosition;
262 
264  mSuccess(false),
265  mCommandId(qsf::getUninitialized<uint32>()),
266  mTargetId(qsf::getUninitialized<uint64>())
267  {}
268 
269  CommandExecutionResult(bool success, uint32 commandId, const uint64 targetId, const boost::optional<glm::vec3>& targetPosition) :
270  mSuccess(success),
271  mCommandId(commandId),
272  mTargetId(targetId),
273  mTargetPosition(targetPosition)
274  {}
275  };
276 
278  {
279  bool mRemoved;
280  std::string mText;
286 
288  mRemoved(false),
289  mType(0),
290  mTypeId(0),
291  mCurrentNumber(0),
292  mNeededNumber(0),
293  mOrderPriority(0)
294  {}
295 
296  FreeplayObjectiveData(const std::string& text, uint32 typeId, uint8 type, uint8 dataType) :
297  mRemoved(false),
298  mText(text),
299  mType(type),
300  mTypeId(typeId),
301  mCurrentNumber(0),
302  mNeededNumber(0),
303  mOrderPriority(0)
304  {}
305  };
306 
308  {
309  bool mIsNew;
311  std::string mName;
319  // We need the items to be ordered by key
320  boost::container::flat_map<uint32, FreeplayObjectiveData> mObjectives;
321 
323  mIsNew(false),
324  mIsFinished(false),
325  mId(0),
326  mState(0),
327  mDestroyed(false),
328  mFocusEntityId(qsf::getUninitialized<uint64>()),
329  mPlayerIndex(qsf::getUninitialized<uint8>()),
330  mHasEventLocationEntity(false)
331  {}
332 
333  FreeplayEventData(const uint32 id, const std::string& name) :
334  mIsNew(true),
335  mIsFinished(false),
336  mName(name),
337  mId(id),
338  mState(0),
339  mDestroyed(false),
340  mFocusEntityId(qsf::getUninitialized<uint64>()),
341  mPlayerIndex(qsf::getUninitialized<uint8>()),
342  mHasEventLocationEntity(false)
343  {}
344  };
345 
347  {
348  bool mChanged; // This is only internal
349  bool mFinished;
350  uint16 mTimeLeftInSeconds; // This supports max of 18 hours
351 
353  mChanged(false),
354  mFinished(false),
355  mTimeLeftInSeconds(0)
356  {}
357  };
358 
359  struct NewHintData
360  {
362  std::string mMessage;
364 
366  mType(HintMessage::MESSAGETYPE_UNKNOWN),
367  mPlayerIndex(qsf::getUninitialized<uint32>())
368  {}
369 
370  NewHintData(HintMessage::MessageType type, const std::string& message, uint32 playerIndex) :
371  mType(type),
372  mMessage(message),
373  mPlayerIndex(playerIndex)
374  {}
375  };
376 
378  {
382 
384  mMessageId(qsf::getUninitialized<uint32>()),
385  mTargetEntityId(qsf::getUninitialized<uint64>()),
386  mCallerId(qsf::getUninitialized<uint64>())
387  {}
388 
389  MinimapMessageData(const uint32 messageId, const uint64 targetEntityId) :
390  mMessageId(messageId),
391  mTargetEntityId(targetEntityId),
392  mCallerId(qsf::getUninitialized<uint64>())
393  {}
394 
395  MinimapMessageData(const uint32 messageId, const uint64 targetEntityId, const uint64 callerEntityId) :
396  mMessageId(messageId),
397  mTargetEntityId(targetEntityId),
398  mCallerId(callerEntityId)
399  {}
400  };
401 
403  {
405  {
410  };
411 
412  struct Parameters {};
413 
414  struct IconParameters : public Parameters
415  {
417  float mIconScale;
418 
420  mIconType(qsf::getUninitialized<int8>()),
421  mIconScale(qsf::getUninitialized<float>())
422  {}
423 
424  IconParameters(int8 iconType, float iconScale) :
425  mIconType(iconType),
426  mIconScale(iconScale)
427  {}
428  };
429 
430  struct CircleParameters : public Parameters
431  {
432  float mRadius;
436 
438  mRadius(qsf::getUninitialized<float>()),
439  mPoints(qsf::getUninitialized<uint8>()),
440  mUpdatePosition(false)
441  {}
442 
443  CircleParameters(float radius, uint8 points, const qsf::Color4& color, bool updatePosition) :
444  mRadius(radius),
445  mPoints(points),
446  mColor(color),
447  mUpdatePosition(updatePosition)
448  {}
449  };
450 
453  std::unique_ptr<Parameters> mParameters;
454 
456  mMessageType(RemoveIcon),
457  mEntityId(qsf::getUninitialized<uint64>())
458  {}
459 
460  MinimapIconMessageData(MessageType messageType, uint64 entityId, std::unique_ptr<Parameters>&& parameters) :
461  mMessageType(messageType),
462  mEntityId(entityId),
463  mParameters(std::move(parameters))
464  {}
465 
467  mMessageType(other.mMessageType),
468  mEntityId(other.mEntityId)
469  {
470  switch (mMessageType)
471  {
472  case RemoveIcon:
473  case RemovePolygon:
474  break;
475 
476  case AddIcon:
477  mParameters = std::make_unique<IconParameters>(*static_cast<const IconParameters*>(other.mParameters.get()));
478  break;
479 
480  case AddCircle:
481  mParameters = std::make_unique<CircleParameters>(*static_cast<const CircleParameters*>(other.mParameters.get()));
482  break;
483  }
484  }
485 
487  {
488  return MinimapIconMessageData(RemoveIcon, entityId, nullptr);
489  }
490 
491  static inline MinimapIconMessageData CreateAddIconMessageData(uint64 entityId, int8 iconType, float iconScale)
492  {
493  return MinimapIconMessageData(AddIcon, entityId, std::make_unique<IconParameters>(iconType, iconScale));
494  }
495 
496  static inline MinimapIconMessageData CreateAddCirclePolygonMessageData(uint64 entityId, float radius, uint8 points, const qsf::Color4& color, bool updatePosition)
497  {
498  return MinimapIconMessageData(AddCircle, entityId, std::make_unique<CircleParameters>(radius, points, color, updatePosition));
499  }
500 
502  {
503  return MinimapIconMessageData(RemovePolygon, entityId, nullptr);
504  }
505  };
506 
508  {
510  bool mIsStart;
511  bool mIsStop;
512  uint16 mDelayTimeInMilliseconds; // This supports max of 65,5 seconds
515  std::string mFileName;
519  uint8 mVolume; // 0-100%
521 
523  mId(0),
524  mIsStart(false),
525  mIsStop(false),
526  mDelayTimeInMilliseconds(0),
527  mLocalAssetId(qsf::getUninitialized<uint32>()),
528  mContextEntityId(qsf::getUninitialized<uint64>()),
529  mIsSpartial(false),
530  mIsLooping(false),
531  mIsDetached(false),
532  mVolume(100),
533  mChannel(0)
534  {}
535  };
536 
538  {
540  bool mActive;
541 
543  mLayerId(qsf::getUninitialized<uint32>()),
544  mActive(false)
545  {}
546 
547  LayerChangedData(const uint32 layerId, bool active) :
548  mLayerId(layerId),
549  mActive(active)
550  {}
551  };
552 
554  {
555  std::vector<uint16> mPing;
557 
559  mServerTime(qsf::Time::ZERO)
560  {}
561 
562  ServerPingData(const qsf::Time& serverTime) :
563  mServerTime(serverTime)
564  {}
565  };
566 
568  {
570 
572  mServerTime(qsf::Time::ZERO)
573  {}
574 
576  mServerTime(serverTime)
577  {}
578  };
579 
581  {
584  std::string mConnectorBoneName;
585  std::string mNozzleBoneName;
586 
588  mConnectorEntityId(qsf::getUninitialized<uint64>()),
589  mNozzleEntityId(qsf::getUninitialized<uint64>())
590  {}
591 
592  CreateFireHoseData(const uint64 connectorEntityId, const uint64 nozzleEntityId, const std::string& connectorBoneName, const std::string& nozzleBoneName) :
593  mConnectorEntityId(connectorEntityId),
594  mNozzleEntityId(nozzleEntityId),
595  mConnectorBoneName(connectorBoneName),
596  mNozzleBoneName(nozzleBoneName)
597  {}
598  };
599 
601  {
603  float mTimeout;
604  glm::vec3 mPosition;
605  glm::vec3 mScale;
606 
608  mPrefabAssetId(qsf::getUninitialized<uint32>()),
609  mTimeout(0.0f),
610  mScale(1.0f, 1.0f, 1.0f)
611  {}
612 
613  SpawnParticleData(const uint32 prefabAssetId, const float timeout, const glm::vec3& position, const glm::vec3& scale) :
614  mPrefabAssetId(prefabAssetId),
615  mTimeout(timeout),
616  mPosition(position),
617  mScale(scale)
618  {}
619  };
620 
622  {
625  bool mFadeIn;
626 
628  mEntityId(qsf::getUninitialized<uint64>()),
629  mFadeTime(qsf::Time::ZERO),
630  mFadeIn(false)
631  {}
632 
633  FadeEntityData(const uint64 entityId, const qsf::Time& fadeTime, const bool fadeIn) :
634  mEntityId(entityId),
635  mFadeTime(fadeTime),
636  mFadeIn(fadeIn)
637  {}
638  };
639 
641  {
642  glm::vec3 mPingPosition;
643 
645  {}
646 
647  MinimapPingData(const glm::vec3& pingPosition) :
648  mPingPosition(pingPosition)
649  {}
650  };
651 
652 
653 //[-------------------------------------------------------]
654 //[ Namespace ]
655 //[-------------------------------------------------------]
656  } // multiplayer
657 } // em5
An unit has spawned (Contains a list of the data, at least one)
qsf::Time mServerTime
Definition: OperationMessages.h:556
Send by the host, when a player changed it's userData.
Definition: ActionPriority.h:13
Definition: OperationMessages.h:359
uint32 mPlayerIndex
The player index which initiated the unit ordering on a client.
Definition: OperationMessages.h:215
signed char int8
Definition: PlatformTypes.h:174
Definition: OperationMessages.h:377
OrderUnitData(uint32 playerIndex, uint32 orderInfoId, const glm::vec3 &targetPosition, const OrderInfo::OrderPairList &orderPairList)
Definition: OperationMessages.h:225
Definition: OperationMessages.h:640
IconParameters()
Definition: OperationMessages.h:419
An unit has spawned and qualifies for a selection update (Contains a list of the data, at least one)
bool mIsStop
Definition: OperationMessages.h:511
std::string mConnectorBoneName
Definition: OperationMessages.h:584
A list of minimap related messages.
uint64 mEntityId
The id of the spawned unit.
Definition: OperationMessages.h:196
OrderInfo::OrderPairList mOrderPairList
A list how many personnel the ordered unit should have.
Definition: OperationMessages.h:218
uint64 mFocusEntityId
Definition: OperationMessages.h:315
LayerChangedData(const uint32 layerId, bool active)
Definition: OperationMessages.h:547
std::string password
Definition: OperationMessages.h:146
uint64 mNozzleEntityId
Definition: OperationMessages.h:583
bool mHasEventLocationEntity
Definition: OperationMessages.h:317
Definition: OperationMessages.h:580
UnitSpawnedData()
Definition: OperationMessages.h:174
Definition: OperationMessages.h:567
Definition: OperationMessages.h:255
uint64 mEntityId
Definition: OperationMessages.h:452
bool playerSeparation
Definition: OperationMessages.h:139
static MinimapIconMessageData CreateRemoveIconMessageData(uint64 entityId)
Definition: OperationMessages.h:486
uint64 mTargetEntityId
Definition: OperationMessages.h:380
AudioUpdateData()
Definition: OperationMessages.h:522
uint32 mNeededNumber
Definition: OperationMessages.h:284
float mRadius
Definition: OperationMessages.h:432
Send by the host, when a player left the session.
NewHintData()
Definition: OperationMessages.h:365
Color class with red, green, blue and alpha component.
Definition: Color4.h:39
ServerPingData()
Definition: OperationMessages.h:558
unsigned int uint32
Definition: PlatformTypes.h:181
HintMessage::MessageType mType
Definition: OperationMessages.h:361
An freeplay event has changed on the host side.
uint8 edition
Definition: OperationMessages.h:145
Definition: OperationMessages.h:142
bool mFinished
Definition: OperationMessages.h:349
uint32 playerIndex
Definition: OperationMessages.h:131
bool mIsLooping
Definition: OperationMessages.h:517
CommandExecutionData()
Definition: OperationMessages.h:241
uint32 mId
Definition: OperationMessages.h:312
JoinResponse response
Definition: OperationMessages.h:129
glm::vec3 mEventLocationPosition
Definition: OperationMessages.h:318
MinimapPingData(const glm::vec3 &pingPosition)
Definition: OperationMessages.h:647
MessageType mMessageType
Definition: OperationMessages.h:451
OrderUnitData()
Definition: OperationMessages.h:220
Contains a list of layer data which have been changed (got activated/deactivated) ...
uint64 mSpawnpointEntityId
The entity ID of the spawn point.
Definition: OperationMessages.h:171
uint64 mCallerId
Definition: OperationMessages.h:381
Definition: AreaConfiguration.h:58
static MinimapIconMessageData CreateRemovePolygonMessageData(uint64 entityId)
Definition: OperationMessages.h:501
boost::optional< glm::vec3 > mTargetPosition
The target position where the command should be take place.
Definition: OperationMessages.h:239
MinimapMessageData(const uint32 messageId, const uint64 targetEntityId)
Definition: OperationMessages.h:389
An client changes it's ready state (ready for starting the game, is normally triggered by the player)...
uint32 mPlayerIndex
The player index, which caused the spawing.
Definition: OperationMessages.h:168
uint8 mapQualiy
Definition: OperationMessages.h:149
uint64 mSpawnedUnitEntityId
The ID of the spawned unit.
Definition: OperationMessages.h:167
int8 mIconType
Definition: OperationMessages.h:416
This operation message gets send by each client to the host, when the player on the client initiates ...
boost::container::flat_map< qsf::NamedIdentifier, uint64 > ContentAuthenticationChecksums
Definition: OperationMessages.h:41
Definition: OperationMessages.h:213
bool mFadeIn
Definition: OperationMessages.h:625
uint32 mOrderInfoId
The ID of the order info, which describes the unit.
Definition: OperationMessages.h:169
std::vector< uint16 > mPing
List of ping values per player (player id = index in the list)
Definition: OperationMessages.h:555
OperationMessage
EMERGENCY 5 multiplayer operation message types.
Definition: OperationMessages.h:51
Send by the host to all clients, when everyone has successfully loaded the map and the game can start...
std::vector< uint64 > mCallerIds
The entity id of the command caller.
Definition: OperationMessages.h:236
ContentAuthenticationChecksums checksums
Definition: OperationMessages.h:148
uint64 mTargetId
The entity id of the command target.
Definition: OperationMessages.h:260
qsf::Color4 mColor
Definition: OperationMessages.h:434
uint64_t uint64
Definition: PlatformTypes.h:184
Definition: OperationMessages.h:277
uint32 mCurrentNumber
Definition: OperationMessages.h:283
Send by the host, when a player joins the session (contains a list of player informations, at least one)
Definition: OperationMessages.h:165
glm::vec3 mPingPosition
Definition: OperationMessages.h:642
Definition: OperationMessages.h:307
Gets send by the host, when the highscore publish was done.
SpawnParticleData()
Definition: OperationMessages.h:607
multiplayer::GameMode gameMode
Definition: OperationMessages.h:136
A list of changed audio information (play/stop)
Definition: OperationMessages.h:346
CommandExecutionResult(bool success, uint32 commandId, const uint64 targetId, const boost::optional< glm::vec3 > &targetPosition)
Definition: OperationMessages.h:269
std::string mName
Definition: OperationMessages.h:311
bool mSuccess
Was the command successfully executed=.
Definition: OperationMessages.h:257
boost::optional< glm::vec3 > mTargetPosition
The target position where the command should be take place.
Definition: OperationMessages.h:261
uint16 mDelayTimeInMilliseconds
Definition: OperationMessages.h:512
uint8 mVolume
Definition: OperationMessages.h:519
std::string playerName
Definition: OperationMessages.h:132
bool mIsDetached
Definition: OperationMessages.h:518
uint32 mChannel
Definition: OperationMessages.h:520
qsf::Time mFadeTime
Definition: OperationMessages.h:624
Definition: OperationMessages.h:412
uint64 mEntityId
Definition: OperationMessages.h:623
GameMode
< Connected to CAMP
Definition: MatchmakingTypes.h:41
Definition: OperationMessages.h:507
uint64 mConnectorEntityId
Definition: OperationMessages.h:582
Definition: PickupPersonByParamedicAction.h:21
std::string playerName
Definition: OperationMessages.h:144
FreeplayObjectiveData(const std::string &text, uint32 typeId, uint8 type, uint8 dataType)
Definition: OperationMessages.h:296
bool mIsNew
Definition: OperationMessages.h:309
EntityCreatedFromPrefabData(const qsf::StringHash &localAssetId)
Definition: OperationMessages.h:160
EntityCreatedFromPrefabData()
Definition: OperationMessages.h:156
uint8 mType
Definition: OperationMessages.h:281
CreateFireHoseData()
Definition: OperationMessages.h:587
std::string mMessage
Definition: OperationMessages.h:362
qsf::Time mServerTime
Definition: OperationMessages.h:569
CircleParameters()
Definition: OperationMessages.h:437
uint64 mContextEntityId
Definition: OperationMessages.h:514
uint32 mId
Definition: OperationMessages.h:509
std::string mFileName
Definition: OperationMessages.h:515
Definition: OperationMessages.h:233
Definition: OperationMessages.h:537
uint8 mPoints
Definition: OperationMessages.h:433
Send by the client, when a unit should be ordered (one message per unit)
uint32 mCommandId
The player index which initiated the unit ordering on a client.
Definition: OperationMessages.h:235
bool mIsSpartial
Definition: OperationMessages.h:516
CommandExecutionResult()
Definition: OperationMessages.h:263
std::string sessionName
Definition: OperationMessages.h:135
uint32 mPlayerId
The id of the owning player.
Definition: OperationMessages.h:195
uint32 mMessageId
Definition: OperationMessages.h:379
T getUninitialized()
Definition: GetUninitialized.h:38
MinimapIconMessageData(MessageType messageType, uint64 entityId, std::unique_ptr< Parameters > &&parameters)
Definition: OperationMessages.h:460
boost::container::flat_map< uint32, FreeplayObjectiveData > mObjectives
Definition: OperationMessages.h:320
uint32 maxPlayerCount
Definition: OperationMessages.h:137
uint32 mPrefabAssetId
Definition: OperationMessages.h:602
Gets send by host or an client if someone wants to submit the highscore.
MinimapMessageData()
Definition: OperationMessages.h:383
uint64 mTargetId
The entity id of the command target.
Definition: OperationMessages.h:237
glm::vec3 mScale
Definition: OperationMessages.h:605
Definition: OperationMessages.h:600
Definition: OperationMessages.h:408
GameModeUpdateData()
Definition: OperationMessages.h:352
uint64 mContainerEntityId
The entity ID to which the entity is linked to on spawn (is valid for unit persons) ...
Definition: OperationMessages.h:170
The host wants that every client should now load the map (the game will shortly begin) ...
uint32 mLayerId
Definition: OperationMessages.h:539
bool mChanged
Definition: OperationMessages.h:348
Send by the client to inform the host about the camera position of the player (needed for cleanup) ...
FreeplayEventData(const uint32 id, const std::string &name)
Definition: OperationMessages.h:333
JoinResponse
Definition: OperationMessages.h:117
uint16 mTimeLeftInSeconds
Definition: OperationMessages.h:350
std::vector< uint64 > mCallerIds
The entity id of the command caller.
Definition: OperationMessages.h:259
An entity was created on host side from an prefab (Contains a list of the data, at least one) ...
A list of data for newly created firehoses.
FadeEntityData(const uint64 entityId, const qsf::Time &fadeTime, const bool fadeIn)
Definition: OperationMessages.h:633
unsigned short uint16
Definition: PlatformTypes.h:178
glm::vec3 mPosition
Definition: OperationMessages.h:604
Send by the host, when a player changed it's ready state.
MinimapPingData()
Definition: OperationMessages.h:644
A client wants to join to a session.
Gets send by host or an client if someone accept to submit the highscore.
CircleParameters(float radius, uint8 points, const qsf::Color4 &color, bool updatePosition)
Definition: OperationMessages.h:443
LayerChangedData()
Definition: OperationMessages.h:542
MinimapIconMessageData(const MinimapIconMessageData &other)
Definition: OperationMessages.h:466
uint8 mPlayerIndex
Definition: OperationMessages.h:316
Definition: OperationMessages.h:553
bool mIsStart
Definition: OperationMessages.h:510
ClientPingAcknowledgeData(const qsf::Time &serverTime)
Definition: OperationMessages.h:575
Definition: OperationMessages.h:127
Definition: OperationMessages.h:152
std::string mNozzleBoneName
Definition: OperationMessages.h:585
float mTimeout
Definition: OperationMessages.h:603
UnitSpawnedPlayerUpdateSelectionData()
Definition: OperationMessages.h:198
CreateFireHoseData(const uint64 connectorEntityId, const uint64 nozzleEntityId, const std::string &connectorBoneName, const std::string &nozzleBoneName)
Definition: OperationMessages.h:592
Hint message contains information about the text, sound file, video file the hint system needs...
Definition: HintMessage.h:32
static MinimapIconMessageData CreateAddIconMessageData(uint64 entityId, int8 iconType, float iconScale)
Definition: OperationMessages.h:491
glm::vec3 mTargetPosition
The target position to which the ordered unit should go first.
Definition: OperationMessages.h:217
UnitSpawnedPlayerUpdateSelectionData(uint32 playerId, uint64 entityId)
Definition: OperationMessages.h:205
MinimapMessageData(const uint32 messageId, const uint64 targetEntityId, const uint64 callerEntityId)
Definition: OperationMessages.h:395
A list of hints which were started between two update calls.
Send by the client, when this player changed it's userData.
ServerPingData(const qsf::Time &serverTime)
Definition: OperationMessages.h:562
bool mRemoved
Definition: OperationMessages.h:279
boost::container::flat_map< std::string, uint32 > OrderPairList
Definition: OrderInfo.h:63
NewHintData(HintMessage::MessageType type, const std::string &message, uint32 playerIndex)
Definition: OperationMessages.h:370
bool mDestroyed
Definition: OperationMessages.h:314
bool mActive
Definition: OperationMessages.h:540
uint32 mOrderPriority
Definition: OperationMessages.h:285
FreeplayEventData()
Definition: OperationMessages.h:322
qsf::StringHash mLocalAssetId
Definition: OperationMessages.h:154
The response which the host sends to a client after a join request.
Definition: OperationMessages.h:406
Send by the client as a response to SERVER_PING.
FadeEntityData()
Definition: OperationMessages.h:627
Compile time string hash class.
Definition: StringHash.h:59
This operation message gets send by the host as the response to a CLIENT_COMMAND_EXECUTION message...
Definition: OperationMessages.h:407
MinimapIconMessageData()
Definition: OperationMessages.h:455
float mIconScale
Definition: OperationMessages.h:417
uint8 mState
Definition: OperationMessages.h:313
uint32 mOrderInfoId
The order info id of the ordered unit.
Definition: OperationMessages.h:216
CommandExecutionData(const uint32 commandId, const uint64 targetId, const bool allowSelfExecution, const boost::optional< glm::vec3 > &targetPosition)
Definition: OperationMessages.h:247
UnitSpawnedData(uint64 spawnedUnitEntityId, uint32 playerIndex, uint32 orderInfoId, uint64 containerEntityId, uint64 spawnpointEntityId, uint64 userData)
Definition: OperationMessages.h:183
FreeplayObjectiveData()
Definition: OperationMessages.h:287
Response from the clients after they received the SERVER_LOAD_MAP operation message and have successf...
uint32 mTypeId
Definition: OperationMessages.h:282
This operation message gets periodically send from the host to all clients. With this message the hos...
SpawnParticleData(const uint32 prefabAssetId, const float timeout, const glm::vec3 &position, const glm::vec3 &scale)
Definition: OperationMessages.h:613
MessageType
Definition: HintMessage.h:40
IconParameters(int8 iconType, float iconScale)
Definition: OperationMessages.h:424
ClientPingAcknowledgeData()
Definition: OperationMessages.h:571
uint32 mCommandId
The player index which initiated the unit ordering on a client.
Definition: OperationMessages.h:258
qsf::GlobalAssetId globalMapId
Definition: OperationMessages.h:130
A list of data for newly spawned particles.
An entity was destroyed on host side (Contains a list of the entity ids, at least one) ...
uint32 mPlayerIndex
Definition: OperationMessages.h:363
uint32 gameDuration
Definition: OperationMessages.h:138
Definition: OperationMessages.h:621
Send by the server to let a entity fade in/out via fade effect component.
bool mIsFinished
Definition: OperationMessages.h:310
std::string mText
Definition: OperationMessages.h:280
bool mAllowSelfExecution
Indicates if the command is executable on the caller itself.
Definition: OperationMessages.h:238
MessageType
Definition: OperationMessages.h:404
uint64 mUserData
Optional user data to send in "em5::Messages::EM5_SPAWN_UNIT", "qsf::getUninitialized()" if t...
Definition: OperationMessages.h:172
Gets send by host or an client if someone declined to submit the highscore.
uint64 GlobalAssetId
Definition: AssetSystemTypes.h:28
Definition: OperationMessages.h:402
std::unique_ptr< Parameters > mParameters
Definition: OperationMessages.h:453
unsigned char uint8
Definition: PlatformTypes.h:175
std::string gameModifications
Definition: OperationMessages.h:147
Send by host or client, when a chat message was created.
static MinimapIconMessageData CreateAddCirclePolygonMessageData(uint64 entityId, float radius, uint8 points, const qsf::Color4 &color, bool updatePosition)
Definition: OperationMessages.h:496
bool mUpdatePosition
Definition: OperationMessages.h:435
uint32 mLocalAssetId
Definition: OperationMessages.h:513
Data type for encapsulating time information. It might represents points in time and time spans...
Definition: Time.h:32