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

    26

char _name_array[512][32];

    27

    28

#ifndef MERSENNE_TWISTER

    29

    30

#ifdef RANDOM_DEBUG

    31

#include "network/network_data.h"

    32

uint32 DoRandom(int line, const char *file)

    33

#else // RANDOM_DEBUG

    34

uint32 Random()

    35

#endif // RANDOM_DEBUG

    36

{

    37

    38

uint32 s;

    39

uint32 t;

    40

    41

#ifdef RANDOM_DEBUG

    42

	if (_networking && (DEREF_CLIENT(0)->status != STATUS_INACTIVE || !_network_server))

    43

		printf("Random [%d/%d] %s:%d\n",_frame_counter, _current_player, file, line);

    44

#endif

    45

    46

	s = _random_seeds[0][0];

    47

	t = _random_seeds[0][1];

    48

	_random_seeds[0][0] = s + ROR(t ^ 0x1234567F, 7) + 1;

    49

	return _random_seeds[0][1] = ROR(s, 3) - 1;

    50

}

    51

#endif // MERSENNE_TWISTER

    52

    53

#if defined(RANDOM_DEBUG) && !defined(MERSENNE_TWISTER)

    54

uint DoRandomRange(uint max, int line, const char *file)

    55

{

    56

	return GB(DoRandom(line, file), 0, 16) * max >> 16;

    57

}

    58

#else

    59

uint RandomRange(uint max)

    60

{

    61

	return GB(Random(), 0, 16) * max >> 16;

    62

}

    63

#endif

    64

    65

    66

uint32 InteractiveRandom()

    67

{

    68

	uint32 t = _random_seeds[1][1];

    69

	uint32 s = _random_seeds[1][0];

    70

	_random_seeds[1][0] = s + ROR(t ^ 0x1234567F, 7) + 1;

    71

	return _random_seeds[1][1] = ROR(s, 3) - 1;

    72

}

    73

    74

uint InteractiveRandomRange(uint max)

    75

{

    76

	return GB(InteractiveRandom(), 0, 16) * max >> 16;

    77

}

    78

    79

void InitializeVehicles();

    80

void InitializeWaypoints();

    81

void InitializeDepots();

    82

void InitializeEngines();

    83

void InitializeOrders();

    84

void InitializeClearLand();

    85

void InitializeRailGui();

    86

void InitializeRoadGui();

    87

void InitializeAirportGui();

    88

void InitializeDockGui();

    89

void InitializeIndustries();

    90

void InitializeMainGui();

    91

void InitializeTowns();

    92

void InitializeTrees();

    93

void InitializeSigns();

    94

void InitializeStations();

    95

static void InitializeNameMgr();

    96

void InitializePlayers();

    97

static void InitializeCheats();

    98

void InitializeNPF();

    99

   100

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

   101

{

   102

	AllocateMap(size_x, size_y);

   103

   104

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

   105

   106

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

   107

   108

	_pause_game = 0;

   109

	_fast_forward = 0;

   110

	_tick_counter = 0;

   111

	_date_fract = 0;

   112

	_cur_tileloop_tile = 0;

   113

   114

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

   115

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

   116

	}

   117

   118

	InitializeEngines();

   119

	InitializeVehicles();

   120

	InitializeWaypoints();

   121

	InitializeDepots();

   122

	InitializeOrders();

   123

   124

	InitNewsItemStructs();

   125

	InitializeLandscape();

   126

	InitializeClearLand();

   127

	InitializeRailGui();

   128

	InitializeRoadGui();

   129

	InitializeAirportGui();

   130

	InitializeDockGui();

   131

	InitializeTowns();

   132

	InitializeTrees();

   133

	InitializeSigns();

   134

	InitializeStations();

   135

	InitializeIndustries();

   136

	InitializeBuildingCounts();

   137

	InitializeMainGui();

   138

   139

	InitializeNameMgr();

   140

	InitializeVehiclesGuiList();

   141

	InitializeTrains();

   142

	InitializeNPF();

   143

   144

	AI_Initialize();

   145

	InitializePlayers();

   146

	InitializeCheats();

   147

   148

	InitTextEffects();

   149

	InitTextMessage();

   150

	InitializeAnimatedTiles();

   151

   152

	InitializeLandscapeVariables(false);

   153

   154

	ResetObjectToPlace();

   155

}

   156

   157

