mirror-games/glest-source
1
0
Fork 0
mirror of https://github.com/glest/glest-source.git synced 2025-08-11 19:04:00 +02:00
Code Issues Projects Releases Wiki Activity

- more byte order logic

Browse Source 
- added new network packet debug
This commit is contained in:
Mark Vejvoda
2012-11-01 22:00:55 +00:00
parent 0d88936680
commit 00e075df97
6 changed files with 503 additions and 290 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
source/glest_game/main/main.cpp
View File

@@ -3243,6 +3243,11 @@ int glestMain(int argc, char** argv) {
LuaScript::setDisableSandbox(true);
}
if(hasCommandArgument(argc, argv,GAME_ARGS[GAME_ARG_DEBUG_NETWORK_PACKETS]) == true) {
printf("*NOTE: debugging network packets.\n");
config.setBool("DebugNetworkPackets",true,true);
}
Socket::setBroadCastPort(config.getInt("BroadcastPort",intToStr(Socket::getBroadCastPort()).c_str()));
Socket::disableNagle = config.getBool("DisableNagle","false");

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

@@ -53,6 +53,8 @@ bool NetworkMessage::receive(Socket* socket, void* data, int dataSize, bool tryR
}
else {
if(SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork,"In [%s::%s Line: %d] dataSize = %d, dataReceived = %d\n",__FILE__,__FUNCTION__,__LINE__,dataSize,dataReceived);
dump_packet("\nINCOMING PACKET:\n",data, dataSize);
return true;
}
}
@@ -64,6 +66,7 @@ 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) {
dump_packet("\nOUTGOING PACKET:\n",data, dataSize);
int sendResult = socket->send(data, dataSize);
if(sendResult != dataSize) {
if(socket != NULL && socket->getSocketId() > 0) {
@@ -78,6 +81,22 @@ void NetworkMessage::send(Socket* socket, const void* data, int dataSize) {
}
}
void NetworkMessage::dump_packet(string label, const void* data, int dataSize) {
Config &config = Config::getInstance();
if(config.getBool("DebugNetworkPackets","false") == true) {
printf("%s",label.c_str());
const char *buf = static_cast<const char *>(data);
for(unsigned int i = 0; i < dataSize; ++i) {
printf("%d[%X][%d] ",i,buf[i],buf[i]);
if(i % 10 == 0) {
printf("\n");
}
}
printf("\n== END ==\n");
}
}
// =====================================================
// class NetworkMessageIntro
// =====================================================
@@ -126,20 +145,26 @@ void NetworkMessageIntro::send(Socket* socket) {
}
void NetworkMessageIntro::toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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);
}
}
// =====================================================
@@ -173,14 +198,20 @@ void NetworkMessagePing::send(Socket* socket) {
}
void NetworkMessagePing::toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
data.pingFrequency = Shared::PlatformByteOrder::toCommonEndian(data.pingFrequency);
data.pingTime = Shared::PlatformByteOrder::toCommonEndian(data.pingTime);
}
}
void NetworkMessagePing::fromEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
data.pingFrequency = Shared::PlatformByteOrder::fromCommonEndian(data.pingFrequency);
data.pingTime = Shared::PlatformByteOrder::fromCommonEndian(data.pingTime);
}
}
// =====================================================
@@ -210,12 +241,18 @@ void NetworkMessageReady::send(Socket* socket) {
}
void NetworkMessageReady::toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
data.checksum = Shared::PlatformByteOrder::toCommonEndian(data.checksum);
}
}
void NetworkMessageReady::fromEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
data.checksum = Shared::PlatformByteOrder::fromCommonEndian(data.checksum);
}
}
// =====================================================
@@ -366,6 +403,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();
@@ -395,6 +433,8 @@ void NetworkMessageLaunch::send(Socket* socket) {
}
void NetworkMessageLaunch::toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
for(int i= 0; i < GameConstants::maxPlayers; ++i){
data.networkPlayerStatuses[i] = Shared::PlatformByteOrder::toCommonEndian(data.networkPlayerStatuses[i]);
@@ -426,8 +466,12 @@ void NetworkMessageLaunch::toEndian() {
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() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
for(int i= 0; i < GameConstants::maxPlayers; ++i){
data.networkPlayerStatuses[i] = Shared::PlatformByteOrder::fromCommonEndian(data.networkPlayerStatuses[i]);
@@ -459,6 +503,7 @@ void NetworkMessageLaunch::fromEndian() {
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);
}
}
// =====================================================
@@ -544,31 +589,44 @@ void NetworkMessageCommandList::send(Socket* socket) {
}
void NetworkMessageCommandList::toEndianHeader() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
if(totalCommand > 0) {
for(int idx = 0 ; idx < totalCommand; ++idx) {
NetworkCommand &cmd = data.commands[idx];
cmd.toEndian();
}
}
}
}
void NetworkMessageCommandList::fromEndianDetail() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
if(data.header.commandCount > 0) {
for(int idx = 0 ; idx < data.header.commandCount; ++idx) {
NetworkCommand &cmd = data.commands[idx];
cmd.fromEndian();
}
}
}
}
// =====================================================
@@ -612,14 +670,20 @@ void NetworkMessageText::send(Socket* socket) {
}
void NetworkMessageText::toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
data.teamIndex = Shared::PlatformByteOrder::toCommonEndian(data.teamIndex);
data.playerIndex = Shared::PlatformByteOrder::toCommonEndian(data.playerIndex);
}
}
void NetworkMessageText::fromEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
data.teamIndex = Shared::PlatformByteOrder::fromCommonEndian(data.teamIndex);
data.playerIndex = Shared::PlatformByteOrder::fromCommonEndian(data.playerIndex);
}
}
// =====================================================
@@ -645,10 +709,16 @@ void NetworkMessageQuit::send(Socket* socket) {
}
void NetworkMessageQuit::toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
}
}
void NetworkMessageQuit::fromEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
}
}
// =====================================================
@@ -851,29 +921,41 @@ void NetworkMessageSynchNetworkGameData::send(Socket* socket) {
}
void NetworkMessageSynchNetworkGameData::toEndianHeader() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
for(unsigned int i = 0; i < totalFileCount; ++i) {
data.detail.techCRCFileCRCList[i] = Shared::PlatformByteOrder::toCommonEndian(data.detail.techCRCFileCRCList[i]);
}
}
}
void NetworkMessageSynchNetworkGameData::fromEndianDetail() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
for(unsigned int i = 0; i < data.header.techCRCFileCount; ++i) {
data.detail.techCRCFileCRCList[i] = Shared::PlatformByteOrder::fromCommonEndian(data.detail.techCRCFileCRCList[i]);
}
}
}
// =====================================================
@@ -1033,29 +1115,42 @@ void NetworkMessageSynchNetworkGameDataStatus::send(Socket* socket) {
}
void NetworkMessageSynchNetworkGameDataStatus::toEndianHeader() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
for(unsigned int i = 0; i < totalFileCount; ++i) {
data.detail.techCRCFileCRCList[i] = Shared::PlatformByteOrder::toCommonEndian(data.detail.techCRCFileCRCList[i]);
}
}
}
void NetworkMessageSynchNetworkGameDataStatus::fromEndianDetail() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
for(unsigned int i = 0; i < data.header.techCRCFileCount; ++i) {
data.detail.techCRCFileCRCList[i] = Shared::PlatformByteOrder::fromCommonEndian(data.detail.techCRCFileCRCList[i]);
}
}
}
// =====================================================
@@ -1089,17 +1184,23 @@ void NetworkMessageSynchNetworkGameDataFileCRCCheck::send(Socket* socket) {
}
void NetworkMessageSynchNetworkGameDataFileCRCCheck::toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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
@@ -1127,10 +1228,16 @@ void NetworkMessageSynchNetworkGameDataFileGet::send(Socket* socket) {
}
void NetworkMessageSynchNetworkGameDataFileGet::toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
}
}
void NetworkMessageSynchNetworkGameDataFileGet::fromEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
}
}
@@ -1186,20 +1293,26 @@ void SwitchSetupRequest::send(Socket* socket) {
}
void SwitchSetupRequest::toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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);
}
}
// =====================================================
@@ -1223,12 +1336,18 @@ void PlayerIndexMessage::send(Socket* socket) {
}
void PlayerIndexMessage::toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
data.playerIndex = Shared::PlatformByteOrder::toCommonEndian(data.playerIndex);
}
}
void PlayerIndexMessage::fromEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
data.playerIndex = Shared::PlatformByteOrder::fromCommonEndian(data.playerIndex);
}
}
// =====================================================
@@ -1253,12 +1372,18 @@ void NetworkMessageLoadingStatus::send(Socket* socket) {
}
void NetworkMessageLoadingStatus::toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
data.messageType = Shared::PlatformByteOrder::toCommonEndian(data.messageType);
data.status = Shared::PlatformByteOrder::toCommonEndian(data.status);
}
}
void NetworkMessageLoadingStatus::fromEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
data.messageType = Shared::PlatformByteOrder::fromCommonEndian(data.messageType);
data.status = Shared::PlatformByteOrder::fromCommonEndian(data.status);
}
}
// =====================================================
@@ -1300,18 +1425,24 @@ void NetworkMessageMarkCell::send(Socket* socket) {
}
void NetworkMessageMarkCell::toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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);
}
}
// =====================================================
@@ -1346,16 +1477,22 @@ void NetworkMessageUnMarkCell::send(Socket* socket) {
}
void NetworkMessageUnMarkCell::toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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);
}
}
// =====================================================
@@ -1385,16 +1522,22 @@ void NetworkMessageHighlightCell::send(Socket* socket) {
}
void NetworkMessageHighlightCell::toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
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

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

