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

    11

#include "string.h"

    12

#include "table/strings.h"

    13

#include "table/sprites.h"

    14

#include "saveload.h"

    15

#include "engine.h"

    16

#include "vehicle_gui.h"

    17

#include "variables.h"

    18

#include "ai/ai.h"

    19

#include "newgrf_house.h"

    20

#include "cargotype.h"

    21

#include "group.h"

    22

#include "viewport.h"

    23

#include "economy_func.h"

    24

#include "zoom_func.h"

    25

#include "functions.h"

    26

#include "map_func.h"

    27

#include "date_func.h"

    30

    31

char _name_array[512][32];

    32

    33

void InitializeVehicles();

    34

void InitializeWaypoints();

    35

void InitializeDepots();

    36

void InitializeEngines();

    37

void InitializeOrders();

    38

void InitializeClearLand();

    39

void InitializeRailGui();

    40

void InitializeRoadGui();

    41

void InitializeAirportGui();

    42

void InitializeDockGui();

    43

void InitializeIndustries();

    44

void InitializeMainGui();

    45

void InitializeTowns();

    46

void InitializeTrees();

    47

void InitializeSigns();

    48

void InitializeStations();

    49

void InitializeCargoPackets();

    50

static void InitializeNameMgr();

    51

void InitializePlayers();

    52

static void InitializeCheats();

    53

void InitializeNPF();

    54

    55

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

    56

{

    57

	AllocateMap(size_x, size_y);

    58

    59

	AddTypeToEngines(); // make sure all engines have a type

    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

void DeleteName(StringID id)

   121

{

   122

	if (IsCustomName(id)) {

   123

		memset(_name_array[id & 0x1FF], 0, sizeof(_name_array[id & 0x1FF]));

   124

	}

   125

}

   126

   127

char *GetName(char *buff, StringID id, const char* last)

   128

{

   129

	return strecpy(buff, _name_array[id & ~0x600], last);

   130

}

   131

   132

   133

static void InitializeCheats()

   134

{

   135

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

   136

}

   137

   138

   139

static void InitializeNameMgr()

   140

{

   141

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

   142

}

   143

   144

StringID RealAllocateName(const char *name, byte skip, bool check_double)

   145

{

   146

	char (*free_item)[lengthof(*_name_array)] = NULL;

   147

	char (*i)[lengthof(*_name_array)];

   148

   149

	for (i = _name_array; i != endof(_name_array); ++i) {

   150

		if ((*i)[0] == '\0') {

   151

			if (free_item == NULL) free_item = i;

   152

		} else if (check_double && strncmp(*i, name, lengthof(*i) - 1) == 0) {

   153

			_error_message = STR_0132_CHOSEN_NAME_IN_USE_ALREADY;

   154

			return 0;

   155

		}

   156

	}

   157

   158

	if (free_item != NULL) {

   159

		ttd_strlcpy(*free_item, name, lengthof(*free_item));

   160

		return (free_item - _name_array) | 0x7800 | (skip << 8);

   161

	} else {

   162

		_error_message = STR_0131_TOO_MANY_NAMES_DEFINED;

   163

		return 0;

   164

	}

   165

}

   166

   167

void ConvertNameArray()

   168

{

   169

	uint i;

   170

   171

	for (i = 0; i < lengthof(_name_array); i++) {

   172

		const char *strfrom = _name_array[i];

   173

		char tmp[sizeof(*_name_array)];

   174

		char *strto = tmp;

   175

   176

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

   177

			WChar c = (byte)*strfrom;

   178

			switch (c) {

   179

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

   180

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

   181

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

   182

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

   183

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

   184

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

   185

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

   186

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

   187

				default: break;

   188

			}

   189

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

   190

			strto += Utf8Encode(strto, c);

   191

		}

   192

   193

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

   194

		*strto = '\0';

   195

		memcpy(_name_array[i], tmp, sizeof(*_name_array));

   196

	}

   197

}

   198

   199

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

   200

void InitializeLandscapeVariables(bool only_constants)

   201

