1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "currency.h"

     6

#include "functions.h"

     7

#include "news.h"

     8

#include "player.h"

     9

#include "string.h"

    10

#include "table/strings.h"

    11

#include "table/sprites.h"

    12

#include "map.h"

    13

#include "vehicle.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 "table/landscape_const.h"

    20

#include "date.h"

    21

    22

char _name_array[512][32];

    23

    24

#ifndef MERSENNE_TWISTER

    25

    26

#ifdef RANDOM_DEBUG

    27

#include "network_data.h"

    28

uint32 DoRandom(int line, const char *file)

    29

#else // RANDOM_DEBUG

    30

uint32 Random(void)

    31

#endif // RANDOM_DEBUG

    32

{

    33

    34

uint32 s;

    35

uint32 t;

    36

    37

#ifdef RANDOM_DEBUG

    38

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

    39

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

    40

#endif

    41

    42

	s = _random_seeds[0][0];

    43

	t = _random_seeds[0][1];

    44

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

    45

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

    46

}

    47

#endif // MERSENNE_TWISTER

    48

    49

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

    50

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

    51

{

    52

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

    53

}

    54

#else

    55

uint RandomRange(uint max)

    56

{

    57

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

    58

}

    59

#endif

    60

    61

    62

uint32 InteractiveRandom(void)

    63

{

    64

	uint32 t = _random_seeds[1][1];

    65

	uint32 s = _random_seeds[1][0];

    66

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

    67

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

    68

}

    69

    70

uint InteractiveRandomRange(uint max)

    71

{

    72

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

    73

}

    74

    75

void InitializeVehicles(void);

    76

void InitializeWaypoints(void);

    77

void InitializeDepots(void);

    78

void InitializeEngines(void);

    79

void InitializeOrders(void);

    80

void InitializeClearLand(void);

    81

void InitializeRailGui(void);

    82

void InitializeRoadGui(void);

    83

void InitializeAirportGui(void);

    84

void InitializeDockGui(void);

    85

void InitializeIndustries(void);

    86

void InitializeMainGui(void);

    87

void InitializeLandscape(void);

    88

void InitializeTowns(void);

    89

void InitializeTrees(void);

    90

void InitializeSigns(void);

    91

void InitializeStations(void);

    92

static void InitializeNameMgr(void);

    93

void InitializePlayers(void);

    94

static void InitializeCheats(void);

    95

void InitializeNPF(void);

    96

    97

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

    98

{

    99

	AllocateMap(size_x, size_y);

   100

   101

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

   102

   103

	SetObjectToPlace(SPR_CURSOR_ZZZ, 0, 0, 0);

   104

   105

	_pause = 0;

   106

	_fast_forward = 0;

   107

	_tick_counter = 0;

   108

	_date_fract = 0;

   109

	_cur_tileloop_tile = 0;

   110

   111

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

   112

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

   113

	}

   114

   115

	InitializeEngines();

   116

	InitializeVehicles();

   117

	InitializeWaypoints();

   118

	InitializeDepots();

   119

	InitializeOrders();

   120

   121

	InitNewsItemStructs();

   122

	InitializeLandscape();

   123

	InitializeClearLand();

   124

	InitializeRailGui();

   125

	InitializeRoadGui();

   126

	InitializeAirportGui();

   127

	InitializeDockGui();

   128

	InitializeTowns();

   129

	InitializeTrees();

   130

	InitializeSigns();

   131

	InitializeStations();

   132

	InitializeIndustries();

   133

	InitializeMainGui();

   134

   135

	InitializeNameMgr();

   136

	InitializeVehiclesGuiList();

   137

	InitializeTrains();

   138

	InitializeNPF();

   139

   140

	AI_Initialize();

   141

	InitializePlayers();

   142

	InitializeCheats();

   143

   144

	InitTextEffects();

   145

	InitTextMessage();

   146

	InitializeAnimatedTiles();

   147

   148

	InitializeLandscapeVariables(false);

   149

   150

	ResetObjectToPlace();

   151

}

   152

   153

bool IsCustomName(StringID id)

   154

{

   155

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

   156

}

   157

   158

void DeleteName(StringID id)

   159

{

   160

	if (IsCustomName(id)) {

   161

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

   162

	}

   163

}

   164

   165

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

   166

{

   167

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

   168

}

   169

   170

   171

static void InitializeCheats(void)

   172

{

   173

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

   174

}

   175

   176

   177

static void InitializeNameMgr(void)

   178

