On Sunday, 19 August 2007 at 17:35, anonymous wrote:
> The patch Giel did should be revoked immediately!

Or use little instead of big endian. I've converted all BE functions to
LE (as an aside, I think having functions called PHYSFS_... in the
Warzone code is a bad idea) and it seems to work. Patch attached.
diff -r 96d259d05600 lib/framework/frame.h
--- a/lib/framework/frame.h	Sat Aug 18 23:37:37 2007 +0200
+++ b/lib/framework/frame.h	Sun Aug 19 18:40:03 2007 +0200
@@ -251,4 +251,28 @@ static inline bool PHYSFS_readBEFloat(PH
 	return (PHYSFS_readUBE32(file, readValue) != 0);
 }
 
-#endif
+// little endian versions
+
+// defines since 8bit is endian-neutral
+#define PHYSFS_writeSLE8 PHYSFS_writeSBE8
+#define PHYSFS_writeULE8 PHYSFS_writeUBE8
+#define PHYSFS_readSLE8 PHYSFS_readSBE8
+#define PHYSFS_readULE8 PHYSFS_readUBE8
+
+static inline bool PHYSFS_writeLEFloat(PHYSFS_file* file, float val)
+{
+	union {
+		float f;
+		uint32_t i;
+	} writeValue;
+	writeValue.f = val;
+	return (PHYSFS_writeULE32(file, writeValue.i) != 0);
+}
+
+static inline bool PHYSFS_readLEFloat(PHYSFS_file* file, float* val)
+{
+	uint32_t* readValue = (uint32_t*)val;
+	return (PHYSFS_readULE32(file, readValue) != 0);
+}
+
+#endif
diff -r 96d259d05600 src/effects.c
--- a/src/effects.c	Sat Aug 18 23:37:37 2007 +0200
+++ b/src/effects.c	Sun Aug 19 18:40:03 2007 +0200
@@ -2708,36 +2708,36 @@ static bool serializeFXData(PHYSFS_file*
 		imdHashedNumber = 0;
 	}
 
