60 bool print = _current_action != NULL;
62 _current_action = NULL;
73 for (uint i = 0; i < gamelog_actions; i++) {
75 for (uint j = 0; j < la->
changes; j++) {
93 _gamelog_action = NULL;
95 _current_action = NULL;
111 if (md5sum != NULL) {
113 buf +=
seprintf(buf, last,
"GRF ID %08X, checksum %s",
BSWAP32(grfid), txt);
119 buf +=
seprintf(buf, last,
", filename: %s (md5sum matches)", gc->
filename);
123 buf +=
seprintf(buf, last,
", filename: %s (matches GRFID only)", gc->
filename);
125 buf +=
seprintf(buf, last,
", unknown GRF");
136 "GRF config changed",
140 "emergency savegame",
169 proc(
"---- gamelog start ----");
173 for (
const LoggedAction *la = _gamelog_action; la != laend; la++) {
181 for (
const LoggedChange *lc = la->change; lc != lcend; lc++) {
185 default: NOT_REACHED();
187 buf +=
seprintf(buf,
lastof(buffer),
"New game mode: %u landscape: %u",
188 (uint)lc->mode.mode, (uint)lc->mode.landscape);
192 buf +=
seprintf(buf,
lastof(buffer),
"Revision text changed to %s, savegame version %u, ",
193 lc->revision.text, lc->revision.slver);
195 switch (lc->revision.modified) {
201 buf +=
seprintf(buf,
lastof(buffer),
"modified, _openttd_newgrf_version = 0x%08x", lc->revision.newgrf);
206 switch (lc->oldver.type) {
207 default: NOT_REACHED();
209 buf +=
seprintf(buf,
lastof(buffer),
"OTTD savegame without gamelog: version %u, %u",
210 GB(lc->oldver.version, 8, 16),
GB(lc->oldver.version, 0, 8));
224 lc->oldver.type ==
SGT_TTDP1 ?
"old" :
"new");
225 if (lc->oldver.version != 0) {
226 buf +=
seprintf(buf,
lastof(buffer),
", TTDP version %u.%u.%u.%u",
227 GB(lc->oldver.version, 24, 8),
GB(lc->oldver.version, 20, 4),
228 GB(lc->oldver.version, 16, 4),
GB(lc->oldver.version, 0, 16));
235 buf +=
seprintf(buf,
lastof(buffer),
"Setting changed: %s : %d -> %d", lc->setting.name, lc->setting.oldval, lc->setting.newval);
243 if (gm != grf_names.
End() && !gm->second.was_missing) buf +=
seprintf(buf,
lastof(buffer),
". Gamelog inconsistency: GrfID was already added!");
244 grf_names[lc->grfadd.grfid] =
gc;
251 buf =
PrintGrfInfo(buf,
lastof(buffer), lc->grfrem.grfid, NULL, gm != grf_names.
End() ? gm->second.gc : NULL);
252 if (gm == grf_names.
End()) {
253 buf +=
seprintf(buf,
lastof(buffer),
". Gamelog inconsistency: GrfID was never added!");
257 gm->second.was_missing =
true;
267 buf +=
seprintf(buf,
lastof(buffer),
"Compatible NewGRF loaded: ");
268 buf =
PrintGrfInfo(buf,
lastof(buffer), lc->grfcompat.grfid, lc->grfcompat.md5sum, gc);
269 if (!grf_names.
Contains(lc->grfcompat.grfid)) buf +=
seprintf(buf,
lastof(buffer),
". Gamelog inconsistency: GrfID was never added!");
270 grf_names[lc->grfcompat.grfid] =
gc;
277 buf =
PrintGrfInfo(buf,
lastof(buffer), lc->grfparam.grfid, NULL, gm != grf_names.
End() ? gm->second.gc : NULL);
278 if (gm == grf_names.
End()) buf +=
seprintf(buf,
lastof(buffer),
". Gamelog inconsistency: GrfID was never added!");
284 buf +=
seprintf(buf,
lastof(buffer),
"GRF order changed: %08X moved %d places %s",
285 BSWAP32(lc->grfmove.grfid),
abs(lc->grfmove.offset), lc->grfmove.offset >= 0 ?
"down" :
"up" );
286 buf =
PrintGrfInfo(buf,
lastof(buffer), lc->grfmove.grfid, NULL, gm != grf_names.
End() ? gm->second.gc : NULL);
287 if (gm == grf_names.
End()) buf +=
seprintf(buf,
lastof(buffer),
". Gamelog inconsistency: GrfID was never added!");
293 switch (lc->grfbug.bug) {
294 default: NOT_REACHED();
296 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);
299 buf =
PrintGrfInfo(buf,
lastof(buffer), lc->grfbug.grfid, NULL, gm != grf_names.
End() ? gm->second.gc : NULL);
300 if (gm == grf_names.
End()) buf +=
seprintf(buf,
lastof(buffer),
". Gamelog inconsistency: GrfID was never added!");
312 proc(
"---- gamelog end ----");
316 static void GamelogPrintConsoleProc(
const char *s)
329 static void GamelogPrintDebugProc(
const char *s)
356 if (_current_action == NULL) {
364 _current_action->
change = NULL;
397 for (
const LoggedAction *la = _gamelog_action; la != laend; la++) {
399 for (
const LoggedChange *lc = la->change; lc != lcend; lc++) {
404 return (emergency != NULL);
415 if (lc == NULL)
return;
417 memset(lc->revision.text, 0,
sizeof(lc->revision.text));
418 strecpy(lc->revision.text, _openttd_revision,
lastof(lc->revision.text));
420 lc->revision.modified = _openttd_revision_modified;
421 lc->revision.newgrf = _openttd_newgrf_version;
432 if (lc == NULL)
return;
434 lc->
mode.mode = _game_mode;
446 if (lc == NULL)
return;
463 if (lc == NULL)
return;
465 lc->setting.name =
stredup(name);
466 lc->setting.oldval = oldval;
467 lc->setting.newval = newval;
480 for (
const LoggedAction *la = _gamelog_action; la != laend; la++) {
482 for (
const LoggedChange *lc = la->change; lc != lcend; lc++) {
487 if (rev == NULL || strcmp(rev->revision.text, _openttd_revision) != 0 ||
488 rev->revision.modified != _openttd_revision_modified ||
489 rev->revision.newgrf != _openttd_newgrf_version) {
503 for (
const LoggedAction *la = _gamelog_action; la != laend; la++) {
505 for (
const LoggedChange *lc = la->change; lc != lcend; lc++) {
525 if (lc == NULL)
return;
527 lc->grfbug.data = data;
528 lc->grfbug.grfid = grfid;
529 lc->grfbug.bug = bug;
544 for (
const LoggedAction *la = _gamelog_action; la != laend; la++) {
546 for (
const LoggedChange *lc = la->change; lc != lcend; lc++) {
547 if (lc->ct ==
GLCT_GRFBUG && lc->grfbug.grfid == grfid &&
581 if (lc == NULL)
return;
583 lc->grfrem.grfid = grfid;
597 if (lc == NULL)
return;
612 if (lc == NULL)
return;
627 if (lc == NULL)
return;
629 lc->grfmove.grfid = grfid;
630 lc->grfmove.offset = offset;
643 if (lc == NULL)
return;
645 lc->grfparam.grfid = grfid;
657 for (; newg != NULL; newg = newg->
next) {
701 while (o < ol->n && n < nl->n) {
707 for (oi = 0; oi < ol->n; oi++) {
720 for (ni = 0; ni < nl->n; ni++) {
736 assert(ni > n && ni < nl->n);
737 assert(oi > o && oi < ol->n);
778 void GamelogInfo(
LoggedAction *gamelog_action, uint gamelog_actions, uint32 *last_ottd_rev, byte *ever_modified,
bool *removed_newgrfs)
780 const LoggedAction *laend = &gamelog_action[gamelog_actions];
781 for (
const LoggedAction *la = gamelog_action; la != laend; la++) {
783 for (
const LoggedChange *lc = la->change; lc != lcend; lc++) {
788 *last_ottd_rev = lc->revision.newgrf;
789 *ever_modified =
max(*ever_modified, lc->revision.modified);
793 *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.
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.
uint16 _sl_version
the major savegame version identifier
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.
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.
const uint16 SAVEGAME_VERSION
current savegame version
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)
#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.
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.