mirror-games/glest-source
1
0
Fork 0
mirror of https://github.com/glest/glest-source.git synced 2025-10-01 18:06:44 +02:00
Code Issues Projects Releases Wiki Activity

- initial attempt at making network messages endian friendly

Browse Source
This commit is contained in:
Mark Vejvoda
2012-11-01 00:06:23 +00:00
parent be8564acc6
commit 7010ddd153
10 changed files with 499 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
source/glest_game/network/connection_slot.cpp
View File

@@ -1276,11 +1276,11 @@ bool ConnectionSlot::updateCompleted(ConnectionSlotEvent *event) {
return (waitingForThread == false); return (waitingForThread == false);
} }
void ConnectionSlot::sendMessage(const NetworkMessage* networkMessage) { void ConnectionSlot::sendMessage(NetworkMessage* networkMessage) {
MutexSafeWrapper safeMutex(socketSynchAccessor,CODE_AT_LINE); MutexSafeWrapper safeMutex(socketSynchAccessor,CODE_AT_LINE);
// Skip text messages not intended for the players preferred language // Skip text messages not intended for the players preferred language
const NetworkMessageText *textMsg = dynamic_cast<const NetworkMessageText *>(networkMessage); NetworkMessageText *textMsg = dynamic_cast<NetworkMessageText *>(networkMessage);
if(textMsg != NULL) { if(textMsg != NULL) {
//printf("\n\n\n~~~ SERVER HAS NetworkMessageText target [%s] player [%s] msg[%s]\n\n\n",textMsg->getTargetLanguage().c_str(),this->getNetworkPlayerLanguage().c_str(), textMsg->getText().c_str()); //printf("\n\n\n~~~ SERVER HAS NetworkMessageText target [%s] player [%s] msg[%s]\n\n\n",textMsg->getTargetLanguage().c_str(),this->getNetworkPlayerLanguage().c_str(), textMsg->getText().c_str());

4
source/glest_game/network/connection_slot.h
View File

@@ -55,7 +55,7 @@ public:
int64 triggerId; int64 triggerId;
ConnectionSlot* connectionSlot; ConnectionSlot* connectionSlot;
ConnectionSlotEventType eventType; ConnectionSlotEventType eventType;
const NetworkMessage *networkMessage; NetworkMessage *networkMessage;
bool socketTriggered; bool socketTriggered;
bool eventCompleted; bool eventCompleted;
int64 eventId; int64 eventId;
@@ -171,7 +171,7 @@ public:
void signalUpdate(ConnectionSlotEvent *event); void signalUpdate(ConnectionSlotEvent *event);
bool updateCompleted(ConnectionSlotEvent *event); bool updateCompleted(ConnectionSlotEvent *event);
virtual void sendMessage(const NetworkMessage* networkMessage); virtual void sendMessage(NetworkMessage* networkMessage);
int getCurrentFrameCount() const { return currentFrameCount; } int getCurrentFrameCount() const { return currentFrameCount; }
int getCurrentLagCount() const { return currentLagCount; } int getCurrentLagCount() const { return currentLagCount; }

2
source/glest_game/network/network_interface.cpp
View File

@@ -40,7 +40,7 @@ DisplayMessageFunction NetworkInterface::pCB_DisplayMessage = NULL;
Vec3f MarkedCell::static_system_marker_color(MAGENTA.x,MAGENTA.y,MAGENTA.z); Vec3f MarkedCell::static_system_marker_color(MAGENTA.x,MAGENTA.y,MAGENTA.z);
void NetworkInterface::sendMessage(const NetworkMessage* networkMessage){ void NetworkInterface::sendMessage(NetworkMessage* networkMessage){
Socket* socket= getSocket(false); Socket* socket= getSocket(false);
networkMessage->send(socket); networkMessage->send(socket);

2
source/glest_game/network/network_interface.h
View File

@@ -203,7 +203,7 @@ public:
string getIp() const {return Socket::getIp();} string getIp() const {return Socket::getIp();}
string getHostName() const {return Socket::getHostName();} string getHostName() const {return Socket::getHostName();}
virtual void sendMessage(const NetworkMessage* networkMessage); virtual void sendMessage(NetworkMessage* networkMessage);
NetworkMessageType getNextMessageType(); NetworkMessageType getNextMessageType();
bool receiveMessage(NetworkMessage* networkMessage); bool receiveMessage(NetworkMessage* networkMessage);

442
source/glest_game/network/network_message.cpp
View File

@@ -60,7 +60,7 @@ bool NetworkMessage::receive(Socket* socket, void* data, int dataSize, bool tryR
} }
void NetworkMessage::send(Socket* socket, const void* data, int dataSize) const { void NetworkMessage::send(Socket* socket, const void* data, int dataSize) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] socket = %p, data = %p, dataSize = %d\n",__FILE__,__FUNCTION__,__LINE__,socket,data,dataSize); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] socket = %p, data = %p, dataSize = %d\n",__FILE__,__FUNCTION__,__LINE__,socket,data,dataSize);
if(socket != NULL) { if(socket != NULL) {
@@ -112,17 +112,35 @@ bool NetworkMessageIntro::receive(Socket* socket) {
data.name.nullTerminate(); data.name.nullTerminate();
data.versionString.nullTerminate(); data.versionString.nullTerminate();
data.language.nullTerminate(); data.language.nullTerminate();
fromEndian();
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] get nmtIntro, data.playerIndex = %d, data.sessionId = %d\n",__FILE__,__FUNCTION__,__LINE__,data.playerIndex,data.sessionId); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] get nmtIntro, data.playerIndex = %d, data.sessionId = %d\n",__FILE__,__FUNCTION__,__LINE__,data.playerIndex,data.sessionId);
return result; return result;
} }
void NetworkMessageIntro::send(Socket* socket) const { void NetworkMessageIntro::send(Socket* socket) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] sending nmtIntro, data.playerIndex = %d, data.sessionId = %d\n",__FILE__,__FUNCTION__,__LINE__,data.playerIndex,data.sessionId); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] sending nmtIntro, data.playerIndex = %d, data.sessionId = %d\n",__FILE__,__FUNCTION__,__LINE__,data.playerIndex,data.sessionId);
assert(data.messageType == nmtIntro); assert(data.messageType == nmtIntro);
toEndian();
NetworkMessage::send(socket, &data, sizeof(data)); NetworkMessage::send(socket, &data, sizeof(data));
} }
void NetworkMessageIntro::toEndian() {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
data.sessionId = Shared::PlatformByteOrder::toCommonEndian(data.sessionId);
data.playerIndex = Shared::PlatformByteOrder::toCommonEndian(data.playerIndex);
data.gameState = Shared::PlatformByteOrder::toCommonEndian(data.gameState);
data.externalIp = Shared::PlatformByteOrder::toCommonEndian(data.externalIp);
data.ftpPort = Shared::PlatformByteOrder::toCommonEndian(data.ftpPort);
}
void NetworkMessageIntro::fromEndian() {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
data.sessionId = Shared::PlatformByteOrder::fromCommonEndian(data.sessionId);
data.playerIndex = Shared::PlatformByteOrder::fromCommonEndian(data.playerIndex);
data.gameState = Shared::PlatformByteOrder::fromCommonEndian(data.gameState);
data.externalIp = Shared::PlatformByteOrder::fromCommonEndian(data.externalIp);
data.ftpPort = Shared::PlatformByteOrder::fromCommonEndian(data.ftpPort);
}
// ===================================================== // =====================================================
// class NetworkMessagePing // class NetworkMessagePing
// ===================================================== // =====================================================
@@ -141,16 +159,29 @@ NetworkMessagePing::NetworkMessagePing(int32 pingFrequency, int64 pingTime){
bool NetworkMessagePing::receive(Socket* socket){ bool NetworkMessagePing::receive(Socket* socket){
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true); bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
pingReceivedLocalTime = time(NULL); pingReceivedLocalTime = time(NULL);
return result; return result;
} }
void NetworkMessagePing::send(Socket* socket) const{ void NetworkMessagePing::send(Socket* socket) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtPing\n",__FILE__,__FUNCTION__,__LINE__); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtPing\n",__FILE__,__FUNCTION__,__LINE__);
assert(data.messageType==nmtPing); assert(data.messageType==nmtPing);
toEndian();
NetworkMessage::send(socket, &data, sizeof(data)); NetworkMessage::send(socket, &data, sizeof(data));
} }
void NetworkMessagePing::toEndian() {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
data.pingFrequency = Shared::PlatformByteOrder::toCommonEndian(data.pingFrequency);
data.pingTime = Shared::PlatformByteOrder::toCommonEndian(data.pingTime);
}
void NetworkMessagePing::fromEndian() {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
data.pingFrequency = Shared::PlatformByteOrder::fromCommonEndian(data.pingFrequency);
data.pingTime = Shared::PlatformByteOrder::fromCommonEndian(data.pingTime);
}
// ===================================================== // =====================================================
// class NetworkMessageReady // class NetworkMessageReady
// ===================================================== // =====================================================
@@ -165,15 +196,27 @@ NetworkMessageReady::NetworkMessageReady(uint32 checksum) {
} }
bool NetworkMessageReady::receive(Socket* socket){ bool NetworkMessageReady::receive(Socket* socket){
return NetworkMessage::receive(socket, &data, sizeof(data), true); bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
return result;
} }
void NetworkMessageReady::send(Socket* socket) const { void NetworkMessageReady::send(Socket* socket) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtReady\n",__FILE__,__FUNCTION__,__LINE__); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtReady\n",__FILE__,__FUNCTION__,__LINE__);
assert(data.messageType==nmtReady); assert(data.messageType==nmtReady);
toEndian();
NetworkMessage::send(socket, &data, sizeof(data)); NetworkMessage::send(socket, &data, sizeof(data));
} }
void NetworkMessageReady::toEndian() {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
data.checksum = Shared::PlatformByteOrder::toCommonEndian(data.checksum);
}
void NetworkMessageReady::fromEndian() {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
data.checksum = Shared::PlatformByteOrder::fromCommonEndian(data.checksum);
}
// ===================================================== // =====================================================
// class NetworkMessageLaunch // class NetworkMessageLaunch
// ===================================================== // =====================================================
@@ -321,6 +364,7 @@ vector<pair<string,uint32> > NetworkMessageLaunch::getFactionCRCList() const {
bool NetworkMessageLaunch::receive(Socket* socket) { bool NetworkMessageLaunch::receive(Socket* socket) {
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true); bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
data.description.nullTerminate(); data.description.nullTerminate();
data.map.nullTerminate(); data.map.nullTerminate();
data.tileset.nullTerminate(); data.tileset.nullTerminate();
@@ -338,16 +382,84 @@ bool NetworkMessageLaunch::receive(Socket* socket) {
return result; return result;
} }
void NetworkMessageLaunch::send(Socket* socket) const{ void NetworkMessageLaunch::send(Socket* socket) {
if(data.messageType == nmtLaunch) { if(data.messageType == nmtLaunch) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtLaunch\n",__FILE__,__FUNCTION__,__LINE__); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtLaunch\n",__FILE__,__FUNCTION__,__LINE__);
} }
else { else {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] messageType = %d\n",__FILE__,__FUNCTION__,__LINE__,data.messageType); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] messageType = %d\n",__FILE__,__FUNCTION__,__LINE__,data.messageType);
} }
toEndian();
NetworkMessage::send(socket, &data, sizeof(data)); NetworkMessage::send(socket, &data, sizeof(data));
} }
void NetworkMessageLaunch::toEndian() {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
for(int i= 0; i < GameConstants::maxPlayers; ++i){
data.networkPlayerStatuses[i] = Shared::PlatformByteOrder::toCommonEndian(data.networkPlayerStatuses[i]);
data.factionCRCList[i] = Shared::PlatformByteOrder::toCommonEndian(data.factionCRCList[i]);
data.factionControls[i] = Shared::PlatformByteOrder::toCommonEndian(data.factionControls[i]);
data.resourceMultiplierIndex[i] = Shared::PlatformByteOrder::toCommonEndian(data.resourceMultiplierIndex[i]);
data.teams[i] = Shared::PlatformByteOrder::toCommonEndian(data.teams[i]);
data.startLocationIndex[i] = Shared::PlatformByteOrder::toCommonEndian(data.startLocationIndex[i]);
}
data.mapCRC = Shared::PlatformByteOrder::toCommonEndian(data.mapCRC);
data.tilesetCRC = Shared::PlatformByteOrder::toCommonEndian(data.tilesetCRC);
data.techCRC = Shared::PlatformByteOrder::toCommonEndian(data.techCRC);
data.thisFactionIndex = Shared::PlatformByteOrder::toCommonEndian(data.thisFactionIndex);
data.factionCount = Shared::PlatformByteOrder::toCommonEndian(data.factionCount);
data.defaultResources = Shared::PlatformByteOrder::toCommonEndian(data.defaultResources);
data.defaultUnits = Shared::PlatformByteOrder::toCommonEndian(data.defaultUnits);
data.defaultVictoryConditions = Shared::PlatformByteOrder::toCommonEndian(data.defaultVictoryConditions);
data.fogOfWar = Shared::PlatformByteOrder::toCommonEndian(data.fogOfWar);
data.allowObservers = Shared::PlatformByteOrder::toCommonEndian(data.allowObservers);
data.enableObserverModeAtEndGame = Shared::PlatformByteOrder::toCommonEndian(data.enableObserverModeAtEndGame);
data.enableServerControlledAI = Shared::PlatformByteOrder::toCommonEndian(data.enableServerControlledAI);
data.networkFramePeriod = Shared::PlatformByteOrder::toCommonEndian(data.networkFramePeriod);
data.networkPauseGameForLaggedClients = Shared::PlatformByteOrder::toCommonEndian(data.networkPauseGameForLaggedClients);
data.pathFinderType = Shared::PlatformByteOrder::toCommonEndian(data.pathFinderType);
data.flagTypes1 = Shared::PlatformByteOrder::toCommonEndian(data.flagTypes1);
data.aiAcceptSwitchTeamPercentChance = Shared::PlatformByteOrder::toCommonEndian(data.aiAcceptSwitchTeamPercentChance);
data.cpuReplacementMultiplier = Shared::PlatformByteOrder::toCommonEndian(data.cpuReplacementMultiplier);
data.masterserver_admin = Shared::PlatformByteOrder::toCommonEndian(data.masterserver_admin);
data.masterserver_admin_factionIndex = Shared::PlatformByteOrder::toCommonEndian(data.masterserver_admin_factionIndex);
}
void NetworkMessageLaunch::fromEndian() {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
for(int i= 0; i < GameConstants::maxPlayers; ++i){
data.networkPlayerStatuses[i] = Shared::PlatformByteOrder::fromCommonEndian(data.networkPlayerStatuses[i]);
data.factionCRCList[i] = Shared::PlatformByteOrder::fromCommonEndian(data.factionCRCList[i]);
data.factionControls[i] = Shared::PlatformByteOrder::fromCommonEndian(data.factionControls[i]);
data.resourceMultiplierIndex[i] = Shared::PlatformByteOrder::fromCommonEndian(data.resourceMultiplierIndex[i]);
data.teams[i] = Shared::PlatformByteOrder::fromCommonEndian(data.teams[i]);
data.startLocationIndex[i] = Shared::PlatformByteOrder::fromCommonEndian(data.startLocationIndex[i]);
}
data.mapCRC = Shared::PlatformByteOrder::fromCommonEndian(data.mapCRC);
data.tilesetCRC = Shared::PlatformByteOrder::fromCommonEndian(data.tilesetCRC);
data.techCRC = Shared::PlatformByteOrder::fromCommonEndian(data.techCRC);
data.thisFactionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.thisFactionIndex);
data.factionCount = Shared::PlatformByteOrder::fromCommonEndian(data.factionCount);
data.defaultResources = Shared::PlatformByteOrder::fromCommonEndian(data.defaultResources);
data.defaultUnits = Shared::PlatformByteOrder::fromCommonEndian(data.defaultUnits);
data.defaultVictoryConditions = Shared::PlatformByteOrder::fromCommonEndian(data.defaultVictoryConditions);
data.fogOfWar = Shared::PlatformByteOrder::fromCommonEndian(data.fogOfWar);
data.allowObservers = Shared::PlatformByteOrder::fromCommonEndian(data.allowObservers);
data.enableObserverModeAtEndGame = Shared::PlatformByteOrder::fromCommonEndian(data.enableObserverModeAtEndGame);
data.enableServerControlledAI = Shared::PlatformByteOrder::fromCommonEndian(data.enableServerControlledAI);
data.networkFramePeriod = Shared::PlatformByteOrder::fromCommonEndian(data.networkFramePeriod);
data.networkPauseGameForLaggedClients = Shared::PlatformByteOrder::fromCommonEndian(data.networkPauseGameForLaggedClients);
data.pathFinderType = Shared::PlatformByteOrder::fromCommonEndian(data.pathFinderType);
data.flagTypes1 = Shared::PlatformByteOrder::fromCommonEndian(data.flagTypes1);
data.aiAcceptSwitchTeamPercentChance = Shared::PlatformByteOrder::fromCommonEndian(data.aiAcceptSwitchTeamPercentChance);
data.cpuReplacementMultiplier = Shared::PlatformByteOrder::fromCommonEndian(data.cpuReplacementMultiplier);
data.masterserver_admin = Shared::PlatformByteOrder::fromCommonEndian(data.masterserver_admin);
data.masterserver_admin_factionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.masterserver_admin_factionIndex);
}
// ===================================================== // =====================================================
// class NetworkMessageLaunch // class NetworkMessageLaunch
// ===================================================== // =====================================================
@@ -359,31 +471,18 @@ NetworkMessageCommandList::NetworkMessageCommandList(int32 frameCount) {
} }
bool NetworkMessageCommandList::addCommand(const NetworkCommand* networkCommand){ bool NetworkMessageCommandList::addCommand(const NetworkCommand* networkCommand){
// if(data.header.commandCount < maxCommandCount){
// data.commands[static_cast<int>(data.header.commandCount)]= *networkCommand;
// data.header.commandCount++;
// return true;
// }
// else {
// if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] WARNING / ERROR too many commands in commandlist data.header.commandCount = %d\n",__FILE__,__FUNCTION__,__LINE__,data.header.commandCount);
// SystemFlags::OutputDebug(SystemFlags::debugError,"In [%s::%s Line: %d] WARNING / ERROR too many commands in commandlist data.header.commandCount = %d\n",__FILE__,__FUNCTION__,__LINE__,data.header.commandCount);
// }
// return false;
data.commands.push_back(*networkCommand); data.commands.push_back(*networkCommand);
data.header.commandCount++; data.header.commandCount++;
return true; return true;
} }
bool NetworkMessageCommandList::receive(Socket* socket) { bool NetworkMessageCommandList::receive(Socket* socket) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
bool result = NetworkMessage::receive(socket, &data.header, commandListHeaderSize, true); bool result = NetworkMessage::receive(socket, &data.header, commandListHeaderSize, true);
fromEndianHeader();
if(result == true) { if(result == true) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] got header, messageType = %d, commandCount = %u, frameCount = %d\n",__FILE__,__FUNCTION__,__LINE__,data.header.messageType,data.header.commandCount,data.header.frameCount); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] got header, messageType = %d, commandCount = %u, frameCount = %d\n",__FILE__,__FUNCTION__,__LINE__,data.header.messageType,data.header.commandCount,data.header.frameCount);
// read header + data.commandCount commands.
//int totalMsgSize = commandListHeaderSize + (sizeof(NetworkCommand) * data.header.commandCount);
if(data.header.commandCount > 0) { if(data.header.commandCount > 0) {
data.commands.resize(data.header.commandCount); data.commands.resize(data.header.commandCount);
@@ -391,6 +490,7 @@ bool NetworkMessageCommandList::receive(Socket* socket) {
int totalMsgSize = (sizeof(NetworkCommand) * data.header.commandCount); int totalMsgSize = (sizeof(NetworkCommand) * data.header.commandCount);
result = NetworkMessage::receive(socket, &data.commands[0], totalMsgSize, true); result = NetworkMessage::receive(socket, &data.commands[0], totalMsgSize, true);
if(result == true) { if(result == true) {
fromEndianDetail();
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled == true) { if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled == true) {
for(int idx = 0 ; idx < data.header.commandCount; ++idx) { for(int idx = 0 ; idx < data.header.commandCount; ++idx) {
const NetworkCommand &cmd = data.commands[idx]; const NetworkCommand &cmd = data.commands[idx];
@@ -413,15 +513,16 @@ bool NetworkMessageCommandList::receive(Socket* socket) {
} }
void NetworkMessageCommandList::send(Socket* socket) const { void NetworkMessageCommandList::send(Socket* socket) {
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",__FILE__,__FUNCTION__,__LINE__,data.header.frameCount,data.header.commandCount,data.header.messageType); 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",__FILE__,__FUNCTION__,__LINE__,data.header.frameCount,data.header.commandCount,data.header.messageType);
assert(data.header.messageType==nmtCommandList); assert(data.header.messageType==nmtCommandList);
//int totalMsgSize = commandListHeaderSize + (sizeof(NetworkCommand) * data.header.commandCount); uint16 totalCommand = data.header.commandCount;
//NetworkMessage::send(socket, &data, totalMsgSize); toEndianHeader();
NetworkMessage::send(socket, &data.header, commandListHeaderSize); NetworkMessage::send(socket, &data.header, commandListHeaderSize);
if(data.header.commandCount > 0) { if(totalCommand > 0) {
NetworkMessage::send(socket, &data.commands[0], (sizeof(NetworkCommand) * data.header.commandCount)); toEndianDetail(totalCommand);
NetworkMessage::send(socket, &data.commands[0], (sizeof(NetworkCommand) * totalCommand));
} }
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled == true) { if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled == true) {
@@ -441,6 +542,34 @@ void NetworkMessageCommandList::send(Socket* socket) const {
} }
} }
void NetworkMessageCommandList::toEndianHeader() {
data.header.messageType = Shared::PlatformByteOrder::toCommonEndian(data.header.messageType);
data.header.commandCount = Shared::PlatformByteOrder::toCommonEndian(data.header.commandCount);
data.header.frameCount = Shared::PlatformByteOrder::toCommonEndian(data.header.frameCount);
}
void NetworkMessageCommandList::fromEndianHeader() {
data.header.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.header.messageType);
data.header.commandCount = Shared::PlatformByteOrder::fromCommonEndian(data.header.commandCount);
data.header.frameCount = Shared::PlatformByteOrder::fromCommonEndian(data.header.frameCount);
}
void NetworkMessageCommandList::toEndianDetail(uint16 totalCommand) {
if(totalCommand > 0) {
for(int idx = 0 ; idx < totalCommand; ++idx) {
NetworkCommand &cmd = data.commands[idx];
cmd.toEndian();
}
}
}
void NetworkMessageCommandList::fromEndianDetail() {
if(data.header.commandCount > 0) {
for(int idx = 0 ; idx < data.header.commandCount; ++idx) {
NetworkCommand &cmd = data.commands[idx];
cmd.fromEndian();
}
}
}
// ===================================================== // =====================================================
// class NetworkMessageText // class NetworkMessageText
// ===================================================== // =====================================================
@@ -466,20 +595,32 @@ NetworkMessageText * NetworkMessageText::getCopy() const {
bool NetworkMessageText::receive(Socket* socket){ bool NetworkMessageText::receive(Socket* socket){
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true); bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
data.text.nullTerminate(); data.text.nullTerminate();
data.targetLanguage.nullTerminate(); data.targetLanguage.nullTerminate();
return result; return result;
} }
void NetworkMessageText::send(Socket* socket) const{ void NetworkMessageText::send(Socket* socket) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtText\n",__FILE__,__FUNCTION__,__LINE__); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtText\n",__FILE__,__FUNCTION__,__LINE__);
assert(data.messageType==nmtText); assert(data.messageType==nmtText);
toEndian();
NetworkMessage::send(socket, &data, sizeof(data)); NetworkMessage::send(socket, &data, sizeof(data));
} }
void NetworkMessageText::toEndian() {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
data.teamIndex = Shared::PlatformByteOrder::toCommonEndian(data.teamIndex);
data.playerIndex = Shared::PlatformByteOrder::toCommonEndian(data.playerIndex);
}
void NetworkMessageText::fromEndian() {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
data.teamIndex = Shared::PlatformByteOrder::fromCommonEndian(data.teamIndex);
data.playerIndex = Shared::PlatformByteOrder::fromCommonEndian(data.playerIndex);
}
// ===================================================== // =====================================================
// class NetworkMessageQuit // class NetworkMessageQuit
// ===================================================== // =====================================================
@@ -489,16 +630,26 @@ NetworkMessageQuit::NetworkMessageQuit(){
} }
bool NetworkMessageQuit::receive(Socket* socket){ bool NetworkMessageQuit::receive(Socket* socket){
return NetworkMessage::receive(socket, &data, sizeof(data),true); bool result = NetworkMessage::receive(socket, &data, sizeof(data),true);
fromEndian();
return result;
} }
void NetworkMessageQuit::send(Socket* socket) const{ void NetworkMessageQuit::send(Socket* socket) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtQuit\n",__FILE__,__FUNCTION__,__LINE__); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtQuit\n",__FILE__,__FUNCTION__,__LINE__);
assert(data.messageType==nmtQuit); assert(data.messageType==nmtQuit);
toEndian();
NetworkMessage::send(socket, &data, sizeof(data)); NetworkMessage::send(socket, &data, sizeof(data));
} }
void NetworkMessageQuit::toEndian() {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
}
void NetworkMessageQuit::fromEndian() {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
}
// ===================================================== // =====================================================
// class NetworkMessageSynchNetworkGameData // class NetworkMessageSynchNetworkGameData
// ===================================================== // =====================================================
@@ -619,6 +770,7 @@ bool NetworkMessageSynchNetworkGameData::receive(Socket* socket) {
data.header.techCRCFileCount = 0; data.header.techCRCFileCount = 0;
bool result = NetworkMessage::receive(socket, &data, HeaderSize, true); bool result = NetworkMessage::receive(socket, &data, HeaderSize, true);
fromEndianHeader();
if(result == true && data.header.techCRCFileCount > 0) { if(result == true && data.header.techCRCFileCount > 0) {
data.header.map.nullTerminate(); data.header.map.nullTerminate();
data.header.tileset.nullTerminate(); data.header.tileset.nullTerminate();
@@ -659,22 +811,25 @@ bool NetworkMessageSynchNetworkGameData::receive(Socket* socket) {
result = NetworkMessage::receive(socket, &data.detail.techCRCFileCRCList[packetIndex], packetDetail2DataSize, true); result = NetworkMessage::receive(socket, &data.detail.techCRCFileCRCList[packetIndex], packetDetail2DataSize, true);
} }
} }
fromEndianDetail();
} }
return result; return result;
} }
void NetworkMessageSynchNetworkGameData::send(Socket* socket) const { void NetworkMessageSynchNetworkGameData::send(Socket* socket) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] about to send nmtSynchNetworkGameData\n",__FILE__,__FUNCTION__,__LINE__); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] about to send nmtSynchNetworkGameData\n",__FILE__,__FUNCTION__,__LINE__);
assert(data.header.messageType==nmtSynchNetworkGameData); assert(data.header.messageType==nmtSynchNetworkGameData);
uint32 totalFileCount = data.header.techCRCFileCount;
toEndianHeader();
NetworkMessage::send(socket, &data, HeaderSize); NetworkMessage::send(socket, &data, HeaderSize);
if(data.header.techCRCFileCount > 0) { if(totalFileCount > 0) {
// Here we loop possibly multiple times // Here we loop possibly multiple times
int packetLoopCount = 1; int packetLoopCount = 1;
if(data.header.techCRCFileCount > NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount) { if(totalFileCount > NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount) {
packetLoopCount = (data.header.techCRCFileCount / NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount); packetLoopCount = (totalFileCount / NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount);
if(data.header.techCRCFileCount % NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount > 0) { if(totalFileCount % NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount > 0) {
packetLoopCount++; packetLoopCount++;
} }
} }
@@ -685,11 +840,38 @@ void NetworkMessageSynchNetworkGameData::send(Socket* socket) const {
int packetIndex = iPacketLoop * NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount; int packetIndex = iPacketLoop * NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount;
int maxFileCountPerPacket = maxFileCRCPacketCount; int maxFileCountPerPacket = maxFileCRCPacketCount;
int packetFileCount = min((uint32)maxFileCountPerPacket,data.header.techCRCFileCount - packetIndex); int packetFileCount = min((uint32)maxFileCountPerPacket,totalFileCount - packetIndex);
NetworkMessage::send(socket, &data.detail.techCRCFileList[packetIndex], (DetailSize1 * packetFileCount)); NetworkMessage::send(socket, &data.detail.techCRCFileList[packetIndex], (DetailSize1 * packetFileCount));
NetworkMessage::send(socket, &data.detail.techCRCFileCRCList[packetIndex], (DetailSize2 * packetFileCount)); NetworkMessage::send(socket, &data.detail.techCRCFileCRCList[packetIndex], (DetailSize2 * packetFileCount));
} }
toEndianDetail(totalFileCount);
}
}
void NetworkMessageSynchNetworkGameData::toEndianHeader() {
data.header.messageType = Shared::PlatformByteOrder::toCommonEndian(data.header.messageType);
data.header.mapCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.mapCRC);
data.header.tilesetCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.tilesetCRC);
data.header.techCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.techCRC);
data.header.techCRCFileCount = Shared::PlatformByteOrder::toCommonEndian(data.header.techCRCFileCount);
}
void NetworkMessageSynchNetworkGameData::fromEndianHeader() {
data.header.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.header.messageType);
data.header.mapCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.mapCRC);
data.header.tilesetCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.tilesetCRC);
data.header.techCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.techCRC);
data.header.techCRCFileCount = Shared::PlatformByteOrder::fromCommonEndian(data.header.techCRCFileCount);
}
void NetworkMessageSynchNetworkGameData::toEndianDetail(uint32 totalFileCount) {
for(unsigned int i = 0; i < totalFileCount; ++i) {
data.detail.techCRCFileCRCList[i] = Shared::PlatformByteOrder::toCommonEndian(data.detail.techCRCFileCRCList[i]);
}
}
void NetworkMessageSynchNetworkGameData::fromEndianDetail() {
for(unsigned int i = 0; i < data.header.techCRCFileCount; ++i) {
data.detail.techCRCFileCRCList[i] = Shared::PlatformByteOrder::fromCommonEndian(data.detail.techCRCFileCRCList[i]);
} }
} }
@@ -777,6 +959,7 @@ bool NetworkMessageSynchNetworkGameDataStatus::receive(Socket* socket) {
bool result = NetworkMessage::receive(socket, &data, HeaderSize, true); bool result = NetworkMessage::receive(socket, &data, HeaderSize, true);
if(result == true && data.header.techCRCFileCount > 0) { if(result == true && data.header.techCRCFileCount > 0) {
fromEndianHeader();
// Here we loop possibly multiple times // Here we loop possibly multiple times
int packetLoopCount = 1; int packetLoopCount = 1;
if(data.header.techCRCFileCount > NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount) { if(data.header.techCRCFileCount > NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount) {
@@ -806,6 +989,7 @@ bool NetworkMessageSynchNetworkGameDataStatus::receive(Socket* socket) {
result = NetworkMessage::receive(socket, &data.detail.techCRCFileCRCList[packetIndex], (DetailSize2 * packetFileCount),true); result = NetworkMessage::receive(socket, &data.detail.techCRCFileCRCList[packetIndex], (DetailSize2 * packetFileCount),true);
} }
} }
fromEndianDetail();
} }
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] result = %d\n",__FILE__,__FUNCTION__,__LINE__,result); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] result = %d\n",__FILE__,__FUNCTION__,__LINE__,result);
@@ -813,28 +997,31 @@ bool NetworkMessageSynchNetworkGameDataStatus::receive(Socket* socket) {
return result; return result;
} }
void NetworkMessageSynchNetworkGameDataStatus::send(Socket* socket) const { void NetworkMessageSynchNetworkGameDataStatus::send(Socket* socket) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] about to send nmtSynchNetworkGameDataStatus, data.header.techCRCFileCount = %d\n",__FILE__,__FUNCTION__,__LINE__,data.header.techCRCFileCount); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] about to send nmtSynchNetworkGameDataStatus, data.header.techCRCFileCount = %d\n",__FILE__,__FUNCTION__,__LINE__,data.header.techCRCFileCount);
assert(data.header.messageType==nmtSynchNetworkGameDataStatus); assert(data.header.messageType==nmtSynchNetworkGameDataStatus);
uint32 totalFileCount = data.header.techCRCFileCount;
toEndianHeader();
NetworkMessage::send(socket, &data, HeaderSize); NetworkMessage::send(socket, &data, HeaderSize);
if(data.header.techCRCFileCount > 0) { if(totalFileCount > 0) {
// Here we loop possibly multiple times // Here we loop possibly multiple times
int packetLoopCount = 1; int packetLoopCount = 1;
if(data.header.techCRCFileCount > NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount) { if(totalFileCount > NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount) {
packetLoopCount = (data.header.techCRCFileCount / NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount); packetLoopCount = (totalFileCount / NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount);
if(data.header.techCRCFileCount % NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount > 0) { if(totalFileCount % NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount > 0) {
packetLoopCount++; packetLoopCount++;
} }
} }
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] packetLoopCount = %d\n",__FILE__,__FUNCTION__,__LINE__,packetLoopCount); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] packetLoopCount = %d\n",__FILE__,__FUNCTION__,__LINE__,packetLoopCount);
toEndianDetail(totalFileCount);
for(int iPacketLoop = 0; iPacketLoop < packetLoopCount; ++iPacketLoop) { for(int iPacketLoop = 0; iPacketLoop < packetLoopCount; ++iPacketLoop) {
int packetIndex = iPacketLoop * NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount; int packetIndex = iPacketLoop * NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount;
int maxFileCountPerPacket = maxFileCRCPacketCount; int maxFileCountPerPacket = maxFileCRCPacketCount;
int packetFileCount = min((uint32)maxFileCountPerPacket,data.header.techCRCFileCount - packetIndex); int packetFileCount = min((uint32)maxFileCountPerPacket,totalFileCount - packetIndex);
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] packetLoop = %d, packetIndex = %d, packetFileCount = %d\n",__FILE__,__FUNCTION__,__LINE__,iPacketLoop,packetIndex,packetFileCount); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] packetLoop = %d, packetIndex = %d, packetFileCount = %d\n",__FILE__,__FUNCTION__,__LINE__,iPacketLoop,packetIndex,packetFileCount);
@@ -844,6 +1031,32 @@ void NetworkMessageSynchNetworkGameDataStatus::send(Socket* socket) const {
} }
} }
void NetworkMessageSynchNetworkGameDataStatus::toEndianHeader() {
data.header.messageType = Shared::PlatformByteOrder::toCommonEndian(data.header.messageType);
data.header.mapCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.mapCRC);
data.header.tilesetCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.tilesetCRC);
data.header.techCRC = Shared::PlatformByteOrder::toCommonEndian(data.header.techCRC);
data.header.techCRCFileCount = Shared::PlatformByteOrder::toCommonEndian(data.header.techCRCFileCount);
}
void NetworkMessageSynchNetworkGameDataStatus::fromEndianHeader() {
data.header.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.header.messageType);
data.header.mapCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.mapCRC);
data.header.tilesetCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.tilesetCRC);
data.header.techCRC = Shared::PlatformByteOrder::fromCommonEndian(data.header.techCRC);
data.header.techCRCFileCount = Shared::PlatformByteOrder::fromCommonEndian(data.header.techCRCFileCount);
}
void NetworkMessageSynchNetworkGameDataStatus::toEndianDetail(uint32 totalFileCount) {
for(unsigned int i = 0; i < totalFileCount; ++i) {
data.detail.techCRCFileCRCList[i] = Shared::PlatformByteOrder::toCommonEndian(data.detail.techCRCFileCRCList[i]);
}
}
void NetworkMessageSynchNetworkGameDataStatus::fromEndianDetail() {
for(unsigned int i = 0; i < data.header.techCRCFileCount; ++i) {
data.detail.techCRCFileCRCList[i] = Shared::PlatformByteOrder::fromCommonEndian(data.detail.techCRCFileCRCList[i]);
}
}
// ===================================================== // =====================================================
// class NetworkMessageSynchNetworkGameDataFileCRCCheck // class NetworkMessageSynchNetworkGameDataFileCRCCheck
// ===================================================== // =====================================================
@@ -860,45 +1073,64 @@ NetworkMessageSynchNetworkGameDataFileCRCCheck::NetworkMessageSynchNetworkGameDa
bool NetworkMessageSynchNetworkGameDataFileCRCCheck::receive(Socket* socket) { bool NetworkMessageSynchNetworkGameDataFileCRCCheck::receive(Socket* socket) {
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true); bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
data.fileName.nullTerminate(); data.fileName.nullTerminate();
return result; return result;
} }
void NetworkMessageSynchNetworkGameDataFileCRCCheck::send(Socket* socket) const { void NetworkMessageSynchNetworkGameDataFileCRCCheck::send(Socket* socket) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtSynchNetworkGameDataFileCRCCheck\n",__FILE__,__FUNCTION__,__LINE__); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtSynchNetworkGameDataFileCRCCheck\n",__FILE__,__FUNCTION__,__LINE__);
assert(data.messageType==nmtSynchNetworkGameDataFileCRCCheck); assert(data.messageType==nmtSynchNetworkGameDataFileCRCCheck);
toEndian();
NetworkMessage::send(socket, &data, sizeof(data)); NetworkMessage::send(socket, &data, sizeof(data));
} }
void NetworkMessageSynchNetworkGameDataFileCRCCheck::toEndian() {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
data.totalFileCount = Shared::PlatformByteOrder::toCommonEndian(data.totalFileCount);
data.fileIndex = Shared::PlatformByteOrder::toCommonEndian(data.fileIndex);
data.fileCRC = Shared::PlatformByteOrder::toCommonEndian(data.fileCRC);
}
void NetworkMessageSynchNetworkGameDataFileCRCCheck::fromEndian() {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
data.totalFileCount = Shared::PlatformByteOrder::fromCommonEndian(data.totalFileCount);
data.fileIndex = Shared::PlatformByteOrder::fromCommonEndian(data.fileIndex);
data.fileCRC = Shared::PlatformByteOrder::fromCommonEndian(data.fileCRC);
}
// ===================================================== // =====================================================
// class NetworkMessageSynchNetworkGameDataFileGet // class NetworkMessageSynchNetworkGameDataFileGet
// ===================================================== // =====================================================
NetworkMessageSynchNetworkGameDataFileGet::NetworkMessageSynchNetworkGameDataFileGet(const string fileName) NetworkMessageSynchNetworkGameDataFileGet::NetworkMessageSynchNetworkGameDataFileGet(const string fileName) {
{
data.messageType= nmtSynchNetworkGameDataFileGet; data.messageType= nmtSynchNetworkGameDataFileGet;
data.fileName = fileName; data.fileName = fileName;
} }
bool NetworkMessageSynchNetworkGameDataFileGet::receive(Socket* socket) { bool NetworkMessageSynchNetworkGameDataFileGet::receive(Socket* socket) {
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true); bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
data.fileName.nullTerminate(); data.fileName.nullTerminate();
return result; return result;
} }
void NetworkMessageSynchNetworkGameDataFileGet::send(Socket* socket) const { void NetworkMessageSynchNetworkGameDataFileGet::send(Socket* socket) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtSynchNetworkGameDataFileGet\n",__FILE__,__FUNCTION__,__LINE__); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtSynchNetworkGameDataFileGet\n",__FILE__,__FUNCTION__,__LINE__);
assert(data.messageType==nmtSynchNetworkGameDataFileGet); assert(data.messageType==nmtSynchNetworkGameDataFileGet);
toEndian();
NetworkMessage::send(socket, &data, sizeof(data)); NetworkMessage::send(socket, &data, sizeof(data));
} }
void NetworkMessageSynchNetworkGameDataFileGet::toEndian() {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
}
void NetworkMessageSynchNetworkGameDataFileGet::fromEndian() {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
}
// ===================================================== // =====================================================
@@ -934,7 +1166,7 @@ SwitchSetupRequest::SwitchSetupRequest(string selectedFactionName, int8 currentF
bool SwitchSetupRequest::receive(Socket* socket) { bool SwitchSetupRequest::receive(Socket* socket) {
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true); bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
data.selectedFactionName.nullTerminate(); data.selectedFactionName.nullTerminate();
data.networkPlayerName.nullTerminate(); data.networkPlayerName.nullTerminate();
data.language.nullTerminate(); data.language.nullTerminate();
@@ -944,32 +1176,60 @@ bool SwitchSetupRequest::receive(Socket* socket) {
return result; return result;
} }
void SwitchSetupRequest::send(Socket* socket) const { void SwitchSetupRequest::send(Socket* socket) {
assert(data.messageType==nmtSwitchSetupRequest); assert(data.messageType==nmtSwitchSetupRequest);
if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s Line %d] data.networkPlayerName [%s]\n",__FILE__,__FUNCTION__,__LINE__,data.networkPlayerName.getString().c_str()); if(SystemFlags::VERBOSE_MODE_ENABLED) printf("In [%s::%s Line %d] data.networkPlayerName [%s]\n",__FILE__,__FUNCTION__,__LINE__,data.networkPlayerName.getString().c_str());
toEndian();
NetworkMessage::send(socket, &data, sizeof(data)); NetworkMessage::send(socket, &data, sizeof(data));
} }
void SwitchSetupRequest::toEndian() {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
data.currentFactionIndex = Shared::PlatformByteOrder::toCommonEndian(data.currentFactionIndex);
data.toFactionIndex = Shared::PlatformByteOrder::toCommonEndian(data.toFactionIndex);
data.toTeam = Shared::PlatformByteOrder::toCommonEndian(data.toTeam);
data.networkPlayerStatus = Shared::PlatformByteOrder::toCommonEndian(data.networkPlayerStatus);
data.switchFlags = Shared::PlatformByteOrder::toCommonEndian(data.switchFlags);
}
void SwitchSetupRequest::fromEndian() {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
data.currentFactionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.currentFactionIndex);
data.toFactionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.toFactionIndex);
data.toTeam = Shared::PlatformByteOrder::fromCommonEndian(data.toTeam);
data.networkPlayerStatus = Shared::PlatformByteOrder::fromCommonEndian(data.networkPlayerStatus);
data.switchFlags = Shared::PlatformByteOrder::fromCommonEndian(data.switchFlags);
}
// ===================================================== // =====================================================
// class PlayerIndexMessage // class PlayerIndexMessage
// ===================================================== // =====================================================
PlayerIndexMessage::PlayerIndexMessage(int16 playerIndex) PlayerIndexMessage::PlayerIndexMessage(int16 playerIndex) {
{
data.messageType= nmtPlayerIndexMessage; data.messageType= nmtPlayerIndexMessage;
data.playerIndex=playerIndex; data.playerIndex=playerIndex;
} }
bool PlayerIndexMessage::receive(Socket* socket) { bool PlayerIndexMessage::receive(Socket* socket) {
return NetworkMessage::receive(socket, &data, sizeof(data), true); bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
return result;
} }
void PlayerIndexMessage::send(Socket* socket) const { void PlayerIndexMessage::send(Socket* socket) {
assert(data.messageType==nmtPlayerIndexMessage); assert(data.messageType==nmtPlayerIndexMessage);
toEndian();
NetworkMessage::send(socket, &data, sizeof(data)); NetworkMessage::send(socket, &data, sizeof(data));
} }
void PlayerIndexMessage::toEndian() {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
data.playerIndex = Shared::PlatformByteOrder::toCommonEndian(data.playerIndex);
}
void PlayerIndexMessage::fromEndian() {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
data.playerIndex = Shared::PlatformByteOrder::fromCommonEndian(data.playerIndex);
}
// ===================================================== // =====================================================
// class NetworkMessageLoadingStatus // class NetworkMessageLoadingStatus
// ===================================================== // =====================================================
@@ -980,15 +1240,26 @@ NetworkMessageLoadingStatus::NetworkMessageLoadingStatus(uint32 status)
} }
bool NetworkMessageLoadingStatus::receive(Socket* socket) { bool NetworkMessageLoadingStatus::receive(Socket* socket) {
return NetworkMessage::receive(socket, &data, sizeof(data), true); bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
return result;
} }
void NetworkMessageLoadingStatus::send(Socket* socket) const void NetworkMessageLoadingStatus::send(Socket* socket) {
{
assert(data.messageType==nmtLoadingStatusMessage); assert(data.messageType==nmtLoadingStatusMessage);
toEndian();
NetworkMessage::send(socket, &data, sizeof(data)); NetworkMessage::send(socket, &data, sizeof(data));
} }
void NetworkMessageLoadingStatus::toEndian() {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
data.status = Shared::PlatformByteOrder::toCommonEndian(data.status);
}
void NetworkMessageLoadingStatus::fromEndian() {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
data.status = Shared::PlatformByteOrder::fromCommonEndian(data.status);
}
// ===================================================== // =====================================================
// class NetworkMessageMarkCell // class NetworkMessageMarkCell
// ===================================================== // =====================================================
@@ -1014,17 +1285,34 @@ NetworkMessageMarkCell * NetworkMessageMarkCell::getCopy() const {
bool NetworkMessageMarkCell::receive(Socket* socket){ bool NetworkMessageMarkCell::receive(Socket* socket){
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true); bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
data.text.nullTerminate(); data.text.nullTerminate();
return result; return result;
} }
void NetworkMessageMarkCell::send(Socket* socket) const{ void NetworkMessageMarkCell::send(Socket* socket) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtMarkCell\n",__FILE__,__FUNCTION__,__LINE__); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtMarkCell\n",__FILE__,__FUNCTION__,__LINE__);
assert(data.messageType == nmtMarkCell); assert(data.messageType == nmtMarkCell);
toEndian();
NetworkMessage::send(socket, &data, sizeof(data)); NetworkMessage::send(socket, &data, sizeof(data));
} }
void NetworkMessageMarkCell::toEndian() {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
data.targetX = Shared::PlatformByteOrder::toCommonEndian(data.targetX);
data.targetY = Shared::PlatformByteOrder::toCommonEndian(data.targetY);
data.factionIndex = Shared::PlatformByteOrder::toCommonEndian(data.factionIndex);
data.playerIndex = Shared::PlatformByteOrder::toCommonEndian(data.playerIndex);
}
void NetworkMessageMarkCell::fromEndian() {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
data.targetX = Shared::PlatformByteOrder::fromCommonEndian(data.targetX);
data.targetY = Shared::PlatformByteOrder::fromCommonEndian(data.targetY);
data.factionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.factionIndex);
data.playerIndex = Shared::PlatformByteOrder::fromCommonEndian(data.playerIndex);
}
// ===================================================== // =====================================================
// class NetworkMessageUnMarkCell // class NetworkMessageUnMarkCell
// ===================================================== // =====================================================
@@ -1044,16 +1332,31 @@ NetworkMessageUnMarkCell * NetworkMessageUnMarkCell::getCopy() const {
bool NetworkMessageUnMarkCell::receive(Socket* socket){ bool NetworkMessageUnMarkCell::receive(Socket* socket){
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true); bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
return result; return result;
} }
void NetworkMessageUnMarkCell::send(Socket* socket) const{ void NetworkMessageUnMarkCell::send(Socket* socket) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtUnMarkCell\n",__FILE__,__FUNCTION__,__LINE__); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtUnMarkCell\n",__FILE__,__FUNCTION__,__LINE__);
assert(data.messageType == nmtUnMarkCell); assert(data.messageType == nmtUnMarkCell);
toEndian();
NetworkMessage::send(socket, &data, sizeof(data)); NetworkMessage::send(socket, &data, sizeof(data));
} }
void NetworkMessageUnMarkCell::toEndian() {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
data.targetX = Shared::PlatformByteOrder::toCommonEndian(data.targetX);
data.targetY = Shared::PlatformByteOrder::toCommonEndian(data.targetY);
data.factionIndex = Shared::PlatformByteOrder::toCommonEndian(data.factionIndex);
}
void NetworkMessageUnMarkCell::fromEndian() {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
data.targetX = Shared::PlatformByteOrder::fromCommonEndian(data.targetX);
data.targetY = Shared::PlatformByteOrder::fromCommonEndian(data.targetY);
data.factionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.factionIndex);
}
// ===================================================== // =====================================================
// class NetworkMessageHighlightCell // class NetworkMessageHighlightCell
// ===================================================== // =====================================================
@@ -1066,18 +1369,31 @@ NetworkMessageHighlightCell::NetworkMessageHighlightCell(Vec2i target, int facti
data.factionIndex = factionIndex; data.factionIndex = factionIndex;
} }
bool NetworkMessageHighlightCell::receive(Socket* socket){ bool NetworkMessageHighlightCell::receive(Socket* socket){
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true); bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
return result; return result;
} }
void NetworkMessageHighlightCell::send(Socket* socket) const{ void NetworkMessageHighlightCell::send(Socket* socket) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtMarkCell\n",__FILE__,__FUNCTION__,__LINE__); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtMarkCell\n",__FILE__,__FUNCTION__,__LINE__);
assert(data.messageType == nmtHighlightCell); assert(data.messageType == nmtHighlightCell);
toEndian();
NetworkMessage::send(socket, &data, sizeof(data)); NetworkMessage::send(socket, &data, sizeof(data));
} }
void NetworkMessageHighlightCell::toEndian() {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
data.targetX = Shared::PlatformByteOrder::toCommonEndian(data.targetX);
data.targetY = Shared::PlatformByteOrder::toCommonEndian(data.targetY);
data.factionIndex = Shared::PlatformByteOrder::toCommonEndian(data.factionIndex);
}
void NetworkMessageHighlightCell::fromEndian() {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
data.targetX = Shared::PlatformByteOrder::fromCommonEndian(data.targetX);
data.targetY = Shared::PlatformByteOrder::fromCommonEndian(data.targetY);
data.factionIndex = Shared::PlatformByteOrder::fromCommonEndian(data.factionIndex);
}
}}//end namespace }}//end namespace

