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

    29

#include "table/strings.h"

    30

#include "table/sprites.h"

    31

    32

char _name_array[512][32];

    33

    34

void InitializeVehicles();

    35

void InitializeWaypoints();

    36

void InitializeDepots();

    37

void InitializeEngines();

    38

void InitializeOrders();

    39

void InitializeClearLand();

    40

void InitializeRailGui();

    41

void InitializeRoadGui();

    42

void InitializeAirportGui();

    43

void InitializeDockGui();

    44

void InitializeIndustries();

    45

void InitializeMainGui();

    46

void InitializeTowns();

    47

void InitializeTrees();

    48

void InitializeSigns();

    49

void InitializeStations();

    50

void InitializeCargoPackets();

    51

static void InitializeNameMgr();

    52

void InitializePlayers();

    53

static void InitializeCheats();

    54

void InitializeNPF();

    55

    56

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

    57

{

    58

	AllocateMap(size_x, size_y);

    59

    60

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

    61

    62

	_pause_game = 0;

    63

	_fast_forward = 0;

    64

	_tick_counter = 0;

    65

	_realtime_tick = 0;

    66

	_date_fract = 0;

    67

	_cur_tileloop_tile = 0;

    68

    69

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

    70

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

    71

	}

    72

    73

	InitializeEngines();

    74

	InitializeVehicles();

    75

	InitializeWaypoints();

    76

	InitializeDepots();

    77

	InitializeOrders();

    78

	InitializeGroup();

    79

    80

	InitNewsItemStructs();

    81

	InitializeLandscape();

    82

	InitializeClearLand();

    83

	InitializeRailGui();

    84

	InitializeRoadGui();

    85

	InitializeAirportGui();

    86

	InitializeDockGui();

    87

	InitializeTowns();

    88

	InitializeTrees();

    89

	InitializeSigns();

    90

	InitializeStations();

    91

	InitializeCargoPackets();

    92

	InitializeIndustries();

    93

	InitializeBuildingCounts();

    94

	InitializeMainGui();

    95

    96

	InitializeNameMgr();

    97

	InitializeVehiclesGuiList();

    98

	InitializeTrains();

    99

	InitializeNPF();

   100

   101

	AI_Initialize();

   102

	InitializePlayers();

   103

	InitializeCheats();

   104

   105

	InitTextEffects();

   106

	InitChatMessage();

   107

	InitializeAnimatedTiles();

   108

   109

	InitializeLandscapeVariables(false);

   110

   111

	ResetObjectToPlace();

   112

}

   113

   114

bool IsCustomName(StringID id)

   115

{

   116

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

   117

}

   118

   119

   120

static void InitializeCheats()

   121

{

   122

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

   123

}

   124

   125

   126

static void InitializeNameMgr()

   127

{

   128

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

   129

}

   130

   131

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

   132

char *CopyFromOldName(StringID id)

   133

{

   134

	if (!IsCustomName(id)) return NULL;

   135

   136

	if (CheckSavegameVersion(37)) {

   137

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

   138

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

   139

		char tmp[128];

   140

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

   141

		char *strto = tmp;

   142

   143

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

   144

			WChar c = (byte)*strfrom;

   145

   146

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

   147

			switch (c) {

   148

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

   149

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

   150

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

   151

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

   152

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

   153

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

   154

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

   155

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

   156

				default: break;

   157

			}

   158

   159

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

   160

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

   161

   162

			strto += Utf8Encode(strto, c);

   163

		}

   164

   165

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

   166

		*strto = '\0';

   167

   168

		return strdup(tmp);

   169

	} else {

   170

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

   171

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

   172

	}

   173

}

   174

   175

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

   176

void InitializeLandscapeVariables(bool only_constants)

   177

{

   178

	if (only_constants) return;

   179

   180

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

   181

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

   182

		_cargo_payment_rates_frac[i] = 0;

   183

	}

   184

}

   185

   186

static void Load_NAME()

   187

{

   188

	int index;

   189

   190

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

   191

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

   192

	}

   193

}

   194

   195

