mirror of https://github.com/OpenTTD/OpenTTD.git
(svn r13375) -Add: logging of actions that could possibly cause desyncs and crashes to simplify debugging. See readme.txt for details
This commit is contained in:
smatz
parent
d58f055876
commit
c7a9637834
|
|
@ -89,6 +89,32 @@ $(LANG_OBJS_DIR)/$(STRGEN):
|
|||
$(LANG_OBJS_DIR)/table/strings.h: $(LANG_DIR)/english.txt $(LANG_OBJS_DIR)/$(STRGEN)
|
||||
$(MAKE) -C $(LANG_OBJS_DIR) table/strings.h
|
||||
|
||||
|
||||
# Determine if we are using a modified version
|
||||
ifeq ($(shell if test -d $(SRC_DIR)/.svn; then echo 1; fi), 1)
|
||||
REV_MODIFIED := $(shell svnversion $(SRC_DIR) | sed -n 's/.*\(M\).*/\1/p' )
|
||||
else
|
||||
# Are we a git dir?
|
||||
ifeq ($(shell if test -d $(SRC_DIR)/../.git; then echo 1; fi), 1)
|
||||
REV_MODIFIED := $(shell if cd "$(SRC_DIR)/.." && git diff-index HEAD src | read dummy; then echo M; fi)
|
||||
else
|
||||
# Are we a hg (Mercurial) dir?
|
||||
ifeq ($(shell if test -d $(SRC_DIR)/../.hg; then echo 1; fi), 1)
|
||||
REV_MODIFIED := $(shell if hg status $(SRC_DIR) | grep -v '^?' | read dummy; then echo M; fi)
|
||||
else
|
||||
MODIFIED="1"
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
ifneq ($(MODIFIED),"1")
|
||||
ifeq ($(REV_MODIFIED),)
|
||||
MODIFIED="0"
|
||||
else
|
||||
MODIFIED="2"
|
||||
endif
|
||||
endif
|
||||
|
||||
# Make the revision number
|
||||
ifdef REVISION
|
||||
REV := $(REVISION)
|
||||
|
|
@ -97,7 +123,6 @@ else
|
|||
# Are we a SVN dir?
|
||||
ifeq ($(shell if test -d $(SRC_DIR)/.svn; then echo 1; fi), 1)
|
||||
# Find if the local source if modified
|
||||
REV_MODIFIED := $(shell svnversion $(SRC_DIR) | sed -n 's/.*\(M\).*/\1/p' )
|
||||
# Find the revision like: rXXXX-branch
|
||||
REV := $(shell LC_ALL=C svn info $(SRC_DIR) | $(AWK) '/^URL:.*branch/ { split($$2, a, "/"); BRANCH="-"a[5] } /^Last Changed Rev:/ { REV="r"$$4"$(REV_MODIFIED)" } END { print REV BRANCH }')
|
||||
REV_NR := $(shell LC_ALL=C svn info $(SRC_DIR) | $(AWK) '/^Last Changed Rev:/ { print $$4 }')
|
||||
|
|
@ -105,13 +130,13 @@ else
|
|||
# Are we a git dir?
|
||||
ifeq ($(shell if test -d $(SRC_DIR)/../.git; then echo 1; fi), 1)
|
||||
# Find the revision like: gXXXXM-branch
|
||||
REV := g$(shell if head=`LC_ALL=C git rev-parse --verify HEAD 2>/dev/null`; then echo "$$head" | cut -c1-8; fi)$(shell if cd "$(SRC_DIR)/.." && git diff-index HEAD src | read dummy; then echo M; fi)$(shell git branch|grep '[*]' | sed 's/\* /-/;s/^-master$$//')
|
||||
REV := g$(shell if head=`LC_ALL=C git rev-parse --verify HEAD 2>/dev/null`; then echo "$$head" | cut -c1-8; fi)$(REV_MODIFIED)$(shell git branch|grep '[*]' | sed 's/\* /-/;s/^-master$$//')
|
||||
REV_NR := $(shell LC_ALL=C cd "$(SRC_DIR)/.." && git log --pretty=format:%s src | grep -m 1 "^(svn r[0-9]*)" | sed "s/.*(svn r\([0-9]*\)).*/\1/" )
|
||||
else
|
||||
# Are we a hg (Mercurial) dir?
|
||||
ifeq ($(shell if test -d $(SRC_DIR)/../.hg; then echo 1; fi), 1)
|
||||
# Find the revision like: hXXXXM-branch
|
||||
REV := h$(shell if head=`LC_ALL=C hg tip 2>/dev/null`; then echo "$$head" | head -n 1 | cut -c19-26; fi)$(shell if hg status $(SRC_DIR) | grep -v '^?' | read dummy; then echo M; fi)$(shell hg branch | sed 's/^/-/;s/^-default$$//')
|
||||
REV := h$(shell if head=`LC_ALL=C hg tip 2>/dev/null`; then echo "$$head" | head -n 1 | cut -c19-26; fi)$(REV_MODIFIED)$(shell hg branch | sed 's/^/-/;s/^-default$$//')
|
||||
REV_NR := $(shell LC_ALL=C hg log -k "svn" -l 1 --template "{desc}\n" $(SRC_DIR) | grep -m 1 "^(svn r[0-9]*)" | sed "s/.*(svn r\([0-9]*\)).*/\1/" )
|
||||
endif
|
||||
endif
|
||||
|
|
@ -287,7 +312,7 @@ $(ENDIAN_CHECK): $(SRC_DIR)/endian_check.cpp
|
|||
# Revision files
|
||||
|
||||
$(SRC_DIR)/rev.cpp: $(CONFIG_CACHE_VERSION) $(SRC_DIR)/rev.cpp.in
|
||||
$(Q)cat $(SRC_DIR)/rev.cpp.in | sed "s#@@REVISION@@#$(REV_NR)#g;s#@@VERSION@@#$(REV)#g;s#@@DATE@@#`date +%d.%m.%y`#g" > $(SRC_DIR)/rev.cpp
|
||||
$(Q)cat $(SRC_DIR)/rev.cpp.in | sed "s#@@REVISION@@#$(REV_NR)#g;s#@@VERSION@@#$(REV)#g;s#@@MODIFIED@@#$(MODIFIED)#g;s#@@DATE@@#`date +%d.%m.%y`#g" > $(SRC_DIR)/rev.cpp
|
||||
|
||||
$(SRC_DIR)/ottdres.rc: $(CONFIG_CACHE_VERSION) $(SRC_DIR)/ottdres.rc.in
|
||||
$(Q)cat $(SRC_DIR)/ottdres.rc.in | sed "s#@@REVISION@@#$(REV_NR)#g;s#@@VERSION@@#$(REV)#g;s#@@DATE@@#`date +%d.%m.%y`#g" > $(SRC_DIR)/ottdres.rc
|
||||
|
|
|
|||
|
|
@ -14,23 +14,28 @@ Sub FindReplaceInFile(filename, to_find, replacement)
|
|||
file.Close
|
||||
End Sub
|
||||
|
||||
Sub UpdateFile(revision, version, cur_date, filename)
|
||||
Sub UpdateFile(modified, revision, version, cur_date, filename)
|
||||
FSO.CopyFile filename & ".in", filename
|
||||
FindReplaceInFile filename, "@@MODIFIED@@", modified
|
||||
FindReplaceInFile filename, "@@REVISION@@", revision
|
||||
FindReplaceInFile filename, "@@VERSION@@", version
|
||||
FindReplaceInFile filename, "@@DATE@@", cur_date
|
||||
End Sub
|
||||
|
||||
Sub UpdateFiles(version)
|
||||
Dim WshShell, cur_date, revision, oExec
|
||||
Dim WshShell, cur_date, modified, revision, oExec
|
||||
Set WshShell = CreateObject("WScript.Shell")
|
||||
cur_date = DatePart("D", Date) & "." & DatePart("M", Date) & "." & DatePart("YYYY", Date)
|
||||
revision = 0
|
||||
modified = 1
|
||||
Select Case Mid(version, 1, 1)
|
||||
Case "r" ' svn
|
||||
revision = Mid(version, 2)
|
||||
If InStr(revision, "M") Then
|
||||
revision = Mid(revision, 1, InStr(revision, "M") - 1)
|
||||
modified = 2
|
||||
Else
|
||||
modified = 0
|
||||
End If
|
||||
If InStr(revision, "-") Then
|
||||
revision = Mid(revision, 1, InStr(revision, "-") - 1)
|
||||
|
|
@ -49,8 +54,8 @@ Sub UpdateFiles(version)
|
|||
End If
|
||||
End Select
|
||||
|
||||
UpdateFile revision, version, cur_date, "../src/rev.cpp"
|
||||
UpdateFile revision, version, cur_date, "../src/ottdres.rc"
|
||||
UpdateFile modified, revision, version, cur_date, "../src/rev.cpp"
|
||||
UpdateFile modified, revision, version, cur_date, "../src/ottdres.rc"
|
||||
End Sub
|
||||
|
||||
Function ReadRegistryKey(shive, subkey, valuename, architecture)
|
||||
|
|
|
|||
|
|
@ -567,6 +567,10 @@
|
|||
RelativePath=".\..\src\fontcache.cpp"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\..\src\gamelog.cpp"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\..\src\genworld.cpp"
|
||||
>
|
||||
|
|
@ -1035,6 +1039,10 @@
|
|||
RelativePath=".\..\src\functions.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\..\src\gamelog.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\..\src\genworld.h"
|
||||
>
|
||||
|
|
|
|||
|
|
@ -564,6 +564,10 @@
|
|||
RelativePath=".\..\src\fontcache.cpp"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\..\src\gamelog.cpp"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\..\src\genworld.cpp"
|
||||
>
|
||||
|
|
@ -1032,6 +1036,10 @@
|
|||
RelativePath=".\..\src\functions.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\..\src\gamelog.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\..\src\genworld.h"
|
||||
>
|
||||
|
|
|
|||
29
readme.txt
29
readme.txt
|
|
@ -203,6 +203,35 @@ Several important non-standard controls:
|
|||
http://wiki.openttd.org/index.php/Console
|
||||
|
||||
|
||||
5.1) Logging of potentially dangerous actions:
|
||||
---- ----------------------------------------
|
||||
|
||||
OpenTTD is a complex program, and together with NewGRF, it may show a buggy
|
||||
behaviour. But not only bugs in code can cause problems. There are several
|
||||
ways to affect game state possibly resulting in program crash or multiplayer
|
||||
desyncs.
|
||||
Easier way would be to forbid all these unsafe actions, but that would affect
|
||||
game usability for many players. We certainly do not want that.
|
||||
However, we receive bugreports because of this. To reduce time spent with
|
||||
solving these problems, these potentially unsafe actions are logged in
|
||||
the savegame (including crash.sav). Log is stored in crash logs, too.
|
||||
|
||||
Information logged:
|
||||
|
||||
* Adding / removing / changing order of NewGRFs
|
||||
* Changing NewGRF parameters, loading compatible NewGRF
|
||||
* Changing game mode (scenario editor <-> normal game)
|
||||
* Loading game saved in a different OTTD / TTDPatch / TTD version
|
||||
* Running a modified OTTD build
|
||||
* Changing patch settings affecting NewGRF behaviour (non-networksafe patches)
|
||||
* Changing landscape (by cheat)
|
||||
|
||||
No personal information is stored.
|
||||
|
||||
You can show the gamelog by typing 'gamelog' in the console or by running
|
||||
OpenTTD in debug mode.
|
||||
|
||||
|
||||
6.0) Configuration File:
|
||||
---- -------------------
|
||||
The configuration file for OpenTTD (openttd.cfg) is in a simple Windows-like
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@ engine.cpp
|
|||
fileio.cpp
|
||||
fios.cpp
|
||||
fontcache.cpp
|
||||
gamelog.cpp
|
||||
genworld.cpp
|
||||
gfx.cpp
|
||||
gfxinit.cpp
|
||||
|
|
@ -184,6 +185,7 @@ fileio.h
|
|||
fios.h
|
||||
fontcache.h
|
||||
functions.h
|
||||
gamelog.h
|
||||
genworld.h
|
||||
core/geometry_type.hpp
|
||||
gfx_func.h
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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 %+");
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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 }
|
||||
};
|
||||
|
|
@ -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 */
|
||||
|
|
@ -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();
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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++) {}
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -22,6 +22,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.
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue