Rampoina/MegaGlest
1
0
Fork 0
Code Issues Pull Requests 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
Show Stats 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);
}
void ConnectionSlot::sendMessage(const NetworkMessage* networkMessage) {
void ConnectionSlot::sendMessage(NetworkMessage* networkMessage) {
MutexSafeWrapper safeMutex(socketSynchAccessor,CODE_AT_LINE);
// 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) {
//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;
ConnectionSlot* connectionSlot;
ConnectionSlotEventType eventType;
const NetworkMessage *networkMessage;
NetworkMessage *networkMessage;
bool socketTriggered;
bool eventCompleted;
int64 eventId;
@ -171,7 +171,7 @@ public:
void signalUpdate(ConnectionSlotEvent *event);
bool updateCompleted(ConnectionSlotEvent *event);
virtual void sendMessage(const NetworkMessage* networkMessage);
virtual void sendMessage(NetworkMessage* networkMessage);
int getCurrentFrameCount() const { return currentFrameCount; }
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);
void NetworkInterface::sendMessage(const NetworkMessage* networkMessage){
void NetworkInterface::sendMessage(NetworkMessage* networkMessage){
Socket* socket= getSocket(false);
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 getHostName() const {return Socket::getHostName();}
virtual void sendMessage(const NetworkMessage* networkMessage);
virtual void sendMessage(NetworkMessage* networkMessage);
NetworkMessageType getNextMessageType();
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(socket != NULL) {
@ -112,17 +112,35 @@ bool NetworkMessageIntro::receive(Socket* socket) {
data.name.nullTerminate();
data.versionString.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);
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);
assert(data.messageType == nmtIntro);
toEndian();
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
// =====================================================
@ -141,16 +159,29 @@ NetworkMessagePing::NetworkMessagePing(int32 pingFrequency, int64 pingTime){
bool NetworkMessagePing::receive(Socket* socket){
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
pingReceivedLocalTime = time(NULL);
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__);
assert(data.messageType==nmtPing);
toEndian();
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
// =====================================================
@ -165,15 +196,27 @@ NetworkMessageReady::NetworkMessageReady(uint32 checksum) {
}
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__);
assert(data.messageType==nmtReady);
toEndian();
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
// =====================================================
@ -321,6 +364,7 @@ vector<pair<string,uint32> > NetworkMessageLaunch::getFactionCRCList() const {
bool NetworkMessageLaunch::receive(Socket* socket) {
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
data.description.nullTerminate();
data.map.nullTerminate();
data.tileset.nullTerminate();
@ -338,16 +382,84 @@ bool NetworkMessageLaunch::receive(Socket* socket) {
return result;
}
void NetworkMessageLaunch::send(Socket* socket) const{
void NetworkMessageLaunch::send(Socket* socket) {
if(data.messageType == nmtLaunch) {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] nmtLaunch\n",__FILE__,__FUNCTION__,__LINE__);
}
else {
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));
}
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
// =====================================================
@ -359,31 +471,18 @@ NetworkMessageCommandList::NetworkMessageCommandList(int32 frameCount) {
}
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.header.commandCount++;
return true;
}
bool NetworkMessageCommandList::receive(Socket* socket) {
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);
fromEndianHeader();
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);
// read header + data.commandCount commands.
//int totalMsgSize = commandListHeaderSize + (sizeof(NetworkCommand) * data.header.commandCount);
if(data.header.commandCount > 0) {
data.commands.resize(data.header.commandCount);
@ -391,6 +490,7 @@ bool NetworkMessageCommandList::receive(Socket* socket) {
int totalMsgSize = (sizeof(NetworkCommand) * data.header.commandCount);
result = NetworkMessage::receive(socket, &data.commands[0], totalMsgSize, true);
if(result == true) {
fromEndianDetail();
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled == true) {
for(int idx = 0 ; idx < data.header.commandCount; ++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);
assert(data.header.messageType==nmtCommandList);
//int totalMsgSize = commandListHeaderSize + (sizeof(NetworkCommand) * data.header.commandCount);
//NetworkMessage::send(socket, &data, totalMsgSize);
uint16 totalCommand = data.header.commandCount;
toEndianHeader();
NetworkMessage::send(socket, &data.header, commandListHeaderSize);
if(data.header.commandCount > 0) {
NetworkMessage::send(socket, &data.commands[0], (sizeof(NetworkCommand) * data.header.commandCount));
if(totalCommand > 0) {
toEndianDetail(totalCommand);
NetworkMessage::send(socket, &data.commands[0], (sizeof(NetworkCommand) * totalCommand));
}
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
// =====================================================
@ -466,20 +595,32 @@ NetworkMessageText * NetworkMessageText::getCopy() const {
bool NetworkMessageText::receive(Socket* socket){
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
data.text.nullTerminate();
data.targetLanguage.nullTerminate();
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__);
assert(data.messageType==nmtText);
toEndian();
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
// =====================================================
@ -489,16 +630,26 @@ NetworkMessageQuit::NetworkMessageQuit(){
}
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__);
assert(data.messageType==nmtQuit);
toEndian();
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
// =====================================================
@ -619,6 +770,7 @@ bool NetworkMessageSynchNetworkGameData::receive(Socket* socket) {
data.header.techCRCFileCount = 0;
bool result = NetworkMessage::receive(socket, &data, HeaderSize, true);
fromEndianHeader();
if(result == true && data.header.techCRCFileCount > 0) {
data.header.map.nullTerminate();
data.header.tileset.nullTerminate();
@ -659,22 +811,25 @@ bool NetworkMessageSynchNetworkGameData::receive(Socket* socket) {
result = NetworkMessage::receive(socket, &data.detail.techCRCFileCRCList[packetIndex], packetDetail2DataSize, true);
}
}
fromEndianDetail();
}
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__);
assert(data.header.messageType==nmtSynchNetworkGameData);
uint32 totalFileCount = data.header.techCRCFileCount;
toEndianHeader();
NetworkMessage::send(socket, &data, HeaderSize);
if(data.header.techCRCFileCount > 0) {
if(totalFileCount > 0) {
// Here we loop possibly multiple times
int packetLoopCount = 1;
if(data.header.techCRCFileCount > NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount) {
packetLoopCount = (data.header.techCRCFileCount / NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount);
if(data.header.techCRCFileCount % NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount > 0) {
if(totalFileCount > NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount) {
packetLoopCount = (totalFileCount / NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount);
if(totalFileCount % NetworkMessageSynchNetworkGameData::maxFileCRCPacketCount > 0) {
packetLoopCount++;
}
}
@ -685,11 +840,38 @@ void NetworkMessageSynchNetworkGameData::send(Socket* socket) const {
int packetIndex = iPacketLoop * NetworkMessageSynchNetworkGameData::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.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);
if(result == true && data.header.techCRCFileCount > 0) {
fromEndianHeader();
// Here we loop possibly multiple times
int packetLoopCount = 1;
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);
}
}
fromEndianDetail();
}
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;
}
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);
assert(data.header.messageType==nmtSynchNetworkGameDataStatus);
uint32 totalFileCount = data.header.techCRCFileCount;
toEndianHeader();
NetworkMessage::send(socket, &data, HeaderSize);
if(data.header.techCRCFileCount > 0) {
if(totalFileCount > 0) {
// Here we loop possibly multiple times
int packetLoopCount = 1;
if(data.header.techCRCFileCount > NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount) {
packetLoopCount = (data.header.techCRCFileCount / NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount);
if(data.header.techCRCFileCount % NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount > 0) {
if(totalFileCount > NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount) {
packetLoopCount = (totalFileCount / NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount);
if(totalFileCount % NetworkMessageSynchNetworkGameDataStatus::maxFileCRCPacketCount > 0) {
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) {
int packetIndex = iPacketLoop * NetworkMessageSynchNetworkGameDataStatus::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);
@ -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
// =====================================================
@ -860,45 +1073,64 @@ NetworkMessageSynchNetworkGameDataFileCRCCheck::NetworkMessageSynchNetworkGameDa
bool NetworkMessageSynchNetworkGameDataFileCRCCheck::receive(Socket* socket) {
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
data.fileName.nullTerminate();
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__);
assert(data.messageType==nmtSynchNetworkGameDataFileCRCCheck);
toEndian();
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
// =====================================================
NetworkMessageSynchNetworkGameDataFileGet::NetworkMessageSynchNetworkGameDataFileGet(const string fileName)
{
NetworkMessageSynchNetworkGameDataFileGet::NetworkMessageSynchNetworkGameDataFileGet(const string fileName) {
data.messageType= nmtSynchNetworkGameDataFileGet;
data.fileName = fileName;
}
bool NetworkMessageSynchNetworkGameDataFileGet::receive(Socket* socket) {
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
data.fileName.nullTerminate();
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__);
assert(data.messageType==nmtSynchNetworkGameDataFileGet);
toEndian();
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 result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
data.selectedFactionName.nullTerminate();
data.networkPlayerName.nullTerminate();
data.language.nullTerminate();
@ -944,32 +1176,60 @@ bool SwitchSetupRequest::receive(Socket* socket) {
return result;
}
void SwitchSetupRequest::send(Socket* socket) const {
void SwitchSetupRequest::send(Socket* socket) {
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());
toEndian();
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
// =====================================================
PlayerIndexMessage::PlayerIndexMessage(int16 playerIndex)
{
PlayerIndexMessage::PlayerIndexMessage(int16 playerIndex) {
data.messageType= nmtPlayerIndexMessage;
data.playerIndex=playerIndex;
}
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);
toEndian();
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
// =====================================================
@ -980,15 +1240,26 @@ NetworkMessageLoadingStatus::NetworkMessageLoadingStatus(uint32 status)
}
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);
toEndian();
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
// =====================================================
@ -1014,17 +1285,34 @@ NetworkMessageMarkCell * NetworkMessageMarkCell::getCopy() const {
bool NetworkMessageMarkCell::receive(Socket* socket){
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
data.text.nullTerminate();
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__);
assert(data.messageType == nmtMarkCell);
toEndian();
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
// =====================================================
@ -1044,16 +1332,31 @@ NetworkMessageUnMarkCell * NetworkMessageUnMarkCell::getCopy() const {
bool NetworkMessageUnMarkCell::receive(Socket* socket){
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
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__);
assert(data.messageType == nmtUnMarkCell);
toEndian();
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
// =====================================================
@ -1066,18 +1369,31 @@ NetworkMessageHighlightCell::NetworkMessageHighlightCell(Vec2i target, int facti
data.factionIndex = factionIndex;
}
bool NetworkMessageHighlightCell::receive(Socket* socket){
bool result = NetworkMessage::receive(socket, &data, sizeof(data), true);
fromEndian();
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__);
assert(data.messageType == nmtHighlightCell);
toEndian();
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

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

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

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

@ -98,6 +98,40 @@ string NetworkCommand::toString() const {
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) {
std::map<string,string> mapTagReplacements;
XmlNode *networkCommandNode = rootNode->addChild("NetworkCommand");

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

@ -153,6 +153,9 @@ public:
void preprocessNetworkCommand(World *world);
string toString() const;
void toEndian();
void fromEndian();
XmlNode * saveGame(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;
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) {
delete item.first;
}
@ -1831,7 +1831,7 @@ void ServerInterface::processBroadCastMessageQueue() {
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());
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) {
this->broadcastMessage(item.first,item.second);
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);
pair<const NetworkMessage*,int> item;
pair<NetworkMessage*,int> item;
item.first = networkMessage;
item.second = excludeSlot;
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__);
}
void ServerInterface::broadcastMessage(const NetworkMessage *networkMessage, int excludeSlot, int lockedSlotIndex) {
void ServerInterface::broadcastMessage(NetworkMessage *networkMessage, int excludeSlot, int lockedSlotIndex) {
try {
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);
if(inBroadcastMessage == true && dynamic_cast<const NetworkMessageText *>(networkMessage) != NULL) {
if(inBroadcastMessage == true && dynamic_cast<NetworkMessageText *>(networkMessage) != NULL) {
safeMutexSlotBroadCastAccessor.ReleaseLock();
const NetworkMessageText *txtMsg = dynamic_cast<const NetworkMessageText *>(networkMessage);
const NetworkMessageText *msgCopy = txtMsg->getCopy();
NetworkMessageText *txtMsg = dynamic_cast<NetworkMessageText *>(networkMessage);
NetworkMessageText *msgCopy = txtMsg->getCopy();
queueBroadcastMessage(msgCopy, excludeSlot);
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__);
try {
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;
Mutex *broadcastMessageQueueThreadAccessor;
vector<pair<const NetworkMessage *,int> > broadcastMessageQueue;
vector<pair<NetworkMessage *,int> > broadcastMessageQueue;
Mutex *inBroadcastMessageThreadAccessor;
bool inBroadcastMessage;
@ -185,12 +185,12 @@ public:
return serverSocket.getBindPort();
}
void broadcastPing(const NetworkMessagePing *networkMessage, int excludeSlot = -1)
void broadcastPing(NetworkMessagePing *networkMessage, int excludeSlot = -1)
{
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 int getHumanPlayerIndex() const;
bool getNeedToRepublishToMasterserver() const
@ -223,8 +223,8 @@ public:
virtual void saveGame(XmlNode *rootNode);
private:
void broadcastMessage(const NetworkMessage *networkMessage, int excludeSlot = -1, int lockedSlotIndex = -1);
void broadcastMessageToConnectedClients(const NetworkMessage *networkMessage, int excludeSlot = -1);
void broadcastMessage(NetworkMessage *networkMessage, int excludeSlot = -1, int lockedSlotIndex = -1);
void broadcastMessageToConnectedClients(NetworkMessage *networkMessage, int excludeSlot = -1);
bool shouldDiscardNetworkMessage(NetworkMessageType networkMessageType, ConnectionSlot *connectionSlot);
void updateSlot(ConnectionSlotEvent *event);
void validateConnectedClients();