1

/* $Id$ */

     2

     3

/** @file misc.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "currency.h"

     8

#include "landscape.h"

     9

#include "news_func.h"

    10

#include "saveload.h"

    11

#include "vehicle_gui.h"

    12

#include "variables.h"

    13

#include "ai/ai.h"

    14

#include "newgrf_house.h"

    15

#include "cargotype.h"

    16

#include "group.h"

    17

#include "viewport_func.h"

    18

#include "economy_func.h"

    19

#include "zoom_func.h"

    20

#include "functions.h"

    21

#include "map_func.h"

    22

#include "date_func.h"

    23

#include "vehicle_func.h"

    24

#include "texteff.hpp"

    25

#include "string_func.h"

    26

#include "gfx_func.h"

    27

#include "core/alloc_func.hpp"

    28

#include "settings_type.h"

    29

    30

#include "table/strings.h"

    31

#include "table/sprites.h"

    32

    33

char _name_array[512][32];

    34

    35

void InitializeVehicles();

    36

void InitializeWaypoints();

    37

void InitializeDepots();

    38

void InitializeEngines();

    39

void InitializeOrders();

    40

void InitializeClearLand();

    41

void InitializeRailGui();

    42

void InitializeRoadGui();

    43

void InitializeAirportGui();

    44

void InitializeDockGui();

    45

void InitializeIndustries();

    46

void InitializeMainGui();

    47

void InitializeTowns();

    48

void InitializeTrees();

    49

void InitializeSigns();

    50

void InitializeStations();

    51

void InitializeCargoPackets();

    52

static void InitializeNameMgr();

    53

void InitializePlayers();

    54

static void InitializeCheats();

    55

void InitializeNPF();

    56

    57

void InitializeGame(int mode, uint size_x, uint size_y)

    58

{

    59

	AllocateMap(size_x, size_y);

    60

    61

	SetObjectToPlace(SPR_CURSOR_ZZZ, PAL_NONE, VHM_NONE, WC_MAIN_WINDOW, 0);

    62

    63

	_pause_game = 0;

    64

	_fast_forward = 0;

    65

	_tick_counter = 0;

    66

	_realtime_tick = 0;

    67

	_date_fract = 0;

    68

	_cur_tileloop_tile = 0;

    69

    70

	if ((mode & IG_DATE_RESET) == IG_DATE_RESET) {

    71

		SetDate(ConvertYMDToDate(_patches.starting_year, 0, 1));

    72

	}

    73

    74

	InitializeEngines();

    75

	InitializeVehicles();

    76

	InitializeWaypoints();

    77

	InitializeDepots();

    78

	InitializeOrders();

    79

	InitializeGroup();

    80

    81

	InitNewsItemStructs();

    82

	InitializeLandscape();

    83

	InitializeClearLand();

    84

	InitializeRailGui();

    85

	InitializeRoadGui();

    86

	InitializeAirportGui();

    87

	InitializeDockGui();

    88

	InitializeTowns();

    89

	InitializeTrees();

    90

	InitializeSigns();

    91

	InitializeStations();

    92

	InitializeCargoPackets();

    93

	InitializeIndustries();

    94

	InitializeBuildingCounts();

    95

	InitializeMainGui();

    96

    97

	InitializeNameMgr();

    98

	InitializeVehiclesGuiList();

    99

	InitializeTrains();

   100

	InitializeNPF();

   101

   102

	AI_Initialize();

   103

	InitializePlayers();

   104

	InitializeCheats();

   105

   106

	InitTextEffects();

   107

	InitChatMessage();

   108

	InitializeAnimatedTiles();

   109

   110

	InitializeLandscapeVariables(false);

   111

   112

	ResetObjectToPlace();

   113

}

   114

   115

bool IsCustomName(StringID id)

   116

{

   117

	return GB(id, 11, 5) == 15;

   118

}

   119

   120

   121

static void InitializeCheats()

   122

{

   123

	memset(&_cheats, 0, sizeof(Cheats));

   124

}

   125

   126

   127

static void InitializeNameMgr()

   128

{

   129

	memset(_name_array, 0, sizeof(_name_array));

   130

}

   131

   132

/* Copy and convert old custom names to UTF-8 */

   133

char *CopyFromOldName(StringID id)

   134

