src/gamelog.cpp

   1 /*
   2  * This file is part of OpenTTD.
   3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /** @file gamelog.cpp Definition of functions used for logging of fundamental changes to the game */
   9
  10 #include "stdafx.h"
  11 #include "saveload/saveload.h"
  12 #include "string_func.h"
  13 #include "settings_type.h"
  14 #include "gamelog_internal.h"
  15 #include "console_func.h"
  16 #include "debug.h"
  17 #include "timer/timer_game_calendar.h"
  18 #include "timer/timer_game_tick.h"
  19 #include "rev.h"
  20
  21 #include "safeguards.h"
  22
  23 extern const SaveLoadVersion SAVEGAME_VERSION;  ///< current savegame version
  24
  25 extern SavegameType _savegame_type; ///< type of savegame we are loading
  26
  27 extern uint32_t _ttdp_version;        ///< version of TTDP savegame (if applicable)
  28 extern SaveLoadVersion _sl_version; ///< the major savegame version identifier
  29 extern byte   _sl_minor_version;    ///< the minor savegame version, DO NOT USE!
  30
  31 Gamelog _gamelog; ///< Gamelog instance
  32
  33 Gamelog::Gamelog()
  34 {
  35         this->data = std::make_unique<GamelogInternalData>();
  36         this->action_type = GLAT_NONE;
  37         this->current_action = nullptr;
  38 }
  39
  40 Gamelog::~Gamelog()
  41 {
  42 }
  43
  44 /**
  45  * Return the revision string for the current client version, for use in gamelog.
  46  */
  47 static std::string GetGamelogRevisionString()
  48 {
  49         if (IsReleasedVersion()) {
  50                 return _openttd_revision;
  51         }
  52
  53         /* Prefix character indication revision status */
  54         assert(_openttd_revision_modified < 3);
  55         return fmt::format("{}{}",
  56                         "gum"[_openttd_revision_modified], // g = "git", u = "unknown", m = "modified"
  57                         _openttd_revision_hash);
  58 }
  59
  60 /**
  61  * Stores information about new action, but doesn't allocate it
  62  * Action is allocated only when there is at least one change
  63  * @param at type of action
  64  */
  65 void Gamelog::StartAction(GamelogActionType at)
  66 {
  67         assert(this->action_type == GLAT_NONE); // do not allow starting new action without stopping the previous first
  68         this->action_type = at;
  69 }
  70
  71 /**
  72  * Stops logging of any changes
  73  */
  74 void Gamelog::StopAction()
  75 {
  76         assert(this->action_type != GLAT_NONE); // nobody should try to stop if there is no action in progress
  77
  78         bool print = this->current_action != nullptr;
  79
  80         this->current_action = nullptr;
  81         this->action_type = GLAT_NONE;
  82
  83         if (print) this->PrintDebug(5);
  84 }
  85
  86 void Gamelog::StopAnyAction()
  87 {
  88         if (this->action_type != GLAT_NONE) this->StopAction();
  89 }
  90
  91 /**
  92  * Resets and frees all memory allocated - used before loading or starting a new game
  93  */
  94 void Gamelog::Reset()
  95 {
  96         assert(this->action_type == GLAT_NONE);
  97         this->data->action.clear();
  98         this->current_action  = nullptr;
  99 }
 100
 101 /**
 102  * Adds the GRF ID, checksum and filename if found to the output iterator
 103  * @param output_iterator The iterator to add the GRF info to.
 104  * @param last The end of the buffer
 105  * @param grfid GRF ID
 106  * @param md5sum array of md5sum to print, if known
 107  * @param gc GrfConfig, if known
 108  */
 109 static void AddGrfInfo(std::back_insert_iterator<std::string> &output_iterator, uint32_t grfid, const MD5Hash *md5sum, const GRFConfig *gc)
 110 {
 111         if (md5sum != nullptr) {
 112                 fmt::format_to(output_iterator, "GRF ID {:08X}, checksum {}", BSWAP32(grfid), FormatArrayAsHex(*md5sum));
 113         } else {
 114                 fmt::format_to(output_iterator, "GRF ID {:08X}", BSWAP32(grfid));
 115         }
 116
 117         if (gc != nullptr) {
 118                 fmt::format_to(output_iterator, ", filename: {} (md5sum matches)", gc->filename);
 119         } else {
 120                 gc = FindGRFConfig(grfid, FGCM_ANY);
 121                 if (gc != nullptr) {
 122                         fmt::format_to(output_iterator, ", filename: {} (matches GRFID only)", gc->filename);
 123                 } else {
 124                         fmt::format_to(output_iterator, ", unknown GRF");
 125                 }
 126         }
 127 }
 128
 129
 130 /** Text messages for various logged actions */
 131 static const char * const la_text[] = {
 132         "new game started",
 133         "game loaded",
 134         "GRF config changed",
 135         "cheat was used",
 136         "settings changed",
 137         "GRF bug triggered",
 138         "emergency savegame",
 139 };
 140
 141 static_assert(lengthof(la_text) == GLAT_END);
 142
 143 /**
 144  * Prints active gamelog
 145  * @param proc the procedure to draw with
 146  */
 147 void Gamelog::Print(std::function<void(const std::string &)> proc)
 148 {
 149         GrfIDMapping grf_names;
 150
 151         proc("---- gamelog start ----");
 152
 153         for (const LoggedAction &la : this->data->action) {
 154                 assert(la.at < GLAT_END);
 155
 156                 proc(fmt::format("Tick {}: {}", la.tick, la_text[la.at]));
 157
 158                 for (auto &lc : la.change) {
 159                         std::string message;
 160                         auto output_iterator = std::back_inserter(message);
 161                         lc->FormatTo(output_iterator, grf_names, la.at);
 162
 163                         proc(message);
 164                 }
 165         }
 166
 167         proc("---- gamelog end ----");
 168 }
 169
 170
 171 /* virtual */ void LoggedChangeMode::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &, GamelogActionType)
 172 {
 173         /* Changing landscape, or going from scenario editor to game or back. */
 174         fmt::format_to(output_iterator, "New game mode: {} landscape: {}", this->mode, this->landscape);
 175 }
 176
 177 /* virtual */ void LoggedChangeRevision::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &, GamelogActionType)
 178 {
 179         /* The game was loaded in a diffferent version than before. */
 180         fmt::format_to(output_iterator, "Revision text changed to {}, savegame version {}, ",
 181                 this->text, this->slver);
 182
 183         switch (this->modified) {
 184                 case 0: fmt::format_to(output_iterator, "not "); break;
 185                 case 1: fmt::format_to(output_iterator, "maybe "); break;
 186                 default: break;
 187         }
 188
 189         fmt::format_to(output_iterator, "modified, _openttd_newgrf_version = 0x{:08x}", this->newgrf);
 190 }
 191
 192 /* virtual */ void LoggedChangeOldVersion::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &, GamelogActionType)
 193 {
 194         /* The game was loaded from before 0.7.0-beta1. */
 195         fmt::format_to(output_iterator, "Conversion from ");
 196         switch (this->type) {
 197                 default: NOT_REACHED();
 198                 case SGT_OTTD:
 199                         fmt::format_to(output_iterator, "OTTD savegame without gamelog: version {}, {}",
 200                                 GB(this->version, 8, 16), GB(this->version, 0, 8));
 201                         break;
 202
 203                 case SGT_TTO:
 204                         fmt::format_to(output_iterator, "TTO savegame");
 205                         break;
 206
 207                 case SGT_TTD:
 208                         fmt::format_to(output_iterator, "TTD savegame");
 209                         break;
 210
 211                 case SGT_TTDP1:
 212                 case SGT_TTDP2:
 213                         fmt::format_to(output_iterator, "TTDP savegame, {} format",
 214                                 this->type == SGT_TTDP1 ? "old" : "new");
 215                         if (this->version != 0) {
 216                                 fmt::format_to(output_iterator, ", TTDP version {}.{}.{}.{}",
 217                                         GB(this->version, 24, 8), GB(this->version, 20, 4),
 218                                         GB(this->version, 16, 4), GB(this->version, 0, 16));
 219                         }
 220                         break;
 221         }
 222 }
 223
 224 /* virtual */ void LoggedChangeSettingChanged::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &, GamelogActionType)
 225 {
 226         /* A setting with the SF_NO_NETWORK flag got changed; these settings usually affect NewGRFs, such as road side or wagon speed limits. */
 227         fmt::format_to(output_iterator, "Setting changed: {} : {} -> {}", this->name, this->oldval, this->newval);
 228 }
 229
 230 /* virtual */ void LoggedChangeGRFAdd::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &grf_names, GamelogActionType)
 231 {
 232         /* A NewGRF got added to the game, either at the start of the game (never an issue), or later on when it could be an issue. */
 233         const GRFConfig *gc = FindGRFConfig(this->grfid, FGCM_EXACT, &this->md5sum);
 234         fmt::format_to(output_iterator, "Added NewGRF: ");
 235         AddGrfInfo(output_iterator, this->grfid, &this->md5sum, gc);
 236         auto gm = grf_names.find(this->grfid);
 237         if (gm != grf_names.end() && !gm->second.was_missing) fmt::format_to(output_iterator, ". Gamelog inconsistency: GrfID was already added!");
 238         grf_names[this->grfid] = gc;
 239 }
 240
 241 /* virtual */ void LoggedChangeGRFRemoved::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &grf_names, GamelogActionType action_type)
 242 {
 243         /* A NewGRF got removed from the game, either manually or by it missing when loading the game. */
 244         auto gm = grf_names.find(this->grfid);
 245         if (action_type == GLAT_LOAD) {
 246                 fmt::format_to(output_iterator, "Missing NewGRF: ");
 247         } else {
 248                 fmt::format_to(output_iterator, "Removed NewGRF: ");
 249         }
 250         AddGrfInfo(output_iterator, this->grfid, nullptr, gm != grf_names.end() ? gm->second.gc : nullptr);
 251         if (gm == grf_names.end()) {
 252                 fmt::format_to(output_iterator, ". Gamelog inconsistency: GrfID was never added!");
 253         } else {
 254                 if (action_type == GLAT_LOAD) {
 255                         /* Missing grfs on load are not removed from the configuration */
 256                         gm->second.was_missing = true;
 257                 } else {
 258                         grf_names.erase(gm);
 259                 }
 260         }
 261 }
 262
 263 /* virtual */ void LoggedChangeGRFChanged::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &grf_names, GamelogActionType)
 264 {
 265         /* Another version of the same NewGRF got loaded. */
 266         const GRFConfig *gc = FindGRFConfig(this->grfid, FGCM_EXACT, &this->md5sum);
 267         fmt::format_to(output_iterator, "Compatible NewGRF loaded: ");
 268         AddGrfInfo(output_iterator, this->grfid, &this->md5sum, gc);
 269         if (grf_names.count(this->grfid) == 0) fmt::format_to(output_iterator, ". Gamelog inconsistency: GrfID was never added!");
 270         grf_names[this->grfid] = gc;
 271 }
 272
 273 /* virtual */ void LoggedChangeGRFParameterChanged::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &grf_names, GamelogActionType)
 274 {
 275         /* A parameter of a NewGRF got changed after the game was started. */
 276         auto gm = grf_names.find(this->grfid);
 277         fmt::format_to(output_iterator, "GRF parameter changed: ");
 278         AddGrfInfo(output_iterator, this->grfid, nullptr, gm != grf_names.end() ? gm->second.gc : nullptr);
 279         if (gm == grf_names.end()) fmt::format_to(output_iterator, ". Gamelog inconsistency: GrfID was never added!");
 280 }
 281
 282 /* virtual */ void LoggedChangeGRFMoved::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &grf_names, GamelogActionType)
 283 {
 284         /* The order of NewGRFs got changed, which might cause some other NewGRFs to behave differently. */
 285         auto gm = grf_names.find(this->grfid);
 286         fmt::format_to(output_iterator, "GRF order changed: {:08X} moved {} places {}",
 287                 BSWAP32(this->grfid), abs(this->offset), this->offset >= 0 ? "down" : "up" );
 288         AddGrfInfo(output_iterator, this->grfid, nullptr, gm != grf_names.end() ? gm->second.gc : nullptr);
 289         if (gm == grf_names.end()) fmt::format_to(output_iterator, ". Gamelog inconsistency: GrfID was never added!");
 290 }
 291
 292 /* virtual */ void LoggedChangeGRFBug::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &grf_names, GamelogActionType)
 293 {
 294         /* A specific bug in a NewGRF, that could cause wide spread problems, has been noted during the execution of the game. */
 295         auto gm = grf_names.find(this->grfid);
 296         assert(this->bug == GBUG_VEH_LENGTH);
 297
 298         fmt::format_to(output_iterator, "Rail vehicle changes length outside a depot: GRF ID {:08X}, internal ID 0x{:X}", BSWAP32(this->grfid), this->data);
 299         AddGrfInfo(output_iterator, this->grfid, nullptr, gm != grf_names.end() ? gm->second.gc : nullptr);
 300         if (gm == grf_names.end()) fmt::format_to(output_iterator, ". Gamelog inconsistency: GrfID was never added!");
 301 }
 302
 303 /* virtual */ void LoggedChangeEmergencySave::FormatTo(std::back_insert_iterator<std::string> &, GrfIDMapping &, GamelogActionType)
 304 {
 305         /* At one point the savegame was made during the handling of a game crash.
 306          * The generic code already mentioned the emergency savegame, and there is no extra information to log. */
 307 }
 308
 309 /** Print the gamelog data to the console. */
 310 void Gamelog::PrintConsole()
 311 {
 312         this->Print([](const std::string &s) {
 313                 IConsolePrint(CC_WARNING, s);
 314         });
 315 }
 316
 317 /**
 318  * Prints gamelog to debug output. Code is executed even when
 319  * there will be no output. It is called very seldom, so it
 320  * doesn't matter that much. At least it gives more uniform code...
 321  * @param level debug level we need to print stuff
 322  */
 323 void Gamelog::PrintDebug(int level)
 324 {
 325         this->Print([level](const std::string &s) {
 326                 Debug(gamelog, level, "{}", s);
 327         });
 328 }
 329
 330
 331 /**
 332  * Allocates a new LoggedAction if needed, and add the change when action is active.
 333  * @param change The actual change.
 334  */
 335 void Gamelog::Change(std::unique_ptr<LoggedChange> &&change)
 336 {
 337         if (this->current_action == nullptr) {
 338                 if (this->action_type == GLAT_NONE) return;
 339
 340                 this->current_action = &this->data->action.emplace_back();
 341                 this->current_action->at = this->action_type;
 342                 this->current_action->tick = TimerGameTick::counter;
 343         }
 344
 345         this->current_action->change.push_back(std::move(change));
 346 }
 347
 348
 349 /**
 350  * Logs a emergency savegame
 351  */
 352 void Gamelog::Emergency()
 353 {
 354         /* Terminate any active action */
 355         if (this->action_type != GLAT_NONE) this->StopAction();
 356         this->StartAction(GLAT_EMERGENCY);
 357         this->Change(std::make_unique<LoggedChangeEmergencySave>());
 358         this->StopAction();
 359 }
 360
 361 /**
 362  * Finds out if current game is a loaded emergency savegame.
 363  */
 364 bool Gamelog::TestEmergency()
 365 {
 366         for (const LoggedAction &la : this->data->action) {
 367                 for (const auto &lc : la.change) {
 368                         if (lc->ct == GLCT_EMERGENCY) return true;
 369                 }
 370         }
 371
 372         return false;
 373 }
 374
 375 /**
 376  * Logs a change in game revision
 377  */
 378 void Gamelog::Revision()
 379 {
 380         assert(this->action_type == GLAT_START || this->action_type == GLAT_LOAD);
 381
 382         this->Change(std::make_unique<LoggedChangeRevision>(
 383                 GetGamelogRevisionString(), _openttd_newgrf_version, SAVEGAME_VERSION, _openttd_revision_modified));
 384 }
 385
 386 /**
 387  * Logs a change in game mode (scenario editor or game)
 388  */
 389 void Gamelog::Mode()
 390 {
 391         assert(this->action_type == GLAT_START || this->action_type == GLAT_LOAD || this->action_type == GLAT_CHEAT);
 392
 393         this->Change(std::make_unique<LoggedChangeMode>(_game_mode, _settings_game.game_creation.landscape));
 394 }
 395
 396 /**
 397  * Logs loading from savegame without gamelog
 398  */
 399 void Gamelog::Oldver()
 400 {
 401         assert(this->action_type == GLAT_LOAD);
 402
 403         this->Change(std::make_unique<LoggedChangeOldVersion>(_savegame_type,
 404                 (_savegame_type == SGT_OTTD ? ((uint32_t)_sl_version << 8 | _sl_minor_version) : _ttdp_version)));
 405 }
 406
 407 /**
 408  * Logs change in game settings. Only non-networksafe settings are logged
 409  * @param name setting name
 410  * @param oldval old setting value
 411  * @param newval new setting value
 412  */
 413 void Gamelog::Setting(const std::string &name, int32_t oldval, int32_t newval)
 414 {
 415         assert(this->action_type == GLAT_SETTING);
 416
 417         this->Change(std::make_unique<LoggedChangeSettingChanged>(name, oldval, newval));
 418 }
 419
 420
 421 /**
 422  * Finds out if current revision is different than last revision stored in the savegame.
 423  * Appends GLCT_REVISION when the revision string changed
 424  */
 425 void Gamelog::TestRevision()
 426 {
 427         const LoggedChangeRevision *rev = nullptr;
 428
 429         for (const LoggedAction &la : this->data->action) {
 430                 for (const auto &lc : la.change) {
 431                         if (lc->ct == GLCT_REVISION) rev = static_cast<const LoggedChangeRevision *>(lc.get());
 432                 }
 433         }
 434
 435         if (rev == nullptr || rev->text != GetGamelogRevisionString() ||
 436                         rev->modified != _openttd_revision_modified ||
 437                         rev->newgrf != _openttd_newgrf_version) {
 438                 this->Revision();
 439         }
 440 }
 441
 442 /**
 443  * Finds last stored game mode or landscape.
 444  * Any change is logged
 445  */
 446 void Gamelog::TestMode()
 447 {
 448         const LoggedChangeMode *mode = nullptr;
 449
 450         for (const LoggedAction &la : this->data->action) {
 451                 for (const auto &lc : la.change) {
 452                         if (lc->ct == GLCT_MODE) mode = static_cast<const LoggedChangeMode *>(lc.get());
 453                 }
 454         }
 455
 456         if (mode == nullptr || mode->mode != _game_mode || mode->landscape != _settings_game.game_creation.landscape) this->Mode();
 457 }
 458
 459
 460 /**
 461  * Logs triggered GRF bug.
 462  * @param grfid ID of problematic GRF
 463  * @param bug type of bug, @see enum GRFBugs
 464  * @param data additional data
 465  */
 466 void Gamelog::GRFBug(uint32_t grfid, byte bug, uint64_t data)
 467 {
 468         assert(this->action_type == GLAT_GRFBUG);
 469
 470         this->Change(std::make_unique<LoggedChangeGRFBug>(data, grfid, bug));
 471 }
 472
 473 /**
 474  * Logs GRF bug - rail vehicle has different length after reversing.
 475  * Ensures this is logged only once for each GRF and engine type
 476  * This check takes some time, but it is called pretty seldom, so it
 477  * doesn't matter that much (ideally it shouldn't be called at all).
 478  * @param grfid the broken NewGRF
 479  * @param internal_id the internal ID of whatever's broken in the NewGRF
 480  * @return true iff a unique record was done
 481  */
 482 bool Gamelog::GRFBugReverse(uint32_t grfid, uint16_t internal_id)
 483 {
 484         for (const LoggedAction &la : this->data->action) {
 485                 for (const auto &lc : la.change) {
 486                         if (lc->ct == GLCT_GRFBUG) {
 487                                 LoggedChangeGRFBug *bug = static_cast<LoggedChangeGRFBug *>(lc.get());
 488                                 if (bug->grfid == grfid && bug->bug == GBUG_VEH_LENGTH && bug->data == internal_id) {
 489                                         return false;
 490                                 }
 491                         }
 492                 }
 493         }
 494
 495         this->StartAction(GLAT_GRFBUG);
 496         this->GRFBug(grfid, GBUG_VEH_LENGTH, internal_id);
 497         this->StopAction();
 498
 499         return true;
 500 }
 501
 502
 503 /**
 504  * Decides if GRF should be logged
 505  * @param g grf to determine
 506  * @return true iff GRF is not static and is loaded
 507  */
 508 static inline bool IsLoggableGrfConfig(const GRFConfig *g)
 509 {
 510         return !HasBit(g->flags, GCF_STATIC) && g->status != GCS_NOT_FOUND;
 511 }
 512
 513 /**
 514  * Logs removal of a GRF
 515  * @param grfid ID of removed GRF
 516  */
 517 void Gamelog::GRFRemove(uint32_t grfid)
 518 {
 519         assert(this->action_type == GLAT_LOAD || this->action_type == GLAT_GRF);
 520
 521         this->Change(std::make_unique<LoggedChangeGRFRemoved>(grfid));
 522 }
 523
 524 /**
 525  * Logs adding of a GRF
 526  * @param newg added GRF
 527  */
 528 void Gamelog::GRFAdd(const GRFConfig *newg)
 529 {
 530         assert(this->action_type == GLAT_LOAD || this->action_type == GLAT_START || this->action_type == GLAT_GRF);
 531
 532         if (!IsLoggableGrfConfig(newg)) return;
 533
 534         this->Change(std::make_unique<LoggedChangeGRFAdd>(newg->ident));
 535 }
 536
 537 /**
 538  * Logs loading compatible GRF
 539  * (the same ID, but different MD5 hash)
 540  * @param newg new (updated) GRF
 541  */
 542 void Gamelog::GRFCompatible(const GRFIdentifier *newg)
 543 {
 544         assert(this->action_type == GLAT_LOAD || this->action_type == GLAT_GRF);
 545
 546         this->Change(std::make_unique<LoggedChangeGRFChanged>(*newg));
 547 }
 548
 549 /**
 550  * Logs changing GRF order
 551  * @param grfid GRF that is moved
 552  * @param offset how far it is moved, positive = moved down
 553  */
 554 void Gamelog::GRFMove(uint32_t grfid, int32_t offset)
 555 {
 556         assert(this->action_type == GLAT_GRF);
 557
 558         this->Change(std::make_unique<LoggedChangeGRFMoved>(grfid, offset));
 559 }
 560
 561 /**
 562  * Logs change in GRF parameters.
 563  * Details about parameters changed are not stored
 564  * @param grfid ID of GRF to store
 565  */
 566 void Gamelog::GRFParameters(uint32_t grfid)
 567 {
 568         assert(this->action_type == GLAT_GRF);
 569
 570         this->Change(std::make_unique<LoggedChangeGRFParameterChanged>(grfid));
 571 }
 572
 573 /**
 574  * Logs adding of list of GRFs.
 575  * Useful when old savegame is loaded or when new game is started
 576  * @param newg head of GRF linked list
 577  */
 578 void Gamelog::GRFAddList(const GRFConfig *newg)
 579 {
 580         assert(this->action_type == GLAT_START || this->action_type == GLAT_LOAD);
 581
 582         for (; newg != nullptr; newg = newg->next) {
 583                 this->GRFAdd(newg);
 584         }
 585 }
 586
 587 /**
 588  * Generates GRFList
 589  * @param grfc head of GRF linked list
 590  */
 591 static std::vector<const GRFConfig *> GenerateGRFList(const GRFConfig *grfc)
 592 {
 593         std::vector<const GRFConfig *> list;
 594         for (const GRFConfig *g = grfc; g != nullptr; g = g->next) {
 595                 if (IsLoggableGrfConfig(g)) list.push_back(g);
 596         }
 597
 598         return list;
 599 }
 600
 601 /**
 602  * Compares two NewGRF lists and logs any change
 603  * @param oldc original GRF list
 604  * @param newc new GRF list
 605  */
 606 void Gamelog::GRFUpdate(const GRFConfig *oldc, const GRFConfig *newc)
 607 {
 608         std::vector<const GRFConfig *> ol = GenerateGRFList(oldc);
 609         std::vector<const GRFConfig *> nl = GenerateGRFList(newc);
 610
 611         uint o = 0, n = 0;
 612
 613         while (o < ol.size() && n < nl.size()) {
 614                 const GRFConfig *og = ol[o];
 615                 const GRFConfig *ng = nl[n];
 616
 617                 if (og->ident.grfid != ng->ident.grfid) {
 618                         uint oi, ni;
 619                         for (oi = 0; oi < ol.size(); oi++) {
 620                                 if (ol[oi]->ident.grfid == nl[n]->ident.grfid) break;
 621                         }
 622                         if (oi < o) {
 623                                 /* GRF was moved, this change has been logged already */
 624                                 n++;
 625                                 continue;
 626                         }
 627                         if (oi == ol.size()) {
 628                                 /* GRF couldn't be found in the OLD list, GRF was ADDED */
 629                                 this->GRFAdd(nl[n++]);
 630                                 continue;
 631                         }
 632                         for (ni = 0; ni < nl.size(); ni++) {
 633                                 if (nl[ni]->ident.grfid == ol[o]->ident.grfid) break;
 634                         }
 635                         if (ni < n) {
 636                                 /* GRF was moved, this change has been logged already */
 637                                 o++;
 638                                 continue;
 639                         }
 640                         if (ni == nl.size()) {
 641                                 /* GRF couldn't be found in the NEW list, GRF was REMOVED */
 642                                 this->GRFRemove(ol[o++]->ident.grfid);
 643                                 continue;
 644                         }
 645
 646                         /* o < oi < ol->n
 647                          * n < ni < nl->n */
 648                         assert(ni > n && ni < nl.size());
 649                         assert(oi > o && oi < ol.size());
 650
 651                         ni -= n; // number of GRFs it was moved downwards
 652                         oi -= o; // number of GRFs it was moved upwards
 653
 654                         if (ni >= oi) { // prefer the one that is moved further
 655                                 /* GRF was moved down */
 656                                 this->GRFMove(ol[o++]->ident.grfid, ni);
 657                         } else {
 658                                 this->GRFMove(nl[n++]->ident.grfid, -(int)oi);
 659                         }
 660                 } else {
 661                         if (og->ident.md5sum != ng->ident.md5sum) {
 662                                 /* md5sum changed, probably loading 'compatible' GRF */
 663                                 this->GRFCompatible(&nl[n]->ident);
 664                         }
 665
 666                         if (og->num_params != ng->num_params || og->param == ng->param) {
 667                                 this->GRFParameters(ol[o]->ident.grfid);
 668                         }
 669
 670                         o++;
 671                         n++;
 672                 }
 673         }
 674
 675         while (o < ol.size()) this->GRFRemove(ol[o++]->ident.grfid); // remaining GRFs were removed ...
 676         while (n < nl.size()) this->GRFAdd   (nl[n++]);              // ... or added
 677 }
 678
 679 /**
 680  * Get some basic information from the given gamelog.
 681  * @param[out] last_ottd_rev OpenTTD NewGRF version from the binary that saved the savegame last.
 682  * @param[out] ever_modified Max value of 'modified' from all binaries that ever saved this savegame.
 683  * @param[out] removed_newgrfs Set to true if any NewGRFs have been removed.
 684  */
 685 void Gamelog::Info(uint32_t *last_ottd_rev, byte *ever_modified, bool *removed_newgrfs)
 686 {
 687         for (const LoggedAction &la : this->data->action) {
 688                 for (const auto &lc : la.change) {
 689                         switch (lc->ct) {
 690                                 default: break;
 691
 692                                 case GLCT_REVISION: {
 693                                         const LoggedChangeRevision *rev = static_cast<const LoggedChangeRevision *>(lc.get());
 694                                         *last_ottd_rev = rev->newgrf;
 695                                         *ever_modified = std::max(*ever_modified, rev->modified);
 696                                         break;
 697                                 }
 698
 699                                 case GLCT_GRFREM:
 700                                         *removed_newgrfs = true;
 701                                         break;
 702                         }
 703                 }
 704         }
 705 }
 706
 707 /**
 708  * Try to find the overridden GRF identifier of the given GRF.
 709  * @param c the GRF to get the 'previous' version of.
 710  * @return the GRF identifier or \a c if none could be found.
 711  */
 712 const GRFIdentifier *Gamelog::GetOverriddenIdentifier(const GRFConfig *c)
 713 {
 714         assert(c != nullptr);
 715         const LoggedAction &la = this->data->action.back();
 716         if (la.at != GLAT_LOAD) return &c->ident;
 717
 718         for (const auto &lc : la.change) {
 719                 if (lc->ct != GLCT_GRFCOMPAT) continue;
 720
 721                 const LoggedChangeGRFChanged *grf = static_cast<const LoggedChangeGRFChanged *>(lc.get());
 722                 if (grf->grfid == c->ident.grfid) return grf;
 723         }
 724
 725         return &c->ident;
 726 }