1

/* $Id$ */

     2

     3

/** @file misc.cpp Misc functions that shouldn't be here. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "currency.h"

     8

#include "landscape.h"

     9

#include "news_func.h"

    10

#include "saveload.h"

    11

#include "vehicle_gui.h"

    12

#include "variables.h"

    13

#include "cheat_func.h"

    14

#include "ai/ai.h"

    15

#include "newgrf_house.h"

    16

#include "cargotype.h"

    17

#include "group.h"

    18

#include "viewport_func.h"

    19

#include "economy_func.h"

    20

#include "zoom_func.h"

    21

#include "functions.h"

    22

#include "map_func.h"

    23

#include "date_func.h"

    24

#include "vehicle_func.h"

    25

#include "texteff.hpp"

    26

#include "gfx_func.h"

    27

#include "core/alloc_type.hpp"

    28

#include "gamelog.h"

    29

#include "animated_tile_func.h"

    30

#include "tilehighlight_func.h"

    31

#include "core/bitmath_func.hpp"

    32

#include "network/network_func.h"

    33

    34

#include "table/strings.h"

    35

#include "table/sprites.h"

    36

    37

extern TileIndex _cur_tileloop_tile;

    38

    39

void InitializeVehicles();

    40

void InitializeWaypoints();

    41

void InitializeDepots();

    42

void InitializeEngineRenews();

    43

void InitializeOrders();

    44

void InitializeClearLand();

    45

void InitializeRailGui();

    46

void InitializeRoadGui();

    47

void InitializeAirportGui();

    48

void InitializeDockGui();

    49

void InitializeIndustries();

    50

void InitializeTowns();

    51

void InitializeTrees();

    52

void InitializeSigns();

    53

void InitializeStations();

    54

void InitializeCargoPackets();

    55

void InitializeCompanies();

    56

void InitializeCheats();

    57

void InitializeNPF();

    58

void InitializeOldNames();

    59

    60

void InitializeGame(uint size_x, uint size_y, bool reset_date)

    61

{

    62

	AllocateMap(size_x, size_y);

    63

    64

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

    65

    66

	_pause_game = 0;

    67

	_fast_forward = 0;

    68

	_tick_counter = 0;

    69

	_realtime_tick = 0;

    70

	_date_fract = 0;

    71

	_cur_tileloop_tile = 0;

    72

	_settings_game = _settings_newgame;

    73

    74

	if (reset_date) {

    75

		SetDate(ConvertYMDToDate(_settings_game.game_creation.starting_year, 0, 1));

    76

		InitializeOldNames();

    77

	}

    78

    79

	InitializeEngineRenews();

    80

	InitializeVehicles();

    81

	InitializeWaypoints();

    82

	InitializeDepots();

    83

	InitializeOrders();

    84

	InitializeGroup();

    85

    86

	InitNewsItemStructs();

    87

	InitializeLandscape();

    88

	InitializeClearLand();

    89

	InitializeRailGui();

    90

	InitializeRoadGui();

    91

	InitializeAirportGui();

    92

	InitializeDockGui();

    93

	InitializeTowns();

    94

	InitializeTrees();

    95

	InitializeSigns();

    96

	InitializeStations();

    97

	InitializeCargoPackets();

    98

	InitializeIndustries();

    99

	InitializeBuildingCounts();

   100

   101

	InitializeTrains();

   102

	InitializeNPF();

   103

   104

	InitializeCompanies();

   105

	AI_Initialize();

   106

	InitializeCheats();

   107

   108

	InitTextEffects();

   109

#ifdef ENABLE_NETWORK

   110

	NetworkInitChatMessage();

   111

#endif /* ENABLE_NETWORK */

   112

	InitializeAnimatedTiles();

   113

   114

	InitializeLandscapeVariables(false);

   115

   116

	ResetObjectToPlace();

   117

   118

	GamelogReset();

   119

	GamelogStartAction(GLAT_START);

   120

	GamelogRevision();

   121

	GamelogMode();

   122

	GamelogGRFAddList(_grfconfig);

   123

	GamelogStopAction();

   124

}

   125

   126

   127

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

   128