static const SaveLoadGlobVarList _date_desc[] = {

   196

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

   197

	SLEG_CONDVAR(_date,                   SLE_INT32,                  31, SL_MAX_VERSION),

   198

	    SLEG_VAR(_date_fract,             SLE_UINT16),

   199

	    SLEG_VAR(_tick_counter,           SLE_UINT16),

   200

	    SLEG_VAR(_vehicle_id_ctr_day,     SLE_UINT16),

   201

	    SLEG_VAR(_age_cargo_skip_counter, SLE_UINT8),

   202

	SLE_CONDNULL(1, 0, 45),

   203

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

   204

	SLEG_CONDVAR(_cur_tileloop_tile,      SLE_UINT32,                  6, SL_MAX_VERSION),

   205

	    SLEG_VAR(_disaster_delay,         SLE_UINT16),

   206

	    SLEG_VAR(_station_tick_ctr,       SLE_UINT16),

   207

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

   208

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

   209

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

   210

	SLEG_CONDVAR(_cur_town_ctr,           SLE_UINT32,                 10, SL_MAX_VERSION),

   211

	    SLEG_VAR(_cur_player_tick_index,  SLE_FILE_U8  | SLE_VAR_U32),

   212

	    SLEG_VAR(_next_competitor_start,  SLE_FILE_U16 | SLE_VAR_U32),

   213

	    SLEG_VAR(_trees_tick_ctr,         SLE_UINT8),

   214

	SLEG_CONDVAR(_pause_game,             SLE_UINT8,                   4, SL_MAX_VERSION),

   215

	SLEG_CONDVAR(_cur_town_iter,          SLE_UINT32,                 11, SL_MAX_VERSION),

   216

	    SLEG_END()

   217

};

   218

   219

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

   220

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

   221

static void SaveLoad_DATE()

   222

{

   223

	SlGlobList(_date_desc);

   224

}

   225

   226

   227

static const SaveLoadGlobVarList _view_desc[] = {

   228

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

   229

	SLEG_CONDVAR(_saved_scrollpos_x,    SLE_INT32,                  6, SL_MAX_VERSION),

   230

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

   231

	SLEG_CONDVAR(_saved_scrollpos_y,    SLE_INT32,                  6, SL_MAX_VERSION),

   232

	    SLEG_VAR(_saved_scrollpos_zoom, SLE_UINT8),

   233

	    SLEG_END()

   234

};

   235

   236

static void SaveLoad_VIEW()

   237

{

   238

	SlGlobList(_view_desc);

   239

}

   240

   241

static uint32 _map_dim_x;

   242

static uint32 _map_dim_y;

   243

   244

static const SaveLoadGlobVarList _map_dimensions[] = {

   245

	SLEG_CONDVAR(_map_dim_x, SLE_UINT32, 6, SL_MAX_VERSION),

   246

	SLEG_CONDVAR(_map_dim_y, SLE_UINT32, 6, SL_MAX_VERSION),

   247

	    SLEG_END()

   248

};

   249

   250

static void Save_MAPS()

   251

{

   252

	_map_dim_x = MapSizeX();

   253

	_map_dim_y = MapSizeY();

   254

	SlGlobList(_map_dimensions);

   255

}

   256

   257

static void Load_MAPS()

   258

{

   259

	SlGlobList(_map_dimensions);

   260

	AllocateMap(_map_dim_x, _map_dim_y);

   261

}

   262

   263

enum {

   264

	MAP_SL_BUF_SIZE = 4096

   265

};

   266

   267

static void Load_MAPT()

   268

{

   269

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   270

	TileIndex size = MapSize();

   271

   272

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

   273

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   274

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

   275

	}

   276

}

   277

   278

static void Save_MAPT()

   279

{

   280

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   281

	TileIndex size = MapSize();

   282

   283

	SlSetLength(size);

   284

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

   285

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

   286

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   287

	}

   288

}

   289

   290

static void Load_MAP1()

   291