@@ -76,6 +76,8 @@ 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);
void dump_packet(string label, const void* data, int dataSize);
};
// =====================================================

24
source/shared_lib/include/graphics/vec.h
View File

@@ -68,15 +68,21 @@ template<typename T> class Vec4;
template<class T>
void toEndianVecArray(T *vec, size_t size) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
for(size_t i = 0; i < size; ++i) {
vec[i].toEndian();
}
}
}
template<class T>
void fromEndianVecArray(T *vec, size_t size) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
for(size_t i = 0; i < size; ++i) {
vec[i].fromEndian();
}
}
}
// =====================================================
@@ -276,13 +282,19 @@ public:
}
void toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
this->x = Shared::PlatformByteOrder::toCommonEndian(this->x);
this->y = Shared::PlatformByteOrder::toCommonEndian(this->y);
}
}
void fromEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
this->x = Shared::PlatformByteOrder::fromCommonEndian(this->x);
this->y = Shared::PlatformByteOrder::fromCommonEndian(this->y);
}
}
};
@@ -524,15 +536,21 @@ public:
}
void toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
this->x = Shared::PlatformByteOrder::toCommonEndian(this->x);
this->y = Shared::PlatformByteOrder::toCommonEndian(this->y);
this->z = Shared::PlatformByteOrder::toCommonEndian(this->z);
}
}
void fromEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
this->x = Shared::PlatformByteOrder::fromCommonEndian(this->x);
this->y = Shared::PlatformByteOrder::fromCommonEndian(this->y);
this->z = Shared::PlatformByteOrder::fromCommonEndian(this->z);
}
}
};
@@ -750,17 +768,23 @@ public:
}
void toEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
this->x = Shared::PlatformByteOrder::toCommonEndian(this->x);
this->y = Shared::PlatformByteOrder::toCommonEndian(this->y);
this->z = Shared::PlatformByteOrder::toCommonEndian(this->z);
this->w = Shared::PlatformByteOrder::toCommonEndian(this->w);
}
}
void fromEndian() {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
this->x = Shared::PlatformByteOrder::fromCommonEndian(this->x);
this->y = Shared::PlatformByteOrder::fromCommonEndian(this->y);
this->z = Shared::PlatformByteOrder::fromCommonEndian(this->z);
this->w = Shared::PlatformByteOrder::fromCommonEndian(this->w);
}
}
};