{

   179

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

   180

}

   181

   182

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

   183

{

   184

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

   185

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

   186

   187

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

   188

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

   189

			if (free_item == NULL) free_item = i;

   190

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

   191

			_error_message = STR_0132_CHOSEN_NAME_IN_USE_ALREADY;

   192

			return 0;

   193

		}

   194

	}

   195

   196

	if (free_item != NULL) {

   197

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

   198

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

   199

	} else {

   200

		_error_message = STR_0131_TOO_MANY_NAMES_DEFINED;

   201

		return 0;

   202

	}

   203

}

   204

   205

void ConvertNameArray(void)

   206

{

   207

	uint i;

   208

   209

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

   210

		const char *strfrom = _name_array[i];

   211

		char tmp[sizeof(*_name_array)];

   212

		char *strto = tmp;

   213

   214

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

   215

			WChar c = (byte)*strfrom;

   216

			switch (c) {

   217

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

   218

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

   219

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

   220

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

   221

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

   222

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

   223

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

   224

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

   225

				default: break;

   226

			}

   227

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

   228

			strto += Utf8Encode(strto, c);

   229

		}

   230

   231

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

   232

		*strto = '\0';

   233

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

   234

	}

   235

}

   236

   237

// Calculate constants that depend on the landscape type.

   238

void InitializeLandscapeVariables(bool only_constants)

   239

{

   240

	const CargoTypesValues *lpd;

   241

	uint i;

   242

	StringID str;

   243

   244

	lpd = &_cargo_types_base_values[_opt.landscape];

   245

   246

	for (i = 0; i != NUM_CARGO; i++) {

   247

		_cargoc.sprites[i] = lpd->sprites[i];

   248

   249

		str = lpd->names[i];

   250

		_cargoc.names_s[i] = str;

   251

		_cargoc.names_long[i] = (str += 0x40);

   252

		_cargoc.names_short[i] = (str += 0x20);

   253

		_cargoc.weights[i] = lpd->weights[i];

   254

   255

		if (!only_constants) {

   256

			_cargo_payment_rates[i] = lpd->initial_cargo_payment[i];

   257

			_cargo_payment_rates_frac[i] = 0;

   258

		}

   259

   260

		_cargoc.transit_days_1[i] = lpd->transit_days_table_1[i];

   261

		_cargoc.transit_days_2[i] = lpd->transit_days_table_2[i];

   262

	}

   263

}

   264

   265

   266

   267

int FindFirstBit(uint32 value)

   268

{

   269

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

   270

	// not more than 128.

   271

	byte i = 0;

   272

   273

	if (value == 0) return 0;

   274

   275

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

   276

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

   277

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

   278

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

   279

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

   280

   281

	return i;

   282

}

   283

   284

   285

static void Save_NAME(void)

   286

{

   287

	int i;

   288

   289

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

   290

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

   291

			SlSetArrayIndex(i);

   292

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

   293

		}

   294

	}

   295

}

   296

   297

static void Load_NAME(void)

   298

{

   299

	int index;

   300

   301

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

   302

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

   303

	}

   304

}

   305

   306

static const SaveLoadGlobVarList _date_desc[] = {

   307

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

   308

	SLEG_CONDVAR(_date,                   SLE_INT32,                  31, SL_MAX_VERSION),

   309

	    SLEG_VAR(_date_fract,             SLE_UINT16),

   310

	    SLEG_VAR(_tick_counter,           SLE_UINT16),

   311

	    SLEG_VAR(_vehicle_id_ctr_day,     SLE_UINT16),

   312

	    SLEG_VAR(_age_cargo_skip_counter, SLE_UINT8),

   313

	    SLEG_VAR(_avail_aircraft,         SLE_UINT8),

   314

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

   315

	SLEG_CONDVAR(_cur_tileloop_tile,      SLE_UINT32,                  6, SL_MAX_VERSION),

   316

	    SLEG_VAR(_disaster_delay,         SLE_UINT16),

   317

	    SLEG_VAR(_station_tick_ctr,       SLE_UINT16),

   318

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

   319

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

   320

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

   321

	SLEG_CONDVAR(_cur_town_ctr,           SLE_UINT32,                 10, SL_MAX_VERSION),

   322

	    SLEG_VAR(_cur_player_tick_index,  SLE_FILE_U8  | SLE_VAR_U32),

   323

	    SLEG_VAR(_next_competitor_start,  SLE_FILE_U16 | SLE_VAR_U32),

   324

	    SLEG_VAR(_trees_tick_ctr,         SLE_UINT8),

   325

	SLEG_CONDVAR(_pause,                  SLE_UINT8,                   4, SL_MAX_VERSION),

   326

	SLEG_CONDVAR(_cur_town_iter,          SLE_UINT32,                 11, SL_MAX_VERSION),

   327

	    SLEG_END()

   328

};

   329

   330

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

   331

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

   332

