gamelog.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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/>.
 */
 
#include "stdafx.h"
#include "saveload/saveload.h"
#include "string_func.h"
#include "settings_type.h"
#include "gamelog_internal.h"
#include "console_func.h"
#include "debug.h"
#include "timer/timer_game_calendar.h"
#include "timer/timer_game_tick.h"
#include "rev.h"
 
#include "safeguards.h"
 
extern const SaveLoadVersion SAVEGAME_VERSION;  
 
extern SavegameType _savegame_type; 
 
extern uint32_t _ttdp_version;        
extern SaveLoadVersion _sl_version; 
extern byte   _sl_minor_version;    
 
Gamelog _gamelog; 
 
Gamelog::Gamelog()
{
  this->data = std::make_unique<GamelogInternalData>();
  this->action_type = GLAT_NONE;
  this->current_action = nullptr;
}
 
Gamelog::~Gamelog()
{
}
 
static std::string GetGamelogRevisionString()
{
  if (IsReleasedVersion()) {
    return _openttd_revision;
  }
 
  /* Prefix character indication revision status */
  assert(_openttd_revision_modified < 3);
  return fmt::format("{}{}",
      "gum"[_openttd_revision_modified], // g = "git", u = "unknown", m = "modified"
      _openttd_revision_hash);
}
 
void Gamelog::StartAction(GamelogActionType at)
{
  assert(this->action_type == GLAT_NONE); // do not allow starting new action without stopping the previous first
  this->action_type = at;
}
 
void Gamelog::StopAction()
{
  assert(this->action_type != GLAT_NONE); // nobody should try to stop if there is no action in progress
 
  bool print = this->current_action != nullptr;
 
  this->current_action = nullptr;
  this->action_type = GLAT_NONE;
 
  if (print) this->PrintDebug(5);
}
 
void Gamelog::StopAnyAction()
{
  if (this->action_type != GLAT_NONE) this->StopAction();
}
 
void Gamelog::Reset()
{
  assert(this->action_type == GLAT_NONE);
  this->data->action.clear();
  this->current_action  = nullptr;
}
 
static void AddGrfInfo(std::back_insert_iterator<std::string> &output_iterator, uint32_t grfid, const MD5Hash *md5sum, const GRFConfig *gc)
{
  if (md5sum != nullptr) {
    fmt::format_to(output_iterator, "GRF ID {:08X}, checksum {}", BSWAP32(grfid), FormatArrayAsHex(*md5sum));
  } else {
    fmt::format_to(output_iterator, "GRF ID {:08X}", BSWAP32(grfid));
  }
 
  if (gc != nullptr) {
    fmt::format_to(output_iterator, ", filename: {} (md5sum matches)", gc->filename);
  } else {
    gc = FindGRFConfig(grfid, FGCM_ANY);
    if (gc != nullptr) {
      fmt::format_to(output_iterator, ", filename: {} (matches GRFID only)", gc->filename);
    } else {
      fmt::format_to(output_iterator, ", unknown GRF");
    }
  }
}
 
 
static const char * const la_text[] = {
  "new game started",
  "game loaded",
  "GRF config changed",
  "cheat was used",
  "settings changed",
  "GRF bug triggered",
  "emergency savegame",
};
 
static_assert(lengthof(la_text) == GLAT_END);
 
void Gamelog::Print(std::function<void(const std::string &)> proc)
{
  GrfIDMapping grf_names;
 
  proc("---- gamelog start ----");
 
  for (const LoggedAction &la : this->data->action) {
    assert(la.at < GLAT_END);
 
    proc(fmt::format("Tick {}: {}", la.tick, la_text[la.at]));
 
    for (auto &lc : la.change) {
      std::string message;
      auto output_iterator = std::back_inserter(message);
      lc->FormatTo(output_iterator, grf_names, la.at);
 
      proc(message);
    }
  }
 
  proc("---- gamelog end ----");
}
 
 
/* virtual */ void LoggedChangeMode::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &, GamelogActionType)
{
  /* Changing landscape, or going from scenario editor to game or back. */
  fmt::format_to(output_iterator, "New game mode: {} landscape: {}", this->mode, this->landscape);
}
 
