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

    33

#include "table/strings.h"

    34

#include "table/sprites.h"

    35

    36

extern TileIndex _cur_tileloop_tile;

    37

    38

void InitializeVehicles();

    39

void InitializeWaypoints();

    40

void InitializeDepots();

    41

void InitializeEngines();

    42

void InitializeOrders();

    43

void InitializeClearLand();

    44

void InitializeRailGui();

    45

void InitializeRoadGui();

    46

void InitializeAirportGui();

    47

void InitializeDockGui();

    48

void InitializeIndustries();

    49

void InitializeTowns();

    50

void InitializeTrees();

    51

void InitializeSigns();

    52

void InitializeStations();

    53

void InitializeCargoPackets();

    54

void InitializePlayers();

    55

void InitializeCheats();

    56

void InitializeNPF();

    57

void InitializeOldNames();

    58

    59

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

    60

{

    61

	AllocateMap(size_x, size_y);

    62

    63

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

    64

    65

	_pause_game = 0;

    66

	_fast_forward = 0;

    67

	_tick_counter = 0;

    68

	_realtime_tick = 0;

    69

	_date_fract = 0;

    70

	_cur_tileloop_tile = 0;

    71

	_settings_game = _settings_newgame;

    72

    73

	if (reset_date) {

    74

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

    75

		InitializeOldNames();

    76

	}

    77

    78

	InitializeEngines();

    79

	InitializeVehicles();

    80

	InitializeWaypoints();

    81

	InitializeDepots();

    82

	InitializeOrders();

    83

	InitializeGroup();

    84

    85

	InitNewsItemStructs();

    86

	InitializeLandscape();

    87

	InitializeClearLand();

    88

	InitializeRailGui();

    89

	InitializeRoadGui();

    90

	InitializeAirportGui();

    91

	InitializeDockGui();

    92

	InitializeTowns();

    93

	InitializeTrees();

    94

	InitializeSigns();

    95

	InitializeStations();

    96

	InitializeCargoPackets();

    97

	InitializeIndustries();

    98

	InitializeBuildingCounts();

    99

   100

	InitializeTrains();

   101

	InitializeNPF();

   102

   103

	AI_Initialize();

   104

	InitializePlayers();

   105

	InitializeCheats();

   106

   107

	InitTextEffects();

   108

	InitChatMessage();

   109

	InitializeAnimatedTiles();

   110

   111

	InitializeLandscapeVariables(false);

   112

   113

	ResetObjectToPlace();

   114

   115

	GamelogReset();

   116

	GamelogStartAction(GLAT_START);

   117

	GamelogRevision();

   118

	GamelogMode();

   119

	GamelogGRFAddList(_grfconfig);

   120

	GamelogStopAction();

   121

}

   122

   123

   124

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

   125

void InitializeLandscapeVariables(bool only_constants)

   126

{

   127

	if (only_constants) return;

   128

   129

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

   130

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

   131

		_cargo_payment_rates_frac[i] = 0;

   132

	}

   133

}

   134

   135

static const SaveLoadGlobVarList _date_desc[] = {

   136

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

   137

	SLEG_CONDVAR(_date,                   SLE_INT32,                  31, SL_MAX_VERSION),

   138

	    SLEG_VAR(_date_fract,             SLE_UINT16),

   139

	    SLEG_VAR(_tick_counter,           SLE_UINT16),

   140

	    SLEG_VAR(_vehicle_id_ctr_day,     SLE_UINT16),

   141

	    SLEG_VAR(_age_cargo_skip_counter, SLE_UINT8),

   142

	SLE_CONDNULL(1, 0, 45),

   143

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

   144

	SLEG_CONDVAR(_cur_tileloop_tile,      SLE_UINT32,                  6, SL_MAX_VERSION),

   145

	    SLEG_VAR(_disaster_delay,         SLE_UINT16),

   146

	    SLEG_VAR(_station_tick_ctr,       SLE_UINT16),

   147

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

   148

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

   149

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

   150

	SLEG_CONDVAR(_cur_town_ctr,           SLE_UINT32,                 10, SL_MAX_VERSION),

   151

	    SLEG_VAR(_cur_player_tick_index,  SLE_FILE_U8  | SLE_VAR_U32),

   152

	    SLEG_VAR(_next_competitor_start,  SLE_FILE_U16 | SLE_VAR_U32),

   153

	    SLEG_VAR(_trees_tick_ctr,         SLE_UINT8),

   154

	SLEG_CONDVAR(_pause_game,             SLE_UINT8,                   4, SL_MAX_VERSION),

   155

	SLEG_CONDVAR(_cur_town_iter,          SLE_UINT32,                 11, SL_MAX_VERSION),

   156

	    SLEG_END()

   157

};

   158

   159

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

   160

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

   161

static void SaveLoad_DATE()

   162

{

   163

	SlGlobList(_date_desc);

   164

}

   165

   166

   167

static const SaveLoadGlobVarList _view_desc[] = {

   168

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

   169

	SLEG_CONDVAR(_saved_scrollpos_x,    SLE_INT32,                  6, SL_MAX_VERSION),

   170

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

   171

	SLEG_CONDVAR(_saved_scrollpos_y,    SLE_INT32,                  6, SL_MAX_VERSION),

   172

	    SLEG_VAR(_saved_scrollpos_zoom, SLE_UINT8),

   173

	    SLEG_END()

   174

};

   175

   176

