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(int id, char *buff)

   166

{

   167

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

   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

// Calculate constants that depend on the landscape type.

   206

void InitializeLandscapeVariables(bool only_constants)

   207

{

   208

	const CargoTypesValues *lpd;

   209

	uint i;

   210

	StringID str;

   211

   212

	lpd = &_cargo_types_base_values[_opt.landscape];

   213

   214

	memcpy(_cargoc.ai_roadveh_start, lpd->road_veh_by_cargo_start,sizeof(lpd->road_veh_by_cargo_start));

   215

	memcpy(_cargoc.ai_roadveh_count, lpd->road_veh_by_cargo_count,sizeof(lpd->road_veh_by_cargo_count));

   216

   217

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

   218

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

   219

   220

		str = lpd->names[i];

   221

		_cargoc.names_s[i] = str;

   222

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

   223

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

   224

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

   225

   226

		if (!only_constants) {

   227

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

   228

			_cargo_payment_rates_frac[i] = 0;

   229

		}

   230

   231

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

   232

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

   233

	}

   234

}

   235

   236

   237

   238

int FindFirstBit(uint32 value)

   239

{

   240

	// This is much faster than the one that was before here.

   241

	//  Created by Darkvater.. blame him if it is wrong ;)

   242

	// Btw, the macro FINDFIRSTBIT is better to use when your value is

   243

	//  not more than 128.

   244

	byte i = 0;

   245

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

   246

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

   247

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

   248

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

   249

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

   250

	return i;

   251

}

   252

   253

   254

static void Save_NAME(void)

   255

{

   256

	int i;

   257

   258

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

   259

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

   260

			SlSetArrayIndex(i);

   261

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

   262

		}

   263

	}

   264

}

   265

   266

static void Load_NAME(void)

   267

{

   268

	int index;

   269

   270

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

   271

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

   272

	}

   273

}

   274

   275

static const SaveLoadGlobVarList _date_desc[] = {

   276

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

   277

	SLEG_CONDVAR(_date,                   SLE_INT32,                  31, SL_MAX_VERSION),

   278

	    SLEG_VAR(_date_fract,             SLE_UINT16),

   279

	    SLEG_VAR(_tick_counter,           SLE_UINT16),

   280

	    SLEG_VAR(_vehicle_id_ctr_day,     SLE_UINT16),

   281

	    SLEG_VAR(_age_cargo_skip_counter, SLE_UINT8),

   282

	    SLEG_VAR(_avail_aircraft,         SLE_UINT8),

   283

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

   284

	SLEG_CONDVAR(_cur_tileloop_tile,      SLE_UINT32,                  6, SL_MAX_VERSION),

   285

	    SLEG_VAR(_disaster_delay,         SLE_UINT16),

   286

	    SLEG_VAR(_station_tick_ctr,       SLE_UINT16),

   287

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

   288

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

   289

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

   290

	SLEG_CONDVAR(_cur_town_ctr,           SLE_UINT32,                 10, SL_MAX_VERSION),

   291

	    SLEG_VAR(_cur_player_tick_index,  SLE_FILE_U8  | SLE_VAR_U32),

   292

	    SLEG_VAR(_next_competitor_start,  SLE_FILE_U16 | SLE_VAR_U32),

   293

	    SLEG_VAR(_trees_tick_ctr,         SLE_UINT8),

   294

	SLEG_CONDVAR(_pause,                  SLE_UINT8,                   4, SL_MAX_VERSION),

   295

	SLEG_CONDVAR(_cur_town_iter,          SLE_UINT32,                 11, SL_MAX_VERSION),

   296

	    SLEG_END()

   297

};

   298

   299

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

   300

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

   301

static void SaveLoad_DATE(void)

   302

{

   303

	SlGlobList(_date_desc);

   304

}

   305

   306

   307

static const SaveLoadGlobVarList _view_desc[] = {

   308

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

   309

	SLEG_CONDVAR(_saved_scrollpos_x,    SLE_INT32,                  6, SL_MAX_VERSION),

   310

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

   311

	SLEG_CONDVAR(_saved_scrollpos_y,    SLE_INT32,                  6, SL_MAX_VERSION),

   312

	    SLEG_VAR(_saved_scrollpos_zoom, SLE_UINT8),

   313

	    SLEG_END()

   314

};

   315

   316

