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"

    27

    28

char _name_array[512][32];

    29

    30

void InitializeVehicles();

    31

void InitializeWaypoints();

    32

void InitializeDepots();

    33

void InitializeEngines();

    34

void InitializeOrders();

    35

void InitializeClearLand();

    36

void InitializeRailGui();

    37

void InitializeRoadGui();

    38

void InitializeAirportGui();

    39

void InitializeDockGui();

    40

void InitializeIndustries();

    41

void InitializeMainGui();

    42

void InitializeTowns();

    43

void InitializeTrees();

    44

void InitializeSigns();

    45

void InitializeStations();

    46

void InitializeCargoPackets();

    47

static void InitializeNameMgr();

    48

void InitializePlayers();

    49

static void InitializeCheats();

    50

void InitializeNPF();

    51

    52

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

    53

{

    54

	AllocateMap(size_x, size_y);

    55

    56

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

    57

    59

    60

	_pause_game = 0;

    61

	_fast_forward = 0;

    62

	_tick_counter = 0;

    63

	_realtime_tick = 0;

    64

	_date_fract = 0;

    65

	_cur_tileloop_tile = 0;

    66

    67

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

    68

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

    69

	}

    70

    71

	InitializeEngines();

    72

	InitializeVehicles();

    73

	InitializeWaypoints();

    74

	InitializeDepots();

    75

	InitializeOrders();

    76

	InitializeGroup();

    77

    78

	InitNewsItemStructs();

    79

	InitializeLandscape();

    80

	InitializeClearLand();

    81

	InitializeRailGui();

    82

	InitializeRoadGui();

    83

	InitializeAirportGui();

    84

	InitializeDockGui();

    85

	InitializeTowns();

    86

	InitializeTrees();

    87

	InitializeSigns();

    88

	InitializeStations();

    89

	InitializeCargoPackets();

    90

	InitializeIndustries();

    91

	InitializeBuildingCounts();

    92

	InitializeMainGui();

    93

    94

	InitializeNameMgr();

    95

	InitializeVehiclesGuiList();

    96

	InitializeTrains();

    97

	InitializeNPF();

    98

    99

	AI_Initialize();

   100

	InitializePlayers();

   101

	InitializeCheats();

   102

   103

	InitTextEffects();

   104

	InitChatMessage();

   105

	InitializeAnimatedTiles();

   106

   107

	InitializeLandscapeVariables(false);

   108

   109

	ResetObjectToPlace();

   110

}

   111

   112

bool IsCustomName(StringID id)

   113

{

   114

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

   115

}

   116

   117

void DeleteName(StringID id)

   118

{

   119

	if (IsCustomName(id)) {

   120

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

   121

	}

   122

}

   123

   124

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

   125

{

   126

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

   127

}

   128

   129

   130

static void InitializeCheats()

   131

{

   132

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

   133

}

   134

   135

   136

static void InitializeNameMgr()

   137

{

   138

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

   139

}

   140

   141

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

   142

{

   143

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

   144

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

   145

   146

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

   147

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

   148

			if (free_item == NULL) free_item = i;

   149

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

   150

			_error_message = STR_0132_CHOSEN_NAME_IN_USE_ALREADY;

   151

			return 0;

   152

		}

   153

	}

   154

   155

	if (free_item != NULL) {

   156

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

   157

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

   158

	} else {

   159

		_error_message = STR_0131_TOO_MANY_NAMES_DEFINED;

   160

		return 0;

   161

	}

   162

}

   163

   164

void ConvertNameArray()

   165

{

   166

	uint i;

   167

   168

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

   169

		const char *strfrom = _name_array[i];

   170

		char tmp[sizeof(*_name_array)];

   171

		char *strto = tmp;

   172

   173

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

   174

			WChar c = (byte)*strfrom;

   175

			switch (c) {

   176

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

   177

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

   178

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

   179

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

   180

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

   181

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

   182

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

   183

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

   184

				default: break;

   185

			}

   186

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

   187

			strto += Utf8Encode(strto, c);

   188

		}

   189

   190

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

   191

		*strto = '\0';

   192

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

   193

	}

   194

}

   195

   196

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

   197

