1

/* $Id$ */

     2

     3

/** @file misc.cpp */

     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"

    29

    30

#include "table/strings.h"

    31

#include "table/sprites.h"

    32

    33

extern TileIndex _cur_tileloop_tile;

    34

    35

void InitializeVehicles();

    36

void InitializeWaypoints();

    37

void InitializeDepots();

    38

void InitializeEngines();

    39

void InitializeOrders();

    40

void InitializeClearLand();

    41

void InitializeRailGui();

    42

void InitializeRoadGui();

    43

void InitializeAirportGui();

    44

void InitializeDockGui();

    45

void InitializeIndustries();

    46

void InitializeTowns();

    47

void InitializeTrees();

    48

void InitializeSigns();

    49

void InitializeStations();

    50

void InitializeCargoPackets();

    51

void InitializePlayers();

    52

void InitializeCheats();

    53

void InitializeNPF();

    55

    56

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

    57

{

    58

	AllocateMap(size_x, size_y);

    59

    60

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

    61

    62

	_pause_game = 0;

    63

	_fast_forward = 0;

    64

	_tick_counter = 0;

    65

	_realtime_tick = 0;

    66

	_date_fract = 0;

    67

	_cur_tileloop_tile = 0;

    68

    69

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

    70

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

    71

	}

    72

    73

	InitializeEngines();

    74

	InitializeVehicles();

    75

	InitializeWaypoints();

    76

	InitializeDepots();

    77

	InitializeOrders();

    78

	InitializeGroup();

    79

    80

	InitNewsItemStructs();

    81

	InitializeLandscape();

    82

	InitializeClearLand();

    83

	InitializeRailGui();

    84

	InitializeRoadGui();

    85

	InitializeAirportGui();

    86

	InitializeDockGui();

    87

	InitializeTowns();

    88

	InitializeTrees();

    89

	InitializeSigns();

    90

	InitializeStations();

    91

	InitializeCargoPackets();

    92

	InitializeIndustries();

    93

	InitializeBuildingCounts();

    94

    96

	InitializeVehiclesGuiList();

    97

	InitializeTrains();

    98

	InitializeNPF();

    99

   100

	AI_Initialize();

   101

	InitializePlayers();

   102

	InitializeCheats();

   103

   104

	InitTextEffects();

   105

	InitChatMessage();

   106

	InitializeAnimatedTiles();

   107

   108

	InitializeLandscapeVariables(false);

   109

   110

	ResetObjectToPlace();

   111

}

   112

   113

   114

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

   115

void InitializeLandscapeVariables(bool only_constants)

   116

{

   117

	if (only_constants) return;

   118

   119

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

   120

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

   121

		_cargo_payment_rates_frac[i] = 0;

   122

	}

   123

}

   124

   125

static const SaveLoadGlobVarList _date_desc[] = {

   126

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

   127

	SLEG_CONDVAR(_date,                   SLE_INT32,                  31, SL_MAX_VERSION),

   128

	    SLEG_VAR(_date_fract,             SLE_UINT16),

   129

	    SLEG_VAR(_tick_counter,           SLE_UINT16),

   130

	    SLEG_VAR(_vehicle_id_ctr_day,     SLE_UINT16),

   131

	    SLEG_VAR(_age_cargo_skip_counter, SLE_UINT8),

   132

	SLE_CONDNULL(1, 0, 45),

   133

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

   134

	SLEG_CONDVAR(_cur_tileloop_tile,      SLE_UINT32,                  6, SL_MAX_VERSION),

   135

	    SLEG_VAR(_disaster_delay,         SLE_UINT16),

   136

	    SLEG_VAR(_station_tick_ctr,       SLE_UINT16),

   137

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

   138

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

   139

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

   140

	SLEG_CONDVAR(_cur_town_ctr,           SLE_UINT32,                 10, SL_MAX_VERSION),

   141

	    SLEG_VAR(_cur_player_tick_index,  SLE_FILE_U8  | SLE_VAR_U32),

   142

	    SLEG_VAR(_next_competitor_start,  SLE_FILE_U16 | SLE_VAR_U32),

   143

	    SLEG_VAR(_trees_tick_ctr,         SLE_UINT8),

   144

	SLEG_CONDVAR(_pause_game,             SLE_UINT8,                   4, SL_MAX_VERSION),

   145

	SLEG_CONDVAR(_cur_town_iter,          SLE_UINT32,                 11, SL_MAX_VERSION),

   146

	    SLEG_END()

   147

};

   148

   149

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

   150

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

   151

static void SaveLoad_DATE()

   152

{

   153

	SlGlobList(_date_desc);

   154

}

   155

   156

   157

static const SaveLoadGlobVarList _view_desc[] = {

   158

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

   159

	SLEG_CONDVAR(_saved_scrollpos_x,    SLE_INT32,                  6, SL_MAX_VERSION),

   160

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

   161

	SLEG_CONDVAR(_saved_scrollpos_y,    SLE_INT32,                  6, SL_MAX_VERSION),

   162

	    SLEG_VAR(_saved_scrollpos_zoom, SLE_UINT8),

   163

	    SLEG_END()

   164

};

   165

   166

static void SaveLoad_VIEW()

   167

