1

/* $Id$ */

     2

     3

/** @file misc.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "economy_new.h"

     8

#include "currency.h"

     9

#include "functions.h"

    10

#include "landscape.h"

    11

#include "news.h"

    12

#include "player.h"

    13

#include "string.h"

    14

#include "table/strings.h"

    15

#include "table/sprites.h"

    16

#include "map.h"

    17

#include "vehicle.h"

    18

#include "saveload.h"

    19

#include "engine.h"

    20

#include "vehicle_gui.h"

    21

#include "variables.h"

    22

#include "ai/ai.h"

    23

#include "newgrf_house.h"

    24

#include "date.h"

    25

#include "cargotype.h"

    26

#include "group.h"

    27

    28

char _name_array[512][32];

    29

    30

#ifndef MERSENNE_TWISTER

    31

    32

#ifdef RANDOM_DEBUG

    33

#include "network/network_data.h"

    34

uint32 DoRandom(int line, const char *file)

    35

#else // RANDOM_DEBUG

    36

uint32 Random()

    37

#endif // RANDOM_DEBUG

    38

{

    39

    40

uint32 s;

    41

uint32 t;

    42

    43

#ifdef RANDOM_DEBUG

    44

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

    45

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

    46

#endif

    47

    48

	s = _random_seeds[0][0];

    49

	t = _random_seeds[0][1];

    50

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

    51

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

    52

}

    53

#endif // MERSENNE_TWISTER

    54

    55

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

    56

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

    57

{

    58

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

    59

}

    60

#else

    61

uint RandomRange(uint max)

    62

{

    63

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

    64

}

    65

#endif

    66

    67

    68

uint32 InteractiveRandom()

    69

{

    70

	uint32 t = _random_seeds[1][1];

    71

	uint32 s = _random_seeds[1][0];

    72

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

    73

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

    74

}

    75

    76

uint InteractiveRandomRange(uint max)

    77

{

    78

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

    79

}

    80

    81

void InitializeVehicles();

    82

void InitializeWaypoints();

    83

void InitializeDepots();

    84

void InitializeEngines();

    85

void InitializeOrders();

    86

void InitializeClearLand();

    87

void InitializeRailGui();

    88

void InitializeRoadGui();

    89

void InitializeAirportGui();

    90

void InitializeDockGui();

    91

void InitializeIndustries();

    92

void InitializeMainGui();

    93

void InitializeTowns();

    94

void InitializeTrees();

    95

void InitializeSigns();

    96

void InitializeStations();

    97

static void InitializeNameMgr();

    98

void InitializePlayers();

    99

static void InitializeCheats();

   100

void InitializeNPF();

   101

   102

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

   103

{

   104

	AllocateMap(size_x, size_y);

   105

   106

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

   107

   108

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

   109

   110

	_pause_game = 0;

   111

	_fast_forward = 0;

   112

	_tick_counter = 0;

   113

	_date_fract = 0;

   114

	_cur_tileloop_tile = 0;

   115

   116

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

   117

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

   118

	}

   119

   120

	InitializeEngines();

   121

	InitializeVehicles();

   122

	InitializeWaypoints();

   123

	InitializeDepots();

   124

	InitializeOrders();

   125

	InitializeGroup();

   126

   127

	InitNewsItemStructs();

   128

	InitializeLandscape();

   129

	InitializeClearLand();

   130

	InitializeRailGui();

   131

	InitializeRoadGui();

   132

	InitializeAirportGui();

   133

	InitializeDockGui();

   134

	InitializeTowns();

   135

	InitializeEconomy();

   136

	InitializeTrees();

   137

	InitializeSigns();

   138

	InitializeStations();

   139

	InitializeIndustries();

   140

	InitializeBuildingCounts();

   141

	InitializeMainGui();

   142

   143

	InitializeNameMgr();

   144

	InitializeVehiclesGuiList();

   145

	InitializeTrains();

   146

	InitializeNPF();

   147

   148

	AI_Initialize();

   149

	InitializePlayers();

   150

	InitializeCheats();

   151

   152

	InitTextEffects();

   153

	InitTextMessage();

   154

	InitializeAnimatedTiles();

   155

   156

	InitializeLandscapeVariables(false);

   157

   158

	ResetObjectToPlace();

   159

}

   160

   161

bool IsCustomName(StringID id)

   162

{

   163

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

   164

}

   165

   166

void DeleteName(StringID id)

   167

{

   168

	if (IsCustomName(id)) {

   169

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

   170

	}

   171

}

   172

   173

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

   174

{

   175

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

   176

}

   177

   178

   179

static void InitializeCheats()

   180

{

   181

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

   182

}

   183

   184

   185

static void InitializeNameMgr()

   186

{

   187

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

   188

}

   189

   190

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

   191

{

   192

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

   193

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

   194

   195

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

   196

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

   197

			if (free_item == NULL) free_item = i;

   198

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

   199

			_error_message = STR_0132_CHOSEN_NAME_IN_USE_ALREADY;

   200

			return 0;

   201

		}

   202

	}

   203

   204

	if (free_item != NULL) {

   205

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

   206

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

   207

	} else {

   208

		_error_message = STR_0131_TOO_MANY_NAMES_DEFINED;

   209

		return 0;

   210

	}

   211

}

   212

   213

void ConvertNameArray()

   214

{

   215

	uint i;

   216

   217

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

   218

		const char *strfrom = _name_array[i];

   219

		char tmp[sizeof(*_name_array)];

   220

		char *strto = tmp;

   221

   222

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

   223

			WChar c = (byte)*strfrom;

   224

			switch (c) {

   225

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

   226

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

   227

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

   228

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

   229

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

   230

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

   231

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

   232

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

   233

				default: break;

   234

			}

   235

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

   236

			strto += Utf8Encode(strto, c);

   237

		}

   238

   239

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

   240

		*strto = '\0';

   241

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

   242

	}

   243

}

   244

   245

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

   246

void InitializeLandscapeVariables(bool only_constants)

   247

{

   248

	if (only_constants) return;

   249

   250

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

   251

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

   252

		_cargo_payment_rates_frac[i] = 0;

   253

	}

   254

}

   255

   256

   257

   258

int FindFirstBit(uint32 value)

   259

{

   260

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

   261

	  not more than 128. */

   262

	byte i = 0;

   263

   264

	if (value == 0) return 0;

   265

   266

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

   267

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

   268

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

   269

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

   270

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

   271

   272

	return i;

   273

}

   274

   290

   291

