openttd-ottdgrfs: comparison src/saveload.cpp

equal deleted inserted replaced

-:67db0d431d5e
+:d8811e327d12
 #include "core/endian_func.hpp"
 #include "vehicle_base.h"
 #include "autoreplace_base.h"
 #include "statusbar_gui.h"
 #include <list>
+#include "gamelog.h"
 #include "table/strings.h"
 extern const uint16 SAVEGAME_VERSION = NEWGRF_AIRPORTS_SAVEGAME;
 uint32 _ttdp_version;     ///< version of TTDP savegame (if applicable)
 uint16 _sl_version;       ///< the major savegame version identifier
 byte   _sl_minor_version; ///< the minor savegame version, DO NOT USE!
-typedef void WriterProc(uint len);
+typedef void WriterProc(size_t len);
-typedef uint ReaderProc();
+typedef size_t ReaderProc();
 /** The saveload struct, containing reader-writer functions, bufffer, version, etc. */
 static struct {
 	bool save;                           ///< are we doing a save or a load atm. True when saving
 	byte need_length;                    ///< ???
 	byte block_mode;                     ///< ???
 	bool error;                          ///< did an error occur or not
-	int obj_len;                         ///< the length of the current object we are busy with
+	size_t obj_len;                      ///< the length of the current object we are busy with
 	int array_index, last_array_index;   ///< in the case of an array, the current and last positions
-	uint32 offs_base;                    ///< the offset in number of bytes since we started writing data (eg uncompressed savegame size)
+	size_t offs_base;                    ///< the offset in number of bytes since we started writing data (eg uncompressed savegame size)
 	WriterProc *write_bytes;             ///< savegame writer function
 	ReaderProc *read_bytes;              ///< savegame loader function
 	const ChunkHandler* const *chs;      ///< the chunk of data that is being processed atm (vehicles, signs, etc.)
 /**
 * Fill the input buffer by reading from the file with the given reader
 */
 static void SlReadFill()
 {
-	uint len = _sl.read_bytes();
+	size_t len = _sl.read_bytes();
 	if (len == 0) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Unexpected end of chunk");
 	_sl.bufp = _sl.buf;
 	_sl.bufe = _sl.buf + len;
 	_sl.offs_base += len;
 }
-static inline uint32 SlGetOffs() {return _sl.offs_base - (_sl.bufe - _sl.bufp);}
+static inline size_t SlGetOffs() {return _sl.offs_base - (_sl.bufe - _sl.bufp);}
 /** Return the size in bytes of a certain type of normal/atomic variable
 * as it appears in memory. See VarTypes
 * @param conv VarType type of variable that is used for calculating the size
 * @return Return the size of this type in bytes */
 * 110xxxxx xxxxxxxx xxxxxxxx
 * 1110xxxx xxxxxxxx xxxxxxxx xxxxxxxx
 * @param i Index being written
 */
-static void SlWriteSimpleGamma(uint i)
+static void SlWriteSimpleGamma(size_t i)
 {
 	if (i >= (1 << 7)) {
 		if (i >= (1 << 14)) {
 			if (i >= (1 << 21)) {
 				assert(i < (1 << 28));
-				SlWriteByte((byte)0xE0 | (i >> 24));
+				SlWriteByte((byte)(0xE0 | (i >> 24)));
 				SlWriteByte((byte)(i >> 16));
 			} else {
-				SlWriteByte((byte)0xC0 | (i >> 16));
+				SlWriteByte((byte)(0xC0 | (i >> 16)));
 			}
 			SlWriteByte((byte)(i >> 8));
 		} else {
 			SlWriteByte((byte)(0x80 | (i >> 8)));
 		}
 	}
-	SlWriteByte(i);
+	SlWriteByte((byte)i);
 }
 /** Return how many bytes used to encode a gamma value */
-static inline uint SlGetGammaLength(uint i)
+static inline uint SlGetGammaLength(size_t i)
 {
 	return 1 + (i >= (1 << 7)) + (i >= (1 << 14)) + (i >= (1 << 21));
 }
 static inline uint SlReadSparseIndex() {return SlReadSimpleGamma();}
 static inline void SlWriteSparseIndex(uint index) {SlWriteSimpleGamma(index);}
 static inline uint SlReadArrayLength() {return SlReadSimpleGamma();}
-static inline void SlWriteArrayLength(uint length) {SlWriteSimpleGamma(length);}
+static inline void SlWriteArrayLength(size_t length) {SlWriteSimpleGamma(length);}
-static inline uint SlGetArrayLength(uint length) {return SlGetGammaLength(length);}
+static inline uint SlGetArrayLength(size_t length) {return SlGetGammaLength(length);}
 void SlSetArrayIndex(uint index)
 {
 	_sl.need_length = NL_WANTLENGTH;
 	_sl.array_index = index;
 }
-static uint32 _next_offs;
+static size_t _next_offs;
 /**
 * Iterate through the elements of an array and read the whole thing
 * @return The index of the object, or -1 if we have reached the end of current block
 */
 		case CH_RIFF:
 			/* Ugly encoding of >16M RIFF chunks
 			 * The lower 24 bits are normal
 			 * The uppermost 4 bits are bits 24:27 */
 			assert(length < (1 << 28));
-			SlWriteUint32((length & 0xFFFFFF) | ((length >> 24) << 28));
+			SlWriteUint32((uint32)((length & 0xFFFFFF) | ((length >> 24) << 28)));
 			break;
 		case CH_ARRAY:
 			assert(_sl.last_array_index <= _sl.array_index);
 			while (++_sl.last_array_index <= _sl.array_index)
 				SlWriteArrayLength(1);
 			SlWriteSparseIndex(_sl.array_index);
 			break;
 		default: NOT_REACHED();
 		} break;
 	case NL_CALCLENGTH:
