1

/* $Id$ */

     2

     3

/** @file gamelog.cpp Definition of functions used for logging of important changes in the game */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "saveload.h"

     8

#include "core/alloc_func.hpp"

     9

#include "core/bitmath_func.hpp"

    10

#include "core/math_func.hpp"

    11

#include "network/core/config.h"

    12

#include "variables.h"

    13

#include "string_func.h"

    14

#include "settings_type.h"

    15

#include "newgrf_config.h"

    16

#include <string.h>

    17

#include <stdarg.h>

    18

#include "gamelog.h"

    19

#include "console_func.h"

    20

#include "debug.h"

    21

#include "rev.h"

    22

    23

extern const uint16 SAVEGAME_VERSION;  ///< current savegame version

    24

    25

extern SavegameType _savegame_type; ///< type of savegame we are loading

    26

    27

extern uint32 _ttdp_version;     ///< version of TTDP savegame (if applicable)

    28

extern uint16 _sl_version;       ///< the major savegame version identifier

    29

extern byte   _sl_minor_version; ///< the minor savegame version, DO NOT USE!

    30

    31

/** Type of logged change */

    32

enum GamelogChangeType {

    33

	GLCT_MODE,        ///< Scenario editor x Game, different landscape

    34

	GLCT_REVISION,    ///< Changed game revision string

    35

	GLCT_OLDVER,      ///< Loaded from savegame without logged data

    36

	GLCT_PATCH,       ///< Non-networksafe patch value changed

    37

	GLCT_GRFADD,      ///< Removed GRF

    38

	GLCT_GRFREM,      ///< Added GRF

    39

	GLCT_GRFCOMPAT,   ///< Loading compatible GRF

    40

	GLCT_GRFPARAM,    ///< GRF parameter changed

    41

	GLCT_GRFMOVE,     ///< GRF order changed

    42

	GLCT_GRFBUG,      ///< GRF bug triggered

    43

	GLCT_END,         ///< So we know how many GLCTs are there

    44

	GLCT_NONE = 0xFF, ///< In savegames, end of list

    45

};

    46

    47

    48

/** Contains information about one logged change */

    49

struct LoggedChange {

    50

	GamelogChangeType ct; ///< Type of change logged in this struct

    51

	union {

    52

		struct {

    53

			byte mode;       ///< new game mode - Editor x Game

    54

			byte landscape;  ///< landscape (temperate, arctic, ...)

    55

		} mode;

    56

		struct {

    57

			char text[NETWORK_REVISION_LENGTH]; ///< revision string, _openttd_revision

    58

			uint32 newgrf;   ///< _openttd_newgrf_version

    59

			uint16 slver;    ///< _sl_version

    60

			byte modified;   ///< _openttd_revision_modified

    61

		} revision;

    62

		struct {

    63

			uint32 type;     ///< type of savegame, @see SavegameType

    64

			uint32 version;  ///< major and minor version OR ttdp version

    65

		} oldver;

    66

		GRFIdentifier grfadd;    ///< ID and md5sum of added GRF

    67

		struct {

    68

			uint32 grfid;    ///< ID of removed GRF

    69

		} grfrem;

    70

		GRFIdentifier grfcompat; ///< ID and new md5sum of changed GRF

    71

		struct {

    72

			uint32 grfid;    ///< ID of GRF with changed parameters

    73

		} grfparam;

    74

		struct {

    75

			uint32 grfid;    ///< ID of moved GRF

    76

			int32 offset;    ///< offset, positive = move down

    77

		} grfmove;

    78

		struct {

    79

			char *name;      ///< name of the patch

    80

			int32 oldval;    ///< old value

    81

			int32 newval;    ///< new value

    82

		} patch;

    83

		struct {

    84

			uint64 data;     ///< additional data

    85

			uint32 grfid;    ///< ID of problematic GRF

    86

			byte bug;        ///< type of bug, @see enum GRFBugs

    87

		} grfbug;

    88

	};

    89

};

    90

    91

    92

/** Contains information about one logged action that caused at least one logged change */

    93

