(svn r13375) -Add: logging of actions that could possibly cause desyncs and crashes to simplify debugging. See readme.txt for details

16 files changed, 976 insertions, 23 deletions

diff --git a/src/cheat_gui.cpp b/src/cheat_gui.cpp
index 510ca7ef2..ce1cb0b58 100644
--- a/src/cheat_gui.cpp
+++ b/src/cheat_gui.cpp
@@ -19,6 +19,7 @@
 #include "rail_gui.h"
 #include "gui.h"
 #include "player_gui.h"
+#include "gamelog.h"
 
 #include "table/strings.h"
 #include "table/sprites.h"
@@ -65,7 +66,12 @@ static int32 ClickChangeClimateCheat(int32 p1, int32 p2)
 	if (p1 == -1) p1 = 3;
 	if (p1 ==  4) p1 = 0;
 	_settings_game.game_creation.landscape = p1;
+
+	GamelogStartAction(GLAT_CHEAT);
+	GamelogTestMode();
 	ReloadNewGRFData();
+	GamelogStopAction();
+
 	return _settings_game.game_creation.landscape;
 }
 
diff --git a/src/console_cmds.cpp b/src/console_cmds.cpp
index b0bd54b59..fe69e759b 100644
--- a/src/console_cmds.cpp
+++ b/src/console_cmds.cpp
@@ -29,6 +29,7 @@
 #include "player_func.h"
 #include "player_base.h"
 #include "settings_type.h"
+#include "gamelog.h"
 
 #ifdef ENABLE_NETWORK
 	#include "table/strings.h"
@@ -1303,6 +1304,11 @@ DEF_CONSOLE_CMD(ConListDumpVariables)
 	return true;
 }
 
+DEF_CONSOLE_CMD(ConGamelogPrint)
+{
+	GamelogPrintConsole();
+	return true;
+}
 
 #ifdef _DEBUG
 /* ****************************************** */
@@ -1366,6 +1372,7 @@ void IConsoleStdLibRegister()
 	IConsoleCmdRegister("clear",        ConClearBuffer);
 	IConsoleCmdRegister("patch",        ConPatch);
 	IConsoleCmdRegister("list_patches", ConListPatches);
+	IConsoleCmdRegister("gamelog",      ConGamelogPrint);
 
 	IConsoleAliasRegister("dir",      "ls");
 	IConsoleAliasRegister("del",      "rm %+");
diff --git a/src/debug.cpp b/src/debug.cpp
index 6584b9e7f..fb1e28a49 100644
--- a/src/debug.cpp
+++ b/src/debug.cpp
@@ -30,6 +30,7 @@ int _debug_yapf_level;
 int _debug_freetype_level;
 int _debug_sl_level;
 int _debug_station_level;
