gamelog.cpp

Go to the documentation of this file.

/* $Id: gamelog.cpp 14828 2009-01-04 15:32:25Z smatz $ */

#include "stdafx.h"
#include "openttd.h"
#include "saveload/saveload.h"
#include "core/alloc_func.hpp"
#include "core/bitmath_func.hpp"
#include "core/math_func.hpp"
#include "network/core/config.h"
#include "variables.h"
#include "string_func.h"
#include "settings_type.h"
#include "newgrf_config.h"
#include "gamelog.h"
#include "gamelog_internal.h"
#include "console_func.h"
#include "debug.h"
#include "rev.h"

#include <string.h>
#include <stdarg.h>

extern const uint16 SAVEGAME_VERSION;  

extern SavegameType _savegame_type; 

extern uint32 _ttdp_version;     
extern uint16 _sl_version;       
extern byte   _sl_minor_version; 


static GamelogActionType _gamelog_action_type = GLAT_NONE; 

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


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 != NULL;

  _current_action = NULL;
  _gamelog_action_type = GLAT_NONE;

  if (print) GamelogPrintDebug(5);
}

void GamelogReset()
{
  assert(_gamelog_action_type == GLAT_NONE);

  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_PATCH) free(lc->patch.name);
    }
    free(la->change);
  }

  free(_gamelog_action);

  _gamelog_action  = NULL;
  _gamelog_actions = 0;
  _current_action  = NULL;
}

enum {
  GAMELOG_BUF_LEN = 1024 
};

static int _dbgofs = 0; 

static void AddDebugText(char *buf, const char *s, ...)
{
  if (GAMELOG_BUF_LEN <= _dbgofs) return;

  va_list va;

  va_start(va, s);
  _dbgofs += vsnprintf(buf + _dbgofs, GAMELOG_BUF_LEN - _dbgofs, s, va);
  va_end(va);
}


static void PrintGrfFilename(char *buf, uint grfid)
{
  const GRFConfig *gc = FindGRFConfig(grfid);

  if (gc == NULL) return;

  AddDebugText(buf, ", filename: %s", gc->filename);
}

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

  md5sumToString(txt, lastof(txt), md5sum);

  AddDebugText(buf, "GRF ID %08X, checksum %s", BSWAP32(grfid), txt);

  PrintGrfFilename(buf, grfid);

  return;
}


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

assert_compile(lengthof(la_text) == GLAT_END);


void GamelogPrint(GamelogPrintProc *proc)
{
  char buf[GAMELOG_BUF_LEN];

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

    snprintf(buf, GAMELOG_BUF_LEN, "Tick %u: %s", (uint)la->tick, la_text[(uint)la->at]);
    proc(buf);

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

    for (const LoggedChange *lc = la->change; lc != lcend; lc++) {
      _dbgofs = 0;
      AddDebugText(buf, "     ");

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

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

          switch (lc->revision.modified) {
            case 0: AddDebugText(buf, "not "); break;
            case 1: AddDebugText(buf, "maybe "); break;
            default: break;
          }

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

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

            case SGT_TTD:
              AddDebugText(buf, "TTD savegame");
              break;

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

        case GLCT_GRFADD:
          AddDebugText(buf, "Added NewGRF: ");
          PrintGrfInfo(buf, lc->grfadd.grfid, lc->grfadd.md5sum);
          break;

        case GLCT_GRFREM:
          AddDebugText(buf, "Removed NewGRF: %08X", BSWAP32(lc->grfrem.grfid));
          PrintGrfFilename(buf, lc->grfrem.grfid);
          break;

        case GLCT_GRFCOMPAT:
          AddDebugText(buf, "Compatible NewGRF loaded: ");
          PrintGrfInfo(buf, lc->grfcompat.grfid, lc->grfcompat.md5sum);
          break;

        case GLCT_GRFPARAM:
          AddDebugText(buf, "GRF parameter changed: %08X", BSWAP32(lc->grfparam.grfid));
          PrintGrfFilename(buf, lc->grfparam.grfid);
          break;

        case GLCT_GRFMOVE:
          AddDebugText(buf, "GRF order changed: %08X moved %d places %s",
            BSWAP32(lc->grfmove.grfid), abs(lc->grfmove.offset), lc->grfmove.offset >= 0 ? "down" : "up" );
          PrintGrfFilename(buf, lc->grfmove.grfid);
          break;

        case GLCT_GRFBUG:
          switch (lc->grfbug.bug) {
            default: NOT_REACHED();
            case GBUG_VEH_LENGTH:
              AddDebugText(buf, "Rail vehicle changes length outside a depot: GRF ID %08X, internal ID 0x%X", BSWAP32(lc->grfbug.grfid), (uint)lc->grfbug.data);
              PrintGrfFilename(buf, lc->grfbug.grfid);
              break;
          }
      }

      proc(buf);
    }
  }

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


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


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

    _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  = NULL;
    _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 GamelogRevision()
{
  assert(_gamelog_action_type == GLAT_START || _gamelog_action_type == GLAT_LOAD);

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

  strecpy(lc->revision.text, _openttd_revision, 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 == NULL) 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 == NULL) return;

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

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

  LoggedChange *lc = GamelogChange(GLCT_PATCH);
  if (lc == NULL) return;

  lc->patch.name = strdup(name);
  lc->patch.oldval = oldval;
  lc->patch.newval = newval;
}


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

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

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

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

  memcpy(&lc->grfadd, newg, sizeof(GRFIdentifier));
}

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

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

  memcpy(&lc->grfcompat, newg, sizeof(GRFIdentifier));
}

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

  LoggedChange *lc = GamelogChange(GLCT_GRFMOVE);
  if (lc == NULL) 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 == NULL) return;

  lc->grfparam.grfid = grfid;
}

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

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

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

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

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

      o++;
      n++;
    }
  }

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

  free(ol);
  free(nl);
}