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.h"

    10

#include "saveload.h"

    11

#include "engine.h"

    12

#include "vehicle_gui.h"

    13

#include "variables.h"

    14

#include "ai/ai.h"

    15

#include "newgrf_house.h"

    16

#include "cargotype.h"

    17

#include "group.h"

    18

#include "viewport_func.h"

    19

#include "economy_func.h"

    20

#include "zoom_func.h"

    21

#include "functions.h"

    22

#include "map_func.h"

    23

#include "date_func.h"

    24

#include "vehicle_func.h"

    25

#include "texteff.hpp"

    26

#include "string_func.h"

    27

#include "gfx_func.h"

    28

    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_seeds[0][0],     SLE_UINT32),

   208

	    SLEG_VAR(_random_seeds[0][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

static void Load_MAPT()

   264

{

   265

	uint size = MapSize();

   266

	uint i;

   267

   268

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

   269

		byte buf[4096];

   270

		uint j;

   271

   272

		SlArray(buf, lengthof(buf), SLE_UINT8);

   273

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

   274

	}

   275

}

   276

   277

static void Save_MAPT()

   278

{

   279

	uint size = MapSize();

   280

	uint i;

   281

   282

	SlSetLength(size);

   283

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

   284

		byte buf[4096];

   285

		uint j;

   286

   287

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

   288

		SlArray(buf, lengthof(buf), SLE_UINT8);

   289

	}

   290

}

   291

   292

static void Load_MAP1()

   293

{

   294

	uint size = MapSize();

   295

	uint i;

   296

   297

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

   298

		byte buf[4096];

   299

		uint j;

   300

   301

		SlArray(buf, lengthof(buf), SLE_UINT8);

   302

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

   303

	}

   304

}

   305

   306

static void Save_MAP1()

   307

{

   308

	uint size = MapSize();

   309

	uint i;

   310

   311

	SlSetLength(size);

   312

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

   313

		byte buf[4096];

   314

		uint j;

   315

   316

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

   317

		SlArray(buf, lengthof(buf), SLE_UINT8);

   318

	}

   319

}

   320

   321

static void Load_MAP2()

   322

{

   323

	uint size = MapSize();

   324

	uint i;

   325

   326

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

   327

		uint16 buf[4096];

   328

		uint j;

   329

   330

		SlArray(buf, lengthof(buf),

   331

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

   332

			CheckSavegameVersion(5) ? SLE_FILE_U8 | SLE_VAR_U16 : SLE_UINT16

   333

		);

   334

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

   335

	}

   336

}

   337

   338

static void Save_MAP2()

   339

{

   340

	uint size = MapSize();

   341

	uint i;

   342

   343

	SlSetLength(size * sizeof(_m[0].m2));

   344

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

   345

		uint16 buf[4096];

   346

		uint j;

   347

   348

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

   349

		SlArray(buf, lengthof(buf), SLE_UINT16);

   350

	}

   351

}

   352

   353

static void Load_MAP3()

   354

{

   355

	uint size = MapSize();

   356

	uint i;

   357

   358

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

   359

		byte buf[4096];

   360

		uint j;

   361

   362

		SlArray(buf, lengthof(buf), SLE_UINT8);

   363

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

   364

	}

   365

}

   366

   367

static void Save_MAP3()

   368

{

   369

	uint size = MapSize();

   370

	uint i;

   371

   372

	SlSetLength(size);

   373

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

   374

		byte buf[4096];

   375

		uint j;

   376

   377

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

   378

		SlArray(buf, lengthof(buf), SLE_UINT8);

   379

	}

   380

}

   381

   382

static void Load_MAP4()

   383

{

   384

	uint size = MapSize();

   385

	uint i;

   386

   387

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

   388

		byte buf[4096];

   389

		uint j;

   390

   391

		SlArray(buf, lengthof(buf), SLE_UINT8);

   392

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

   393

	}

   394

}

   395

   396

static void Save_MAP4()

   397

{

   398

	uint size = MapSize();

   399

	uint i;

   400

   401

	SlSetLength(size);

   402

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

   403

		byte buf[4096];

   404

		uint j;

   405

   406

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

   407

		SlArray(buf, lengthof(buf), SLE_UINT8);

   408

	}

   409

}

   410

   411

static void Load_MAP5()

   412

{

   413

	uint size = MapSize();

   414

	uint i;

   415

   416

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

   417

		byte buf[4096];

   418

		uint j;

   419

   420

		SlArray(buf, lengthof(buf), SLE_UINT8);

   421

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

   422

	}

   423

}

   424

   425

static void Save_MAP5()

   426

{

   427

	uint size = MapSize();

   428

	uint i;

   429

   430

	SlSetLength(size);

   431

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

   432

		byte buf[4096];

   433

		uint j;

   434

   435

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

   436

		SlArray(buf, lengthof(buf), SLE_UINT8);

   437

	}

   438

}

   439

   440

static void Load_MAP6()

   441

{

   442

	/* Still available for loading old games */

   443

	uint size = MapSize();

   444

	uint i;

   445

   446

	if (CheckSavegameVersion(42)) {

   447

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

   448

			uint8 buf[1024];

   449

			uint j;

   450

   451

			SlArray(buf, lengthof(buf), SLE_UINT8);

   452

			for (j = 0; j != lengthof(buf); j++) {

   453

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

   454

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

   455

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

   456

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

   457

			}

   458

		}

   459

	} else {

   460

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

   461

			byte buf[4096];

   462

			uint j;

   463

   464

			SlArray(buf, lengthof(buf), SLE_UINT8);

   465

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

   466

		}

   467

	}

   468

}

   469

   470

static void Save_MAP6()

   471

{

   472

	uint size = MapSize();

   473

	uint i;

   474

   475

	SlSetLength(size);

   476

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

   477

		uint8 buf[4096];

   478

		uint j;

   479

   480

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

   481

		SlArray(buf, lengthof(buf), SLE_UINT8);

   482

	}

   483

}

   484

   485

static void Load_MAP7()

   486

{

   487

	uint size = MapSize();

   488

	uint i;

   489