static void SaveLoad_DATE(void)

   333

{

   334

	SlGlobList(_date_desc);

   335

}

   336

   337

   338

static const SaveLoadGlobVarList _view_desc[] = {

   339

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

   340

	SLEG_CONDVAR(_saved_scrollpos_x,    SLE_INT32,                  6, SL_MAX_VERSION),

   341

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

   342

	SLEG_CONDVAR(_saved_scrollpos_y,    SLE_INT32,                  6, SL_MAX_VERSION),

   343

	    SLEG_VAR(_saved_scrollpos_zoom, SLE_UINT8),

   344

	    SLEG_END()

   345

};

   346

   347

static void SaveLoad_VIEW(void)

   348

{

   349

	SlGlobList(_view_desc);

   350

}

   351

   352

static uint32 _map_dim_x;

   353

static uint32 _map_dim_y;

   354

   355

static const SaveLoadGlobVarList _map_dimensions[] = {

   356

	SLEG_CONDVAR(_map_dim_x, SLE_UINT32, 6, SL_MAX_VERSION),

   357

	SLEG_CONDVAR(_map_dim_y, SLE_UINT32, 6, SL_MAX_VERSION),

   358

	    SLEG_END()

   359

};

   360

   361

static void Save_MAPS(void)

   362

{

   363

	_map_dim_x = MapSizeX();

   364

	_map_dim_y = MapSizeY();

   365

	SlGlobList(_map_dimensions);

   366

}

   367

   368

static void Load_MAPS(void)

   369

{

   370

	SlGlobList(_map_dimensions);

   371

	AllocateMap(_map_dim_x, _map_dim_y);

   372

}

   373

   374

static void Load_MAPT(void)

   375

{

   376

	uint size = MapSize();

   377

	uint i;

   378

   379

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

   380

		byte buf[4096];

   381

		uint j;

   382

   383

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

   384

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

   385

	}

   386

}

   387

   388

static void Save_MAPT(void)

   389

{

   390

	uint size = MapSize();

   391

	uint i;

   392

   393

	SlSetLength(size);

   394

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

   395

		byte buf[4096];

   396

		uint j;

   397

   398

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

   399

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

   400

	}

   401

}

   402

   403

static void Load_MAP1(void)

   404

{

   405

	uint size = MapSize();

   406

	uint i;

   407

   408

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

   409

		byte buf[4096];

   410

		uint j;

   411

   412

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

   413

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

   414

	}

   415

}

   416

   417

static void Save_MAP1(void)

   418

{

   419

	uint size = MapSize();

   420

	uint i;

   421

   422

	SlSetLength(size);

   423

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

   424

		byte buf[4096];

   425

		uint j;

   426

   427

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

   428

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

   429

	}

   430

}

   431

   432

static void Load_MAP2(void)

   433

{

   434

	uint size = MapSize();

   435

	uint i;

   436

   437

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

   438

		uint16 buf[4096];

   439

		uint j;

   440

   441

		SlArray(buf, lengthof(buf),

   442

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

   443

			CheckSavegameVersion(5) ? SLE_FILE_U8 | SLE_VAR_U16 : SLE_UINT16

   444

		);

   445

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

   446

	}

   447

}

   448

   449

static void Save_MAP2(void)

   450

{

   451

	uint size = MapSize();

   452

	uint i;

   453

   454

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

   455

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

   456

		uint16 buf[4096];

   457

		uint j;

   458

   459

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

   460

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

   461

	}

   462

}

   463

   464

static void Load_MAP3(void)

   465

{

   466

	uint size = MapSize();

   467

	uint i;

   468

   469

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

   470

		byte buf[4096];

   471

		uint j;

   472

   473

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

   474

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

   475

	}

   476

}

   477

   478

static void Save_MAP3(void)

   479

{

   480

	uint size = MapSize();

   481

	uint i;

   482

   483

	SlSetLength(size);

   484

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

   485

		byte buf[4096];

   486

		uint j;

   487

   488

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

   489

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

   490

	}

   491

}

   492