{

   135

	if (!IsCustomName(id)) return NULL;

   136

   137

	if (CheckSavegameVersion(37)) {

   138

		/* Old names were 32 characters long, so 128 characters should be

   139

		 * plenty to allow for expansion when converted to UTF-8. */

   140

		char tmp[128];

   141

		const char *strfrom = _name_array[GB(id, 0, 9)];

   142

		char *strto = tmp;

   143

   144

		for (; *strfrom != '\0'; strfrom++) {

   145

			WChar c = (byte)*strfrom;

   146

   147

			/* Map from non-ISO8859-15 characters to UTF-8. */

   148

			switch (c) {

   149

				case 0xA4: c = 0x20AC; break; // Euro

   150

				case 0xA6: c = 0x0160; break; // S with caron

   151

				case 0xA8: c = 0x0161; break; // s with caron

   152

				case 0xB4: c = 0x017D; break; // Z with caron

   153

				case 0xB8: c = 0x017E; break; // z with caron

   154

				case 0xBC: c = 0x0152; break; // OE ligature

   155

				case 0xBD: c = 0x0153; break; // oe ligature

   156

				case 0xBE: c = 0x0178; break; // Y with diaresis

   157

				default: break;

   158

			}

   159

   160

			/* Check character will fit into our buffer. */

   161

			if (strto + Utf8CharLen(c) > lastof(tmp)) break;

   162

   163

			strto += Utf8Encode(strto, c);

   164

		}

   165

   166

		/* Terminate the new string and copy it back to the name array */

   167

		*strto = '\0';

   168

   169

		return strdup(tmp);

   170

	} else {

   171

		/* Name will already be in UTF-8. */

   172

		return strdup(_name_array[GB(id, 0, 9)]);

   173

	}

   174

}

   175

   176

/* Calculate constants that depend on the landscape type. */

   177

void InitializeLandscapeVariables(bool only_constants)

   178

{

   179

	if (only_constants) return;

   180

   181

	for (CargoID i = 0; i < NUM_CARGO; i++) {

   182

		_cargo_payment_rates[i] = GetCargo(i)->initial_payment;

   183

		_cargo_payment_rates_frac[i] = 0;

   184

	}

   185

}

   186

   187

static void Load_NAME()

   188

{

   189

	int index;

   190

   191

	while ((index = SlIterateArray()) != -1) {

   192

		SlArray(_name_array[index], SlGetFieldLength(), SLE_UINT8);

   193

	}

   194

}

   195

   196

static const SaveLoadGlobVarList _date_desc[] = {

   197

	SLEG_CONDVAR(_date,                   SLE_FILE_U16 | SLE_VAR_I32,  0,  30),

   198

	SLEG_CONDVAR(_date,                   SLE_INT32,                  31, SL_MAX_VERSION),

   199

	    SLEG_VAR(_date_fract,             SLE_UINT16),

   200

	    SLEG_VAR(_tick_counter,           SLE_UINT16),

   201

	    SLEG_VAR(_vehicle_id_ctr_day,     SLE_UINT16),

   202

	    SLEG_VAR(_age_cargo_skip_counter, SLE_UINT8),

   203

	SLE_CONDNULL(1, 0, 45),

   204

	SLEG_CONDVAR(_cur_tileloop_tile,      SLE_FILE_U16 | SLE_VAR_U32,  0, 5),

   205

	SLEG_CONDVAR(_cur_tileloop_tile,      SLE_UINT32,                  6, SL_MAX_VERSION),

   206

	    SLEG_VAR(_disaster_delay,         SLE_UINT16),

   207

	    SLEG_VAR(_station_tick_ctr,       SLE_UINT16),

   208

	    SLEG_VAR(_random.state[0],        SLE_UINT32),

   209

	    SLEG_VAR(_random.state[1],        SLE_UINT32),

   210

	SLEG_CONDVAR(_cur_town_ctr,           SLE_FILE_U8  | SLE_VAR_U32,  0, 9),

   211

	SLEG_CONDVAR(_cur_town_ctr,           SLE_UINT32,                 10, SL_MAX_VERSION),

   212

	    SLEG_VAR(_cur_player_tick_index,  SLE_FILE_U8  | SLE_VAR_U32),

   213

	    SLEG_VAR(_next_competitor_start,  SLE_FILE_U16 | SLE_VAR_U32),

   214

	    SLEG_VAR(_trees_tick_ctr,         SLE_UINT8),

   215

	SLEG_CONDVAR(_pause_game,             SLE_UINT8,                   4, SL_MAX_VERSION),

   216

	SLEG_CONDVAR(_cur_town_iter,          SLE_UINT32,                 11, SL_MAX_VERSION),

   217

	    SLEG_END()

   218

};

   219

   220