-	return (PHYSFS_writeUBE8 (fileHandle, serializeEffect->  control)
-	     && PHYSFS_writeUBE8 (fileHandle, serializeEffect->  group)
-	     && PHYSFS_writeUBE8 (fileHandle, serializeEffect->  type)
-	     && PHYSFS_writeUBE8 (fileHandle, serializeEffect->  frameNumber)
-	     && PHYSFS_writeUBE16(fileHandle, serializeEffect->  size)
-	     && PHYSFS_writeUBE8 (fileHandle, serializeEffect->  baseScale)
-	     && PHYSFS_writeUBE8 (fileHandle, serializeEffect->  specific)
+	return (PHYSFS_writeULE8 (fileHandle, serializeEffect->  control)
+	     && PHYSFS_writeULE8 (fileHandle, serializeEffect->  group)
+	     && PHYSFS_writeULE8 (fileHandle, serializeEffect->  type)
+	     && PHYSFS_writeULE8 (fileHandle, serializeEffect->  frameNumber)
+	     && PHYSFS_writeULE16(fileHandle, serializeEffect->  size)
+	     && PHYSFS_writeULE8 (fileHandle, serializeEffect->  baseScale)
+	     && PHYSFS_writeULE8 (fileHandle, serializeEffect->  specific)
 
 	     // Write Vector3f types
-	     && PHYSFS_writeBEFloat(fileHandle, serializeEffect->position.x)
-	     && PHYSFS_writeBEFloat(fileHandle, serializeEffect->position.y)
-	     && PHYSFS_writeBEFloat(fileHandle, serializeEffect->position.z)
-	     && PHYSFS_writeBEFloat(fileHandle, serializeEffect->velocity.x)
-	     && PHYSFS_writeBEFloat(fileHandle, serializeEffect->velocity.y)
-	     && PHYSFS_writeBEFloat(fileHandle, serializeEffect->velocity.z)
+	     && PHYSFS_writeLEFloat(fileHandle, serializeEffect->position.x)
+	     && PHYSFS_writeLEFloat(fileHandle, serializeEffect->position.y)
+	     && PHYSFS_writeLEFloat(fileHandle, serializeEffect->position.z)
+	     && PHYSFS_writeLEFloat(fileHandle, serializeEffect->velocity.x)
+	     && PHYSFS_writeLEFloat(fileHandle, serializeEffect->velocity.y)
+	     && PHYSFS_writeLEFloat(fileHandle, serializeEffect->velocity.z)
 
 	     // Write Vector3i types
-	     && PHYSFS_writeSBE32(fileHandle, serializeEffect->  rotation.x)
-	     && PHYSFS_writeSBE32(fileHandle, serializeEffect->  rotation.y)
-	     && PHYSFS_writeSBE32(fileHandle, serializeEffect->  rotation.z)
-	     && PHYSFS_writeSBE32(fileHandle, serializeEffect->  spin.x)
-	     && PHYSFS_writeSBE32(fileHandle, serializeEffect->  spin.y)
-	     && PHYSFS_writeSBE32(fileHandle, serializeEffect->  spin.z)
-
-	     && PHYSFS_writeUBE32(fileHandle, serializeEffect->  birthTime)
-	     && PHYSFS_writeUBE32(fileHandle, serializeEffect->  lastFrame)
-	     && PHYSFS_writeUBE16(fileHandle, serializeEffect->  frameDelay)
-	     && PHYSFS_writeUBE16(fileHandle, serializeEffect->  lifeSpan)
-	     && PHYSFS_writeUBE16(fileHandle, serializeEffect->  radius)
-	     && PHYSFS_writeUBE32(fileHandle, imdHashedNumber));
+	     && PHYSFS_writeSLE32(fileHandle, serializeEffect->  rotation.x)
+	     && PHYSFS_writeSLE32(fileHandle, serializeEffect->  rotation.y)
+	     && PHYSFS_writeSLE32(fileHandle, serializeEffect->  rotation.z)
+	     && PHYSFS_writeSLE32(fileHandle, serializeEffect->  spin.x)
+	     && PHYSFS_writeSLE32(fileHandle, serializeEffect->  spin.y)
+	     && PHYSFS_writeSLE32(fileHandle, serializeEffect->  spin.z)
+
+	     && PHYSFS_writeULE32(fileHandle, serializeEffect->  birthTime)
+	     && PHYSFS_writeULE32(fileHandle, serializeEffect->  lastFrame)
+	     && PHYSFS_writeULE16(fileHandle, serializeEffect->  frameDelay)
+	     && PHYSFS_writeULE16(fileHandle, serializeEffect->  lifeSpan)
+	     && PHYSFS_writeULE16(fileHandle, serializeEffect->  radius)
+	     && PHYSFS_writeULE32(fileHandle, imdHashedNumber));
 }
 
 /** Read an EFFECT from the given file with endianness swapped correctly
@@ -2749,35 +2749,35 @@ static bool deserializeFXData(PHYSFS_fil
 {
 	uint32_t imdHashedNumber;
 
-	if (!PHYSFS_readUBE8 (fileHandle, &serializeEffect->  control)
-	 || !PHYSFS_readUBE8 (fileHandle, &serializeEffect->  group)
-	 || !PHYSFS_readUBE8 (fileHandle, &serializeEffect->  type)
-	 || !PHYSFS_readUBE8 (fileHandle, &serializeEffect->  frameNumber)
-	 || !PHYSFS_readUBE16(fileHandle, &serializeEffect->  size)
-	 || !PHYSFS_readUBE8 (fileHandle, &serializeEffect->  baseScale)
-	 || !PHYSFS_readUBE8 (fileHandle, &serializeEffect->  specific)
+	if (!PHYSFS_readULE8 (fileHandle, &serializeEffect->  control)
+	 || !PHYSFS_readULE8 (fileHandle, &serializeEffect->  group)
+	 || !PHYSFS_readULE8 (fileHandle, &serializeEffect->  type)
+	 || !PHYSFS_readULE8 (fileHandle, &serializeEffect->  frameNumber)
+	 || !PHYSFS_readULE16(fileHandle, &serializeEffect->  size)
+	 || !PHYSFS_readULE8 (fileHandle, &serializeEffect->  baseScale)
+	 || !PHYSFS_readULE8 (fileHandle, &serializeEffect->  specific)
 
 	 // Write Vector3f types
-	 || !PHYSFS_readBEFloat(fileHandle, &serializeEffect->position.x)
-	 || !PHYSFS_readBEFloat(fileHandle, &serializeEffect->position.y)
-	 || !PHYSFS_readBEFloat(fileHandle, &serializeEffect->position.z)
-	 || !PHYSFS_readBEFloat(fileHandle, &serializeEffect->velocity.x)
-	 || !PHYSFS_readBEFloat(fileHandle, &serializeEffect->velocity.y)
-	 || !PHYSFS_readBEFloat(fileHandle, &serializeEffect->velocity.z)
+	 || !PHYSFS_readLEFloat(fileHandle, &serializeEffect->position.x)
+	 || !PHYSFS_readLEFloat(fileHandle, &serializeEffect->position.y)
+	 || !PHYSFS_readLEFloat(fileHandle, &serializeEffect->position.z)
+	 || !PHYSFS_readLEFloat(fileHandle, &serializeEffect->velocity.x)
+	 || !PHYSFS_readLEFloat(fileHandle, &serializeEffect->velocity.y)
+	 || !PHYSFS_readLEFloat(fileHandle, &serializeEffect->velocity.z)
 
 	 // Write Vector3i types
-	 || !PHYSFS_readSBE32(fileHandle, &serializeEffect->  rotation.x)
-	 || !PHYSFS_readSBE32(fileHandle, &serializeEffect->  rotation.y)
-	 || !PHYSFS_readSBE32(fileHandle, &serializeEffect->  rotation.z)
-	 || !PHYSFS_readSBE32(fileHandle, &serializeEffect->  spin.x)
-	 || !PHYSFS_readSBE32(fileHandle, &serializeEffect->  spin.y)
-	 || !PHYSFS_readSBE32(fileHandle, &serializeEffect->  spin.z)
-	 || !PHYSFS_readUBE32(fileHandle, &serializeEffect->  birthTime)
-	 || !PHYSFS_readUBE32(fileHandle, &serializeEffect->  lastFrame)
-	 || !PHYSFS_readUBE16(fileHandle, &serializeEffect->  frameDelay)
-	 || !PHYSFS_readUBE16(fileHandle, &serializeEffect->  lifeSpan)
-	 || !PHYSFS_readUBE16(fileHandle, &serializeEffect->  radius)
-	 || !PHYSFS_readUBE32(fileHandle, &imdHashedNumber))
+	 || !PHYSFS_readSLE32(fileHandle, &serializeEffect->  rotation.x)
+	 || !PHYSFS_readSLE32(fileHandle, &serializeEffect->  rotation.y)
+	 || !PHYSFS_readSLE32(fileHandle, &serializeEffect->  rotation.z)
+	 || !PHYSFS_readSLE32(fileHandle, &serializeEffect->  spin.x)
+	 || !PHYSFS_readSLE32(fileHandle, &serializeEffect->  spin.y)
+	 || !PHYSFS_readSLE32(fileHandle, &serializeEffect->  spin.z)
+	 || !PHYSFS_readULE32(fileHandle, &serializeEffect->  birthTime)
+	 || !PHYSFS_readULE32(fileHandle, &serializeEffect->  lastFrame)
+	 || !PHYSFS_readULE16(fileHandle, &serializeEffect->  frameDelay)
+	 || !PHYSFS_readULE16(fileHandle, &serializeEffect->  lifeSpan)
+	 || !PHYSFS_readULE16(fileHandle, &serializeEffect->  radius)
+	 || !PHYSFS_readULE32(fileHandle, &imdHashedNumber))
 	{
 		return false;
 	}
@@ -2826,8 +2826,8 @@ bool writeFXData(const char* fileName)
 	}
 
 	if (PHYSFS_write(fileHandle, fileHeader.aFileType, sizeof(fileHeader.aFileType), 1) != 1
-	 || !PHYSFS_writeUBE32(fileHandle, fileHeader.version)
-	 || !PHYSFS_writeUBE32(fileHandle, fileHeader.entries))
+	 || !PHYSFS_writeULE32(fileHandle, fileHeader.version)
+	 || !PHYSFS_writeULE32(fileHandle, fileHeader.entries))
 	{
 		debug(LOG_ERROR, "writeFXData: could not write to %s; PHYSFS error: %s", fileName, PHYSFS_getLastError());
 		PHYSFS_close(fileHandle);
@@ -2876,8 +2876,8 @@ bool readFXData(const char* fileName)
 
 	// Read the header from the file
 	if (PHYSFS_read(fileHandle, fileHeader.aFileType, sizeof(fileHeader.aFileType), 1) != 1
-	 || !PHYSFS_readUBE32(fileHandle, &fileHeader.version)
-	 || !PHYSFS_readUBE32(fileHandle, &fileHeader.entries))
+	 || !PHYSFS_readULE32(fileHandle, &fileHeader.version)
+	 || !PHYSFS_readULE32(fileHandle, &fileHeader.entries))
 	{
 		debug(LOG_ERROR, "readFXData: error while reading file: %s", PHYSFS_getLastError());
 		PHYSFS_close(fileHandle);
diff -r 96d259d05600 src/game.c
--- a/src/game.c	Sat Aug 18 23:37:37 2007 +0200
+++ b/src/game.c	Sun Aug 19 18:40:03 2007 +0200
@@ -275,30 +275,30 @@ typedef struct _savePower
 
 static bool serializeSavePowerData(PHYSFS_file* fileHandle, const SAVE_POWER* serializePower)
 {
-	return (PHYSFS_writeUBE32(fileHandle, serializePower->currentPower)
-	     && PHYSFS_writeUBE32(fileHandle, serializePower->extractedPower));
+	return (PHYSFS_writeULE32(fileHandle, serializePower->currentPower)
+	     && PHYSFS_writeULE32(fileHandle, serializePower->extractedPower));
 }
 
 static bool deserializeSavePowerData(PHYSFS_file* fileHandle, SAVE_POWER* serializePower)
 {
-	return (PHYSFS_readUBE32(fileHandle, &serializePower->currentPower)
-	     && PHYSFS_readUBE32(fileHandle, &serializePower->extractedPower));
+	return (PHYSFS_readULE32(fileHandle, &serializePower->currentPower)
+	     && PHYSFS_readULE32(fileHandle, &serializePower->extractedPower));
 }
 
 static bool serializeVector3i(PHYSFS_file* fileHandle, const Vector3i* serializeVector)
 {
-	return (PHYSFS_writeSBE32(fileHandle, serializeVector->x)
-	     && PHYSFS_writeSBE32(fileHandle, serializeVector->y)
-	     && PHYSFS_writeSBE32(fileHandle, serializeVector->z));
+	return (PHYSFS_writeSLE32(fileHandle, serializeVector->x)
+	     && PHYSFS_writeSLE32(fileHandle, serializeVector->y)
+	     && PHYSFS_writeSLE32(fileHandle, serializeVector->z));
 }
 
 static bool deserializeVector3i(PHYSFS_file* fileHandle, Vector3i* serializeVector)
 {
 	int32_t x, y, z;
 
-	if (!PHYSFS_readSBE32(fileHandle, &x)
-	 || !PHYSFS_readSBE32(fileHandle, &y)
-	 || !PHYSFS_readSBE32(fileHandle, &z))
+	if (!PHYSFS_readSLE32(fileHandle, &x)
+	 || !PHYSFS_readSLE32(fileHandle, &y)
+	 || !PHYSFS_readSLE32(fileHandle, &z))
 		return false;
 
 	serializeVector-> x = x;
@@ -310,16 +310,16 @@ static bool deserializeVector3i(PHYSFS_f
 
 static bool serializeVector2i(PHYSFS_file* fileHandle, const Vector2i* serializeVector)
 {
-	return (PHYSFS_writeSBE32(fileHandle, serializeVector->x)
-	     && PHYSFS_writeSBE32(fileHandle, serializeVector->y));
+	return (PHYSFS_writeSLE32(fileHandle, serializeVector->x)
+	     && PHYSFS_writeSLE32(fileHandle, serializeVector->y));
 }
 
 static bool deserializeVector2i(PHYSFS_file* fileHandle, Vector2i* serializeVector)
 {
 	int32_t x, y;
 
-	if (!PHYSFS_readSBE32(fileHandle, &x)
-	 || !PHYSFS_readSBE32(fileHandle, &y))
+	if (!PHYSFS_readSLE32(fileHandle, &x)
+	 || !PHYSFS_readSLE32(fileHandle, &y))
 		return false;
 
 	serializeVector-> x = x;
@@ -343,64 +343,64 @@ static bool serializeRunData(PHYSFS_file
 static bool serializeRunData(PHYSFS_file* fileHandle, const RUN_DATA* serializeRun)
 {
 	return (serializeVector2i(fileHandle, &serializeRun->sPos)
-	     && PHYSFS_writeUBE8(fileHandle, serializeRun->forceLevel)
-	     && PHYSFS_writeUBE8(fileHandle, serializeRun->healthLevel)
-	     && PHYSFS_writeUBE8(fileHandle, serializeRun->leadership));
+	     && PHYSFS_writeULE8(fileHandle, serializeRun->forceLevel)
+	     && PHYSFS_writeULE8(fileHandle, serializeRun->healthLevel)
+	     && PHYSFS_writeULE8(fileHandle, serializeRun->leadership));
 }
 
 static bool deserializeRunData(PHYSFS_file* fileHandle, RUN_DATA* serializeRun)
 {
 	return (deserializeVector2i(fileHandle, &serializeRun->sPos)
-	     && PHYSFS_readUBE8(fileHandle, &serializeRun->forceLevel)
-	     && PHYSFS_readUBE8(fileHandle, &serializeRun->healthLevel)
-	     && PHYSFS_readUBE8(fileHandle, &serializeRun->leadership));
+	     && PHYSFS_readULE8(fileHandle, &serializeRun->forceLevel)
+	     && PHYSFS_readULE8(fileHandle, &serializeRun->healthLevel)
+	     && PHYSFS_readULE8(fileHandle, &serializeRun->leadership));
 }
 
 static bool serializeLandingZoneData(PHYSFS_file* fileHandle, const LANDING_ZONE* serializeLandZone)
 {
-	return (PHYSFS_writeUBE8(fileHandle, serializeLandZone->x1)
-	     && PHYSFS_writeUBE8(fileHandle, serializeLandZone->y1)
-	     && PHYSFS_writeUBE8(fileHandle, serializeLandZone->x2)
-	     && PHYSFS_writeUBE8(fileHandle, serializeLandZone->y2));
+	return (PHYSFS_writeULE8(fileHandle, serializeLandZone->x1)
+	     && PHYSFS_writeULE8(fileHandle, serializeLandZone->y1)
+	     && PHYSFS_writeULE8(fileHandle, serializeLandZone->x2)
+	     && PHYSFS_writeULE8(fileHandle, serializeLandZone->y2));
 }
 
 static bool deserializeLandingZoneData(PHYSFS_file* fileHandle, LANDING_ZONE* serializeLandZone)
 {
-	return (PHYSFS_readUBE8(fileHandle, &serializeLandZone->x1)
-	     && PHYSFS_readUBE8(fileHandle, &serializeLandZone->y1)
-	     && PHYSFS_readUBE8(fileHandle, &serializeLandZone->x2)
-	     && PHYSFS_readUBE8(fileHandle, &serializeLandZone->y2));
+	return (PHYSFS_readULE8(fileHandle, &serializeLandZone->x1)
+	     && PHYSFS_readULE8(fileHandle, &serializeLandZone->y1)
+	     && PHYSFS_readULE8(fileHandle, &serializeLandZone->x2)
+	     && PHYSFS_readULE8(fileHandle, &serializeLandZone->y2));
 }
 
 static bool serializeMultiplayerGame(PHYSFS_file* fileHandle, const MULTIPLAYERGAME* serializeMulti)
 {
 	unsigned int i;
 
-	if (!PHYSFS_writeUBE8(fileHandle, serializeMulti->type)
+	if (!PHYSFS_writeULE8(fileHandle, serializeMulti->type)
 	 || PHYSFS_write(fileHandle, serializeMulti->map, 1, 128) != 128
 	 || PHYSFS_write(fileHandle, serializeMulti->version, 1, 8) != 8
-	 || !PHYSFS_writeUBE8(fileHandle, serializeMulti->maxPlayers)
+	 || !PHYSFS_writeULE8(fileHandle, serializeMulti->maxPlayers)
 	 || PHYSFS_write(fileHandle, serializeMulti->name, 1, 128) != 128
-	 || !PHYSFS_writeSBE32(fileHandle, serializeMulti->fog)
-	 || !PHYSFS_writeUBE32(fileHandle, serializeMulti->power)
-//	 || !PHYSFS_writeUBE8(fileHandle, serializeMulti->techLevel)
-	 || !PHYSFS_writeUBE8(fileHandle, serializeMulti->base)
-	 || !PHYSFS_writeUBE8(fileHandle, serializeMulti->alliance)
-	 || !PHYSFS_writeUBE8(fileHandle, serializeMulti->limit)
-	 || !PHYSFS_writeUBE16(fileHandle, serializeMulti->bytesPerSec)
-	 || !PHYSFS_writeUBE8(fileHandle, serializeMulti->packetsPerSec)
-	 || !PHYSFS_writeUBE8(fileHandle, serializeMulti->encryptKey))
+	 || !PHYSFS_writeSLE32(fileHandle, serializeMulti->fog)
+	 || !PHYSFS_writeULE32(fileHandle, serializeMulti->power)
+//	 || !PHYSFS_writeULE8(fileHandle, serializeMulti->techLevel)
+	 || !PHYSFS_writeULE8(fileHandle, serializeMulti->base)
+	 || !PHYSFS_writeULE8(fileHandle, serializeMulti->alliance)
+	 || !PHYSFS_writeULE8(fileHandle, serializeMulti->limit)
+	 || !PHYSFS_writeULE16(fileHandle, serializeMulti->bytesPerSec)
+	 || !PHYSFS_writeULE8(fileHandle, serializeMulti->packetsPerSec)
+	 || !PHYSFS_writeULE8(fileHandle, serializeMulti->encryptKey))
 		return false;
 
 //	for (i = 0; i < MAX_PLAYERS; ++i)
 //	{
-//		if (!PHYSFS_writeUBE8(fileHandle, serializeMulti->skirmishPlayers[i]))
+//		if (!PHYSFS_writeULE8(fileHandle, serializeMulti->skirmishPlayers[i]))
 //			return false;
 //	}
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-		if (!PHYSFS_writeUBE8(fileHandle, serializeMulti->skDiff[i]))
+		if (!PHYSFS_writeULE8(fileHandle, serializeMulti->skDiff[i]))
 			return false;
 	}
 
@@ -412,34 +412,34 @@ static bool deserializeMultiplayerGame(P
 	unsigned int i;
 	int32_t boolFog;
 
-	if (!PHYSFS_readUBE8(fileHandle, &serializeMulti->type)
+	if (!PHYSFS_readULE8(fileHandle, &serializeMulti->type)
 	 || PHYSFS_read(fileHandle, serializeMulti->map, 1, 128) != 128
 	 || PHYSFS_read(fileHandle, serializeMulti->version, 1, 8) != 8
-	 || !PHYSFS_readUBE8(fileHandle, &serializeMulti->maxPlayers)
+	 || !PHYSFS_readULE8(fileHandle, &serializeMulti->maxPlayers)
 	 || PHYSFS_read(fileHandle, serializeMulti->name, 1, 128) != 128
-	 || !PHYSFS_readSBE32(fileHandle, &boolFog)
-	 || !PHYSFS_readUBE32(fileHandle, &serializeMulti->power)
-//	 || !PHYSFS_readUBE8(fileHandle, &serializeMulti->techLevel)
-	 || !PHYSFS_readUBE8(fileHandle, &serializeMulti->base)
-	 || !PHYSFS_readUBE8(fileHandle, &serializeMulti->alliance)
-	 || !PHYSFS_readUBE8(fileHandle, &serializeMulti->limit)
-
-	 || !PHYSFS_readUBE16(fileHandle, &serializeMulti->bytesPerSec)
-	 || !PHYSFS_readUBE8(fileHandle, &serializeMulti->packetsPerSec)
-	 || !PHYSFS_readUBE8(fileHandle, &serializeMulti->encryptKey))
+	 || !PHYSFS_readSLE32(fileHandle, &boolFog)
+	 || !PHYSFS_readULE32(fileHandle, &serializeMulti->power)
+//	 || !PHYSFS_readULE8(fileHandle, &serializeMulti->techLevel)
+	 || !PHYSFS_readULE8(fileHandle, &serializeMulti->base)
+	 || !PHYSFS_readULE8(fileHandle, &serializeMulti->alliance)
+	 || !PHYSFS_readULE8(fileHandle, &serializeMulti->limit)
+
+	 || !PHYSFS_readULE16(fileHandle, &serializeMulti->bytesPerSec)
+	 || !PHYSFS_readULE8(fileHandle, &serializeMulti->packetsPerSec)
+	 || !PHYSFS_readULE8(fileHandle, &serializeMulti->encryptKey))
 		return false;
 
 	serializeMulti->fog = boolFog;
 
 //	for (i = 0; i < MAX_PLAYERS; ++i)
 //	{
-//		if (!PHYSFS_readUBE8(fileHandle, &serializeMulti->skirmishPlayers[i]))
+//		if (!PHYSFS_readULE8(fileHandle, &serializeMulti->skirmishPlayers[i]))
 //			return false;
 //	}
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-		if (!PHYSFS_readUBE8(fileHandle, &serializeMulti->skDiff[i]))
+		if (!PHYSFS_readULE8(fileHandle, &serializeMulti->skDiff[i]))
 			return false;
 	}
 
@@ -448,28 +448,28 @@ static bool deserializeMultiplayerGame(P
 
 static bool serializeSessionDesc(PHYSFS_file* fileHandle, const SESSIONDESC* serializeDesc)
 {
-	return (PHYSFS_writeSBE32(fileHandle, serializeDesc->dwSize)
-	     && PHYSFS_writeSBE32(fileHandle, serializeDesc->dwFlags)
+	return (PHYSFS_writeSLE32(fileHandle, serializeDesc->dwSize)
+	     && PHYSFS_writeSLE32(fileHandle, serializeDesc->dwFlags)
 	     && PHYSFS_write(fileHandle, serializeDesc->host, 1, 16) == 16
-	     && PHYSFS_writeSBE32(fileHandle, serializeDesc->dwMaxPlayers)
-	     && PHYSFS_writeSBE32(fileHandle, serializeDesc->dwCurrentPlayers)
-	     && PHYSFS_writeSBE32(fileHandle, serializeDesc->dwUser1)
-	     && PHYSFS_writeSBE32(fileHandle, serializeDesc->dwUser2)
-	     && PHYSFS_writeSBE32(fileHandle, serializeDesc->dwUser3)
-	     && PHYSFS_writeSBE32(fileHandle, serializeDesc->dwUser4));
+	     && PHYSFS_writeSLE32(fileHandle, serializeDesc->dwMaxPlayers)
+	     && PHYSFS_writeSLE32(fileHandle, serializeDesc->dwCurrentPlayers)
+	     && PHYSFS_writeSLE32(fileHandle, serializeDesc->dwUser1)
+	     && PHYSFS_writeSLE32(fileHandle, serializeDesc->dwUser2)
+	     && PHYSFS_writeSLE32(fileHandle, serializeDesc->dwUser3)
+	     && PHYSFS_writeSLE32(fileHandle, serializeDesc->dwUser4));
 }
 
 static bool deserializeSessionDesc(PHYSFS_file* fileHandle, SESSIONDESC* serializeDesc)
 {
-	return (PHYSFS_readSBE32(fileHandle, &serializeDesc->dwSize)
-	     && PHYSFS_readSBE32(fileHandle, &serializeDesc->dwFlags)
+	return (PHYSFS_readSLE32(fileHandle, &serializeDesc->dwSize)
+	     && PHYSFS_readSLE32(fileHandle, &serializeDesc->dwFlags)
 	     && PHYSFS_read(fileHandle, serializeDesc->host, 1, 16) == 16
-	     && PHYSFS_readSBE32(fileHandle, &serializeDesc->dwMaxPlayers)
-	     && PHYSFS_readSBE32(fileHandle, &serializeDesc->dwCurrentPlayers)
-	     && PHYSFS_readSBE32(fileHandle, &serializeDesc->dwUser1)
-	     && PHYSFS_readSBE32(fileHandle, &serializeDesc->dwUser2)
-	     && PHYSFS_readSBE32(fileHandle, &serializeDesc->dwUser3)
-	     && PHYSFS_readSBE32(fileHandle, &serializeDesc->dwUser4));
+	     && PHYSFS_readSLE32(fileHandle, &serializeDesc->dwMaxPlayers)
+	     && PHYSFS_readSLE32(fileHandle, &serializeDesc->dwCurrentPlayers)
+	     && PHYSFS_readSLE32(fileHandle, &serializeDesc->dwUser1)
+	     && PHYSFS_readSLE32(fileHandle, &serializeDesc->dwUser2)
+	     && PHYSFS_readSLE32(fileHandle, &serializeDesc->dwUser3)
+	     && PHYSFS_readSLE32(fileHandle, &serializeDesc->dwUser4));
 }
 
 static bool serializeGameStruct(PHYSFS_file* fileHandle, const GAMESTRUCT* serializeGame)
@@ -486,18 +486,18 @@ static bool deserializeGameStruct(PHYSFS
 
 static bool serializePlayer(PHYSFS_file* fileHandle, const PLAYER* serializePlayer)
 {
-	return (PHYSFS_writeUBE32(fileHandle, serializePlayer->dpid)
+	return (PHYSFS_writeULE32(fileHandle, serializePlayer->dpid)
 	     && PHYSFS_write(fileHandle, serializePlayer->name, StringSize, 1) == 1
-	     && PHYSFS_writeUBE32(fileHandle, serializePlayer->bHost)
-	     && PHYSFS_writeUBE32(fileHandle, serializePlayer->bSpectator));
+	     && PHYSFS_writeULE32(fileHandle, serializePlayer->bHost)
+	     && PHYSFS_writeULE32(fileHandle, serializePlayer->bSpectator));
 }
 
 static bool deserializePlayer(PHYSFS_file* fileHandle, PLAYER* serializePlayer)
 {
-	return (PHYSFS_readUBE32(fileHandle, &serializePlayer->dpid)
+	return (PHYSFS_readULE32(fileHandle, &serializePlayer->dpid)
 	     && PHYSFS_read(fileHandle, serializePlayer->name, StringSize, 1) == 1
-	     && PHYSFS_readUBE32(fileHandle, &serializePlayer->bHost)
-	     && PHYSFS_readUBE32(fileHandle, &serializePlayer->bSpectator));
+	     && PHYSFS_readULE32(fileHandle, &serializePlayer->bHost)
+	     && PHYSFS_readULE32(fileHandle, &serializePlayer->bSpectator));
 }
 
 static bool serializeNetPlay(PHYSFS_file* fileHandle, const NETPLAY* serializeNetPlay)
@@ -516,13 +516,13 @@ static bool serializeNetPlay(PHYSFS_file
 			return false;
 	}
 
-	return (PHYSFS_writeUBE32(fileHandle, serializeNetPlay->bComms)
-	     && PHYSFS_writeUBE32(fileHandle, serializeNetPlay->bHost)
-	     && PHYSFS_writeUBE32(fileHandle, serializeNetPlay->bLobbyLaunched)
-	     && PHYSFS_writeUBE32(fileHandle, serializeNetPlay->bSpectator)
-	     && PHYSFS_writeUBE32(fileHandle, serializeNetPlay->bCaptureInUse)
-	     && PHYSFS_writeUBE32(fileHandle, serializeNetPlay->bAllowCaptureRecord)
-	     && PHYSFS_writeUBE32(fileHandle, serializeNetPlay->bAllowCapturePlay));
+	return (PHYSFS_writeULE32(fileHandle, serializeNetPlay->bComms)
+	     && PHYSFS_writeULE32(fileHandle, serializeNetPlay->bHost)
+	     && PHYSFS_writeULE32(fileHandle, serializeNetPlay->bLobbyLaunched)
+	     && PHYSFS_writeULE32(fileHandle, serializeNetPlay->bSpectator)
+	     && PHYSFS_writeULE32(fileHandle, serializeNetPlay->bCaptureInUse)
+	     && PHYSFS_writeULE32(fileHandle, serializeNetPlay->bAllowCaptureRecord)
+	     && PHYSFS_writeULE32(fileHandle, serializeNetPlay->bAllowCapturePlay));
 }
 
 static bool deserializeNetPlay(PHYSFS_file* fileHandle, NETPLAY* serializeNetPlay)
@@ -541,13 +541,13 @@ static bool deserializeNetPlay(PHYSFS_fi
 			return false;
 	}
 
-	return (PHYSFS_readUBE32(fileHandle, &serializeNetPlay->bComms)
-	     && PHYSFS_readUBE32(fileHandle, &serializeNetPlay->bHost)
-	     && PHYSFS_readUBE32(fileHandle, &serializeNetPlay->bLobbyLaunched)
-	     && PHYSFS_readUBE32(fileHandle, &serializeNetPlay->bSpectator)
-	     && PHYSFS_readUBE32(fileHandle, &serializeNetPlay->bCaptureInUse)
-	     && PHYSFS_readUBE32(fileHandle, &serializeNetPlay->bAllowCaptureRecord)
-	     && PHYSFS_readUBE32(fileHandle, &serializeNetPlay->bAllowCapturePlay));
+	return (PHYSFS_readULE32(fileHandle, &serializeNetPlay->bComms)
+	     && PHYSFS_readULE32(fileHandle, &serializeNetPlay->bHost)
+	     && PHYSFS_readULE32(fileHandle, &serializeNetPlay->bLobbyLaunched)
+	     && PHYSFS_readULE32(fileHandle, &serializeNetPlay->bSpectator)
+	     && PHYSFS_readULE32(fileHandle, &serializeNetPlay->bCaptureInUse)
+	     && PHYSFS_readULE32(fileHandle, &serializeNetPlay->bAllowCaptureRecord)
+	     && PHYSFS_readULE32(fileHandle, &serializeNetPlay->bAllowCapturePlay));
 }
 
 #define GAME_SAVE_V7	\
@@ -566,23 +566,23 @@ typedef struct save_game_v7
 
 static bool serializeSaveGameV7Data(PHYSFS_file* fileHandle, const SAVE_GAME_V7* serializeGame)
 {
-	return (PHYSFS_writeUBE32(fileHandle, serializeGame->gameTime)
-	     && PHYSFS_writeUBE32(fileHandle, serializeGame->GameType)
-	     && PHYSFS_writeSBE32(fileHandle, serializeGame->ScrollMinX)
-	     && PHYSFS_writeSBE32(fileHandle, serializeGame->ScrollMinY)
-	     && PHYSFS_writeUBE32(fileHandle, serializeGame->ScrollMaxX)
-	     && PHYSFS_writeUBE32(fileHandle, serializeGame->ScrollMaxY)
+	return (PHYSFS_writeULE32(fileHandle, serializeGame->gameTime)
+	     && PHYSFS_writeULE32(fileHandle, serializeGame->GameType)
+	     && PHYSFS_writeSLE32(fileHandle, serializeGame->ScrollMinX)
+	     && PHYSFS_writeSLE32(fileHandle, serializeGame->ScrollMinY)
+	     && PHYSFS_writeULE32(fileHandle, serializeGame->ScrollMaxX)
+	     && PHYSFS_writeULE32(fileHandle, serializeGame->ScrollMaxY)
 	     && PHYSFS_write(fileHandle, serializeGame->levelName, MAX_LEVEL_SIZE, 1) == 1);
 }
 
 static bool deserializeSaveGameV7Data(PHYSFS_file* fileHandle, SAVE_GAME_V7* serializeGame)
 {
-	return (PHYSFS_readUBE32(fileHandle, &serializeGame->gameTime)
-	     && PHYSFS_readUBE32(fileHandle, &serializeGame->GameType)
-	     && PHYSFS_readSBE32(fileHandle, &serializeGame->ScrollMinX)
-	     && PHYSFS_readSBE32(fileHandle, &serializeGame->ScrollMinY)
-	     && PHYSFS_readUBE32(fileHandle, &serializeGame->ScrollMaxX)
-	     && PHYSFS_readUBE32(fileHandle, &serializeGame->ScrollMaxY)
+	return (PHYSFS_readULE32(fileHandle, &serializeGame->gameTime)
+	     && PHYSFS_readULE32(fileHandle, &serializeGame->GameType)
+	     && PHYSFS_readSLE32(fileHandle, &serializeGame->ScrollMinX)
+	     && PHYSFS_readSLE32(fileHandle, &serializeGame->ScrollMinY)
+	     && PHYSFS_readULE32(fileHandle, &serializeGame->ScrollMaxX)
+	     && PHYSFS_readULE32(fileHandle, &serializeGame->ScrollMaxY)
 	     && PHYSFS_read(fileHandle, serializeGame->levelName, MAX_LEVEL_SIZE, 1) == 1);
 }
 
@@ -661,15 +661,15 @@ static bool serializeSaveGameV12Data(PHY
 static bool serializeSaveGameV12Data(PHYSFS_file* fileHandle, const SAVE_GAME_V12* serializeGame)
 {
 	return (serializeSaveGameV11Data(fileHandle, (const SAVE_GAME_V11*) serializeGame)
-	     && PHYSFS_writeUBE32(fileHandle, serializeGame->missionTime)
-	     && PHYSFS_writeUBE32(fileHandle, serializeGame->saveKey));
+	     && PHYSFS_writeULE32(fileHandle, serializeGame->missionTime)
+	     && PHYSFS_writeULE32(fileHandle, serializeGame->saveKey));
 }
 
 static bool deserializeSaveGameV12Data(PHYSFS_file* fileHandle, SAVE_GAME_V12* serializeGame)
 {
 	return (deserializeSaveGameV11Data(fileHandle, (SAVE_GAME_V11*) serializeGame)
-	     && PHYSFS_readUBE32(fileHandle, &serializeGame->missionTime)
-	     && PHYSFS_readUBE32(fileHandle, &serializeGame->saveKey));
+	     && PHYSFS_readULE32(fileHandle, &serializeGame->missionTime)
+	     && PHYSFS_readULE32(fileHandle, &serializeGame->saveKey));
 }
 
 #define GAME_SAVE_V14			\
@@ -698,53 +698,53 @@ static bool serializeSaveGameV14Data(PHY
 	unsigned int i;
 
 	if (!serializeSaveGameV12Data(fileHandle, (const SAVE_GAME_V12*) serializeGame)
-	 || !PHYSFS_writeSBE32(fileHandle, serializeGame->missionOffTime)
-	 || !PHYSFS_writeSBE32(fileHandle, serializeGame->missionETA)
-	 || !PHYSFS_writeUBE16(fileHandle, serializeGame->missionHomeLZ_X)
-	 || !PHYSFS_writeUBE16(fileHandle, serializeGame->missionHomeLZ_Y)
-	 || !PHYSFS_writeSBE32(fileHandle, serializeGame->missionPlayerX)
-	 || !PHYSFS_writeSBE32(fileHandle, serializeGame->missionPlayerY))
+	 || !PHYSFS_writeSLE32(fileHandle, serializeGame->missionOffTime)
+	 || !PHYSFS_writeSLE32(fileHandle, serializeGame->missionETA)
+	 || !PHYSFS_writeULE16(fileHandle, serializeGame->missionHomeLZ_X)
+	 || !PHYSFS_writeULE16(fileHandle, serializeGame->missionHomeLZ_Y)
+	 || !PHYSFS_writeSLE32(fileHandle, serializeGame->missionPlayerX)
+	 || !PHYSFS_writeSLE32(fileHandle, serializeGame->missionPlayerY))
 		return false;
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-	     if (!PHYSFS_writeUBE16(fileHandle, serializeGame->iTranspEntryTileX[i]))
+	     if (!PHYSFS_writeULE16(fileHandle, serializeGame->iTranspEntryTileX[i]))
 		     return false;
 	}
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-	     if (!PHYSFS_writeUBE16(fileHandle, serializeGame->iTranspEntryTileY[i]))
+	     if (!PHYSFS_writeULE16(fileHandle, serializeGame->iTranspEntryTileY[i]))
 		     return false;
 	}
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-	     if (!PHYSFS_writeUBE16(fileHandle, serializeGame->iTranspExitTileX[i]))
+	     if (!PHYSFS_writeULE16(fileHandle, serializeGame->iTranspExitTileX[i]))
 		     return false;
 	}
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-	     if (!PHYSFS_writeUBE16(fileHandle, serializeGame->iTranspExitTileY[i]))
+	     if (!PHYSFS_writeULE16(fileHandle, serializeGame->iTranspExitTileY[i]))
 		     return false;
 	}
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-	     if (!PHYSFS_writeUBE32(fileHandle, serializeGame->aDefaultSensor[i]))
+	     if (!PHYSFS_writeULE32(fileHandle, serializeGame->aDefaultSensor[i]))
 		     return false;
 	}
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-	     if (!PHYSFS_writeUBE32(fileHandle, serializeGame->aDefaultECM[i]))
+	     if (!PHYSFS_writeULE32(fileHandle, serializeGame->aDefaultECM[i]))
 		     return false;
 	}
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-	     if (!PHYSFS_writeUBE32(fileHandle, serializeGame->aDefaultRepair[i]))
+	     if (!PHYSFS_writeULE32(fileHandle, serializeGame->aDefaultRepair[i]))
 		     return false;
 	}
 
@@ -756,53 +756,53 @@ static bool deserializeSaveGameV14Data(P
 	unsigned int i;
 
 	if (!deserializeSaveGameV12Data(fileHandle, (SAVE_GAME_V12*) serializeGame)
-	 || !PHYSFS_readSBE32(fileHandle, &serializeGame->missionOffTime)
-	 || !PHYSFS_readSBE32(fileHandle, &serializeGame->missionETA)
-	 || !PHYSFS_readUBE16(fileHandle, &serializeGame->missionHomeLZ_X)
-	 || !PHYSFS_readUBE16(fileHandle, &serializeGame->missionHomeLZ_Y)
-	 || !PHYSFS_readSBE32(fileHandle, &serializeGame->missionPlayerX)
-	 || !PHYSFS_readSBE32(fileHandle, &serializeGame->missionPlayerY))
+	 || !PHYSFS_readSLE32(fileHandle, &serializeGame->missionOffTime)
+	 || !PHYSFS_readSLE32(fileHandle, &serializeGame->missionETA)
+	 || !PHYSFS_readULE16(fileHandle, &serializeGame->missionHomeLZ_X)
+	 || !PHYSFS_readULE16(fileHandle, &serializeGame->missionHomeLZ_Y)
+	 || !PHYSFS_readSLE32(fileHandle, &serializeGame->missionPlayerX)
+	 || !PHYSFS_readSLE32(fileHandle, &serializeGame->missionPlayerY))
 		return false;
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-	     if (!PHYSFS_readUBE16(fileHandle, &serializeGame->iTranspEntryTileX[i]))
+	     if (!PHYSFS_readULE16(fileHandle, &serializeGame->iTranspEntryTileX[i]))
 		     return false;
 	}
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-	     if (!PHYSFS_readUBE16(fileHandle, &serializeGame->iTranspEntryTileY[i]))
+	     if (!PHYSFS_readULE16(fileHandle, &serializeGame->iTranspEntryTileY[i]))
 		     return false;
 	}
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-	     if (!PHYSFS_readUBE16(fileHandle, &serializeGame->iTranspExitTileX[i]))
+	     if (!PHYSFS_readULE16(fileHandle, &serializeGame->iTranspExitTileX[i]))
 		     return false;
 	}
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-	     if (!PHYSFS_readUBE16(fileHandle, &serializeGame->iTranspExitTileY[i]))
+	     if (!PHYSFS_readULE16(fileHandle, &serializeGame->iTranspExitTileY[i]))
 		     return false;
 	}
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-	     if (!PHYSFS_readUBE32(fileHandle, &serializeGame->aDefaultSensor[i]))
+	     if (!PHYSFS_readULE32(fileHandle, &serializeGame->aDefaultSensor[i]))
 		     return false;
 	}
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-	     if (!PHYSFS_readUBE32(fileHandle, &serializeGame->aDefaultECM[i]))
+	     if (!PHYSFS_readULE32(fileHandle, &serializeGame->aDefaultECM[i]))
 		     return false;
 	}
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-	     if (!PHYSFS_readUBE32(fileHandle, &serializeGame->aDefaultRepair[i]))
+	     if (!PHYSFS_readULE32(fileHandle, &serializeGame->aDefaultRepair[i]))
 		     return false;
 	}
 
@@ -828,22 +828,22 @@ static bool serializeSaveGameV15Data(PHY
 	unsigned int i, j;
 
 	if (!serializeSaveGameV14Data(fileHandle, (const SAVE_GAME_V14*) serializeGame)
-	 || !PHYSFS_writeSBE32(fileHandle, serializeGame->offWorldKeepLists))
+	 || !PHYSFS_writeSLE32(fileHandle, serializeGame->offWorldKeepLists))
 		return false;
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
 		for (j = 0; j < MAX_RECYCLED_DROIDS; ++j)
 		{
-			if (!PHYSFS_writeUBE8(fileHandle, serializeGame->aDroidExperience[i][j]))
+			if (!PHYSFS_writeULE8(fileHandle, serializeGame->aDroidExperience[i][j]))
 				return false;
 		}
 	}
 
-	return (PHYSFS_writeUBE32(fileHandle, serializeGame->RubbleTile)
-	     && PHYSFS_writeUBE32(fileHandle, serializeGame->WaterTile)
-	     && PHYSFS_writeUBE32(fileHandle, serializeGame->fogColour)
-	     && PHYSFS_writeUBE32(fileHandle, serializeGame->fogState));
+	return (PHYSFS_writeULE32(fileHandle, serializeGame->RubbleTile)
+	     && PHYSFS_writeULE32(fileHandle, serializeGame->WaterTile)
+	     && PHYSFS_writeULE32(fileHandle, serializeGame->fogColour)
+	     && PHYSFS_writeULE32(fileHandle, serializeGame->fogState));
 }
 
 static bool deserializeSaveGameV15Data(PHYSFS_file* fileHandle, SAVE_GAME_V15* serializeGame)
@@ -852,7 +852,7 @@ static bool deserializeSaveGameV15Data(P
 	int32_t boolOffWorldKeepLists;
 
 	if (!deserializeSaveGameV14Data(fileHandle, (SAVE_GAME_V14*) serializeGame)
-	 || !PHYSFS_readSBE32(fileHandle, &boolOffWorldKeepLists))
+	 || !PHYSFS_readSLE32(fileHandle, &boolOffWorldKeepLists))
 		return false;
 
 	serializeGame->offWorldKeepLists = boolOffWorldKeepLists;
@@ -861,15 +861,15 @@ static bool deserializeSaveGameV15Data(P
 	{
 		for (j = 0; j < MAX_RECYCLED_DROIDS; ++j)
 		{
-			if (!PHYSFS_readUBE8(fileHandle, &serializeGame->aDroidExperience[i][j]))
+			if (!PHYSFS_readULE8(fileHandle, &serializeGame->aDroidExperience[i][j]))
 				return false;
 		}
 	}
 
-	return (PHYSFS_readUBE32(fileHandle, &serializeGame->RubbleTile)
-	     && PHYSFS_readUBE32(fileHandle, &serializeGame->WaterTile)
-	     && PHYSFS_readUBE32(fileHandle, &serializeGame->fogColour)
-	     && PHYSFS_readUBE32(fileHandle, &serializeGame->fogState));
+	return (PHYSFS_readULE32(fileHandle, &serializeGame->RubbleTile)
+	     && PHYSFS_readULE32(fileHandle, &serializeGame->WaterTile)
+	     && PHYSFS_readULE32(fileHandle, &serializeGame->fogColour)
+	     && PHYSFS_readULE32(fileHandle, &serializeGame->fogState));
 }
 
 #define GAME_SAVE_V16			\
@@ -925,13 +925,13 @@ static bool serializeSaveGameV17Data(PHY
 static bool serializeSaveGameV17Data(PHYSFS_file* fileHandle, const SAVE_GAME_V17* serializeGame)
 {
 	return (serializeSaveGameV16Data(fileHandle, (const SAVE_GAME_V16*) serializeGame)
-	     && PHYSFS_writeUBE32(fileHandle, serializeGame->objId));
+	     && PHYSFS_writeULE32(fileHandle, serializeGame->objId));
 }
 
 static bool deserializeSaveGameV17Data(PHYSFS_file* fileHandle, SAVE_GAME_V17* serializeGame)
 {
 	return (deserializeSaveGameV16Data(fileHandle, (SAVE_GAME_V16*) serializeGame)
-	     && PHYSFS_readUBE32(fileHandle, &serializeGame->objId));
+	     && PHYSFS_readULE32(fileHandle, &serializeGame->objId));
 }
 
 #define GAME_SAVE_V18			\
@@ -949,16 +949,16 @@ static bool serializeSaveGameV18Data(PHY
 {
 	return (serializeSaveGameV17Data(fileHandle, (const SAVE_GAME_V17*) serializeGame)
 	     && PHYSFS_write(fileHandle, serializeGame->buildDate, MAX_STR_LENGTH, 1) == 1
-	     && PHYSFS_writeUBE32(fileHandle, serializeGame->oldestVersion)
-	     && PHYSFS_writeUBE32(fileHandle, serializeGame->validityKey));
+	     && PHYSFS_writeULE32(fileHandle, serializeGame->oldestVersion)
+	     && PHYSFS_writeULE32(fileHandle, serializeGame->validityKey));
 }
 
 static bool deserializeSaveGameV18Data(PHYSFS_file* fileHandle, SAVE_GAME_V18* serializeGame)
 {
 	return (deserializeSaveGameV17Data(fileHandle, (SAVE_GAME_V17*) serializeGame)
 	     && PHYSFS_read(fileHandle, serializeGame->buildDate, MAX_STR_LENGTH, 1) == 1
-	     && PHYSFS_readUBE32(fileHandle, &serializeGame->oldestVersion)
-	     && PHYSFS_readUBE32(fileHandle, &serializeGame->validityKey));
+	     && PHYSFS_readULE32(fileHandle, &serializeGame->oldestVersion)
+	     && PHYSFS_readULE32(fileHandle, &serializeGame->validityKey));
 }
 
 #define GAME_SAVE_V19			\
@@ -983,18 +983,18 @@ static bool serializeSaveGameV19Data(PHY
 	{
 		for (j = 0; j < MAX_PLAYERS; ++j)
 		{
-			if (!PHYSFS_writeUBE8(fileHandle, serializeGame->alliances[i][j]))
+			if (!PHYSFS_writeULE8(fileHandle, serializeGame->alliances[i][j]))
 				return false;
 		}
 	}
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-		if (!PHYSFS_writeUBE8(fileHandle, serializeGame->playerColour[i]))
+		if (!PHYSFS_writeULE8(fileHandle, serializeGame->playerColour[i]))
 			return false;
 	}
 
-	return PHYSFS_writeUBE8(fileHandle, serializeGame->radarZoom);
+	return PHYSFS_writeULE8(fileHandle, serializeGame->radarZoom);
 }
 
 static bool deserializeSaveGameV19Data(PHYSFS_file* fileHandle, SAVE_GAME_V19* serializeGame)
@@ -1008,18 +1008,18 @@ static bool deserializeSaveGameV19Data(P
 	{
 		for (j = 0; j < MAX_PLAYERS; ++j)
 		{
-			if (!PHYSFS_readUBE8(fileHandle, &serializeGame->alliances[i][j]))
+			if (!PHYSFS_readULE8(fileHandle, &serializeGame->alliances[i][j]))
 				return false;
 		}
 	}
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-		if (!PHYSFS_readUBE8(fileHandle, &serializeGame->playerColour[i]))
+		if (!PHYSFS_readULE8(fileHandle, &serializeGame->playerColour[i]))
 			return false;
 	}
 
-	return PHYSFS_readUBE8(fileHandle, &serializeGame->radarZoom);
+	return PHYSFS_readULE8(fileHandle, &serializeGame->radarZoom);
 }
 
 #define GAME_SAVE_V20			\
@@ -1037,7 +1037,7 @@ static bool serializeSaveGameV20Data(PHY
 	unsigned int i;
 
 	if (!serializeSaveGameV19Data(fileHandle, (const SAVE_GAME_V19*) serializeGame)
-	 || !PHYSFS_writeUBE8(fileHandle, serializeGame->bDroidsToSafetyFlag))
+	 || !PHYSFS_writeULE8(fileHandle, serializeGame->bDroidsToSafetyFlag))
 		return false;
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
@@ -1054,7 +1054,7 @@ static bool deserializeSaveGameV20Data(P
 	unsigned int i;
 
 	if (!deserializeSaveGameV19Data(fileHandle, (SAVE_GAME_V19*) serializeGame)
-	 || !PHYSFS_readUBE8(fileHandle, &serializeGame->bDroidsToSafetyFlag))
+	 || !PHYSFS_readULE8(fileHandle, &serializeGame->bDroidsToSafetyFlag))
 		return false;
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
@@ -1123,21 +1123,21 @@ static bool serializeSaveGameV24Data(PHY
 static bool serializeSaveGameV24Data(PHYSFS_file* fileHandle, const SAVE_GAME_V24* serializeGame)
 {
 	return (serializeSaveGameV22Data(fileHandle, (const SAVE_GAME_V22*) serializeGame)
-	     && PHYSFS_writeUBE32(fileHandle, serializeGame->reinforceTime)
-	     && PHYSFS_writeUBE8(fileHandle, serializeGame->bPlayCountDown)
-	     && PHYSFS_writeUBE8(fileHandle, serializeGame->bPlayerHasWon)
-	     && PHYSFS_writeUBE8(fileHandle, serializeGame->bPlayerHasLost)
-	     && PHYSFS_writeUBE8(fileHandle, serializeGame->dummy3));
+	     && PHYSFS_writeULE32(fileHandle, serializeGame->reinforceTime)
+	     && PHYSFS_writeULE8(fileHandle, serializeGame->bPlayCountDown)
+	     && PHYSFS_writeULE8(fileHandle, serializeGame->bPlayerHasWon)
+	     && PHYSFS_writeULE8(fileHandle, serializeGame->bPlayerHasLost)
+	     && PHYSFS_writeULE8(fileHandle, serializeGame->dummy3));
 }
 
 static bool deserializeSaveGameV24Data(PHYSFS_file* fileHandle, SAVE_GAME_V24* serializeGame)
 {
 	return (deserializeSaveGameV22Data(fileHandle, (SAVE_GAME_V22*) serializeGame)
-	     && PHYSFS_readUBE32(fileHandle, &serializeGame->reinforceTime)
-	     && PHYSFS_readUBE8(fileHandle, &serializeGame->bPlayCountDown)
-	     && PHYSFS_readUBE8(fileHandle, &serializeGame->bPlayerHasWon)
-	     && PHYSFS_readUBE8(fileHandle, &serializeGame->bPlayerHasLost)
-	     && PHYSFS_readUBE8(fileHandle, &serializeGame->dummy3));
+	     && PHYSFS_readULE32(fileHandle, &serializeGame->reinforceTime)
+	     && PHYSFS_readULE8(fileHandle, &serializeGame->bPlayCountDown)
+	     && PHYSFS_readULE8(fileHandle, &serializeGame->bPlayerHasWon)
+	     && PHYSFS_readULE8(fileHandle, &serializeGame->bPlayerHasLost)
+	     && PHYSFS_readULE8(fileHandle, &serializeGame->dummy3));
 }
 
 /*
@@ -1169,7 +1169,7 @@ static bool serializeSaveGameV27Data(PHY
 	{
 		for (j = 0; j < MAX_RECYCLED_DROIDS; ++j)
 		{
-			if (!PHYSFS_writeUBE16(fileHandle, serializeGame->awDroidExperience[i][j]))
+			if (!PHYSFS_writeULE16(fileHandle, serializeGame->awDroidExperience[i][j]))
 				return false;
 		}
 	}
@@ -1188,7 +1188,7 @@ static bool deserializeSaveGameV27Data(P
 	{
 		for (j = 0; j < MAX_RECYCLED_DROIDS; ++j)
 		{
-			if (!PHYSFS_readUBE16(fileHandle, &serializeGame->awDroidExperience[i][j]))
+			if (!PHYSFS_readULE16(fileHandle, &serializeGame->awDroidExperience[i][j]))
 				return false;
 		}
 	}
@@ -1211,19 +1211,19 @@ static bool serializeSaveGameV29Data(PHY
 static bool serializeSaveGameV29Data(PHYSFS_file* fileHandle, const SAVE_GAME_V29* serializeGame)
 {
 	return (serializeSaveGameV27Data(fileHandle, (const SAVE_GAME_V27*) serializeGame)
-	     && PHYSFS_writeUBE16(fileHandle, serializeGame->missionScrollMinX)
-	     && PHYSFS_writeUBE16(fileHandle, serializeGame->missionScrollMinY)
-	     && PHYSFS_writeUBE16(fileHandle, serializeGame->missionScrollMaxX)
-	     && PHYSFS_writeUBE16(fileHandle, serializeGame->missionScrollMaxY));
+	     && PHYSFS_writeULE16(fileHandle, serializeGame->missionScrollMinX)
+	     && PHYSFS_writeULE16(fileHandle, serializeGame->missionScrollMinY)
+	     && PHYSFS_writeULE16(fileHandle, serializeGame->missionScrollMaxX)
+	     && PHYSFS_writeULE16(fileHandle, serializeGame->missionScrollMaxY));
 }
 
 static bool deserializeSaveGameV29Data(PHYSFS_file* fileHandle, SAVE_GAME_V29* serializeGame)
 {
 	return (deserializeSaveGameV27Data(fileHandle, (SAVE_GAME_V27*) serializeGame)
-	     && PHYSFS_readUBE16(fileHandle, &serializeGame->missionScrollMinX)
-	     && PHYSFS_readUBE16(fileHandle, &serializeGame->missionScrollMinY)
-	     && PHYSFS_readUBE16(fileHandle, &serializeGame->missionScrollMaxX)
-	     && PHYSFS_readUBE16(fileHandle, &serializeGame->missionScrollMaxY));
+	     && PHYSFS_readULE16(fileHandle, &serializeGame->missionScrollMinX)
+	     && PHYSFS_readULE16(fileHandle, &serializeGame->missionScrollMinY)
+	     && PHYSFS_readULE16(fileHandle, &serializeGame->missionScrollMaxX)
+	     && PHYSFS_readULE16(fileHandle, &serializeGame->missionScrollMaxY));
 }
 
 #define GAME_SAVE_V30			\
@@ -1241,19 +1241,19 @@ static bool serializeSaveGameV30Data(PHY
 static bool serializeSaveGameV30Data(PHYSFS_file* fileHandle, const SAVE_GAME_V30* serializeGame)
 {
 	return (serializeSaveGameV29Data(fileHandle, (const SAVE_GAME_V29*) serializeGame)
-	     && PHYSFS_writeSBE32(fileHandle, serializeGame->scrGameLevel)
-	     && PHYSFS_writeUBE8(fileHandle, serializeGame->bExtraVictoryFlag)
-	     && PHYSFS_writeUBE8(fileHandle, serializeGame->bExtraFailFlag)
-	     && PHYSFS_writeUBE8(fileHandle, serializeGame->bTrackTransporter));
+	     && PHYSFS_writeSLE32(fileHandle, serializeGame->scrGameLevel)
+	     && PHYSFS_writeULE8(fileHandle, serializeGame->bExtraVictoryFlag)
+	     && PHYSFS_writeULE8(fileHandle, serializeGame->bExtraFailFlag)
+	     && PHYSFS_writeULE8(fileHandle, serializeGame->bTrackTransporter));
 }
 
 static bool deserializeSaveGameV30Data(PHYSFS_file* fileHandle, SAVE_GAME_V30* serializeGame)
 {
 	return (deserializeSaveGameV29Data(fileHandle, (SAVE_GAME_V29*) serializeGame)
-	     && PHYSFS_readSBE32(fileHandle, &serializeGame->scrGameLevel)
-	     && PHYSFS_readUBE8(fileHandle, &serializeGame->bExtraVictoryFlag)
-	     && PHYSFS_readUBE8(fileHandle, &serializeGame->bExtraFailFlag)
-	     && PHYSFS_readUBE8(fileHandle, &serializeGame->bTrackTransporter));
+	     && PHYSFS_readSLE32(fileHandle, &serializeGame->scrGameLevel)
+	     && PHYSFS_readULE8(fileHandle, &serializeGame->bExtraVictoryFlag)
+	     && PHYSFS_readULE8(fileHandle, &serializeGame->bExtraFailFlag)
+	     && PHYSFS_readULE8(fileHandle, &serializeGame->bTrackTransporter));
 }
 
 //extra code for the patch - saves out whether cheated with the mission timer
@@ -1270,13 +1270,13 @@ static bool serializeSaveGameV31Data(PHY
 static bool serializeSaveGameV31Data(PHYSFS_file* fileHandle, const SAVE_GAME_V31* serializeGame)
 {
 	return (serializeSaveGameV30Data(fileHandle, (const SAVE_GAME_V30*) serializeGame)
-	     && PHYSFS_writeSBE32(fileHandle, serializeGame->missionCheatTime));
+	     && PHYSFS_writeSLE32(fileHandle, serializeGame->missionCheatTime));
 }
 
 static bool deserializeSaveGameV31Data(PHYSFS_file* fileHandle, SAVE_GAME_V31* serializeGame)
 {
 	return (deserializeSaveGameV30Data(fileHandle, (SAVE_GAME_V30*) serializeGame)
-	     && PHYSFS_readSBE32(fileHandle, &serializeGame->missionCheatTime));
+	     && PHYSFS_readSLE32(fileHandle, &serializeGame->missionCheatTime));
 }
 
 // alexl. skirmish saves
@@ -1301,14 +1301,14 @@ static bool serializeSaveGameV33Data(PHY
 	if (!serializeSaveGameV31Data(fileHandle, (const SAVE_GAME_V31*) serializeGame)
 	 || !serializeMultiplayerGame(fileHandle, &serializeGame->sGame)
 	 || !serializeNetPlay(fileHandle, &serializeGame->sNetPlay)
-	 || !PHYSFS_writeUBE32(fileHandle, serializeGame->savePlayer)
+	 || !PHYSFS_writeULE32(fileHandle, serializeGame->savePlayer)
 	 || !PHYSFS_write(fileHandle, serializeGame->sPName, 1, 32) == 32
-	 || !PHYSFS_writeSBE32(fileHandle, serializeGame->multiPlayer))
+	 || !PHYSFS_writeSLE32(fileHandle, serializeGame->multiPlayer))
 		return false;
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-		if (!PHYSFS_writeUBE32(fileHandle, serializeGame->sPlayer2dpid[i]))
+		if (!PHYSFS_writeULE32(fileHandle, serializeGame->sPlayer2dpid[i]))
 			return false;
 	}
 
@@ -1323,16 +1323,16 @@ static bool deserializeSaveGameV33Data(P
 	if (!deserializeSaveGameV31Data(fileHandle, (SAVE_GAME_V31*) serializeGame)
 	 || !deserializeMultiplayerGame(fileHandle, &serializeGame->sGame)
 	 || !deserializeNetPlay(fileHandle, &serializeGame->sNetPlay)
-	 || !PHYSFS_readUBE32(fileHandle, &serializeGame->savePlayer)
+	 || !PHYSFS_readULE32(fileHandle, &serializeGame->savePlayer)
 	 || PHYSFS_read(fileHandle, serializeGame->sPName, 1, 32) != 32
-	 || !PHYSFS_readSBE32(fileHandle, &boolMultiPlayer))
+	 || !PHYSFS_readSLE32(fileHandle, &boolMultiPlayer))
 		return false;
 
 	serializeGame->multiPlayer = boolMultiPlayer;
 
 	for (i = 0; i < MAX_PLAYERS; ++i)
 	{
-		if (!PHYSFS_readUBE32(fileHandle, &serializeGame->sPlayer2dpid[i]))
+		if (!PHYSFS_readULE32(fileHandle, &serializeGame->sPlayer2dpid[i]))
 			return false;
 	}
 
@@ -4010,7 +4010,7 @@ bool gameLoad(const char* fileName)
 
 	// Read the header from the file
 	if (PHYSFS_read(fileHandle, fileHeader.aFileType, sizeof(fileHeader.aFileType), 1) != 1
-	 || !PHYSFS_readUBE32(fileHandle, &fileHeader.version))
+	 || !PHYSFS_readULE32(fileHandle, &fileHeader.version))
 	{
 		debug(LOG_ERROR, "gameLoad: error while reading header from file (%s): %s", fileName, PHYSFS_getLastError());
 		PHYSFS_close(fileHandle);
@@ -4109,7 +4109,7 @@ UDWORD getCampaign(const char* fileName)
 
 	// Read the header from the file
 	if (PHYSFS_read(fileHandle, fileHeader.aFileType, sizeof(fileHeader.aFileType), 1) != 1
-	 || !PHYSFS_readUBE32(fileHandle, &fileHeader.version))
+	 || !PHYSFS_readULE32(fileHandle, &fileHeader.version))
 	{
 		debug(LOG_ERROR, "getCampaign: error while reading header from file (%s): %s", fileName, PHYSFS_getLastError());
 		PHYSFS_close(fileHandle);
@@ -4761,7 +4761,7 @@ static bool writeGameFile(const char* fi
 	fileHeader.version = CURRENT_VERSION_NUM;
 
 	if (PHYSFS_write(fileHandle, fileHeader.aFileType, sizeof(fileHeader.aFileType), 1) != 1
-	 || !PHYSFS_writeUBE32(fileHandle, fileHeader.version))
+	 || !PHYSFS_writeULE32(fileHandle, fileHeader.version))
 	{
 		debug(LOG_ERROR, "game.c:writeGameFile: could not write header to %s; PHYSFS error: %s", fileName, PHYSFS_getLastError());
 		PHYSFS_close(fileHandle);
diff -r 96d259d05600 src/map.c
--- a/src/map.c	Sat Aug 18 23:37:37 2007 +0200
+++ b/src/map.c	Sun Aug 19 18:40:03 2007 +0200
@@ -918,7 +918,7 @@ bool writeVisibilityData(const char* fil
 
 	// Write out the current file header
 	if (PHYSFS_write(fileHandle, fileHeader.aFileType, sizeof(fileHeader.aFileType), 1) != 1
-	 || !PHYSFS_writeUBE32(fileHandle, fileHeader.version))
+	 || !PHYSFS_writeULE32(fileHandle, fileHeader.version))
 	{
 		debug(LOG_ERROR, "writeVisibilityData: could not write header to %s; PHYSFS error: %s", fileName, PHYSFS_getLastError());
 		PHYSFS_close(fileHandle);
@@ -927,7 +927,7 @@ bool writeVisibilityData(const char* fil
 
 	for (i = 0; i < mapWidth * mapHeight; ++i)
 	{
-		if (!PHYSFS_writeUBE8(fileHandle, psMapTiles[i].tileVisBits))
+		if (!PHYSFS_writeULE8(fileHandle, psMapTiles[i].tileVisBits))
 		{
 			debug(LOG_ERROR, "writeVisibilityData: could not write to %s; PHYSFS error: %s", fileName, PHYSFS_getLastError());
 			PHYSFS_close(fileHandle);
@@ -956,7 +956,7 @@ bool readVisibilityData(const char* file
 
 	// Read the header from the file
 	if (PHYSFS_read(fileHandle, fileHeader.aFileType, sizeof(fileHeader.aFileType), 1) != 1
-	 || !PHYSFS_readUBE32(fileHandle, &fileHeader.version))
+	 || !PHYSFS_readULE32(fileHandle, &fileHeader.version))
 	{
 		debug(LOG_ERROR, "readVisibilityData: error while reading header from file: %s", PHYSFS_getLastError());
 		PHYSFS_close(fileHandle);
@@ -994,7 +994,7 @@ bool readVisibilityData(const char* file
 	for(i=0; i<mapWidth*mapHeight; i++)
 	{
 		/* Get the visibility data */