-		_sl.obj_len += length;
+		_sl.obj_len += (int)length;
 		break;
 	}
 }
 /**
 {
 	for (; length != 0; length--) SlReadByte();
 }
 /* Get the length of the current object */
-uint SlGetFieldLength() {return _sl.obj_len;}
+size_t SlGetFieldLength() {return _sl.obj_len;}
 /** Return a signed-long version of the value of a setting
 * @param ptr pointer to the variable
 * @param conv type of variable, can be a non-clean
 * type, eg one with other flags because it is parsed
 /**
 * Return the size in bytes of a certain type of atomic array
 * @param length The length of the array counted in elements
 * @param conv VarType type of the variable that is used in calculating the size
 */
-static inline size_t SlCalcArrayLen(uint length, VarType conv)
+static inline size_t SlCalcArrayLen(size_t length, VarType conv)
 {
 	return SlCalcConvFileLen(conv) * length;
 }
 /**
 * Save/Load an array.
 * @param array The array being manipulated
 * @param length The length of the array in elements
 * @param conv VarType type of the atomic array (int, byte, uint64, etc.)
 */
-void SlArray(void *array, uint length, VarType conv)
+void SlArray(void *array, size_t length, VarType conv)
 {
 	/* Automatically calculate the length? */
 	if (_sl.need_length != NL_NONE) {
 		SlSetLength(SlCalcArrayLen(length, conv));
 		/* Determine length only? */
 	}
 	/* NOTICE - handle some buggy stuff, in really old versions everything was saved
 	 * as a byte-type. So detect this, and adjust array size accordingly */
 	if (!_sl.save && _sl_version == 0) {
+		/* all arrays except difficulty settings */
 		if (conv == SLE_INT16 || conv == SLE_UINT16 || conv == SLE_STRINGID ||
 				conv == SLE_INT32 || conv == SLE_UINT32) {
-			length *= SlCalcConvFileLen(conv);
+			SlCopyBytes(array, length * SlCalcConvFileLen(conv));
-			conv = SLE_INT8;
+			return;
+		}
+		/* used for conversion of Money 32bit->64bit */
+		if (conv == (SLE_FILE_I32 | SLE_VAR_I64)) {
+			for (uint i = 0; i < length; i++) {
+				((int64*)array)[i] = (int32)BSWAP32(SlReadUint32());
+			}
+			return;
 		}
 	}
 	/* If the size of elements is 1 byte both in file and memory, no special
 	 * conversion is needed, use specialized copy-copy function to speed up things */
 	}
 	std::list<void *> *l = (std::list<void *> *) list;
 	if (_sl.save) {
-		SlWriteUint32(l->size());
+		SlWriteUint32((uint32)l->size());
 		std::list<void *>::iterator iter;
 		for (iter = l->begin(); iter != l->end(); ++iter) {
 			void *ptr = *iter;
 			SlWriteUint32(ReferenceToInt(ptr, conv));
 * Calculate the size of an object.
 * @param object to be measured
 * @param sld The SaveLoad description of the object so we know how to manipulate it
 * @return size of given objetc
 */
-static size_t SlCalcObjLength(const void *object, const SaveLoad *sld)
+size_t SlCalcObjLength(const void *object, const SaveLoad *sld)
 {
 	size_t length = 0;
 	/* Need to determine the length and write a length tag. */
 	for (; sld->cmd != SL_END; sld++) {
 * @param proc The callback procedure that is called
 * @param arg The variable that will be used for the callback procedure
 */
 void SlAutolength(AutolengthProc *proc, void *arg)
 {
-	uint32 offs;
+	size_t offs;
 	assert(_sl.save);
 	/* Tell it to calculate the length */
 	_sl.need_length = NL_CALCLENGTH;
 * @param ch The chunkhandler that will be used for the operation
 */
 static void SlLoadChunk(const ChunkHandler *ch)
 {
 	byte m = SlReadByte();
-	uint32 len;
+	size_t len;
-	uint32 endoffs;
+	size_t endoffs;
 	_sl.block_mode = m;
 	_sl.obj_len = 0;
 	switch (m) {
 *******************************************/
 #define LZO_SIZE 8192
 #include "minilzo.h"
-static uint ReadLZO()
+static size_t ReadLZO()
 {
 	byte out[LZO_SIZE + LZO_SIZE / 64 + 16 + 3 + 8];
 	uint32 tmp[2];
 	uint32 size;
 	uint len;
 	return len;
 }
 /* p contains the pointer to the buffer, len contains the pointer to the length.
 * len bytes will be written, p and l will be updated to reflect the next buffer. */
-static void WriteLZO(uint size)
+static void WriteLZO(size_t size)
 {
 	byte out[LZO_SIZE + LZO_SIZE / 64 + 16 + 3 + 8];
 	byte wrkmem[sizeof(byte*)*4096];
 	uint outlen;
-	lzo1x_1_compress(_sl.buf, size, out + sizeof(uint32)*2, &outlen, wrkmem);
+	lzo1x_1_compress(_sl.buf, (lzo_uint)size, out + sizeof(uint32)*2, &outlen, wrkmem);
 	((uint32*)out)[1] = TO_BE32(outlen);
 	((uint32*)out)[0] = TO_BE32(lzo_adler32(0, out + sizeof(uint32), outlen + sizeof(uint32)));
 	if (fwrite(out, outlen + sizeof(uint32)*2, 1, _sl.fh) != 1) SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE);
 }
 }
 /*********************************************
 ******** START OF NOCOMP CODE (uncompressed)*
 *********************************************/
-static uint ReadNoComp()
+static size_t ReadNoComp()
 {
 	return fread(_sl.buf, 1, LZO_SIZE, _sl.fh);
 }
-static void WriteNoComp(uint size)
+static void WriteNoComp(size_t size)
 {
 	if (fwrite(_sl.buf, 1, size, _sl.fh) != size) SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE);
 }
 static bool InitNoComp()
 static void UnInitMem()
 {
 	_Savegame_pool.CleanPool();
 }
-static void WriteMem(uint size)
+static void WriteMem(size_t size)
 {
-	_ts.count += size;
+	_ts.count += (uint)size;
 	/* Allocate new block and new buffer-pointer */
 	_Savegame_pool.AddBlockIfNeeded(_ts.count);
 	_sl.buf = GetSavegame(_ts.count);
 }
 	_sl.bufsize = 4096;
 	_sl.buf = _sl.buf_ori = MallocT<byte>(4096 + 4096); // also contains fread buffer
 	return true;
 }
-static uint ReadZlib()
+static size_t ReadZlib()
 {
 	int r;
 	_z.next_out = _sl.buf;
 	_z.avail_out = 4096;
 	_sl.bufsize = 4096;
 	_sl.buf = _sl.buf_ori = MallocT<byte>(4096); // also contains fread buffer
 	return true;
 }
-static void WriteZlibLoop(z_streamp z, byte *p, uint len, int mode)
+static void WriteZlibLoop(z_streamp z, byte *p, size_t len, int mode)
 {
 	byte buf[1024]; // output buffer
 	int r;
 	uint n;
 	z->next_in = p;
-	z->avail_in = len;
+	z->avail_in = (uInt)len;
 	do {
 		z->next_out = buf;
 		z->avail_out = sizeof(buf);
 		r = deflate(z, mode);
 			/* bytes were emitted? */
 			break;
 		if (r != Z_OK) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_INTERNAL_ERROR, "zlib returned error code");
 	} while (z->avail_in || !z->avail_out);
 }
-static void WriteZlib(uint len)
+static void WriteZlib(size_t len)
 {
 	WriteZlibLoop(&_z, _sl.buf, len, 0);
 }
 static void UninitWriteZlib()
 /*******************************************
 ************* END OF CODE *****************
 *******************************************/
 /* these define the chunks */
+extern const ChunkHandler _gamelog_chunk_handlers[];
 extern const ChunkHandler _misc_chunk_handlers[];
 extern const ChunkHandler _name_chunk_handlers[];
 extern const ChunkHandler _cheat_chunk_handlers[] ;
 extern const ChunkHandler _setting_chunk_handlers[];
 extern const ChunkHandler _player_chunk_handlers[];
 extern const ChunkHandler _newgrf_chunk_handlers[];
 extern const ChunkHandler _group_chunk_handlers[];
 extern const ChunkHandler _cargopacket_chunk_handlers[];
 static const ChunkHandler * const _chunk_handlers[] = {
+	_gamelog_chunk_handlers,
 	_misc_chunk_handlers,
 	_name_chunk_handlers,
 	_cheat_chunk_handlers,
 	_setting_chunk_handlers,
 	_veh_chunk_handlers,
 	}
 	return def;
 }
 /* actual loader/saver function */
-void InitializeGame(int mode, uint size_x, uint size_y);
+void InitializeGame(uint size_x, uint size_y, bool reset_date);
 extern bool AfterLoadGame();
-extern void BeforeSaveGame();
+extern void SaveViewportBeforeSaveGame();
 extern bool LoadOldSaveGame(const char *file);
 /** Small helper function to close the to be loaded savegame an signal error */
 static inline SaveOrLoadResult AbortSaveLoad()
 {
 		}
 		return SL_ERROR;
 	}
 }
