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_END,         ///< So we know how many GLCTs are there

    43

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

    44

};

    45

    46

    47

/** Contains information about one logged change */

    48

struct LoggedChange {

    49

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

    50

	union {

    51

		struct {

    52

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

    53

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

    54

		} mode;

    55

		struct {

    56

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

    57

			uint32 newgrf;   ///< _openttd_newgrf_version

    58

			uint16 slver;    ///< _sl_version

    59

			byte modified;   ///< _openttd_revision_modified

    60

		} revision;

    61

		struct {

    62

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

    63

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

    64

		} oldver;

    65

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

    66

		struct {

    67

			uint32 grfid;    ///< ID of removed GRF

    68

		} grfrem;

    69

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

    70

		struct {

    71

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

    72

		} grfparam;

    73

		struct {

    74

			uint32 grfid;    ///< ID of moved GRF

    75

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

    76

		} grfmove;

    77

		struct {

    78

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

    79

			int32 oldval;    ///< old value

    80

			int32 newval;    ///< new value

    81

		} patch;

    82

	};

    83

};

    84

    85

    86

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

    87

struct LoggedAction {

    88

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

    89

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

    90

	GamelogActionType at; ///< Type of action

    91

	uint16 tick;          ///< Tick when it happened

    92

};

    93

    94

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

    95

    96

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

    97

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

    98

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

    99

   100

   101

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

   102

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

   103

 * @param at type of action

   104

 */

   105

void GamelogStartAction(GamelogActionType at)

   106

{

   107

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

   108

	_gamelog_action_type = at;

   109

}

   110

   111

/** Stops logging of any changes

   112

 */

   113

void GamelogStopAction()

   114

{

   115

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

   116

   117

	bool print = _current_action != NULL;

   118

   119

	_current_action = NULL;

   120

	_gamelog_action_type = GLAT_NONE;

   121

   122

	if (print) GamelogPrintDebug(5);

   123

}

   124

   125

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

   126

 */

   127

void GamelogReset()

   128

{

   129

	assert(_gamelog_action_type == GLAT_NONE);

   130

   131

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

   132

		const LoggedAction *la = &_gamelog_action[i];

   133

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

   134

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

   135

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

   136

		}

   137

		free(la->change);

   138

	}

   139

   140

	free(_gamelog_action);

   141

   142

	_gamelog_action  = NULL;

   143

	_gamelog_actions = 0;

   144

	_current_action  = NULL;

   145

}

   146

   147

enum {

   148

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

   149

};

   150

   151

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

   152

   153

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

   154

{

   155

	if (GAMELOG_BUF_LEN <= _dbgofs) return;

   156

   157

	va_list va;

   158

   159

	va_start(va, s);

   160

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

   161

	va_end(va);

   162

}

   163

   164

   165

/** Prints GRF filename if found

   166

 * @param grfid GRF which filename to print

   167

 */

   168

static void PrintGrfFilename(char *buf, uint grfid)

   169

{

   170

	const GRFConfig *gc = FindGRFConfig(grfid);

   171

   172

	if (gc == NULL) return;

   173

   174

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

   175

}

   176

   177

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

   178

 * @param grfid GRF ID

   179

 * @param md5sum array of md5sum to print

   180

 */

   181

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

   182

{

   183

	char txt[40];

   184

   185

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

   186

   187

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

   188

   189

	PrintGrfFilename(buf, grfid);

   190

   191

	return;

   192

}

   193

   194

   195

/** Text messages for various logged actions */

   196

static const char *la_text[] = {

   197

	"new game started",

   198

	"game loaded",

   199

	"GRF config changed",

   200

	"cheat was used",

   201

	"patch settings changed"

   202

};

   203

   204

assert_compile(lengthof(la_text) == GLAT_END);

   205

   206

   207

/** Prints active gamelog */

   208

void GamelogPrint(GamelogPrintProc *proc)

   209

