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

extern void StartupEconomy(void);

    23

    24

char _name_array[512][32];

    25

    26

#ifndef MERSENNE_TWISTER

    27

    28

#ifdef RANDOM_DEBUG

    29

#include "network_data.h"

    30

uint32 DoRandom(int line, const char *file)

    31

#else // RANDOM_DEBUG

    32

uint32 Random(void)

    33

#endif // RANDOM_DEBUG

    34

{

    35

    36

uint32 s;

    37

uint32 t;

    38

    39

#ifdef RANDOM_DEBUG

    40

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

    41

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

    42

#endif

    43

    44

	s = _random_seeds[0][0];

    45

	t = _random_seeds[0][1];

    46

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

    47

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

    48

}

    49

#endif // MERSENNE_TWISTER

    50

    51

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

    52

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

    53

{

    54

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

    55

}

    56

#else

    57

uint RandomRange(uint max)

    58

{

    59

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

    60

}

    61

#endif

    62

    63

    64

uint32 InteractiveRandom(void)

    65

{

    66

	uint32 t = _random_seeds[1][1];

    67

	uint32 s = _random_seeds[1][0];

    68

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

    69

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

    70

}

    71

    72

uint InteractiveRandomRange(uint max)

    73

{

    74

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

    75

}

    76

    77

void InitializeVehicles(void);

    78

void InitializeWaypoints(void);

    79

void InitializeDepot(void);

    80

void InitializeEngines(void);

    81

void InitializeOrders(void);

    82

void InitializeClearLand(void);

    83

void InitializeRailGui(void);

    84

void InitializeRoadGui(void);

    85

void InitializeAirportGui(void);

    86

void InitializeDockGui(void);

    87

void InitializeIndustries(void);

    88

void InitializeMainGui(void);

    89

void InitializeLandscape(void);

    90

void InitializeTowns(void);

    91

void InitializeTrees(void);

    92

void InitializeSigns(void);

    93

void InitializeStations(void);

    94

static void InitializeNameMgr(void);

    95

void InitializePlayers(void);

    96

static void InitializeCheats(void);

    97

void InitializeNPF(void);

    98

    99

void GenerateLandscape(void);

   100

void GenerateClearTile(void);

   101

   102

void GenerateIndustries(void);

   103

void GenerateUnmovables(void);

   104

bool GenerateTowns(void);

   105

   106

void StartupPlayers(void);

   107

void StartupDisasters(void);

   108

void GenerateTrees(void);

   109

   110

void ConvertGroundTilesIntoWaterTiles(void);

   111

   112

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

   113

{

   114

	AllocateMap(size_x, size_y);

   115

   116

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

   117

   118

	SetObjectToPlace(SPR_CURSOR_ZZZ, 0, 0, 0);

   119

   120

	_pause = 0;

   121

	_fast_forward = 0;

   122

	_tick_counter = 0;

   123

	_date_fract = 0;

   124

	_cur_tileloop_tile = 0;

   125

   126

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

   128

	}

   129

   130

	InitializeEngines();

   131

	InitializeVehicles();

   132

	InitializeWaypoints();

   133

	InitializeDepot();

   134

	InitializeOrders();

   135

   136

	InitNewsItemStructs();

   137

	InitializeLandscape();

   138

	InitializeClearLand();

   139

	InitializeRailGui();

   140

	InitializeRoadGui();

   141

	InitializeAirportGui();

   142

	InitializeDockGui();

   143

	InitializeTowns();

   144

	InitializeTrees();

   145

	InitializeSigns();

   146

	InitializeStations();

   147

	InitializeIndustries();

   148

	InitializeMainGui();

   149

   150

	InitializeNameMgr();

   151

	InitializeVehiclesGuiList();

   152

	InitializeTrains();

   153

	InitializeNPF();

   154

   155

	AI_Initialize();

   156

	InitializePlayers();

   157

	InitializeCheats();

   158

   159

	InitTextEffects();

   160

	InitTextMessage();

   161

	InitializeAnimatedTiles();

   162

   163

	InitializeLandscapeVariables(false);

   164

   165

	ResetObjectToPlace();

   166

}

   167

   168

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

   169