/* Save load date related variables as well as persistent tick counters

   221

 * XXX: currently some unrelated stuff is just put here */

   222

static void SaveLoad_DATE()

   223

{

   224

	SlGlobList(_date_desc);

   225

}

   226

   227

   228

static const SaveLoadGlobVarList _view_desc[] = {

   229

	SLEG_CONDVAR(_saved_scrollpos_x,    SLE_FILE_I16 | SLE_VAR_I32, 0, 5),

   230

	SLEG_CONDVAR(_saved_scrollpos_x,    SLE_INT32,                  6, SL_MAX_VERSION),

   231

	SLEG_CONDVAR(_saved_scrollpos_y,    SLE_FILE_I16 | SLE_VAR_I32, 0, 5),

   232

	SLEG_CONDVAR(_saved_scrollpos_y,    SLE_INT32,                  6, SL_MAX_VERSION),

   233

	    SLEG_VAR(_saved_scrollpos_zoom, SLE_UINT8),

   234

	    SLEG_END()

   235

};

   236

   237

static void SaveLoad_VIEW()

   238

{

   239

	SlGlobList(_view_desc);

   240

}

   241

   242

static uint32 _map_dim_x;

   243

static uint32 _map_dim_y;

   244

   245

static const SaveLoadGlobVarList _map_dimensions[] = {

   246

	SLEG_CONDVAR(_map_dim_x, SLE_UINT32, 6, SL_MAX_VERSION),

   247

	SLEG_CONDVAR(_map_dim_y, SLE_UINT32, 6, SL_MAX_VERSION),

   248

	    SLEG_END()

   249

};

   250

   251

static void Save_MAPS()

   252

{

   253

	_map_dim_x = MapSizeX();

   254

	_map_dim_y = MapSizeY();

   255

	SlGlobList(_map_dimensions);

   256

}

   257

   258

static void Load_MAPS()

   259

{

   260

	SlGlobList(_map_dimensions);

   261

	AllocateMap(_map_dim_x, _map_dim_y);

   262

}

   263

   264

enum {

   265

	MAP_SL_BUF_SIZE = 4096

   266

};

   267

   268

static void Load_MAPT()

   269

{

   270

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   271

	TileIndex size = MapSize();

   272

   273

	for (TileIndex i = 0; i != size;) {

   274

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   275

		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) _m[i++].type_height = buf[j];

   276

	}

   277

}

   278

   279

static void Save_MAPT()

   280

{

   281

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   282

	TileIndex size = MapSize();

   283

   284

	SlSetLength(size);

   285

	for (TileIndex i = 0; i != size;) {

   286

		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) buf[j] = _m[i++].type_height;

   287

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   288

	}

   289

}

   290

   291

static void Load_MAP1()

   292

{

   293

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   294

	TileIndex size = MapSize();

   295

   296

	for (TileIndex i = 0; i != size;) {

   297

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   298

		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) _m[i++].m1 = buf[j];

   299

	}

   300

}

   301

   302

static void Save_MAP1()

   303

{

   304

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   305

	TileIndex size = MapSize();

   306

   307

	SlSetLength(size);

   308

	for (TileIndex i = 0; i != size;) {

   309

		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) buf[j] = _m[i++].m1;

   310

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   311

	}

   312

}

   313

   314

static void Load_MAP2()

   315

{

   316

	SmallStackSafeStackAlloc<uint16, MAP_SL_BUF_SIZE> buf;

   317

	TileIndex size = MapSize();

   318

   319

	for (TileIndex i = 0; i != size;) {

   320

		SlArray(buf, MAP_SL_BUF_SIZE,

   321

			/* In those versions the m2 was 8 bits */

   322

			CheckSavegameVersion(5) ? SLE_FILE_U8 | SLE_VAR_U16 : SLE_UINT16

   323

		);

   324

		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) _m[i++].m2 = buf[j];

   325

	}

   326

}

   327

   328

static void Save_MAP2()

   329

{

   330

	SmallStackSafeStackAlloc<uint16, MAP_SL_BUF_SIZE> buf;

   331

	TileIndex size = MapSize();

   332

   333

	SlSetLength(size * sizeof(uint16));

   334

	for (TileIndex i = 0; i != size;) {

   335

		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) buf[j] = _m[i++].m2;

   336

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT16);

   337

	}

   338

}

   339

   340