void InitializeLandscapeVariables(bool only_constants)

   198

{

   199

	if (only_constants) return;

   200

   201

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

   202

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

   203

		_cargo_payment_rates_frac[i] = 0;

   204

	}

   205

}

   206

   207

   208

static void Save_NAME()

   209

{

   210

	int i;

   211

   212

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

   213

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

   214

			SlSetArrayIndex(i);

   215

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

   216

		}

   217

	}

   218

}

   219

   220

static void Load_NAME()

   221

{

   222

	int index;

   223

   224

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

   225

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

   226

	}

   227

}

   228

   229

static const SaveLoadGlobVarList _date_desc[] = {

   230

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

   231

	SLEG_CONDVAR(_date,                   SLE_INT32,                  31, SL_MAX_VERSION),

   232

	    SLEG_VAR(_date_fract,             SLE_UINT16),

   233

	    SLEG_VAR(_tick_counter,           SLE_UINT16),

   234

	    SLEG_VAR(_vehicle_id_ctr_day,     SLE_UINT16),

   235

	    SLEG_VAR(_age_cargo_skip_counter, SLE_UINT8),

   236

	SLE_CONDNULL(1, 0, 45),

   237

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

   238

	SLEG_CONDVAR(_cur_tileloop_tile,      SLE_UINT32,                  6, SL_MAX_VERSION),

   239

	    SLEG_VAR(_disaster_delay,         SLE_UINT16),

   240

	    SLEG_VAR(_station_tick_ctr,       SLE_UINT16),

   241

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

   242

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

   243

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

   244

	SLEG_CONDVAR(_cur_town_ctr,           SLE_UINT32,                 10, SL_MAX_VERSION),

   245

	    SLEG_VAR(_cur_player_tick_index,  SLE_FILE_U8  | SLE_VAR_U32),

   246

	    SLEG_VAR(_next_competitor_start,  SLE_FILE_U16 | SLE_VAR_U32),

   247

	    SLEG_VAR(_trees_tick_ctr,         SLE_UINT8),

   248

	SLEG_CONDVAR(_pause_game,             SLE_UINT8,                   4, SL_MAX_VERSION),

   249

	SLEG_CONDVAR(_cur_town_iter,          SLE_UINT32,                 11, SL_MAX_VERSION),

   250

	    SLEG_END()

   251

};

   252

   253

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

   254

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

   255

static void SaveLoad_DATE()

   256

{

   257

	SlGlobList(_date_desc);

   258

}

   259

   260

   261

static const SaveLoadGlobVarList _view_desc[] = {

   262

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

   263

	SLEG_CONDVAR(_saved_scrollpos_x,    SLE_INT32,                  6, SL_MAX_VERSION),

   264

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

   265

	SLEG_CONDVAR(_saved_scrollpos_y,    SLE_INT32,                  6, SL_MAX_VERSION),

   266

	    SLEG_VAR(_saved_scrollpos_zoom, SLE_UINT8),

   267

	    SLEG_END()

   268

};

   269

   270

static void SaveLoad_VIEW()

   271

{

   272

	SlGlobList(_view_desc);

   273

}

   274

   275

static uint32 _map_dim_x;

   276

static uint32 _map_dim_y;

   277

   278

static const SaveLoadGlobVarList _map_dimensions[] = {

   279

	SLEG_CONDVAR(_map_dim_x, SLE_UINT32, 6, SL_MAX_VERSION),

   280

	SLEG_CONDVAR(_map_dim_y, SLE_UINT32, 6, SL_MAX_VERSION),

   281

	    SLEG_END()

   282

};

   283

   284

static void Save_MAPS()

   285

{

   286

	_map_dim_x = MapSizeX();

   287

	_map_dim_y = MapSizeY();

   288

	SlGlobList(_map_dimensions);

   289

}

   290

   291