{

   210

	char buf[GAMELOG_BUF_LEN];

   211

   212

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

   213

   214

	const LoggedAction *laend = &_gamelog_action[_gamelog_actions];

   215

   216

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

   217

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

   218

   219

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

   220

		proc(buf);

   221

   222

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

   223

   224

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

   225

			_dbgofs = 0;

   226

			AddDebugText(buf, "     ");

   227

   228

			switch (lc->ct) {

   229

				default: NOT_REACHED();

   230

				case GLCT_MODE:

   231

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

   232

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

   233

					break;

   234

   235

				case GLCT_REVISION:

   236

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

   237

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

   238

   239

					switch (lc->revision.modified) {

   240

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

   241

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

   242

						default: break;

   243

					}

   244

   245

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

   246

					break;

   247

   248

				case GLCT_OLDVER:

   249

					AddDebugText(buf, "Conversion from ");

   250

					switch (lc->oldver.type) {

   251

						default: NOT_REACHED();

   252

						case SGT_OTTD:

   253

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

   254

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

   255

							break;

   256

   257

						case SGT_TTD:

   258

							AddDebugText(buf, "TTD savegame");

   259

							break;

   260

   261

						case SGT_TTDP1:

   262

						case SGT_TTDP2:

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

							}

   270

							break;

   271

					}

   272

					break;

   273

   274

				case GLCT_PATCH:

   275

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

   276

					break;

   277

   278

				case GLCT_GRFADD:

   279

					AddDebugText(buf, "Added NewGRF: ");

   280

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

   281

					break;

   282

   283

				case GLCT_GRFREM:

   284

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

   285

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

   286

					break;

   287

   288

				case GLCT_GRFCOMPAT:

   289

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

   290

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

   291

					break;

   292

   293

				case GLCT_GRFPARAM:

   294

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

   295

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

   296

					break;

   297

   298

				case GLCT_GRFMOVE:

   299

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

   300

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

   301

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

   302

					break;

   303

			}

   304

   305

			proc(buf);

   306

		}

   307

	}

   308

   309

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

   310

}

   311

   312

   313

static void GamelogPrintConsoleProc(const char *s)

   314

{

   315

	IConsolePrint(CC_WARNING, s);

   316

}

   317

   318

void GamelogPrintConsole()

   319

{

   320

	GamelogPrint(&GamelogPrintConsoleProc);

   321

}

   322

   323

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

   324

   325

static void GamelogPrintDebugProc(const char *s)

   326

{

   327

	DEBUG(gamelog, _gamelog_print_level, s);

   328

}

   329

   330

   331

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

   332

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

   333

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

   334

 * @param level debug level we need to print stuff

   335

 */

   336

void GamelogPrintDebug(int level)

   337

{

   338

	_gamelog_print_level = level;

   339

	GamelogPrint(&GamelogPrintDebugProc);

   340

}

   341

   342

   343

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

   344

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

   345

 * @param ct type of change

   346

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

   347

 */

   348

static LoggedChange *GamelogChange(GamelogChangeType ct)

   349

{

   350

	if (_current_action == NULL) {

   351

		if (_gamelog_action_type == GLAT_NONE) return NULL;

   352

   353

		_gamelog_action  = ReallocT(_gamelog_action, _gamelog_actions + 1);

   354

		_current_action  = &_gamelog_action[_gamelog_actions++];

   355

   356

		_current_action->at      = _gamelog_action_type;

   357

		_current_action->tick    = _tick_counter;

   358

		_current_action->change  = NULL;

   359

		_current_action->changes = 0;

   360

	}

   361

   362

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

   363

   364

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

   365

	lc->ct = ct;

   366

   367

	return lc;

   368

}

   369

   370

   371

/** Logs a change in game revision

   372

 * @param revision new revision string

   373

 */

   374

void GamelogRevision()

   375

{

   376

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

   377

   378

	LoggedChange *lc = GamelogChange(GLCT_REVISION);

   379

	if (lc == NULL) return;

   380

   381

	strncpy(lc->revision.text, _openttd_revision, lengthof(lc->revision.text));

   382

	lc->revision.slver = SAVEGAME_VERSION;

   383

	lc->revision.modified = _openttd_revision_modified;

   384

	lc->revision.newgrf = _openttd_newgrf_version;

   385

}

   386

   387

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

   388

 */

   389

