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 "date_func.h"
#include "rev.h"

#include <stdarg.h>

#include "safeguards.h"

extern const SaveLoadVersion SAVEGAME_VERSION;  

extern SavegameType _savegame_type; 

extern uint32 _ttdp_version;        
extern SaveLoadVersion _sl_version; 
extern byte   _sl_minor_version;    


static GamelogActionType _gamelog_action_type = GLAT_NONE; 

LoggedAction *_gamelog_action = nullptr;        
uint _gamelog_actions         = 0;           
static LoggedAction *_current_action = nullptr; 


static const char * GetGamelogRevisionString()
{
  /* Allocate a buffer larger than necessary (git revision hash is 40 bytes) to avoid truncation later */
  static char gamelog_revision[48] = { 0 };
  assert_compile(lengthof(gamelog_revision) > GAMELOG_REVISION_LENGTH);

  if (IsReleasedVersion()) {
    return _openttd_revision;
  } else if (gamelog_revision[0] == 0) {
    /* Prefix character indication revision status */
    assert(_openttd_revision_modified < 3);
    gamelog_revision[0] = "gum"[_openttd_revision_modified]; // g = "git", u = "unknown", m = "modified"
    /* Append the revision hash */
    strecat(gamelog_revision, _openttd_revision_hash, lastof(gamelog_revision));
    /* Truncate string to GAMELOG_REVISION_LENGTH bytes */
    gamelog_revision[GAMELOG_REVISION_LENGTH - 1] = '\0';
  }
  return gamelog_revision;
}

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;
}

void GamelogStopAction()
{
  assert(_gamelog_action_type != GLAT_NONE); // nobody should try to stop if there is no action in progress

  bool print = _current_action != nullptr;

  _current_action = nullptr;
  _gamelog_action_type = GLAT_NONE;

  if (print) GamelogPrintDebug(5);
}

void GamelogStopAnyAction()
{
  if (_gamelog_action_type != GLAT_NONE) GamelogStopAction();
}

void GamelogFree(LoggedAction *gamelog_action, uint gamelog_actions)
{
  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_SETTING) free(lc->setting.name);
    }
    free(la->change);
  }

  free(gamelog_action);
}

void GamelogReset()
{
  assert(_gamelog_action_type == GLAT_NONE);
  GamelogFree(_gamelog_action, _gamelog_actions);

  _gamelog_action  = nullptr;
  _gamelog_actions = 0;
  _current_action  = nullptr;
}

static char *PrintGrfInfo(char *buf, const char *last, uint grfid, const uint8 *md5sum, const GRFConfig *gc)
{
  char txt[40];

  if (md5sum != nullptr) {
    md5sumToString(txt, lastof(txt), md5sum);
    buf += seprintf(buf, last, "GRF ID %08X, checksum %s", BSWAP32(grfid), txt);
  } else {
    buf += seprintf(buf, last, "GRF ID %08X", BSWAP32(grfid));
  }

  if (gc != nullptr) {
    buf += seprintf(buf, last, ", filename: %s (md5sum matches)", gc->filename);
  } else {
    gc = FindGRFConfig(grfid, FGCM_ANY);
    if (gc != nullptr) {
      buf += seprintf(buf, last, ", filename: %s (matches GRFID only)", gc->filename);
    } else {
      buf += seprintf(buf, last, ", unknown GRF");
    }
  }
  return buf;
}


static const char * const la_text[] = {
  "new game started",
  "game loaded",
  "GRF config changed",
  "cheat was used",
  "settings changed",
  "GRF bug triggered",
  "emergency savegame",
};

assert_compile(lengthof(la_text) == GLAT_END);

struct GRFPresence{
  const GRFConfig *gc;  
  bool was_missing;     

  GRFPresence(const GRFConfig *gc) : gc(gc), was_missing(false) {}
  GRFPresence() = default;
};
typedef SmallMap<uint32, GRFPresence> GrfIDMapping;