{

   292

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   293

	TileIndex size = MapSize();

   294

   295

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

   296

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   297

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

   298

	}

   299

}

   300

   301

static void Save_MAP1()

   302

{

   303

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   304

	TileIndex size = MapSize();

   305

   306

	SlSetLength(size);

   307

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

   308

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

   309

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   310

	}

   311

}

   312

   313

static void Load_MAP2()

   314

{

   315

	SmallStackSafeStackAlloc<uint16, MAP_SL_BUF_SIZE> buf;

   316

	TileIndex size = MapSize();

   317

   318

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

   319

		SlArray(buf, MAP_SL_BUF_SIZE,

   320

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

   321

			CheckSavegameVersion(5) ? SLE_FILE_U8 | SLE_VAR_U16 : SLE_UINT16

   322

		);

   323

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

   324

	}

   325

}

   326

   327

static void Save_MAP2()

   328

{

   329

	SmallStackSafeStackAlloc<uint16, MAP_SL_BUF_SIZE> buf;

   330

	TileIndex size = MapSize();

   331

   332

	SlSetLength(size * sizeof(uint16));

   333

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

   334

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

   335

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT16);

   336

	}

   337

}

   338

   339

static void Load_MAP3()

   340

{

   341

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   342

	TileIndex size = MapSize();

   343

   344

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

   345

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   346

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

   347

	}

   348

}

   349

   350

static void Save_MAP3()

   351

{

   352

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   353

	TileIndex size = MapSize();

   354

   355

	SlSetLength(size);

   356

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

   357

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

   358

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   359

	}

   360

}

   361

   362

static void Load_MAP4()

   363

{

   364

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   365

	TileIndex size = MapSize();

   366

   367

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

   368

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   369

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

   370

	}

   371

}

   372

   373

static void Save_MAP4()

   374

{

   375

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   376

	TileIndex size = MapSize();

   377

   378

	SlSetLength(size);

   379

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

   380

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

   381

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   382

	}

   383

}

   384

   385

static void Load_MAP5()

   386

{

   387

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   388

	TileIndex size = MapSize();

   389

   390

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

   391

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   392

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

   393

	}

   394

}

   395

   396

static void Save_MAP5()

   397

{

   398

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   399

	TileIndex size = MapSize();

   400

   401

	SlSetLength(size);

   402

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

   403

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

   404

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   405

	}

   406

}

   407

   408

static void Load_MAP6()

   409

{

   410

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   411

	TileIndex size = MapSize();

   412

   413

	if (CheckSavegameVersion(42)) {

   414

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

   415

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

   416

			SlArray(buf, 1024, SLE_UINT8);

   417

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

   418

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

   419

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

   420

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

   421

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

   422

			}

   423

		}

   424

	} else {

   425

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

   426

			SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   427

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

   428

		}

   429

	}

   430

}

   431

   432

static void Save_MAP6()

   433

{

   434

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   435

	TileIndex size = MapSize();

   436

   437

	SlSetLength(size);

   438

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

   439

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

   440

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   441

	}

   442

}

   443

   444

static void Load_MAP7()

   445

{

   446

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   447

	TileIndex size = MapSize();

   448

   449

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

   450

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   451

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

   452

	}

   453

}

   454

   455

static void Save_MAP7()

   456

{

   457

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   458

	TileIndex size = MapSize();

   459

   460

	SlSetLength(size);

   461

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

   462

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

   463

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   464

	}

   465

}

   466

   467

static void Save_CHTS()

   468

{

   469

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

   470

	Cheat* cht = (Cheat*) &_cheats;

   471

	Cheat* cht_last = &cht[count];

   472

   473

	SlSetLength(count * 2);

   474

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

   475

		SlWriteByte(cht->been_used);

   476

		SlWriteByte(cht->value);

   477

	}

   478

}

   479

   480

static void Load_CHTS()

   481

{

   482

	Cheat* cht = (Cheat*)&_cheats;

   483

	uint count = SlGetFieldLength() / 2;

   484

   485

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

   486

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

   487