static void Save_NAME()

   292

{

   293

	int i;

   294

   295

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

   296

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

   297

			SlSetArrayIndex(i);

   298

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

   299

		}

   300

	}

   301

}

   302

   303

static void Load_NAME()

   304

{

   305

	int index;

   306

   307

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

   308

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

   309

	}

   310

}

   311

   312

static const SaveLoadGlobVarList _date_desc[] = {

   313

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

   314

	SLEG_CONDVAR(_date,                   SLE_INT32,                  31, SL_MAX_VERSION),

   315

	    SLEG_VAR(_date_fract,             SLE_UINT16),

   316

	    SLEG_VAR(_tick_counter,           SLE_UINT16),

   317

	    SLEG_VAR(_vehicle_id_ctr_day,     SLE_UINT16),

   318

	    SLEG_VAR(_age_cargo_skip_counter, SLE_UINT8),

   319

	SLE_CONDNULL(1, 0, 45),

   320

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

   321

	SLEG_CONDVAR(_cur_tileloop_tile,      SLE_UINT32,                  6, SL_MAX_VERSION),

   322

	    SLEG_VAR(_disaster_delay,         SLE_UINT16),

   323

	    SLEG_VAR(_station_tick_ctr,       SLE_UINT16),

   324

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

   325

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

   326

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

   327

	SLEG_CONDVAR(_cur_town_ctr,           SLE_UINT32,                 10, SL_MAX_VERSION),

   328

	    SLEG_VAR(_cur_player_tick_index,  SLE_FILE_U8  | SLE_VAR_U32),

   329

	    SLEG_VAR(_next_competitor_start,  SLE_FILE_U16 | SLE_VAR_U32),

   330

	    SLEG_VAR(_trees_tick_ctr,         SLE_UINT8),

   331

	SLEG_CONDVAR(_pause_game,             SLE_UINT8,                   4, SL_MAX_VERSION),

   332

	SLEG_CONDVAR(_cur_town_iter,          SLE_UINT32,                 11, SL_MAX_VERSION),

   333

	    SLEG_END()

   334

};

   335

   336

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

   337

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

   338