struct LoggedAction {

    94

	LoggedChange *change; ///< First logged change in this action

    95

	uint32 changes;       ///< Number of changes in this action

    96

	GamelogActionType at; ///< Type of action

    97

	uint16 tick;          ///< Tick when it happened

    98

};

    99

   100

static GamelogActionType _gamelog_action_type = GLAT_NONE; ///< action to record if anything changes

   101

   102

static LoggedAction *_gamelog_action = NULL; ///< first logged action

   103

static uint _gamelog_actions         = 0;    ///< number of actions

   104

static LoggedAction *_current_action = NULL; ///< current action we are logging, NULL when there is no action active

   105

   106

   107

/** Stores information about new action, but doesn't allocate it

   108

 * Action is allocated only when there is at least one change

   109

 * @param at type of action

   110

 */

   111

void GamelogStartAction(GamelogActionType at)

   112

{

   113

	assert(_gamelog_action_type == GLAT_NONE); // do not allow starting new action without stopping the previous first

   114

	_gamelog_action_type = at;

   115

}

   116

   117

/** Stops logging of any changes

   118

 */

   119

void GamelogStopAction()

   120

{

   121

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

   122

   123

	bool print = _current_action != NULL;

   124

   125

	_current_action = NULL;

   126

	_gamelog_action_type = GLAT_NONE;

   127

   128

	if (print) GamelogPrintDebug(5);

   129

}

   130

   131

/** Resets and frees all memory allocated - used before loading or starting a new game

   132

 */

   133

void GamelogReset()

   134

{

   135

	assert(_gamelog_action_type == GLAT_NONE);

   136

   137

	for (uint i = 0; i < _gamelog_actions; i++) {

   138

		const LoggedAction *la = &_gamelog_action[i];

   139

		for (uint j = 0; j < la->changes; j++) {

   140

			const LoggedChange *lc = &la->change[j];

   141

			if (lc->ct == GLCT_PATCH) free(lc->patch.name);

   142

		}

   143

		free(la->change);

   144

	}

   145

   146

	free(_gamelog_action);

   147

   148

	_gamelog_action  = NULL;

   149

	_gamelog_actions = 0;

   150

	_current_action  = NULL;

   151

}

   152

   153

enum {

   154

	GAMELOG_BUF_LEN = 1024 ///< length of buffer for one line of text

   155

};

   156

   157

static int _dbgofs = 0; ///< offset in current output buffer

   158

   159

static void AddDebugText(char *buf, const char *s, ...)

   160

{

   161

	if (GAMELOG_BUF_LEN <= _dbgofs) return;

   162

   163

	va_list va;

   164

   165

	va_start(va, s);

   166

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

   167

	va_end(va);

   168

}

   169

   170

   171

/** Prints GRF filename if found

   172

 * @param grfid GRF which filename to print

   173

 */

   174

static void PrintGrfFilename(char *buf, uint grfid)

   175

{

   176

	const GRFConfig *gc = FindGRFConfig(grfid);

   177

   178

	if (gc == NULL) return;

   179

   180

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

   181

}

   182

   183

/** Prints GRF ID, checksum and filename if found

   184

 * @param grfid GRF ID

   185

 * @param md5sum array of md5sum to print

   186

 */

   187

static void PrintGrfInfo(char *buf, uint grfid, const uint8 *md5sum)

   188

{

   189

	char txt[40];

   190

   191

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

   192

   193

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

   194

   195

	PrintGrfFilename(buf, grfid);

   196

   197

	return;

   198

}

   199

   200

   201

/** Text messages for various logged actions */

   202

static const char *la_text[] = {

   203

	"new game started",

   204

	"game loaded",

   205

	"GRF config changed",

   206

	"cheat was used",

   207

	"patch settings changed",

   208

	"GRF bug triggered",

   209

};

   210

   211

assert_compile(lengthof(la_text) == GLAT_END);

   212

   213

   214

/** Prints active gamelog */

   215

void GamelogPrint(GamelogPrintProc *proc)

   216