/* virtual */ void LoggedChangeRevision::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &, GamelogActionType)
{
  /* The game was loaded in a diffferent version than before. */
  fmt::format_to(output_iterator, "Revision text changed to {}, savegame version {}, ",
    this->text, this->slver);
 
  switch (this->modified) {
    case 0: fmt::format_to(output_iterator, "not "); break;
    case 1: fmt::format_to(output_iterator, "maybe "); break;
    default: break;
  }
 
  fmt::format_to(output_iterator, "modified, _openttd_newgrf_version = 0x{:08x}", this->newgrf);
}
 
/* virtual */ void LoggedChangeOldVersion::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &, GamelogActionType)
{
  /* The game was loaded from before 0.7.0-beta1. */
  fmt::format_to(output_iterator, "Conversion from ");
  switch (this->type) {
    default: NOT_REACHED();
    case SGT_OTTD:
      fmt::format_to(output_iterator, "OTTD savegame without gamelog: version {}, {}",
        GB(this->version, 8, 16), GB(this->version, 0, 8));
      break;
 
    case SGT_TTO:
      fmt::format_to(output_iterator, "TTO savegame");
      break;
 
    case SGT_TTD:
      fmt::format_to(output_iterator, "TTD savegame");
      break;
 
    case SGT_TTDP1:
    case SGT_TTDP2:
      fmt::format_to(output_iterator, "TTDP savegame, {} format",
        this->type == SGT_TTDP1 ? "old" : "new");
      if (this->version != 0) {
        fmt::format_to(output_iterator, ", TTDP version {}.{}.{}.{}",
          GB(this->version, 24, 8), GB(this->version, 20, 4),
          GB(this->version, 16, 4), GB(this->version, 0, 16));
      }
      break;
  }
}
 
/* virtual */ void LoggedChangeSettingChanged::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &, GamelogActionType)
{
  /* A setting with the SF_NO_NETWORK flag got changed; these settings usually affect NewGRFs, such as road side or wagon speed limits. */
  fmt::format_to(output_iterator, "Setting changed: {} : {} -> {}", this->name, this->oldval, this->newval);
}
 
/* virtual */ void LoggedChangeGRFAdd::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &grf_names, GamelogActionType)
{
  /* 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. */
  const GRFConfig *gc = FindGRFConfig(this->grfid, FGCM_EXACT, &this->md5sum);
  fmt::format_to(output_iterator, "Added NewGRF: ");
  AddGrfInfo(output_iterator, this->grfid, &this->md5sum, gc);
  auto gm = grf_names.find(this->grfid);
  if (gm != grf_names.end() && !gm->second.was_missing) fmt::format_to(output_iterator, ". Gamelog inconsistency: GrfID was already added!");
  grf_names[this->grfid] = gc;
}
 
/* virtual */ void LoggedChangeGRFRemoved::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &grf_names, GamelogActionType action_type)
{
  /* A NewGRF got removed from the game, either manually or by it missing when loading the game. */
  auto gm = grf_names.find(this->grfid);
  if (action_type == GLAT_LOAD) {
    fmt::format_to(output_iterator, "Missing NewGRF: ");
  } else {
    fmt::format_to(output_iterator, "Removed NewGRF: ");
  }
  AddGrfInfo(output_iterator, this->grfid, nullptr, gm != grf_names.end() ? gm->second.gc : nullptr);
  if (gm == grf_names.end()) {
    fmt::format_to(output_iterator, ". Gamelog inconsistency: GrfID was never added!");
  } else {
    if (action_type == GLAT_LOAD) {
      /* Missing grfs on load are not removed from the configuration */
      gm->second.was_missing = true;
    } else {
      grf_names.erase(gm);
    }
  }
}
 
/* virtual */ void LoggedChangeGRFChanged::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &grf_names, GamelogActionType)
{
  /* Another version of the same NewGRF got loaded. */
  const GRFConfig *gc = FindGRFConfig(this->grfid, FGCM_EXACT, &this->md5sum);
  fmt::format_to(output_iterator, "Compatible NewGRF loaded: ");
  AddGrfInfo(output_iterator, this->grfid, &this->md5sum, gc);
  if (grf_names.count(this->grfid) == 0) fmt::format_to(output_iterator, ". Gamelog inconsistency: GrfID was never added!");
  grf_names[this->grfid] = gc;
}
 