-		if (!PHYSFS_readUBE8(fileHandle, &psMapTiles[i].tileVisBits))
+		if (!PHYSFS_readULE8(fileHandle, &psMapTiles[i].tileVisBits))
 		{
 			debug(LOG_ERROR, "readVisibilityData: could not read from %s; PHYSFS error: %s", fileName, PHYSFS_getLastError());
 			PHYSFS_close(fileHandle);
diff -r 96d259d05600 src/scores.c
--- a/src/scores.c	Sat Aug 18 23:37:37 2007 +0200
+++ b/src/scores.c	Sun Aug 19 18:40:03 2007 +0200
@@ -532,17 +532,17 @@ void	fillUpStats( void )
  */
 static bool serializeScoreData(PHYSFS_file* fileHandle, const MISSION_DATA* serializeScore)
 {
-	return (PHYSFS_writeUBE32(fileHandle, serializeScore->unitsBuilt)
-	     && PHYSFS_writeUBE32(fileHandle, serializeScore->unitsKilled)
-	     && PHYSFS_writeUBE32(fileHandle, serializeScore->unitsLost)
-	     && PHYSFS_writeUBE32(fileHandle, serializeScore->strBuilt)
-	     && PHYSFS_writeUBE32(fileHandle, serializeScore->strKilled)
-	     && PHYSFS_writeUBE32(fileHandle, serializeScore->strLost)
-	     && PHYSFS_writeUBE32(fileHandle, serializeScore->artefactsFound)
-	     && PHYSFS_writeUBE32(fileHandle, serializeScore->missionStarted)
-	     && PHYSFS_writeUBE32(fileHandle, serializeScore->shotsOnTarget)
-	     && PHYSFS_writeUBE32(fileHandle, serializeScore->shotsOffTarget)
-	     && PHYSFS_writeUBE32(fileHandle, serializeScore->babasMowedDown));
+	return (PHYSFS_writeULE32(fileHandle, serializeScore->unitsBuilt)
+	     && PHYSFS_writeULE32(fileHandle, serializeScore->unitsKilled)
+	     && PHYSFS_writeULE32(fileHandle, serializeScore->unitsLost)
+	     && PHYSFS_writeULE32(fileHandle, serializeScore->strBuilt)
+	     && PHYSFS_writeULE32(fileHandle, serializeScore->strKilled)
+	     && PHYSFS_writeULE32(fileHandle, serializeScore->strLost)
+	     && PHYSFS_writeULE32(fileHandle, serializeScore->artefactsFound)
+	     && PHYSFS_writeULE32(fileHandle, serializeScore->missionStarted)
+	     && PHYSFS_writeULE32(fileHandle, serializeScore->shotsOnTarget)
+	     && PHYSFS_writeULE32(fileHandle, serializeScore->shotsOffTarget)
+	     && PHYSFS_writeULE32(fileHandle, serializeScore->babasMowedDown));
 }
 
 /** Read a MISSION_DATA from the given file with endianness swapped correctly
@@ -552,17 +552,17 @@ static bool serializeScoreData(PHYSFS_fi
  */
 static bool deserializeScoreData(PHYSFS_file* fileHandle, MISSION_DATA* serializeScore)
 {
-	return (PHYSFS_readUBE32(fileHandle, &serializeScore->unitsBuilt)
-	     && PHYSFS_readUBE32(fileHandle, &serializeScore->unitsKilled)
-	     && PHYSFS_readUBE32(fileHandle, &serializeScore->unitsLost)
-	     && PHYSFS_readUBE32(fileHandle, &serializeScore->strBuilt)
-	     && PHYSFS_readUBE32(fileHandle, &serializeScore->strKilled)
-	     && PHYSFS_readUBE32(fileHandle, &serializeScore->strLost)
-	     && PHYSFS_readUBE32(fileHandle, &serializeScore->artefactsFound)
-	     && PHYSFS_readUBE32(fileHandle, &serializeScore->missionStarted)
-	     && PHYSFS_readUBE32(fileHandle, &serializeScore->shotsOnTarget)
-	     && PHYSFS_readUBE32(fileHandle, &serializeScore->shotsOffTarget)
-	     && PHYSFS_readUBE32(fileHandle, &serializeScore->babasMowedDown));
+	return (PHYSFS_readULE32(fileHandle, &serializeScore->unitsBuilt)
+	     && PHYSFS_readULE32(fileHandle, &serializeScore->unitsKilled)
+	     && PHYSFS_readULE32(fileHandle, &serializeScore->unitsLost)
+	     && PHYSFS_readULE32(fileHandle, &serializeScore->strBuilt)
+	     && PHYSFS_readULE32(fileHandle, &serializeScore->strKilled)
+	     && PHYSFS_readULE32(fileHandle, &serializeScore->strLost)
+	     && PHYSFS_readULE32(fileHandle, &serializeScore->artefactsFound)
+	     && PHYSFS_readULE32(fileHandle, &serializeScore->missionStarted)
+	     && PHYSFS_readULE32(fileHandle, &serializeScore->shotsOnTarget)
+	     && PHYSFS_readULE32(fileHandle, &serializeScore->shotsOffTarget)
+	     && PHYSFS_readULE32(fileHandle, &serializeScore->babasMowedDown));
 }
 
 // -----------------------------------------------------------------------------------
@@ -587,8 +587,8 @@ bool writeScoreData(const char* fileName
 
 	// Write out the current file header
 	if (PHYSFS_write(fileHandle, fileHeader.aFileType, sizeof(fileHeader.aFileType), 1) != 1
-	 || !PHYSFS_writeUBE32(fileHandle, fileHeader.version)
-	 || !PHYSFS_writeUBE32(fileHandle, fileHeader.entries))
+	 || !PHYSFS_writeULE32(fileHandle, fileHeader.version)
+	 || !PHYSFS_writeULE32(fileHandle, fileHeader.entries))
 	{
 		debug(LOG_ERROR, "writeScoreData: could not write header to %s; PHYSFS error: %s", fileName, PHYSFS_getLastError());
 		PHYSFS_close(fileHandle);
@@ -627,8 +627,8 @@ bool readScoreData(const char* fileName)
 
 	// Read the header from the file
 	if (PHYSFS_read(fileHandle, fileHeader.aFileType, sizeof(fileHeader.aFileType), 1) != 1
-	 || !PHYSFS_readUBE32(fileHandle, &fileHeader.version)
-	 || !PHYSFS_readUBE32(fileHandle, &fileHeader.entries))
+	 || !PHYSFS_readULE32(fileHandle, &fileHeader.version)
+	 || !PHYSFS_readULE32(fileHandle, &fileHeader.entries))
 	{
 		debug(LOG_ERROR, "readScoreData: error while reading header from file: %s", PHYSFS_getLastError());
 		PHYSFS_close(fileHandle);
_______________________________________________
Warzone-dev mailing list
Warzone-dev@gna.org
https://mail.gna.org/listinfo/warzone-dev

Reply via email to