{

   217

	char buf[GAMELOG_BUF_LEN];

   218

   219

	proc("---- gamelog start ----");

   220

   221

	const LoggedAction *laend = &_gamelog_action[_gamelog_actions];

   222

   223

	for (const LoggedAction *la = _gamelog_action; la != laend; la++) {

   224

		assert((uint)la->at < GLAT_END);

   225

   226

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

   227

		proc(buf);

   228

   229

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

   230

   231

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

   232

			_dbgofs = 0;

   233

			AddDebugText(buf, "     ");

   234

   235

			switch (lc->ct) {

   236

				default: NOT_REACHED();

   237

				case GLCT_MODE:

   238

					AddDebugText(buf, "New game mode: %u landscape: %u",

   239

						(uint)lc->mode.mode, (uint)lc->mode.landscape);

   240

					break;

   241

   242

				case GLCT_REVISION:

   243

					AddDebugText(buf, "Revision text changed to %s, savegame version %u, ",

   244

						lc->revision.text, lc->revision.slver);

   245

   246

					switch (lc->revision.modified) {

   247

						case 0: AddDebugText(buf, "not "); break;

   248

						case 1: AddDebugText(buf, "maybe "); break;

   249

						default: break;

   250

					}

   251

   252

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

   253

					break;

   254

   255

				case GLCT_OLDVER:

   256

					AddDebugText(buf, "Conversion from ");

   257

					switch (lc->oldver.type) {

   258

						default: NOT_REACHED();

   259

						case SGT_OTTD:

   260

							AddDebugText(buf, "OTTD savegame without gamelog: version %u, %u",

   261

								GB(lc->oldver.version, 8, 16), GB(lc->oldver.version, 0, 8));

   262

							break;

   263

   264

						case SGT_TTD:

   265

							AddDebugText(buf, "TTD savegame");

   266

							break;

   267

   268

						case SGT_TTDP1:

   269

						case SGT_TTDP2:

   270

							AddDebugText(buf, "TTDP savegame, %s format",

   271

								lc->oldver.type == SGT_TTDP1 ? "old" : "new");

   272

							if (lc->oldver.version != 0) {

   273

								AddDebugText(buf, ", TTDP version %u.%u.%u.%u",

   274

									GB(lc->oldver.version, 24, 8), GB(lc->oldver.version, 20, 4),

   275

									GB(lc->oldver.version, 16, 4), GB(lc->oldver.version, 0, 16));

   276

							}

   277

							break;

   278

					}

   279

					break;

   280

   281

				case GLCT_PATCH:

   282

					AddDebugText(buf, "Patch setting changed: %s : %d -> %d", lc->patch.name, lc->patch.oldval, lc->patch.newval);

   283

					break;

   284

   285

				case GLCT_GRFADD:

   286

					AddDebugText(buf, "Added NewGRF: ");

   287

					PrintGrfInfo(buf, lc->grfadd.grfid, lc->grfadd.md5sum);

   288

					break;

   289

   290

				case GLCT_GRFREM:

   291

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

   292

					PrintGrfFilename(buf, lc->grfrem.grfid);

   293

					break;

   294

   295

				case GLCT_GRFCOMPAT:

   296

					AddDebugText(buf, "Compatible NewGRF loaded: ");

   297

					PrintGrfInfo(buf, lc->grfcompat.grfid, lc->grfcompat.md5sum);

   298

					break;

   299

   300

				case GLCT_GRFPARAM:

   301

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

   302

					PrintGrfFilename(buf, lc->grfparam.grfid);

   303

					break;

   304

   305

				case GLCT_GRFMOVE:

   306

					AddDebugText(buf, "GRF order changed: %08X moved %d places %s",

   307

						BSWAP32(lc->grfmove.grfid), abs(lc->grfmove.offset), lc->grfmove.offset >= 0 ? "down" : "up" );

   308

					PrintGrfFilename(buf, lc->grfmove.grfid);

   309

					break;

   310

   311

				case GLCT_GRFBUG:

   312

					switch (lc->grfbug.bug) {

   313

						default: NOT_REACHED();

   314

						case GBUG_VEH_LENGTH:

   315

							AddDebugText(buf, "Rail vehicle changes length outside a depot: GRF ID %08X, internal ID 0x%X", BSWAP32(lc->grfbug.grfid), (uint)lc->grfbug.data);

   316

							PrintGrfFilename(buf, lc->grfbug.grfid);

   317

							break;

   318

					}

   319

			}

   320

   321

			proc(buf);

   322

		}

   323

	}

   324

   325

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

   326

}

   327

   328

   329