/* virtual */ void LoggedChangeGRFParameterChanged::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &grf_names, GamelogActionType)
{
  /* A parameter of a NewGRF got changed after the game was started. */
  auto gm = grf_names.find(this->grfid);
  fmt::format_to(output_iterator, "GRF parameter changed: ");
  AddGrfInfo(output_iterator, this->grfid, nullptr, gm != grf_names.end() ? gm->second.gc : nullptr);
  if (gm == grf_names.end()) fmt::format_to(output_iterator, ". Gamelog inconsistency: GrfID was never added!");
}
 
/* virtual */ void LoggedChangeGRFMoved::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &grf_names, GamelogActionType)
{
  /* The order of NewGRFs got changed, which might cause some other NewGRFs to behave differently. */
  auto gm = grf_names.find(this->grfid);
  fmt::format_to(output_iterator, "GRF order changed: {:08X} moved {} places {}",
    BSWAP32(this->grfid), abs(this->offset), this->offset >= 0 ? "down" : "up" );
  AddGrfInfo(output_iterator, this->grfid, nullptr, gm != grf_names.end() ? gm->second.gc : nullptr);
  if (gm == grf_names.end()) fmt::format_to(output_iterator, ". Gamelog inconsistency: GrfID was never added!");
}
 
/* virtual */ void LoggedChangeGRFBug::FormatTo(std::back_insert_iterator<std::string> &output_iterator, GrfIDMapping &grf_names, GamelogActionType)
{
  /* A specific bug in a NewGRF, that could cause wide spread problems, has been noted during the execution of the game. */
  auto gm = grf_names.find(this->grfid);
  assert(this->bug == GBUG_VEH_LENGTH);
 
  fmt::format_to(output_iterator, "Rail vehicle changes length outside a depot: GRF ID {:08X}, internal ID 0x{:X}", BSWAP32(this->grfid), this->data);
  AddGrfInfo(output_iterator, this->grfid, nullptr, gm != grf_names.end() ? gm->second.gc : nullptr);
  if (gm == grf_names.end()) fmt::format_to(output_iterator, ". Gamelog inconsistency: GrfID was never added!");
}
 
/* virtual */ void LoggedChangeEmergencySave::FormatTo(std::back_insert_iterator<std::string> &, GrfIDMapping &, GamelogActionType)
{
  /* At one point the savegame was made during the handling of a game crash.
   * The generic code already mentioned the emergency savegame, and there is no extra information to log. */
}
 
void Gamelog::PrintConsole()
{
  this->Print([](const std::string &s) {
    IConsolePrint(CC_WARNING, s);
  });
}
 
void Gamelog::PrintDebug(int level)
{
  this->Print([level](const std::string &s) {
    Debug(gamelog, level, "{}", s);
  });
}
 
 
void Gamelog::Change(std::unique_ptr<LoggedChange> &&change)
{
  if (this->current_action == nullptr) {
    if (this->action_type == GLAT_NONE) return;
 
    this->current_action = &this->data->action.emplace_back();
    this->current_action->at = this->action_type;
    this->current_action->tick = TimerGameTick::counter;
  }
 
  this->current_action->change.push_back(std::move(change));
}
 
 
void Gamelog::Emergency()
{
  /* Terminate any active action */
  if (this->action_type != GLAT_NONE) this->StopAction();
  this->StartAction(GLAT_EMERGENCY);
  this->Change(std::make_unique<LoggedChangeEmergencySave>());
  this->StopAction();
}
 
bool Gamelog::TestEmergency()
{
  for (const LoggedAction &la : this->data->action) {
    for (const auto &lc : la.change) {
      if (lc->ct == GLCT_EMERGENCY) return true;
    }
  }
 
  return false;
}
 
void Gamelog::Revision()
{
  assert(this->action_type == GLAT_START || this->action_type == GLAT_LOAD);
 
  this->Change(std::make_unique<LoggedChangeRevision>(
    GetGamelogRevisionString(), _openttd_newgrf_version, SAVEGAME_VERSION, _openttd_revision_modified));
}
 
void Gamelog::Mode()
{
  assert(this->action_type == GLAT_START || this->action_type == GLAT_LOAD || this->action_type == GLAT_CHEAT);
 
  this->Change(std::make_unique<LoggedChangeMode>(_game_mode, _settings_game.game_creation.landscape));
}
 