+int _debug_gamelog_level;
 
 
 struct DebugLevel {
@@ -54,24 +55,17 @@ struct DebugLevel {
 	DEBUG_LEVEL(freetype),
 	DEBUG_LEVEL(sl),
 	DEBUG_LEVEL(station),
+	DEBUG_LEVEL(gamelog),
 	};
 #undef DEBUG_LEVEL
 
 #if !defined(NO_DEBUG_MESSAGES)
 
-void CDECL debug(const char *dbg, ...)
+void CDECL debug_print(const char *dbg, const char *buf)
 {
-	va_list va;
-	va_start(va, dbg);
-	const char *s;
-	char buf[1024];
-
-	s = va_arg(va, const char*);
-	vsnprintf(buf, lengthof(buf), s, va);
-	va_end(va);
 #if defined(ENABLE_NETWORK)
 	if (_debug_socket != INVALID_SOCKET) {
-		char buf2[lengthof(buf) + 32];
+		char buf2[1024 + 32];
 
 		snprintf(buf2, lengthof(buf2), "dbg: [%s] %s\n", dbg, buf);
 		send(_debug_socket, buf2, (int)strlen(buf2), 0);
@@ -89,6 +83,20 @@ void CDECL debug(const char *dbg, ...)
 		IConsoleDebug(dbg, buf);
 	}
 }
+
+void CDECL debug(const char *dbg, ...)
+{
+	va_list va;
+	va_start(va, dbg);
+	const char *s;
+	char buf[1024];
+
+	s = va_arg(va, const char*);
+	vsnprintf(buf, lengthof(buf), s, va);
+	va_end(va);
+
+	debug_print(dbg, buf);
+}
 #endif /* NO_DEBUG_MESSAGES */
 
 void SetDebugString(const char *s)
diff --git a/src/debug.h b/src/debug.h
index 936d7f683..4048c16c0 100644
--- a/src/debug.h
+++ b/src/debug.h
@@ -47,8 +47,10 @@
 	extern int _debug_freetype_level;
 	extern int _debug_sl_level;
 	extern int _debug_station_level;
+	extern int _debug_gamelog_level;
 
 	void CDECL debug(const char *dbg, ...);
+	void CDECL debug_print(const char *dbg, const char *buf);
 #endif /* NO_DEBUG_MESSAGES */
 
 void SetDebugString(const char *s);
diff --git a/src/gamelog.cpp b/src/gamelog.cpp
new file mode 100644
index 000000000..e5518dbe8
--- /dev/null
+++ b/src/gamelog.cpp
@@ -0,0 +1,801 @@
+/* $Id$ */
+
+/** @file gamelog.cpp Definition of functions used for logging of important changes in the game */
+
+#include "stdafx.h"
+#include "openttd.h"
+#include "saveload.h"
+#include "core/alloc_func.hpp"
+#include "core/bitmath_func.hpp"
+#include "core/math_func.hpp"
+#include "network/core/config.h"
+#include "variables.h"
+#include "string_func.h"
+#include "settings_type.h"
+#include "newgrf_config.h"
+#include <string.h>
+#include <stdarg.h>
+#include "gamelog.h"
+#include "console_func.h"
+#include "debug.h"
+#include "rev.h"
+
+extern const uint16 SAVEGAME_VERSION;  ///< current savegame version
+
+extern SavegameType _savegame_type; ///< type of savegame we are loading
+
+extern uint32 _ttdp_version;     ///< version of TTDP savegame (if applicable)
+extern uint16 _sl_version;       ///< the major savegame version identifier
+extern byte   _sl_minor_version; ///< the minor savegame version, DO NOT USE!
+
+/** Type of logged change */
+enum GamelogChangeType {
+	GLCT_MODE,        ///< Scenario editor x Game, different landscape
+	GLCT_REVISION,    ///< Changed game revision string
+	GLCT_OLDVER,      ///< Loaded from savegame without logged data
+	GLCT_PATCH,       ///< Non-networksafe patch value changed
+	GLCT_GRFADD,      ///< Removed GRF
+	GLCT_GRFREM,      ///< Added GRF
+	GLCT_GRFCOMPAT,   ///< Loading compatible GRF
+	GLCT_GRFPARAM,    ///< GRF parameter changed
+	GLCT_GRFMOVE,     ///< GRF order changed
+	GLCT_END,         ///< So we know how many GLCTs are there
+	GLCT_NONE = 0xFF, ///< In savegames, end of list
+};
+
+
+/** Contains information about one logged change */
+struct LoggedChange {
+	GamelogChangeType ct; ///< Type of change logged in this struct
+	union {
+		struct {
+			byte mode;       ///< new game mode - Editor x Game
+			byte landscape;  ///< landscape (temperate, arctic, ...)
+		} mode;
+		struct {
+			char text[NETWORK_REVISION_LENGTH]; ///< revision string, _openttd_revision
+			uint32 newgrf;   ///< _openttd_newgrf_version
+			uint16 slver;    ///< _sl_version
+			byte modified;   ///< _openttd_revision_modified
+		} revision;
+		struct {
+			uint32 type;     ///< type of savegame, @see SavegameType
+			uint32 version;  ///< major and minor version OR ttdp version
+		} oldver;
+		GRFIdentifier grfadd;    ///< ID and md5sum of added GRF
+		struct {
+			uint32 grfid;    ///< ID of removed GRF
+		} grfrem;
+		GRFIdentifier grfcompat; ///< ID and new md5sum of changed GRF
+		struct {
+			uint32 grfid;    ///< ID of GRF with changed parameters
+		} grfparam;
+		struct {
+			uint32 grfid;    ///< ID of moved GRF
+			int32 offset;    ///< offset, positive = move down
+		} grfmove;
+		struct {
+			char *name;      ///< name of the patch
+			int32 oldval;    ///< old value
+			int32 newval;    ///< new value
+		} patch;
+	};
+};
+
+
+/** Contains information about one logged action that caused at least one logged change */
+struct LoggedAction {
+	LoggedChange *change; ///< First logged change in this action
+	uint32 changes;       ///< Number of changes in this action
+	GamelogActionType at; ///< Type of action
+	uint16 tick;          ///< Tick when it happened
+};
+
+static GamelogActionType _gamelog_action_type = GLAT_NONE; ///< action to record if anything changes
+
+static LoggedAction *_gamelog_action = NULL; ///< first logged action
+static uint _gamelog_actions         = 0;    ///< number of actions
+static LoggedAction *_current_action = NULL; ///< current action we are logging, NULL when there is no action active
+
+
+/** Stores information about new action, but doesn't allocate it
+ * Action is allocated only when there is at least one change
+ * @param at type of action
+ */
+void GamelogStartAction(GamelogActionType at)
+{
+	assert(_gamelog_action_type == GLAT_NONE); // do not allow starting new action without stopping the previous first
+	_gamelog_action_type = at;
+}
+
+/** Stops logging of any changes
+ */
+void GamelogStopAction()
+{
+	assert(_gamelog_action_type != GLAT_NONE); // nobody should try to stop if there is no action in progress
+
+	_current_action = NULL;
+	_gamelog_action_type = GLAT_NONE;
+
+	if (_debug_gamelog_level > 4) GamelogPrintDebug();
+}
+
+/** Resets and frees all memory allocated - used before loading or starting a new game
+ */
+void GamelogReset()
+{
+	assert(_gamelog_action_type == GLAT_NONE);
+
+	for (uint i = 0; i < _gamelog_actions; i++) {
+		const LoggedAction *la = &_gamelog_action[i];
+		for (uint j = 0; j < la->changes; j++) {
+			const LoggedChange *lc = &la->change[j];
+			if (lc->ct == GLCT_PATCH) free(lc->patch.name);
+		}
+		free(la->change);
+	}
+
+	free(_gamelog_action);
+
+	_gamelog_action  = NULL;
+	_gamelog_actions = 0;
+	_current_action  = NULL;
+}
+
+enum {
+	GAMELOG_BUF_LEN = 1024 ///< length of buffer for one line of text
+};
+
+static int _dbgofs = 0; ///< offset in current output buffer
+
+static void AddDebugText(char *buf, const char *s, ...)
+{
+	if (GAMELOG_BUF_LEN <= _dbgofs) return;
+
+	va_list va;
+
+	va_start(va, s);
+	_dbgofs += vsnprintf(buf + _dbgofs, GAMELOG_BUF_LEN - _dbgofs, s, va);
+	va_end(va);
+}
+
+
+/** Prints GRF filename if found
+ * @param grfid GRF which filename to print
+ */
+static void PrintGrfFilename(char *buf, uint grfid)
+{
+	const GRFConfig *gc = FindGRFConfig(grfid);
+
+	if (gc == NULL) return;
+
+	AddDebugText(buf, ", filename: %s", gc->filename);
+}
+
+/** Prints GRF ID, checksum and filename if found
+ * @param grfid GRF ID
+ * @param md5sum array of md5sum to print
+ */
+static void PrintGrfInfo(char *buf, uint grfid, const uint8 *md5sum)
+{
+	char txt[40];
+
+	md5sumToString(txt, lastof(txt), md5sum);
+
+	AddDebugText(buf, "GRF ID %08X, checksum %s", BSWAP32(grfid), txt);
+
+	PrintGrfFilename(buf, grfid);
+
+	return;
+}
+
+
+/** Text messages for various logged actions */
+static const char *la_text[] = {
+	"new game started",
+	"game loaded",
+	"GRF config changed",
+	"cheat was used",
+	"patch settings changed"
+};
+
+assert_compile(lengthof(la_text) == GLAT_END);
+
+
+/** Prints active gamelog */
+void GamelogPrint(GamelogPrintProc *proc)
+{
+	char buf[GAMELOG_BUF_LEN];
+
+	proc("---- gamelog start ----");
+
+	const LoggedAction *laend = &_gamelog_action[_gamelog_actions];
+
+	for (const LoggedAction *la = _gamelog_action; la != laend; la++) {
+		assert((uint)la->at < GLAT_END);
+
+		snprintf(buf, GAMELOG_BUF_LEN, "Tick %u: %s", (uint)la->tick, la_text[(uint)la->at]);
+		proc(buf);
+
+		const LoggedChange *lcend = &la->change[la->changes];
+
+		for (const LoggedChange *lc = la->change; lc != lcend; lc++) {
+			_dbgofs = 0;
+			AddDebugText(buf, "     ");
+
+			switch (lc->ct) {
+				default: NOT_REACHED();
+				case GLCT_MODE:
+					AddDebugText(buf, "New game mode: %u landscape: %u",
+						(uint)lc->mode.mode, (uint)lc->mode.landscape);
+					break;
+
+				case GLCT_REVISION:
+					AddDebugText(buf, "Revision text changed to %s, savegame version %u, ",
+						lc->revision.text, lc->revision.slver);
+
+					switch (lc->revision.modified) {
+						case 0: AddDebugText(buf, "not "); break;
+						case 1: AddDebugText(buf, "maybe "); break;
+						default: break;
+					}
+
+					AddDebugText(buf, "modified, _openttd_newgrf_version = 0x%08x", lc->revision.newgrf);
+					break;
+
+				case GLCT_OLDVER:
+					AddDebugText(buf, "Conversion from ");
+					switch (lc->oldver.type) {
+						default: NOT_REACHED();
+						case SGT_OTTD:
+							AddDebugText(buf, "OTTD savegame without gamelog: version %u, %u",
+								GB(lc->oldver.version, 8, 16), GB(lc->oldver.version, 0, 8));
+							break;
+
+						case SGT_TTD:
+							AddDebugText(buf, "TTD savegame");
+							break;
+
+						case SGT_TTDP1:
+						case SGT_TTDP2:
+							AddDebugText(buf, "TTDP savegame, %s format",
+								lc->oldver.type == SGT_TTDP1 ? "old" : "new");
+							if (lc->oldver.version != 0) {
+								AddDebugText(buf, ", TTDP version %u.%u.%u.%u",
+									GB(lc->oldver.version, 24, 8), GB(lc->oldver.version, 20, 4),
+									GB(lc->oldver.version, 16, 4), GB(lc->oldver.version, 0, 16));
+							}
+							break;
+					}
+					break;
+
+				case GLCT_PATCH:
+					AddDebugText(buf, "Patch setting changed: %s : %d -> %d", lc->patch.name, lc->patch.oldval, lc->patch.newval);
+					break;
+
+				case GLCT_GRFADD:
+					AddDebugText(buf, "Added NewGRF: ");
+					PrintGrfInfo(buf, lc->grfadd.grfid, lc->grfadd.md5sum);
+					break;
+
+				case GLCT_GRFREM:
+					AddDebugText(buf, "Removed NewGRF: %08X", BSWAP32(lc->grfrem.grfid));
+					PrintGrfFilename(buf, lc->grfrem.grfid);
+					break;
+
+				case GLCT_GRFCOMPAT:
+					AddDebugText(buf, "Compatible NewGRF loaded: ");
+					PrintGrfInfo(buf, lc->grfcompat.grfid, lc->grfcompat.md5sum);
+					break;
+
+				case GLCT_GRFPARAM:
+					AddDebugText(buf, "GRF parameter changed: %08X", BSWAP32(lc->grfparam.grfid));
+					PrintGrfFilename(buf, lc->grfparam.grfid);
+					break;
+
+				case GLCT_GRFMOVE:
+					AddDebugText(buf, "GRF order changed: %08X moved %d places %s",
+						BSWAP32(lc->grfmove.grfid), abs(lc->grfmove.offset), lc->grfmove.offset >= 0 ? "down" : "up" );
+					PrintGrfFilename(buf, lc->grfmove.grfid);
+					break;
+			}
+
+			proc(buf);
+		}
+	}
+
+	proc("---- gamelog end ----");
+}
+
+
+static void GamelogPrintConsoleProc(const char *s)
+{
+	IConsolePrint(CC_WARNING, s);
+}
+
+void GamelogPrintConsole()
+{
+	GamelogPrint(&GamelogPrintConsoleProc);
+}
+
+
+static void GamelogPrintDebugProc(const char *s)
+{
+	debug_print("gamelog", s);
+}
+
+void GamelogPrintDebug()
+{
+	GamelogPrint(&GamelogPrintDebugProc);
+}
+
+
+/** Allocates new LoggedChange and new LoggedAction if needed.
+ * If there is no action active, NULL is returned.
+ * @param ct type of change
+ * @return new LoggedChange, or NULL if there is no action active
+ */
+static LoggedChange *GamelogChange(GamelogChangeType ct)
+{
+	if (_current_action == NULL) {
+		if (_gamelog_action_type == GLAT_NONE) return NULL;
+
+		_gamelog_action  = ReallocT(_gamelog_action, _gamelog_actions + 1);
+		_current_action  = &_gamelog_action[_gamelog_actions++];
+
+		_current_action->at      = _gamelog_action_type;
+		_current_action->tick    = _tick_counter;
+		_current_action->change  = NULL;
+		_current_action->changes = 0;
+	}
+
+	_current_action->change = ReallocT(_current_action->change, _current_action->changes + 1);
+
+	LoggedChange *lc = &_current_action->change[_current_action->changes++];
+	lc->ct = ct;
+
+	return lc;
+}
+
+
+/** Logs a change in game revision
+ * @param revision new revision string
+ */
+void GamelogRevision()
+{
+	assert(_gamelog_action_type == GLAT_START || _gamelog_action_type == GLAT_LOAD);
+
+	LoggedChange *lc = GamelogChange(GLCT_REVISION);
+	if (lc == NULL) return;
+
+	strncpy(lc->revision.text, _openttd_revision, lengthof(lc->revision.text));
+	lc->revision.slver = SAVEGAME_VERSION;
+	lc->revision.modified = _openttd_revision_modified;
+	lc->revision.newgrf = _openttd_newgrf_version;
+}
+
+/** Logs a change in game mode (scenario editor or game)
+ */
+void GamelogMode()
+{
+	assert(_gamelog_action_type == GLAT_START || _gamelog_action_type == GLAT_LOAD || _gamelog_action_type == GLAT_CHEAT);
+
+	LoggedChange *lc = GamelogChange(GLCT_MODE);
+	if (lc == NULL) return;
+
+	lc->mode.mode      = _game_mode;
+	lc->mode.landscape = _settings_game.game_creation.landscape;
+}
+
+/** Logs loading from savegame without gamelog
+ */
+void GamelogOldver()
+{
+	assert(_gamelog_action_type == GLAT_LOAD);
+
+	LoggedChange *lc = GamelogChange(GLCT_OLDVER);
+	if (lc == NULL) return;
+
+	lc->oldver.type = _savegame_type;
+	lc->oldver.version = (_savegame_type == SGT_OTTD ? ((uint32)_sl_version << 8 | _sl_minor_version) : _ttdp_version);
+}
+
+/** Logs change in game patches. Only non-networksafe patches are logged
+ * @param name patch name
+ * @param oldval old patch value
+ * @param newval new patch value
+ */
+void GamelogPatch(const char *name, int32 oldval, int32 newval)
+{
+	assert(_gamelog_action_type == GLAT_PATCH);
+
+	LoggedChange *lc = GamelogChange(GLCT_PATCH);
+	if (lc == NULL) return;
+
+	lc->patch.name = strdup(name);
+	lc->patch.oldval = oldval;
+	lc->patch.newval = newval;
+}
+
+
+/** Finds out if current revision is different than last revision stored in the savegame.
+ * Appends GLCT_REVISION when the revision string changed
+ */
+void GamelogTestRevision()
+{
+	const LoggedChange *rev = NULL;
+
+	const LoggedAction *laend = &_gamelog_action[_gamelog_actions];
+	for (const LoggedAction *la = _gamelog_action; la != laend; la++) {
+		const LoggedChange *lcend = &la->change[la->changes];
+		for (const LoggedChange *lc = la->change; lc != lcend; lc++) {
+			if (lc->ct == GLCT_REVISION) rev = lc;
+		}
+	}
+
+	if (rev == NULL || strcmp(rev->revision.text, _openttd_revision) != 0 ||
+			rev->revision.modified != _openttd_revision_modified ||
+			rev->revision.newgrf != _openttd_newgrf_version) {
+		GamelogRevision();
+	}
+}
+
+/** Finds last stored game mode or landscape.
+ * Any change is logged
+ */
+void GamelogTestMode()
+{
+	const LoggedChange *mode = NULL;
+
+	const LoggedAction *laend = &_gamelog_action[_gamelog_actions];
+	for (const LoggedAction *la = _gamelog_action; la != laend; la++) {
+		const LoggedChange *lcend = &la->change[la->changes];
+		for (const LoggedChange *lc = la->change; lc != lcend; lc++) {
+			if (lc->ct == GLCT_MODE) mode = lc;
+		}
+	}
+
+	if (mode == NULL || mode->mode.mode != _game_mode || mode->mode.landscape != _settings_game.game_creation.landscape) GamelogMode();
+}
+
+
+/** Decides if GRF should be logged
+ * @param g grf to determine
+ * @return true iff GRF is not static and is loaded
+ */
+static inline bool IsLoggableGrfConfig(const GRFConfig *g)
+{
+	return !HasBit(g->flags, GCF_STATIC) && g->status != GCS_NOT_FOUND;
+}
+
+/** Logs removal of a GRF
+ * @param grfid ID of removed GRF
+ */
+void GamelogGRFRemove(uint32 grfid)
+{
+	assert(_gamelog_action_type == GLAT_LOAD || _gamelog_action_type == GLAT_GRF);
+
+	LoggedChange *lc = GamelogChange(GLCT_GRFREM);
+	if (lc == NULL) return;
+
+	lc->grfrem.grfid = grfid;
+}
+
+/** Logs adding of a GRF
+ * @param newg added GRF
+ */
+void GamelogGRFAdd(const GRFConfig *newg)
+{
+	assert(_gamelog_action_type == GLAT_LOAD || _gamelog_action_type == GLAT_START || _gamelog_action_type == GLAT_GRF);
+
+	if (!IsLoggableGrfConfig(newg)) return;
+
+	LoggedChange *lc = GamelogChange(GLCT_GRFADD);
+	if (lc == NULL) return;
+
+	memcpy(&lc->grfadd, newg, sizeof(GRFIdentifier));
+}
+
+/** Logs loading compatible GRF
+ * (the same ID, but different MD5 hash)
+ * @param newg new (updated) GRF
+ */
+void GamelogGRFCompatible(const GRFIdentifier *newg)
+{
+	assert(_gamelog_action_type == GLAT_LOAD);
+
+	LoggedChange *lc = GamelogChange(GLCT_GRFCOMPAT);
+	if (lc == NULL) return;
+
+	memcpy(&lc->grfcompat, newg, sizeof(GRFIdentifier));
+}
+
+/** Logs changing GRF order
+ * @param grfid GRF that is moved
+ * @param offset how far it is moved, positive = moved down
+ */
+static void GamelogGRFMove(uint32 grfid, int32 offset)
+{
+	assert(_gamelog_action_type == GLAT_GRF);
+
+	LoggedChange *lc = GamelogChange(GLCT_GRFMOVE);
+	if (lc == NULL) return;
+
+	lc->grfmove.grfid  = grfid;
+	lc->grfmove.offset = offset;
+}
+
+/** Logs change in GRF parameters.
+ * Details about parameters changed are not stored
+ * @param grfid ID of GRF to store
+ */
+static void GamelogGRFParameters(uint32 grfid)
+{
+	assert(_gamelog_action_type == GLAT_GRF);
+
+	LoggedChange *lc = GamelogChange(GLCT_GRFPARAM);
+	if (lc == NULL) return;
+
+	lc->grfparam.grfid = grfid;
+}
+
+/** Logs adding of list of GRFs.
+ * Useful when old savegame is loaded or when new game is started
+ * @param newg head of GRF linked list
+ */
+void GamelogGRFAddList(const GRFConfig *newg)
+{
+	assert(_gamelog_action_type == GLAT_START || _gamelog_action_type == GLAT_LOAD);
+
+	for (; newg != NULL; newg = newg->next) {
+		GamelogGRFAdd(newg);
+	}
+}
+
+/** List of GRFs using array of pointers instead of linked list */
+struct GRFList {
+	uint n;
+	const GRFConfig *grf[VARARRAY_SIZE];
+};
+
+/** Generates GRFList
+ * @param grfc head of GRF linked list
+ */
+static GRFList *GenerateGRFList(const GRFConfig *grfc)
+{
+	uint n = 0;
+	for (const GRFConfig *g = grfc; g != NULL; g = g->next) {
+		if (IsLoggableGrfConfig(g)) n++;
+	}
+
+	GRFList *list = (GRFList*)MallocT<byte>(sizeof(GRFList) + n * sizeof(GRFConfig*));
+
+	list->n = 0;
+	for (const GRFConfig *g = grfc; g != NULL; g = g->next) {
+		if (IsLoggableGrfConfig(g)) list->grf[list->n++] = g;
+	}
+
+	return list;
+}
+
+/** Compares two NewGRF lists and logs any change
+ * @param oldc original GRF list
+ * @param newc new GRF list
+ */
+void GamelogGRFUpdate(const GRFConfig *oldc, const GRFConfig *newc)
+{
+	GRFList *ol = GenerateGRFList(oldc);
+	GRFList *nl = GenerateGRFList(newc);
+
+	uint o = 0, n = 0;
+
+	while (o < ol->n && n < nl->n) {
+		const GRFConfig *og = ol->grf[o];
+		const GRFConfig *ng = nl->grf[n];
+
+		if (og->grfid != ng->grfid) {
+			uint oi, ni;
+			for (oi = 0; oi < ol->n; oi++) {
+				if (ol->grf[oi]->grfid == nl->grf[n]->grfid) break;
+			}
+			if (oi < o) {
+				/* GRF was moved, this change has been logged already */
+				n++;
+				continue;
+			}
+			if (oi == ol->n) {
+				/* GRF couldn't be found in the OLD list, GRF was ADDED */
+				GamelogGRFAdd(nl->grf[n++]);
+				continue;
+			}
+			for (ni = 0; ni < nl->n; ni++) {
+				if (nl->grf[ni]->grfid == ol->grf[o]->grfid) break;
+			}
+			if (ni < n) {
+				/* GRF was moved, this change has been logged already */
+				o++;
+				continue;
+			}
+			if (ni == nl->n) {
+				/* GRF couldn't be found in the NEW list, GRF was REMOVED */
+				GamelogGRFRemove(ol->grf[o++]->grfid);
+				continue;
+			}
+
+			/* o < oi < ol->n
+			 * n < ni < nl->n */
+			assert(ni > n && ni < nl->n);
+			assert(oi > o && oi < ol->n);
+
+			ni -= n; // number of GRFs it was moved downwards
+			oi -= o; // number of GRFs it was moved upwards
+
+			if (ni >= oi) { // prefer the one that is moved further
+				/* GRF was moved down */
+				GamelogGRFMove(ol->grf[o++]->grfid, ni);
+			} else {
+				GamelogGRFMove(nl->grf[n++]->grfid, -(int)oi);
+			}
+		} else {
+			if (memcmp(og->md5sum, ng->md5sum, sizeof(og->md5sum)) != 0) {
+				/* md5sum changed, probably loading 'compatible' GRF */
+				GamelogGRFCompatible(nl->grf[n]);
+			}
+
+			if (og->num_params != ng->num_params || memcmp(og->param, ng->param, og->num_params * sizeof(og->param[0])) != 0) {
+				GamelogGRFParameters(ol->grf[o]->grfid);
+			}
+
+			o++;
+			n++;
+		}
+	}
+
+	while (o < ol->n) GamelogGRFRemove(ol->grf[o++]->grfid); // remaining GRFs were removed ...
+	while (n < nl->n) GamelogGRFAdd   (nl->grf[n++]);    // ... or added
+
+	free(ol);
+	free(nl);
+}
+
+
+static const SaveLoad _glog_action_desc[] = {
+	SLE_VAR(LoggedAction, tick,              SLE_UINT16),
+	SLE_END()
+};
+
+static const SaveLoad _glog_mode_desc[] = {
+	SLE_VAR(LoggedChange, mode.mode,         SLE_UINT8),
+	SLE_VAR(LoggedChange, mode.landscape,    SLE_UINT8),
+	SLE_END()
+};
+
+static const SaveLoad _glog_revision_desc[] = {
+	SLE_ARR(LoggedChange, revision.text,     SLE_UINT8,  NETWORK_REVISION_LENGTH),
+	SLE_VAR(LoggedChange, revision.newgrf,   SLE_UINT32),
+	SLE_VAR(LoggedChange, revision.slver,    SLE_UINT16),
+	SLE_VAR(LoggedChange, revision.modified, SLE_UINT8),
+	SLE_END()
+};
+
+static const SaveLoad _glog_oldver_desc[] = {
+	SLE_VAR(LoggedChange, oldver.type,       SLE_UINT32),
+	SLE_VAR(LoggedChange, oldver.version,    SLE_UINT32),
+	SLE_END()
+};
+
+static const SaveLoad _glog_patch_desc[] = {
+	SLE_STR(LoggedChange, patch.name,        SLE_STR,    128),
+	SLE_VAR(LoggedChange, patch.oldval,      SLE_INT32),
+	SLE_VAR(LoggedChange, patch.newval,      SLE_INT32),
+	SLE_END()
+};
+
+static const SaveLoad _glog_grfadd_desc[] = {
+	SLE_VAR(LoggedChange, grfadd.grfid,      SLE_UINT32    ),
+	SLE_ARR(LoggedChange, grfadd.md5sum,     SLE_UINT8,  16),
+	SLE_END()
+};
+
+static const SaveLoad _glog_grfrem_desc[] = {
+	SLE_VAR(LoggedChange, grfrem.grfid,      SLE_UINT32),
+	SLE_END()
+};
+
+static const SaveLoad _glog_grfcompat_desc[] = {
+	SLE_VAR(LoggedChange, grfcompat.grfid,   SLE_UINT32    ),
+	SLE_ARR(LoggedChange, grfcompat.md5sum,  SLE_UINT8,  16),
+	SLE_END()
+};
+
+static const SaveLoad _glog_grfparam_desc[] = {
+	SLE_VAR(LoggedChange, grfparam.grfid,    SLE_UINT32),
+	SLE_END()
+};
+
+static const SaveLoad _glog_grfmove_desc[] = {
+	SLE_VAR(LoggedChange, grfmove.grfid,    SLE_UINT32),
+	SLE_VAR(LoggedChange, grfmove.offset,   SLE_INT32),
+	SLE_END()
+};
+
+static const SaveLoad *_glog_desc[] = {
+	_glog_mode_desc,
+	_glog_revision_desc,
+	_glog_oldver_desc,
+	_glog_patch_desc,
+	_glog_grfadd_desc,
+	_glog_grfrem_desc,
+	_glog_grfcompat_desc,
+	_glog_grfparam_desc,
+	_glog_grfmove_desc
+};
+
+assert_compile(lengthof(_glog_desc) == GLCT_END);
+
+static void Load_GLOG()
+{
+	assert(_gamelog_action == NULL);
+	assert(_gamelog_actions == 0);
+
+	GamelogActionType at;
+	while ((at = (GamelogActionType)SlReadByte()) != GLAT_NONE) {
+		_gamelog_action = ReallocT(_gamelog_action, _gamelog_actions + 1);
+		LoggedAction *la = &_gamelog_action[_gamelog_actions++];
+
+		la->at = at;
+
+		SlObject(la, _glog_action_desc); // has to be saved after 'DATE'!
+		la->change = NULL;
+		la->changes = 0;
+
+		GamelogChangeType ct;
+		while ((ct = (GamelogChangeType)SlReadByte()) != GLCT_NONE) {
+			la->change = ReallocT(la->change, la->changes + 1);
+
+			LoggedChange *lc = &la->change[la->changes++];
+			lc->ct = ct;
+
+			assert((uint)ct < GLCT_END);
+
+			SlObject(lc, _glog_desc[ct]);
+		}
+	}
+}
+
+static void Save_GLOG()
+{
+	const LoggedAction *laend = &_gamelog_action[_gamelog_actions];
+	size_t length = 0;
+
+	for (const LoggedAction *la = _gamelog_action; la != laend; la++) {
+		const LoggedChange *lcend = &la->change[la->changes];
+		for (LoggedChange *lc = la->change; lc != lcend; lc++) {
+			assert((uint)lc->ct < lengthof(_glog_desc));
+			length += SlCalcObjLength(lc, _glog_desc[lc->ct]) + 1;
+		}
+		length += 4;
+	}
+	length++;
+
+	SlSetLength(length);
+
+	for (LoggedAction *la = _gamelog_action; la != laend; la++) {
+		SlWriteByte(la->at);
+		SlObject(la, _glog_action_desc);
+
+		const LoggedChange *lcend = &la->change[la->changes];
+		for (LoggedChange *lc = la->change; lc != lcend; lc++) {
+			SlWriteByte(lc->ct);
+			assert((uint)lc->ct < GLCT_END);
+			SlObject(lc, _glog_desc[lc->ct]);
+		}
+		SlWriteByte(GLCT_NONE);
+	}
+	SlWriteByte(GLAT_NONE);
+}
+
+
+extern const ChunkHandler _gamelog_chunk_handlers[] = {
+	{ 'GLOG', Save_GLOG, Load_GLOG, CH_RIFF | CH_LAST }
+};
diff --git a/src/gamelog.h b/src/gamelog.h
new file mode 100644
index 000000000..418ec1ee4
--- /dev/null
+++ b/src/gamelog.h
@@ -0,0 +1,46 @@
+/* $Id$ */
+
+/** @file gamelog.h Functions to be called to log possibly unsafe game events */
+
+#ifndef GAMELOG_H
+#define GAMELOG_H
+
+#include "newgrf_config.h"
+
+enum GamelogActionType {
+	GLAT_START,        ///< Game created
+	GLAT_LOAD,         ///< Game loaded
+	GLAT_GRF,          ///< GRF changed
+	GLAT_CHEAT,        ///< Cheat was used
+	GLAT_PATCH,        ///< Patches setting changed
+	GLAT_END,          ///< So we know how many GLATs are there
+	GLAT_NONE  = 0xFF, ///< No logging active; in savegames, end of list
+};
+
+void GamelogStartAction(GamelogActionType at);
+void GamelogStopAction();
+
+void GamelogReset();
+
+typedef void GamelogPrintProc(const char *s);
+void GamelogPrint(GamelogPrintProc *proc); // needed for WIN32 / WINCE crash.log
+
+void GamelogPrintDebug();
+void GamelogPrintConsole();
+
+void GamelogRevision();
+void GamelogMode();
+void GamelogOldver();
+void GamelogPatch(const char *name, int32 oldval, int32 newval);
+
+void GamelogGRFUpdate(const GRFConfig *oldg, const GRFConfig *newg);
+void GamelogGRFAddList(const GRFConfig *newg);
+void GamelogGRFRemove(uint32 grfid);
+void GamelogGRFAdd(const GRFConfig *newg);
+void GamelogGRFCompatible(const GRFIdentifier *newg);
+
+void GamelogTestRevision();
+void GamelogTestMode();
+void GamelogTestGRF();
+
+#endif /* GAMELOG_H */
diff --git a/src/misc.cpp b/src/misc.cpp
index 9c1cb82ed..f89f233c5 100644
--- a/src/misc.cpp
+++ b/src/misc.cpp
@@ -25,6 +25,7 @@
 #include "texteff.hpp"
 #include "gfx_func.h"
 #include "core/alloc_type.hpp"
+#include "gamelog.h"
 #include "animated_tile_func.h"
 #include "tilehighlight_func.h"
 #include "core/bitmath_func.hpp"
@@ -110,6 +111,13 @@ void InitializeGame(uint size_x, uint size_y, bool reset_date)
 	InitializeLandscapeVariables(false);
 
 	ResetObjectToPlace();
+
+	GamelogReset();
+	GamelogStartAction(GLAT_START);
+	GamelogRevision();
+	GamelogMode();
+	GamelogGRFAddList(_grfconfig);
+	GamelogStopAction();
 }
 
 