{

   202

	if (only_constants) return;

   203

   204

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

   205

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

   206

		_cargo_payment_rates_frac[i] = 0;

   207

	}

   208

}

   209

   210

   211

static void Save_NAME()

   212

{

   213

	int i;

   214

   215

	for (i = 0; i != lengthof(_name_array); ++i) {

   216

		if (_name_array[i][0] != '\0') {

   217

			SlSetArrayIndex(i);

   218

			SlArray(_name_array[i], (uint)strlen(_name_array[i]), SLE_UINT8);

   219

		}

   220

	}

   221

}

   222

   223

static void Load_NAME()

   224

{

   225

	int index;

   226

   227

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

   228

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

   229

	}

   230

}

   231

   232

static const SaveLoadGlobVarList _date_desc[] = {

   233

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

   234

	SLEG_CONDVAR(_date,                   SLE_INT32,                  31, SL_MAX_VERSION),

   235

	    SLEG_VAR(_date_fract,             SLE_UINT16),

   236

	    SLEG_VAR(_tick_counter,           SLE_UINT16),

   237

	    SLEG_VAR(_vehicle_id_ctr_day,     SLE_UINT16),

   238

	    SLEG_VAR(_age_cargo_skip_counter, SLE_UINT8),

   239

	SLE_CONDNULL(1, 0, 45),

   240

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

   241

	SLEG_CONDVAR(_cur_tileloop_tile,      SLE_UINT32,                  6, SL_MAX_VERSION),

   242

	    SLEG_VAR(_disaster_delay,         SLE_UINT16),

   243

	    SLEG_VAR(_station_tick_ctr,       SLE_UINT16),

   244

	    SLEG_VAR(_random_seeds[0][0],     SLE_UINT32),

   245

	    SLEG_VAR(_random_seeds[0][1],     SLE_UINT32),

   246

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

   247

	SLEG_CONDVAR(_cur_town_ctr,           SLE_UINT32,                 10, SL_MAX_VERSION),

   248

	    SLEG_VAR(_cur_player_tick_index,  SLE_FILE_U8  | SLE_VAR_U32),

   249

	    SLEG_VAR(_next_competitor_start,  SLE_FILE_U16 | SLE_VAR_U32),

   250

	    SLEG_VAR(_trees_tick_ctr,         SLE_UINT8),

   251

	SLEG_CONDVAR(_pause_game,             SLE_UINT8,                   4, SL_MAX_VERSION),

   252

	SLEG_CONDVAR(_cur_town_iter,          SLE_UINT32,                 11, SL_MAX_VERSION),

   253

	    SLEG_END()

   254

};

   255

   256

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

   257

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

   258

static void SaveLoad_DATE()

   259

{

   260

	SlGlobList(_date_desc);

   261

}

   262

   263

   264

static const SaveLoadGlobVarList _view_desc[] = {

   265

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

   266

	SLEG_CONDVAR(_saved_scrollpos_x,    SLE_INT32,                  6, SL_MAX_VERSION),

   267

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

   268

	SLEG_CONDVAR(_saved_scrollpos_y,    SLE_INT32,                  6, SL_MAX_VERSION),

   269

	    SLEG_VAR(_saved_scrollpos_zoom, SLE_UINT8),

   270

	    SLEG_END()

   271

};

   272

   273

static void SaveLoad_VIEW()

   274

{

   275

	SlGlobList(_view_desc);

   276

}

   277

   278

static uint32 _map_dim_x;

   279

static uint32 _map_dim_y;

   280

   281

static const SaveLoadGlobVarList _map_dimensions[] = {

   282

	SLEG_CONDVAR(_map_dim_x, SLE_UINT32, 6, SL_MAX_VERSION),

   283

	SLEG_CONDVAR(_map_dim_y, SLE_UINT32, 6, SL_MAX_VERSION),

   284

	    SLEG_END()

   285

};

   286

   287

static void Save_MAPS()

   288