static void GamelogPrintConsoleProc(const char *s)

   330

{

   331

	IConsolePrint(CC_WARNING, s);

   332

}

   333

   334

void GamelogPrintConsole()

   335

{

   336

	GamelogPrint(&GamelogPrintConsoleProc);

   337

}

   338

   339

static int _gamelog_print_level = 0; ///< gamelog debug level we need to print stuff

   340

   341

static void GamelogPrintDebugProc(const char *s)

   342

{

   343

	DEBUG(gamelog, _gamelog_print_level, s);

   344

}

   345

   346

   347

/** Prints gamelog to debug output. Code is executed even when

   348

 * there will be no output. It is called very seldom, so it

   349

 * doesn't matter that much. At least it gives more uniform code...

   350

 * @param level debug level we need to print stuff

   351

 */

   352

void GamelogPrintDebug(int level)

   353

{

   354

	_gamelog_print_level = level;

   355

	GamelogPrint(&GamelogPrintDebugProc);

   356

}

   357

   358

   359

/** Allocates new LoggedChange and new LoggedAction if needed.

   360

 * If there is no action active, NULL is returned.

   361

 * @param ct type of change

   362

 * @return new LoggedChange, or NULL if there is no action active

   363

 */

   364

static LoggedChange *GamelogChange(GamelogChangeType ct)

   365

{

   366

	if (_current_action == NULL) {

   367

		if (_gamelog_action_type == GLAT_NONE) return NULL;

   368

   369

		_gamelog_action  = ReallocT(_gamelog_action, _gamelog_actions + 1);

   370

		_current_action  = &_gamelog_action[_gamelog_actions++];

   371

   372

		_current_action->at      = _gamelog_action_type;

   373

		_current_action->tick    = _tick_counter;

   374

		_current_action->change  = NULL;

   375

		_current_action->changes = 0;

   376

	}

   377

   378

	_current_action->change = ReallocT(_current_action->change, _current_action->changes + 1);

   379

   380

	LoggedChange *lc = &_current_action->change[_current_action->changes++];

   381

	lc->ct = ct;

   382

   383

	return lc;

   384

}

   385

   386

   387

/** Logs a change in game revision

   388

 * @param revision new revision string

   389

 */

   390

void GamelogRevision()

   391

{

   392

	assert(_gamelog_action_type == GLAT_START || _gamelog_action_type == GLAT_LOAD);

   393

   394

	LoggedChange *lc = GamelogChange(GLCT_REVISION);

   395

	if (lc == NULL) return;

   396

   397

	strecpy(lc->revision.text, _openttd_revision, lastof(lc->revision.text));

   398

	lc->revision.slver = SAVEGAME_VERSION;

   399

	lc->revision.modified = _openttd_revision_modified;

   400

	lc->revision.newgrf = _openttd_newgrf_version;

   401

}

   402

   403

/** Logs a change in game mode (scenario editor or game)

   404

 */

   405

void GamelogMode()

   406

{

   407

	assert(_gamelog_action_type == GLAT_START || _gamelog_action_type == GLAT_LOAD || _gamelog_action_type == GLAT_CHEAT);

   408

   409

	LoggedChange *lc = GamelogChange(GLCT_MODE);

   410

	if (lc == NULL) return;

   411

   412

	lc->mode.mode      = _game_mode;

   413

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

   414

}

   415

   416

/** Logs loading from savegame without gamelog

   417

 */

   418

void GamelogOldver()

   419