diff --git a/src/newgrf_config.cpp b/src/newgrf_config.cpp
index 0c8e0dbd2..0a09c82f4 100644
--- a/src/newgrf_config.cpp
+++ b/src/newgrf_config.cpp
@@ -12,6 +12,7 @@
 #include "newgrf_config.h"
 #include "core/alloc_func.hpp"
 #include "string_func.h"
+#include "gamelog.h"
 #include "network/network_type.h"
 
 #include "fileio.h"
@@ -231,6 +232,7 @@ GRFListCompatibility IsGoodGRFConfigList()
 
 				/* Non-found has precedence over compatibility load */
 				if (res != GLC_NOT_FOUND) res = GLC_COMPATIBLE;
+				GamelogGRFCompatible(f);
 				goto compatible_grf;
 			}
 
@@ -238,6 +240,8 @@ GRFListCompatibility IsGoodGRFConfigList()
 			md5sumToString(buf, lastof(buf), c->md5sum);
 			DEBUG(grf, 0, "NewGRF %08X (%s) not found; checksum %s", BSWAP32(c->grfid), c->filename, buf);
 
+			GamelogGRFRemove(c->grfid);
+
 			c->status = GCS_NOT_FOUND;
 			res = GLC_NOT_FOUND;
 		} else {
diff --git a/src/newgrf_gui.cpp b/src/newgrf_gui.cpp
index 70b0ac6b8..4b4765fe2 100644
--- a/src/newgrf_gui.cpp
+++ b/src/newgrf_gui.cpp
@@ -15,6 +15,7 @@
 #include "core/alloc_func.hpp"
 #include "string_func.h"
 #include "gfx_func.h"
+#include "gamelog.h"
 
 #include "table/strings.h"
 #include "table/sprites.h"
@@ -564,8 +565,11 @@ static void NewGRFConfirmationCallback(Window *w, bool confirmed)
 		GRFConfig *c;
 		int i = 0;
 
+		GamelogStartAction(GLAT_GRF);
+		GamelogGRFUpdate(_grfconfig, nw->list); // log GRF changes
 		CopyGRFConfigList(nw->orig_list, nw->list, false);
 		ReloadNewGRFData();
+		GamelogStopAction();
 
 		/* Show new, updated list */
 		for (c = nw->list; c != NULL && c != nw->sel; c = c->next, i++) {}
diff --git a/src/openttd.cpp b/src/openttd.cpp
index 5cf5fb6ea..50bebca62 100644
--- a/src/openttd.cpp
+++ b/src/openttd.cpp
@@ -54,6 +54,7 @@
 #include "strings_func.h"
 #include "date_func.h"
 #include "vehicle_func.h"
+#include "gamelog.h"
 #include "cheat_func.h"
 #include "animated_tile_func.h"
 #include "functions.h"
@@ -304,6 +305,7 @@ static void ShutdownGame()
 	UnInitializeAirports();
 
 	/* Uninitialize variables that are allocated dynamically */
+	GamelogReset();
 	_Town_pool.CleanPool();
 	_Industry_pool.CleanPool();
 	_Station_pool.CleanPool();
@@ -1257,6 +1259,13 @@ bool AfterLoadGame()
 	TileIndex map_size = MapSize();
 	Player *p;
 
+	if (CheckSavegameVersion(98)) GamelogOldver();
+
+	GamelogTestRevision();
+	GamelogTestMode();
+
+	if (CheckSavegameVersion(98)) GamelogGRFAddList(_grfconfig);
+
 	/* in version 2.1 of the savegame, town owner was unified. */
 	if (CheckSavegameVersionOldStyle(2, 1)) ConvertTownOwner();
 
@@ -2420,6 +2429,8 @@ bool AfterLoadGame()
 		}
 	}
 
