1 // ==============================================================
2 // This file is part of Glest (www.glest.org)
3 //
4 // Copyright (C) 2001-2008 Martiño Figueroa
5 //
6 // You can redistribute this code and/or modify it under
7 // the terms of the GNU General Public License as published
8 // by the Free Software Foundation; either version 2 of the
9 // License, or (at your option) any later version
10 // ==============================================================
11
12 #include "network_message.h"
13
14 #include "data_types.h"
15 #include "util.h"
16 #include "game_settings.h"
17 #include "checksum.h"
18 #include "platform_util.h"
19 #include "config.h"
20 #include "network_protocol.h"
21 #include "compression_utils.h"
22 #include <algorithm>
23 #include <cassert>
24 #include <stdexcept>
25 #include "common_scoped_ptr.h"
26
27 #include "leak_dumper.h"
28
29 using namespace Shared::Platform;
30 using namespace Shared::Util;
31 using namespace std;
32 using std::min;
33
34 namespace Glest{ namespace Game{
35
36 bool NetworkMessage::useOldProtocol = true;
37
38 auto_ptr<Mutex> NetworkMessage::mutexMessageStats(new Mutex(CODE_AT_LINE));
39 Chrono NetworkMessage::statsTimer;
40 Chrono NetworkMessage::lastSend;
41 Chrono NetworkMessage::lastRecv;
42 std::map<NetworkMessageStatisticType,int64> NetworkMessage::mapMessageStats;
43
44 // =====================================================
45 // class NetworkMessage
46 // =====================================================
47
receive(Socket * socket,void * data,int dataSize,bool tryReceiveUntilDataSizeMet)48 bool NetworkMessage::receive(Socket* socket, void* data, int dataSize, bool tryReceiveUntilDataSizeMet) {
49 if(socket != NULL) {
50 int dataReceived = socket->receive(data, dataSize, tryReceiveUntilDataSizeMet);
51 if(dataReceived != dataSize) {
52 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] WARNING, dataReceived = %d dataSize = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,dataReceived,dataSize);
53 if(SystemFlags::VERBOSE_MODE_ENABLED) printf("\nIn [%s::%s Line: %d] WARNING, dataReceived = %d dataSize = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,dataReceived,dataSize);
54
55 if(socket != NULL && socket->isSocketValid() == true) {
56 throw megaglest_runtime_error("Error receiving NetworkMessage, dataReceived = " + intToStr(dataReceived) + ", dataSize = " + intToStr(dataSize));
57 }
58 else {
59 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] socket has been disconnected\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
60 }
61 }
62 else {
63 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] dataSize = %d, dataReceived = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,dataSize,dataReceived);
64
65 dump_packet("\nINCOMING PACKET:\n",data, dataSize, false);
66 return true;
67 }
68 }
69 return false;
70
71 }
72
send(Socket * socket,const void * data,int dataSize)73 void NetworkMessage::send(Socket* socket, const void* data, int dataSize) {
74 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] socket = %p, data = %p, dataSize = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,socket,data,dataSize);
75
76 if(socket != NULL) {
77 dump_packet("\nOUTGOING PACKET:\n",data, dataSize, true);
78 int sendResult = socket->send(data, dataSize);
79 if(sendResult != dataSize) {
80 if(socket != NULL && socket->isSocketValid() == true) {
81 char szBuf[8096]="";
82 snprintf(szBuf,8096,"Error sending NetworkMessage, sendResult = %d, dataSize = %d",sendResult,dataSize);
83 throw megaglest_runtime_error(szBuf);
84 }
85 else {
86 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s] Line: %d socket has been disconnected\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
87 }
88 }
89 }
90 }
91
send(Socket * socket,const void * data,int dataSize,int8 messageType)92 void NetworkMessage::send(Socket* socket, const void* data, int dataSize, int8 messageType) {
93 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] socket = %p, data = %p, dataSize = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,socket,data,dataSize);
94
95 if(socket != NULL) {
96 int msgTypeSize = sizeof(messageType);
97 int fullMsgSize = msgTypeSize + dataSize;
98
99 char *out_buffer = new char[fullMsgSize];
100 memcpy(out_buffer,&messageType,msgTypeSize);
101 memcpy(&out_buffer[msgTypeSize],(const char *)data,dataSize);
102
103 dump_packet("\nOUTGOING PACKET:\n",out_buffer, fullMsgSize, true);
104 int sendResult = socket->send(out_buffer, fullMsgSize);
105 if(sendResult != fullMsgSize) {
106 delete [] out_buffer;
107 if(socket != NULL && socket->isSocketValid() == true) {
108 char szBuf[8096]="";
109 snprintf(szBuf,8096,"Error sending NetworkMessage, sendResult = %d, dataSize = %d",sendResult,fullMsgSize);
110 throw megaglest_runtime_error(szBuf);
111 }
112 else {
113 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s] Line: %d socket has been disconnected\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
114 }
115 }
116 else {
117 delete [] out_buffer;
118 }
119 }
120 }
121
send(Socket * socket,const void * data,int dataSize,int8 messageType,uint32 compressedLength)122 void NetworkMessage::send(Socket* socket, const void* data, int dataSize, int8 messageType, uint32 compressedLength) {
123 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] socket = %p, data = %p, dataSize = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,socket,data,dataSize);
124
125 if(socket != NULL) {
126 int msgTypeSize = sizeof(messageType);
127 int compressedSize = sizeof(compressedLength);
128 int fullMsgSize = msgTypeSize + compressedSize + dataSize;
129
130 char *out_buffer = new char[fullMsgSize];
131 memcpy(out_buffer,&messageType,msgTypeSize);
132 memcpy(&out_buffer[msgTypeSize],&compressedLength,compressedSize);
133 memcpy(&out_buffer[msgTypeSize+compressedSize],(const char *)data,dataSize);
134
135 dump_packet("\nOUTGOING PACKET:\n",out_buffer, fullMsgSize, true);
136 int sendResult = socket->send(out_buffer, fullMsgSize);
137 if(sendResult != fullMsgSize) {
138 delete [] out_buffer;
139 if(socket != NULL && socket->isSocketValid() == true) {
140 char szBuf[8096]="";
141 snprintf(szBuf,8096,"Error sending NetworkMessage, sendResult = %d, dataSize = %d",sendResult,fullMsgSize);
142 throw megaglest_runtime_error(szBuf);
143 }
144 else {
145 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s] Line: %d socket has been disconnected\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
146 }
147 }
148 else {
149 delete [] out_buffer;
150 }
151 }
152 }
153
resetNetworkPacketStats()154 void NetworkMessage::resetNetworkPacketStats() {
155 NetworkMessage::statsTimer.stop();
156 NetworkMessage::lastSend.stop();
157 NetworkMessage::lastRecv.stop();
158 NetworkMessage::mapMessageStats.clear();
159 }
160
getNetworkPacketStats()161 string NetworkMessage::getNetworkPacketStats() {
162 string result = "Current Timer Milliseconds: " + intToStr(NetworkMessage::statsTimer.getMillis()) + "\n";
163
164 for(std::map<NetworkMessageStatisticType,int64>::iterator iterMap = mapMessageStats.begin();
165 iterMap != mapMessageStats.end(); ++iterMap) {
166 switch(iterMap->first) {
167 case netmsgstPacketsPerMillisecondSend:
168 result += "send p / msec: " + intToStr(iterMap->second) + (iterMap->second > 10 ? " ****WARNING WIN32 LIMIT EXCEEDED****" : "") + "\n";
169 break;
170 case netmsgstPacketsPerSecondSend:
171 result += "send p / sec: " + intToStr(iterMap->second) + "\n";
172 break;
173 case netmsgstAverageSendSize:
174 result += "send avg size: " + intToStr(iterMap->second) + "\n";
175 break;
176
177 case netmsgstPacketsPerMillisecondRecv:
178 result += "recv p / msec: " + intToStr(iterMap->second) + "\n";
179 break;
180 case netmsgstPacketsPerSecondRecv:
181 result += "recv p / sec: " + intToStr(iterMap->second) + (iterMap->second > 10 ? " ****WARNING WIN32 LIMIT EXCEEDED****" : "") + "\n";
182 break;
183 case netmsgstAverageRecvSize:
184 result += "recv avg size: " + intToStr(iterMap->second) + "\n";
185 break;
186
187 }
188 }
189 return result;
190 }
191
dump_packet(string label,const void * data,int dataSize,bool isSend)192 void NetworkMessage::dump_packet(string label, const void* data, int dataSize, bool isSend) {
193 Config &config = Config::getInstance();
194 if( config.getBool("DebugNetworkPacketStats","false") == true) {
195
196 MutexSafeWrapper safeMutex(NetworkMessage::mutexMessageStats.get());
197
198 if(NetworkMessage::statsTimer.isStarted() == false) {
199 NetworkMessage::statsTimer.start();
200 }
201
202 bool secondChanged = false;
203 if(NetworkMessage::statsTimer.getSeconds() - NetworkMessage::mapMessageStats[netmsgstLastEvent] >= 3) {
204
205 NetworkMessage::mapMessageStats[netmsgstLastEvent] = NetworkMessage::statsTimer.getSeconds();
206 secondChanged = true;
207 }
208
209 if(isSend == true) {
210 if(NetworkMessage::lastSend.isStarted() == false) {
211 NetworkMessage::lastSend.start();
212 }
213 int64 millisecondsSinceLastSend = NetworkMessage::lastSend.getMillis();
214 int64 secondsSinceLastSend = NetworkMessage::lastSend.getSeconds();
215
216 //char szBuf[8096]="";
217 //snprintf(szBuf,8095,"\nSEND check cur [%lld] last [%lld]\n", (long long)millisecondsSinceLastSend,(long long)NetworkMessage::mapMessageStats[netmsgstPacketsPerMillisecondSend_last] );
218 //printf("%s",szBuf);
219
220 if(millisecondsSinceLastSend == NetworkMessage::mapMessageStats[netmsgstPacketsPerMillisecondSend_last]) {
221 NetworkMessage::mapMessageStats[netmsgstPacketsPerMillisecondSend_current_count]++;
222
223 }
224 else {
225 NetworkMessage::mapMessageStats[netmsgstPacketsPerMillisecondSend_last] = millisecondsSinceLastSend;
226 NetworkMessage::mapMessageStats[netmsgstPacketsPerMillisecondSend] =
227 (NetworkMessage::mapMessageStats[netmsgstPacketsPerMillisecondSend] +
228 NetworkMessage::mapMessageStats[netmsgstPacketsPerMillisecondSend_current_count]) / 2;
229 }
230
231 if(secondsSinceLastSend == NetworkMessage::mapMessageStats[netmsgstPacketsPerSecondSend_last]) {
232 NetworkMessage::mapMessageStats[netmsgstPacketsPerSecondSend_current_count]++;
233
234 }
235 else {
236 NetworkMessage::mapMessageStats[netmsgstPacketsPerSecondSend_last] = secondsSinceLastSend;
237 NetworkMessage::mapMessageStats[netmsgstPacketsPerSecondSend] =
238 (NetworkMessage::mapMessageStats[netmsgstPacketsPerSecondSend] +
239 NetworkMessage::mapMessageStats[netmsgstPacketsPerSecondSend_current_count]) / 2;
240 }
241
242 NetworkMessage::mapMessageStats[netmsgstAverageSendSize] =
243 (NetworkMessage::mapMessageStats[netmsgstAverageSendSize] +
244 dataSize) / 2;
245 }
246 else {
247 if(NetworkMessage::lastRecv.isStarted() == false) {
248 NetworkMessage::lastRecv.start();
249 }
250 int64 millisecondsSinceLastRecv = NetworkMessage::lastRecv.getMillis();
251 int64 secondsSinceLastRecv = NetworkMessage::lastRecv.getSeconds();
252
253 //char szBuf[8096]="";
254 //snprintf(szBuf,8095,"\nRECV check cur [%lld] last [%lld]\n", (long long)millisecondsSinceLastRecv,(long long)NetworkMessage::mapMessageStats[netmsgstPacketsPerMillisecondRecv_last] );
255 //printf("%s",szBuf);
256
257 if(millisecondsSinceLastRecv == NetworkMessage::mapMessageStats[netmsgstPacketsPerMillisecondRecv_last]) {
258 NetworkMessage::mapMessageStats[netmsgstPacketsPerMillisecondRecv_current_count]++;
259
260 }
261 else {
262 NetworkMessage::mapMessageStats[netmsgstPacketsPerMillisecondRecv_last] = millisecondsSinceLastRecv;
263 NetworkMessage::mapMessageStats[netmsgstPacketsPerMillisecondRecv] =
264 (NetworkMessage::mapMessageStats[netmsgstPacketsPerMillisecondRecv] +
265 NetworkMessage::mapMessageStats[netmsgstPacketsPerMillisecondRecv_current_count]) / 2;
266 }
267
268 if(secondsSinceLastRecv == NetworkMessage::mapMessageStats[netmsgstPacketsPerSecondRecv_last]) {
269 NetworkMessage::mapMessageStats[netmsgstPacketsPerSecondRecv_current_count]++;
270
271 }
272 else {
273 NetworkMessage::mapMessageStats[netmsgstPacketsPerSecondRecv_last] = secondsSinceLastRecv;
274 NetworkMessage::mapMessageStats[netmsgstPacketsPerSecondRecv] =
275 (NetworkMessage::mapMessageStats[netmsgstPacketsPerSecondRecv] +
276 NetworkMessage::mapMessageStats[netmsgstPacketsPerSecondRecv_current_count]) / 2;
277 }
278
279 NetworkMessage::mapMessageStats[netmsgstAverageRecvSize] =
280 (NetworkMessage::mapMessageStats[netmsgstAverageRecvSize] +
281 dataSize) / 2;
282 }
283
284 if(secondChanged == true) {
285 printf("%s",NetworkMessage::getNetworkPacketStats().c_str());
286 }
287 }
288
289 if( config.getBool("DebugNetworkPackets","false") == true ||
290 config.getBool("DebugNetworkPacketSizes","false") == true) {
291
292 printf("%s DataSize = %d",label.c_str(),dataSize);
293
294 if(config.getBool("DebugNetworkPackets","false") == true) {
295
296 printf("\n");
297 const char *buf = static_cast<const char *>(data);
298 for(unsigned int index = 0; index < (unsigned int)dataSize; ++index) {
299
300 printf("%u[%X][%d] ",index,buf[index],buf[index]);
301 if(index % 10 == 0) {
302 printf("\n");
303 }
304 }
305 }
306 printf("\n======= END =======\n");
307 }
308 }
309
310 // =====================================================
311 // class NetworkMessageIntro
312 // =====================================================
NetworkMessageIntro()313 NetworkMessageIntro::NetworkMessageIntro() {
314 messageType= -1;
315 data.sessionId= -1;
316 data.playerIndex= -1;
317 data.gameState = nmgstInvalid;
318 data.externalIp = 0;
319 data.ftpPort = 0;
320 data.gameInProgress = 0;
321 }
322
NetworkMessageIntro(int32 sessionId,const string & versionString,const string & name,int playerIndex,NetworkGameStateType gameState,uint32 externalIp,uint32 ftpPort,const string & playerLanguage,int gameInProgress,const string & playerUUID,const string & platform)323 NetworkMessageIntro::NetworkMessageIntro(int32 sessionId,const string &versionString,
324 const string &name, int playerIndex,
325 NetworkGameStateType gameState,
326 uint32 externalIp,
327 uint32 ftpPort,
328 const string &playerLanguage,
329 int gameInProgress, const string &playerUUID,
330 const string &platform) {
331 messageType = nmtIntro;
332 data.sessionId = sessionId;
333 data.versionString = versionString;
334 data.name = name;
335 data.playerIndex = static_cast<int16>(playerIndex);
336 data.gameState = static_cast<int8>(gameState);
337 data.externalIp = externalIp;
338 data.ftpPort = ftpPort;
339 data.language = playerLanguage;
340 data.gameInProgress = gameInProgress;
341 data.playerUUID = playerUUID;
342 data.platform = platform;
343 }
344
getPackedMessageFormat() const345 const char * NetworkMessageIntro::getPackedMessageFormat() const {
346 return "cl128s32shcLL60sc60s60s";
347 }
348
getPackedSize()349 unsigned int NetworkMessageIntro::getPackedSize() {
350 static unsigned int result = 0;
351 if(result == 0) {
352 Data packedData;
353 packedData.externalIp = 0;
354 packedData.ftpPort = 0;
355 packedData.gameInProgress = 0;
356 packedData.gameState = 0;
357 messageType = nmtIntro;
358 packedData.playerIndex = 0;
359 packedData.sessionId = 0;
360
361 unsigned char *buf = new unsigned char[sizeof(packedData)*3];
362 result = pack(buf, getPackedMessageFormat(),
363 messageType,
364 packedData.sessionId,
365 packedData.versionString.getBuffer(),
366 packedData.name.getBuffer(),
367 packedData.playerIndex,
368 packedData.gameState,
369 packedData.externalIp,
370 packedData.ftpPort,
371 packedData.language.getBuffer(),
372 data.gameInProgress,
373 packedData.playerUUID.getBuffer(),
374 packedData.platform.getBuffer());
375 delete [] buf;
376 }
377 return result;
378 }
unpackMessage(unsigned char * buf)379 void NetworkMessageIntro::unpackMessage(unsigned char *buf) {
380 if(SystemFlags::VERBOSE_MODE_ENABLED) printf("\nIn [%s] about to unpack...\n",__FUNCTION__);
381 unpack(buf, getPackedMessageFormat(),
382 &messageType,
383 &data.sessionId,
384 data.versionString.getBuffer(),
385 data.name.getBuffer(),
386 &data.playerIndex,
387 &data.gameState,
388 &data.externalIp,
389 &data.ftpPort,
390 data.language.getBuffer(),
391 &data.gameInProgress,
392 data.playerUUID.getBuffer(),
393 data.platform.getBuffer());
394 if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s] unpacked data:\n%s\n",__FUNCTION__,this->toString().c_str());
395 }
396
packMessage()397 unsigned char * NetworkMessageIntro::packMessage() {
398 unsigned char *buf = new unsigned char[getPackedSize()+1];
399
400 if(SystemFlags::VERBOSE_MODE_ENABLED) printf("\nIn [%s] about to pack...\n",__FUNCTION__);
401 pack(buf, getPackedMessageFormat(),
402 messageType,
403 data.sessionId,
404 data.versionString.getBuffer(),
405 data.name.getBuffer(),
406 data.playerIndex,
407 data.gameState,
408 data.externalIp,
409 data.ftpPort,
410 data.language.getBuffer(),
411 data.gameInProgress,
412 data.playerUUID.getBuffer(),
413 data.platform.getBuffer());
414 return buf;
415 }
416
toString() const417 string NetworkMessageIntro::toString() const {
418 string result = "messageType = " + intToStr(messageType);
419 result += " sessionId = " + intToStr(data.sessionId);
420 result += " versionString = " + data.versionString.getString();
421 result += " name = " + data.name.getString();
422 result += " playerIndex = " + intToStr(data.playerIndex);
423 result += " gameState = " + intToStr(data.gameState);
424 result += " externalIp = " + uIntToStr(data.externalIp);
425 result += " ftpPort = " + uIntToStr(data.ftpPort);
426 result += " language = " + data.language.getString();
427 result += " gameInProgress = " + uIntToStr(data.gameInProgress);
428 result += " playerUUID = " + data.playerUUID.getString();
429 result += " platform = " + data.platform.getString();
430
431 return result;
432 }
433
receive(Socket * socket)434 bool NetworkMessageIntro::receive(Socket* socket) {
435 bool result = false;
436 if(useOldProtocol == true) {
437 result = NetworkMessage::receive(socket, &data, sizeof(data), true);
438 if(result == true) {
439 messageType = this->getNetworkMessageType();
440 }
441 }
442 else {
443 unsigned char *buf = new unsigned char[getPackedSize()+1];
444 result = NetworkMessage::receive(socket, buf, getPackedSize(), true);
445 unpackMessage(buf);
446 //printf("Got packet size = %u data.messageType = %d\n%s\n",getPackedSize(),data.messageType,buf);
447 delete [] buf;
448 }
449 fromEndian();
450
451 data.name.nullTerminate();
452 data.versionString.nullTerminate();
453 data.language.nullTerminate();
454 data.playerUUID.nullTerminate();
455 data.platform.nullTerminate();
456
457 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] get nmtIntro, data.playerIndex = %d, data.sessionId = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,data.playerIndex,data.sessionId);
458 return result;
459 }
460
send(Socket * socket)461 void NetworkMessageIntro::send(Socket* socket) {
462 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] sending nmtIntro, data.playerIndex = %d, data.sessionId = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,data.playerIndex,data.sessionId);
463 assert(messageType == nmtIntro);
464 toEndian();
465
466 if(useOldProtocol == true) {
467 //NetworkMessage::send(socket, &messageType, sizeof(messageType));
468 NetworkMessage::send(socket, &data, sizeof(data),messageType);
469 }
470 else {
471 unsigned char *buf = packMessage();
472 //printf("Send packet size = %u data.messageType = %d\n[%s]\n",getPackedSize(),data.messageType,buf);
473 //NetworkMessage::send(socket, &data, sizeof(data));
474 NetworkMessage::send(socket, buf, getPackedSize());
475 delete [] buf;
476 }
477 }
478
toEndian()479 void NetworkMessageIntro::toEndian() {
480 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
481 if(bigEndianSystem == true) {
482 messageType = Shared::PlatformByteOrder::toCommonEndian(messageType);
483 data.sessionId = Shared::PlatformByteOrder::toCommonEndian(data.sessionId);
484 data.playerIndex = Shared::PlatformByteOrder::toCommonEndian(data.playerIndex);
485 data.gameState = Shared::PlatformByteOrder::toCommonEndian(data.gameState);
486 data.externalIp = Shared::PlatformByteOrder::toCommonEndian(data.externalIp);
487 data.ftpPort = Shared::PlatformByteOrder::toCommonEndian(data.ftpPort);
488
489 data.gameInProgress = Shared::PlatformByteOrder::toCommonEndian(data.gameInProgress);
490 }
491 }
fromEndian()492 void NetworkMessageIntro::fromEndian() {
493 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
494 if(bigEndianSystem == true) {
495 messageType = Shared::PlatformByteOrder::fromCommonEndian(messageType);
496 data.sessionId = Shared::PlatformByteOrder::fromCommonEndian(data.sessionId);
497 data.playerIndex = Shared::PlatformByteOrder::fromCommonEndian(data.playerIndex);
498 data.gameState = Shared::PlatformByteOrder::fromCommonEndian(data.gameState);
499 data.externalIp = Shared::PlatformByteOrder::fromCommonEndian(data.externalIp);
500 data.ftpPort = Shared::PlatformByteOrder::fromCommonEndian(data.ftpPort);
501
502 data.gameInProgress = Shared::PlatformByteOrder::fromCommonEndian(data.gameInProgress);
503 }
504 }
505
506 // =====================================================
507 // class NetworkMessagePing
508 // =====================================================
509
NetworkMessagePing()510 NetworkMessagePing::NetworkMessagePing(){
511 messageType = nmtPing;
512 data.pingFrequency = 0;
513 data.pingTime = 0;
514 pingReceivedLocalTime = 0;
515 }
516
NetworkMessagePing(int32 pingFrequency,int64 pingTime)517 NetworkMessagePing::NetworkMessagePing(int32 pingFrequency, int64 pingTime){
518 messageType= nmtPing;
519 data.pingFrequency= pingFrequency;
520 data.pingTime= pingTime;
521 pingReceivedLocalTime=0;
522 }
523
getPackedMessageFormat() const524 const char * NetworkMessagePing::getPackedMessageFormat() const {
525 return "clq";
526 }
527
getPackedSize()528 unsigned int NetworkMessagePing::getPackedSize() {
529 static unsigned int result = 0;
530 if(result == 0) {
531 Data packedData;
532 messageType = 0;
533 packedData.pingFrequency = 0;
534 packedData.pingTime = 0;
535 unsigned char *buf = new unsigned char[sizeof(packedData)*3];
536 result = pack(buf, getPackedMessageFormat(),
537 messageType,
538 packedData.pingFrequency,
539 packedData.pingTime);
540 delete [] buf;
541 }
542 return result;
543 }
unpackMessage(unsigned char * buf)544 void NetworkMessagePing::unpackMessage(unsigned char *buf) {
545 unpack(buf, getPackedMessageFormat(),
546 &messageType,
547 &data.pingFrequency,
548 &data.pingTime);
549 }
550
packMessage()551 unsigned char * NetworkMessagePing::packMessage() {
552 unsigned char *buf = new unsigned char[getPackedSize()+1];
553 pack(buf, getPackedMessageFormat(),
554 messageType,
555 data.pingFrequency,
556 data.pingTime);
557 return buf;
558 }
559
receive(Socket * socket)560 bool NetworkMessagePing::receive(Socket* socket){
561 bool result = false;
562 if(useOldProtocol == true) {
563 result = NetworkMessage::receive(socket, &data, sizeof(data), true);
564 if(result == true) {
565 messageType = this->getNetworkMessageType();
566 }
567 }
568 else {
569 unsigned char *buf = new unsigned char[getPackedSize()+1];
570 result = NetworkMessage::receive(socket, buf, getPackedSize(), true);
571 unpackMessage(buf);
572 //printf("Got packet size = %u data.messageType = %d\n%s\n",getPackedSize(),data.messageType,buf);
573 delete [] buf;
574 }
575 fromEndian();
576
577 pingReceivedLocalTime = time(NULL);
578 return result;
579 }
580
send(Socket * socket)581 void NetworkMessagePing::send(Socket* socket) {
582 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtPing\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
583 assert(messageType == nmtPing);
584 toEndian();
585
586 if(useOldProtocol == true) {
587 //NetworkMessage::send(socket, &messageType, sizeof(messageType));
588 NetworkMessage::send(socket, &data, sizeof(data), messageType);
589 }
590 else {
591 unsigned char *buf = packMessage();
592 //printf("Send packet size = %u data.messageType = %d\n[%s]\n",getPackedSize(),data.messageType,buf);
593 //NetworkMessage::send(socket, &data, sizeof(data));
594 NetworkMessage::send(socket, buf, getPackedSize());
595 delete [] buf;
596 }
597 }
598
toEndian()599 void NetworkMessagePing::toEndian() {
600 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
601 if(bigEndianSystem == true) {
602 messageType = Shared::PlatformByteOrder::toCommonEndian(messageType);
603 data.pingFrequency = Shared::PlatformByteOrder::toCommonEndian(data.pingFrequency);
604 data.pingTime = Shared::PlatformByteOrder::toCommonEndian(data.pingTime);
605 }
606 }
fromEndian()607 void NetworkMessagePing::fromEndian() {
608 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
609 if(bigEndianSystem == true) {
610 messageType = Shared::PlatformByteOrder::fromCommonEndian(messageType);
611 data.pingFrequency = Shared::PlatformByteOrder::fromCommonEndian(data.pingFrequency);
612 data.pingTime = Shared::PlatformByteOrder::fromCommonEndian(data.pingTime);
613 }
614 }
615
616 // =====================================================
617 // class NetworkMessageReady
618 // =====================================================
619
NetworkMessageReady()620 NetworkMessageReady::NetworkMessageReady() {
621 messageType = nmtReady;
622 data.checksum= 0;
623 }
624
NetworkMessageReady(uint32 checksum)625 NetworkMessageReady::NetworkMessageReady(uint32 checksum) {
626 messageType = nmtReady;
627 data.checksum= checksum;
628 }
629
getPackedMessageFormat() const630 const char * NetworkMessageReady::getPackedMessageFormat() const {
631 return "cL";
632 }
633
getPackedSize()634 unsigned int NetworkMessageReady::getPackedSize() {
635 static unsigned int result = 0;
636 if(result == 0) {
637 Data packedData;
638 packedData.checksum = 0;
639 messageType = 0;
640 unsigned char *buf = new unsigned char[sizeof(packedData)*3];
641 result = pack(buf, getPackedMessageFormat(),
642 messageType,
643 packedData.checksum);
644 delete [] buf;
645 }
646 return result;
647 }
unpackMessage(unsigned char * buf)648 void NetworkMessageReady::unpackMessage(unsigned char *buf) {
649 unpack(buf, getPackedMessageFormat(),
650 &messageType,
651 &data.checksum);
652 }
653
packMessage()654 unsigned char * NetworkMessageReady::packMessage() {
655 unsigned char *buf = new unsigned char[getPackedSize()+1];
656 pack(buf, getPackedMessageFormat(),
657 messageType,
658 data.checksum);
659 return buf;
660 }
661
receive(Socket * socket)662 bool NetworkMessageReady::receive(Socket* socket){
663 bool result = false;
664 if(useOldProtocol == true) {
665 result = NetworkMessage::receive(socket, &data, sizeof(data), true);
666 if(result == true) {
667 messageType = this->getNetworkMessageType();
668 }
669 }
670 else {
671 unsigned char *buf = new unsigned char[getPackedSize()+1];
672 //bool result = NetworkMessage::receive(socket, buf, getPackedSize(), true);
673 NetworkMessage::receive(socket, buf, getPackedSize(), true);
674 unpackMessage(buf);
675 //printf("Got packet size = %u data.messageType = %d\n%s\n",getPackedSize(),data.messageType,buf);
676 delete [] buf;
677 }
678 fromEndian();
679 return result;
680 }
681
send(Socket * socket)682 void NetworkMessageReady::send(Socket* socket) {
683 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtReady\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
684 assert(messageType == nmtReady);
685 toEndian();
686
687 if(useOldProtocol == true) {
688 //NetworkMessage::send(socket, &messageType, sizeof(messageType));
689 NetworkMessage::send(socket, &data, sizeof(data), messageType);
690 }
691 else {
692 unsigned char *buf = packMessage();
693 //printf("Send packet size = %u data.messageType = %d\n[%s]\n",getPackedSize(),data.messageType,buf);
694 NetworkMessage::send(socket, buf, getPackedSize());
695 delete [] buf;
696 }
697 }
698
toEndian()699 void NetworkMessageReady::toEndian() {
700 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
701 if(bigEndianSystem == true) {
702 messageType = Shared::PlatformByteOrder::toCommonEndian(messageType);
703 data.checksum = Shared::PlatformByteOrder::toCommonEndian(data.checksum);
704 }
705 }
fromEndian()706 void NetworkMessageReady::fromEndian() {
707 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
708 if(bigEndianSystem == true) {
709 messageType = Shared::PlatformByteOrder::fromCommonEndian(messageType);
710 data.checksum = Shared::PlatformByteOrder::fromCommonEndian(data.checksum);
711 }
712 }
713
714 // =====================================================
715 // class NetworkMessageLaunch
716 // =====================================================
717
NetworkMessageLaunch()718 NetworkMessageLaunch::NetworkMessageLaunch() {
719 messageType = -1;
720 compressedLength = 0;
721 for(unsigned int i = 0; i < (unsigned int)maxFactionCRCCount; ++i) {
722 data.factionNameList[i] = "";
723 data.factionCRCList[i] = 0;
724 }
725 data.aiAcceptSwitchTeamPercentChance = 0;
726 data.cpuReplacementMultiplier = 10 ;
727 data.masterserver_admin = -1;
728 data.masterserver_admin_factionIndex = -1;
729 }
730
NetworkMessageLaunch(const GameSettings * gameSettings,int8 messageType)731 NetworkMessageLaunch::NetworkMessageLaunch(const GameSettings *gameSettings,int8 messageType) {
732 this->messageType = messageType;
733 compressedLength = 0;
734
735 data.mapFilter = gameSettings->getMapFilter();
736 data.mapCRC = gameSettings->getMapCRC();
737 data.tilesetCRC = gameSettings->getTilesetCRC();
738 data.techCRC = gameSettings->getTechCRC();
739
740 for(unsigned int i = 0; i < (unsigned int)maxFactionCRCCount; ++i) {
741 data.factionNameList[i] = "";
742 data.factionCRCList[i] = 0;
743 }
744
745 vector<pair<string,uint32> > factionCRCList = gameSettings->getFactionCRCList();
746 for(unsigned int i = 0; i < factionCRCList.size() && i < (unsigned int)maxFactionCRCCount; ++i) {
747 data.factionNameList[i] = factionCRCList[i].first;
748 data.factionCRCList[i] = factionCRCList[i].second;
749 }
750
751 data.description= gameSettings->getDescription();
752 data.map= gameSettings->getMap();
753 data.tileset= gameSettings->getTileset();
754 data.tech= gameSettings->getTech();
755 data.factionCount= gameSettings->getFactionCount();
756 data.thisFactionIndex= gameSettings->getThisFactionIndex();
757 data.defaultResources= gameSettings->getDefaultResources();
758 data.defaultUnits= gameSettings->getDefaultUnits();
759 data.defaultVictoryConditions= gameSettings->getDefaultVictoryConditions();
760 data.fogOfWar = gameSettings->getFogOfWar();
761 data.allowObservers = gameSettings->getAllowObservers();
762 data.enableObserverModeAtEndGame = gameSettings->getEnableObserverModeAtEndGame();
763 data.enableServerControlledAI = gameSettings->getEnableServerControlledAI();
764 data.networkFramePeriod = gameSettings->getNetworkFramePeriod();
765 data.networkPauseGameForLaggedClients = gameSettings->getNetworkPauseGameForLaggedClients();
766 data.pathFinderType = gameSettings->getPathFinderType();
767 data.flagTypes1 = gameSettings->getFlagTypes1();
768
769 //for(int i= 0; i < data.factionCount; ++i) {
770 for(int i= 0; i < GameConstants::maxPlayers; ++i) {
771 data.factionTypeNames[i]= gameSettings->getFactionTypeName(i);
772 data.networkPlayerNames[i]= gameSettings->getNetworkPlayerName(i);
773 data.networkPlayerPlatform[i]= gameSettings->getNetworkPlayerPlatform(i);
774 data.networkPlayerStatuses[i] = gameSettings->getNetworkPlayerStatuses(i);
775 data.networkPlayerLanguages[i] = gameSettings->getNetworkPlayerLanguages(i);
776 data.factionControls[i]= gameSettings->getFactionControl(i);
777 data.resourceMultiplierIndex[i]= gameSettings->getResourceMultiplierIndex(i);
778 data.teams[i]= gameSettings->getTeam(i);
779 data.startLocationIndex[i]= gameSettings->getStartLocationIndex(i);
780
781 data.networkPlayerUUID[i] = gameSettings->getNetworkPlayerUUID(i);
782 //printf("Build netmsg for index: %d [%s]\n",i,data.networkPlayerUUID[i].getString().c_str());
783 }
784 data.cpuReplacementMultiplier = gameSettings->getFallbackCpuMultiplier();
785 data.aiAcceptSwitchTeamPercentChance = gameSettings->getAiAcceptSwitchTeamPercentChance();
786 data.masterserver_admin = gameSettings->getMasterserver_admin();
787 data.masterserver_admin_factionIndex = gameSettings->getMasterserver_admin_faction_index();
788
789 data.scenario = gameSettings->getScenario();
790 data.gameUUID = gameSettings->getGameUUID();
791
792 data.networkAllowNativeLanguageTechtree = gameSettings->getNetworkAllowNativeLanguageTechtree();
793 }
794
buildGameSettings(GameSettings * gameSettings) const795 void NetworkMessageLaunch::buildGameSettings(GameSettings *gameSettings) const {
796 gameSettings->setDescription(data.description.getString());
797 gameSettings->setMap(data.map.getString());
798 gameSettings->setTileset(data.tileset.getString());
799 gameSettings->setTech(data.tech.getString());
800 gameSettings->setFactionCount(data.factionCount);
801 gameSettings->setThisFactionIndex(data.thisFactionIndex);
802 gameSettings->setDefaultResources((data.defaultResources != 0));
803 gameSettings->setDefaultUnits((data.defaultUnits != 0));
804 gameSettings->setDefaultVictoryConditions((data.defaultVictoryConditions != 0));
805 gameSettings->setFogOfWar((data.fogOfWar != 0));
806 gameSettings->setAllowObservers((data.allowObservers != 0));
807
808 gameSettings->setEnableObserverModeAtEndGame((data.enableObserverModeAtEndGame != 0));
809 gameSettings->setEnableServerControlledAI((data.enableServerControlledAI != 0));
810 gameSettings->setNetworkFramePeriod(data.networkFramePeriod);
811 gameSettings->setNetworkPauseGameForLaggedClients((data.networkPauseGameForLaggedClients != 0));
812 gameSettings->setPathFinderType(static_cast<PathFinderType>(data.pathFinderType));
813 gameSettings->setFlagTypes1(data.flagTypes1);
814
815 gameSettings->setMapCRC(data.mapCRC);
816 gameSettings->setMapFilter(data.mapFilter);
817 gameSettings->setTilesetCRC(data.tilesetCRC);
818 gameSettings->setTechCRC(data.techCRC);
819
820 vector<pair<string,uint32> > factionCRCList;
821 for(unsigned int i = 0; i < (unsigned int)maxFactionCRCCount; ++i) {
822 if(data.factionNameList[i].getString() != "") {
823 factionCRCList.push_back(make_pair(data.factionNameList[i].getString(),data.factionCRCList[i]));
824 }
825 }
826 gameSettings->setFactionCRCList(factionCRCList);
827
828 //for(int i= 0; i < data.factionCount; ++i) {
829 for(int i= 0; i < GameConstants::maxPlayers; ++i) {
830 gameSettings->setFactionTypeName(i, data.factionTypeNames[i].getString());
831 gameSettings->setNetworkPlayerName(i,data.networkPlayerNames[i].getString());
832 gameSettings->setNetworkPlayerPlatform(i,data.networkPlayerPlatform[i].getString());
833 gameSettings->setNetworkPlayerStatuses(i, data.networkPlayerStatuses[i]);
834 gameSettings->setNetworkPlayerLanguages(i, data.networkPlayerLanguages[i].getString());
835 gameSettings->setFactionControl(i, static_cast<ControlType>(data.factionControls[i]));
836 gameSettings->setResourceMultiplierIndex(i,data.resourceMultiplierIndex[i]);
837 gameSettings->setTeam(i, data.teams[i]);
838 gameSettings->setStartLocationIndex(i, data.startLocationIndex[i]);
839
840 gameSettings->setNetworkPlayerUUID(i,data.networkPlayerUUID[i].getString());
841 gameSettings->setNetworkPlayerPlatform(i,data.networkPlayerPlatform[i].getString());
842 //printf("Build game settings for index: %d [%s]\n",i,data.networkPlayerUUID[i].getString().c_str());
843 }
844
845 gameSettings->setAiAcceptSwitchTeamPercentChance(data.aiAcceptSwitchTeamPercentChance);
846 gameSettings->setFallbackCpuMultiplier(data.cpuReplacementMultiplier);
847
848 gameSettings->setMasterserver_admin(data.masterserver_admin);
849 gameSettings->setMasterserver_admin_faction_index(data.masterserver_admin_factionIndex);
850
851 gameSettings->setScenario(data.scenario.getString());
852
853 gameSettings->setGameUUID(data.gameUUID.getString());
854
855 gameSettings->setNetworkAllowNativeLanguageTechtree((data.networkAllowNativeLanguageTechtree != 0));
856 }
857
getFactionCRCList() const858 vector<pair<string,uint32> > NetworkMessageLaunch::getFactionCRCList() const {
859
860 vector<pair<string,uint32> > factionCRCList;
861 for(unsigned int i = 0; i < (unsigned int)maxFactionCRCCount; ++i) {
862 if(data.factionNameList[i].getString() != "") {
863 factionCRCList.push_back(make_pair(data.factionNameList[i].getString(),data.factionCRCList[i]));
864 }
865 }
866 return factionCRCList;
867 }
868
getPackedMessageFormat() const869 const char * NetworkMessageLaunch::getPackedMessageFormat() const {
870 return "c256s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60sllllllll60s60s60s60s60s60s60s60sLLL60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60s60sLLLLLLLLLLLLLLLLLLLLcccccccccccccccccccccccccccccccccccccccccCccLccll256s60s60s60s60s60s60s60s60sc60s";
871 }
872
getPackedSize()873 unsigned int NetworkMessageLaunch::getPackedSize() {
874 static unsigned int result = 0;
875 if(result == 0) {
876 Data packedData;
877 packedData.aiAcceptSwitchTeamPercentChance = 0;
878 packedData.allowObservers = 0;
879 packedData.cpuReplacementMultiplier = 0;
880 packedData.defaultResources = 0;
881 packedData.defaultUnits = 0;
882 packedData.defaultVictoryConditions = 0;
883 packedData.enableObserverModeAtEndGame = 0;
884 packedData.enableServerControlledAI = 0;
885 for(unsigned int index =0; index < (unsigned int)maxFactionCRCCount; ++index) {
886 packedData.factionCRCList[index] = 0;
887 }
888 for(unsigned int index =0; index < (unsigned int)GameConstants::maxPlayers; ++index) {
889 packedData.factionControls[index] = 0;
890 packedData.networkPlayerStatuses[index] = 0;
891 packedData.resourceMultiplierIndex[index] = 0;
892 packedData.startLocationIndex[index] = 0;
893 packedData.teams[index] = 0;
894 }
895 packedData.factionCount = 0;
896 packedData.flagTypes1 = 0;
897 packedData.fogOfWar = 0;
898 packedData.mapCRC = 0;
899 packedData.mapFilter = 0;
900 packedData.masterserver_admin = 0;
901 packedData.masterserver_admin_factionIndex = 0;
902 messageType = 0;
903 packedData.networkAllowNativeLanguageTechtree = 0;
904 packedData.networkFramePeriod = 0;
905 packedData.networkPauseGameForLaggedClients = 0;
906 packedData.pathFinderType = 0;
907 packedData.techCRC = 0;
908 packedData.thisFactionIndex = 0;
909 packedData.tilesetCRC = 0;
910
911 unsigned char *buf = new unsigned char[sizeof(packedData)*3];
912 result = pack(buf, getPackedMessageFormat(),
913 messageType,
914 packedData.description.getBuffer(),
915 packedData.map.getBuffer(),
916 packedData.tileset.getBuffer(),
917 packedData.tech.getBuffer(),
918 packedData.factionTypeNames[0].getBuffer(),
919 packedData.factionTypeNames[1].getBuffer(),
920 packedData.factionTypeNames[2].getBuffer(),
921 packedData.factionTypeNames[3].getBuffer(),
922 packedData.factionTypeNames[4].getBuffer(),
923 packedData.factionTypeNames[5].getBuffer(),
924 packedData.factionTypeNames[6].getBuffer(),
925 packedData.factionTypeNames[7].getBuffer(),
926 packedData.networkPlayerNames[0].getBuffer(),
927 packedData.networkPlayerNames[1].getBuffer(),
928 packedData.networkPlayerNames[2].getBuffer(),
929 packedData.networkPlayerNames[3].getBuffer(),
930 packedData.networkPlayerNames[4].getBuffer(),
931 packedData.networkPlayerNames[5].getBuffer(),
932 packedData.networkPlayerNames[6].getBuffer(),
933 packedData.networkPlayerNames[7].getBuffer(),
934 packedData.networkPlayerPlatform[0].getBuffer(),
935 packedData.networkPlayerPlatform[1].getBuffer(),
936 packedData.networkPlayerPlatform[2].getBuffer(),
937 packedData.networkPlayerPlatform[3].getBuffer(),
938 packedData.networkPlayerPlatform[4].getBuffer(),
939 packedData.networkPlayerPlatform[5].getBuffer(),
940 packedData.networkPlayerPlatform[6].getBuffer(),
941 packedData.networkPlayerPlatform[7].getBuffer(),
942 packedData.networkPlayerStatuses[0],
943 packedData.networkPlayerStatuses[1],
944 packedData.networkPlayerStatuses[2],
945 packedData.networkPlayerStatuses[3],
946 packedData.networkPlayerStatuses[4],
947 packedData.networkPlayerStatuses[5],
948 packedData.networkPlayerStatuses[6],
949 packedData.networkPlayerStatuses[7],
950 packedData.networkPlayerLanguages[0].getBuffer(),
951 packedData.networkPlayerLanguages[1].getBuffer(),
952 packedData.networkPlayerLanguages[2].getBuffer(),
953 packedData.networkPlayerLanguages[3].getBuffer(),
954 packedData.networkPlayerLanguages[4].getBuffer(),
955 packedData.networkPlayerLanguages[5].getBuffer(),
956 packedData.networkPlayerLanguages[6].getBuffer(),
957 packedData.networkPlayerLanguages[7].getBuffer(),
958 packedData.mapCRC,
959 packedData.mapFilter,
960 packedData.tilesetCRC,
961 packedData.techCRC,
962 packedData.factionNameList[0].getBuffer(),
963 packedData.factionNameList[1].getBuffer(),
964 packedData.factionNameList[2].getBuffer(),
965 packedData.factionNameList[3].getBuffer(),
966 packedData.factionNameList[4].getBuffer(),
967 packedData.factionNameList[5].getBuffer(),
968 packedData.factionNameList[6].getBuffer(),
969 packedData.factionNameList[7].getBuffer(),
970 packedData.factionNameList[8].getBuffer(),
971 packedData.factionNameList[9].getBuffer(),
972 packedData.factionNameList[10].getBuffer(),
973 packedData.factionNameList[11].getBuffer(),
974 packedData.factionNameList[12].getBuffer(),
975 packedData.factionNameList[13].getBuffer(),
976 packedData.factionNameList[14].getBuffer(),
977 packedData.factionNameList[15].getBuffer(),
978 packedData.factionNameList[16].getBuffer(),
979 packedData.factionNameList[17].getBuffer(),
980 packedData.factionNameList[18].getBuffer(),
981 packedData.factionNameList[19].getBuffer(),
982 packedData.factionCRCList[0],
983 packedData.factionCRCList[1],
984 packedData.factionCRCList[2],
985 packedData.factionCRCList[3],
986 packedData.factionCRCList[4],
987 packedData.factionCRCList[5],
988 packedData.factionCRCList[6],
989 packedData.factionCRCList[7],
990 packedData.factionCRCList[8],
991 packedData.factionCRCList[9],
992 packedData.factionCRCList[10],
993 packedData.factionCRCList[11],
994 packedData.factionCRCList[12],
995 packedData.factionCRCList[13],
996 packedData.factionCRCList[14],
997 packedData.factionCRCList[15],
998 packedData.factionCRCList[16],
999 packedData.factionCRCList[17],
1000 packedData.factionCRCList[18],
1001 packedData.factionCRCList[19],
1002 packedData.factionControls[0],
1003 packedData.factionControls[1],
1004 packedData.factionControls[2],
1005 packedData.factionControls[3],
1006 packedData.factionControls[4],
1007 packedData.factionControls[5],
1008 packedData.factionControls[6],
1009 packedData.factionControls[7],
1010 packedData.resourceMultiplierIndex[0],
1011 packedData.resourceMultiplierIndex[1],
1012 packedData.resourceMultiplierIndex[2],
1013 packedData.resourceMultiplierIndex[3],
1014 packedData.resourceMultiplierIndex[4],
1015 packedData.resourceMultiplierIndex[5],
1016 packedData.resourceMultiplierIndex[6],
1017 packedData.resourceMultiplierIndex[7],
1018 packedData.thisFactionIndex,
1019 packedData.factionCount,
1020 packedData.teams[0],
1021 packedData.teams[1],
1022 packedData.teams[2],
1023 packedData.teams[3],
1024 packedData.teams[4],
1025 packedData.teams[5],
1026 packedData.teams[6],
1027 packedData.teams[7],
1028 packedData.startLocationIndex[0],
1029 packedData.startLocationIndex[1],
1030 packedData.startLocationIndex[2],
1031 packedData.startLocationIndex[3],
1032 packedData.startLocationIndex[4],
1033 packedData.startLocationIndex[5],
1034 packedData.startLocationIndex[6],
1035 packedData.startLocationIndex[7],
1036 packedData.defaultResources,
1037 packedData.defaultUnits,
1038 packedData.defaultVictoryConditions,
1039 packedData.fogOfWar,
1040 packedData.allowObservers,
1041 packedData.enableObserverModeAtEndGame,
1042 packedData.enableServerControlledAI,
1043 packedData.networkFramePeriod,
1044 packedData.networkPauseGameForLaggedClients,
1045 packedData.pathFinderType,
1046 packedData.flagTypes1,
1047 packedData.aiAcceptSwitchTeamPercentChance,
1048 packedData.cpuReplacementMultiplier,
1049 packedData.masterserver_admin,
1050 packedData.masterserver_admin_factionIndex,
1051 packedData.scenario.getBuffer(),
1052 packedData.networkPlayerUUID[0].getBuffer(),
1053 packedData.networkPlayerUUID[1].getBuffer(),
1054 packedData.networkPlayerUUID[2].getBuffer(),
1055 packedData.networkPlayerUUID[3].getBuffer(),
1056 packedData.networkPlayerUUID[4].getBuffer(),
1057 packedData.networkPlayerUUID[5].getBuffer(),
1058 packedData.networkPlayerUUID[6].getBuffer(),
1059 packedData.networkPlayerUUID[7].getBuffer(),
1060 packedData.networkAllowNativeLanguageTechtree,
1061 packedData.gameUUID.getBuffer()
1062 );
1063 delete [] buf;
1064 }
1065 return result;
1066 }
unpackMessage(unsigned char * buf)1067 void NetworkMessageLaunch::unpackMessage(unsigned char *buf) {
1068 unpack(buf, getPackedMessageFormat(),
1069 &messageType,
1070 data.description.getBuffer(),
1071 data.map.getBuffer(),
1072 data.tileset.getBuffer(),
1073 data.tech.getBuffer(),
1074 data.factionTypeNames[0].getBuffer(),
1075 data.factionTypeNames[1].getBuffer(),
1076 data.factionTypeNames[2].getBuffer(),
1077 data.factionTypeNames[3].getBuffer(),
1078 data.factionTypeNames[4].getBuffer(),
1079 data.factionTypeNames[5].getBuffer(),
1080 data.factionTypeNames[6].getBuffer(),
1081 data.factionTypeNames[7].getBuffer(),
1082 data.networkPlayerNames[0].getBuffer(),
1083 data.networkPlayerNames[1].getBuffer(),
1084 data.networkPlayerNames[2].getBuffer(),
1085 data.networkPlayerNames[3].getBuffer(),
1086 data.networkPlayerNames[4].getBuffer(),
1087 data.networkPlayerNames[5].getBuffer(),
1088 data.networkPlayerNames[6].getBuffer(),
1089 data.networkPlayerNames[7].getBuffer(),
1090 data.networkPlayerPlatform[0].getBuffer(),
1091 data.networkPlayerPlatform[1].getBuffer(),
1092 data.networkPlayerPlatform[2].getBuffer(),
1093 data.networkPlayerPlatform[3].getBuffer(),
1094 data.networkPlayerPlatform[4].getBuffer(),
1095 data.networkPlayerPlatform[5].getBuffer(),
1096 data.networkPlayerPlatform[6].getBuffer(),
1097 data.networkPlayerPlatform[7].getBuffer(),
1098 &data.networkPlayerStatuses[0],
1099 &data.networkPlayerStatuses[1],
1100 &data.networkPlayerStatuses[2],
1101 &data.networkPlayerStatuses[3],
1102 &data.networkPlayerStatuses[4],
1103 &data.networkPlayerStatuses[5],
1104 &data.networkPlayerStatuses[6],
1105 &data.networkPlayerStatuses[7],
1106 data.networkPlayerLanguages[0].getBuffer(),
1107 data.networkPlayerLanguages[1].getBuffer(),
1108 data.networkPlayerLanguages[2].getBuffer(),
1109 data.networkPlayerLanguages[3].getBuffer(),
1110 data.networkPlayerLanguages[4].getBuffer(),
1111 data.networkPlayerLanguages[5].getBuffer(),
1112 data.networkPlayerLanguages[6].getBuffer(),
1113 data.networkPlayerLanguages[7].getBuffer(),
1114 &data.mapFilter,
1115 &data.mapCRC,
1116 &data.tilesetCRC,
1117 &data.techCRC,
1118 data.factionNameList[0].getBuffer(),
1119 data.factionNameList[1].getBuffer(),
1120 data.factionNameList[2].getBuffer(),
1121 data.factionNameList[3].getBuffer(),
1122 data.factionNameList[4].getBuffer(),
1123 data.factionNameList[5].getBuffer(),
1124 data.factionNameList[6].getBuffer(),
1125 data.factionNameList[7].getBuffer(),
1126 data.factionNameList[8].getBuffer(),
1127 data.factionNameList[9].getBuffer(),
1128 data.factionNameList[10].getBuffer(),
1129 data.factionNameList[11].getBuffer(),
1130 data.factionNameList[12].getBuffer(),
1131 data.factionNameList[13].getBuffer(),
1132 data.factionNameList[14].getBuffer(),
1133 data.factionNameList[15].getBuffer(),
1134 data.factionNameList[16].getBuffer(),
1135 data.factionNameList[17].getBuffer(),
1136 data.factionNameList[18].getBuffer(),
1137 data.factionNameList[19].getBuffer(),
1138 &data.factionCRCList[0],
1139 &data.factionCRCList[1],
1140 &data.factionCRCList[2],
1141 &data.factionCRCList[3],
1142 &data.factionCRCList[4],
1143 &data.factionCRCList[5],
1144 &data.factionCRCList[6],
1145 &data.factionCRCList[7],
1146 &data.factionCRCList[8],
1147 &data.factionCRCList[9],
1148 &data.factionCRCList[10],
1149 &data.factionCRCList[11],
1150 &data.factionCRCList[12],
1151 &data.factionCRCList[13],
1152 &data.factionCRCList[14],
1153 &data.factionCRCList[15],
1154 &data.factionCRCList[16],
1155 &data.factionCRCList[17],
1156 &data.factionCRCList[18],
1157 &data.factionCRCList[19],
1158 &data.factionControls[0],
1159 &data.factionControls[1],
1160 &data.factionControls[2],
1161 &data.factionControls[3],
1162 &data.factionControls[4],
1163 &data.factionControls[5],
1164 &data.factionControls[6],
1165 &data.factionControls[7],
1166 &data.resourceMultiplierIndex[0],
1167 &data.resourceMultiplierIndex[1],
1168 &data.resourceMultiplierIndex[2],
1169 &data.resourceMultiplierIndex[3],
1170 &data.resourceMultiplierIndex[4],
1171 &data.resourceMultiplierIndex[5],
1172 &data.resourceMultiplierIndex[6],
1173 &data.resourceMultiplierIndex[7],
1174 &data.thisFactionIndex,
1175 &data.factionCount,
1176 &data.teams[0],
1177 &data.teams[1],
1178 &data.teams[2],
1179 &data.teams[3],
1180 &data.teams[4],
1181 &data.teams[5],
1182 &data.teams[6],
1183 &data.teams[7],
1184 &data.startLocationIndex[0],
1185 &data.startLocationIndex[1],
1186 &data.startLocationIndex[2],
1187 &data.startLocationIndex[3],
1188 &data.startLocationIndex[4],
1189 &data.startLocationIndex[5],
1190 &data.startLocationIndex[6],
1191 &data.startLocationIndex[7],
1192 &data.defaultResources,
1193 &data.defaultUnits,
1194 &data.defaultVictoryConditions,
1195 &data.fogOfWar,
1196 &data.allowObservers,
1197 &data.enableObserverModeAtEndGame,
1198 &data.enableServerControlledAI,
1199 &data.networkFramePeriod,
1200 &data.networkPauseGameForLaggedClients,
1201 &data.pathFinderType,
1202 &data.flagTypes1,
1203 &data.aiAcceptSwitchTeamPercentChance,
1204 &data.cpuReplacementMultiplier,
1205 &data.masterserver_admin,
1206 &data.masterserver_admin_factionIndex,
1207 data.scenario.getBuffer(),
1208 data.networkPlayerUUID[0].getBuffer(),
1209 data.networkPlayerUUID[1].getBuffer(),
1210 data.networkPlayerUUID[2].getBuffer(),
1211 data.networkPlayerUUID[3].getBuffer(),
1212 data.networkPlayerUUID[4].getBuffer(),
1213 data.networkPlayerUUID[5].getBuffer(),
1214 data.networkPlayerUUID[6].getBuffer(),
1215 data.networkPlayerUUID[7].getBuffer(),
1216 &data.networkAllowNativeLanguageTechtree,
1217 data.gameUUID.getBuffer()
1218 );
1219 }
1220
packMessage()1221 unsigned char * NetworkMessageLaunch::packMessage() {
1222 unsigned char *buf = new unsigned char[getPackedSize()+1];
1223 pack(buf, getPackedMessageFormat(),
1224 messageType,
1225 data.description.getBuffer(),
1226 data.map.getBuffer(),
1227 data.tileset.getBuffer(),
1228 data.tech.getBuffer(),
1229 data.factionTypeNames[0].getBuffer(),
1230 data.factionTypeNames[1].getBuffer(),
1231 data.factionTypeNames[2].getBuffer(),
1232 data.factionTypeNames[3].getBuffer(),
1233 data.factionTypeNames[4].getBuffer(),
1234 data.factionTypeNames[5].getBuffer(),
1235 data.factionTypeNames[6].getBuffer(),
1236 data.factionTypeNames[7].getBuffer(),
1237 data.networkPlayerNames[0].getBuffer(),
1238 data.networkPlayerNames[1].getBuffer(),
1239 data.networkPlayerNames[2].getBuffer(),
1240 data.networkPlayerNames[3].getBuffer(),
1241 data.networkPlayerNames[4].getBuffer(),
1242 data.networkPlayerNames[5].getBuffer(),
1243 data.networkPlayerNames[6].getBuffer(),
1244 data.networkPlayerNames[7].getBuffer(),
1245 data.networkPlayerPlatform[0].getBuffer(),
1246 data.networkPlayerPlatform[1].getBuffer(),
1247 data.networkPlayerPlatform[2].getBuffer(),
1248 data.networkPlayerPlatform[3].getBuffer(),
1249 data.networkPlayerPlatform[4].getBuffer(),
1250 data.networkPlayerPlatform[5].getBuffer(),
1251 data.networkPlayerPlatform[6].getBuffer(),
1252 data.networkPlayerPlatform[7].getBuffer(),
1253 data.networkPlayerStatuses[0],
1254 data.networkPlayerStatuses[1],
1255 data.networkPlayerStatuses[2],
1256 data.networkPlayerStatuses[3],
1257 data.networkPlayerStatuses[4],
1258 data.networkPlayerStatuses[5],
1259 data.networkPlayerStatuses[6],
1260 data.networkPlayerStatuses[7],
1261 data.networkPlayerLanguages[0].getBuffer(),
1262 data.networkPlayerLanguages[1].getBuffer(),
1263 data.networkPlayerLanguages[2].getBuffer(),
1264 data.networkPlayerLanguages[3].getBuffer(),
1265 data.networkPlayerLanguages[4].getBuffer(),
1266 data.networkPlayerLanguages[5].getBuffer(),
1267 data.networkPlayerLanguages[6].getBuffer(),
1268 data.networkPlayerLanguages[7].getBuffer(),
1269 data.mapFilter,
1270 data.mapCRC,
1271 data.tilesetCRC,
1272 data.techCRC,
1273 data.factionNameList[0].getBuffer(),
1274 data.factionNameList[1].getBuffer(),
1275 data.factionNameList[2].getBuffer(),
1276 data.factionNameList[3].getBuffer(),
1277 data.factionNameList[4].getBuffer(),
1278 data.factionNameList[5].getBuffer(),
1279 data.factionNameList[6].getBuffer(),
1280 data.factionNameList[7].getBuffer(),
1281 data.factionNameList[8].getBuffer(),
1282 data.factionNameList[9].getBuffer(),
1283 data.factionNameList[10].getBuffer(),
1284 data.factionNameList[11].getBuffer(),
1285 data.factionNameList[12].getBuffer(),
1286 data.factionNameList[13].getBuffer(),
1287 data.factionNameList[14].getBuffer(),
1288 data.factionNameList[15].getBuffer(),
1289 data.factionNameList[16].getBuffer(),
1290 data.factionNameList[17].getBuffer(),
1291 data.factionNameList[18].getBuffer(),
1292 data.factionNameList[19].getBuffer(),
1293 data.factionCRCList[0],
1294 data.factionCRCList[1],
1295 data.factionCRCList[2],
1296 data.factionCRCList[3],
1297 data.factionCRCList[4],
1298 data.factionCRCList[5],
1299 data.factionCRCList[6],
1300 data.factionCRCList[7],
1301 data.factionCRCList[8],
1302 data.factionCRCList[9],
1303 data.factionCRCList[10],
1304 data.factionCRCList[11],
1305 data.factionCRCList[12],
1306 data.factionCRCList[13],
1307 data.factionCRCList[14],
1308 data.factionCRCList[15],
1309 data.factionCRCList[16],
1310 data.factionCRCList[17],
1311 data.factionCRCList[18],
1312 data.factionCRCList[19],
1313 data.factionControls[0],
1314 data.factionControls[1],
1315 data.factionControls[2],
1316 data.factionControls[3],
1317 data.factionControls[4],
1318 data.factionControls[5],
1319 data.factionControls[6],
1320 data.factionControls[7],
1321 data.resourceMultiplierIndex[0],
1322 data.resourceMultiplierIndex[1],
1323 data.resourceMultiplierIndex[2],
1324 data.resourceMultiplierIndex[3],
1325 data.resourceMultiplierIndex[4],
1326 data.resourceMultiplierIndex[5],
1327 data.resourceMultiplierIndex[6],
1328 data.resourceMultiplierIndex[7],
1329 data.thisFactionIndex,
1330 data.factionCount,
1331 data.teams[0],
1332 data.teams[1],
1333 data.teams[2],
1334 data.teams[3],
1335 data.teams[4],
1336 data.teams[5],
1337 data.teams[6],
1338 data.teams[7],
1339 data.startLocationIndex[0],
1340 data.startLocationIndex[1],
1341 data.startLocationIndex[2],
1342 data.startLocationIndex[3],
1343 data.startLocationIndex[4],
1344 data.startLocationIndex[5],
1345 data.startLocationIndex[6],
1346 data.startLocationIndex[7],
1347 data.defaultResources,
1348 data.defaultUnits,
1349 data.defaultVictoryConditions,
1350 data.fogOfWar,
1351 data.allowObservers,
1352 data.enableObserverModeAtEndGame,
1353 data.enableServerControlledAI,
1354 data.networkFramePeriod,
1355 data.networkPauseGameForLaggedClients,
1356 data.pathFinderType,
1357 data.flagTypes1,
1358 data.aiAcceptSwitchTeamPercentChance,
1359 data.cpuReplacementMultiplier,
1360 data.masterserver_admin,
1361 data.masterserver_admin_factionIndex,
1362 data.scenario.getBuffer(),
1363 data.networkPlayerUUID[0].getBuffer(),
1364 data.networkPlayerUUID[1].getBuffer(),
1365 data.networkPlayerUUID[2].getBuffer(),
1366 data.networkPlayerUUID[3].getBuffer(),
1367 data.networkPlayerUUID[4].getBuffer(),
1368 data.networkPlayerUUID[5].getBuffer(),
1369 data.networkPlayerUUID[6].getBuffer(),
1370 data.networkPlayerUUID[7].getBuffer(),
1371 data.networkAllowNativeLanguageTechtree,
1372 data.gameUUID.getBuffer()
1373 );
1374 return buf;
1375 }
1376
receive(Socket * socket,NetworkMessageType type)1377 bool NetworkMessageLaunch::receive(Socket* socket, NetworkMessageType type) {
1378 bool result = receive(socket);
1379 messageType = type;
1380 return result;
1381 }
1382
receive(Socket * socket)1383 bool NetworkMessageLaunch::receive(Socket* socket) {
1384 //printf("Receive NetworkMessageLaunch\n");
1385 bool result = false;
1386
1387 Chrono chrono;
1388 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled) chrono.start();
1389
1390 if(useOldProtocol == true) {
1391
1392 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) SystemFlags::OutputDebug(SystemFlags::debugPerformance,"In [%s::%s Line: %d] took msecs: %lld\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,chrono.getMillis());
1393 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) chrono.start();
1394
1395 //printf("UnCompressed launch packet before read compressed size\n");
1396 result = NetworkMessage::receive(socket, &compressedLength, sizeof(compressedLength), true);
1397 //printf("UnCompressed launch packet after read compressed size: %d\n",compressedLength);
1398
1399 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) SystemFlags::OutputDebug(SystemFlags::debugPerformance,"In [%s::%s Line: %d] took msecs: %lld\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,chrono.getMillis());
1400 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) chrono.start();
1401
1402 if(result == true && compressedLength > 0 && socket != NULL && socket->isSocketValid()) {
1403 //printf("UnCompressed launch packet before: %u after: %d\n",compressedLength,(int)getDataSize());
1404
1405 unsigned char *compressedMessage = new unsigned char[compressedLength+1];
1406 memset(compressedMessage,0,compressedLength+1);
1407
1408 result = NetworkMessage::receive(socket, compressedMessage, compressedLength, true);
1409 //printf("UnCompressed launch packet READ returned: %d\n",result);
1410
1411 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) SystemFlags::OutputDebug(SystemFlags::debugPerformance,"In [%s::%s Line: %d] took msecs: %lld\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,chrono.getMillis());
1412 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) chrono.start();
1413
1414 if(result == true && socket != NULL && socket->isSocketValid()) {
1415 //printf("UnCompressed launch packet before decompress\n");
1416
1417 // printf("\n");
1418 // const unsigned char *buf = static_cast<const unsigned char *>(compressedMessage);
1419 // for(unsigned int index = 0; index < (unsigned int)compressedLength; ++index) {
1420 // printf("%u[%X][%d] ",index,buf[index],buf[index]);
1421 // if(index % 10 == 0) {
1422 // printf("\n");
1423 // }
1424 // }
1425 // printf("\n");
1426
1427 unsigned long buffer_size = compressedLength;
1428 std::pair<unsigned char *,unsigned long> decompressedBuffer =
1429 Shared::CompressionUtil::extractMemoryToMemory(compressedMessage, buffer_size, maxNetworkMessageSize);
1430
1431 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) SystemFlags::OutputDebug(SystemFlags::debugPerformance,"In [%s::%s Line: %d] took msecs: %lld\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,chrono.getMillis());
1432 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) chrono.start();
1433
1434 unsigned char *decompressed_buffer = decompressedBuffer.first;
1435 memcpy(&data,decompressed_buffer,decompressedBuffer.second);
1436 delete [] decompressed_buffer;
1437
1438 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) SystemFlags::OutputDebug(SystemFlags::debugPerformance,"In [%s::%s Line: %d] took msecs: %lld\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,chrono.getMillis());
1439 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) chrono.start();
1440
1441 //printf("SUCCESS UnCompressed launch packet before: %u after: %lu\n",compressedLength,decompressedBuffer.second);
1442 }
1443 delete [] compressedMessage;
1444
1445 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) SystemFlags::OutputDebug(SystemFlags::debugPerformance,"In [%s::%s Line: %d] took msecs: %lld\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,chrono.getMillis());
1446 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) chrono.start();
1447 }
1448 else if(result == true) {
1449 //printf("Normal launch packet detected (uncompressed)\n");
1450 result = NetworkMessage::receive(socket, &data, sizeof(data), true);
1451
1452 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) SystemFlags::OutputDebug(SystemFlags::debugPerformance,"In [%s::%s Line: %d] took msecs: %lld\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,chrono.getMillis());
1453 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) chrono.start();
1454 }
1455 }
1456 else {
1457 unsigned char *buf = new unsigned char[getPackedSize()+1];
1458 result = NetworkMessage::receive(socket, buf, getPackedSize(), true);
1459 unpackMessage(buf);
1460 //printf("Got packet size = %u data.messageType = %d\n%s\n",getPackedSize(),data.messageType,buf);
1461 delete [] buf;
1462 }
1463 fromEndian();
1464
1465 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) SystemFlags::OutputDebug(SystemFlags::debugPerformance,"In [%s::%s Line: %d] took msecs: %lld\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,chrono.getMillis());
1466 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) chrono.start();
1467
1468 data.description.nullTerminate();
1469 data.map.nullTerminate();
1470 data.tileset.nullTerminate();
1471 data.tech.nullTerminate();
1472 for(int i= 0; i < GameConstants::maxPlayers; ++i){
1473 data.factionTypeNames[i].nullTerminate();
1474 data.networkPlayerNames[i].nullTerminate();
1475 data.networkPlayerPlatform[i].nullTerminate();
1476 data.networkPlayerLanguages[i].nullTerminate();
1477
1478 data.networkPlayerUUID[i].nullTerminate();
1479 }
1480 for(unsigned int i = 0; i < (unsigned int)maxFactionCRCCount; ++i) {
1481 data.factionNameList[i].nullTerminate();
1482 }
1483
1484 data.scenario.nullTerminate();
1485
1486 data.gameUUID.nullTerminate();
1487
1488 if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) SystemFlags::OutputDebug(SystemFlags::debugPerformance,"In [%s::%s Line: %d] took msecs: %lld\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,chrono.getMillis());
1489
1490 //for(int i= 0; i < GameConstants::maxPlayers; ++i){
1491 // printf("Receive index: %d resource multiplier index: %d sizeof(data): %d\n",i,data.resourceMultiplierIndex[i],sizeof(data));
1492 //}
1493
1494 return result;
1495 }
1496
getData()1497 unsigned char * NetworkMessageLaunch::getData() {
1498 unsigned char *buffer = new unsigned char[getDataSize()];
1499 memcpy(buffer,&data,getDataSize());
1500 return buffer;
1501 }
1502
getCompressedMessage()1503 std::pair<unsigned char *,unsigned long> NetworkMessageLaunch::getCompressedMessage() {
1504 unsigned char *buffer = this->getData();
1505 std::pair<unsigned char *,unsigned long> result =
1506 Shared::CompressionUtil::compressMemoryToMemory(buffer,getDataSize());
1507 delete [] buffer;
1508 return result;
1509 }
1510
send(Socket * socket)1511 void NetworkMessageLaunch::send(Socket* socket) {
1512 //printf("Sending NetworkMessageLaunch\n");
1513
1514 //for(int i= 0; i < GameConstants::maxPlayers; ++i){
1515 // printf("Send index: %d resource multiplier index: %d sizeof(data): %d\n",i,data.resourceMultiplierIndex[i],sizeof(data));
1516 //}
1517
1518 if(messageType == nmtLaunch) {
1519 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtLaunch\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
1520 }
1521 else {
1522 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] messageType = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,messageType);
1523 }
1524 toEndian();
1525
1526 if(useOldProtocol == true) {
1527 ////NetworkMessage::send(socket, &messageType, sizeof(messageType));
1528 //NetworkMessage::send(socket, &data, sizeof(data), messageType);
1529
1530 std::pair<unsigned char *,unsigned long> compressionResult = getCompressedMessage();
1531 compressedLength = compressionResult.second;
1532 //printf("Compressed launch packet before: %d after: %lu\n",(int)getDataSize(),compressionResult.second);
1533
1534 // printf("\n");
1535 // const unsigned char *buf = static_cast<const unsigned char *>(compressionResult.first);
1536 // for(unsigned int index = 0; index < (unsigned int)compressionResult.second; ++index) {
1537 // printf("%u[%X][%d] ",index,buf[index],buf[index]);
1538 // if(index % 10 == 0) {
1539 // printf("\n");
1540 // }
1541 // }
1542 // printf("\n");
1543
1544 /*
1545 NetworkMessage::send(socket, &messageType, sizeof(messageType));
1546 if(socket != NULL && socket->isSocketValid()) {
1547 NetworkMessage::send(socket, &compressedLength, sizeof(compressedLength));
1548 if(socket != NULL && socket->isSocketValid()) {
1549 NetworkMessage::send(socket, compressionResult.first, compressionResult.second);
1550 }
1551 }
1552 */
1553 NetworkMessage::send(socket, compressionResult.first, compressionResult.second, messageType, compressedLength);
1554 delete [] compressionResult.first;
1555 //printf("Compressed launch packet SENT\n");
1556 }
1557 else {
1558 unsigned char *buf = packMessage();
1559 //printf("Send packet size = %u data.messageType = %d\n[%s]\n",getPackedSize(),data.messageType,buf);
1560 NetworkMessage::send(socket, buf, getPackedSize());
1561 delete [] buf;
1562 }
1563 }
1564
toEndian()1565 void NetworkMessageLaunch::toEndian() {
1566 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
1567 if(bigEndianSystem == true) {
1568 messageType = Shared::PlatformByteOrder::toCommonEndian(messageType);
1569 for(int i= 0; i < GameConstants::maxPlayers; ++i){
1570 data.networkPlayerStatuses[i] = Shared::PlatformByteOrder::toCommonEndian(data.networkPlayerStatuses[i]);
1571 data.factionCRCList[i] = Shared::PlatformByteOrder::toCommonEndian(data.factionCRCList[i]);
1572 data.factionControls[i] = Shared::PlatformByteOrder::toCommonEndian(data.factionControls[i]);
1573 data.resourceMultiplierIndex[i] = Shared::PlatformByteOrder::toCommonEndian(data.resourceMultiplierIndex[i]);
1574 data.teams[i] = Shared::PlatformByteOrder::toCommonEndian(data.teams[i]);
1575 data.startLocationIndex[i] = Shared::PlatformByteOrder::toCommonEndian(data.startLocationIndex[i]);
1576 }
1577 data.mapFilter = Shared::PlatformByteOrder::toCommonEndian(data.mapFilter);
1578 data.mapCRC = Shared::PlatformByteOrder::toCommonEndian(data.mapCRC);
1579 data.tilesetCRC = Shared::PlatformByteOrder::toCommonEndian(data.tilesetCRC);
1580 data.techCRC = Shared::PlatformByteOrder::toCommonEndian(data.techCRC);
1581 data.thisFactionIndex = Shared::PlatformByteOrder::toCommonEndian(data.thisFactionIndex);
1582 data.factionCount = Shared::PlatformByteOrder::toCommonEndian(data.factionCount);
1583 data.defaultResources = Shared::PlatformByteOrder::toCommonEndian(data.defaultResources);
1584 data.defaultUnits = Shared::PlatformByteOrder::toCommonEndian(data.defaultUnits);
1585
1586 data.defaultVictoryConditions = Shared::PlatformByteOrder::toCommonEndian(data.defaultVictoryConditions);
1587 data.fogOfWar = Shared::PlatformByteOrder::toCommonEndian(data.fogOfWar);
1588 data.allowObservers = Shared::PlatformByteOrder::toCommonEndian(data.allowObservers);
1589 data.enableObserverModeAtEndGame = Shared::PlatformByteOrder::toCommonEndian(data.enableObserverModeAtEndGame);
1590 data.enableServerControlledAI = Shared::PlatformByteOrder::toCommonEndian(data.enableServerControlledAI);
1591 data.networkFramePeriod = Shared::PlatformByteOrder::toCommonEndian(data.networkFramePeriod);
1592 data.networkPauseGameForLaggedClients = Shared::PlatformByteOrder::toCommonEndian(data.networkPauseGameForLaggedClients);
1593 data.pathFinderType = Shared::PlatformByteOrder::toCommonEndian(data.pathFinderType);
1594 data.flagTypes1 = Shared::PlatformByteOrder::toCommonEndian(data.flagTypes1);
1595
1596 data.aiAcceptSwitchTeamPercentChance = Shared::PlatformByteOrder::toCommonEndian(data.aiAcceptSwitchTeamPercentChance);
1597 data.cpuReplacementMultiplier = Shared::PlatformByteOrder::toCommonEndian(data.cpuReplacementMultiplier);
1598 data.masterserver_admin = Shared::PlatformByteOrder::toCommonEndian(data.masterserver_admin);
1599 data.masterserver_admin_factionIndex = Shared::PlatformByteOrder::toCommonEndian(data.masterserver_admin_factionIndex);
1600
1601 data.networkAllowNativeLanguageTechtree = Shared::PlatformByteOrder::toCommonEndian(data.networkAllowNativeLanguageTechtree);
1602 }
1603 }
1604
fromEndian()1605 void NetworkMessageLaunch::fromEndian() {
1606 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
1607 if(bigEndianSystem == true) {
1608 messageType = Shared::PlatformByteOrder::toCommonEndian(messageType);
1609 for(int i= 0; i < GameConstants::maxPlayers; ++i){
1610 data.networkPlayerStatuses[i] = Shared::PlatformByteOrder::fromCommonEndian(data.networkPlayerStatuses[i]);
1611 data.factionCRCList[i] = Shared::PlatformByteOrder::fromCommonEndian(data.factionCRCList[i]);
1612 data.factionControls[i] = Shared::PlatformByteOrder::fromCommonEndian(data.factionControls[i]);
1613 data.resourceMultiplierIndex[i] = Shared::PlatformByteOrder::fromCommonEndian(data.resourceMultiplierIndex[i]);
1614 data.teams[i] = Shared::PlatformByteOrder::fromCommonEndian(data.teams[i]);
1615 data.startLocationIndex[i] = Shared::PlatformByteOrder::fromCommonEndian(data.startLocationIndex[i]);
1616 }
1617 data.mapFilter = Shared::PlatformByteOrder::fromCommonEndian(data.mapFilter);
1618 data.mapCRC = Shared::PlatformByteOrder::fromCommonEndian(data.mapCRC);
1619 data.tilesetCRC = Shared::PlatformByteOrder::fromCommonEndian(data.tilesetCRC);
1620 data.techCRC = Shared::PlatformByteOrder::fromCommonEndian(data.techCRC);
1621 data.thisFactionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.thisFactionIndex);
1622 data.factionCount = Shared::PlatformByteOrder::fromCommonEndian(data.factionCount);
1623 data.defaultResources = Shared::PlatformByteOrder::fromCommonEndian(data.defaultResources);
1624 data.defaultUnits = Shared::PlatformByteOrder::fromCommonEndian(data.defaultUnits);
1625
1626 data.defaultVictoryConditions = Shared::PlatformByteOrder::fromCommonEndian(data.defaultVictoryConditions);
1627 data.fogOfWar = Shared::PlatformByteOrder::fromCommonEndian(data.fogOfWar);
1628 data.allowObservers = Shared::PlatformByteOrder::fromCommonEndian(data.allowObservers);
1629 data.enableObserverModeAtEndGame = Shared::PlatformByteOrder::fromCommonEndian(data.enableObserverModeAtEndGame);
1630 data.enableServerControlledAI = Shared::PlatformByteOrder::fromCommonEndian(data.enableServerControlledAI);
1631 data.networkFramePeriod = Shared::PlatformByteOrder::fromCommonEndian(data.networkFramePeriod);
1632 data.networkPauseGameForLaggedClients = Shared::PlatformByteOrder::fromCommonEndian(data.networkPauseGameForLaggedClients);
1633 data.pathFinderType = Shared::PlatformByteOrder::fromCommonEndian(data.pathFinderType);
1634 data.flagTypes1 = Shared::PlatformByteOrder::fromCommonEndian(data.flagTypes1);
1635
1636 data.aiAcceptSwitchTeamPercentChance = Shared::PlatformByteOrder::fromCommonEndian(data.aiAcceptSwitchTeamPercentChance);
1637 data.cpuReplacementMultiplier = Shared::PlatformByteOrder::fromCommonEndian(data.cpuReplacementMultiplier);
1638 data.masterserver_admin = Shared::PlatformByteOrder::fromCommonEndian(data.masterserver_admin);
1639 data.masterserver_admin_factionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.masterserver_admin_factionIndex);
1640
1641 data.networkAllowNativeLanguageTechtree = Shared::PlatformByteOrder::fromCommonEndian(data.networkAllowNativeLanguageTechtree);
1642 }
1643 }
1644
1645 // =====================================================
1646 // class NetworkMessageLaunch
1647 // =====================================================
1648
NetworkMessageCommandList(int32 frameCount)1649 NetworkMessageCommandList::NetworkMessageCommandList(int32 frameCount) {
1650 data.messageType = nmtCommandList;
1651 data.header.frameCount= frameCount;
1652 data.header.commandCount= 0;
1653 for(int index = 0; index < GameConstants::maxPlayers; ++index) {
1654 data.header.networkPlayerFactionCRC[index]=0;
1655 }
1656 }
1657
addCommand(const NetworkCommand * networkCommand)1658 bool NetworkMessageCommandList::addCommand(const NetworkCommand* networkCommand){
1659 data.commands.push_back(*networkCommand);
1660 data.header.commandCount++;
1661 return true;
1662 }
1663
getPackedMessageFormatHeader() const1664 const char * NetworkMessageCommandList::getPackedMessageFormatHeader() const {
1665 return "cHlLLLLLLLL";
1666 }
1667
getPackedSizeHeader()1668 unsigned int NetworkMessageCommandList::getPackedSizeHeader() {
1669 static unsigned int result = 0;
1670 if(result == 0) {
1671 Data packedData;
1672 init(packedData);
1673 unsigned char *buf = new unsigned char[sizeof(packedData)*3];
1674 result = pack(buf, getPackedMessageFormatHeader(),
1675 packedData.messageType,
1676 packedData.header.commandCount,
1677 packedData.header.frameCount,
1678 packedData.header.networkPlayerFactionCRC[0],
1679 packedData.header.networkPlayerFactionCRC[1],
1680 packedData.header.networkPlayerFactionCRC[2],
1681 packedData.header.networkPlayerFactionCRC[3],
1682 packedData.header.networkPlayerFactionCRC[4],
1683 packedData.header.networkPlayerFactionCRC[5],
1684 packedData.header.networkPlayerFactionCRC[6],
1685 packedData.header.networkPlayerFactionCRC[7]);
1686 delete [] buf;
1687 }
1688 return result;
1689 }
unpackMessageHeader(unsigned char * buf)1690 void NetworkMessageCommandList::unpackMessageHeader(unsigned char *buf) {
1691 unpack(buf, getPackedMessageFormatHeader(),
1692 &data.messageType,
1693 &data.header.commandCount,
1694 &data.header.frameCount,
1695 &data.header.networkPlayerFactionCRC[0],
1696 &data.header.networkPlayerFactionCRC[1],
1697 &data.header.networkPlayerFactionCRC[2],
1698 &data.header.networkPlayerFactionCRC[3],
1699 &data.header.networkPlayerFactionCRC[4],
1700 &data.header.networkPlayerFactionCRC[5],
1701 &data.header.networkPlayerFactionCRC[6],
1702 &data.header.networkPlayerFactionCRC[7]);
1703 }
1704
packMessageHeader()1705 unsigned char * NetworkMessageCommandList::packMessageHeader() {
1706 unsigned char *buf = new unsigned char[getPackedSizeHeader()+1];
1707 pack(buf, getPackedMessageFormatHeader(),
1708 data.messageType,
1709 data.header.commandCount,
1710 data.header.frameCount,
1711 data.header.networkPlayerFactionCRC[0],
1712 data.header.networkPlayerFactionCRC[1],
1713 data.header.networkPlayerFactionCRC[2],
1714 data.header.networkPlayerFactionCRC[3],
1715 data.header.networkPlayerFactionCRC[4],
1716 data.header.networkPlayerFactionCRC[5],
1717 data.header.networkPlayerFactionCRC[6],
1718 data.header.networkPlayerFactionCRC[7]);
1719 return buf;
1720 }
1721
getPackedMessageFormatDetail() const1722 const char * NetworkMessageCommandList::getPackedMessageFormatDetail() const {
1723 return "hlhhhhlccHccll";
1724 }
1725
getPackedSizeDetail(int count)1726 unsigned int NetworkMessageCommandList::getPackedSizeDetail(int count) {
1727 unsigned int result = 0;
1728 if(result == 0) {
1729 for(unsigned int i = 0; i < (unsigned int)count; ++i) {
1730 NetworkCommand packedData;
1731 unsigned char *buf = new unsigned char[sizeof(NetworkCommand)*3];
1732 result += pack(buf, getPackedMessageFormatDetail(),
1733 packedData.networkCommandType,
1734 packedData.unitId,
1735 packedData.unitTypeId,
1736 packedData.commandTypeId,
1737 packedData.positionX,
1738 packedData.positionY,
1739 packedData.targetId,
1740 packedData.wantQueue,
1741 packedData.fromFactionIndex,
1742 packedData.unitFactionUnitCount,
1743 packedData.unitFactionIndex,
1744 packedData.commandStateType,
1745 packedData.commandStateValue,
1746 packedData.unitCommandGroupId);
1747 delete [] buf;
1748 }
1749 }
1750 return result;
1751 }
unpackMessageDetail(unsigned char * buf,int count)1752 void NetworkMessageCommandList::unpackMessageDetail(unsigned char *buf,int count) {
1753 data.commands.clear();
1754 data.commands.resize(count);
1755 //unsigned int bytes_processed_total = 0;
1756 unsigned char *bufMove = buf;
1757 for(unsigned int i = 0; i < (unsigned int)count; ++i) {
1758 unsigned int bytes_processed = unpack(bufMove, getPackedMessageFormatDetail(),
1759 &data.commands[i].networkCommandType,
1760 &data.commands[i].unitId,
1761 &data.commands[i].unitTypeId,
1762 &data.commands[i].commandTypeId,
1763 &data.commands[i].positionX,
1764 &data.commands[i].positionY,
1765 &data.commands[i].targetId,
1766 &data.commands[i].wantQueue,
1767 &data.commands[i].fromFactionIndex,
1768 &data.commands[i].unitFactionUnitCount,
1769 &data.commands[i].unitFactionIndex,
1770 &data.commands[i].commandStateType,
1771 &data.commands[i].commandStateValue,
1772 &data.commands[i].unitCommandGroupId);
1773 bufMove += bytes_processed;
1774 //bytes_processed_total += bytes_processed;
1775 }
1776 //printf("\nUnPacked detail size = %u\n",bytes_processed_total);
1777 }
1778
packMessageDetail(uint16 totalCommand)1779 unsigned char * NetworkMessageCommandList::packMessageDetail(uint16 totalCommand) {
1780 int packetSize = getPackedSizeDetail(totalCommand) +1;
1781 unsigned char *buf = new unsigned char[packetSize];
1782 unsigned char *bufMove = buf;
1783 //unsigned int bytes_processed_total = 0;
1784 for(unsigned int i = 0; i < totalCommand; ++i) {
1785 unsigned int bytes_processed = pack(bufMove, getPackedMessageFormatDetail(),
1786 data.commands[i].networkCommandType,
1787 data.commands[i].unitId,
1788 data.commands[i].unitTypeId,
1789 data.commands[i].commandTypeId,
1790 data.commands[i].positionX,
1791 data.commands[i].positionY,
1792 data.commands[i].targetId,
1793 data.commands[i].wantQueue,
1794 data.commands[i].fromFactionIndex,
1795 data.commands[i].unitFactionUnitCount,
1796 data.commands[i].unitFactionIndex,
1797 data.commands[i].commandStateType,
1798 data.commands[i].commandStateValue,
1799 data.commands[i].unitCommandGroupId);
1800 bufMove += bytes_processed;
1801 //bytes_processed_total += bytes_processed;
1802 }
1803 //printf("\nPacked detail size = %u, allocated = %d\n",bytes_processed_total,packetSize);
1804 return buf;
1805 }
1806
receive(Socket * socket)1807 bool NetworkMessageCommandList::receive(Socket* socket) {
1808 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
1809
1810 unsigned char *buf = NULL;
1811 bool result = false;
1812 if(useOldProtocol == true) {
1813 result = NetworkMessage::receive(socket, &data.header, commandListHeaderSize, true);
1814 if(result == true) {
1815 data.messageType = this->getNetworkMessageType();
1816 }
1817
1818 //printf("!!! =====> IN Network hdr cmd get frame: %d data.header.commandCount: %u\n",data.header.frameCount,data.header.commandCount);
1819 }
1820 else {
1821 buf = new unsigned char[getPackedSizeHeader()+1];
1822 result = NetworkMessage::receive(socket, buf, getPackedSizeHeader(), true);
1823 unpackMessageHeader(buf);
1824 //if(data.header.commandCount) printf("\n\nGot packet size = %u data.messageType = %d\n%s\ncommandcount [%u] framecount [%d]\n",getPackedSizeHeader(),data.header.messageType,buf,data.header.commandCount,data.header.frameCount);
1825 delete [] buf;
1826 }
1827 fromEndianHeader();
1828
1829 if(result == true) {
1830 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] got header, messageType = %d, commandCount = %u, frameCount = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,data.messageType,data.header.commandCount,data.header.frameCount);
1831
1832 //printf("!!! =====> IN Network cmd get frame: %d data.header.commandCount: %u\n",data.header.frameCount,data.header.commandCount);
1833
1834 if(data.header.commandCount > 0) {
1835 data.commands.resize(data.header.commandCount);
1836
1837 if(useOldProtocol == true) {
1838 int totalMsgSize = (sizeof(NetworkCommand) * data.header.commandCount);
1839 result = NetworkMessage::receive(socket, &data.commands[0], totalMsgSize, true);
1840
1841 // if(data.commands[0].getNetworkCommandType() == nctPauseResume) {
1842 // printf("=====> IN Network cmd type: %d [%d] frame: %d\n",data.commands[0].getNetworkCommandType(),nctPauseResume,data.header.frameCount);
1843 // }
1844 }
1845 else {
1846 //int totalMsgSize = (sizeof(NetworkCommand) * data.header.commandCount);
1847 //result = NetworkMessage::receive(socket, &data.commands[0], totalMsgSize, true);
1848 buf = new unsigned char[getPackedSizeDetail(data.header.commandCount)+1];
1849 result = NetworkMessage::receive(socket, buf, getPackedSizeDetail(data.header.commandCount), true);
1850 unpackMessageDetail(buf,data.header.commandCount);
1851 //printf("Got packet size = %u data.messageType = %d\n%s\n",getPackedSize(),data.messageType,buf);
1852 delete [] buf;
1853 }
1854 fromEndianDetail();
1855
1856 // for(int idx = 0 ; idx < data.header.commandCount; ++idx) {
1857 // const NetworkCommand &cmd = data.commands[idx];
1858 // printf("========> Got index = %d / %u, got networkCommand [%s]\n",idx, data.header.commandCount,cmd.toString().c_str());
1859 // }
1860
1861 if(result == true) {
1862 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled == true) {
1863 for(int idx = 0 ; idx < data.header.commandCount; ++idx) {
1864 const NetworkCommand &cmd = data.commands[idx];
1865
1866 SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] index = %d, received networkCommand [%s]\n",
1867 extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,idx, cmd.toString().c_str());
1868 }
1869 }
1870 }
1871 else {
1872 //if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] ERROR Failed to get command data, totalMsgSize = %d.\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,totalMsgSize);
1873 }
1874 }
1875 }
1876 else {
1877 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] ERROR header not received as expected\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
1878 SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] ERROR header not received as expected\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
1879 }
1880 return result;
1881
1882 }
1883
getData()1884 unsigned char * NetworkMessageCommandList::getData() {
1885 int headerSize = sizeof(data.header);
1886 uint16 totalCommand = data.header.commandCount;
1887 int detailSize = (sizeof(NetworkCommand) * totalCommand);
1888 int fullBufferSize = headerSize + detailSize;
1889
1890 unsigned char *buffer = new unsigned char[fullBufferSize];
1891 memcpy(buffer,&data.header,headerSize);
1892 memcpy(&buffer[headerSize],&data.commands[0],detailSize);
1893 return buffer;
1894 }
1895
send(Socket * socket)1896 void NetworkMessageCommandList::send(Socket* socket) {
1897 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtCommandList, frameCount = %d, data.header.commandCount = %d, data.header.messageType = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,data.header.frameCount,data.header.commandCount,data.messageType);
1898
1899 assert(data.messageType == nmtCommandList);
1900 uint16 totalCommand = data.header.commandCount;
1901 toEndianHeader();
1902 toEndianDetail(totalCommand);
1903
1904 unsigned char *buf = NULL;
1905 //bool result = false;
1906 if(useOldProtocol == true) {
1907 //printf("<===== OUT Network hdr cmd type: frame: %d totalCommand: %u [%u]\n",data.header.frameCount,totalCommand,data.header.commandCount);
1908 //NetworkMessage::send(socket, &data.messageType, sizeof(data.messageType));
1909
1910 //NetworkMessage::send(socket, &data.header, commandListHeaderSize, data.messageType);
1911 unsigned char *send_buffer = getData();
1912 int headerSize = sizeof(data.header);
1913 uint16 totalCommand = data.header.commandCount;
1914 int detailSize = (sizeof(NetworkCommand) * totalCommand);
1915 int fullBufferSize = headerSize + detailSize;
1916 NetworkMessage::send(socket, send_buffer, fullBufferSize, data.messageType);
1917 delete [] send_buffer;
1918 }
1919 else {
1920 //NetworkMessage::send(socket, &data.header, commandListHeaderSize);
1921 buf = packMessageHeader();
1922 //if(totalCommand) printf("\n\nSend packet size = %u data.messageType = %d\n%s\ncommandcount [%u] framecount [%d]\n",getPackedSizeHeader(),data.header.messageType,buf,totalCommand,data.header.frameCount);
1923 NetworkMessage::send(socket, buf, getPackedSizeHeader());
1924 delete [] buf;
1925 }
1926
1927 if(totalCommand > 0) {
1928 //printf("\n#2 Send packet commandcount [%u] framecount [%d]\n",totalCommand,data.header.frameCount);
1929 //toEndianDetail(totalCommand);
1930 //printf("\n#3 Send packet commandcount [%u] framecount [%d]\n",totalCommand,data.header.frameCount);
1931
1932 //bool result = false;
1933 if(useOldProtocol == true) {
1934 // if(data.commands[0].getNetworkCommandType() == nctPauseResume) {
1935 // printf("<===== OUT Network cmd type: %d [%d] frame: %d totalCommand: %u [%u]\n",data.commands[0].getNetworkCommandType(),nctPauseResume,data.header.frameCount,totalCommand,data.header.commandCount);
1936 // }
1937 //NetworkMessage::send(socket, &data.commands[0], (sizeof(NetworkCommand) * totalCommand));
1938 }
1939 else {
1940 buf = packMessageDetail(totalCommand);
1941 //printf("\n#4 Send packet commandcount [%u] framecount [%d]\n",totalCommand,data.header.frameCount);
1942 //printf("Send packet size = %u data.messageType = %d\n[%s]\n",getPackedSize(),data.messageType,buf);
1943 NetworkMessage::send(socket, buf, getPackedSizeDetail(totalCommand));
1944 //printf("\n#5 Send packet commandcount [%u] framecount [%d]\n",totalCommand,data.header.frameCount);
1945 delete [] buf;
1946 //printf("\n#6 Send packet commandcount [%u] framecount [%d]\n",totalCommand,data.header.frameCount);
1947
1948 // for(int idx = 0 ; idx < totalCommand; ++idx) {
1949 // const NetworkCommand &cmd = data.commands[idx];
1950 // printf("========> Send index = %d / %u, sent networkCommand [%s]\n",idx, totalCommand,cmd.toString().c_str());
1951 // }
1952 }
1953 }
1954
1955 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled == true) {
1956 SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] messageType = %d, frameCount = %d, data.commandCount = %d\n",
1957 extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,data.messageType,data.header.frameCount,data.header.commandCount);
1958
1959 if (totalCommand > 0) {
1960 for(int idx = 0 ; idx < totalCommand; ++idx) {
1961 const NetworkCommand &cmd = data.commands[idx];
1962
1963 SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] index = %d, sent networkCommand [%s]\n",
1964 extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,idx, cmd.toString().c_str());
1965 }
1966
1967 SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] END of loop, nmtCommandList, frameCount = %d, data.header.commandCount = %d, data.header.messageType = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,data.header.frameCount,totalCommand,data.messageType);
1968 }
1969 }
1970 }
1971
toEndianHeader()1972 void NetworkMessageCommandList::toEndianHeader() {
1973 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
1974 if(bigEndianSystem == true) {
1975 data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
1976 data.header.commandCount = Shared::PlatformByteOrder::toCommonEndian(data.header.commandCount);
1977 data.header.frameCount = Shared::PlatformByteOrder::toCommonEndian(data.header.frameCount);
1978 for(int index = 0; index < GameConstants::maxPlayers; ++index) {
1979 data.header.networkPlayerFactionCRC[index] = Shared::PlatformByteOrder::toCommonEndian(data.header.networkPlayerFactionCRC[index]);
1980 }
1981 }
1982 }
fromEndianHeader()1983 void NetworkMessageCommandList::fromEndianHeader() {
1984 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
1985 if(bigEndianSystem == true) {
1986 data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
1987 data.header.commandCount = Shared::PlatformByteOrder::fromCommonEndian(data.header.commandCount);
1988 data.header.frameCount = Shared::PlatformByteOrder::fromCommonEndian(data.header.frameCount);
1989 for(int index = 0; index < GameConstants::maxPlayers; ++index) {
1990 data.header.networkPlayerFactionCRC[index] = Shared::PlatformByteOrder::fromCommonEndian(data.header.networkPlayerFactionCRC[index]);
1991 }
1992 }
1993 }
1994
toEndianDetail(uint16 totalCommand)1995 void NetworkMessageCommandList::toEndianDetail(uint16 totalCommand) {
1996 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
1997 if(bigEndianSystem == true) {
1998 if(totalCommand > 0) {
1999 for(int idx = 0 ; idx < totalCommand; ++idx) {
2000 NetworkCommand &cmd = data.commands[idx];
2001 cmd.toEndian();
2002 }
2003 }
2004 }
2005 }
2006
fromEndianDetail()2007 void NetworkMessageCommandList::fromEndianDetail() {
2008 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2009 if(bigEndianSystem == true) {
2010 if(data.header.commandCount > 0) {
2011 for(int idx = 0 ; idx < data.header.commandCount; ++idx) {
2012 NetworkCommand &cmd = data.commands[idx];
2013 cmd.fromEndian();
2014 }
2015 }
2016 }
2017 }
2018
2019 // =====================================================
2020 // class NetworkMessageText
2021 // =====================================================
2022
NetworkMessageText()2023 NetworkMessageText::NetworkMessageText() {
2024 messageType = nmtText;
2025 }
NetworkMessageText(const string & text,int teamIndex,int playerIndex,const string targetLanguage)2026 NetworkMessageText::NetworkMessageText(const string &text, int teamIndex, int playerIndex,
2027 const string targetLanguage) {
2028 if((int)text.length() >= maxTextStringSize) {
2029 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] WARNING / ERROR - text [%s] length = %d, max = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,text.c_str(),text.length(),maxTextStringSize);
2030 }
2031
2032 messageType = nmtText;
2033 data.text = text.substr(0,maxTextStringSize);
2034 data.teamIndex = teamIndex;
2035 data.playerIndex = playerIndex;
2036 data.targetLanguage = targetLanguage;
2037 }
2038
getCopy() const2039 NetworkMessageText * NetworkMessageText::getCopy() const {
2040 NetworkMessageText *copy = new NetworkMessageText();
2041 copy->data = this->data;
2042 return copy;
2043 }
2044
getPackedMessageFormat() const2045 const char * NetworkMessageText::getPackedMessageFormat() const {
2046 return "c500scc60s";
2047 }
2048
getPackedSize()2049 unsigned int NetworkMessageText::getPackedSize() {
2050 static unsigned int result = 0;
2051 if(result == 0) {
2052 Data packedData;
2053 messageType = nmtText;
2054 packedData.playerIndex = 0;
2055 packedData.teamIndex = 0;
2056 unsigned char *buf = new unsigned char[sizeof(packedData)*3];
2057 result = pack(buf, getPackedMessageFormat(),
2058 messageType,
2059 packedData.text.getBuffer(),
2060 packedData.teamIndex,
2061 packedData.playerIndex,
2062 packedData.targetLanguage.getBuffer());
2063 delete [] buf;
2064 }
2065 return result;
2066 }
unpackMessage(unsigned char * buf)2067 void NetworkMessageText::unpackMessage(unsigned char *buf) {
2068 unpack(buf, getPackedMessageFormat(),
2069 &messageType,
2070 data.text.getBuffer(),
2071 &data.teamIndex,
2072 &data.playerIndex,
2073 data.targetLanguage.getBuffer());
2074 }
2075
packMessage()2076 unsigned char * NetworkMessageText::packMessage() {
2077 unsigned char *buf = new unsigned char[getPackedSize()+1];
2078 pack(buf, getPackedMessageFormat(),
2079 messageType,
2080 data.text.getBuffer(),
2081 data.teamIndex,
2082 data.playerIndex,
2083 data.targetLanguage.getBuffer());
2084 return buf;
2085 }
2086
receive(Socket * socket)2087 bool NetworkMessageText::receive(Socket* socket) {
2088 bool result = false;
2089 if(useOldProtocol == true) {
2090 result = NetworkMessage::receive(socket, &data, sizeof(data), true);
2091 if(result == true) {
2092 messageType = this->getNetworkMessageType();
2093 }
2094 }
2095 else {
2096 unsigned char *buf = new unsigned char[getPackedSize()+1];
2097 result = NetworkMessage::receive(socket, buf, getPackedSize(), true);
2098 unpackMessage(buf);
2099 //printf("Got packet size = %u data.messageType = %d\n%s\n",getPackedSize(),data.messageType,buf);
2100 delete [] buf;
2101 }
2102 fromEndian();
2103
2104 data.text.nullTerminate();
2105 data.targetLanguage.nullTerminate();
2106
2107 return result;
2108 }
2109
send(Socket * socket)2110 void NetworkMessageText::send(Socket* socket) {
2111 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtText\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
2112
2113 assert(messageType == nmtText);
2114 toEndian();
2115
2116 if(useOldProtocol == true) {
2117 //NetworkMessage::send(socket, &messageType, sizeof(messageType));
2118 NetworkMessage::send(socket, &data, sizeof(data), messageType);
2119 }
2120 else {
2121 unsigned char *buf = packMessage();
2122 //printf("Send packet size = %u data.messageType = %d\n[%s]\n",getPackedSize(),data.messageType,buf);
2123 NetworkMessage::send(socket, buf, getPackedSize());
2124 delete [] buf;
2125 }
2126 }
2127
toEndian()2128 void NetworkMessageText::toEndian() {
2129 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2130 if(bigEndianSystem == true) {
2131 messageType = Shared::PlatformByteOrder::toCommonEndian(messageType);
2132 data.teamIndex = Shared::PlatformByteOrder::toCommonEndian(data.teamIndex);
2133 data.playerIndex = Shared::PlatformByteOrder::toCommonEndian(data.playerIndex);
2134 }
2135 }
fromEndian()2136 void NetworkMessageText::fromEndian() {
2137 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2138 if(bigEndianSystem == true) {
2139 messageType = Shared::PlatformByteOrder::fromCommonEndian(messageType);
2140 data.teamIndex = Shared::PlatformByteOrder::fromCommonEndian(data.teamIndex);
2141 data.playerIndex = Shared::PlatformByteOrder::fromCommonEndian(data.playerIndex);
2142 }
2143 }
2144
2145 // =====================================================
2146 // class NetworkMessageQuit
2147 // =====================================================
2148
NetworkMessageQuit()2149 NetworkMessageQuit::NetworkMessageQuit(){
2150 messageType = nmtQuit;
2151 }
2152
getPackedMessageFormat() const2153 const char * NetworkMessageQuit::getPackedMessageFormat() const {
2154 return "c";
2155 }
2156
getPackedSize()2157 unsigned int NetworkMessageQuit::getPackedSize() {
2158 static unsigned int result = 0;
2159 if(result == 0) {
2160 //Data packedData;
2161 messageType = 0;
2162 unsigned char *buf = new unsigned char[sizeof(messageType)*3];
2163 result = pack(buf, getPackedMessageFormat(),
2164 messageType);
2165 delete [] buf;
2166 }
2167 return result;
2168 }
unpackMessage(unsigned char * buf)2169 void NetworkMessageQuit::unpackMessage(unsigned char *buf) {
2170 unpack(buf, getPackedMessageFormat(),
2171 &messageType);
2172 }
2173
packMessage()2174 unsigned char * NetworkMessageQuit::packMessage() {
2175 unsigned char *buf = new unsigned char[getPackedSize()+1];
2176 pack(buf, getPackedMessageFormat(),
2177 messageType);
2178 return buf;
2179 }
2180
receive(Socket * socket)2181 bool NetworkMessageQuit::receive(Socket* socket) {
2182 bool result = false;
2183 if(useOldProtocol == true) {
2184 result = NetworkMessage::receive(socket, &messageType, sizeof(messageType),true);
2185 }
2186 else {
2187 //fromEndian();
2188 unsigned char *buf = new unsigned char[getPackedSize()+1];
2189 result = NetworkMessage::receive(socket, buf, getPackedSize(), true);
2190 unpackMessage(buf);
2191 //printf("Got packet size = %u data.messageType = %d\n%s\n",getPackedSize(),data.messageType,buf);
2192 delete [] buf;
2193 }
2194 fromEndian();
2195
2196 return result;
2197 }
2198
send(Socket * socket)2199 void NetworkMessageQuit::send(Socket* socket) {
2200 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtQuit\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
2201
2202 assert(messageType == nmtQuit);
2203 toEndian();
2204
2205 if(useOldProtocol == true) {
2206 NetworkMessage::send(socket, &messageType, sizeof(messageType));
2207 }
2208 else {
2209 unsigned char *buf = packMessage();
2210 //printf("Send packet size = %u data.messageType = %d\n[%s]\n",getPackedSize(),data.messageType,buf);
2211 NetworkMessage::send(socket, buf, getPackedSize());
2212 delete [] buf;
2213 }
2214 }
2215
toEndian()2216 void NetworkMessageQuit::toEndian() {
2217 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2218 if(bigEndianSystem == true) {
2219 messageType = Shared::PlatformByteOrder::toCommonEndian(messageType);
2220 }
2221 }
fromEndian()2222 void NetworkMessageQuit::fromEndian() {
2223 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2224 if(bigEndianSystem == true) {
2225 messageType = Shared::PlatformByteOrder::fromCommonEndian(messageType);
2226 }
2227 }
2228
2229 // =====================================================
2230 // class NetworkMessageSynchNetworkGameData
2231 // =====================================================
2232
NetworkMessageSynchNetworkGameData(const GameSettings * gameSettings)2233 NetworkMessageSynchNetworkGameData::NetworkMessageSynchNetworkGameData(const GameSettings *gameSettings)
2234 {
2235 data.messageType= nmtSynchNetworkGameData;
2236
2237 if(gameSettings == NULL) {
2238 throw std::runtime_error("gameSettings == NULL");
2239 }
2240 data.header.map = gameSettings->getMap();
2241 data.header.tileset = gameSettings->getTileset();
2242 data.header.tech = gameSettings->getTech();
2243
2244 Config &config = Config::getInstance();
2245 string scenarioDir = "";
2246 if(gameSettings->getScenarioDir() != "") {
2247 scenarioDir = gameSettings->getScenarioDir();
2248 if(EndsWith(scenarioDir, ".xml") == true) {
2249 scenarioDir = scenarioDir.erase(scenarioDir.size() - 4, 4);
2250 scenarioDir = scenarioDir.erase(scenarioDir.size() - gameSettings->getScenario().size(), gameSettings->getScenario().size() + 1);
2251 }
2252
2253 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] gameSettings.getScenarioDir() = [%s] gameSettings.getScenario() = [%s] scenarioDir = [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,gameSettings->getScenarioDir().c_str(),gameSettings->getScenario().c_str(),scenarioDir.c_str());
2254 }
2255
2256 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
2257
2258 data.header.tilesetCRC = getFolderTreeContentsCheckSumRecursively(config.getPathListForType(ptTilesets,scenarioDir), string("/") + gameSettings->getTileset() + string("/*"), ".xml", NULL);
2259
2260 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] data.tilesetCRC = %d, [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__, data.header.tilesetCRC,gameSettings->getTileset().c_str());
2261
2262 //tech, load before map because of resources
2263 data.header.techCRC = getFolderTreeContentsCheckSumRecursively(config.getPathListForType(ptTechs,scenarioDir), string("/") + gameSettings->getTech() + string("/*"), ".xml", NULL);
2264
2265 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] data.techCRC = %d, [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__, data.header.techCRC,gameSettings->getTech().c_str());
2266
2267 vector<std::pair<string,uint32> > vctFileList;
2268 vctFileList = getFolderTreeContentsCheckSumListRecursively(config.getPathListForType(ptTechs,scenarioDir),string("/") + gameSettings->getTech() + string("/*"), ".xml",&vctFileList);
2269 data.header.techCRCFileCount = min((int)vctFileList.size(),(int)maxFileCRCCount);
2270
2271 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] vctFileList.size() = %d, maxFileCRCCount = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__, vctFileList.size(),maxFileCRCCount);
2272
2273 for(int idx =0; idx < (int)data.header.techCRCFileCount; ++idx) {
2274 const std::pair<string,uint32> &fileInfo = vctFileList[idx];
2275 data.detail.techCRCFileList[idx] = fileInfo.first;
2276 data.detail.techCRCFileCRCList[idx] = fileInfo.second;
2277 }
2278
2279 //map
2280 Checksum checksum;
2281 string file = Config::getMapPath(gameSettings->getMap(),scenarioDir,false);
2282 checksum.addFile(file);
2283 data.header.mapCRC = checksum.getSum();
2284
2285 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] data.mapCRC = %d, [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__, data.header.mapCRC,gameSettings->getMap().c_str());
2286 }
2287
getTechCRCFileMismatchReport(vector<std::pair<string,uint32>> & vctFileList)2288 string NetworkMessageSynchNetworkGameData::getTechCRCFileMismatchReport(vector<std::pair<string,uint32> > &vctFileList) {
2289 string result = "Techtree: [" + data.header.tech.getString() + "] Filecount local: " + intToStr(vctFileList.size()) + " remote: " + intToStr(data.header.techCRCFileCount) + "\n";
2290 if(vctFileList.size() <= 0) {
2291 result = result + "Local player has no files.\n";
2292 }
2293 else if(data.header.techCRCFileCount <= 0) {
2294 result = result + "Remote player has no files.\n";
2295 }
2296 else {
2297 for(int idx = 0; idx < (int)vctFileList.size(); ++idx) {
2298 std::pair<string,uint32> &fileInfo = vctFileList[idx];
2299 bool fileFound = false;
2300 uint32 remoteCRC = 0;
2301 for(int j = 0; j < (int)data.header.techCRCFileCount; ++j) {
2302 string networkFile = data.detail.techCRCFileList[j].getString();
2303 uint32 &networkFileCRC = data.detail.techCRCFileCRCList[j];
2304 if(fileInfo.first == networkFile) {
2305 fileFound = true;
2306 remoteCRC = networkFileCRC;
2307 break;
2308 }
2309 }
2310
2311 if(fileFound == false) {
2312 result = result + "local file [" + fileInfo.first + "] missing remotely.\n";
2313 }
2314 else if(fileInfo.second != remoteCRC) {
2315 result = result + "local file [" + fileInfo.first + "] CRC mismatch.\n";
2316 }
2317 }
2318
2319 for(int i = 0; i < (int)data.header.techCRCFileCount; ++i) {
2320 string networkFile = data.detail.techCRCFileList[i].getString();
2321 uint32 &networkFileCRC = data.detail.techCRCFileCRCList[i];
2322 bool fileFound = false;
2323 uint32 localCRC = 0;
2324 for(int idx = 0; idx < (int)vctFileList.size(); ++idx) {
2325 std::pair<string,uint32> &fileInfo = vctFileList[idx];
2326 if(networkFile == fileInfo.first) {
2327 fileFound = true;
2328 localCRC = fileInfo.second;
2329 break;
2330 }
2331 }
2332
2333 if(fileFound == false) {
2334 result = result + "remote file [" + networkFile + "] missing locally.\n";
2335 }
2336 else if(networkFileCRC != localCRC) {
2337 result = result + "remote file [" + networkFile + "] CRC mismatch.\n";
2338 }
2339 }
2340 }
2341 return result;
2342 }
2343
getPackedMessageFormatHeader() const2344 const char * NetworkMessageSynchNetworkGameData::getPackedMessageFormatHeader() const {
2345 return "c255s255s255sLLLL";
2346 }
2347
getPackedSizeHeader()2348 unsigned int NetworkMessageSynchNetworkGameData::getPackedSizeHeader() {
2349 static unsigned int result = 0;
2350 if(result == 0) {
2351 Data packedData;
2352 unsigned char *buf = new unsigned char[sizeof(packedData)*3];
2353 result = pack(buf, getPackedMessageFormatHeader(),
2354 packedData.messageType,
2355 packedData.header.map.getBuffer(),
2356 packedData.header.tileset.getBuffer(),
2357 packedData.header.tech.getBuffer(),
2358 packedData.header.mapCRC,
2359 packedData.header.tilesetCRC,
2360 packedData.header.techCRC,
2361 packedData.header.techCRCFileCount);
2362 delete [] buf;
2363 }
2364 return result;
2365 }
unpackMessageHeader(unsigned char * buf)2366 void NetworkMessageSynchNetworkGameData::unpackMessageHeader(unsigned char *buf) {
2367 unpack(buf, getPackedMessageFormatHeader(),
2368 &data.messageType,
2369 data.header.map.getBuffer(),
2370 data.header.tileset.getBuffer(),
2371 data.header.tech.getBuffer(),
2372 &data.header.mapCRC,
2373 &data.header.tilesetCRC,
2374 &data.header.techCRC,
2375 &data.header.techCRCFileCount);
2376 }
2377
packMessageHeader()2378 unsigned char * NetworkMessageSynchNetworkGameData::packMessageHeader() {
2379 unsigned char *buf = new unsigned char[getPackedSizeHeader()+1];
2380 pack(buf, getPackedMessageFormatHeader(),
2381 data.messageType,
2382 data.header.map.getBuffer(),
2383 data.header.tileset.getBuffer(),
2384 data.header.tech.getBuffer(),
2385 data.header.mapCRC,
2386 data.header.tilesetCRC,
2387 data.header.techCRC,
2388 data.header.techCRCFileCount);
2389
2390 return buf;
2391 }
2392
getPackedSizeDetail()2393 unsigned int NetworkMessageSynchNetworkGameData::getPackedSizeDetail() {
2394 static unsigned int result = 0;
2395 if(result == 0) {
2396 DataDetail packedData;
2397 for(unsigned int index = 0; index < (unsigned int)maxFileCRCCount; ++index) {
2398 packedData.techCRCFileCRCList[index] = 0;
2399 }
2400 unsigned char *buf = new unsigned char[sizeof(DataDetail)*3];
2401
2402 for(unsigned int i = 0; i < (unsigned int)maxFileCRCCount; ++i) {
2403 result += pack(buf, "255s",
2404 packedData.techCRCFileList[i].getBuffer());
2405 buf += result;
2406 }
2407 for(unsigned int i = 0; i < (unsigned int)maxFileCRCCount; ++i) {
2408 result += pack(buf, "L",
2409 packedData.techCRCFileCRCList[i]);
2410 buf += result;
2411 }
2412
2413 delete [] buf;
2414 }
2415 return result;
2416 }
unpackMessageDetail(unsigned char * buf)2417 void NetworkMessageSynchNetworkGameData::unpackMessageDetail(unsigned char *buf) {
2418 for(unsigned int i = 0; i < (unsigned int)maxFileCRCCount; ++i) {
2419 unsigned int bytes_processed = unpack(buf, "255s",
2420 data.detail.techCRCFileList[i].getBuffer());
2421 buf += bytes_processed;
2422 }
2423 for(unsigned int i = 0; i < (unsigned int)maxFileCRCCount; ++i) {
2424 unsigned int bytes_processed = unpack(buf, "L",
2425 &data.detail.techCRCFileCRCList[i]);
2426 buf += bytes_processed;
2427 }
2428 }
2429
packMessageDetail()2430 unsigned char * NetworkMessageSynchNetworkGameData::packMessageDetail() {
2431 unsigned char *buf = new unsigned char[sizeof(DataDetail)*3 +1];
2432 unsigned char *bufMove = buf;
2433 for(unsigned int i = 0; i < (unsigned int)maxFileCRCCount; ++i) {
2434 unsigned int bytes_processed = pack(bufMove, "255s",
2435 data.detail.techCRCFileList[i].getBuffer());
2436 bufMove += bytes_processed;
2437 }
2438 for(unsigned int i = 0; i < (unsigned int)maxFileCRCCount; ++i) {
2439 unsigned int bytes_processed = pack(bufMove, "L",
2440 data.detail.techCRCFileCRCList[i]);
2441 bufMove += bytes_processed;
2442 }
2443
2444 return buf;
2445 }
2446
2447
receive(Socket * socket)2448 bool NetworkMessageSynchNetworkGameData::receive(Socket* socket) {
2449 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] about to get nmtSynchNetworkGameData\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
2450
2451 data.header.techCRCFileCount = 0;
2452 bool result = NetworkMessage::receive(socket, &data.header, HeaderSize, true);
2453 fromEndianHeader();
2454 if(result == true) {
2455 data.messageType = nmtSynchNetworkGameData;
2456 }
2457
2458 if(result == true && data.header.techCRCFileCount > 0) {
2459 data.header.map.nullTerminate();
2460 data.header.tileset.nullTerminate();
2461 data.header.tech.nullTerminate();
2462
2463 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] messageType = %d, data.techCRCFileCount = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,data.messageType,data.header.techCRCFileCount);
2464
2465
2466
2467 // Here we loop possibly multiple times
2468 int packetLoopCount = 1;
2469 if(data.header.techCRCFileCount > (uint32)NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount) {
2470 packetLoopCount = (data.header.techCRCFileCount / NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount);
2471 if(data.header.techCRCFileCount % NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount > 0) {
2472 packetLoopCount++;
2473 }
2474 }
2475
2476 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] packetLoopCount = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,packetLoopCount);
2477
2478 for(int iPacketLoop = 0; result == true && iPacketLoop < packetLoopCount; ++iPacketLoop) {
2479
2480 int packetIndex = iPacketLoop * NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount;
2481 int maxFileCountPerPacket = maxFileCRCPacketCount;
2482 int packetFileCount = min((uint32)maxFileCountPerPacket,data.header.techCRCFileCount - packetIndex);
2483 int packetDetail1DataSize = (DetailSize1 * packetFileCount);
2484 int packetDetail2DataSize = (DetailSize2 * packetFileCount);
2485
2486 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] iPacketLoop = %d, packetIndex = %d, maxFileCountPerPacket = %d, packetFileCount = %d, packetDetail1DataSize = %d, packetDetail2DataSize = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,iPacketLoop,packetIndex,maxFileCountPerPacket,packetFileCount,packetDetail1DataSize,packetDetail2DataSize);
2487
2488 // Wait a max of x seconds for this message
2489 result = NetworkMessage::receive(socket, &data.detail.techCRCFileList[packetIndex], packetDetail1DataSize, true);
2490 if(result == true) {
2491 for(unsigned int i = 0; i < data.header.techCRCFileCount; ++i) {
2492 data.detail.techCRCFileList[i].nullTerminate();
2493 }
2494
2495 result = NetworkMessage::receive(socket, &data.detail.techCRCFileCRCList[packetIndex], packetDetail2DataSize, true);
2496 }
2497 }
2498 fromEndianDetail();
2499 }
2500
2501 return result;
2502 }
2503
send(Socket * socket)2504 void NetworkMessageSynchNetworkGameData::send(Socket* socket) {
2505 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] about to send nmtSynchNetworkGameData\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
2506
2507 assert(data.messageType == nmtSynchNetworkGameData);
2508 uint32 totalFileCount = data.header.techCRCFileCount;
2509 toEndianHeader();
2510 NetworkMessage::send(socket, &data, HeaderSize);
2511 if(totalFileCount > 0) {
2512 // Here we loop possibly multiple times
2513 int packetLoopCount = 1;
2514 if(totalFileCount > (uint32)NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount) {
2515 packetLoopCount = (totalFileCount / NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount);
2516 if(totalFileCount % NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount > 0) {
2517 packetLoopCount++;
2518 }
2519 }
2520
2521 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] packetLoopCount = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,packetLoopCount);
2522
2523 for(int iPacketLoop = 0; iPacketLoop < packetLoopCount; ++iPacketLoop) {
2524
2525 int packetIndex = iPacketLoop * NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount;
2526 int maxFileCountPerPacket = maxFileCRCPacketCount;
2527 int packetFileCount = min((uint32)maxFileCountPerPacket,totalFileCount - packetIndex);
2528
2529 NetworkMessage::send(socket, &data.detail.techCRCFileList[packetIndex], (DetailSize1 * packetFileCount));
2530 NetworkMessage::send(socket, &data.detail.techCRCFileCRCList[packetIndex], (DetailSize2 * packetFileCount));
2531 }
2532 toEndianDetail(totalFileCount);
2533 }
2534 }
2535
toEndianHeader()2536 void NetworkMessageSynchNetworkGameData::toEndianHeader() {
2537 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2538 if(bigEndianSystem == true) {
2539 data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
2540 data.header.mapCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.mapCRC);
2541 data.header.tilesetCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.tilesetCRC);
2542 data.header.techCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.techCRC);
2543 data.header.techCRCFileCount = Shared::PlatformByteOrder::toCommonEndian(data.header.techCRCFileCount);
2544 }
2545 }
fromEndianHeader()2546 void NetworkMessageSynchNetworkGameData::fromEndianHeader() {
2547 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2548 if(bigEndianSystem == true) {
2549 data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
2550 data.header.mapCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.mapCRC);
2551 data.header.tilesetCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.tilesetCRC);
2552 data.header.techCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.techCRC);
2553 data.header.techCRCFileCount = Shared::PlatformByteOrder::fromCommonEndian(data.header.techCRCFileCount);
2554 }
2555 }
2556
toEndianDetail(uint32 totalFileCount)2557 void NetworkMessageSynchNetworkGameData::toEndianDetail(uint32 totalFileCount) {
2558 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2559 if(bigEndianSystem == true) {
2560 for(unsigned int i = 0; i < totalFileCount; ++i) {
2561 data.detail.techCRCFileCRCList[i] = Shared::PlatformByteOrder::toCommonEndian(data.detail.techCRCFileCRCList[i]);
2562 }
2563 }
2564 }
fromEndianDetail()2565 void NetworkMessageSynchNetworkGameData::fromEndianDetail() {
2566 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2567 if(bigEndianSystem == true) {
2568 for(unsigned int i = 0; i < data.header.techCRCFileCount; ++i) {
2569 data.detail.techCRCFileCRCList[i] = Shared::PlatformByteOrder::fromCommonEndian(data.detail.techCRCFileCRCList[i]);
2570 }
2571 }
2572 }
2573
2574 // =====================================================
2575 // class NetworkMessageSynchNetworkGameDataStatus
2576 // =====================================================
2577
NetworkMessageSynchNetworkGameDataStatus(uint32 mapCRC,uint32 tilesetCRC,uint32 techCRC,vector<std::pair<string,uint32>> & vctFileList)2578 NetworkMessageSynchNetworkGameDataStatus::NetworkMessageSynchNetworkGameDataStatus(uint32 mapCRC, uint32 tilesetCRC, uint32 techCRC, vector<std::pair<string,uint32> > &vctFileList)
2579 {
2580 data.messageType= nmtSynchNetworkGameDataStatus;
2581
2582 data.header.tilesetCRC = tilesetCRC;
2583 data.header.techCRC = techCRC;
2584 data.header.mapCRC = mapCRC;
2585
2586 data.header.techCRCFileCount = min((int)vctFileList.size(),(int)maxFileCRCCount);
2587 for(unsigned int idx =0; idx < data.header.techCRCFileCount; ++idx) {
2588 const std::pair<string,uint32> &fileInfo = vctFileList[idx];
2589 data.detail.techCRCFileList[idx] = fileInfo.first;
2590 data.detail.techCRCFileCRCList[idx] = fileInfo.second;
2591 }
2592 }
2593
getTechCRCFileMismatchReport(string techtree,vector<std::pair<string,uint32>> & vctFileList)2594 string NetworkMessageSynchNetworkGameDataStatus::getTechCRCFileMismatchReport(string techtree, vector<std::pair<string,uint32> > &vctFileList) {
2595 string result = "Techtree: [" + techtree + "] Filecount local: " + intToStr(vctFileList.size()) + " remote: " + intToStr(data.header.techCRCFileCount) + "\n";
2596 if(vctFileList.size() <= 0) {
2597 result = result + "Local player has no files.\n";
2598 }
2599 else if(data.header.techCRCFileCount <= 0) {
2600 result = result + "Remote player has no files.\n";
2601 }
2602 else {
2603 for(int idx = 0; idx < (int)vctFileList.size(); ++idx) {
2604 std::pair<string,uint32> &fileInfo = vctFileList[idx];
2605 bool fileFound = false;
2606 uint32 remoteCRC = 0;
2607 for(int j = 0; j < (int)data.header.techCRCFileCount; ++j) {
2608 string networkFile = data.detail.techCRCFileList[j].getString();
2609 uint32 &networkFileCRC = data.detail.techCRCFileCRCList[j];
2610 if(fileInfo.first == networkFile) {
2611 fileFound = true;
2612 remoteCRC = networkFileCRC;
2613 break;
2614 }
2615 }
2616
2617 if(fileFound == false) {
2618 result = result + "local file [" + fileInfo.first + "] missing remotely.\n";
2619 }
2620 else if(fileInfo.second != remoteCRC) {
2621 result = result + "local file [" + fileInfo.first + "] CRC mismatch.\n";
2622 }
2623 }
2624
2625 for(int i = 0; i < (int)data.header.techCRCFileCount; ++i) {
2626 string networkFile = data.detail.techCRCFileList[i].getString();
2627 uint32 &networkFileCRC = data.detail.techCRCFileCRCList[i];
2628 bool fileFound = false;
2629 uint32 localCRC = 0;
2630 for(int idx = 0; idx < (int)vctFileList.size(); ++idx) {
2631 std::pair<string,uint32> &fileInfo = vctFileList[idx];
2632
2633 if(networkFile == fileInfo.first) {
2634 fileFound = true;
2635 localCRC = fileInfo.second;
2636 break;
2637 }
2638 }
2639
2640 if(fileFound == false) {
2641 result = result + "remote file [" + networkFile + "] missing locally.\n";
2642 }
2643 else if(networkFileCRC != localCRC) {
2644 result = result + "remote file [" + networkFile + "] CRC mismatch.\n";
2645 }
2646 }
2647 }
2648 return result;
2649 }
2650
receive(Socket * socket)2651 bool NetworkMessageSynchNetworkGameDataStatus::receive(Socket* socket) {
2652 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] about to get nmtSynchNetworkGameDataStatus\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
2653
2654 data.header.techCRCFileCount = 0;
2655
2656 bool result = NetworkMessage::receive(socket, &data.header, HeaderSize, true);
2657 if(result == true && data.header.techCRCFileCount > 0) {
2658 fromEndianHeader();
2659 // Here we loop possibly multiple times
2660 uint32 packetLoopCount = 1;
2661 if(data.header.techCRCFileCount > NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount) {
2662 packetLoopCount = (data.header.techCRCFileCount / NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount);
2663 if(data.header.techCRCFileCount % NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount > 0) {
2664 packetLoopCount++;
2665 }
2666 }
2667
2668 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] packetLoopCount = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,packetLoopCount);
2669
2670 for(uint32 iPacketLoop = 0; iPacketLoop < packetLoopCount; ++iPacketLoop) {
2671
2672 uint32 packetIndex = iPacketLoop * NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount;
2673 uint32 maxFileCountPerPacket = maxFileCRCPacketCount;
2674 uint32 packetFileCount = min((uint32)maxFileCountPerPacket,data.header.techCRCFileCount - packetIndex);
2675
2676 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] iPacketLoop = %u, packetIndex = %u, packetFileCount = %u\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,iPacketLoop,packetIndex,packetFileCount);
2677
2678 result = NetworkMessage::receive(socket, &data.detail.techCRCFileList[packetIndex], ((uint32)DetailSize1 * packetFileCount),true);
2679 if(result == true) {
2680 for(int i = 0; i < (int)data.header.techCRCFileCount; ++i) {
2681 data.detail.techCRCFileList[i].nullTerminate();
2682 }
2683
2684 // Wait a max of x seconds for this message
2685 result = NetworkMessage::receive(socket, &data.detail.techCRCFileCRCList[packetIndex], ((uint32)DetailSize2 * packetFileCount),true);
2686 }
2687 }
2688 fromEndianDetail();
2689 }
2690
2691 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] result = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,result);
2692
2693 return result;
2694 }
2695
send(Socket * socket)2696 void NetworkMessageSynchNetworkGameDataStatus::send(Socket* socket) {
2697 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] about to send nmtSynchNetworkGameDataStatus, data.header.techCRCFileCount = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,data.header.techCRCFileCount);
2698
2699 assert(data.messageType == nmtSynchNetworkGameDataStatus);
2700 uint32 totalFileCount = data.header.techCRCFileCount;
2701 toEndianHeader();
2702 NetworkMessage::send(socket, &data, HeaderSize);
2703 if(totalFileCount > 0) {
2704 // Here we loop possibly multiple times
2705 int packetLoopCount = 1;
2706 if(totalFileCount > NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount) {
2707 packetLoopCount = (totalFileCount / NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount);
2708 if(totalFileCount % NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount > 0) {
2709 packetLoopCount++;
2710 }
2711 }
2712
2713 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] packetLoopCount = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,packetLoopCount);
2714
2715 toEndianDetail(totalFileCount);
2716 for(int iPacketLoop = 0; iPacketLoop < packetLoopCount; ++iPacketLoop) {
2717
2718 int packetIndex = iPacketLoop * NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount;
2719 int maxFileCountPerPacket = maxFileCRCPacketCount;
2720 int packetFileCount = min((uint32)maxFileCountPerPacket,totalFileCount - packetIndex);
2721
2722 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] packetLoop = %d, packetIndex = %d, packetFileCount = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,iPacketLoop,packetIndex,packetFileCount);
2723
2724 NetworkMessage::send(socket, &data.detail.techCRCFileList[packetIndex], (DetailSize1 * packetFileCount));
2725 NetworkMessage::send(socket, &data.detail.techCRCFileCRCList[packetIndex], (DetailSize2 * packetFileCount));
2726 }
2727 }
2728 }
2729
toEndianHeader()2730 void NetworkMessageSynchNetworkGameDataStatus::toEndianHeader() {
2731 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2732 if(bigEndianSystem == true) {
2733 data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
2734 data.header.mapCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.mapCRC);
2735 data.header.tilesetCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.tilesetCRC);
2736 data.header.techCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.techCRC);
2737 data.header.techCRCFileCount = Shared::PlatformByteOrder::toCommonEndian(data.header.techCRCFileCount);
2738 }
2739 }
2740
fromEndianHeader()2741 void NetworkMessageSynchNetworkGameDataStatus::fromEndianHeader() {
2742 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2743 if(bigEndianSystem == true) {
2744 data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
2745 data.header.mapCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.mapCRC);
2746 data.header.tilesetCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.tilesetCRC);
2747 data.header.techCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.techCRC);
2748 data.header.techCRCFileCount = Shared::PlatformByteOrder::fromCommonEndian(data.header.techCRCFileCount);
2749 }
2750 }
2751
toEndianDetail(uint32 totalFileCount)2752 void NetworkMessageSynchNetworkGameDataStatus::toEndianDetail(uint32 totalFileCount) {
2753 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2754 if(bigEndianSystem == true) {
2755 for(unsigned int i = 0; i < totalFileCount; ++i) {
2756 data.detail.techCRCFileCRCList[i] = Shared::PlatformByteOrder::toCommonEndian(data.detail.techCRCFileCRCList[i]);
2757 }
2758 }
2759 }
fromEndianDetail()2760 void NetworkMessageSynchNetworkGameDataStatus::fromEndianDetail() {
2761 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2762 if(bigEndianSystem == true) {
2763 for(unsigned int i = 0; i < data.header.techCRCFileCount; ++i) {
2764 data.detail.techCRCFileCRCList[i] = Shared::PlatformByteOrder::fromCommonEndian(data.detail.techCRCFileCRCList[i]);
2765 }
2766 }
2767 }
2768
2769 // =====================================================
2770 // class NetworkMessageSynchNetworkGameDataFileCRCCheck
2771 // =====================================================
2772
NetworkMessageSynchNetworkGameDataFileCRCCheck()2773 NetworkMessageSynchNetworkGameDataFileCRCCheck::NetworkMessageSynchNetworkGameDataFileCRCCheck() {
2774 messageType= nmtSynchNetworkGameDataFileCRCCheck;
2775 }
2776
NetworkMessageSynchNetworkGameDataFileCRCCheck(uint32 totalFileCount,uint32 fileIndex,uint32 fileCRC,const string fileName)2777 NetworkMessageSynchNetworkGameDataFileCRCCheck::NetworkMessageSynchNetworkGameDataFileCRCCheck(
2778 uint32 totalFileCount, uint32 fileIndex, uint32 fileCRC, const string fileName)
2779 {
2780 messageType= nmtSynchNetworkGameDataFileCRCCheck;
2781
2782 data.totalFileCount = totalFileCount;
2783 data.fileIndex = fileIndex;
2784 data.fileCRC = fileCRC;
2785 data.fileName = fileName;
2786 }
2787
getPackedMessageFormat() const2788 const char * NetworkMessageSynchNetworkGameDataFileCRCCheck::getPackedMessageFormat() const {
2789 return "cLLL256s";
2790 }
2791
getPackedSize()2792 unsigned int NetworkMessageSynchNetworkGameDataFileCRCCheck::getPackedSize() {
2793 static unsigned int result = 0;
2794 if(result == 0) {
2795 Data packedData;
2796 packedData.fileCRC = 0;
2797 packedData.fileIndex = 0;
2798 messageType = nmtSynchNetworkGameDataFileCRCCheck;
2799 packedData.totalFileCount = 0;
2800
2801 unsigned char *buf = new unsigned char[sizeof(packedData)*3];
2802 result = pack(buf, getPackedMessageFormat(),
2803 messageType,
2804 packedData.totalFileCount,
2805 packedData.fileIndex,
2806 packedData.fileCRC,
2807 packedData.fileName.getBuffer());
2808 delete [] buf;
2809 }
2810 return result;
2811 }
unpackMessage(unsigned char * buf)2812 void NetworkMessageSynchNetworkGameDataFileCRCCheck::unpackMessage(unsigned char *buf) {
2813 unpack(buf, getPackedMessageFormat(),
2814 &messageType,
2815 &data.totalFileCount,
2816 &data.fileIndex,
2817 &data.fileCRC,
2818 data.fileName.getBuffer());
2819 }
2820
packMessage()2821 unsigned char * NetworkMessageSynchNetworkGameDataFileCRCCheck::packMessage() {
2822 unsigned char *buf = new unsigned char[getPackedSize()+1];
2823 pack(buf, getPackedMessageFormat(),
2824 messageType,
2825 data.totalFileCount,
2826 data.fileIndex,
2827 data.fileCRC,
2828 data.fileName.getBuffer());
2829 return buf;
2830 }
2831
receive(Socket * socket)2832 bool NetworkMessageSynchNetworkGameDataFileCRCCheck::receive(Socket* socket) {
2833 bool result = false;
2834 if(useOldProtocol == true) {
2835 result = NetworkMessage::receive(socket, &data, sizeof(data),true);
2836 }
2837 else {
2838 unsigned char *buf = new unsigned char[getPackedSize()+1];
2839 result = NetworkMessage::receive(socket, buf, getPackedSize(), true);
2840 unpackMessage(buf);
2841 //printf("Got packet size = %u data.messageType = %d\n%s\n",getPackedSize(),data.messageType,buf);
2842 delete [] buf;
2843 }
2844 fromEndian();
2845 data.fileName.nullTerminate();
2846
2847 return result;
2848 }
2849
send(Socket * socket)2850 void NetworkMessageSynchNetworkGameDataFileCRCCheck::send(Socket* socket) {
2851 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtSynchNetworkGameDataFileCRCCheck\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
2852
2853 assert(messageType == nmtSynchNetworkGameDataFileCRCCheck);
2854 toEndian();
2855
2856 if(useOldProtocol == true) {
2857 //NetworkMessage::send(socket, &messageType, sizeof(messageType));
2858 NetworkMessage::send(socket, &data, sizeof(data), messageType);
2859 }
2860 else {
2861 unsigned char *buf = packMessage();
2862 //printf("Send packet size = %u data.messageType = %d\n[%s]\n",getPackedSize(),data.messageType,buf);
2863 NetworkMessage::send(socket, buf, getPackedSize());
2864 delete [] buf;
2865 }
2866 }
2867
toEndian()2868 void NetworkMessageSynchNetworkGameDataFileCRCCheck::toEndian() {
2869 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2870 if(bigEndianSystem == true) {
2871 messageType = Shared::PlatformByteOrder::toCommonEndian(messageType);
2872 data.totalFileCount = Shared::PlatformByteOrder::toCommonEndian(data.totalFileCount);
2873 data.fileIndex = Shared::PlatformByteOrder::toCommonEndian(data.fileIndex);
2874 data.fileCRC = Shared::PlatformByteOrder::toCommonEndian(data.fileCRC);
2875 }
2876 }
2877
fromEndian()2878 void NetworkMessageSynchNetworkGameDataFileCRCCheck::fromEndian() {
2879 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2880 if(bigEndianSystem == true) {
2881 messageType = Shared::PlatformByteOrder::fromCommonEndian(messageType);
2882 data.totalFileCount = Shared::PlatformByteOrder::fromCommonEndian(data.totalFileCount);
2883 data.fileIndex = Shared::PlatformByteOrder::fromCommonEndian(data.fileIndex);
2884 data.fileCRC = Shared::PlatformByteOrder::fromCommonEndian(data.fileCRC);
2885 }
2886 }
2887 // =====================================================
2888 // class NetworkMessageSynchNetworkGameDataFileGet
2889 // =====================================================
NetworkMessageSynchNetworkGameDataFileGet()2890 NetworkMessageSynchNetworkGameDataFileGet::NetworkMessageSynchNetworkGameDataFileGet() {
2891 messageType= nmtSynchNetworkGameDataFileGet;
2892 }
NetworkMessageSynchNetworkGameDataFileGet(const string fileName)2893 NetworkMessageSynchNetworkGameDataFileGet::NetworkMessageSynchNetworkGameDataFileGet(const string fileName) {
2894 messageType= nmtSynchNetworkGameDataFileGet;
2895 data.fileName = fileName;
2896 }
2897
getPackedMessageFormat() const2898 const char * NetworkMessageSynchNetworkGameDataFileGet::getPackedMessageFormat() const {
2899 return "c256s";
2900 }
2901
getPackedSize()2902 unsigned int NetworkMessageSynchNetworkGameDataFileGet::getPackedSize() {
2903 static unsigned int result = 0;
2904 if(result == 0) {
2905 Data packedData;
2906 messageType = nmtSynchNetworkGameDataFileGet;
2907 unsigned char *buf = new unsigned char[sizeof(packedData)*3];
2908 result = pack(buf, getPackedMessageFormat(),
2909 messageType,
2910 packedData.fileName.getBuffer());
2911 delete [] buf;
2912 }
2913 return result;
2914 }
unpackMessage(unsigned char * buf)2915 void NetworkMessageSynchNetworkGameDataFileGet::unpackMessage(unsigned char *buf) {
2916 unpack(buf, getPackedMessageFormat(),
2917 &messageType,
2918 data.fileName.getBuffer());
2919 }
2920
packMessage()2921 unsigned char * NetworkMessageSynchNetworkGameDataFileGet::packMessage() {
2922 unsigned char *buf = new unsigned char[getPackedSize()+1];
2923 pack(buf, getPackedMessageFormat(),
2924 messageType,
2925 data.fileName.getBuffer());
2926 return buf;
2927 }
2928
receive(Socket * socket)2929 bool NetworkMessageSynchNetworkGameDataFileGet::receive(Socket* socket) {
2930 bool result = false;
2931 if(useOldProtocol == true) {
2932 result = NetworkMessage::receive(socket, &data, sizeof(data),true);
2933 }
2934 else {
2935 unsigned char *buf = new unsigned char[getPackedSize()+1];
2936 result = NetworkMessage::receive(socket, buf, getPackedSize(), true);
2937 unpackMessage(buf);
2938 //printf("Got packet size = %u data.messageType = %d\n%s\n",getPackedSize(),data.messageType,buf);
2939 delete [] buf;
2940 }
2941 fromEndian();
2942 data.fileName.nullTerminate();
2943
2944 return result;
2945 }
2946
send(Socket * socket)2947 void NetworkMessageSynchNetworkGameDataFileGet::send(Socket* socket) {
2948 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtSynchNetworkGameDataFileGet\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
2949
2950 assert(messageType == nmtSynchNetworkGameDataFileGet);
2951 toEndian();
2952 if(useOldProtocol == true) {
2953 //NetworkMessage::send(socket, &messageType, sizeof(messageType));
2954 NetworkMessage::send(socket, &data, sizeof(data), messageType);
2955 }
2956 else {
2957 unsigned char *buf = packMessage();
2958 //printf("Send packet size = %u data.messageType = %d\n[%s]\n",getPackedSize(),data.messageType,buf);
2959 NetworkMessage::send(socket, buf, getPackedSize());
2960 delete [] buf;
2961 }
2962 }
2963
toEndian()2964 void NetworkMessageSynchNetworkGameDataFileGet::toEndian() {
2965 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2966 if(bigEndianSystem == true) {
2967 messageType = Shared::PlatformByteOrder::toCommonEndian(messageType);
2968 }
2969 }
fromEndian()2970 void NetworkMessageSynchNetworkGameDataFileGet::fromEndian() {
2971 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
2972 if(bigEndianSystem == true) {
2973 messageType = Shared::PlatformByteOrder::fromCommonEndian(messageType);
2974 }
2975 }
2976
2977
2978 // =====================================================
2979 // class SwitchSetupRequest
2980 // =====================================================
2981
SwitchSetupRequest()2982 SwitchSetupRequest::SwitchSetupRequest() {
2983 messageType= nmtSwitchSetupRequest;
2984 data.selectedFactionName="";
2985 data.currentSlotIndex=-1;
2986 data.toSlotIndex=-1;
2987 data.toTeam = -1;
2988 data.networkPlayerName="";
2989 data.networkPlayerStatus = npst_None;
2990 data.switchFlags = ssrft_None;
2991 data.language = "";
2992 }
2993
SwitchSetupRequest(string selectedFactionName,int8 currentFactionIndex,int8 toFactionIndex,int8 toTeam,string networkPlayerName,int8 networkPlayerStatus,int8 flags,string language)2994 SwitchSetupRequest::SwitchSetupRequest(string selectedFactionName, int8 currentFactionIndex,
2995 int8 toFactionIndex,int8 toTeam,string networkPlayerName,
2996 int8 networkPlayerStatus, int8 flags,
2997 string language) {
2998 messageType= nmtSwitchSetupRequest;
2999 data.selectedFactionName=selectedFactionName;
3000 data.currentSlotIndex=currentFactionIndex;
3001 data.toSlotIndex=toFactionIndex;
3002 data.toTeam = toTeam;
3003 data.networkPlayerName=networkPlayerName;
3004 data.networkPlayerStatus=networkPlayerStatus;
3005 data.switchFlags = flags;
3006 data.language = language;
3007 }
3008
getPackedMessageFormat() const3009 const char * SwitchSetupRequest::getPackedMessageFormat() const {
3010 return "c256sccc80scc60s";
3011 }
3012
getPackedSize()3013 unsigned int SwitchSetupRequest::getPackedSize() {
3014 static unsigned int result = 0;
3015 if(result == 0) {
3016 Data packedData;
3017 packedData.currentSlotIndex = 0;
3018 messageType = nmtSwitchSetupRequest;
3019 packedData.networkPlayerStatus = 0;
3020 packedData.switchFlags = 0;
3021 packedData.toSlotIndex = 0;
3022 packedData.toTeam = 0;
3023
3024 unsigned char *buf = new unsigned char[sizeof(Data)*3];
3025 result = pack(buf, getPackedMessageFormat(),
3026 messageType,
3027 packedData.selectedFactionName.getBuffer(),
3028 packedData.currentSlotIndex,
3029 packedData.toSlotIndex,
3030 packedData.toTeam,
3031 packedData.networkPlayerName.getBuffer(),
3032 packedData.networkPlayerStatus,
3033 packedData.switchFlags,
3034 packedData.language.getBuffer());
3035 delete [] buf;
3036 }
3037 return result;
3038 }
unpackMessage(unsigned char * buf)3039 void SwitchSetupRequest::unpackMessage(unsigned char *buf) {
3040 unpack(buf, getPackedMessageFormat(),
3041 &messageType,
3042 data.selectedFactionName.getBuffer(),
3043 &data.currentSlotIndex,
3044 &data.toSlotIndex,
3045 &data.toTeam,
3046 data.networkPlayerName.getBuffer(),
3047 &data.networkPlayerStatus,
3048 &data.switchFlags,
3049 data.language.getBuffer());
3050 }
3051
packMessage()3052 unsigned char * SwitchSetupRequest::packMessage() {
3053 unsigned char *buf = new unsigned char[getPackedSize()+1];
3054 pack(buf, getPackedMessageFormat(),
3055 messageType,
3056 data.selectedFactionName.getBuffer(),
3057 data.currentSlotIndex,
3058 data.toSlotIndex,
3059 data.toTeam,
3060 data.networkPlayerName.getBuffer(),
3061 data.networkPlayerStatus,
3062 data.switchFlags,
3063 data.language.getBuffer());
3064 return buf;
3065 }
3066
receive(Socket * socket)3067 bool SwitchSetupRequest::receive(Socket* socket) {
3068 bool result = false;
3069 if(useOldProtocol == true) {
3070
3071 result = NetworkMessage::receive(socket, &data, sizeof(data), true);
3072 if(result == true) {
3073 messageType = nmtSwitchSetupRequest;
3074 }
3075
3076 }
3077 else {
3078 //fromEndian();
3079 unsigned char *buf = new unsigned char[getPackedSize()+1];
3080 result = NetworkMessage::receive(socket, buf, getPackedSize(), true);
3081 unpackMessage(buf);
3082 //printf("Got packet size = %u data.messageType = %d\n%s\nTeam = %d faction [%s] currentFactionIndex = %d toFactionIndex = %d\n",getPackedSize(),data.messageType,buf,data.toTeam,data.selectedFactionName.getBuffer(),data.currentFactionIndex,data.toFactionIndex);
3083 delete [] buf;
3084 }
3085 fromEndian();
3086
3087 data.selectedFactionName.nullTerminate();
3088 data.networkPlayerName.nullTerminate();
3089 data.language.nullTerminate();
3090
3091 if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s Line %d] data.networkPlayerName [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,data.networkPlayerName.getString().c_str());
3092
3093 return result;
3094 }
3095
send(Socket * socket)3096 void SwitchSetupRequest::send(Socket* socket) {
3097 assert(messageType == nmtSwitchSetupRequest);
3098
3099 if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s Line %d] data.networkPlayerName [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,data.networkPlayerName.getString().c_str());
3100 toEndian();
3101
3102 if(useOldProtocol == true) {
3103 //NetworkMessage::send(socket, &messageType, sizeof(messageType));
3104 NetworkMessage::send(socket, &data, sizeof(data), messageType);
3105 }
3106 else {
3107 unsigned char *buf = packMessage();
3108 //printf("Send packet size = %u data.messageType = %d\n%s\nTeam = %d faction [%s] currentFactionIndex = %d toFactionIndex = %d\n",getPackedSize(),data.messageType,buf,data.toTeam,data.selectedFactionName.getBuffer(),data.currentFactionIndex,data.toFactionIndex);
3109 NetworkMessage::send(socket, buf, getPackedSize());
3110 delete [] buf;
3111 }
3112 }
3113
toEndian()3114 void SwitchSetupRequest::toEndian() {
3115 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
3116 if(bigEndianSystem == true) {
3117 messageType = Shared::PlatformByteOrder::toCommonEndian(messageType);
3118 data.currentSlotIndex = Shared::PlatformByteOrder::toCommonEndian(data.currentSlotIndex);
3119 data.toSlotIndex = Shared::PlatformByteOrder::toCommonEndian(data.toSlotIndex);
3120 data.toTeam = Shared::PlatformByteOrder::toCommonEndian(data.toTeam);
3121 data.networkPlayerStatus = Shared::PlatformByteOrder::toCommonEndian(data.networkPlayerStatus);
3122 data.switchFlags = Shared::PlatformByteOrder::toCommonEndian(data.switchFlags);
3123 }
3124 }
fromEndian()3125 void SwitchSetupRequest::fromEndian() {
3126 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
3127 if(bigEndianSystem == true) {
3128 messageType = Shared::PlatformByteOrder::fromCommonEndian(messageType);
3129 data.currentSlotIndex = Shared::PlatformByteOrder::fromCommonEndian(data.currentSlotIndex);
3130 data.toSlotIndex = Shared::PlatformByteOrder::fromCommonEndian(data.toSlotIndex);
3131 data.toTeam = Shared::PlatformByteOrder::fromCommonEndian(data.toTeam);
3132 data.networkPlayerStatus = Shared::PlatformByteOrder::fromCommonEndian(data.networkPlayerStatus);
3133 data.switchFlags = Shared::PlatformByteOrder::fromCommonEndian(data.switchFlags);
3134 }
3135 }
3136
3137 // =====================================================
3138 // class PlayerIndexMessage
3139 // =====================================================
PlayerIndexMessage(int16 playerIndex)3140 PlayerIndexMessage::PlayerIndexMessage(int16 playerIndex) {
3141 messageType = nmtPlayerIndexMessage;
3142 data.playerIndex=playerIndex;
3143 }
3144
getPackedMessageFormat() const3145 const char * PlayerIndexMessage::getPackedMessageFormat() const {
3146 return "ch";
3147 }
3148
getPackedSize()3149 unsigned int PlayerIndexMessage::getPackedSize() {
3150 static unsigned int result = 0;
3151 if(result == 0) {
3152 Data packedData;
3153 messageType = 0;
3154 packedData.playerIndex = 0;
3155 unsigned char *buf = new unsigned char[sizeof(packedData)*3];
3156 result = pack(buf, getPackedMessageFormat(),
3157 messageType,
3158 packedData.playerIndex);
3159 delete [] buf;
3160 }
3161 return result;
3162 }
unpackMessage(unsigned char * buf)3163 void PlayerIndexMessage::unpackMessage(unsigned char *buf) {
3164 unpack(buf, getPackedMessageFormat(),
3165 &messageType,
3166 &data.playerIndex);
3167 }
3168
packMessage()3169 unsigned char * PlayerIndexMessage::packMessage() {
3170 unsigned char *buf = new unsigned char[getPackedSize()+1];
3171 pack(buf, getPackedMessageFormat(),
3172 messageType,
3173 data.playerIndex);
3174 return buf;
3175 }
3176
receive(Socket * socket)3177 bool PlayerIndexMessage::receive(Socket* socket) {
3178 bool result = false;
3179 if(useOldProtocol == true) {
3180 result = NetworkMessage::receive(socket, &data, sizeof(data), true);
3181 if(result == true) {
3182 messageType = nmtPlayerIndexMessage;
3183 }
3184
3185 }
3186 else {
3187 //fromEndian();
3188 unsigned char *buf = new unsigned char[getPackedSize()+1];
3189 result = NetworkMessage::receive(socket, buf, getPackedSize(), true);
3190 unpackMessage(buf);
3191 //printf("Got packet size = %u data.messageType = %d\n%s\n",getPackedSize(),data.messageType,buf);
3192 delete [] buf;
3193 }
3194 fromEndian();
3195
3196 return result;
3197 }
3198
send(Socket * socket)3199 void PlayerIndexMessage::send(Socket* socket) {
3200 assert(messageType == nmtPlayerIndexMessage);
3201 toEndian();
3202
3203 if(useOldProtocol == true) {
3204 //NetworkMessage::send(socket, &messageType, sizeof(messageType));
3205 NetworkMessage::send(socket, &data, sizeof(data), messageType);
3206 }
3207 else {
3208 unsigned char *buf = packMessage();
3209 //printf("Send packet size = %u data.messageType = %d\n[%s]\n",getPackedSize(),data.messageType,buf);
3210 //NetworkMessage::send(socket, &data, sizeof(data));
3211 NetworkMessage::send(socket, buf, getPackedSize());
3212 delete [] buf;
3213 }
3214 }
3215
toEndian()3216 void PlayerIndexMessage::toEndian() {
3217 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
3218 if(bigEndianSystem == true) {
3219 messageType = Shared::PlatformByteOrder::toCommonEndian(messageType);
3220 data.playerIndex = Shared::PlatformByteOrder::toCommonEndian(data.playerIndex);
3221 }
3222 }
fromEndian()3223 void PlayerIndexMessage::fromEndian() {
3224 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
3225 if(bigEndianSystem == true) {
3226 messageType = Shared::PlatformByteOrder::fromCommonEndian(messageType);
3227 data.playerIndex = Shared::PlatformByteOrder::fromCommonEndian(data.playerIndex);
3228 }
3229 }
3230
3231 // =====================================================
3232 // class NetworkMessageLoadingStatus
3233 // =====================================================
NetworkMessageLoadingStatus(uint32 status)3234 NetworkMessageLoadingStatus::NetworkMessageLoadingStatus(uint32 status)
3235 {
3236 messageType = nmtLoadingStatusMessage;
3237 data.status=status;
3238 }
3239
getPackedMessageFormat() const3240 const char * NetworkMessageLoadingStatus::getPackedMessageFormat() const {
3241 return "cL";
3242 }
3243
getPackedSize()3244 unsigned int NetworkMessageLoadingStatus::getPackedSize() {
3245 static unsigned int result = 0;
3246 if(result == 0) {
3247 Data packedData;
3248 messageType = 0;
3249 packedData.status = 0;
3250 unsigned char *buf = new unsigned char[sizeof(packedData)*3];
3251 result = pack(buf, getPackedMessageFormat(),
3252 messageType,
3253 packedData.status);
3254 delete [] buf;
3255 }
3256 return result;
3257 }
unpackMessage(unsigned char * buf)3258 void NetworkMessageLoadingStatus::unpackMessage(unsigned char *buf) {
3259 unpack(buf, getPackedMessageFormat(),
3260 &messageType,
3261 &data.status);
3262 }
3263
packMessage()3264 unsigned char * NetworkMessageLoadingStatus::packMessage() {
3265 unsigned char *buf = new unsigned char[getPackedSize()+1];
3266 pack(buf, getPackedMessageFormat(),
3267 messageType,
3268 data.status);
3269 return buf;
3270 }
3271
receive(Socket * socket)3272 bool NetworkMessageLoadingStatus::receive(Socket* socket) {
3273 bool result = false;
3274 if(useOldProtocol == true) {
3275 result = NetworkMessage::receive(socket, &data, sizeof(data), true);
3276 if(result == true) {
3277 messageType = nmtLoadingStatusMessage;
3278 }
3279 }
3280 else {
3281 //fromEndian();
3282 unsigned char *buf = new unsigned char[getPackedSize()+1];
3283 result = NetworkMessage::receive(socket, buf, getPackedSize(), true);
3284 unpackMessage(buf);
3285 //printf("Got packet size = %u data.messageType = %d\n%s\n",getPackedSize(),data.messageType,buf);
3286 delete [] buf;
3287 }
3288 fromEndian();
3289
3290 return result;
3291 }
3292
send(Socket * socket)3293 void NetworkMessageLoadingStatus::send(Socket* socket) {
3294 assert(messageType == nmtLoadingStatusMessage);
3295 toEndian();
3296
3297 if(useOldProtocol == true) {
3298 //NetworkMessage::send(socket, &messageType, sizeof(messageType));
3299 NetworkMessage::send(socket, &data, sizeof(data), messageType);
3300 }
3301 else {
3302 unsigned char *buf = packMessage();
3303 //printf("Send packet size = %u data.messageType = %d\n[%s]\n",getPackedSize(),data.messageType,buf);
3304 NetworkMessage::send(socket, buf, getPackedSize());
3305 delete [] buf;
3306 }
3307 }
3308
toEndian()3309 void NetworkMessageLoadingStatus::toEndian() {
3310 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
3311 if(bigEndianSystem == true) {
3312 messageType = Shared::PlatformByteOrder::toCommonEndian(messageType);
3313 data.status = Shared::PlatformByteOrder::toCommonEndian(data.status);
3314 }
3315 }
fromEndian()3316 void NetworkMessageLoadingStatus::fromEndian() {
3317 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
3318 if(bigEndianSystem == true) {
3319 messageType = Shared::PlatformByteOrder::fromCommonEndian(messageType);
3320 data.status = Shared::PlatformByteOrder::fromCommonEndian(data.status);
3321 }
3322 }
3323
3324 // =====================================================
3325 // class NetworkMessageMarkCell
3326 // =====================================================
NetworkMessageMarkCell()3327 NetworkMessageMarkCell::NetworkMessageMarkCell() {
3328 messageType = nmtMarkCell;
3329 }
3330
NetworkMessageMarkCell(Vec2i target,int factionIndex,const string & text,int playerIndex)3331 NetworkMessageMarkCell::NetworkMessageMarkCell(Vec2i target, int factionIndex, const string &text, int playerIndex) {
3332 if((int)text.length() >= maxTextStringSize) {
3333 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] WARNING / ERROR - text [%s] length = %d, max = %d\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,text.c_str(),text.length(),maxTextStringSize);
3334 }
3335
3336 messageType = nmtMarkCell;
3337 data.text = text;
3338 data.targetX = target.x;
3339 data.targetY = target.y;
3340 data.factionIndex = factionIndex;
3341 data.playerIndex = playerIndex;
3342 }
3343
getCopy() const3344 NetworkMessageMarkCell * NetworkMessageMarkCell::getCopy() const {
3345 NetworkMessageMarkCell *copy = new NetworkMessageMarkCell();
3346 copy->data = this->data;
3347 return copy;
3348 }
3349
getPackedMessageFormat() const3350 const char * NetworkMessageMarkCell::getPackedMessageFormat() const {
3351 return "chhcc500s";
3352 }
3353
getPackedSize()3354 unsigned int NetworkMessageMarkCell::getPackedSize() {
3355 static unsigned int result = 0;
3356 if(result == 0) {
3357 Data packedData;
3358 packedData.factionIndex = 0;
3359 messageType = nmtMarkCell;
3360 packedData.playerIndex = 0;
3361 packedData.targetX = 0;
3362 packedData.targetY = 0;
3363
3364 unsigned char *buf = new unsigned char[sizeof(packedData)*3];
3365 result = pack(buf, getPackedMessageFormat(),
3366 messageType,
3367 packedData.targetX,
3368 packedData.targetY,
3369 packedData.factionIndex,
3370 packedData.playerIndex,
3371 packedData.text.getBuffer());
3372 delete [] buf;
3373 }
3374 return result;
3375 }
unpackMessage(unsigned char * buf)3376 void NetworkMessageMarkCell::unpackMessage(unsigned char *buf) {
3377 unpack(buf, getPackedMessageFormat(),
3378 &messageType,
3379 &data.targetX,
3380 &data.targetY,
3381 &data.factionIndex,
3382 &data.playerIndex,
3383 data.text.getBuffer());
3384
3385 }
3386
packMessage()3387 unsigned char * NetworkMessageMarkCell::packMessage() {
3388 unsigned char *buf = new unsigned char[getPackedSize()+1];
3389 pack(buf, getPackedMessageFormat(),
3390 messageType,
3391 data.targetX,
3392 data.targetY,
3393 data.factionIndex,
3394 data.playerIndex,
3395 data.text.getBuffer());
3396
3397 return buf;
3398 }
3399
receive(Socket * socket)3400 bool NetworkMessageMarkCell::receive(Socket* socket){
3401 bool result = false;
3402 if(useOldProtocol == true) {
3403 result = NetworkMessage::receive(socket, &data, sizeof(data), true);
3404 if(result == true) {
3405 messageType = nmtMarkCell;
3406 }
3407 }
3408 else {
3409 unsigned char *buf = new unsigned char[getPackedSize()+1];
3410 result = NetworkMessage::receive(socket, buf, getPackedSize(), true);
3411 unpackMessage(buf);
3412 //printf("Got packet size = %u data.messageType = %d\n%s\n",getPackedSize(),data.messageType,buf);
3413 delete [] buf;
3414 }
3415 fromEndian();
3416
3417 data.text.nullTerminate();
3418 return result;
3419 }
3420
send(Socket * socket)3421 void NetworkMessageMarkCell::send(Socket* socket) {
3422 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtMarkCell\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
3423
3424 assert(messageType == nmtMarkCell);
3425 toEndian();
3426
3427 if(useOldProtocol == true) {
3428 //NetworkMessage::send(socket, &messageType, sizeof(messageType));
3429 NetworkMessage::send(socket, &data, sizeof(data), messageType);
3430 }
3431 else {
3432 unsigned char *buf = packMessage();
3433 //printf("Send packet size = %u data.messageType = %d\n[%s]\n",getPackedSize(),data.messageType,buf);
3434 NetworkMessage::send(socket, buf, getPackedSize());
3435 delete [] buf;
3436 }
3437 }
3438
toEndian()3439 void NetworkMessageMarkCell::toEndian() {
3440 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
3441 if(bigEndianSystem == true) {
3442 messageType = Shared::PlatformByteOrder::toCommonEndian(messageType);
3443 data.targetX = Shared::PlatformByteOrder::toCommonEndian(data.targetX);
3444 data.targetY = Shared::PlatformByteOrder::toCommonEndian(data.targetY);
3445 data.factionIndex = Shared::PlatformByteOrder::toCommonEndian(data.factionIndex);
3446 data.playerIndex = Shared::PlatformByteOrder::toCommonEndian(data.playerIndex);
3447 }
3448 }
fromEndian()3449 void NetworkMessageMarkCell::fromEndian() {
3450 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
3451 if(bigEndianSystem == true) {
3452 messageType = Shared::PlatformByteOrder::fromCommonEndian(messageType);
3453 data.targetX = Shared::PlatformByteOrder::fromCommonEndian(data.targetX);
3454 data.targetY = Shared::PlatformByteOrder::fromCommonEndian(data.targetY);
3455 data.factionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.factionIndex);
3456 data.playerIndex = Shared::PlatformByteOrder::fromCommonEndian(data.playerIndex);
3457 }
3458 }
3459
3460 // =====================================================
3461 // class NetworkMessageUnMarkCell
3462 // =====================================================
3463
NetworkMessageUnMarkCell()3464 NetworkMessageUnMarkCell::NetworkMessageUnMarkCell() {
3465 messageType = nmtUnMarkCell;
3466 data.targetX = 0;
3467 data.targetY = 0;
3468 data.factionIndex = 0;
3469 }
3470
NetworkMessageUnMarkCell(Vec2i target,int factionIndex)3471 NetworkMessageUnMarkCell::NetworkMessageUnMarkCell(Vec2i target, int factionIndex) {
3472 messageType = nmtUnMarkCell;
3473 data.targetX = target.x;
3474 data.targetY = target.y;
3475 data.factionIndex = factionIndex;
3476 }
3477
getCopy() const3478 NetworkMessageUnMarkCell * NetworkMessageUnMarkCell::getCopy() const {
3479 NetworkMessageUnMarkCell *copy = new NetworkMessageUnMarkCell();
3480 copy->data = this->data;
3481 return copy;
3482 }
3483
getPackedMessageFormat() const3484 const char * NetworkMessageUnMarkCell::getPackedMessageFormat() const {
3485 return "chhc";
3486 }
3487
getPackedSize()3488 unsigned int NetworkMessageUnMarkCell::getPackedSize() {
3489 static unsigned int result = 0;
3490 if(result == 0) {
3491 Data packedData;
3492 packedData.factionIndex = 0;
3493 messageType = 0;
3494 packedData.targetX = 0;
3495 packedData.targetY = 0;
3496 unsigned char *buf = new unsigned char[sizeof(packedData)*3];
3497 result = pack(buf, getPackedMessageFormat(),
3498 messageType,
3499 packedData.targetX,
3500 packedData.targetY,
3501 packedData.factionIndex);
3502 delete [] buf;
3503 }
3504 return result;
3505 }
unpackMessage(unsigned char * buf)3506 void NetworkMessageUnMarkCell::unpackMessage(unsigned char *buf) {
3507 unpack(buf, getPackedMessageFormat(),
3508 &messageType,
3509 &data.targetX,
3510 &data.targetY,
3511 &data.factionIndex);
3512
3513 }
3514
packMessage()3515 unsigned char * NetworkMessageUnMarkCell::packMessage() {
3516 unsigned char *buf = new unsigned char[getPackedSize()+1];
3517 pack(buf, getPackedMessageFormat(),
3518 messageType,
3519 data.targetX,
3520 data.targetY,
3521 data.factionIndex);
3522
3523 return buf;
3524 }
3525
receive(Socket * socket)3526 bool NetworkMessageUnMarkCell::receive(Socket* socket){
3527 bool result = false;
3528 if(useOldProtocol == true) {
3529 result = NetworkMessage::receive(socket, &data, sizeof(data), true);
3530 if(result == true) {
3531 messageType = nmtUnMarkCell;
3532 }
3533 }
3534 else {
3535 unsigned char *buf = new unsigned char[getPackedSize()+1];
3536 result = NetworkMessage::receive(socket, buf, getPackedSize(), true);
3537 unpackMessage(buf);
3538 //printf("Got packet size = %u data.messageType = %d\n%s\n",getPackedSize(),data.messageType,buf);
3539 delete [] buf;
3540 }
3541 fromEndian();
3542
3543 return result;
3544 }
3545
send(Socket * socket)3546 void NetworkMessageUnMarkCell::send(Socket* socket) {
3547 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtUnMarkCell\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
3548
3549 assert(messageType == nmtUnMarkCell);
3550 toEndian();
3551
3552 if(useOldProtocol == true) {
3553 //NetworkMessage::send(socket, &messageType, sizeof(messageType));
3554 NetworkMessage::send(socket, &data, sizeof(data), messageType);
3555 }
3556 else {
3557 unsigned char *buf = packMessage();
3558 //printf("Send packet size = %u data.messageType = %d\n[%s]\n",getPackedSize(),data.messageType,buf);
3559 NetworkMessage::send(socket, buf, getPackedSize());
3560 delete [] buf;
3561 }
3562 }
3563
toEndian()3564 void NetworkMessageUnMarkCell::toEndian() {
3565 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
3566 if(bigEndianSystem == true) {
3567 messageType = Shared::PlatformByteOrder::toCommonEndian(messageType);
3568 data.targetX = Shared::PlatformByteOrder::toCommonEndian(data.targetX);
3569 data.targetY = Shared::PlatformByteOrder::toCommonEndian(data.targetY);
3570 data.factionIndex = Shared::PlatformByteOrder::toCommonEndian(data.factionIndex);
3571 }
3572 }
fromEndian()3573 void NetworkMessageUnMarkCell::fromEndian() {
3574 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
3575 if(bigEndianSystem == true) {
3576 messageType = Shared::PlatformByteOrder::fromCommonEndian(messageType);
3577 data.targetX = Shared::PlatformByteOrder::fromCommonEndian(data.targetX);
3578 data.targetY = Shared::PlatformByteOrder::fromCommonEndian(data.targetY);
3579 data.factionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.factionIndex);
3580 }
3581 }
3582
3583 // =====================================================
3584 // class NetworkMessageHighlightCell
3585 // =====================================================
3586
NetworkMessageHighlightCell()3587 NetworkMessageHighlightCell::NetworkMessageHighlightCell() {
3588 messageType = nmtHighlightCell;
3589 data.targetX = 0;
3590 data.targetY = 0;
3591 data.factionIndex = 0;
3592 }
3593
NetworkMessageHighlightCell(Vec2i target,int factionIndex)3594 NetworkMessageHighlightCell::NetworkMessageHighlightCell(Vec2i target, int factionIndex) {
3595 messageType = nmtHighlightCell;
3596 data.targetX = target.x;
3597 data.targetY = target.y;
3598 data.factionIndex = factionIndex;
3599 }
3600
getPackedMessageFormat() const3601 const char * NetworkMessageHighlightCell::getPackedMessageFormat() const {
3602 return "chhc";
3603 }
3604
getPackedSize()3605 unsigned int NetworkMessageHighlightCell::getPackedSize() {
3606 static unsigned int result = 0;
3607 if(result == 0) {
3608 Data packedData;
3609 packedData.factionIndex = 0;
3610 messageType = 0;
3611 packedData.targetX = 0;
3612 packedData.targetY = 0;
3613 unsigned char *buf = new unsigned char[sizeof(packedData)*3];
3614 result = pack(buf, getPackedMessageFormat(),
3615 messageType,
3616 packedData.targetX,
3617 packedData.targetY,
3618 packedData.factionIndex);
3619 delete [] buf;
3620 }
3621 return result;
3622 }
unpackMessage(unsigned char * buf)3623 void NetworkMessageHighlightCell::unpackMessage(unsigned char *buf) {
3624 unpack(buf, getPackedMessageFormat(),
3625 &messageType,
3626 &data.targetX,
3627 &data.targetY,
3628 &data.factionIndex);
3629
3630 }
3631
packMessage()3632 unsigned char * NetworkMessageHighlightCell::packMessage() {
3633 unsigned char *buf = new unsigned char[getPackedSize()+1];
3634 pack(buf, getPackedMessageFormat(),
3635 messageType,
3636 data.targetX,
3637 data.targetY,
3638 data.factionIndex);
3639
3640 return buf;
3641 }
3642
receive(Socket * socket)3643 bool NetworkMessageHighlightCell::receive(Socket* socket) {
3644 bool result = false;
3645 if(useOldProtocol == true) {
3646 result = NetworkMessage::receive(socket, &data, sizeof(data), true);
3647 if(result == true) {
3648 messageType = nmtHighlightCell;
3649 }
3650 }
3651 else {
3652 unsigned char *buf = new unsigned char[getPackedSize()+1];
3653 result = NetworkMessage::receive(socket, buf, getPackedSize(), true);
3654 unpackMessage(buf);
3655 //printf("Got packet size = %u data.messageType = %d\n%s\n",getPackedSize(),data.messageType,buf);
3656 delete [] buf;
3657 }
3658 fromEndian();
3659 return result;
3660 }
3661
send(Socket * socket)3662 void NetworkMessageHighlightCell::send(Socket* socket) {
3663 if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtMarkCell\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__);
3664
3665 assert(messageType == nmtHighlightCell);
3666 toEndian();
3667
3668 if(useOldProtocol == true) {
3669 //NetworkMessage::send(socket, &messageType, sizeof(messageType));
3670 NetworkMessage::send(socket, &data, sizeof(data), messageType);
3671 }
3672 else {
3673 unsigned char *buf = packMessage();
3674 //printf("Send packet size = %u data.messageType = %d\n[%s]\n",getPackedSize(),data.messageType,buf);
3675 NetworkMessage::send(socket, buf, getPackedSize());
3676 delete [] buf;
3677 }
3678 }
3679
toEndian()3680 void NetworkMessageHighlightCell::toEndian() {
3681 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
3682 if(bigEndianSystem == true) {
3683 messageType = Shared::PlatformByteOrder::toCommonEndian(messageType);
3684 data.targetX = Shared::PlatformByteOrder::toCommonEndian(data.targetX);
3685 data.targetY = Shared::PlatformByteOrder::toCommonEndian(data.targetY);
3686 data.factionIndex = Shared::PlatformByteOrder::toCommonEndian(data.factionIndex);
3687 }
3688 }
fromEndian()3689 void NetworkMessageHighlightCell::fromEndian() {
3690 static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
3691 if(bigEndianSystem == true) {
3692 messageType = Shared::PlatformByteOrder::fromCommonEndian(messageType);
3693 data.targetX = Shared::PlatformByteOrder::fromCommonEndian(data.targetX);
3694 data.targetY = Shared::PlatformByteOrder::fromCommonEndian(data.targetY);
3695 data.factionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.factionIndex);
3696 }
3697 }
3698
3699 }}//end namespace
3700