void InitializeLandscapeVariables(bool only_constants)

   129

{

   130

	if (only_constants) return;

   131

   132

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

   133

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

   134

		_cargo_payment_rates_frac[i] = 0;

   135

	}

   136

}

   137

   138

static const SaveLoadGlobVarList _date_desc[] = {

   139

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

   140

	SLEG_CONDVAR(_date,                   SLE_INT32,                  31, SL_MAX_VERSION),

   141

	    SLEG_VAR(_date_fract,             SLE_UINT16),

   142

	    SLEG_VAR(_tick_counter,           SLE_UINT16),

   143

	    SLEG_VAR(_vehicle_id_ctr_day,     SLE_UINT16),

   144

	    SLEG_VAR(_age_cargo_skip_counter, SLE_UINT8),

   145

	SLE_CONDNULL(1, 0, 45),

   146

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

   147

	SLEG_CONDVAR(_cur_tileloop_tile,      SLE_UINT32,                  6, SL_MAX_VERSION),

   148

	    SLEG_VAR(_disaster_delay,         SLE_UINT16),

   149

	    SLEG_VAR(_station_tick_ctr,       SLE_UINT16),

   150

	    SLEG_VAR(_random.state[0],        SLE_UINT32),

   151

	    SLEG_VAR(_random.state[1],        SLE_UINT32),

   152

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

   153

	SLEG_CONDVAR(_cur_town_ctr,           SLE_UINT32,                 10, SL_MAX_VERSION),

   154

	    SLEG_VAR(_cur_company_tick_index, SLE_FILE_U8  | SLE_VAR_U32),

   155

	    SLEG_VAR(_next_competitor_start,  SLE_FILE_U16 | SLE_VAR_U32),

   156

	    SLEG_VAR(_trees_tick_ctr,         SLE_UINT8),

   157

	SLEG_CONDVAR(_pause_game,             SLE_UINT8,                   4, SL_MAX_VERSION),

   158

	SLEG_CONDVAR(_cur_town_iter,          SLE_UINT32,                 11, SL_MAX_VERSION),

   159

	    SLEG_END()

   160

};

   161

   162

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

   163

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

   164

static void SaveLoad_DATE()

   165

{

   166

	SlGlobList(_date_desc);

   167

}

   168

   169

   170

static const SaveLoadGlobVarList _view_desc[] = {

   171

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

   172

	SLEG_CONDVAR(_saved_scrollpos_x,    SLE_INT32,                  6, SL_MAX_VERSION),

   173

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

   174

	SLEG_CONDVAR(_saved_scrollpos_y,    SLE_INT32,                  6, SL_MAX_VERSION),

   175

	    SLEG_VAR(_saved_scrollpos_zoom, SLE_UINT8),

   176

	    SLEG_END()

   177

};

   178

   179

static void SaveLoad_VIEW()

   180

{

   181

	SlGlobList(_view_desc);

   182

}

   183

   184

static uint32 _map_dim_x;

   185

static uint32 _map_dim_y;

   186

   187

static const SaveLoadGlobVarList _map_dimensions[] = {

   188

	SLEG_CONDVAR(_map_dim_x, SLE_UINT32, 6, SL_MAX_VERSION),

   189

	SLEG_CONDVAR(_map_dim_y, SLE_UINT32, 6, SL_MAX_VERSION),

   190

	    SLEG_END()

   191

};

   192

   193

static void Save_MAPS()

   194

{

   195

	_map_dim_x = MapSizeX();

   196

	_map_dim_y = MapSizeY();

   197

	SlGlobList(_map_dimensions);

   198

}

   199

   200

static void Load_MAPS()

   201