void GamelogMode()

   390

{

   391

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

   392

   393

	LoggedChange *lc = GamelogChange(GLCT_MODE);

   394

	if (lc == NULL) return;

   395

   396

	lc->mode.mode      = _game_mode;

   397

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

   398

}

   399

   400

/** Logs loading from savegame without gamelog

   401

 */

   402

void GamelogOldver()

   403

{

   404

	assert(_gamelog_action_type == GLAT_LOAD);

   405

   406

	LoggedChange *lc = GamelogChange(GLCT_OLDVER);

   407

	if (lc == NULL) return;

   408

   409

	lc->oldver.type = _savegame_type;

   410

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

   411

}

   412

   413

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

   414

 * @param name patch name

   415

 * @param oldval old patch value

   416

 * @param newval new patch value

   417

 */

   418

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

   419

{

   420

	assert(_gamelog_action_type == GLAT_PATCH);

   421

   422

	LoggedChange *lc = GamelogChange(GLCT_PATCH);

   423

	if (lc == NULL) return;

   424

   425

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

   426

	lc->patch.oldval = oldval;

   427

	lc->patch.newval = newval;

   428

}

   429

   430

   431

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

   432

 * Appends GLCT_REVISION when the revision string changed

   433

 */

   434

void GamelogTestRevision()

   435

{

   436

	const LoggedChange *rev = NULL;

   437

   438

	const LoggedAction *laend = &_gamelog_action[_gamelog_actions];

   439

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

   440

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

   441

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

   442

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

   443

		}

   444

	}

   445

   446

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

   447

			rev->revision.modified != _openttd_revision_modified ||

   448

			rev->revision.newgrf != _openttd_newgrf_version) {

   449

		GamelogRevision();

   450

	}

   451

}

   452

   453

/** Finds last stored game mode or landscape.

   454

 * Any change is logged

   455

 */

   456

void GamelogTestMode()

   457

{

   458

	const LoggedChange *mode = NULL;

   459

   460

	const LoggedAction *laend = &_gamelog_action[_gamelog_actions];

   461

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

   462

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

   463

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

   464

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

   465

		}

   466

	}

   467

   468

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

   469

}

   470

   471

   472

/** Decides if GRF should be logged

   473

 * @param g grf to determine

   474

 * @return true iff GRF is not static and is loaded

   475

 */

   476

static inline bool IsLoggableGrfConfig(const GRFConfig *g)

   477

{

   478

	return !HasBit(g->flags, GCF_STATIC) && g->status != GCS_NOT_FOUND;

   479

}

   480

   481

/** Logs removal of a GRF

   482

 * @param grfid ID of removed GRF

   483

 */

   484

void GamelogGRFRemove(uint32 grfid)

   485

{

   486

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

   487

   488

	LoggedChange *lc = GamelogChange(GLCT_GRFREM);

   489

	if (lc == NULL) return;

   490

   491

	lc->grfrem.grfid = grfid;

   492

}

   493

   494

/** Logs adding of a GRF

   495

 * @param newg added GRF

   496

 */

   497

void GamelogGRFAdd(const GRFConfig *newg)

   498

{

   499

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

   500

   501

	if (!IsLoggableGrfConfig(newg)) return;

   502

   503

	LoggedChange *lc = GamelogChange(GLCT_GRFADD);

   504

	if (lc == NULL) return;

   505

   506

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

   507

}

   508

   509

/** Logs loading compatible GRF

   510

 * (the same ID, but different MD5 hash)

   511

 * @param newg new (updated) GRF

   512

 */

   513

void GamelogGRFCompatible(const GRFIdentifier *newg)

   514

{

   515

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

   516

   517

	LoggedChange *lc = GamelogChange(GLCT_GRFCOMPAT);

   518

	if (lc == NULL) return;

   519

   520

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

   521

}

   522

   523

/** Logs changing GRF order

   524

 * @param grfid GRF that is moved

   525

 * @param offset how far it is moved, positive = moved down

   526

 */

   527

static void GamelogGRFMove(uint32 grfid, int32 offset)

   528

{