-static void * CDECL SaveFileToDiskThread(void *arg)
+static void SaveFileToDiskThread(void *arg)
 {
 	SaveFileToDisk(true);
-	return NULL;
 }
 void WaitTillSaved()
 {
 	if (_save_thread == NULL) return;
 	_next_offs = 0;
 	/* Load a TTDLX or TTDPatch game */
 	if (mode == SL_OLD_LOAD) {
-		InitializeGame(IG_DATE_RESET, 256, 256); // set a mapsize of 256x256 for TTDPatch games or it might get confused
+		InitializeGame(256, 256, true); // set a mapsize of 256x256 for TTDPatch games or it might get confused
+		GamelogReset();
 		if (!LoadOldSaveGame(filename)) return SL_REINIT;
 		_sl_version = 0;
 		_sl_minor_version = 0;
-		if (!AfterLoadGame()) return SL_REINIT;
+		GamelogStartAction(GLAT_LOAD);
+		if (!AfterLoadGame()) {
+			GamelogStopAction();
+			return SL_REINIT;
+		}
+		GamelogStopAction();
 		return SL_OK;
 	}
 	_sl.excpt_uninit = NULL;
 	try {
 				return AbortSaveLoad();
 			}
 			_sl_version = SAVEGAME_VERSION;
-			BeforeSaveGame();
+			SaveViewportBeforeSaveGame();
 			SlSaveChunks();
 			SlWriteFill(); // flush the save buffer
 			SaveFileStart();
 			if (_network_server ||
 			}
 			/* Old maps were hardcoded to 256x256 and thus did not contain
 			 * any mapsize information. Pre-initialize to 256x256 to not to
 			 * confuse old games */
-			InitializeGame(IG_DATE_RESET, 256, 256);
+			InitializeGame(256, 256, true);
+			GamelogReset();
 			SlLoadChunks();
 			fmt->uninit_read();
 			fclose(_sl.fh);
+			GamelogStartAction(GLAT_LOAD);
 			_savegame_type = SGT_OTTD;
 			/* After loading fix up savegame for any internal changes that
 			 * might've occured since then. If it fails, load back the old game */
-			if (!AfterLoadGame()) return SL_REINIT;
+			if (!AfterLoadGame()) {
+				GamelogStopAction();
+				return SL_REINIT;
+			}
+			GamelogStopAction();
 		}
 		return SL_OK;
 	}
 	catch (...) {
 		/* A saver/loader exception!! reinitialize all variables to prevent crash! */
 		return (mode == SL_LOAD) ? SL_REINIT : SL_ERROR;
 	}
 }
-/** Do a save when exiting the game (patch option) _settings.gui.autosave_on_exit */
+/** Do a save when exiting the game (patch option) _settings_client.gui.autosave_on_exit */
 void DoExitSave()
 {
 	SaveOrLoad("exit.sav", SL_SAVE, AUTOSAVE_DIR);
 }

branch	NewGRF_ports
changeset 10991	d8811e327d12
parent 10731	67db0d431d5e
child 10994	cd9968b6f96b