{

   420

	assert(_gamelog_action_type == GLAT_LOAD);

   421

   422

	LoggedChange *lc = GamelogChange(GLCT_OLDVER);

   423

	if (lc == NULL) return;

   424

   425

	lc->oldver.type = _savegame_type;

   426

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

   427

}

   428

   429

/** Logs change in game patches. Only non-networksafe patches are logged

   430

 * @param name patch name

   431

 * @param oldval old patch value

   432

 * @param newval new patch value

   433

 */

   434

void GamelogPatch(const char *name, int32 oldval, int32 newval)

   435

{

   436

	assert(_gamelog_action_type == GLAT_PATCH);

   437

   438

	LoggedChange *lc = GamelogChange(GLCT_PATCH);

   439

	if (lc == NULL) return;

   440

   441

	lc->patch.name = strdup(name);

   442

	lc->patch.oldval = oldval;

   443

	lc->patch.newval = newval;

   444

}

   445

   446

   447

/** Finds out if current revision is different than last revision stored in the savegame.

   448

 * Appends GLCT_REVISION when the revision string changed

   449

 */

   450

void GamelogTestRevision()

   451

{

   452

	const LoggedChange *rev = NULL;

   453

   454

	const LoggedAction *laend = &_gamelog_action[_gamelog_actions];

   455

	for (const LoggedAction *la = _gamelog_action; la != laend; la++) {

   456

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

   457

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

   458

			if (lc->ct == GLCT_REVISION) rev = lc;

   459

		}

   460

	}

   461

   462

	if (rev == NULL || strcmp(rev->revision.text, _openttd_revision) != 0 ||

   463

			rev->revision.modified != _openttd_revision_modified ||

   464

			rev->revision.newgrf != _openttd_newgrf_version) {

   465

		GamelogRevision();

   466

	}

   467

}

   468

   469

/** Finds last stored game mode or landscape.

   470

 * Any change is logged

   471

 */

   472

void GamelogTestMode()

   473

{

   474

	const LoggedChange *mode = NULL;

   475

   476

	const LoggedAction *laend = &_gamelog_action[_gamelog_actions];

   477

	for (const LoggedAction *la = _gamelog_action; la != laend; la++) {

   478

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

   479

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

   480

			if (lc->ct == GLCT_MODE) mode = lc;

   481

		}

   482

	}

   483

   484

	if (mode == NULL || mode->mode.mode != _game_mode || mode->mode.landscape != _settings_game.game_creation.landscape) GamelogMode();

   485

}

   486

   487

   488

/** Logs triggered GRF bug.

   489

 * @param grfid ID of problematic GRF

   490

 * @param bug type of bug, @see enum GRFBugs

   491

 * @param data additional data

   492

 */

   493

static void GamelogGRFBug(uint32 grfid, byte bug, uint64 data)

   494

{

   495

	assert(_gamelog_action_type == GLAT_GRFBUG);

   496

   497

	LoggedChange *lc = GamelogChange(GLCT_GRFBUG);

   498

	if (lc == NULL) return;

   499

   500

	lc->grfbug.data  = data;

   501

	lc->grfbug.grfid = grfid;

   502

	lc->grfbug.bug   = bug;

   503

}

   504

   505

/** Logs GRF bug - rail vehicle has different length after reversing.

   506

 * Ensures this is logged only once for each GRF and engine type

   507

 * This check takes some time, but it is called pretty seldom, so it

   508

 * doesn't matter that much (ideally it shouldn't be called at all).

   509

 * @param engine engine to log

   510

 * @return true iff a unique record was done

   511

 */

   512

bool GamelogGRFBugReverse(uint32 grfid, uint16 internal_id)

   513

{

   514

	const LoggedAction *laend = &_gamelog_action[_gamelog_actions];

   515

	for (const LoggedAction *la = _gamelog_action; la != laend; la++) {

   516

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

   517

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

   518

			if (lc->ct == GLCT_GRFBUG && lc->grfbug.grfid == grfid &&

   519

					lc->grfbug.bug == GBUG_VEH_LENGTH && lc->grfbug.data == internal_id) {

   520

				return false;

   521

			}

   522

		}

   523

	}

   524