49 static char gamelog_revision[48] = { 0 };
50 assert_compile(
lengthof(gamelog_revision) > GAMELOG_REVISION_LENGTH);
52 if (IsReleasedVersion()) {
53 return _openttd_revision;
54 }
else if (gamelog_revision[0] == 0) {
56 assert(_openttd_revision_modified < 3);
57 gamelog_revision[0] =
"gum"[_openttd_revision_modified];
59 strecat(gamelog_revision, _openttd_revision_hash,
lastof(gamelog_revision));
61 gamelog_revision[GAMELOG_REVISION_LENGTH - 1] =
'\0';
63 return gamelog_revision;
84 bool print = _current_action != NULL;
86 _current_action = NULL;
97 for (uint i = 0; i < gamelog_actions; i++) {
99 for (uint j = 0; j < la->
changes; j++) {
106 free(gamelog_action);
117 _gamelog_action = NULL;
119 _current_action = NULL;
135 if (md5sum != NULL) {
137 buf +=
seprintf(buf, last,
"GRF ID %08X, checksum %s",
BSWAP32(grfid), txt);
143 buf +=
seprintf(buf, last,
", filename: %s (md5sum matches)", gc->
filename);
147 buf +=
seprintf(buf, last,
", filename: %s (matches GRFID only)", gc->
filename);
149 buf +=
seprintf(buf, last,
", unknown GRF");
160 "GRF config changed",
164 "emergency savegame",
193 proc(
"---- gamelog start ----");
197 for (
const LoggedAction *la = _gamelog_action; la != laend; la++) {
205 for (
const LoggedChange *lc = la->change; lc != lcend; lc++) {
209 default: NOT_REACHED();
211 buf +=
seprintf(buf,
lastof(buffer),
"New game mode: %u landscape: %u",
212 (uint)lc->mode.mode, (uint)lc->mode.landscape);
216 buf +=
seprintf(buf,
lastof(buffer),
"Revision text changed to %s, savegame version %u, ",
217 lc->revision.text, lc->revision.slver);
219 switch (lc->revision.modified) {
225 buf +=
seprintf(buf,
lastof(buffer),
"modified, _openttd_newgrf_version = 0x%08x", lc->revision.newgrf);
230 switch (lc->oldver.type) {
231 default: NOT_REACHED();
233 buf +=
seprintf(buf,
lastof(buffer),
"OTTD savegame without gamelog: version %u, %u",
234 GB(lc->oldver.version, 8, 16),
GB(lc->oldver.version, 0, 8));
248 lc->oldver.type ==
SGT_TTDP1 ?
"old" :
"new");
249 if (lc->oldver.version != 0) {
250 buf +=
seprintf(buf,
lastof(buffer),
", TTDP version %u.%u.%u.%u",
251 GB(lc->oldver.version, 24, 8),
GB(lc->oldver.version, 20, 4),
252 GB(lc->oldver.version, 16, 4),
GB(lc->oldver.version, 0, 16));
259 buf +=
seprintf(buf,
lastof(buffer),
"Setting changed: %s : %d -> %d", lc->setting.name, lc->setting.oldval, lc->setting.newval);
267 if (gm != grf_names.
End() && !gm->second.was_missing) buf +=
seprintf(buf,
lastof(buffer),
". Gamelog inconsistency: GrfID was already added!");
268 grf_names[lc->grfadd.grfid] =
gc;
275 buf =
PrintGrfInfo(buf,
lastof(buffer), lc->grfrem.grfid, NULL, gm != grf_names.
End() ? gm->second.gc : NULL);
276 if (gm == grf_names.
End()) {
277 buf +=
seprintf(buf,
lastof(buffer),
". Gamelog inconsistency: GrfID was never added!");
281 gm->second.was_missing =
true;
291 buf +=
seprintf(buf,
lastof(buffer),
"Compatible NewGRF loaded: ");
292 buf =
PrintGrfInfo(buf,
lastof(buffer), lc->grfcompat.grfid, lc->grfcompat.md5sum, gc);
293 if (!grf_names.
Contains(lc->grfcompat.grfid)) buf +=
seprintf(buf,
lastof(buffer),
". Gamelog inconsistency: GrfID was never added!");
294 grf_names[lc->grfcompat.grfid] =
gc;
301 buf =
PrintGrfInfo(buf,
lastof(buffer), lc->grfparam.grfid, NULL, gm != grf_names.
End() ? gm->second.gc : NULL);
302 if (gm == grf_names.
End()) buf +=
seprintf(buf,
lastof(buffer),
". Gamelog inconsistency: GrfID was never added!");
308 buf +=
seprintf(buf,
lastof(buffer),
"GRF order changed: %08X moved %d places %s",
309 BSWAP32(lc->grfmove.grfid),
abs(lc->grfmove.offset), lc->grfmove.offset >= 0 ?
"down" :
"up" );
310 buf =
PrintGrfInfo(buf,
lastof(buffer), lc->grfmove.grfid, NULL, gm != grf_names.
End() ? gm->second.gc : NULL);
311 if (gm == grf_names.
End()) buf +=
seprintf(buf,
lastof(buffer),
". Gamelog inconsistency: GrfID was never added!");
317 switch (lc->grfbug.bug) {
318 default: NOT_REACHED();
320 buf +=
seprintf(buf,
lastof(buffer),
"Rail vehicle changes length outside a depot: GRF ID %08X, internal ID 0x%X",
BSWAP32(lc->grfbug.grfid), (uint)lc->grfbug.data);
323 buf =
PrintGrfInfo(buf,
lastof(buffer), lc->grfbug.grfid, NULL, gm != grf_names.
End() ? gm->second.gc : NULL);
324 if (gm == grf_names.
End()) buf +=
seprintf(buf,
lastof(buffer),
". Gamelog inconsistency: GrfID was never added!");
336 proc(
"---- gamelog end ----");
340 static void GamelogPrintConsoleProc(
const char *s)
353 static void GamelogPrintDebugProc(
const char *s)
380 if (_current_action == NULL) {
388 _current_action->
change = NULL;
421 for (
const LoggedAction *la = _gamelog_action; la != laend; la++) {
423 for (
const LoggedChange *lc = la->change; lc != lcend; lc++) {
428 return (emergency != NULL);
439 if (lc == NULL)
return;
441 memset(lc->revision.text, 0,
sizeof(lc->revision.text));
444 lc->revision.modified = _openttd_revision_modified;
445 lc->revision.newgrf = _openttd_newgrf_version;
456 if (lc == NULL)
return;
458 lc->
mode.mode = _game_mode;
470 if (lc == NULL)
return;
487 if (lc == NULL)
return;
489 lc->setting.name =
stredup(name);
490 lc->setting.oldval = oldval;
491 lc->setting.newval = newval;
504 for (
const LoggedAction *la = _gamelog_action; la != laend; la++) {
506 for (
const LoggedChange *lc = la->change; lc != lcend; lc++) {
512 rev->revision.modified != _openttd_revision_modified ||
513 rev->revision.newgrf != _openttd_newgrf_version) {
527 for (
const LoggedAction *la = _gamelog_action; la != laend; la++) {
529 for (
const LoggedChange *lc = la->change; lc != lcend; lc++) {
549 if (lc == NULL)
return;
551 lc->grfbug.data = data;
552 lc->grfbug.grfid = grfid;
553 lc->grfbug.bug = bug;
568 for (
const LoggedAction *la = _gamelog_action; la != laend; la++) {
570 for (
const LoggedChange *lc = la->change; lc != lcend; lc++) {
571 if (lc->ct ==
GLCT_GRFBUG && lc->grfbug.grfid == grfid &&
605 if (lc == NULL)
return;
607 lc->grfrem.grfid = grfid;
621 if (lc == NULL)
return;
636 if (lc == NULL)
return;
651 if (lc == NULL)
return;
653 lc->grfmove.grfid = grfid;
654 lc->grfmove.offset = offset;
667 if (lc == NULL)
return;
669 lc->grfparam.grfid = grfid;
681 for (; newg != NULL; newg = newg->
next) {
725 while (o < ol->n && n < nl->n) {
731 for (oi = 0; oi < ol->n; oi++) {
744 for (ni = 0; ni < nl->n; ni++) {
760 assert(ni > n && ni < nl->n);
761 assert(oi > o && oi < ol->n);
802 void GamelogInfo(
LoggedAction *gamelog_action, uint gamelog_actions, uint32 *last_ottd_rev, byte *ever_modified,
bool *removed_newgrfs)
804 const LoggedAction *laend = &gamelog_action[gamelog_actions];
805 for (
const LoggedAction *la = gamelog_action; la != laend; la++) {
807 for (
const LoggedChange *lc = la->change; lc != lcend; lc++) {
812 *last_ottd_rev = lc->revision.newgrf;
813 *ever_modified =
max(*ever_modified, lc->revision.modified);
817 *removed_newgrfs =
true;
void GamelogPrint(GamelogPrintProc *proc)
Prints active gamelog.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
bool GamelogTestEmergency()
Finds out if current game is a loaded emergency savegame.
Loaded from savegame without logged data.
static GamelogActionType _gamelog_action_type
action to record if anything changes
static LoggedAction * _current_action
current action we are logging, NULL when there is no action active
bool Contains(const T &key) const
Tests whether a key is assigned in this map.
static void GamelogGRFParameters(uint32 grfid)
Logs change in GRF parameters.
void GamelogEmergency()
Logs a emergency savegame.
byte landscape
the landscape we're currently in
GamelogChangeType ct
Type of change logged in this struct.
static char * strecat(char *dst, const char *src, const char *last)
Appends characters from one string to another.
SaveLoadVersion
SaveLoad versions Previous savegame versions, the trunk revision where they were introduced and the r...
const Pair * Find(const T &key) const
Finds given key in this map.
Functions related to dates.
int CDECL seprintf(char *str, const char *last, const char *format,...)
Safer implementation of snprintf; same as snprintf except:
Functions related to debugging.
static void GamelogGRFMove(uint32 grfid, int32 offset)
Logs changing GRF order.
void GamelogStartAction(GamelogActionType at)
Stores information about new action, but doesn't allocate it Action is allocated only when there is a...
Implementation of simple mapping class.
GRFStatus status
NOSAVE: GRFStatus, enum.
char * md5sumToString(char *buf, const char *last, const uint8 md5sum[16])
Convert the md5sum to a hexadecimal string representation.
SaveLoadVersion _sl_version
the major savegame version identifier
static bool IsLoggableGrfConfig(const GRFConfig *g)
Decides if GRF should be logged.
uint32 changes
Number of changes in this action.
void GamelogRevision()
Logs a change in game revision.
GRF file is used statically (can be used in any MP game)
TTD savegame (can be detected incorrectly)
List of GRFs using array of pointers instead of linked list.
#define lastof(x)
Get the last element of an fixed size array.
void GamelogPrintDebug(int level)
Prints gamelog to debug output.
GRF file was not found in the local cache.
void GamelogOldver()
Logs loading from savegame without gamelog.
SavegameType
Types of save games.
const GRFConfig * FindGRFConfig(uint32 grfid, FindGRFConfigMode mode, const uint8 *md5sum, uint32 desired_version)
Find a NewGRF in the scanned list.
Non-networksafe setting value changed.
GRFIdentifier ident
grfid and md5sum to uniquely identify newgrfs
static T max(const T a, const T b)
Returns the maximum of two values.
GRFIdentifier grfcompat
ID and new md5sum of changed GRF.
static LoggedChange * GamelogChange(GamelogChangeType ct)
Allocates new LoggedChange and new LoggedAction if needed.
Basic data to distinguish a GRF.
uint _gamelog_actions
number of actions
const T * End() const
Get the pointer behind the last valid item (const)
static void GamelogGRFBug(uint32 grfid, byte bug, uint64 data)
Logs triggered GRF bug.
struct GRFConfig * next
NOSAVE: Next item in the linked list.
GamelogActionType
The actions we log.
GRFIdentifier grfadd
ID and md5sum of added GRF.
void GamelogInfo(LoggedAction *gamelog_action, uint gamelog_actions, uint32 *last_ottd_rev, byte *ever_modified, bool *removed_newgrfs)
Get some basic information from the given gamelog.
Functions related to low-level strings.
void GamelogSetting(const char *name, int32 oldval, int32 newval)
Logs change in game settings.
void GamelogReset()
Resets and frees all memory allocated - used before loading or starting a new game.
Functions/types related to saving and loading games.
uint8 num_params
Number of used parameters.
static int _gamelog_print_level
gamelog debug level we need to print stuff
Contains information about one logged action that caused at least one logged change.
void GamelogPrintConsole()
Print the gamelog data to the console.
void GamelogFree(LoggedAction *gamelog_action, uint gamelog_actions)
Frees the memory allocated by a gamelog.
Information about GRF, used in the game and (part of it) in savegames.
void IConsolePrint(TextColour colour_code, const char *string)
Handle the printing of text entered into the console or redirected there by any other means...
Types related to global configuration settings.
void GamelogGRFAdd(const GRFConfig *newg)
Logs adding of a GRF.
void GamelogMode()
Logs a change in game mode (scenario editor or game)
Definition of base types and functions in a cross-platform compatible way.
byte _sl_minor_version
the minor savegame version, DO NOT USE!
Information about the presence of a Grf at a certain point during gamelog history Note about missing ...
A number of safeguards to prevent using unsafe methods.
byte mode
new game mode - Editor x Game
bool was_missing
Grf was missing during some gameload in the past.
TTDP savegame in new format (data at SE border)
uint8 flags
NOSAVE: GCF_Flags, bitset.
char * stredup(const char *s, const char *last)
Create a duplicate of the given string.
static T * ReallocT(T *t_ptr, size_t num_elements)
Simplified reallocation function that allocates the specified number of elements of the given type...
Console functions used outside of the console code.
uint16 tick
Tick when it happened.
SavegameType _savegame_type
type of savegame we are loading
void GamelogGRFAddList(const GRFConfig *newg)
Logs adding of list of GRFs.
Scenario editor x Game, different landscape.
So we know how many GLATs are there.
void GamelogGRFCompatible(const GRFIdentifier *newg)
Logs loading compatible GRF (the same ID, but different MD5 hash)
const SaveLoadVersion SAVEGAME_VERSION
current savegame version
#define lengthof(x)
Return the length of an fixed size array.
void GamelogTestRevision()
Finds out if current revision is different than last revision stored in the savegame.
uint32 _ttdp_version
version of TTDP savegame (if applicable)
Changed game revision string.
void GamelogStopAction()
Stops logging of any changes.
#define DEBUG(name, level,...)
Output a line of debugging information.
LoggedAction * _gamelog_action
first logged action
uint16 _tick_counter
Ever incrementing (and sometimes wrapping) tick counter for setting off various events.
static char * PrintGrfInfo(char *buf, const char *last, uint grfid, const uint8 *md5sum, const GRFConfig *gc)
Prints GRF ID, checksum and filename if found.
void Erase(Pair *pair)
Removes given pair from this map.
GamelogActionType at
Type of action.
TTDP savegame ( -//- ) (data at NW border)
GamelogChangeType
Type of logged change.
LoggedChange * change
First logged change in this action.
Contains information about one logged change.
static T abs(const T a)
Returns the absolute value of (scalar) variable.
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
bool GamelogGRFBugReverse(uint32 grfid, uint16 internal_id)
Logs GRF bug - rail vehicle has different length after reversing.
char * strecpy(char *dst, const char *src, const char *last)
Copies characters from one buffer to another.
char * filename
Filename - either with or without full path.
const GRFConfig * gc
GRFConfig, if known.
void GamelogGRFRemove(uint32 grfid)
Logs removal of a GRF.
uint32 grfid
GRF ID (defined by Action 0x08)
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
declaration of OTTD revision dependent variables
Declaration shared among gamelog.cpp and saveload/gamelog_sl.cpp.
uint32 param[0x80]
GRF parameters.
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
No logging active; in savegames, end of list.
GameCreationSettings game_creation
settings used during the creation of a game (map)
void GamelogTestMode()
Finds last stored game mode or landscape.
static uint32 BSWAP32(uint32 x)
Perform a 32 bits endianness bitswap on x.
Length of rail vehicle changes when not inside a depot.
void GamelogPrintProc(const char *s)
Callback for printing text.
uint8 md5sum[16]
MD5 checksum of file to distinguish files with the same GRF ID (eg. newer version of GRF) ...
Only find Grfs matching md5sum.
static const char * GetGamelogRevisionString()
Return the revision string for the current client version, for use in gamelog.
void GamelogGRFUpdate(const GRFConfig *oldc, const GRFConfig *newc)
Compares two NewGRF lists and logs any change.
static const TextColour CC_WARNING
Colour for warning lines.
static const char *const la_text[]
Text messages for various logged actions.
static GRFList * GenerateGRFList(const GRFConfig *grfc)
Generates GRFList.