{

   168

	SlGlobList(_view_desc);

   169

}

   170

   171

static uint32 _map_dim_x;

   172

static uint32 _map_dim_y;

   173

   174

static const SaveLoadGlobVarList _map_dimensions[] = {

   175

	SLEG_CONDVAR(_map_dim_x, SLE_UINT32, 6, SL_MAX_VERSION),

   176

	SLEG_CONDVAR(_map_dim_y, SLE_UINT32, 6, SL_MAX_VERSION),

   177

	    SLEG_END()

   178

};

   179

   180

static void Save_MAPS()

   181

{

   182

	_map_dim_x = MapSizeX();

   183

	_map_dim_y = MapSizeY();

   184

	SlGlobList(_map_dimensions);

   185

}

   186

   187

static void Load_MAPS()

   188

{

   189

	SlGlobList(_map_dimensions);

   190

	AllocateMap(_map_dim_x, _map_dim_y);

   191

}

   192

   193

enum {

   194

	MAP_SL_BUF_SIZE = 4096

   195

};

   196

   197

static void Load_MAPT()

   198

{

   199

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   200

	TileIndex size = MapSize();

   201

   202

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

   203

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   204

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

   205

	}

   206

}

   207

   208

static void Save_MAPT()

   209

{

   210

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   211

	TileIndex size = MapSize();

   212

   213

	SlSetLength(size);

   214

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

   215

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

   216

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   217

	}

   218

}

   219

   220

static void Load_MAP1()

   221

{

   222

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   223

	TileIndex size = MapSize();

   224

   225

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

   226

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   227

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

   228

	}

   229

}

   230

   231

static void Save_MAP1()

   232

{

   233

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   234

	TileIndex size = MapSize();

   235

   236

	SlSetLength(size);

   237

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

   238

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

   239

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   240

	}

   241

}

   242

   243

static void Load_MAP2()

   244

{

   245

	SmallStackSafeStackAlloc<uint16, MAP_SL_BUF_SIZE> buf;

   246

	TileIndex size = MapSize();

   247

   248

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

   249

		SlArray(buf, MAP_SL_BUF_SIZE,

   250

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

   251

			CheckSavegameVersion(5) ? SLE_FILE_U8 | SLE_VAR_U16 : SLE_UINT16

   252

		);

   253

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

   254

	}

   255

}

   256

   257

static void Save_MAP2()

   258

{

   259

	SmallStackSafeStackAlloc<uint16, MAP_SL_BUF_SIZE> buf;

   260

	TileIndex size = MapSize();

   261

   262

	SlSetLength(size * sizeof(uint16));

   263

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

   264

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

   265

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT16);

   266

	}

   267

}

   268

   269

static void Load_MAP3()

   270

{

   271

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   272

	TileIndex size = MapSize();

   273

   274

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

   275

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   276

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

   277

	}

   278

}

   279

   280

static void Save_MAP3()

   281

{

   282

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   283

	TileIndex size = MapSize();

   284

   285

	SlSetLength(size);

   286

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

   287

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

   288

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   289

	}

   290

}

   291

   292

static void Load_MAP4()

   293

{

   294

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   295

	TileIndex size = MapSize();

   296

   297

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

   298

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   299

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

   300

	}

   301

}

   302

   303

static void Save_MAP4()

   304

{

   305

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   306

	TileIndex size = MapSize();

   307

   308

	SlSetLength(size);

   309

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

   310

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

   311

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   312

	}

   313

}

   314

   315

static void Load_MAP5()

   316

{

   317

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   318

	TileIndex size = MapSize();

   319

   320

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

   321

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   322

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

   323

	}

   324

}

   325

   326

static void Save_MAP5()

   327

{

   328

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   329

	TileIndex size = MapSize();

   330

   331

	SlSetLength(size);

   332

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

   333

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

   334

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   335

	}

   336

}

   337

   338

static void Load_MAP6()

   339

{

   340

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   341

	TileIndex size = MapSize();

   342

   343

	if (CheckSavegameVersion(42)) {

   344

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

   345

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

   346

			SlArray(buf, 1024, SLE_UINT8);

   347

			for (uint j = 0; j != 1024; j++) {

   348

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

   349

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

   350

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

   351

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

   352

			}

   353

		}

   354

	} else {

   355

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

   356

			SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   357

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

   358

		}

   359

	}

   360

}

   361

   362

static void Save_MAP6()

   363

{

   364

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   365

	TileIndex size = MapSize();

   366

   367

	SlSetLength(size);

   368

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

   369

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

   370

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   371

	}

   372

}

   373

   374

static void Load_MAP7()

   375

{

   376

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   377

	TileIndex size = MapSize();

   378

   379

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

   380

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   381

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

   382

	}

   383

}

   384

   385

static void Save_MAP7()

   386

{

   387

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   388

	TileIndex size = MapSize();

   389

   390

	SlSetLength(size);

   391

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

   392

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

   393

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   394

	}

   395

}

   396

   397

extern const ChunkHandler _misc_chunk_handlers[] = {

   398

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

   399

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

   400

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

   401

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

   402

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

   403

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

   404

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

   405

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

   406

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

   407

   408

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

   409

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

   410

};