void GamelogPrint(GamelogPrintProc *proc)
{
  char buffer[1024];
  GrfIDMapping grf_names;

  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);

    seprintf(buffer, lastof(buffer), "Tick %u: %s", (uint)la->tick, la_text[(uint)la->at]);
    proc(buffer);

    const LoggedChange *lcend = &la->change[la->changes];

    for (const LoggedChange *lc = la->change; lc != lcend; lc++) {
      char *buf = buffer;

      switch (lc->ct) {
        default: NOT_REACHED();
        case GLCT_MODE:
          buf += seprintf(buf, lastof(buffer), "New game mode: %u landscape: %u",
            (uint)lc->mode.mode, (uint)lc->mode.landscape);
          break;

        case GLCT_REVISION:
          buf += seprintf(buf, lastof(buffer), "Revision text changed to %s, savegame version %u, ",
            lc->revision.text, lc->revision.slver);

          switch (lc->revision.modified) {
            case 0: buf += seprintf(buf, lastof(buffer), "not "); break;
            case 1: buf += seprintf(buf, lastof(buffer), "maybe "); break;
            default: break;
          }

          buf += seprintf(buf, lastof(buffer), "modified, _openttd_newgrf_version = 0x%08x", lc->revision.newgrf);
          break;

        case GLCT_OLDVER:
          buf += seprintf(buf, lastof(buffer), "Conversion from ");
          switch (lc->oldver.type) {
            default: NOT_REACHED();
            case SGT_OTTD:
              buf += seprintf(buf, lastof(buffer), "OTTD savegame without gamelog: version %u, %u",
                GB(lc->oldver.version, 8, 16), GB(lc->oldver.version, 0, 8));
              break;

            case SGT_TTO:
              buf += seprintf(buf, lastof(buffer), "TTO savegame");
              break;

            case SGT_TTD:
              buf += seprintf(buf, lastof(buffer), "TTD savegame");
              break;

            case SGT_TTDP1:
            case SGT_TTDP2:
              buf += seprintf(buf, lastof(buffer), "TTDP savegame, %s format",
                lc->oldver.type == SGT_TTDP1 ? "old" : "new");
              if (lc->oldver.version != 0) {
                buf += seprintf(buf, lastof(buffer), ", 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_SETTING:
          buf += seprintf(buf, lastof(buffer), "Setting changed: %s : %d -> %d", lc->setting.name, lc->setting.oldval, lc->setting.newval);
          break;

        case GLCT_GRFADD: {
          const GRFConfig *gc = FindGRFConfig(lc->grfadd.grfid, FGCM_EXACT, lc->grfadd.md5sum);
          buf += seprintf(buf, lastof(buffer), "Added NewGRF: ");
          buf = PrintGrfInfo(buf, lastof(buffer), lc->grfadd.grfid, lc->grfadd.md5sum, gc);
          GrfIDMapping::Pair *gm = grf_names.Find(lc->grfrem.grfid);
          if (gm != grf_names.End() && !gm->second.was_missing) buf += seprintf(buf, lastof(buffer), ". Gamelog inconsistency: GrfID was already added!");
          grf_names[lc->grfadd.grfid] = gc;
          break;
        }

        case GLCT_GRFREM: {
          GrfIDMapping::Pair *gm = grf_names.Find(lc->grfrem.grfid);
          buf += seprintf(buf, lastof(buffer), la->at == GLAT_LOAD ? "Missing NewGRF: " : "Removed NewGRF: ");
          buf = PrintGrfInfo(buf, lastof(buffer), lc->grfrem.grfid, nullptr, gm != grf_names.End() ? gm->second.gc : nullptr);
          if (gm == grf_names.End()) {
            buf += seprintf(buf, lastof(buffer), ". Gamelog inconsistency: GrfID was never added!");
          } else {
            if (la->at == GLAT_LOAD) {
              /* Missing grfs on load are not removed from the configuration */
              gm->second.was_missing = true;
            } else {
              grf_names.Erase(gm);
            }
          }
          break;
        }

        case GLCT_GRFCOMPAT: {
          const GRFConfig *gc = FindGRFConfig(lc->grfadd.grfid, FGCM_EXACT, lc->grfadd.md5sum);
          buf += seprintf(buf, lastof(buffer), "Compatible NewGRF loaded: ");
          buf = PrintGrfInfo(buf, lastof(buffer), lc->grfcompat.grfid, lc->grfcompat.md5sum, gc);
          if (!grf_names.Contains(lc->grfcompat.grfid)) buf += seprintf(buf, lastof(buffer), ". Gamelog inconsistency: GrfID was never added!");
          grf_names[lc->grfcompat.grfid] = gc;
          break;
        }

        case GLCT_GRFPARAM: {
          GrfIDMapping::Pair *gm = grf_names.Find(lc->grfrem.grfid);
          buf += seprintf(buf, lastof(buffer), "GRF parameter changed: ");
          buf = PrintGrfInfo(buf, lastof(buffer), lc->grfparam.grfid, nullptr, gm != grf_names.End() ? gm->second.gc : nullptr);
          if (gm == grf_names.End()) buf += seprintf(buf, lastof(buffer), ". Gamelog inconsistency: GrfID was never added!");
          break;
        }

        case GLCT_GRFMOVE: {
          GrfIDMapping::Pair *gm = grf_names.Find(lc->grfrem.grfid);
          buf += seprintf(buf, lastof(buffer), "GRF order changed: %08X moved %d places %s",
            BSWAP32(lc->grfmove.grfid), abs(lc->grfmove.offset), lc->grfmove.offset >= 0 ? "down" : "up" );
          buf = PrintGrfInfo(buf, lastof(buffer), lc->grfmove.grfid, nullptr, gm != grf_names.End() ? gm->second.gc : nullptr);
          if (gm == grf_names.End()) buf += seprintf(buf, lastof(buffer), ". Gamelog inconsistency: GrfID was never added!");
          break;
        }

        case GLCT_GRFBUG: {
          GrfIDMapping::Pair *gm = grf_names.Find(lc->grfrem.grfid);
          switch (lc->grfbug.bug) {
            default: NOT_REACHED();
            case GBUG_VEH_LENGTH:
              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);
              break;
          }
          buf = PrintGrfInfo(buf, lastof(buffer), lc->grfbug.grfid, nullptr, gm != grf_names.End() ? gm->second.gc : nullptr);
          if (gm == grf_names.End()) buf += seprintf(buf, lastof(buffer), ". Gamelog inconsistency: GrfID was never added!");
          break;
        }

        case GLCT_EMERGENCY:
          break;
      }

      proc(buffer);
    }
  }

  proc("---- gamelog end ----");
}