static void SaveLoad_DATE()

   339

{

   340

	SlGlobList(_date_desc);

   341

}

   342

   343

   344

static const SaveLoadGlobVarList _view_desc[] = {

   345

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

   346

	SLEG_CONDVAR(_saved_scrollpos_x,    SLE_INT32,                  6, SL_MAX_VERSION),

   347

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

   348

	SLEG_CONDVAR(_saved_scrollpos_y,    SLE_INT32,                  6, SL_MAX_VERSION),

   349

	    SLEG_VAR(_saved_scrollpos_zoom, SLE_UINT8),

   350

	    SLEG_END()

   351

};

   352

   353

static void SaveLoad_VIEW()

   354

{

   355

	SlGlobList(_view_desc);

   356

}

   357

   358

static uint32 _map_dim_x;

   359

static uint32 _map_dim_y;

   360

   361

static const SaveLoadGlobVarList _map_dimensions[] = {

   362

	SLEG_CONDVAR(_map_dim_x, SLE_UINT32, 6, SL_MAX_VERSION),

   363

	SLEG_CONDVAR(_map_dim_y, SLE_UINT32, 6, SL_MAX_VERSION),

   364

	    SLEG_END()

   365

};

   366

   367

static void Save_MAPS()

   368

{

   369

	_map_dim_x = MapSizeX();

   370

	_map_dim_y = MapSizeY();

   371

	SlGlobList(_map_dimensions);

   372

}

   373

   374

static void Load_MAPS()

   375

{

   376

	SlGlobList(_map_dimensions);

   377

	AllocateMap(_map_dim_x, _map_dim_y);

   378

}

   379

   380

static void Load_MAPT()

   381

{

   382

	uint size = MapSize();

   383

	uint i;

   384

   385

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

   386

		byte buf[4096];

   387

		uint j;

   388

   389

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

   390

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

   391

	}

   392

}

   393

   394

static void Save_MAPT()

   395

{

   396

	uint size = MapSize();

   397

	uint i;

   398

   399

	SlSetLength(size);

   400

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

   401

		byte buf[4096];

   402

		uint j;

   403

   404

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

   405

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

   406

	}

   407

}

   408

   409

static void Load_MAP1()

   410

{

   411

	uint size = MapSize();

   412

	uint i;

   413

   414

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

   415

		byte buf[4096];

   416

		uint j;

   417

   418

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

   419

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

   420

	}

   421

}

   422

   423

static void Save_MAP1()

   424

{

   425

	uint size = MapSize();

   426

	uint i;

   427

   428

	SlSetLength(size);

   429

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

   430

		byte buf[4096];

   431

		uint j;

   432

   433

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

   434

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

   435

	}

   436

}

   437

   438

static void Load_MAP2()

   439

{

   440

	uint size = MapSize();

   441

	uint i;

   442

   443

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

   444

		uint16 buf[4096];

   445

		uint j;

   446

   447

		SlArray(buf, lengthof(buf),

   448

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

   449

			CheckSavegameVersion(5) ? SLE_FILE_U8 | SLE_VAR_U16 : SLE_UINT16

   450

		);

   451

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

   452

	}

   453

}

   454

   455

static void Save_MAP2()

   456

{

   457

	uint size = MapSize();

   458

	uint i;

   459

   460

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

   461

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

   462

		uint16 buf[4096];

   463

		uint j;

   464

   465

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

   466

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

   467

	}

   468

}

   469

   470

static void Load_MAP3()

   471

{

   472

	uint size = MapSize();

   473

	uint i;

   474

   475

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

   476

		byte buf[4096];

   477

		uint j;

   478

   479

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

   480

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

   481

	}

   482

}

   483

   484

static void Save_MAP3()

   485

{

   486

	uint size = MapSize();

   487

	uint i;

   488

   489

	SlSetLength(size);

   490

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

   491

		byte buf[4096];