void Gamelog::Oldver()
{
  assert(this->action_type == GLAT_LOAD);
 
  this->Change(std::make_unique<LoggedChangeOldVersion>(_savegame_type,
    (_savegame_type == SGT_OTTD ? ((uint32_t)_sl_version << 8 | _sl_minor_version) : _ttdp_version)));
}
 
void Gamelog::Setting(const std::string &name, int32_t oldval, int32_t newval)
{
  assert(this->action_type == GLAT_SETTING);
 
  this->Change(std::make_unique<LoggedChangeSettingChanged>(name, oldval, newval));
}
 
 
void Gamelog::TestRevision()
{
  const LoggedChangeRevision *rev = nullptr;
 
  for (const LoggedAction &la : this->data->action) {
    for (const auto &lc : la.change) {
      if (lc->ct == GLCT_REVISION) rev = static_cast<const LoggedChangeRevision *>(lc.get());
    }
  }
 
  if (rev == nullptr || rev->text != GetGamelogRevisionString() ||
      rev->modified != _openttd_revision_modified ||
      rev->newgrf != _openttd_newgrf_version) {
    this->Revision();
  }
}
 
void Gamelog::TestMode()
{
  const LoggedChangeMode *mode = nullptr;
 
  for (const LoggedAction &la : this->data->action) {
    for (const auto &lc : la.change) {
      if (lc->ct == GLCT_MODE) mode = static_cast<const LoggedChangeMode *>(lc.get());
    }
  }
 
  if (mode == nullptr || mode->mode != _game_mode || mode->landscape != _settings_game.game_creation.landscape) this->Mode();
}
 
 
void Gamelog::GRFBug(uint32_t grfid, byte bug, uint64_t data)
{
  assert(this->action_type == GLAT_GRFBUG);
 
  this->Change(std::make_unique<LoggedChangeGRFBug>(data, grfid, bug));
}
 
bool Gamelog::GRFBugReverse(uint32_t grfid, uint16_t internal_id)
{
  for (const LoggedAction &la : this->data->action) {
    for (const auto &lc : la.change) {
      if (lc->ct == GLCT_GRFBUG) {
        LoggedChangeGRFBug *bug = static_cast<LoggedChangeGRFBug *>(lc.get());
        if (bug->grfid == grfid && bug->bug == GBUG_VEH_LENGTH && bug->data == internal_id) {
          return false;
        }
      }
    }
  }
 
  this->StartAction(GLAT_GRFBUG);
  this->GRFBug(grfid, GBUG_VEH_LENGTH, internal_id);
  this->StopAction();
 
  return true;
}
 
 
static inline bool IsLoggableGrfConfig(const GRFConfig *g)
{
  return !HasBit(g->flags, GCF_STATIC) && g->status != GCS_NOT_FOUND;
}
 
void Gamelog::GRFRemove(uint32_t grfid)
{
  assert(this->action_type == GLAT_LOAD || this->action_type == GLAT_GRF);
 
  this->Change(std::make_unique<LoggedChangeGRFRemoved>(grfid));
}
 
void Gamelog::GRFAdd(const GRFConfig *newg)
{
  assert(this->action_type == GLAT_LOAD || this->action_type == GLAT_START || this->action_type == GLAT_GRF);
 
  if (!IsLoggableGrfConfig(newg)) return;
 
  this->Change(std::make_unique<LoggedChangeGRFAdd>(newg->ident));
}
 
void Gamelog::GRFCompatible(const GRFIdentifier *newg)
{
  assert(this->action_type == GLAT_LOAD || this->action_type == GLAT_GRF);
 
  this->Change(std::make_unique<LoggedChangeGRFChanged>(*newg));
}
 
void Gamelog::GRFMove(uint32_t grfid, int32_t offset)
{
  assert(this->action_type == GLAT_GRF);
 
  this->Change(std::make_unique<LoggedChangeGRFMoved>(grfid, offset));
}
 
void Gamelog::GRFParameters(uint32_t grfid)
{
  assert(this->action_type == GLAT_GRF);
 
  this->Change(std::make_unique<LoggedChangeGRFParameterChanged>(grfid));
}
 