static void Load_MAPS()

   292

{

   293

	SlGlobList(_map_dimensions);

   294

	AllocateMap(_map_dim_x, _map_dim_y);

   295

}

   296

   297

static void Load_MAPT()

   298

{

   299

	uint size = MapSize();

   300

	uint i;

   301

   302

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

   303

		byte buf[4096];

   304

		uint j;

   305

   306

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

   307

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

   308

	}

   309

}

   310

   311

static void Save_MAPT()

   312

{

   313

	uint size = MapSize();

   314

	uint i;

   315

   316

	SlSetLength(size);

   317

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

   318

		byte buf[4096];

   319

		uint j;

   320

   321

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

   322

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

   323

	}

   324

}

   325

   326

static void Load_MAP1()

   327

{

   328

	uint size = MapSize();

   329

	uint i;

   330

   331

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

   332

		byte buf[4096];

   333

		uint j;

   334

   335

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

   336

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

   337

	}

   338

}

   339

   340

static void Save_MAP1()

   341

{

   342

	uint size = MapSize();

   343

	uint i;

   344

   345

	SlSetLength(size);

   346

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

   347

		byte buf[4096];

   348

		uint j;

   349

   350

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

   351

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

   352

	}

   353

}

   354

   355

static void Load_MAP2()

   356

{

   357

	uint size = MapSize();

   358

	uint i;

   359

   360

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

   361

		uint16 buf[4096];

   362

		uint j;

   363

   364

		SlArray(buf, lengthof(buf),

   365

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

   366

			CheckSavegameVersion(5) ? SLE_FILE_U8 | SLE_VAR_U16 : SLE_UINT16

   367

		);

   368

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

   369

	}

   370

}

   371

   372

static void Save_MAP2()

   373

{

   374

	uint size = MapSize();

   375

	uint i;

   376

   377

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

   378

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

   379

		uint16 buf[4096];

   380

		uint j;

   381

   382

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

   383

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

   384

	}

   385

}

   386

   387

static void Load_MAP3()

   388

{

   389

	uint size = MapSize();

   390

	uint i;

   391

   392

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

   393

		byte buf[4096];

   394

		uint j;

   395

   396

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

   397

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

   398

	}

   399

}

   400

   401

static void Save_MAP3()

   402

{

   403

	uint size = MapSize();

   404

	uint i;

   405

   406

	SlSetLength(size);

   407

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

   408

		byte buf[4096];

   409

		uint j;

   410

   411

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

   412

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

   413

	}

   414

}

   415

   416

static void Load_MAP4()

   417

{

   418

	uint size = MapSize();

   419

	uint i;

   420

   421

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

   422

		byte buf[4096];

   423

		uint j;

   424

   425

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

   426

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

   427

	}

   428

}

   429

   430

static void Save_MAP4()

   431

{

   432

	uint size = MapSize();

   433

	uint i;

   434

   435

	SlSetLength(size);

   436

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

   437

		byte buf[4096];

   438

		uint j;

   439

   440

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

   441

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

   442

	}

   443

}

   444

   445

static void Load_MAP5()

   446

{

   447

	uint size = MapSize();

   448

	uint i;

   449

   450

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

   451

		byte buf[4096];

   452

		uint j;

   453

   454

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

   455

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

   456

	}

   457

}

   458

   459

static void Save_MAP5()

   460

{

   461

	uint size = MapSize();

   462

	uint i;

   463

   464

	SlSetLength(size);

   465

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

   466

		byte buf[4096];

   467

		uint j;

   468

   469

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

   470

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

   471

	}

   472

}

   473

   474

static void Load_MAP6()

   475

{

   476

	/* Still available for loading old games */

   477

	uint size = MapSize();

   478

	uint i;

   479

   480

	if (CheckSavegameVersion(42)) {

   481

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

   482

			uint8 buf[1024];

   483

			uint j;

   484

   485

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

   486

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

   487

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

   488

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

   489

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

   490

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

   491

			}