bool IsCustomName(StringID id)

   158

{

   159

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

   160

}

   161

   162

void DeleteName(StringID id)

   163

{

   164

	if (IsCustomName(id)) {

   165

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

   166

	}

   167

}

   168

   169

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

   170

{

   171

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

   172

}

   173

   174

   175

static void InitializeCheats()

   176

{

   177

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

   178

}

   179

   180

   181

static void InitializeNameMgr()

   182

{

   183

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

   184

}

   185

   186

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

   187

{

   188

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

   189

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

   190

   191

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

   192

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

   193

			if (free_item == NULL) free_item = i;

   194

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

   195

			_error_message = STR_0132_CHOSEN_NAME_IN_USE_ALREADY;

   196

			return 0;

   197

		}

   198

	}

   199

   200

	if (free_item != NULL) {

   201

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

   202

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

   203

	} else {

   204

		_error_message = STR_0131_TOO_MANY_NAMES_DEFINED;

   205

		return 0;

   206

	}

   207

}

   208

   209

void ConvertNameArray()

   210

{

   211

	uint i;

   212

   213

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

   214

		const char *strfrom = _name_array[i];

   215

		char tmp[sizeof(*_name_array)];

   216

		char *strto = tmp;

   217

   218

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

   219

			WChar c = (byte)*strfrom;

   220

			switch (c) {

   221

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

   222

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

   223

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

   224

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

   225

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

   226

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

   227

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

   228

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

   229

				default: break;

   230

			}

   231

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

   232

			strto += Utf8Encode(strto, c);

   233

		}

   234

   235

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

   236

		*strto = '\0';

   237

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

   238

	}

   239

}

   240

   241

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

   242

void InitializeLandscapeVariables(bool only_constants)

   243

{

   244

	if (only_constants) return;

   245

   246

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

   247

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

   248

		_cargo_payment_rates_frac[i] = 0;

   249

	}

   250

}

   251

   252

   253

   254

int FindFirstBit(uint32 value)

   255

{

   256

	/* The macro FIND_FIRST_BIT is better to use when your value is

   257

	  not more than 128. */

   258

	byte i = 0;

   259

   260

	if (value == 0) return 0;

   261

   262

	if ((value & 0x0000ffff) == 0) { value >>= 16; i += 16; }

   263

	if ((value & 0x000000ff) == 0) { value >>= 8;  i += 8;  }

   264

	if ((value & 0x0000000f) == 0) { value >>= 4;  i += 4;  }

   265

	if ((value & 0x00000003) == 0) { value >>= 2;  i += 2;  }

   266

	if ((value & 0x00000001) == 0) { i += 1; }

   267

   268

	return i;

   269

}

   270

   271

   272

static void Save_NAME()

   273

{

   274

	int i;

   275

   276

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

   277

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

   278

			SlSetArrayIndex(i);

   279

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

   280

		}

   281

	}

   282

}

   283

   284

static void Load_NAME()

   285

{

   286

	int index;

   287

   288

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

   290

	}

   291

}

   292

   293

static const SaveLoadGlobVarList _date_desc[] = {

   294

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

   295

	SLEG_CONDVAR(_date,                   SLE_INT32,                  31, SL_MAX_VERSION),

   296

	    SLEG_VAR(_date_fract,             SLE_UINT16),

   297

	    SLEG_VAR(_tick_counter,           SLE_UINT16),

   298

	    SLEG_VAR(_vehicle_id_ctr_day,     SLE_UINT16),

   299

	    SLEG_VAR(_age_cargo_skip_counter, SLE_UINT8),

   300

	SLE_CONDNULL(1, 0, 45),

   301

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

   302

	SLEG_CONDVAR(_cur_tileloop_tile,      SLE_UINT32,                  6, SL_MAX_VERSION),

   303

	    SLEG_VAR(_disaster_delay,         SLE_UINT16),

   304

	    SLEG_VAR(_station_tick_ctr,       SLE_UINT16),

   305

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

   306

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

   307

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

   308

	SLEG_CONDVAR(_cur_town_ctr,           SLE_UINT32,                 10, SL_MAX_VERSION),

   309

	    SLEG_VAR(_cur_player_tick_index,  SLE_FILE_U8  | SLE_VAR_U32),

   310

	    SLEG_VAR(_next_competitor_start,  SLE_FILE_U16 | SLE_VAR_U32),

   311

	    SLEG_VAR(_trees_tick_ctr,         SLE_UINT8),

   312

	SLEG_CONDVAR(_pause_game,             SLE_UINT8,                   4, SL_MAX_VERSION),

   313

	SLEG_CONDVAR(_cur_town_iter,          SLE_UINT32,                 11, SL_MAX_VERSION),

   314

	    SLEG_END()

   315

};

   316

   317

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

   318

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

   319

