1

/* $Id$ */

     2

     3

/** @file misc.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "currency.h"

     8

#include "functions.h"

     9

#include "landscape.h"

    10

#include "news.h"

    11

#include "player.h"

    12

#include "string.h"

    13

#include "table/strings.h"

    14

#include "table/sprites.h"

    15

#include "map.h"

    16

#include "vehicle.h"

    17

#include "saveload.h"

    18

#include "engine.h"

    19

#include "vehicle_gui.h"

    20

#include "variables.h"

    21

#include "ai/ai.h"

    22

#include "newgrf_house.h"

    23

#include "date.h"

    24

#include "cargotype.h"

    25

#include "group.h"

    26

#include "viewport.h"

    27

#include "economy_func.h"

    28

    29

char _name_array[512][32];

    30

    31

void InitializeVehicles();

    32

void InitializeWaypoints();

    33

void InitializeDepots();

    34

void InitializeEngines();

    35

void InitializeOrders();

    36

void InitializeClearLand();

    37

void InitializeRailGui();

    38

void InitializeRoadGui();

    39

void InitializeAirportGui();

    40

void InitializeDockGui();

    41

void InitializeIndustries();

    42

void InitializeMainGui();

    43

void InitializeTowns();

    44

void InitializeTrees();

    45

void InitializeSigns();

    46

void InitializeStations();

    47

void InitializeCargoPackets();

    48

static void InitializeNameMgr();

    49

void InitializePlayers();

    50

static void InitializeCheats();

    51

void InitializeNPF();

    52

    53

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

    54

{

    55

	AllocateMap(size_x, size_y);

    56

    57

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

    58

    59

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

    60

    61

	_pause_game = 0;

    62

	_fast_forward = 0;

    63

	_tick_counter = 0;

    64

	_realtime_tick = 0;

    65

	_date_fract = 0;

    66

	_cur_tileloop_tile = 0;

    67

    68

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

    69

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

    70

	}

    71

    72

	InitializeEngines();

    73

	InitializeVehicles();

    74

	InitializeWaypoints();

    75

	InitializeDepots();

    76

	InitializeOrders();

    77

	InitializeGroup();

    78

    79

	InitNewsItemStructs();

    80

	InitializeLandscape();

    81

	InitializeClearLand();

    82

	InitializeRailGui();

    83

	InitializeRoadGui();

    84

	InitializeAirportGui();

    85

	InitializeDockGui();

    86

	InitializeTowns();

    87

	InitializeTrees();

    88

	InitializeSigns();

    89

	InitializeStations();

    90

	InitializeCargoPackets();

    91

	InitializeIndustries();

    92

	InitializeBuildingCounts();

    93

	InitializeMainGui();

    94

    95

	InitializeNameMgr();

    96

	InitializeVehiclesGuiList();

    97

	InitializeTrains();

    98

	InitializeNPF();

    99

   100

	AI_Initialize();

   101

	InitializePlayers();

   102

	InitializeCheats();

   103

   104

	InitTextEffects();

   105

	InitChatMessage();

   106

	InitializeAnimatedTiles();

   107

   108

	InitializeLandscapeVariables(false);

   109

   110

	ResetObjectToPlace();

   111

}

   112

   113

bool IsCustomName(StringID id)

   114

{

   115

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

   116

}

   117

   118

void DeleteName(StringID id)

   119

{

   120

	if (IsCustomName(id)) {

   121

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

   122

	}

   123

}

   124

   125

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

   126

{

   127

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

   128

}

   129

   130

   131

static void InitializeCheats()

   132

{

   133

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

   134

}

   135

   136

   137

static void InitializeNameMgr()

   138

{

   139

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

   140

}

   141

   142

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

   143

{

   144

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

   145

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

   146

   147

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

   148

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

   149

			if (free_item == NULL) free_item = i;

   150

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

   151

			_error_message = STR_0132_CHOSEN_NAME_IN_USE_ALREADY;

   152

			return 0;

   153

		}

   154

	}

   155

   156

	if (free_item != NULL) {

   157

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

   158

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

   159

	} else {

   160

		_error_message = STR_0131_TOO_MANY_NAMES_DEFINED;

   161

		return 0;

   162

	}

   163

}

   164

   165

void ConvertNameArray()

   166

{

   167

	uint i;

   168

   169

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

   170

		const char *strfrom = _name_array[i];

   171

		char tmp[sizeof(*_name_array)];

   172

		char *strto = tmp;

   173

   174

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

   175

			WChar c = (byte)*strfrom;

   176

			switch (c) {

   177

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

   178

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

   179

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

   180

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

   181

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

   182

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

   183

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

   184

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

   185

				default: break;

   186

			}

   187

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

   188

			strto += Utf8Encode(strto, c);

   189

		}

   190

   191

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

   192

		*strto = '\0';

   193

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

   194

	}

   195

}

   196

   197

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

   198

void InitializeLandscapeVariables(bool only_constants)

   199

{

   200

	if (only_constants) return;

   201

   202

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

   203

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

   204

		_cargo_payment_rates_frac[i] = 0;

   205

	}

   206

}

   207

   208

   209

static void Save_NAME()

   210

{

   211

	int i;

   212

   213

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

   214

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

   215

			SlSetArrayIndex(i);

   216

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

   217

		}

   218

	}

   219

}

   220

   221

static void Load_NAME()

   222

{

   223

	int index;

   224

   225

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

   226

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

   227

	}

   228

}

   229

   230

static const SaveLoadGlobVarList _date_desc[] = {

   231

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

   232

	SLEG_CONDVAR(_date,                   SLE_INT32,                  31, SL_MAX_VERSION),

   233

	    SLEG_VAR(_date_fract,             SLE_UINT16),

   234

	    SLEG_VAR(_tick_counter,           SLE_UINT16),

   235

	    SLEG_VAR(_vehicle_id_ctr_day,     SLE_UINT16),

   236

	    SLEG_VAR(_age_cargo_skip_counter, SLE_UINT8),

   237

	SLE_CONDNULL(1, 0, 45),

   238

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

   239

	SLEG_CONDVAR(_cur_tileloop_tile,      SLE_UINT32,                  6, SL_MAX_VERSION),

   240

	    SLEG_VAR(_disaster_delay,         SLE_UINT16),

   241

	    SLEG_VAR(_station_tick_ctr,       SLE_UINT16),

   242

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

   243

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

   244

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

   245

	SLEG_CONDVAR(_cur_town_ctr,           SLE_UINT32,                 10, SL_MAX_VERSION),

   246

	    SLEG_VAR(_cur_player_tick_index,  SLE_FILE_U8  | SLE_VAR_U32),

   247

	    SLEG_VAR(_next_competitor_start,  SLE_FILE_U16 | SLE_VAR_U32),

   248

	    SLEG_VAR(_trees_tick_ctr,         SLE_UINT8),

   249

	SLEG_CONDVAR(_pause_game,             SLE_UINT8,                   4, SL_MAX_VERSION),

   250

	SLEG_CONDVAR(_cur_town_iter,          SLE_UINT32,                 11, SL_MAX_VERSION),

   251

	    SLEG_END()

   252

};

   253

   254

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

   255

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

   256

static void SaveLoad_DATE()

   257

{

   258

	SlGlobList(_date_desc);

   259

}

   260

   261

   262

static const SaveLoadGlobVarList _view_desc[] = {

   263

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

   264

	SLEG_CONDVAR(_saved_scrollpos_x,    SLE_INT32,                  6, SL_MAX_VERSION),

   265

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

   266

	SLEG_CONDVAR(_saved_scrollpos_y,    SLE_INT32,                  6, SL_MAX_VERSION),

   267

	    SLEG_VAR(_saved_scrollpos_zoom, SLE_UINT8),

   268

	    SLEG_END()

   269

};

   270

   271

static void SaveLoad_VIEW()

   272

{

   273

	SlGlobList(_view_desc);

   274

}

   275

   276

static uint32 _map_dim_x;

   277

static uint32 _map_dim_y;

   278

   279

static const SaveLoadGlobVarList _map_dimensions[] = {

   280

	SLEG_CONDVAR(_map_dim_x, SLE_UINT32, 6, SL_MAX_VERSION),

   281

	SLEG_CONDVAR(_map_dim_y, SLE_UINT32, 6, SL_MAX_VERSION),

   282

	    SLEG_END()

   283

};

   284

   285

static void Save_MAPS()

   286

{

   287

	_map_dim_x = MapSizeX();

   288

	_map_dim_y = MapSizeY();

   289

	SlGlobList(_map_dimensions);

   290

}

   291

   292

static void Load_MAPS()

   293

{

   294

	SlGlobList(_map_dimensions);

   295

	AllocateMap(_map_dim_x, _map_dim_y);

   296

}

   297

   298

static void Load_MAPT()

   299

{

   300

	uint size = MapSize();

   301

	uint i;

   302

   303

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

   304

		byte buf[4096];

   305

		uint j;

   306

   307

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

   308

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

   309

	}

   310

}

   311

   312

static void Save_MAPT()

   313

{

   314

	uint size = MapSize();

   315

	uint i;

   316

   317

	SlSetLength(size);

   318

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

   319

		byte buf[4096];

   320

		uint j;

   321

   322

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

   323

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

   324

	}

   325

}

   326

   327

static void Load_MAP1()

   328

{

   329

	uint size = MapSize();

   330

	uint i;

   331

   332

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

   333

		byte buf[4096];

   334

		uint j;

   335

   336

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

   337

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

   338

	}

   339

}

   340

   341

static void Save_MAP1()

   342

{

   343

	uint size = MapSize();

   344

	uint i;

   345

   346

	SlSetLength(size);

   347

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

   348

		byte buf[4096];

   349

		uint j;

   350

   351

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

   352

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

   353

	}

   354

}

   355

   356

static void Load_MAP2()

   357

{

   358

	uint size = MapSize();

   359

	uint i;

   360

   361

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

   362

		uint16 buf[4096];

   363

		uint j;

   364

   365

		SlArray(buf, lengthof(buf),

   366

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

   367

			CheckSavegameVersion(5) ? SLE_FILE_U8 | SLE_VAR_U16 : SLE_UINT16

   368

		);

   369

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

   370

	}

   371

}

   372

   373

static void Save_MAP2()

   374

{

   375

	uint size = MapSize();

   376

	uint i;

   377

   378

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

   379

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

   380

		uint16 buf[4096];

   381

		uint j;

   382

   383

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

   384

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

   385

	}

   386

}

   387

   388

static void Load_MAP3()

   389

{

   390

	uint size = MapSize();

   391

	uint i;

   392

   393

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

   394

		byte buf[4096];

   395

		uint j;

   396

   397

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

   398

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

   399

	}

   400

}

   401

   402

static void Save_MAP3()

   403

{

   404

	uint size = MapSize();

   405

	uint i;

   406

   407

	SlSetLength(size);

   408

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

   409

		byte buf[4096];

   410

		uint j;

   411

   412

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

   413

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

   414

	}

   415

}

   416

   417

static void Load_MAP4()

   418

{

   419

	uint size = MapSize();

   420

	uint i;

   421

   422

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

   423

		byte buf[4096];

   424

		uint j;

   425

   426

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

   427

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

   428

	}

   429

}

   430

   431

static void Save_MAP4()

   432

{

   433

	uint size = MapSize();

   434

	uint i;

   435

   436

	SlSetLength(size);

   437

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

   438

		byte buf[4096];

   439

		uint j;

   440

   441

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

   442

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

   443

	}

   444

}

   445

   446

static void Load_MAP5()

   447

{

   448

	uint size = MapSize();

   449

	uint i;

   450

   451

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

   452

		byte buf[4096];

   453

		uint j;

   454

   455

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

   456

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

   457

	}

   458

}

   459

   460

static void Save_MAP5()

   461

{

   462

	uint size = MapSize();

   463

	uint i;

   464

   465

	SlSetLength(size);

   466

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

   467

		byte buf[4096];

   468

		uint j;

   469

   470

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

   471

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

   472

	}

   473

}

   474

   475

static void Load_MAP6()

   476

{

   477

	/* Still available for loading old games */

   478

	uint size = MapSize();

   479

	uint i;

   480

   481

	if (CheckSavegameVersion(42)) {

   482

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

   483

			uint8 buf[1024];

   484

			uint j;

   485

   486

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

   487

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

   488

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

   489

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

   490

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

   491

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