static void GamelogPrintConsoleProc(const char *s)
{
  IConsolePrint(CC_WARNING, s);
}

void GamelogPrintConsole()
{
  GamelogPrint(&GamelogPrintConsoleProc);
}

static int _gamelog_print_level = 0; 

static void GamelogPrintDebugProc(const char *s)
{
  DEBUG(gamelog, _gamelog_print_level, "%s", s);
}


void GamelogPrintDebug(int level)
{
  _gamelog_print_level = level;
  GamelogPrint(&GamelogPrintDebugProc);
}


static LoggedChange *GamelogChange(GamelogChangeType ct)
{
  if (_current_action == nullptr) {
    if (_gamelog_action_type == GLAT_NONE) return nullptr;

    _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  = nullptr;
    _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;
}


void GamelogEmergency()
{
  /* Terminate any active action */
  if (_gamelog_action_type != GLAT_NONE) GamelogStopAction();
  GamelogStartAction(GLAT_EMERGENCY);
  GamelogChange(GLCT_EMERGENCY);
  GamelogStopAction();
}

bool GamelogTestEmergency()
{
  const LoggedChange *emergency = nullptr;

  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_EMERGENCY) emergency = lc;
    }
  }

  return (emergency != nullptr);
}

void GamelogRevision()
{
  assert(_gamelog_action_type == GLAT_START || _gamelog_action_type == GLAT_LOAD);

  LoggedChange *lc = GamelogChange(GLCT_REVISION);
  if (lc == nullptr) return;

  memset(lc->revision.text, 0, sizeof(lc->revision.text));
  strecpy(lc->revision.text, GetGamelogRevisionString(), lastof(lc->revision.text));
  lc->revision.slver = SAVEGAME_VERSION;
  lc->revision.modified = _openttd_revision_modified;
  lc->revision.newgrf = _openttd_newgrf_version;
}

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 == nullptr) return;

  lc->mode.mode      = _game_mode;
  lc->mode.landscape = _settings_game.game_creation.landscape;
}

void GamelogOldver()
{
  assert(_gamelog_action_type == GLAT_LOAD);

  LoggedChange *lc = GamelogChange(GLCT_OLDVER);
  if (lc == nullptr) return;

  lc->oldver.type = _savegame_type;
  lc->oldver.version = (_savegame_type == SGT_OTTD ? ((uint32)_sl_version << 8 | _sl_minor_version) : _ttdp_version);
}

void GamelogSetting(const char *name, int32 oldval, int32 newval)
{
  assert(_gamelog_action_type == GLAT_SETTING);

  LoggedChange *lc = GamelogChange(GLCT_SETTING);
  if (lc == nullptr) return;

  lc->setting.name = stredup(name);
  lc->setting.oldval = oldval;
  lc->setting.newval = newval;
}


void GamelogTestRevision()
{
  const LoggedChange *rev = nullptr;

  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 == nullptr || strcmp(rev->revision.text, GetGamelogRevisionString()) != 0 ||
      rev->revision.modified != _openttd_revision_modified ||
      rev->revision.newgrf != _openttd_newgrf_version) {
    GamelogRevision();
  }
}

void GamelogTestMode()
{
  const LoggedChange *mode = nullptr;

  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 == nullptr || mode->mode.mode != _game_mode || mode->mode.landscape != _settings_game.game_creation.landscape) GamelogMode();
}