+	if (_debug_gamelog_level > 0) GamelogPrintDebug();
+
 	return InitializeWindowsAndCaches();
 }
 
diff --git a/src/rev.cpp.in b/src/rev.cpp.in
index 458f92e86..bae5c6085 100644
--- a/src/rev.cpp.in
+++ b/src/rev.cpp.in
@@ -23,6 +23,16 @@
 const char _openttd_revision[] = "@@VERSION@@";
 
 /**
+ * Let us know if current build was modified. This detection
+ * works even in the case when revision string is overriden by
+ * --revision argument.
+ * Value 0 means no modification, 1 is for unknown state
+ * (compiling from sources without any version control software)
+ * and 2 is for modified revision.
+ */
+const byte _openttd_revision_modified = @@MODIFIED@@;
+
+/**
  * The NewGRF revision of OTTD:
  * bits  meaning.
  * 28-31 major version
diff --git a/src/rev.h b/src/rev.h
index b25c729ca..c474b900b 100644
--- a/src/rev.h
+++ b/src/rev.h
@@ -6,6 +6,7 @@
 #define REV_H
 
 extern const char _openttd_revision[];
+extern const byte _openttd_revision_modified;
 extern const uint32 _openttd_newgrf_version;
 
 #endif /* REV_H */
diff --git a/src/saveload.cpp b/src/saveload.cpp
index 76feecc38..5cec94cdf 100644
--- a/src/saveload.cpp
+++ b/src/saveload.cpp
@@ -32,10 +32,11 @@
 #include "autoreplace_base.h"
 #include "statusbar_gui.h"
 #include <list>