static void Load_MAP3()

   341

{

   342

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   343

	TileIndex size = MapSize();

   344

   345

	for (TileIndex i = 0; i != size;) {

   346

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   347

		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) _m[i++].m3 = buf[j];

   348

	}

   349

}

   350

   351

static void Save_MAP3()

   352

{

   353

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   354

	TileIndex size = MapSize();

   355

   356

	SlSetLength(size);

   357

	for (TileIndex i = 0; i != size;) {

   358

		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) buf[j] = _m[i++].m3;

   359

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   360

	}

   361

}

   362

   363

static void Load_MAP4()

   364

{

   365

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   366

	TileIndex size = MapSize();

   367

   368

	for (TileIndex i = 0; i != size;) {

   369

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   370

		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) _m[i++].m4 = buf[j];

   371

	}

   372

}

   373

   374

static void Save_MAP4()

   375

{

   376

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   377

	TileIndex size = MapSize();

   378

   379

	SlSetLength(size);

   380

	for (TileIndex i = 0; i != size;) {

   381

		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) buf[j] = _m[i++].m4;

   382

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   383

	}

   384

}

   385

   386

static void Load_MAP5()

   387

{

   388

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   389

	TileIndex size = MapSize();

   390

   391

	for (TileIndex i = 0; i != size;) {

   392

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   393

		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) _m[i++].m5 = buf[j];

   394

	}

   395

}

   396

   397

static void Save_MAP5()

   398

{

   399

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   400

	TileIndex size = MapSize();

   401

   402

	SlSetLength(size);

   403

	for (TileIndex i = 0; i != size;) {

   404

		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) buf[j] = _m[i++].m5;

   405

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   406

	}

   407

}

   408

   409

static void Load_MAP6()

   410

{

   411

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   412

	TileIndex size = MapSize();

   413

   414

	if (CheckSavegameVersion(42)) {

   415

		for (TileIndex i = 0; i != size;) {

   416

			/* 1024, otherwise we overflow on 64x64 maps! */

   417

			SlArray(buf, 1024, SLE_UINT8);

   418

			for (uint j = 0; j != 1024; j++) {

   419

				_m[i++].m6 = GB(buf[j], 0, 2);

   420

				_m[i++].m6 = GB(buf[j], 2, 2);

   421

				_m[i++].m6 = GB(buf[j], 4, 2);

   422

				_m[i++].m6 = GB(buf[j], 6, 2);

   423

			}

   424

		}

   425

	} else {

   426

		for (TileIndex i = 0; i != size;) {

   427

			SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   428

			for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) _m[i++].m6 = buf[j];

   429

		}

   430

	}

   431

}

   432

   433

static void Save_MAP6()

   434

{

   435

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   436

	TileIndex size = MapSize();

   437

   438

	SlSetLength(size);

   439

	for (TileIndex i = 0; i != size;) {

   440

		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) buf[j] = _m[i++].m6;

   441

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   442

	}

   443

}

   444

   445

static void Load_MAP7()

   446

{

   447

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   448

	TileIndex size = MapSize();

   449

   450

	for (TileIndex i = 0; i != size;) {

   451

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   452

		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) _me[i++].m7 = buf[j];

   453

	}

   454

}

   455

   456

static void Save_MAP7()

   457

{

   458

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   459

	TileIndex size = MapSize();

   460

   461

	SlSetLength(size);

   462

	for (TileIndex i = 0; i != size;) {

   463

		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) buf[j] = _me[i++].m7;

   464

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   465

	}

   466

}

   467

   468

static void Save_CHTS()

   469

{

   470

	byte count = sizeof(_cheats)/sizeof(Cheat);

   471

	Cheat* cht = (Cheat*) &_cheats;

   472

	Cheat* cht_last = &cht[count];

   473

   474

	SlSetLength(count * 2);

   475

	for (; cht != cht_last; cht++) {

   476

		SlWriteByte(cht->been_used);

   477

		SlWriteByte(cht->value);

   478

	}

   479

}

   480

   481

static void Load_CHTS()

   482

{

   483

	Cheat* cht = (Cheat*)&_cheats;

   484

	uint count = SlGetFieldLength() / 2;

   485

   487

		cht[i].been_used = (SlReadByte() != 0);