static void SaveLoad_VIEW(void)

   317

{

   318

	SlGlobList(_view_desc);

   319

}

   320

   321

static uint32 _map_dim_x;

   322

static uint32 _map_dim_y;

   323

   324

static const SaveLoadGlobVarList _map_dimensions[] = {

   325

	SLEG_CONDVAR(_map_dim_x, SLE_UINT32, 6, SL_MAX_VERSION),

   326

	SLEG_CONDVAR(_map_dim_y, SLE_UINT32, 6, SL_MAX_VERSION),

   327

	    SLEG_END()

   328

};

   329

   330

static void Save_MAPS(void)

   331

{

   332

	_map_dim_x = MapSizeX();

   333

	_map_dim_y = MapSizeY();

   334

	SlGlobList(_map_dimensions);

   335

}

   336

   337

static void Load_MAPS(void)

   338

{

   339

	SlGlobList(_map_dimensions);

   340

	AllocateMap(_map_dim_x, _map_dim_y);

   341

}

   342

   343

static void Load_MAPT(void)

   344

{

   345

	uint size = MapSize();

   346

	uint i;

   347

   348

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

   349

		byte buf[4096];

   350

		uint j;

   351

   352

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

   353

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

   354

	}

   355

}

   356

   357

static void Save_MAPT(void)

   358

{

   359

	uint size = MapSize();

   360

	uint i;

   361

   362

	SlSetLength(size);

   363

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

   364

		byte buf[4096];

   365

		uint j;

   366

   367

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

   368

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

   369

	}

   370

}

   371

   372

static void Load_MAP1(void)

   373

{

   374

	uint size = MapSize();

   375

	uint i;

   376

   377

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

   378

		byte buf[4096];

   379

		uint j;

   380

   381

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

   382

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

   383

	}

   384

}

   385

   386

static void Save_MAP1(void)

   387

{

   388

	uint size = MapSize();

   389

	uint i;

   390

   391

	SlSetLength(size);

   392

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

   393

		byte buf[4096];

   394

		uint j;

   395

   396

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

   397

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

   398

	}

   399

}

   400

   401

static void Load_MAP2(void)

   402

{

   403

	uint size = MapSize();

   404

	uint i;

   405

   406

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

   407

		uint16 buf[4096];

   408

		uint j;

   409

   410

		SlArray(buf, lengthof(buf),

   411

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

   412

			CheckSavegameVersion(5) ? SLE_FILE_U8 | SLE_VAR_U16 : SLE_UINT16

   413

		);

   414

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

   415

	}

   416

}

   417

   418

static void Save_MAP2(void)

   419

{

   420

	uint size = MapSize();

   421

	uint i;

   422

   423

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

   424

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

   425

		uint16 buf[4096];

   426

		uint j;

   427

   428

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

   429

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

   430

	}

   431

}

   432

   433

static void Load_MAP3(void)

   434

{

   435

	uint size = MapSize();

   436

	uint i;

   437

   438

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

   439

		byte buf[4096];

   440

		uint j;

   441

   442

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

   443

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

   444

	}

   445

}

   446

   447

static void Save_MAP3(void)

   448

{

   449

	uint size = MapSize();

   450

	uint i;

   451

   452

	SlSetLength(size);

   453

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

   454

		byte buf[4096];

   455

		uint j;

   456

   457

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

   458

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

   459

	}

   460

}

   461

   462

static void Load_MAP4(void)

   463

{

   464

	uint size = MapSize();

   465

	uint i;

   466

   467

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

   468

		byte buf[4096];

   469

		uint j;

   470

   471

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

   472

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

   473

	}

   474

}

   475

   476

static void Save_MAP4(void)

   477

{

   478

	uint size = MapSize();

   479

	uint i;

   480

   481

	SlSetLength(size);

   482

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

   483

		byte buf[4096];

   484

		uint j;

   485

   486

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

   487

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

   488

	}

   489

}

   490

   491

static void Load_MAP5(void)

   492

{