+#include "gamelog.h"
 
 #include "table/strings.h"
 
-extern const uint16 SAVEGAME_VERSION = 97;
+extern const uint16 SAVEGAME_VERSION = 98;
 
 SavegameType _savegame_type; ///< type of savegame we are loading
 
@@ -765,7 +766,7 @@ static inline bool SlSkipVariableOnLoad(const SaveLoad *sld)
  * @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;
 
@@ -1286,6 +1287,7 @@ static void UninitWriteZlib()
  *******************************************/
 
 /* 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[] ;
@@ -1307,6 +1309,7 @@ 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,
@@ -1643,10 +1646,16 @@ SaveOrLoadResult SaveOrLoad(const char *filename, int mode, Subdirectory sb)
 	/* Load a TTDLX or TTDPatch game */
 	if (mode == SL_OLD_LOAD) {
 		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;
 	}
 
@@ -1757,15 +1766,24 @@ SaveOrLoadResult SaveOrLoad(const char *filename, int mode, Subdirectory sb)
 			 * confuse old games */
 			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;
diff --git a/src/saveload.h b/src/saveload.h
index bed4f7737..dfe07350c 100644
--- a/src/saveload.h
+++ b/src/saveload.h
@@ -317,6 +317,7 @@ void SlAutolength(AutolengthProc *proc, void *arg);
 size_t SlGetFieldLength();
 void SlSetLength(size_t length);
 size_t SlCalcObjMemberLength(const void *object, const SaveLoad *sld);