{

   170

	// Make sure everything is done via OWNER_NONE

   171

	_current_player = OWNER_NONE;

   172

   173

	UpdatePatches();

   174

   175

	_generating_world = true;

   176

	InitializeGame(mode == GW_RANDOM ? 0 : IG_DATE_RESET, size_x, size_y);

   177

	SetObjectToPlace(SPR_CURSOR_ZZZ, 0, 0, 0);

   178

   179

	// Must start economy early because of the costs.

   180

	StartupEconomy();

   181

   182

	// Don't generate landscape items when in the scenario editor.

   183

	if (mode == GW_EMPTY) {

   184

		// empty world in scenario editor

   185

		ConvertGroundTilesIntoWaterTiles();

   186

	} else {

   187

		GenerateLandscape();

   188

		GenerateClearTile();

   189

   190

		// only generate towns, tree and industries in newgame mode.

   191

		if (mode == GW_NEWGAME) {

   192

			GenerateTowns();

   193

			GenerateTrees();

   194

			GenerateIndustries();

   195

			GenerateUnmovables();

   196

		}

   197

	}

   198

   199

	// These are probably pointless when inside the scenario editor.

   200

	StartupPlayers();

   201

	StartupEngines();

   202

	StartupDisasters();

   203

	_generating_world = false;

   204

   205

	// No need to run the tile loop in the scenario editor.

   206

	if (mode != GW_EMPTY) {

   207

		uint i;

   208

   209

		for (i = 0; i < 0x500; i++) RunTileLoop();

   210

	}

   211

   212

	ResetObjectToPlace();

   213

}

   214

   215

void DeleteName(StringID id)

   216

{

   217

	if ((id & 0xF800) == 0x7800) {

   218

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

   219

	}

   220

}

   221

   222

char *GetName(int id, char *buff)

   223

{

   224

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

   225

}

   226

   227

   228

static void InitializeCheats(void)

   229

{

   230

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

   231

}

   232

   233

   234

static void InitializeNameMgr(void)

   235

{

   236

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

   237

}

   238

   239

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

   240

{

   241

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

   242

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

   243

   244

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

   245

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

   246

			if (free_item == NULL) free_item = i;

   247

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

   248

			_error_message = STR_0132_CHOSEN_NAME_IN_USE_ALREADY;

   249

			return 0;

   250

		}

   251

	}

   252

   253

	if (free_item != NULL) {

   254

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

   255

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

   256

	} else {

   257

		_error_message = STR_0131_TOO_MANY_NAMES_DEFINED;

   258

		return 0;

   259

	}

   260

}

   261

   262

// Calculate constants that depend on the landscape type.

   263

void InitializeLandscapeVariables(bool only_constants)

   264

{

   265

	const CargoTypesValues *lpd;

   266

	uint i;

   267

	StringID str;

   268

   269

	lpd = &_cargo_types_base_values[_opt.landscape];

   270

   271

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

   272

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

   273

   274

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

   275

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

   276

   277

		str = lpd->names[i];

   278

		_cargoc.names_s[i] = str;

   279

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

   280

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

   281

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

   282

   283

		if (!only_constants) {

   284

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

   285

			_cargo_payment_rates_frac[i] = 0;

   286

		}

   287

   288

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

   289

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

   290

	}

   291

}

   292

   293

   294

   295

int FindFirstBit(uint32 value)

   296

{

   297

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

   298

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

   299

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

   300

	//  not more than 128.

   301

	byte i = 0;

   302

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

   303

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

   304

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

   305

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

   306

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

   307

	return i;

   308

}

   309

   310

   311

static void Save_NAME(void)

   312

{

   313

	int i;

   314

   315

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

   316

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

   317

			SlSetArrayIndex(i);

   318

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

   319

		}

   320

	}

   321

}

   322

   323

static void Load_NAME(void)

   324

{

   325

	int index;

   326

   327

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

   328

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

   329

	}

   330

}

   331

   332