static void GamelogGRFBug(uint32 grfid, byte bug, uint64 data)
{
  assert(_gamelog_action_type == GLAT_GRFBUG);

  LoggedChange *lc = GamelogChange(GLCT_GRFBUG);
  if (lc == nullptr) return;

  lc->grfbug.data  = data;
  lc->grfbug.grfid = grfid;
  lc->grfbug.bug   = bug;
}

bool GamelogGRFBugReverse(uint32 grfid, uint16 internal_id)
{
  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_GRFBUG && lc->grfbug.grfid == grfid &&
          lc->grfbug.bug == GBUG_VEH_LENGTH && lc->grfbug.data == internal_id) {
        return false;
      }
    }
  }

  GamelogStartAction(GLAT_GRFBUG);
  GamelogGRFBug(grfid, GBUG_VEH_LENGTH, internal_id);
  GamelogStopAction();

  return true;
}


static inline bool IsLoggableGrfConfig(const GRFConfig *g)
{
  return !HasBit(g->flags, GCF_STATIC) && g->status != GCS_NOT_FOUND;
}

void GamelogGRFRemove(uint32 grfid)
{
  assert(_gamelog_action_type == GLAT_LOAD || _gamelog_action_type == GLAT_GRF);

  LoggedChange *lc = GamelogChange(GLCT_GRFREM);
  if (lc == nullptr) return;

  lc->grfrem.grfid = grfid;
}

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 == nullptr) return;

  lc->grfadd = newg->ident;
}

void GamelogGRFCompatible(const GRFIdentifier *newg)
{
  assert(_gamelog_action_type == GLAT_LOAD || _gamelog_action_type == GLAT_GRF);

  LoggedChange *lc = GamelogChange(GLCT_GRFCOMPAT);
  if (lc == nullptr) return;

  lc->grfcompat = *newg;
}

static void GamelogGRFMove(uint32 grfid, int32 offset)
{
  assert(_gamelog_action_type == GLAT_GRF);

  LoggedChange *lc = GamelogChange(GLCT_GRFMOVE);
  if (lc == nullptr) return;

  lc->grfmove.grfid  = grfid;
  lc->grfmove.offset = offset;
}

static void GamelogGRFParameters(uint32 grfid)
{
  assert(_gamelog_action_type == GLAT_GRF);

  LoggedChange *lc = GamelogChange(GLCT_GRFPARAM);
  if (lc == nullptr) return;

  lc->grfparam.grfid = grfid;
}

void GamelogGRFAddList(const GRFConfig *newg)
{
  assert(_gamelog_action_type == GLAT_START || _gamelog_action_type == GLAT_LOAD);

  for (; newg != nullptr; newg = newg->next) {
    GamelogGRFAdd(newg);
  }
}

struct GRFList {
  uint n;
  const GRFConfig *grf[];
};

static GRFList *GenerateGRFList(const GRFConfig *grfc)
{
  uint n = 0;
  for (const GRFConfig *g = grfc; g != nullptr; 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 != nullptr; g = g->next) {
    if (IsLoggableGrfConfig(g)) list->grf[list->n++] = g;
  }

  return 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->ident.grfid != ng->ident.grfid) {
      uint oi, ni;
      for (oi = 0; oi < ol->n; oi++) {
        if (ol->grf[oi]->ident.grfid == nl->grf[n]->ident.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]->ident.grfid == ol->grf[o]->ident.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++]->ident.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++]->ident.grfid, ni);
      } else {
        GamelogGRFMove(nl->grf[n++]->ident.grfid, -(int)oi);
      }
    } else {
      if (memcmp(og->ident.md5sum, ng->ident.md5sum, sizeof(og->ident.md5sum)) != 0) {
        /* md5sum changed, probably loading 'compatible' GRF */
        GamelogGRFCompatible(&nl->grf[n]->ident);
      }

      if (og->num_params != ng->num_params || memcmp(og->param, ng->param, og->num_params * sizeof(og->param[0])) != 0) {
        GamelogGRFParameters(ol->grf[o]->ident.grfid);
      }

      o++;
      n++;
    }
  }

  while (o < ol->n) GamelogGRFRemove(ol->grf[o++]->ident.grfid); // remaining GRFs were removed ...
  while (n < nl->n) GamelogGRFAdd   (nl->grf[n++]);              // ... or added

  free(ol);
  free(nl);
}

void GamelogInfo(LoggedAction *gamelog_action, uint gamelog_actions, uint32 *last_ottd_rev, byte *ever_modified, bool *removed_newgrfs)
{
  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++) {
      switch (lc->ct) {
        default: break;

        case GLCT_REVISION:
          *last_ottd_rev = lc->revision.newgrf;
          *ever_modified = max(*ever_modified, lc->revision.modified);
          break;

        case GLCT_GRFREM:
          *removed_newgrfs = true;
          break;
      }
    }
  }
}