OpenClonk
C4Packet2.cpp
Go to the documentation of this file.
1 /*
2  * OpenClonk, http://www.openclonk.org
3  *
4  * Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
5  * Copyright (c) 2009-2016, The OpenClonk Team and contributors
6  *
7  * Distributed under the terms of the ISC license; see accompanying file
8  * "COPYING" for details.
9  *
10  * "Clonk" is a registered trademark of Matthes Bender, used with permission.
11  * See accompanying file "TRADEMARK" for details.
12  *
13  * To redistribute this file separately, substitute the full license texts
14  * for the above references.
15  */
16 #include "C4Include.h"
17 
18 #include "C4Version.h"
19 #include "control/C4RoundResults.h"
20 #include "gui/C4GameLobby.h"
22 #include "network/C4Network2.h"
23 #include "network/C4Network2Res.h"
24 
25 // *** constants
26 
27 // workaround
28 template <class T> struct unpack_class
29 {
31  {
32  assert(pComp->isDeserializer());
33  T *pPkt = new T();
34  try
35  {
36  pComp->Value(*pPkt);
37  }
38  catch (...)
39  {
40  delete pPkt;
41  throw;
42  }
43  return pPkt;
44  }
45 };
46 
47 #define PKT_UNPACK(T) unpack_class<T>::unpack
48 
49 
51 {
52 
53  // C4Network2IO (network thread)
54  { PID_Conn, PC_Network, "Connection Request", true, true, PH_C4Network2IO, PKT_UNPACK(C4PacketConn) },
55  { PID_ConnRe, PC_Network, "Connection Request Reply", true, true, PH_C4Network2IO, PKT_UNPACK(C4PacketConnRe) },
56 
57  { PID_Ping, PC_Network, "Ping", true, true, PH_C4Network2IO, PKT_UNPACK(C4PacketPing) },
58  { PID_Pong, PC_Network, "Pong", true, true, PH_C4Network2IO, PKT_UNPACK(C4PacketPing) },
59 
60  { PID_FwdReq, PC_Network, "Forward Request", false, true, PH_C4Network2IO, PKT_UNPACK(C4PacketFwd) },
61  { PID_Fwd, PC_Network, "Forward", false, true, PH_C4Network2IO, PKT_UNPACK(C4PacketFwd) },
62 
63  { PID_PostMortem, PC_Network, "Post Mortem", false, true, PH_C4Network2IO, PKT_UNPACK(C4PacketPostMortem) },
64 
65  // C4Network2 (main thread)
66  { PID_Conn, PC_Network, "Connection Request", true, false, PH_C4Network2, PKT_UNPACK(C4PacketConn) },
67  { PID_ConnRe, PC_Network, "Connection Request Reply", true, false, PH_C4Network2, PKT_UNPACK(C4PacketConnRe) },
68 
69  { PID_Status, PC_Network, "Game Status", true, false, PH_C4Network2, PKT_UNPACK(C4Network2Status) },
70  { PID_StatusAck, PC_Network, "Game Status Acknowledgement",true, false, PH_C4Network2, PKT_UNPACK(C4Network2Status) },
71 
72  { PID_ClientActReq, PC_Network, "Client Activation Request", false, false, PH_C4Network2, PKT_UNPACK(C4PacketActivateReq) },
73 
74  { PID_JoinData, PC_Network, "Join Data", false, false, PH_C4Network2, PKT_UNPACK(C4PacketJoinData) },
75 
76  // C4Network2PlayerList (main thread)
77  { PID_PlayerInfoUpdReq,PC_Network, "Player info update request",true, false, PH_C4Network2Players, PKT_UNPACK(C4PacketPlayerInfoUpdRequest) },
78 
80 
81  // C4GameLobby (main thread)
84 
85  // C4Network2ClientList (main thread)
86  { PID_Addr, PC_Network, "Client Address", false, false, PH_C4Network2ClientList, PKT_UNPACK(C4PacketAddr) },
87  { PID_TCPSimOpen, PC_Network, "TCP simultaneous open req", false, false, PH_C4Network2ClientList, PKT_UNPACK(C4PacketTCPSimOpen) },
88 
89 
90  // C4Network2ResList (network thread)
91  { PID_NetResDis, PC_Network, "Resource Discover", true, true, PH_C4Network2ResList, PKT_UNPACK(C4PacketResDiscover) },
92  { PID_NetResStat, PC_Network, "Resource Status", false, true, PH_C4Network2ResList, PKT_UNPACK(C4PacketResStatus) },
93  { PID_NetResDerive, PC_Network, "Resource Derive", false, true, PH_C4Network2ResList, PKT_UNPACK(C4Network2ResCore) },
94  { PID_NetResReq, PC_Network, "Resource Request", false, true, PH_C4Network2ResList, PKT_UNPACK(C4PacketResRequest) },
95  { PID_NetResData, PC_Network, "Resource Data", false, true, PH_C4Network2ResList, PKT_UNPACK(C4Network2ResChunk) },
96 
97  // C4GameControlNetwork (network thread)
99  { PID_ControlReq, PC_Network, "Control Request", false, true, PH_C4GameControlNetwork, PKT_UNPACK(C4PacketControlReq) },
100  // main thread
101  { PID_ControlPkt, PC_Network, "Control Paket", false, false, PH_C4GameControlNetwork, PKT_UNPACK(C4PacketControlPkt) },
102  { PID_ExecSyncCtrl, PC_Network, "Execute Sync Control", false, false, PH_C4GameControlNetwork, PKT_UNPACK(C4PacketExecSyncCtrl)},
103 
104  // Control (Isn't send over network, handled only as part of a control list)
105  { CID_ClientJoin, PC_Control, "Client Join", false, true, 0, PKT_UNPACK(C4ControlClientJoin) },
106  { CID_ClientUpdate, PC_Control, "Client Update", false, true, 0, PKT_UNPACK(C4ControlClientUpdate)},
107  { CID_ClientRemove, PC_Control, "Client Remove", false, true, 0, PKT_UNPACK(C4ControlClientRemove)},
108  { CID_Vote, PC_Control, "Voting", false, true, 0, PKT_UNPACK(C4ControlVote) },
109  { CID_VoteEnd, PC_Control, "Voting End", false, true, 0, PKT_UNPACK(C4ControlVoteEnd) },
110  { CID_SyncCheck, PC_Control, "Sync Check", false, true, 0, PKT_UNPACK(C4ControlSyncCheck) },
111  { CID_Synchronize, PC_Control, "Synchronize", false, true, 0, PKT_UNPACK(C4ControlSynchronize)},
112  { CID_Set, PC_Control, "Set", false, true, 0, PKT_UNPACK(C4ControlSet) },
113  { CID_Script, PC_Control, "Script", false, true, 0, PKT_UNPACK(C4ControlScript) },
114  { CID_MsgBoardReply,PC_Control, "Message Board Reply", false, true, 0, PKT_UNPACK(C4ControlMsgBoardReply)},
115  { CID_MsgBoardCmd ,PC_Control, "Message Board Command", false, true, 0, PKT_UNPACK(C4ControlMsgBoardCmd)},
116  { CID_PlrInfo, PC_Control, "Player Info", false, true, 0, PKT_UNPACK(C4ControlPlayerInfo) },
117  { CID_JoinPlr, PC_Control, "Join Player", false, true, 0, PKT_UNPACK(C4ControlJoinPlayer) },
118  { CID_RemovePlr, PC_Control, "Remove Player", false, true, 0, PKT_UNPACK(C4ControlRemovePlr) },
119  { CID_PlrSelect, PC_Control, "Player Select", false, true, 0, PKT_UNPACK(C4ControlPlayerSelect)},
120  { CID_PlrControl, PC_Control, "Player Control", false, true, 0, PKT_UNPACK(C4ControlPlayerControl)},
121  { CID_PlrAction, PC_Control, "Player Self-Mgmt Action", false, true, 0, PKT_UNPACK(C4ControlPlayerAction)},
122  { CID_PlrMouseMove, PC_Control, "Player Mouse Movement", false, true, 0, PKT_UNPACK(C4ControlPlayerMouse)},
123  { CID_Message, PC_Control, "Message", false, true, 0, PKT_UNPACK(C4ControlMessage) },
124  { CID_MenuCommand, PC_Control, "Menu Command", false, true, 0, PKT_UNPACK(C4ControlMenuCommand)},
125  { CID_EMMoveObj, PC_Control, "EM Move Obj", false, true, 0, PKT_UNPACK(C4ControlEMMoveObject)},
126  { CID_EMDrawTool, PC_Control, "EM Draw Tool", false, true, 0, PKT_UNPACK(C4ControlEMDrawTool) },
127  { CID_ReInitScenario,PC_Control, "Reinit Scenario", false, true, 0, PKT_UNPACK(C4ControlReInitScenario) },
128  { CID_EditGraph, PC_Control, "Edit Graph", false, true, 0, PKT_UNPACK(C4ControlEditGraph) },
129 
130  { CID_DebugRec, PC_Control, "Debug Rec", false, true, 0, PKT_UNPACK(C4ControlDebugRec) },
131 
132  // EOL
133  { PID_None, PC_Network, nullptr, false, true, 0, nullptr }
134 };
135 
136 const char *PacketNameByID(C4PacketType eID)
137 {
138  for (const C4PktHandlingData *pPData = PktHandlingData; pPData->ID != PID_None; pPData++)
139  if (pPData->ID == eID)
140  return pPData->Name;
141  return "?!?";
142 }
143 
144 // *** C4PacketBase
145 
146 C4PacketBase::C4PacketBase() = default;
147 
148 C4PacketBase::~C4PacketBase() = default;
149 
151 {
152  return C4NetIOPacket(DecompileToBuf<StdCompilerBinWrite>(*this), addr);
153 }
154 
155 C4NetIOPacket C4PacketBase::pack(uint8_t cStatus, const C4NetIO::addr_t &addr) const
156 {
157  return C4NetIOPacket(DecompileToBuf<StdCompilerBinWrite>(mkInsertAdapt(mkDecompileAdapt(*this), cStatus)), addr);
158 }
159 
160 void C4PacketBase::unpack(const C4NetIOPacket &Pkt, char *pStatus)
161 {
162  if (pStatus) *pStatus = Pkt.getStatus();
163  CompileFromBuf<StdCompilerBinRead>(*this, pStatus ? Pkt.getPBuf() : Pkt.getRef());
164 }
165 
166 
167 // *** C4PktBuf
168 
169 C4PktBuf::C4PktBuf() = default;
170 
172 {
173  Data.Copy(rCpyData);
174  return *this;
175 }
177 {
178  Data.Copy(rCopy.Data);
179  return *this;
180 }
181 
183 {
184  pComp->Value(mkNamingAdapt(Data, "Data"));
185 }
186 
187 // *** C4IDPacket
188 
189 C4IDPacket::C4IDPacket() = default;
190 
192  : eID(eID), pPkt(pPkt), fOwnPkt(fTakePkt), pNext(nullptr)
193 {
194 
195 }
196 
198  : C4PacketBase(Packet2)
199 {
200  // kinda hacky (note this might throw an uncaught exception)
201  C4PacketBase::unpack(Packet2.C4PacketBase::pack());
202 }
203 
205 {
206  Clear();
207 }
208 
209 const char *C4IDPacket::getPktName() const
210 {
211  // Use map
212  for (const C4PktHandlingData *pPData = PktHandlingData; pPData->ID != PID_None; pPData++)
213  if (pPData->ID == eID && pPData->Name)
214  return pPData->Name;
215  return "Unknown Packet Type";
216 }
217 
219 {
220  eID = PID_None; pPkt = nullptr;
221 }
222 
224 {
225  if (fOwnPkt) delete pPkt;
226  pPkt = nullptr;
227  eID = PID_None;
228 }
229 
231 {
232  // Packet ID
233  pComp->Value(mkNamingAdapt(mkIntAdaptT<uint8_t>(eID), "ID", PID_None));
234  // Compiling or Decompiling?
235  if (pComp->isDeserializer())
236  {
237  if (!pComp->Name(getPktName()))
238  { pComp->excCorrupt("C4IDPacket: Data value needed! Packet data missing!"); return; }
239  // Delete old packet
240  if (fOwnPkt) delete pPkt;
241  pPkt = nullptr;
242  if (eID == PID_None) return;
243  // Search unpacking function
244  for (const C4PktHandlingData *pPData = PktHandlingData; pPData->ID != PID_None; pPData++)
245  if (pPData->ID == eID && pPData->FnUnpack)
246  {
247  pPkt = pPData->FnUnpack(pComp);
248  break;
249  }
250  if (!pPkt)
251  pComp->excCorrupt("C4IDPacket: could not unpack packet id %02x!", eID);
252  pComp->NameEnd();
253  }
254  else if (eID != PID_None)
255  // Just write
256  pComp->Value(mkNamingAdapt(*pPkt, getPktName()));
257 }
258 
259 // *** C4PacketList
260 
261 C4PacketList::C4PacketList() = default;
262 
264  : C4PacketBase(List2),
265  pFirst(nullptr), pLast(nullptr)
266 {
267  Append(List2);
268 }
269 
271 {
272  Clear();
273 }
274 
275 int32_t C4PacketList::getPktCnt() const
276 {
277  int32_t iCnt = 0;
278  for (C4IDPacket *pPkt = pFirst; pPkt; pPkt = pPkt->pNext)
279  iCnt++;
280  return iCnt;
281 }
282 
284 {
285  assert(!pPkt->pNext);
286  (pLast ? pLast->pNext : pFirst) = pPkt;
287  pLast = pPkt;
288 }
289 
291 {
292  assert(!pPkt->pNext);
293  pPkt->pNext = pFirst;
294  pFirst = pPkt;
295  if (!pLast) pLast = pPkt;
296 }
297 
299 {
300  Add(new C4IDPacket(eType, pPkt));
301 }
302 
304 {
305  AddHead(new C4IDPacket(eType, pPkt));
306 }
307 
309 {
310  pFirst = List.pFirst;
311  pLast = List.pLast;
312  List.pFirst = List.pLast = nullptr;
313 }
314 
316 {
317  for (C4IDPacket *pPkt = List.firstPkt(); pPkt; pPkt = List.nextPkt(pPkt))
318  Add(new C4IDPacket(*pPkt));
319 }
320 
322 {
323  while (pFirst)
324  Delete(pFirst);
325 }
326 
328 {
329  if (pPkt == pFirst)
330  {
331  pFirst = pPkt->pNext;
332  if (pPkt == pLast)
333  pLast = nullptr;
334  }
335  else
336  {
337  C4IDPacket *pPrev;
338  for (pPrev = pFirst; pPrev && pPrev->pNext != pPkt; pPrev = pPrev->pNext) {}
339  if (pPrev)
340  {
341  pPrev->pNext = pPkt->pNext;
342  if (pPkt == pLast)
343  pLast = pPrev;
344  }
345  }
346 }
347 
349 {
350  Remove(pPkt);
351  delete pPkt;
352 }
353 
355 {
356  // unpack packets
357  if (pComp->isDeserializer())
358  {
359  // Read until no further sections available
360  while (pComp->Name("IDPacket"))
361  {
362  // Read the packet
363  C4IDPacket *pPkt = new C4IDPacket();
364  try
365  {
366  pComp->Value(*pPkt);
367  pComp->NameEnd();
368  }
369  catch (...)
370  {
371  delete pPkt;
372  throw;
373  }
374  // Terminator?
375  if (!pPkt->getPkt()) { delete pPkt; break; }
376  // Add to list
377  Add(pPkt);
378  }
379  pComp->NameEnd();
380  }
381  else
382  {
383  // Write all packets
384  for (C4IDPacket *pPkt = pFirst; pPkt; pPkt = pPkt->pNext)
385  pComp->Value(mkNamingAdapt(*pPkt, "IDPacket"));
386  // Terminate, if no naming is available
387  if (!pComp->hasNaming())
388  {
389  C4IDPacket Pkt;
390  pComp->Value(mkNamingAdapt(Pkt, "IDPacket"));
391  }
392  }
393 }
394 
395 // *** C4PacketConn
396 
398  : iVer(C4XVER1*100 + C4XVER2)
399 {
400 }
401 
402 C4PacketConn::C4PacketConn(const C4ClientCore &nCCore, uint32_t inConnID, const char *szPassword)
403  : iVer(C4XVER1*100 + C4XVER2),
404  iConnID(inConnID),
405  CCore(nCCore),
406  Password(szPassword)
407 {
408 }
409 
411 {
412  pComp->Value(mkNamingAdapt(CCore, "CCore"));
413  pComp->Value(mkNamingAdapt(mkIntPackAdapt(iVer), "Version", -1));
414  pComp->Value(mkNamingAdapt(Password, "Password", ""));
415  pComp->Value(mkNamingAdapt(mkIntPackAdapt(iConnID), "ConnID", ~0u));
416 }
417 
418 // *** C4PacketConnRe
419 
421 
422 C4PacketConnRe::C4PacketConnRe(bool fnOK, bool fWrongPassword, const char *sznMsg)
423  : fOK(fnOK),
424  fWrongPassword(fWrongPassword),
425  szMsg(sznMsg, true)
426 {
427 }
428 
430 {
431  pComp->Value(mkNamingAdapt(fOK, "OK", true));
432  pComp->Value(mkNamingAdapt(szMsg, "Message", ""));
433  pComp->Value(mkNamingAdapt(fWrongPassword, "WrongPassword", false));
434 }
435 
436 // *** C4PacketFwd
437 
438 C4PacketFwd::C4PacketFwd() = default;
439 
441  : Data(Pkt)
442 {
443 }
444 
445 bool C4PacketFwd::DoFwdTo(int32_t iClient) const
446 {
447  for (int32_t i = 0; i < iClientCnt; i++)
448  if (iClients[i] == iClient)
449  return !fNegativeList;
450  return fNegativeList;
451 }
452 
453 void C4PacketFwd::SetData(const StdBuf &Pkt)
454 {
455  Data = Pkt;
456 }
457 
458 void C4PacketFwd::SetListType(bool fnNegativeList)
459 {
460  fNegativeList = fnNegativeList;
461 }
462 
463 void C4PacketFwd::AddClient(int32_t iClient)
464 {
465  if (iClientCnt + 1 > C4NetMaxClients) return;
466  // add
467  iClients[iClientCnt++] = iClient;
468 }
469 
471 {
472  pComp->Value(mkNamingAdapt(fNegativeList, "Negative", false));
473  pComp->Value(mkNamingAdapt(mkIntPackAdapt(iClientCnt), "ClientCnt", 0));
474  pComp->Value(mkNamingAdapt(mkArrayAdaptMap(iClients, iClientCnt, mkIntPackAdapt<int32_t>), "Clients", -1));
475  pComp->Value(mkNamingAdapt(Data, "Data"));
476 }
477 
478 // *** C4PacketJoinData
479 
481 {
483  pComp->Value(mkNamingAdapt(mkIntPackAdapt(iStartCtrlTick), "CtrlTick", -1));
484  pComp->Value(mkNamingAdapt(mkParAdapt(GameStatus, true), "GameStatus"));
485  pComp->Value(mkNamingAdapt(Dynamic, "Dynamic"));
486  pComp->Value(mkNamingAdapt(ScenarioParameterDefs, "ParameterDefs"));
487  pComp->Value(Parameters);
488 }
489 
490 // *** C4PacketPing
491 
492 C4PacketPing::C4PacketPing(uint32_t iPacketCounter, uint32_t iRemotePacketCounter)
493  : tTime(C4TimeMilliseconds::Now()),
494  iPacketCounter(iPacketCounter)
495 {
496 }
497 
499 {
500  return C4TimeMilliseconds::Now() - tTime;
501 }
502 
504 {
505  uint32_t time = tTime.AsInt();
506  pComp->Value(mkNamingAdapt(time, "Time", 0U));
507  tTime = C4TimeMilliseconds(time);
508 
509  pComp->Value(mkNamingAdapt(iPacketCounter, "PacketCounter", 0U));
510 }
511 
512 // *** C4PacketResStatus
513 
515 
517  : iResID(iResID), Chunks(nChunks)
518 {
519 
520 }
521 
523 {
524  pComp->Value(mkNamingAdapt(iResID, "ResID"));
525  pComp->Value(mkNamingAdapt(Chunks, "Chunks"));
526 }
527 
528 // *** C4PacketResDiscover
529 
531 
532 bool C4PacketResDiscover::isIDPresent(int32_t iID) const
533 {
534  for (int32_t i = 0; i < iDisIDCnt; i++)
535  if (iDisIDs[i] == iID)
536  return true;
537  return false;
538 }
539 
541 {
542  if (iDisIDCnt + 1 >= int32_t(sizeof(iDisIDs) / sizeof(*iDisIDs))) return false;
543  // add
544  iDisIDs[iDisIDCnt++] = iID;
545  return true;
546 }
547 
549 {
550  pComp->Value(mkNamingAdapt(mkIntPackAdapt(iDisIDCnt), "DiscoverCnt", 0));
551  pComp->Value(mkNamingAdapt(mkArrayAdapt(iDisIDs, iDisIDCnt), "Discovers", -1));
552 }
553 
554 // *** C4PacketResRequest
555 
556 C4PacketResRequest::C4PacketResRequest(int32_t inID, int32_t inChunk)
557  : iReqID(inID), iReqChunk(inChunk)
558 {
559 
560 }
561 
563 {
564  pComp->Value(mkNamingAdapt(iReqID, "ResID", -1));
565  pComp->Value(mkNamingAdapt(mkIntPackAdapt(iReqChunk), "Chunk", -1));
566 }
567 
568 // *** C4PacketControlReq
569 
571  : iCtrlTick(inCtrlTick)
572 {
573 
574 }
575 
577 {
578  pComp->Value(mkNamingAdapt(mkIntPackAdapt(iCtrlTick), "CtrlTick", -1));
579 }
580 
581 // *** C4PacketActivateReq
582 
584 {
585  pComp->Value(mkNamingAdapt(mkIntPackAdapt(iTick), "Tick", -1));
586 }
587 
588 
589 // *** C4PacketControlPkt
590 
592 {
593  pComp->Value(mkNamingAdapt(mkIntAdaptT<uint8_t>(eDelivery), "Delivery", CDT_Queue));
594  pComp->Value(Ctrl);
595 }
const int32_t C4ClientIDUnknown
Definition: C4Client.h:24
@ CDT_Queue
Definition: C4GameControl.h:34
const int C4NetMaxClients
Definition: C4Network2IO.h:41
const char * PacketNameByID(C4PacketType eID)
Definition: C4Packet2.cpp:136
const C4PktHandlingData PktHandlingData[]
Definition: C4Packet2.cpp:50
#define PKT_UNPACK(T)
Definition: C4Packet2.cpp:47
@ PC_Network
Definition: C4PacketBase.h:184
@ PC_Control
Definition: C4PacketBase.h:185
C4PacketType
Definition: C4PacketBase.h:77
@ CID_ReInitScenario
Definition: C4PacketBase.h:171
@ PID_JoinData
Definition: C4PacketBase.h:116
@ PID_NetResDis
Definition: C4PacketBase.h:129
@ PID_StatusAck
Definition: C4PacketBase.h:104
@ PID_ControlReq
Definition: C4PacketBase.h:137
@ CID_JoinPlr
Definition: C4PacketBase.h:159
@ CID_MenuCommand
Definition: C4PacketBase.h:175
@ PID_SetScenarioParameter
Definition: C4PacketBase.h:126
@ PID_ExecSyncCtrl
Definition: C4PacketBase.h:139
@ CID_DebugRec
Definition: C4PacketBase.h:174
@ CID_SyncCheck
Definition: C4PacketBase.h:151
@ PID_PostMortem
Definition: C4PacketBase.h:96
@ CID_MsgBoardReply
Definition: C4PacketBase.h:155
@ CID_VoteEnd
Definition: C4PacketBase.h:149
@ CID_PlrInfo
Definition: C4PacketBase.h:158
@ PID_LeagueRoundResults
Definition: C4PacketBase.h:122
@ CID_Message
Definition: C4PacketBase.h:165
@ CID_PlrSelect
Definition: C4PacketBase.h:162
@ PID_TCPSimOpen
Definition: C4PacketBase.h:113
@ PID_ClientActReq
Definition: C4PacketBase.h:110
@ PID_NetResReq
Definition: C4PacketBase.h:132
@ PID_NetResDerive
Definition: C4PacketBase.h:131
@ CID_EMMoveObj
Definition: C4PacketBase.h:169
@ CID_PlrMouseMove
Definition: C4PacketBase.h:167
@ PID_Conn
Definition: C4PacketBase.h:88
@ PID_Pong
Definition: C4PacketBase.h:85
@ CID_EMDrawTool
Definition: C4PacketBase.h:170
@ PID_Control
Definition: C4PacketBase.h:136
@ CID_PlrAction
Definition: C4PacketBase.h:166
@ CID_PlrControl
Definition: C4PacketBase.h:163
@ PID_Fwd
Definition: C4PacketBase.h:93
@ PID_None
Definition: C4PacketBase.h:78
@ PID_PlayerInfoUpdReq
Definition: C4PacketBase.h:119
@ PID_NetResStat
Definition: C4PacketBase.h:130
@ CID_EditGraph
Definition: C4PacketBase.h:172
@ CID_Synchronize
Definition: C4PacketBase.h:152
@ PID_FwdReq
Definition: C4PacketBase.h:92
@ CID_MsgBoardCmd
Definition: C4PacketBase.h:156
@ CID_Script
Definition: C4PacketBase.h:154
@ CID_RemovePlr
Definition: C4PacketBase.h:160
@ CID_ClientRemove
Definition: C4PacketBase.h:146
@ CID_Vote
Definition: C4PacketBase.h:148
@ PID_ControlPkt
Definition: C4PacketBase.h:138
@ PID_Ping
Definition: C4PacketBase.h:84
@ CID_Set
Definition: C4PacketBase.h:153
@ CID_ClientJoin
Definition: C4PacketBase.h:144
@ CID_ClientUpdate
Definition: C4PacketBase.h:145
@ PID_LobbyCountdown
Definition: C4PacketBase.h:125
@ PID_Status
Definition: C4PacketBase.h:103
@ PID_ConnRe
Definition: C4PacketBase.h:89
@ PID_NetResData
Definition: C4PacketBase.h:133
@ PID_Addr
Definition: C4PacketBase.h:107
@ PH_C4Network2
Definition: C4PacketBase.h:192
@ PH_C4GUIMainDlg
Definition: C4PacketBase.h:193
@ PH_C4Network2Players
Definition: C4PacketBase.h:195
@ PH_C4Network2ResList
Definition: C4PacketBase.h:196
@ PH_C4Network2IO
Definition: C4PacketBase.h:191
@ PH_C4Network2ClientList
Definition: C4PacketBase.h:194
@ PH_C4GameControlNetwork
Definition: C4PacketBase.h:197
StdInsertAdapt< T, I > mkInsertAdapt(T &&rObj, I &&rIns, bool fBefore=true)
Definition: StdAdaptors.h:469
StdDecompileAdapt< T > mkDecompileAdapt(const T &rValue)
Definition: StdAdaptors.h:153
StdArrayAdapt< T > mkArrayAdapt(T *pArray, int iSize)
Definition: StdAdaptors.h:336
StdArrayAdapt< T, M > mkArrayAdaptMap(T *pArray, int iSize, M &&map)
Definition: StdAdaptors.h:340
StdIntPackAdapt< T > mkIntPackAdapt(T &rVal)
Definition: StdAdaptors.h:791
StdParameterAdapt< T, P > mkParAdapt(T &&rObj, P &&rPar)
Definition: StdAdaptors.h:490
StdNamingAdapt< T > mkNamingAdapt(T &&rValue, const char *szName)
Definition: StdAdaptors.h:92
int iCnt
Definition: TstC4NetIO.cpp:32
void Default()
Definition: C4Packet2.cpp:218
const char * getPktName() const
Definition: C4Packet2.cpp:209
~C4IDPacket() override
Definition: C4Packet2.cpp:204
C4PacketType eID
Definition: C4PacketBase.h:251
C4IDPacket * pNext
Definition: C4PacketBase.h:256
C4PacketBase * pPkt
Definition: C4PacketBase.h:252
void Clear()
Definition: C4Packet2.cpp:223
C4PacketBase * getPkt() const
Definition: C4PacketBase.h:260
void CompileFunc(StdCompiler *pComp) override
Definition: C4Packet2.cpp:230
uint8_t getStatus() const
Definition: C4NetIO.h:319
StdBuf getPBuf() const
Definition: C4NetIO.h:322
C4NetIOPacket getRef() const
Definition: C4NetIO.h:325
void CompileFunc(StdCompiler *pComp) override
Definition: C4Packet2.cpp:583
virtual ~C4PacketBase()
void unpack(const C4NetIOPacket &Pkt, char *pStatus=nullptr)
Definition: C4Packet2.cpp:160
C4NetIOPacket pack(const C4NetIO::addr_t &addr=C4NetIO::addr_t()) const
Definition: C4Packet2.cpp:150
int32_t iVer
Definition: C4Network2IO.h:358
uint32_t iConnID
Definition: C4Network2IO.h:359
void CompileFunc(StdCompiler *pComp) override
Definition: C4Packet2.cpp:410
StdCopyStrBuf Password
Definition: C4Network2IO.h:361
C4ClientCore CCore
Definition: C4Network2IO.h:360
void CompileFunc(StdCompiler *pComp) override
Definition: C4Packet2.cpp:429
StdStrBuf szMsg
Definition: C4Network2IO.h:380
void CompileFunc(StdCompiler *pComp) override
Definition: C4Packet2.cpp:591
void CompileFunc(StdCompiler *pComp) override
Definition: C4Packet2.cpp:576
C4PacketControlReq(int32_t iCtrlTick=-1)
Definition: C4Packet2.cpp:570
bool fNegativeList
Definition: C4Network2IO.h:397
StdCopyBuf Data
Definition: C4Network2IO.h:400
bool DoFwdTo(int32_t iClient) const
Definition: C4Packet2.cpp:445
int32_t iClients[C4NetMaxClients]
Definition: C4Network2IO.h:398
void CompileFunc(StdCompiler *pComp) override
Definition: C4Packet2.cpp:470
int32_t iClientCnt
Definition: C4Network2IO.h:399
void SetData(const StdBuf &Pkt)
Definition: C4Packet2.cpp:453
void AddClient(int32_t iClient)
Definition: C4Packet2.cpp:463
void SetListType(bool fnNegativeList)
Definition: C4Packet2.cpp:458
C4ScenarioParameterDefs ScenarioParameterDefs
Definition: C4Network2.h:437
int32_t iClientID
Definition: C4Network2.h:423
int32_t iStartCtrlTick
Definition: C4Network2.h:432
C4Network2Status GameStatus
Definition: C4Network2.h:429
C4GameParameters Parameters
Definition: C4Network2.h:440
void CompileFunc(StdCompiler *pComp) override
Definition: C4Packet2.cpp:480
C4Network2ResCore Dynamic
Definition: C4Network2.h:426
void CompileFunc(StdCompiler *pComp) override
Definition: C4Packet2.cpp:354
C4IDPacket * firstPkt() const
Definition: C4PacketBase.h:282
C4IDPacket * pFirst
Definition: C4PacketBase.h:279
C4IDPacket * pLast
Definition: C4PacketBase.h:279
void Clear()
Definition: C4Packet2.cpp:321
void Delete(C4IDPacket *pPkt)
Definition: C4Packet2.cpp:348
int32_t getPktCnt() const
Definition: C4Packet2.cpp:275
void AddHead(C4IDPacket *pPkt)
Definition: C4Packet2.cpp:290
void Take(C4PacketList &List)
Definition: C4Packet2.cpp:308
~C4PacketList() override
Definition: C4Packet2.cpp:270
void Add(C4IDPacket *pPkt)
Definition: C4Packet2.cpp:283
void Append(const C4PacketList &List)
Definition: C4Packet2.cpp:315
void Remove(C4IDPacket *pPkt)
Definition: C4Packet2.cpp:327
C4IDPacket * nextPkt(C4IDPacket *pPkt) const
Definition: C4PacketBase.h:283
void CompileFunc(StdCompiler *pComp) override
Definition: C4Packet2.cpp:503
uint32_t getTravelTime() const
Definition: C4Packet2.cpp:498
uint32_t iPacketCounter
Definition: C4Network2IO.h:342
C4TimeMilliseconds tTime
Definition: C4Network2IO.h:341
C4PacketPing(uint32_t iPacketCounter=0, uint32_t iRemotePacketCounter=0)
Definition: C4Packet2.cpp:492
Definition: C4Network2IO.h:418
bool AddDisID(int32_t iID)
Definition: C4Packet2.cpp:540
void CompileFunc(StdCompiler *pComp) override
Definition: C4Packet2.cpp:548
bool isIDPresent(int32_t iID) const
Definition: C4Packet2.cpp:532
C4PacketResRequest(int32_t iID=-1, int32_t iChunk=-1)
Definition: C4Packet2.cpp:556
void CompileFunc(StdCompiler *pComp) override
Definition: C4Packet2.cpp:562
void CompileFunc(StdCompiler *pComp) override
Definition: C4Packet2.cpp:522
C4Network2ResChunkData Chunks
void CompileFunc(StdCompiler *pComp) override
Definition: C4Packet2.cpp:182
C4PktBuf & operator=(const C4PktBuf &rCopy)
Definition: C4Packet2.cpp:176
StdCopyBuf Data
Definition: C4PacketBase.h:226
uint32_t AsInt() const
static C4TimeMilliseconds Now()
Definition: StdBuf.h:30
void Copy(size_t inSize)
Definition: StdBuf.h:225
void excCorrupt(const char *szMessage,...)
Definition: StdCompiler.h:249
void Value(const T &rStruct)
Definition: StdCompiler.h:161
virtual void NameEnd(bool fBreak=false)
Definition: StdCompiler.h:78
virtual bool isDeserializer()
Definition: StdCompiler.h:53
virtual bool Name(const char *szName)
Definition: StdCompiler.h:77
virtual bool hasNaming()
Definition: StdCompiler.h:58
C4PacketType ID
Definition: C4PacketBase.h:204
static C4PacketBase * unpack(StdCompiler *pComp)
Definition: C4Packet2.cpp:30