3
source/shared_lib/include/platform/sdl/platform_main.h
View File

@@ -87,6 +87,7 @@ const char *GAME_ARGS[] = {
"--disable-opengl-checks",
"--disable-streflop-checks",
"--debug-network-packets",
"--verbose"
@@ -160,6 +161,8 @@ enum GAME_ARG_TYPE {
GAME_ARG_DISABLE_OPENGL_CAPS_CHECK,
GAME_ARG_DISABLE_STREFLOP_CAPS_CHECK,
GAME_ARG_DEBUG_NETWORK_PACKETS,
GAME_ARG_VERBOSE_MODE,
GAME_ARG_END

36
source/shared_lib/sources/graphics/model.cpp
View File

@@ -37,28 +37,42 @@ using namespace Util;
// Utils methods for endianness conversion
void toEndianFileHeader(FileHeader &header) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
for(unsigned int i = 0; i < 3; ++i) {
header.id[i] = Shared::PlatformByteOrder::toCommonEndian(header.id[i]);
}
header.version = Shared::PlatformByteOrder::toCommonEndian(header.version);
}
}
void fromEndianFileHeader(FileHeader &header) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
for(unsigned int i = 0; i < 3; ++i) {
header.id[i] = Shared::PlatformByteOrder::fromCommonEndian(header.id[i]);
}
header.version = Shared::PlatformByteOrder::fromCommonEndian(header.version);
}
}
void toEndianModelHeader(ModelHeader &header) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
header.type = Shared::PlatformByteOrder::toCommonEndian(header.type);
header.meshCount = Shared::PlatformByteOrder::toCommonEndian(header.meshCount);
}
}
void fromEndianModelHeader(ModelHeader &header) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
header.type = Shared::PlatformByteOrder::toCommonEndian(header.type);
header.meshCount = Shared::PlatformByteOrder::toCommonEndian(header.meshCount);
}
}
void toEndianMeshHeader(MeshHeader &header) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
for(unsigned int i = 0; i < meshNameSize; ++i) {
header.name[i] = Shared::PlatformByteOrder::toCommonEndian(header.name[i]);
}
@@ -73,9 +87,12 @@ void toEndianMeshHeader(MeshHeader &header) {
header.opacity = Shared::PlatformByteOrder::toCommonEndian(header.opacity);
header.properties = Shared::PlatformByteOrder::toCommonEndian(header.properties);
header.textures = Shared::PlatformByteOrder::toCommonEndian(header.textures);
}
}
void fromEndianMeshHeader(MeshHeader &header) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
for(unsigned int i = 0; i < meshNameSize; ++i) {
header.name[i] = Shared::PlatformByteOrder::fromCommonEndian(header.name[i]);
}
@@ -90,16 +107,25 @@ void fromEndianMeshHeader(MeshHeader &header) {
header.opacity = Shared::PlatformByteOrder::fromCommonEndian(header.opacity);
header.properties = Shared::PlatformByteOrder::fromCommonEndian(header.properties);
header.textures = Shared::PlatformByteOrder::fromCommonEndian(header.textures);
}
}
void toEndianModelHeaderV3(ModelHeaderV3 &header) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
header.meshCount = Shared::PlatformByteOrder::toCommonEndian(header.meshCount);
}
}
void fromEndianModelHeaderV3(ModelHeaderV3 &header) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
header.meshCount = Shared::PlatformByteOrder::fromCommonEndian(header.meshCount);
}
}
void toEndianMeshHeaderV3(MeshHeaderV3 &header) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
header.vertexFrameCount = Shared::PlatformByteOrder::toCommonEndian(header.vertexFrameCount);
header.normalFrameCount = Shared::PlatformByteOrder::toCommonEndian(header.normalFrameCount);
header.texCoordFrameCount = Shared::PlatformByteOrder::toCommonEndian(header.texCoordFrameCount);
@@ -110,9 +136,12 @@ void toEndianMeshHeaderV3(MeshHeaderV3 &header) {
for(unsigned int i = 0; i < 64; ++i) {
header.texName[i] = Shared::PlatformByteOrder::toCommonEndian(header.texName[i]);
}
}
}
void fromEndianMeshHeaderV3(MeshHeaderV3 &header) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
header.vertexFrameCount = Shared::PlatformByteOrder::fromCommonEndian(header.vertexFrameCount);
header.normalFrameCount = Shared::PlatformByteOrder::fromCommonEndian(header.normalFrameCount);
header.texCoordFrameCount = Shared::PlatformByteOrder::fromCommonEndian(header.texCoordFrameCount);
@@ -123,9 +152,12 @@ void fromEndianMeshHeaderV3(MeshHeaderV3 &header) {
for(unsigned int i = 0; i < 64; ++i) {
header.texName[i] = Shared::PlatformByteOrder::fromCommonEndian(header.texName[i]);
}
}
}
void toEndianMeshHeaderV2(MeshHeaderV2 &header) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
header.vertexFrameCount = Shared::PlatformByteOrder::toCommonEndian(header.vertexFrameCount);
header.normalFrameCount = Shared::PlatformByteOrder::toCommonEndian(header.normalFrameCount);
header.texCoordFrameCount = Shared::PlatformByteOrder::toCommonEndian(header.texCoordFrameCount);
@@ -139,9 +171,12 @@ void toEndianMeshHeaderV2(MeshHeaderV2 &header) {
for(unsigned int i = 0; i < 64; ++i) {
header.texName[i] = Shared::PlatformByteOrder::toCommonEndian(header.texName[i]);
}
}
}
void fromEndianMeshHeaderV2(MeshHeaderV2 &header) {
static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
if(bigEndianSystem == true) {
header.vertexFrameCount = Shared::PlatformByteOrder::fromCommonEndian(header.vertexFrameCount);
header.normalFrameCount = Shared::PlatformByteOrder::fromCommonEndian(header.normalFrameCount);
header.texCoordFrameCount = Shared::PlatformByteOrder::fromCommonEndian(header.texCoordFrameCount);
@@ -155,6 +190,7 @@ void fromEndianMeshHeaderV2(MeshHeaderV2 &header) {
for(unsigned int i = 0; i < 64; ++i) {
header.texName[i] = Shared::PlatformByteOrder::fromCommonEndian(header.texName[i]);
}
}
}
// =====================================================