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

	_current_action = NULL;

   118

	_gamelog_action_type = GLAT_NONE;

   119

   120

	if (_debug_gamelog_level > 4) GamelogPrintDebug();

   121

}

   122

   123

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

   124

 */

   125

void GamelogReset()

   126

{

   127

	assert(_gamelog_action_type == GLAT_NONE);

   128

   129

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

   130

		const LoggedAction *la = &_gamelog_action[i];

   131

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

   132

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

   133

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

   134

		}

   135

		free(la->change);

   136

	}

   137

   138

	free(_gamelog_action);

   139

   140

	_gamelog_action  = NULL;

   141

	_gamelog_actions = 0;

   142

	_current_action  = NULL;

   143

}

   144

   145

enum {

   146

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

   147

};

   148

   149

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

   150

   151

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

   152

{

   153

	if (GAMELOG_BUF_LEN <= _dbgofs) return;

   154

   155

	va_list va;

   156

   157

	va_start(va, s);

   158

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

   159

	va_end(va);

   160

}

   161

   162

   163

/** Prints GRF filename if found

   164

 * @param grfid GRF which filename to print

   165

 */

   166

static void PrintGrfFilename(char *buf, uint grfid)

   167

{

   168

	const GRFConfig *gc = FindGRFConfig(grfid);

   169

   170

	if (gc == NULL) return;

   171

   172

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

   173

}

   174

   175

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

   176

 * @param grfid GRF ID

   177

 * @param md5sum array of md5sum to print

   178

 */

   179

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

   180

{

   181

	char txt[40];

   182

   183

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

   184

   185

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

   186

   187

	PrintGrfFilename(buf, grfid);

   188

   189

	return;

   190

}

   191

   192

   193

/** Text messages for various logged actions */

   194

static const char *la_text[] = {

   195

	"new game started",

   196

	"game loaded",

   197

	"GRF config changed",

   198

	"cheat was used",

   199

	"patch settings changed"

   200

};

   201

   202

assert_compile(lengthof(la_text) == GLAT_END);

   203

   204

   205

/** Prints active gamelog */

   206

void GamelogPrint(GamelogPrintProc *proc)

   207

{

   208

	char buf[GAMELOG_BUF_LEN];

   209

   210

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

   211

   212

	const LoggedAction *laend = &_gamelog_action[_gamelog_actions];

   213

   214

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

   215

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

   216

   217

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

   218

		proc(buf);

   219

   220

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

   221

   222

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

   223

			_dbgofs = 0;

   224

			AddDebugText(buf, "     ");

   225

   226

			switch (lc->ct) {

   227

				default: NOT_REACHED();

   228

				case GLCT_MODE:

   229

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

   230

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

   231

					break;

   232

   233

				case GLCT_REVISION:

   234

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

   235

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

   236

   237

					switch (lc->revision.modified) {

   238

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

   239

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

   240

						default: break;

   241

					}

   242

   243

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

   244

					break;

   245

   246

				case GLCT_OLDVER:

   247

					AddDebugText(buf, "Conversion from ");

   248

					switch (lc->oldver.type) {

   249

						default: NOT_REACHED();

   250

						case SGT_OTTD:

   251

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

   252

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

   253

							break;

   254

   255

						case SGT_TTD:

   256

							AddDebugText(buf, "TTD savegame");

   257

							break;

   258

   259

						case SGT_TTDP1:

   260

						case SGT_TTDP2:

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

							}

   268

							break;

   269

					}

   270

					break;

   271

   272

				case GLCT_PATCH:

   273

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

   274

					break;

   275

   276

				case GLCT_GRFADD:

   277

					AddDebugText(buf, "Added NewGRF: ");

   278

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

   279

					break;

   280

   281

				case GLCT_GRFREM:

   282

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

   283

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

   284

					break;

   285

   286

				case GLCT_GRFCOMPAT:

   287

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

   288

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

   289

					break;

   290

   291

				case GLCT_GRFPARAM:

   292

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

   293

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

   294

					break;

   295

   296

				case GLCT_GRFMOVE:

   297

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

   298

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

   299

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

   300

					break;

   301

			}

   302

   303

			proc(buf);

   304

		}

   305

	}

   306

   307

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

   308

}

   309

   310

   311

static void GamelogPrintConsoleProc(const char *s)

   312

{

   313

	IConsolePrint(CC_WARNING, s);

   314

}

   315

   316

void GamelogPrintConsole()

   317

{

   318

	GamelogPrint(&GamelogPrintConsoleProc);

   319

}

   320

   321

   322

static void GamelogPrintDebugProc(const char *s)

   323

{

   324

	debug_print("gamelog", s);

   325

}

   326

   327

void GamelogPrintDebug()

   328

{

   329

	GamelogPrint(&GamelogPrintDebugProc);

   330

}

   331

   332

   333

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

   334

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

   335

 * @param ct type of change

   336

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

   337

 */

   338

static LoggedChange *GamelogChange(GamelogChangeType ct)

   339