static void SaveLoad_DATE()

   320

{

   321

	SlGlobList(_date_desc);

   322

}

   323

   324

   325

static const SaveLoadGlobVarList _view_desc[] = {

   326

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

   327

	SLEG_CONDVAR(_saved_scrollpos_x,    SLE_INT32,                  6, SL_MAX_VERSION),

   328

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

   329

	SLEG_CONDVAR(_saved_scrollpos_y,    SLE_INT32,                  6, SL_MAX_VERSION),

   330

	    SLEG_VAR(_saved_scrollpos_zoom, SLE_UINT8),

   331

	    SLEG_END()

   332

};

   333

   334

static void SaveLoad_VIEW()

   335

{

   336

	SlGlobList(_view_desc);

   337

}

   338

   339

static uint32 _map_dim_x;

   340

static uint32 _map_dim_y;

   341

   342

static const SaveLoadGlobVarList _map_dimensions[] = {

   343

	SLEG_CONDVAR(_map_dim_x, SLE_UINT32, 6, SL_MAX_VERSION),

   344

	SLEG_CONDVAR(_map_dim_y, SLE_UINT32, 6, SL_MAX_VERSION),

   345

	    SLEG_END()

   346

};

   347

   348

static void Save_MAPS()

   349

{

   350

	_map_dim_x = MapSizeX();

   351

	_map_dim_y = MapSizeY();

   352

	SlGlobList(_map_dimensions);

   353

}

   354

   355

static void Load_MAPS()

   356

{

   357

	SlGlobList(_map_dimensions);

   358

	AllocateMap(_map_dim_x, _map_dim_y);

   359

}

   360

   361

static void Load_MAPT()

   362

{

   363

	uint size = MapSize();

   364

	uint i;

   365

   366

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

   367

		byte buf[4096];

   368

		uint j;

   369

   370

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

   371

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

   372

	}

   373

}

   374

   375

static void Save_MAPT()

   376

{

   377

	uint size = MapSize();

   378

	uint i;

   379

   380

	SlSetLength(size);

   381

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

   382

		byte buf[4096];

   383

		uint j;

   384

   385

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

   386

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

   387

	}

   388

}

   389

   390

static void Load_MAP1()

   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++].m1 = buf[j];

   401

	}

   402

}

   403

   404

static void Save_MAP1()

   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++].m1;

   415

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

   416

	}

   417

}

   418

   419

static void Load_MAP2()

   420

{

   421

	uint size = MapSize();

   422

	uint i;

   423

   424

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

   425

		uint16 buf[4096];

   426

		uint j;

   427

   428

		SlArray(buf, lengthof(buf),

   429

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

   430

			CheckSavegameVersion(5) ? SLE_FILE_U8 | SLE_VAR_U16 : SLE_UINT16

   431

		);

   432

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

   433

	}

   434

}

   435

   436

static void Save_MAP2()

   437

{

   438

	uint size = MapSize();

   439

	uint i;

   440

   441

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

   442

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

   443

		uint16 buf[4096];

   444

		uint j;

   445

   446

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

   447

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

   448

	}

   449

}

   450

   451

static void Load_MAP3()

   452

{

   453

	uint size = MapSize();

   454

	uint i;

   455

   456

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

   457

		byte buf[4096];

   458

		uint j;

   459

   460

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

   461

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

   462

	}

   463

}

   464

   465

static void Save_MAP3()

   466

{

   467

	uint size = MapSize();

   468

	uint i;

   469

   470

	SlSetLength(size);

   471

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

   472

		byte buf[4096];

   473

		uint j;

   474

   475

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

   476

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

   477

	}

   478

}

   479

   480

static void Load_MAP4()

   481

{

   482

	uint size = MapSize();

   483

	uint i;

   484

   485

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

   486

		byte buf[4096];

   487

		uint j;

   488

   489

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

   490

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

   491

	}