87
source/glest_game/network/network_message.h
View File

@@ -15,6 +15,7 @@
#include "socket.h" #include "socket.h"
#include "game_constants.h" #include "game_constants.h"
#include "network_types.h" #include "network_types.h"
#include "byte_order.h"
#include "leak_dumper.h" #include "leak_dumper.h"
using Shared::Platform::Socket; using Shared::Platform::Socket;
@@ -68,12 +69,12 @@ class NetworkMessage {
public: public:
virtual ~NetworkMessage(){} virtual ~NetworkMessage(){}
virtual bool receive(Socket* socket)= 0; virtual bool receive(Socket* socket)= 0;
virtual void send(Socket* socket) const = 0; virtual void send(Socket* socket) = 0;
protected: protected:
//bool peek(Socket* socket, void* data, int dataSize); //bool peek(Socket* socket, void* data, int dataSize);
bool receive(Socket* socket, void* data, int dataSize,bool tryReceiveUntilDataSizeMet); bool receive(Socket* socket, void* data, int dataSize,bool tryReceiveUntilDataSizeMet);
void send(Socket* socket, const void* data, int dataSize) const; void send(Socket* socket, const void* data, int dataSize);
}; };
// ===================================================== // =====================================================
@@ -101,6 +102,8 @@ private:
uint32 ftpPort; uint32 ftpPort;
NetworkString<maxLanguageStringSize> language; NetworkString<maxLanguageStringSize> language;
}; };
void toEndian();
void fromEndian();
private: private:
Data data; Data data;
@@ -121,7 +124,7 @@ public:
string getPlayerLanguage() const { return data.language.getString(); } string getPlayerLanguage() const { return data.language.getString(); }
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
}; };
#pragma pack(pop) #pragma pack(pop)
@@ -139,6 +142,8 @@ private:
int32 pingFrequency; int32 pingFrequency;
int64 pingTime; int64 pingTime;
}; };
void toEndian();
void fromEndian();
private: private:
Data data; Data data;
@@ -153,7 +158,7 @@ public:
int64 getPingReceivedLocalTime() const { return pingReceivedLocalTime; } int64 getPingReceivedLocalTime() const { return pingReceivedLocalTime; }
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
}; };
#pragma pack(pop) #pragma pack(pop)
@@ -170,6 +175,8 @@ private:
int8 messageType; int8 messageType;
uint32 checksum; uint32 checksum;
}; };
void toEndian();
void fromEndian();
private: private:
Data data; Data data;
@@ -181,7 +188,7 @@ public:
uint32 getChecksum() const {return data.checksum;} uint32 getChecksum() const {return data.checksum;}
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
}; };
#pragma pack(pop) #pragma pack(pop)
@@ -243,6 +250,8 @@ private:
NetworkString<maxStringSize> scenario; NetworkString<maxStringSize> scenario;
}; };
void toEndian();
void fromEndian();
private: private:
Data data; Data data;
@@ -260,7 +269,7 @@ public:
vector<pair<string,uint32> > getFactionCRCList() const; vector<pair<string,uint32> > getFactionCRCList() const;
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
}; };
#pragma pack(pop) #pragma pack(pop)
@@ -270,8 +279,6 @@ public:
// Message to order a commands to several units // Message to order a commands to several units
// ===================================================== // =====================================================
//const int32 commandListHeaderSize = 6;
#pragma pack(push, 1) #pragma pack(push, 1)
class NetworkMessageCommandList: public NetworkMessage { class NetworkMessageCommandList: public NetworkMessage {
private: private:
@@ -291,6 +298,10 @@ private:
//NetworkCommand commands[maxCommandCount]; //NetworkCommand commands[maxCommandCount];
std::vector<NetworkCommand> commands; std::vector<NetworkCommand> commands;
}; };
void toEndianHeader();
void fromEndianHeader();
void toEndianDetail(uint16 totalCommand);
void fromEndianDetail();
private: private:
Data data; Data data;
@@ -306,7 +317,7 @@ public:
const NetworkCommand* getCommand(int i) const {return &data.commands[i];} const NetworkCommand* getCommand(int i) const {return &data.commands[i];}
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
}; };
#pragma pack(pop) #pragma pack(pop)
@@ -329,6 +340,8 @@ private:
int8 playerIndex; int8 playerIndex;
NetworkString<maxLanguageStringSize> targetLanguage; NetworkString<maxLanguageStringSize> targetLanguage;
}; };
void toEndian();
void fromEndian();
private: private:
Data data; Data data;
@@ -344,7 +357,7 @@ public:
string getTargetLanguage() const {return data.targetLanguage.getString();} string getTargetLanguage() const {return data.targetLanguage.getString();}
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
NetworkMessageText * getCopy() const; NetworkMessageText * getCopy() const;
}; };
#pragma pack(pop) #pragma pack(pop)
@@ -361,6 +374,8 @@ private:
struct Data{ struct Data{
int8 messageType; int8 messageType;
}; };
void toEndian();
void fromEndian();
private: private:
Data data; Data data;
@@ -369,7 +384,7 @@ public:
NetworkMessageQuit(); NetworkMessageQuit();
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
}; };
#pragma pack(pop) #pragma pack(pop)
@@ -418,6 +433,10 @@ private:
DataHeader header; DataHeader header;
DataDetail detail; DataDetail detail;
}; };
void toEndianHeader();
void fromEndianHeader();
void toEndianDetail(uint32 totalFileCount);
void fromEndianDetail();
private: private:
Data data; Data data;
@@ -427,7 +446,7 @@ public:
NetworkMessageSynchNetworkGameData(const GameSettings *gameSettings); NetworkMessageSynchNetworkGameData(const GameSettings *gameSettings);
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
string getMap() const {return data.header.map.getString();} string getMap() const {return data.header.map.getString();}
string getTileset() const {return data.header.tileset.getString();} string getTileset() const {return data.header.tileset.getString();}
@@ -485,6 +504,10 @@ private:
DataHeader header; DataHeader header;
DataDetail detail; DataDetail detail;
}; };
void toEndianHeader();
void fromEndianHeader();
void toEndianDetail(uint32 totalFileCount);
void fromEndianDetail();
private: private:
Data data; Data data;
@@ -494,7 +517,7 @@ public:
NetworkMessageSynchNetworkGameDataStatus(uint32 mapCRC, uint32 tilesetCRC, uint32 techCRC, vector<std::pair<string,uint32> > &vctFileList); NetworkMessageSynchNetworkGameDataStatus(uint32 mapCRC, uint32 tilesetCRC, uint32 techCRC, vector<std::pair<string,uint32> > &vctFileList);
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
uint32 getMapCRC() const {return data.header.mapCRC;} uint32 getMapCRC() const {return data.header.mapCRC;}
uint32 getTilesetCRC() const {return data.header.tilesetCRC;} uint32 getTilesetCRC() const {return data.header.tilesetCRC;}
@@ -531,6 +554,8 @@ private:
uint32 fileCRC; uint32 fileCRC;
NetworkString<maxStringSize> fileName; NetworkString<maxStringSize> fileName;
}; };
void toEndian();
void fromEndian();
private: private:
Data data; Data data;
@@ -540,7 +565,7 @@ public:
NetworkMessageSynchNetworkGameDataFileCRCCheck(uint32 totalFileCount, uint32 fileIndex, uint32 fileCRC, const string fileName); NetworkMessageSynchNetworkGameDataFileCRCCheck(uint32 totalFileCount, uint32 fileIndex, uint32 fileCRC, const string fileName);
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
uint32 getTotalFileCount() const {return data.totalFileCount;} uint32 getTotalFileCount() const {return data.totalFileCount;}
uint32 getFileIndex() const {return data.fileIndex;} uint32 getFileIndex() const {return data.fileIndex;}
@@ -568,6 +593,8 @@ private:
NetworkString<maxStringSize> fileName; NetworkString<maxStringSize> fileName;
}; };
void toEndian();
void fromEndian();
private: private:
Data data; Data data;
@@ -577,7 +604,7 @@ public:
NetworkMessageSynchNetworkGameDataFileGet(const string fileName); NetworkMessageSynchNetworkGameDataFileGet(const string fileName);
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
string getFileName() const {return data.fileName.getString();} string getFileName() const {return data.fileName.getString();}
}; };
@@ -619,6 +646,8 @@ private:
int8 switchFlags; int8 switchFlags;
NetworkString<maxLanguageStringSize> language; NetworkString<maxLanguageStringSize> language;
}; };
void toEndian();
void fromEndian();
private: private:
Data data; Data data;
@@ -643,7 +672,7 @@ public:
string getNetworkPlayerLanguage() const { return data.language.getString(); } string getNetworkPlayerLanguage() const { return data.language.getString(); }
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
}; };
#pragma pack(pop) #pragma pack(pop)
@@ -658,10 +687,12 @@ public:
class PlayerIndexMessage: public NetworkMessage{ class PlayerIndexMessage: public NetworkMessage{
private: private:
struct Data{ struct Data {
int8 messageType; int8 messageType;
int16 playerIndex; int16 playerIndex;
}; };
void toEndian();
void fromEndian();
private: private:
Data data; Data data;
@@ -672,7 +703,7 @@ public:
int16 getPlayerIndex() const {return data.playerIndex;} int16 getPlayerIndex() const {return data.playerIndex;}
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
}; };
#pragma pack(pop) #pragma pack(pop)
@@ -707,10 +738,12 @@ enum NetworkMessageLoadingStatusType {
#pragma pack(push, 1) #pragma pack(push, 1)
class NetworkMessageLoadingStatus : public NetworkMessage { class NetworkMessageLoadingStatus : public NetworkMessage {
private: private:
struct Data{ struct Data {
int8 messageType; int8 messageType;
uint32 status; uint32 status;
}; };
void toEndian();
void fromEndian();
private: private:
Data data; Data data;
@@ -722,7 +755,7 @@ public:
uint32 getStatus() const {return data.status;} uint32 getStatus() const {return data.status;}
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
}; };
#pragma pack(pop) #pragma pack(pop)
@@ -748,6 +781,8 @@ private:
int8 playerIndex; int8 playerIndex;
NetworkString<maxTextStringSize> text; NetworkString<maxTextStringSize> text;
}; };
void toEndian();
void fromEndian();
private: private:
Data data; Data data;
@@ -762,7 +797,7 @@ public:
int getPlayerIndex() const { return data.playerIndex; } int getPlayerIndex() const { return data.playerIndex; }
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
NetworkMessageMarkCell * getCopy() const; NetworkMessageMarkCell * getCopy() const;
}; };
#pragma pack(pop) #pragma pack(pop)
@@ -777,13 +812,15 @@ public:
class NetworkMessageUnMarkCell: public NetworkMessage { class NetworkMessageUnMarkCell: public NetworkMessage {
private: private:
struct Data{ struct Data {
int8 messageType; int8 messageType;
int16 targetX; int16 targetX;
int16 targetY; int16 targetY;
int8 factionIndex; int8 factionIndex;
}; };
void toEndian();
void fromEndian();
private: private:
Data data; Data data;
@@ -796,7 +833,7 @@ public:
int getFactionIndex() const { return data.factionIndex; } int getFactionIndex() const { return data.factionIndex; }
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
NetworkMessageUnMarkCell * getCopy() const; NetworkMessageUnMarkCell * getCopy() const;
}; };
#pragma pack(pop) #pragma pack(pop)
@@ -821,6 +858,8 @@ private:
int16 targetY; int16 targetY;
int8 factionIndex; int8 factionIndex;
}; };
void toEndian();
void fromEndian();
private: private:
Data data; Data data;
@@ -833,7 +872,7 @@ public:
int getFactionIndex() const { return data.factionIndex; } int getFactionIndex() const { return data.factionIndex; }
virtual bool receive(Socket* socket); virtual bool receive(Socket* socket);
virtual void send(Socket* socket) const; virtual void send(Socket* socket);
}; };
#pragma pack(pop) #pragma pack(pop)