{

   340

	if (_current_action == NULL) {

   341

		if (_gamelog_action_type == GLAT_NONE) return NULL;

   342

   343

		_gamelog_action  = ReallocT(_gamelog_action, _gamelog_actions + 1);

   344

		_current_action  = &_gamelog_action[_gamelog_actions++];

   345

   346

		_current_action->at      = _gamelog_action_type;

   347

		_current_action->tick    = _tick_counter;

   348

		_current_action->change  = NULL;

   349

		_current_action->changes = 0;

   350

	}

   351

   352

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

   353

   354

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

   355

	lc->ct = ct;

   356

   357

	return lc;

   358

}

   359

   360

   361

/** Logs a change in game revision

   362

 * @param revision new revision string

   363

 */

   364

void GamelogRevision()

   365

{

   366

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

   367

   368

	LoggedChange *lc = GamelogChange(GLCT_REVISION);

   369

	if (lc == NULL) return;

   370

   371

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

   372

	lc->revision.slver = SAVEGAME_VERSION;

   373

	lc->revision.modified = _openttd_revision_modified;

   374

	lc->revision.newgrf = _openttd_newgrf_version;

   375

}

   376

   377

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

   378

 */

   379

void GamelogMode()

   380

{

   381

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

   382

   383

	LoggedChange *lc = GamelogChange(GLCT_MODE);

   384

	if (lc == NULL) return;

   385

   386

	lc->mode.mode      = _game_mode;

   387

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

   388

}

   389

   390

/** Logs loading from savegame without gamelog

   391

 */

   392

void GamelogOldver()

   393

{

   394

	assert(_gamelog_action_type == GLAT_LOAD);

   395

   396

	LoggedChange *lc = GamelogChange(GLCT_OLDVER);

   397

	if (lc == NULL) return;

   398

   399

	lc->oldver.type = _savegame_type;

   400

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

   401

}

   402

   403

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

   404

 * @param name patch name

   405

 * @param oldval old patch value

   406

 * @param newval new patch value

   407

 */

   408

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

   409

{

   410

	assert(_gamelog_action_type == GLAT_PATCH);

   411

   412

	LoggedChange *lc = GamelogChange(GLCT_PATCH);

   413

	if (lc == NULL) return;

   414

   415

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

   416

	lc->patch.oldval = oldval;

   417

	lc->patch.newval = newval;

   418

}

   419

   420

   421

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

   422

 * Appends GLCT_REVISION when the revision string changed

   423

 */

   424

void GamelogTestRevision()

   425

{

   426

	const LoggedChange *rev = NULL;

   427

   428

	const LoggedAction *laend = &_gamelog_action[_gamelog_actions];

   429

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

   430

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

   431

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

   432

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

   433

		}

   434

	}

   435

   436

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

   437

			rev->revision.modified != _openttd_revision_modified ||

   438

			rev->revision.newgrf != _openttd_newgrf_version) {

   439

		GamelogRevision();

   440

	}

   441

}

   442

   443

/** Finds last stored game mode or landscape.

   444

 * Any change is logged

   445

 */

   446

void GamelogTestMode()

   447

{

   448

	const LoggedChange *mode = NULL;

   449

   450

	const LoggedAction *laend = &_gamelog_action[_gamelog_actions];

   451

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

   452

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

   453

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

   454

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

   455

		}

   456

	}

   457

   458

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

   459

}

   460

   461

   462

/** Decides if GRF should be logged

   463

 * @param g grf to determine

   464

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

   465

 */

   466

static inline bool IsLoggableGrfConfig(const GRFConfig *g)

   467

{

   468

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

   469

}

   470

   471

/** Logs removal of a GRF

   472

 * @param grfid ID of removed GRF

   473

 */

   474

void GamelogGRFRemove(uint32 grfid)

   475

{

   476

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

   477

   478

	LoggedChange *lc = GamelogChange(GLCT_GRFREM);

   479

	if (lc == NULL) return;

   480

   481

	lc->grfrem.grfid = grfid;

   482

}

   483

   484

/** Logs adding of a GRF

   485

 * @param newg added GRF

   486

 */

   487

void GamelogGRFAdd(const GRFConfig *newg)

   488

{

   489

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

   490

   491

	if (!IsLoggableGrfConfig(newg)) return;

   492

   493

	LoggedChange *lc = GamelogChange(GLCT_GRFADD);

   494

	if (lc == NULL) return;

   495

   496

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

   497

}

   498

   499

/** Logs loading compatible GRF

   500

 * (the same ID, but different MD5 hash)

   501

 * @param newg new (updated) GRF

   502

 */

   503

void GamelogGRFCompatible(const GRFIdentifier *newg)

   504

{

   505

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

   506

   507

	LoggedChange *lc = GamelogChange(GLCT_GRFCOMPAT);

   508

	if (lc == NULL) return;

   509

   510

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

   511

}

   512

   513

/** Logs changing GRF order

   514

 * @param grfid GRF that is moved

   515

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

   516

 */

   517

static void GamelogGRFMove(uint32 grfid, int32 offset)

   518

{

   519

	assert(_gamelog_action_type == GLAT_GRF);

   520

   521

	LoggedChange *lc = GamelogChange(GLCT_GRFMOVE);

   522

	if (lc == NULL) return;

   523

   524

	lc->grfmove.grfid  = grfid;

   525

	lc->grfmove.offset = offset;

   526

}

   527

   528

/** Logs change in GRF parameters.

   529

 * Details about parameters changed are not stored