{

   202

	SlGlobList(_map_dimensions);

   203

	AllocateMap(_map_dim_x, _map_dim_y);

   204

}

   205

   206

enum {

   207

	MAP_SL_BUF_SIZE = 4096

   208

};

   209

   210

static void Load_MAPT()

   211

{

   212

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   213

	TileIndex size = MapSize();

   214

   215

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

   216

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   217

		for (uint j = 0; j != MAP_SL_BUF_SIZE && i != size; j++) _m[i++].type_height = buf[j];

   218

	}

   219

}

   220

   221

static void Save_MAPT()

   222

{

   223

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   224

	TileIndex size = MapSize();

   225

   226

	SlSetLength(size);

   227

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

   228

		for (uint j = 0; j != MAP_SL_BUF_SIZE && i != size; j++) buf[j] = _m[i++].type_height;

   229

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   230

	}

   231

}

   232

   233

static void Load_MAP1()

   234

{

   235

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   236

	TileIndex size = MapSize();

   237

   238

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

   239

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   240

		for (uint j = 0; j != MAP_SL_BUF_SIZE && i != size; j++) _m[i++].m1 = buf[j];

   241

	}

   242

}

   243

   244

static void Save_MAP1()

   245

{

   246

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   247

	TileIndex size = MapSize();

   248

   249

	SlSetLength(size);

   250

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

   251

		for (uint j = 0; j != MAP_SL_BUF_SIZE && i != size; j++) buf[j] = _m[i++].m1;

   252

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   253

	}

   254

}

   255

   256

static void Load_MAP2()

   257

{

   258

	SmallStackSafeStackAlloc<uint16, MAP_SL_BUF_SIZE> buf;

   259

	TileIndex size = MapSize();

   260

   261

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

   262

		SlArray(buf, MAP_SL_BUF_SIZE,

   263

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

   264

			CheckSavegameVersion(5) ? SLE_FILE_U8 | SLE_VAR_U16 : SLE_UINT16

   265

		);

   266

		for (uint j = 0; j != MAP_SL_BUF_SIZE && i != size; j++) _m[i++].m2 = buf[j];

   267

	}

   268

}

   269

   270

static void Save_MAP2()

   271

{

   272

	SmallStackSafeStackAlloc<uint16, MAP_SL_BUF_SIZE> buf;

   273

	TileIndex size = MapSize();

   274

   275

	SlSetLength(size * sizeof(uint16));

   276

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

   277

		for (uint j = 0; j != MAP_SL_BUF_SIZE && i != size; j++) buf[j] = _m[i++].m2;

   278

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT16);

   279

	}

   280

}

   281

   282

static void Load_MAP3()

   283

{

   284

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   285

	TileIndex size = MapSize();

   286

   287

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

   288

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   289

		for (uint j = 0; j != MAP_SL_BUF_SIZE && i != size; j++) _m[i++].m3 = buf[j];

   290

	}

   291

}

   292

   293

static void Save_MAP3()

   294

{

   295

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   296

	TileIndex size = MapSize();

   297

   298

	SlSetLength(size);

   299

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

   300

		for (uint j = 0; j != MAP_SL_BUF_SIZE && i != size; j++) buf[j] = _m[i++].m3;

   301

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   302

	}

   303

}

   304

   305

static void Load_MAP4()

   306

{

   307

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   308

	TileIndex size = MapSize();

   309

   310

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

   311

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   312

		for (uint j = 0; j != MAP_SL_BUF_SIZE && i != size; j++) _m[i++].m4 = buf[j];

   313

	}

   314

}

   315

   316

static void Save_MAP4()

   317

{

   318

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   319

	TileIndex size = MapSize();

   320

   321

	SlSetLength(size);

   322

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

   323

		for (uint j = 0; j != MAP_SL_BUF_SIZE && i != size; j++) buf[j] = _m[i++].m4;

   324

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   325

	}

   326

}

   327

   328