void Gamelog::GRFAddList(const GRFConfig *newg)
{
  assert(this->action_type == GLAT_START || this->action_type == GLAT_LOAD);
 
  for (; newg != nullptr; newg = newg->next) {
    this->GRFAdd(newg);
  }
}
 
static std::vector<const GRFConfig *> GenerateGRFList(const GRFConfig *grfc)
{
  std::vector<const GRFConfig *> list;
  for (const GRFConfig *g = grfc; g != nullptr; g = g->next) {
    if (IsLoggableGrfConfig(g)) list.push_back(g);
  }
 
  return list;
}
 
void Gamelog::GRFUpdate(const GRFConfig *oldc, const GRFConfig *newc)
{
  std::vector<const GRFConfig *> ol = GenerateGRFList(oldc);
  std::vector<const GRFConfig *> nl = GenerateGRFList(newc);
 
  uint o = 0, n = 0;
 
  while (o < ol.size() && n < nl.size()) {
    const GRFConfig *og = ol[o];
    const GRFConfig *ng = nl[n];
 
    if (og->ident.grfid != ng->ident.grfid) {
      uint oi, ni;
      for (oi = 0; oi < ol.size(); oi++) {
        if (ol[oi]->ident.grfid == nl[n]->ident.grfid) break;
      }
      if (oi < o) {
        /* GRF was moved, this change has been logged already */
        n++;
        continue;
      }
      if (oi == ol.size()) {
        /* GRF couldn't be found in the OLD list, GRF was ADDED */
        this->GRFAdd(nl[n++]);
        continue;
      }
      for (ni = 0; ni < nl.size(); ni++) {
        if (nl[ni]->ident.grfid == ol[o]->ident.grfid) break;
      }
      if (ni < n) {
        /* GRF was moved, this change has been logged already */
        o++;
        continue;
      }
      if (ni == nl.size()) {
        /* GRF couldn't be found in the NEW list, GRF was REMOVED */
        this->GRFRemove(ol[o++]->ident.grfid);
        continue;
      }
 
      /* o < oi < ol->n
       * n < ni < nl->n */
      assert(ni > n && ni < nl.size());
      assert(oi > o && oi < ol.size());
 
      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 */
        this->GRFMove(ol[o++]->ident.grfid, ni);
      } else {
        this->GRFMove(nl[n++]->ident.grfid, -(int)oi);
      }
    } else {
      if (og->ident.md5sum != ng->ident.md5sum) {
        /* md5sum changed, probably loading 'compatible' GRF */
        this->GRFCompatible(&nl[n]->ident);
      }
 
      if (og->num_params != ng->num_params || og->param == ng->param) {
        this->GRFParameters(ol[o]->ident.grfid);
      }
 
      o++;
      n++;
    }
  }
 
  while (o < ol.size()) this->GRFRemove(ol[o++]->ident.grfid); // remaining GRFs were removed ...
  while (n < nl.size()) this->GRFAdd   (nl[n++]);              // ... or added
}
 
void Gamelog::Info(uint32_t *last_ottd_rev, byte *ever_modified, bool *removed_newgrfs)
{
  for (const LoggedAction &la : this->data->action) {
    for (const auto &lc : la.change) {
      switch (lc->ct) {
        default: break;
 
        case GLCT_REVISION: {
          const LoggedChangeRevision *rev = static_cast<const LoggedChangeRevision *>(lc.get());
          *last_ottd_rev = rev->newgrf;
          *ever_modified = std::max(*ever_modified, rev->modified);
          break;
        }
 
        case GLCT_GRFREM:
          *removed_newgrfs = true;
          break;
      }
    }
  }
}
 
const GRFIdentifier *Gamelog::GetOverriddenIdentifier(const GRFConfig *c)
{
  assert(c != nullptr);
  const LoggedAction &la = this->data->action.back();
  if (la.at != GLAT_LOAD) return &c->ident;
 
  for (const auto &lc : la.change) {
    if (lc->ct != GLCT_GRFCOMPAT) continue;
 
    const LoggedChangeGRFChanged *grf = static_cast<const LoggedChangeGRFChanged *>(lc.get());
    if (grf->grfid == c->ident.grfid) return grf;
  }
 
  return &c->ident;
}