{

   289

	_map_dim_x = MapSizeX();

   290

	_map_dim_y = MapSizeY();

   291

	SlGlobList(_map_dimensions);

   292

}

   293

   294

static void Load_MAPS()

   295

{

   296

	SlGlobList(_map_dimensions);

   297

	AllocateMap(_map_dim_x, _map_dim_y);

   298

}

   299

   300

static void Load_MAPT()

   301

{

   302

	uint size = MapSize();

   303

	uint i;

   304

   305

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

   306

		byte buf[4096];

   307

		uint j;

   308

   309

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

   310

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

   311

	}

   312

}

   313

   314

static void Save_MAPT()

   315

{

   316

	uint size = MapSize();

   317

	uint i;

   318

   319

	SlSetLength(size);

   320

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

   321

		byte buf[4096];

   322

		uint j;

   323

   324

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

   325

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

   326

	}

   327

}

   328

   329

static void Load_MAP1()

   330

{

   331

	uint size = MapSize();

   332

	uint i;

   333

   334

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

   335

		byte buf[4096];

   336

		uint j;

   337

   338

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

   339

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

   340

	}

   341

}

   342

   343

static void Save_MAP1()

   344

{

   345

	uint size = MapSize();

   346

	uint i;

   347

   348

	SlSetLength(size);

   349

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

   350

		byte buf[4096];

   351

		uint j;

   352

   353

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

   354

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

   355

	}

   356

}

   357

   358

static void Load_MAP2()

   359

{

   360

	uint size = MapSize();

   361

	uint i;

   362

   363

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

   364

		uint16 buf[4096];

   365

		uint j;

   366

   367

		SlArray(buf, lengthof(buf),

   368

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

   369

			CheckSavegameVersion(5) ? SLE_FILE_U8 | SLE_VAR_U16 : SLE_UINT16

   370

		);

   371

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

   372

	}

   373

}

   374

   375

static void Save_MAP2()

   376

{

   377

	uint size = MapSize();

   378

	uint i;

   379

   380

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

   381

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

   382

		uint16 buf[4096];

   383

		uint j;

   384

   385

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

   386

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

   387

	}

   388

}

   389

   390

static void Load_MAP3()

   391

{

   392

	uint size = MapSize();

   393

	uint i;

   394

   395

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

   396

		byte buf[4096];

   397

		uint j;

   398

   399

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

   400

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

   401

	}

   402

}

   403

   404

static void Save_MAP3()

   405

{

   406

	uint size = MapSize();

   407

	uint i;

   408

   409

	SlSetLength(size);

   410

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

   411

		byte buf[4096];

   412

		uint j;

   413

   414

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

   415

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

   416

	}

   417

}

   418

   419

static void Load_MAP4()

   420

{

   421

	uint size = MapSize();

   422

	uint i;

   423

   424

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

   425

		byte buf[4096];

   426

		uint j;

   427

   428

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

   429

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

   430

	}

   431

}

   432

   433

static void Save_MAP4()

   434

{

   435

	uint size = MapSize();

   436

	uint i;

   437

   438

	SlSetLength(size);

   439

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

   440

		byte buf[4096];

   441

		uint j;

   442

   443

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

   444

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

   445

	}

   446

}

   447

   448

static void Load_MAP5()

   449

{

   450

	uint size = MapSize();

   451

	uint i;

   452

   453

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

   454

		byte buf[4096];

   455

		uint j;

   456

   457

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

   458

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

   459

	}

   460

}

   461

   462

static void Save_MAP5()

   463

{

   464

	uint size = MapSize();

   465

	uint i;

   466

   467

	SlSetLength(size);

   468

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

   469

		byte buf[4096];

   470

		uint j;

   471

   472

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

   473

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

   474

	}

   475

}

   476

   477

static void Load_MAP6()

   478

{

   479

	/* Still available for loading old games */

   480

	uint size = MapSize();

   481

	uint i;

   482

   483

	if (CheckSavegameVersion(42)) {

   484

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

   485

			uint8 buf[1024];

   486

			uint j;

   487

   488

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

   489

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

   490

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

   491

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