static void Load_MAP5()

   329

{

   330

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   331

	TileIndex size = MapSize();

   332

   333

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

   334

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   335

		for (uint j = 0; j != MAP_SL_BUF_SIZE && i != size; j++) _m[i++].m5 = buf[j];

   336

	}

   337

}

   338

   339

static void Save_MAP5()

   340

{

   341

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   342

	TileIndex size = MapSize();

   343

   344

	SlSetLength(size);

   345

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

   346

		for (uint j = 0; j != MAP_SL_BUF_SIZE && i != size; j++) buf[j] = _m[i++].m5;

   347

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   348

	}

   349

}

   350

   351

static void Load_MAP6()

   352

{

   353

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   354

	TileIndex size = MapSize();

   355

   356

	if (CheckSavegameVersion(42)) {

   357

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

   358

			/* 1024, otherwise we overflow on 64x64 maps! */

   359

            /* XXX: fail */

   360

			SlArray(buf, 1024, SLE_UINT8);

   361

			for (uint j = 0; j != 1024 && i < size - 4; j++) {

   362

				_m[i++].m6 = GB(buf[j], 0, 2);

   363

				_m[i++].m6 = GB(buf[j], 2, 2);

   364

				_m[i++].m6 = GB(buf[j], 4, 2);

   365

				_m[i++].m6 = GB(buf[j], 6, 2);

   366

			}

   367

		}

   368

	} else {

   369

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

   370

			SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   371

			for (uint j = 0; j != MAP_SL_BUF_SIZE && i != size; j++) _m[i++].m6 = buf[j];

   372

		}

   373

	}

   374

}

   375

   376

static void Save_MAP6()

   377

{

   378

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   379

	TileIndex size = MapSize();

   380

   381

	SlSetLength(size);

   382

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

   383

		for (uint j = 0; j != MAP_SL_BUF_SIZE && i != size; j++) buf[j] = _m[i++].m6;

   384

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   385

	}

   386

}

   387

   388

static void Load_MAP7()

   389

{

   390

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   391

	TileIndex size = MapSize();

   392

   393

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

   394

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   395

		for (uint j = 0; j != MAP_SL_BUF_SIZE && i != size; j++) _me[i++].m7 = buf[j];

   396

	}

   397

}

   398

   399

static void Save_MAP7()

   400

{

   401

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   402

	TileIndex size = MapSize();

   403

   404

	SlSetLength(size);

   405

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

   406

		for (uint j = 0; j != MAP_SL_BUF_SIZE && i != size; j++) buf[j] = _me[i++].m7;

   407

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   408

	}

   409

}

   410

   411

extern const ChunkHandler _misc_chunk_handlers[] = {

   412

	{ 'MAPS', Save_MAPS,     Load_MAPS,     CH_RIFF },

   413

	{ 'MAPT', Save_MAPT,     Load_MAPT,     CH_RIFF },

   414

	{ 'MAPO', Save_MAP1,     Load_MAP1,     CH_RIFF },

   415

	{ 'MAP2', Save_MAP2,     Load_MAP2,     CH_RIFF },

   416

	{ 'M3LO', Save_MAP3,     Load_MAP3,     CH_RIFF },

   417

	{ 'M3HI', Save_MAP4,     Load_MAP4,     CH_RIFF },

   418

	{ 'MAP5', Save_MAP5,     Load_MAP5,     CH_RIFF },

   419

	{ 'MAPE', Save_MAP6,     Load_MAP6,     CH_RIFF },

   420

	{ 'MAP7', Save_MAP7,     Load_MAP7,     CH_RIFF },

   421

   422

	{ 'DATE', SaveLoad_DATE, SaveLoad_DATE, CH_RIFF},

   423

	{ 'VIEW', SaveLoad_VIEW, SaveLoad_VIEW, CH_RIFF | CH_LAST},

   424

};