static void SaveLoad_VIEW()

   177

{

   178

	SlGlobList(_view_desc);

   179

}

   180

   181

static uint32 _map_dim_x;

   182

static uint32 _map_dim_y;

   183

   184

static const SaveLoadGlobVarList _map_dimensions[] = {

   185

	SLEG_CONDVAR(_map_dim_x, SLE_UINT32, 6, SL_MAX_VERSION),

   186

	SLEG_CONDVAR(_map_dim_y, SLE_UINT32, 6, SL_MAX_VERSION),

   187

	    SLEG_END()

   188

};

   189

   190

static void Save_MAPS()

   191

{

   192

	_map_dim_x = MapSizeX();

   193

	_map_dim_y = MapSizeY();

   194

	SlGlobList(_map_dimensions);

   195

}

   196

   197

static void Load_MAPS()

   198

{

   199

	SlGlobList(_map_dimensions);

   200

	AllocateMap(_map_dim_x, _map_dim_y);

   201

}

   202

   203

enum {

   204

	MAP_SL_BUF_SIZE = 4096

   205

};

   206

   207

static void Load_MAPT()

   208

{

   209

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   210

	TileIndex size = MapSize();

   211

   212

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

   213

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   214

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

   215

	}

   216

}

   217

   218

static void Save_MAPT()

   219

{

   220

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   221

	TileIndex size = MapSize();

   222

   223

	SlSetLength(size);

   224

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

   225

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

   226

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   227

	}

   228

}

   229

   230

static void Load_MAP1()

   231

{

   232

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   233

	TileIndex size = MapSize();

   234

   235

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

   236

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   237

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

   238

	}

   239

}

   240

   241

static void Save_MAP1()

   242

{

   243

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   244

	TileIndex size = MapSize();

   245

   246

	SlSetLength(size);

   247

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

   248

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

   249

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   250

	}

   251

}

   252

   253

static void Load_MAP2()

   254

{

   255

	SmallStackSafeStackAlloc<uint16, MAP_SL_BUF_SIZE> buf;

   256

	TileIndex size = MapSize();

   257

   258

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

   259

		SlArray(buf, MAP_SL_BUF_SIZE,

   260

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

   261

			CheckSavegameVersion(5) ? SLE_FILE_U8 | SLE_VAR_U16 : SLE_UINT16

   262

		);

   263

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

   264

	}

   265

}

   266

   267

static void Save_MAP2()

   268

{

   269

	SmallStackSafeStackAlloc<uint16, MAP_SL_BUF_SIZE> buf;

   270

	TileIndex size = MapSize();

   271

   272

	SlSetLength(size * sizeof(uint16));

   273

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

   274

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

   275

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT16);

   276

	}

   277

}

   278

   279

static void Load_MAP3()

   280

{

   281

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   282

	TileIndex size = MapSize();

   283

   284

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

   285

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   286

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

   287

	}

   288

}

   289

   290

static void Save_MAP3()

   291

{

   292

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   293

	TileIndex size = MapSize();

   294

   295

	SlSetLength(size);

   296

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

   297

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

   298

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   299

	}

   300

}

   301

   302

static void Load_MAP4()

   303

{

   304

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   305

	TileIndex size = MapSize();

   306

   307

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

   308

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   309

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

   310

	}

   311

}

   312

   313

static void Save_MAP4()

   314

{

   315

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   316

	TileIndex size = MapSize();

   317

   318

	SlSetLength(size);

   319

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

   320

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

   321

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   322

	}

   323

}

   324

   325

static void Load_MAP5()

   326

{

   327

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   328

	TileIndex size = MapSize();

   329

   330

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

   331

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   332

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

   333

	}

   334

}

   335

   336

static void Save_MAP5()

   337

{

   338

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   339

	TileIndex size = MapSize();

   340

   341

	SlSetLength(size);

   342

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

   343

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

   344

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   345

	}

   346

}

   347

   348

static void Load_MAP6()

   349

{

   350

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   351

	TileIndex size = MapSize();

   352

   353

	if (CheckSavegameVersion(42)) {

   354

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

   355

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

   356

			SlArray(buf, 1024, SLE_UINT8);

   357

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

   358

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

   359

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

   360

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

   361

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

   362

			}

   363

		}

   364

	} else {

   365

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

   366

			SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   367

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

   368

		}

   369

	}

   370

}

   371

   372

static void Save_MAP6()

   373

{

   374

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   375

	TileIndex size = MapSize();

   376

   377

	SlSetLength(size);

   378

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

   379

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

   380

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   381

	}

   382

}

   383

   384

static void Load_MAP7()

   385

{

   386

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   387

	TileIndex size = MapSize();

   388

   389

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

   390

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   391

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

   392

	}

   393

}

   394

   395

static void Save_MAP7()

   396

{

   397

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   398

	TileIndex size = MapSize();

   399

   400

	SlSetLength(size);

   401

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

   402

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

   403

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   404

	}

   405

}

   406

   407

extern const ChunkHandler _misc_chunk_handlers[] = {

   408

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

   409

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

   410

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

   411

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

   412

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

   413

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

   414

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

   415

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

   416

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

   417

   418

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

   419

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

   420

};