34
source/glest_game/network/network_types.cpp
View File

@@ -98,6 +98,40 @@ string NetworkCommand::toString() const {
return result; return result;
} }
void NetworkCommand::toEndian() {
networkCommandType = Shared::PlatformByteOrder::toCommonEndian(networkCommandType);
unitId = Shared::PlatformByteOrder::toCommonEndian(unitId);
unitTypeId = Shared::PlatformByteOrder::toCommonEndian(unitTypeId);
commandTypeId = Shared::PlatformByteOrder::toCommonEndian(commandTypeId);
positionX = Shared::PlatformByteOrder::toCommonEndian(positionX);
positionY = Shared::PlatformByteOrder::toCommonEndian(positionY);
targetId = Shared::PlatformByteOrder::toCommonEndian(targetId);
wantQueue = Shared::PlatformByteOrder::toCommonEndian(wantQueue);
fromFactionIndex = Shared::PlatformByteOrder::toCommonEndian(fromFactionIndex);
unitFactionUnitCount = Shared::PlatformByteOrder::toCommonEndian(unitFactionUnitCount);
unitFactionIndex = Shared::PlatformByteOrder::toCommonEndian(unitFactionIndex);
commandStateType = Shared::PlatformByteOrder::toCommonEndian(commandStateType);
commandStateValue = Shared::PlatformByteOrder::toCommonEndian(commandStateValue);
unitCommandGroupId = Shared::PlatformByteOrder::toCommonEndian(unitCommandGroupId);
}
void NetworkCommand::fromEndian() {
networkCommandType = Shared::PlatformByteOrder::fromCommonEndian(networkCommandType);
unitId = Shared::PlatformByteOrder::fromCommonEndian(unitId);
unitTypeId = Shared::PlatformByteOrder::fromCommonEndian(unitTypeId);
commandTypeId = Shared::PlatformByteOrder::fromCommonEndian(commandTypeId);
positionX = Shared::PlatformByteOrder::fromCommonEndian(positionX);
positionY = Shared::PlatformByteOrder::fromCommonEndian(positionY);
targetId = Shared::PlatformByteOrder::fromCommonEndian(targetId);
wantQueue = Shared::PlatformByteOrder::fromCommonEndian(wantQueue);
fromFactionIndex = Shared::PlatformByteOrder::fromCommonEndian(fromFactionIndex);
unitFactionUnitCount = Shared::PlatformByteOrder::fromCommonEndian(unitFactionUnitCount);
unitFactionIndex = Shared::PlatformByteOrder::fromCommonEndian(unitFactionIndex);
commandStateType = Shared::PlatformByteOrder::fromCommonEndian(commandStateType);
commandStateValue = Shared::PlatformByteOrder::fromCommonEndian(commandStateValue);
unitCommandGroupId = Shared::PlatformByteOrder::fromCommonEndian(unitCommandGroupId);
}
XmlNode * NetworkCommand::saveGame(XmlNode *rootNode) { XmlNode * NetworkCommand::saveGame(XmlNode *rootNode) {
std::map<string,string> mapTagReplacements; std::map<string,string> mapTagReplacements;
XmlNode *networkCommandNode = rootNode->addChild("NetworkCommand"); XmlNode *networkCommandNode = rootNode->addChild("NetworkCommand");

3
source/glest_game/network/network_types.h
View File

@@ -153,6 +153,9 @@ public:
void preprocessNetworkCommand(World *world); void preprocessNetworkCommand(World *world);
string toString() const; string toString() const;
void toEndian();
void fromEndian();
XmlNode * saveGame(XmlNode *rootNode); XmlNode * saveGame(XmlNode *rootNode);
void loadGame(const XmlNode *rootNode); void loadGame(const XmlNode *rootNode);
}; };