+size_t SlCalcObjLength(const void *object, const SaveLoad *sld);
 
 byte SlReadByte();
 void SlWriteByte(byte b);
diff --git a/src/settings.cpp b/src/settings.cpp
index 88596c9f1..b3cc06127 100644
--- a/src/settings.cpp
+++ b/src/settings.cpp
@@ -60,6 +60,7 @@
 #include "sound/sound_driver.hpp"
 #include "music/music_driver.hpp"
 #include "blitter/factory.hpp"
+#include "gamelog.h"
 #include "station_func.h"
 
 #include "table/strings.h"
@@ -2128,8 +2129,20 @@ CommandCost CmdChangePatchSetting(TileIndex tile, uint32 flags, uint32 p1, uint3
 	if (flags & DC_EXEC) {
 		GameSettings *s = (_game_mode == GM_MENU) ? &_settings_newgame : &_settings_game;
 		void *var = GetVariableAddress(s, &sd->save);
-		Write_ValidateSetting(var, sd, (int32)p2);
-		if (sd->desc.proc != NULL) sd->desc.proc((int32)ReadValue(var, sd->save.conv));
+
+		int32 oldval = (int32)ReadValue(var, sd->save.conv);
+		int32 newval = (int32)p2;
+
+		Write_ValidateSetting(var, sd, newval);
+		newval = (int32)ReadValue(var, sd->save.conv);
+
+		if (sd->desc.proc != NULL) sd->desc.proc(newval);
+
+		if ((sd->desc.flags & SGF_NO_NETWORK) && oldval != newval) {
+			GamelogStartAction(GLAT_PATCH);
+			GamelogPatch(sd->desc.name, oldval, newval);
+			GamelogStopAction();
+		}
 
 		InvalidateWindow(WC_GAME_OPTIONS, 0);
 	}
diff --git a/src/win32.cpp b/src/win32.cpp
index 21ddfed03..5fa7edc82 100644
--- a/src/win32.cpp
+++ b/src/win32.cpp
@@ -25,6 +25,7 @@
 #include "core/random_func.hpp"
 #include "core/bitmath_func.hpp"
 #include "string_func.h"
+#include "gamelog.h"
 #include <ctype.h>
 #include <tchar.h>
 #include <errno.h>
@@ -454,6 +455,15 @@ static void Handler2()
 
 extern bool CloseConsoleLogIfActive();
 
+static HANDLE _file_crash_log;
+
+static void GamelogPrintCrashLogProc(const char *s)
+{
+	DWORD num_written;
+	WriteFile(_file_crash_log, s, strlen(s), &num_written, NULL);
+	WriteFile(_file_crash_log, "\r\n", strlen("\r\n"), &num_written, NULL);
+}
+
 static LONG WINAPI ExceptionHandler(EXCEPTION_POINTERS *ep)
 {
 	char *output;
@@ -588,17 +598,15 @@ static LONG WINAPI ExceptionHandler(EXCEPTION_POINTERS *ep)
 		os.dwOSVersionInfoSize = sizeof(os);
 		GetVersionEx(&os);
 		output += sprintf(output, "\r\nSystem information:\r\n"
-			" Windows version %d.%d %d %s\r\n",
+			" Windows version %d.%d %d %s\r\n\r\n",
 			os.dwMajorVersion, os.dwMinorVersion, os.dwBuildNumber, os.szCSDVersion);
 	}
 
-	{
-		HANDLE file = CreateFile(_T("crash.log"), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
+	_file_crash_log = CreateFile(_T("crash.log"), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
+
+	if (_file_crash_log != INVALID_HANDLE_VALUE) {
 		DWORD num_written;
-		if (file != INVALID_HANDLE_VALUE) {
-			WriteFile(file, _crash_msg, output - _crash_msg, &num_written, NULL);
-			CloseHandle(file);
-		}
+		WriteFile(_file_crash_log, _crash_msg, output - _crash_msg, &num_written, NULL);
 	}
 
 #if !defined(_DEBUG)
@@ -636,6 +644,11 @@ static LONG WINAPI ExceptionHandler(EXCEPTION_POINTERS *ep)
 	}
 #endif
 
+	if (_file_crash_log != INVALID_HANDLE_VALUE) {
+		GamelogPrint(&GamelogPrintCrashLogProc);
+		CloseHandle(_file_crash_log);
+	}
+
 	/* Close any possible log files */
 	CloseConsoleLogIfActive();