static const SaveLoadGlobVarList _date_desc[] = {

   333

	    SLEG_VAR(_date,                  SLE_UINT16),

   334

	    SLEG_VAR(_date_fract,            SLE_UINT16),

   335

	    SLEG_VAR(_tick_counter,          SLE_UINT16),

   336

	    SLEG_VAR(_vehicle_id_ctr_day,    SLE_UINT16),

   337

	    SLEG_VAR(_age_cargo_skip_counter,SLE_UINT8),

   338

	    SLEG_VAR(_avail_aircraft,        SLE_UINT8),

   339

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

   340

	SLEG_CONDVAR(_cur_tileloop_tile,     SLE_UINT32,                 6, SL_MAX_VERSION),

   341

	    SLEG_VAR(_disaster_delay,        SLE_UINT16),

   342

	    SLEG_VAR(_station_tick_ctr,      SLE_UINT16),

   343

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

   344

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

   345

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

   346

	SLEG_CONDVAR(_cur_town_ctr,          SLE_UINT32,                10, SL_MAX_VERSION),

   347

	    SLEG_VAR(_cur_player_tick_index, SLE_FILE_U8  | SLE_VAR_U32),

   348

	    SLEG_VAR(_next_competitor_start, SLE_FILE_U16 | SLE_VAR_U32),

   349

	    SLEG_VAR(_trees_tick_ctr,        SLE_UINT8),

   350

	SLEG_CONDVAR(_pause,                 SLE_UINT8,   4, SL_MAX_VERSION),

   351

	SLEG_CONDVAR(_cur_town_iter,         SLE_UINT32, 11, SL_MAX_VERSION),

   352

	    SLEG_END()

   353

};

   354

   355

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

   356

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

   357

static void SaveLoad_DATE(void)

   358

{

   359

	SlGlobList(_date_desc);

   360

}

   361

   362

   363

static const SaveLoadGlobVarList _view_desc[] = {

   364

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

   365

	SLEG_CONDVAR(_saved_scrollpos_x,   SLE_INT32,                  6, SL_MAX_VERSION),

   366

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

   367

	SLEG_CONDVAR(_saved_scrollpos_y,   SLE_INT32,                  6, SL_MAX_VERSION),

   368

	    SLEG_VAR(_saved_scrollpos_zoom,SLE_UINT8),

   369

	    SLEG_END()

   370

};

   371

   372

static void SaveLoad_VIEW(void)

   373

{

   374

	SlGlobList(_view_desc);

   375

}

   376

   377

static uint32 _map_dim_x;

   378

static uint32 _map_dim_y;

   379

   380

static const SaveLoadGlobVarList _map_dimensions[] = {

   381

	SLEG_CONDVAR(_map_dim_x, SLE_UINT32, 6, SL_MAX_VERSION),

   382

	SLEG_CONDVAR(_map_dim_y, SLE_UINT32, 6, SL_MAX_VERSION),

   383

	    SLEG_END()

   384

};

   385

   386

static void Save_MAPS(void)

   387

{

   388

	_map_dim_x = MapSizeX();

   389

	_map_dim_y = MapSizeY();

   390

	SlGlobList(_map_dimensions);

   391

}

   392

   393

static void Load_MAPS(void)

   394

{

   395

	SlGlobList(_map_dimensions);

   396

	AllocateMap(_map_dim_x, _map_dim_y);

   397

}

   398

   399

static void Load_MAPT(void)

   400

{

   401

	uint size = MapSize();

   402

	uint i;

   403

   404

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

   405

		byte buf[4096];

   406

		uint j;

   407

   408

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

   409

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

   410

	}

   411

}

   412

   413

static void Save_MAPT(void)

   414

{

   415

	uint size = MapSize();

   416

	uint i;

   417

   418

	SlSetLength(size);

   419

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

   420

		byte buf[4096];

   421

		uint j;

   422

   423

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

   424

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

   425

	}

   426

}

   427

   428

static void Load_MAP1(void)

   429

{

   430

	uint size = MapSize();

   431

	uint i;

   432

   433

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

   434

		byte buf[4096];

   435

		uint j;

   436

   437

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

   438

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

   439

	}

   440

}

   441

   442

static void Save_MAP1(void)

   443

{

   444

	uint size = MapSize();

   445

	uint i;

   446

   447

	SlSetLength(size);

   448

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

   449

		byte buf[4096];

   450

		uint j;

   451

   452

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

   453

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

   454

	}

   455

}

   456

   457

static void Load_MAP2(void)

   458

{

   459

	uint size = MapSize();

   460

	uint i;

   461

   462

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

   463

		uint16 buf[4096];

   464

		uint j;

   465

   466

		SlArray(buf, lengthof(buf),

   467

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

   468

			CheckSavegameVersion(5) ? SLE_FILE_U8 | SLE_VAR_U16 : SLE_UINT16

   469

		);

   470

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

   471

	}

   472

}

   473

   474

static void Save_MAP2(void)

   475

{

   476

	uint size = MapSize();

   477

	uint i;

   478

   479

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

   480

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

   481

		uint16 buf[4096];

   482

		uint j;

   483

   484

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

   485

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

   486

	}

   487

}

   488

   489

static void Load_MAP3(void)

   490

{

   491

	uint size = MapSize();

   492

	uint i;

   493

   494

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