18
source/glest_game/network/server_interface.cpp
View File

@@ -287,7 +287,7 @@ ServerInterface::~ServerInterface() {
serverSocketAdmin = NULL; serverSocketAdmin = NULL;
for(int i = 0; i < broadcastMessageQueue.size(); ++i) { for(int i = 0; i < broadcastMessageQueue.size(); ++i) {
pair<const NetworkMessage *,int> &item = broadcastMessageQueue[i]; pair<NetworkMessage *,int> &item = broadcastMessageQueue[i];
if(item.first != NULL) { if(item.first != NULL) {
delete item.first; delete item.first;
} }
@@ -1831,7 +1831,7 @@ void ServerInterface::processBroadCastMessageQueue() {
if(broadcastMessageQueue.empty() == false) { if(broadcastMessageQueue.empty() == false) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] broadcastMessageQueue.size() = %d\n",__FILE__,__FUNCTION__,__LINE__,broadcastMessageQueue.size()); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] broadcastMessageQueue.size() = %d\n",__FILE__,__FUNCTION__,__LINE__,broadcastMessageQueue.size());
for(int i = 0; i < broadcastMessageQueue.size(); ++i) { for(int i = 0; i < broadcastMessageQueue.size(); ++i) {
pair<const NetworkMessage *,int> &item = broadcastMessageQueue[i]; pair<NetworkMessage *,int> &item = broadcastMessageQueue[i];
if(item.first != NULL) { if(item.first != NULL) {
this->broadcastMessage(item.first,item.second); this->broadcastMessage(item.first,item.second);
delete item.first; delete item.first;
@@ -1842,9 +1842,9 @@ void ServerInterface::processBroadCastMessageQueue() {
} }
} }
void ServerInterface::queueBroadcastMessage(const NetworkMessage *networkMessage, int excludeSlot) { void ServerInterface::queueBroadcastMessage(NetworkMessage *networkMessage, int excludeSlot) {
MutexSafeWrapper safeMutexSlot(broadcastMessageQueueThreadAccessor,CODE_AT_LINE); MutexSafeWrapper safeMutexSlot(broadcastMessageQueueThreadAccessor,CODE_AT_LINE);
pair<const NetworkMessage*,int> item; pair<NetworkMessage*,int> item;
item.first = networkMessage; item.first = networkMessage;
item.second = excludeSlot; item.second = excludeSlot;
broadcastMessageQueue.push_back(item); broadcastMessageQueue.push_back(item);
@@ -2068,15 +2068,15 @@ void ServerInterface::broadcastGameSetup(GameSettings *gameSettingsBuffer, bool
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s] Line: %d\n",__FILE__,__FUNCTION__,__LINE__); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s] Line: %d\n",__FILE__,__FUNCTION__,__LINE__);
} }
void ServerInterface::broadcastMessage(const NetworkMessage *networkMessage, int excludeSlot, int lockedSlotIndex) { void ServerInterface::broadcastMessage(NetworkMessage *networkMessage, int excludeSlot, int lockedSlotIndex) {
try { try {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d]\n",__FILE__,__FUNCTION__,__LINE__);
MutexSafeWrapper safeMutexSlotBroadCastAccessor(inBroadcastMessageThreadAccessor,CODE_AT_LINE); MutexSafeWrapper safeMutexSlotBroadCastAccessor(inBroadcastMessageThreadAccessor,CODE_AT_LINE);
if(inBroadcastMessage == true && dynamic_cast<const NetworkMessageText *>(networkMessage) != NULL) { if(inBroadcastMessage == true && dynamic_cast<NetworkMessageText *>(networkMessage) != NULL) {
safeMutexSlotBroadCastAccessor.ReleaseLock(); safeMutexSlotBroadCastAccessor.ReleaseLock();
const NetworkMessageText *txtMsg = dynamic_cast<const NetworkMessageText *>(networkMessage); NetworkMessageText *txtMsg = dynamic_cast<NetworkMessageText *>(networkMessage);
const NetworkMessageText *msgCopy = txtMsg->getCopy(); NetworkMessageText *msgCopy = txtMsg->getCopy();
queueBroadcastMessage(msgCopy, excludeSlot); queueBroadcastMessage(msgCopy, excludeSlot);
return; return;
} }
@@ -2133,7 +2133,7 @@ void ServerInterface::broadcastMessage(const NetworkMessage *networkMessage, int
} }
} }
void ServerInterface::broadcastMessageToConnectedClients(const NetworkMessage *networkMessage, int excludeSlot) { void ServerInterface::broadcastMessageToConnectedClients(NetworkMessage *networkMessage, int excludeSlot) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s] Line: %d\n",__FILE__,__FUNCTION__,__LINE__); if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s] Line: %d\n",__FILE__,__FUNCTION__,__LINE__);
try { try {
for(int i= 0; exitServer == false && i < GameConstants::maxPlayers; ++i) { for(int i= 0; exitServer == false && i < GameConstants::maxPlayers; ++i) {

10
source/glest_game/network/server_interface.h
View File

@@ -79,7 +79,7 @@ private:
vector<TextMessageQueue> textMessageQueue; vector<TextMessageQueue> textMessageQueue;
Mutex *broadcastMessageQueueThreadAccessor; Mutex *broadcastMessageQueueThreadAccessor;
vector<pair<const NetworkMessage *,int> > broadcastMessageQueue; vector<pair<NetworkMessage *,int> > broadcastMessageQueue;
Mutex *inBroadcastMessageThreadAccessor; Mutex *inBroadcastMessageThreadAccessor;
bool inBroadcastMessage; bool inBroadcastMessage;
@@ -185,12 +185,12 @@ public:
return serverSocket.getBindPort(); return serverSocket.getBindPort();
} }
void broadcastPing(const NetworkMessagePing *networkMessage, int excludeSlot = -1) void broadcastPing(NetworkMessagePing *networkMessage, int excludeSlot = -1)
{ {
this->broadcastMessage(networkMessage, excludeSlot); this->broadcastMessage(networkMessage, excludeSlot);
} }
void queueBroadcastMessage(const NetworkMessage *networkMessage, int excludeSlot = -1); void queueBroadcastMessage(NetworkMessage *networkMessage, int excludeSlot = -1);
virtual string getHumanPlayerName(int index = -1); virtual string getHumanPlayerName(int index = -1);
virtual int getHumanPlayerIndex() const; virtual int getHumanPlayerIndex() const;
bool getNeedToRepublishToMasterserver() const bool getNeedToRepublishToMasterserver() const
@@ -223,8 +223,8 @@ public:
virtual void saveGame(XmlNode *rootNode); virtual void saveGame(XmlNode *rootNode);
private: private:
void broadcastMessage(const NetworkMessage *networkMessage, int excludeSlot = -1, int lockedSlotIndex = -1); void broadcastMessage(NetworkMessage *networkMessage, int excludeSlot = -1, int lockedSlotIndex = -1);
void broadcastMessageToConnectedClients(const NetworkMessage *networkMessage, int excludeSlot = -1); void broadcastMessageToConnectedClients(NetworkMessage *networkMessage, int excludeSlot = -1);
bool shouldDiscardNetworkMessage(NetworkMessageType networkMessageType, ConnectionSlot *connectionSlot); bool shouldDiscardNetworkMessage(NetworkMessageType networkMessageType, ConnectionSlot *connectionSlot);
void updateSlot(ConnectionSlotEvent *event); void updateSlot(ConnectionSlotEvent *event);
void validateConnectedClients(); void validateConnectedClients();