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 "animated_tile_func.h"

    29

#include "tilehighlight_func.h"

    31

    32

#include "table/strings.h"

    33

#include "table/sprites.h"

    34

    35

extern TileIndex _cur_tileloop_tile;

    36

    37

void InitializeVehicles();

    38

void InitializeWaypoints();

    39

void InitializeDepots();

    40

void InitializeEngines();

    41

void InitializeOrders();

    42

void InitializeClearLand();

    43

void InitializeRailGui();

    44

void InitializeRoadGui();

    45

void InitializeAirportGui();

    46

void InitializeDockGui();

    47

void InitializeIndustries();

    48

void InitializeTowns();

    49

void InitializeTrees();

    50

void InitializeSigns();

    51

void InitializeStations();

    52

void InitializeCargoPackets();

    53

void InitializePlayers();

    54

void InitializeCheats();

    55

void InitializeNPF();

    56

void InitializeOldNames();

    57

    58

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

    59

{

    60

	AllocateMap(size_x, size_y);

    61

    62

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

    63

    64

	_pause_game = 0;

    65

	_fast_forward = 0;

    66

	_tick_counter = 0;

    67

	_realtime_tick = 0;

    68

	_date_fract = 0;

    69

	_cur_tileloop_tile = 0;

    70

    71

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

    72

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

    73

		InitializeOldNames();

    74

	}

    75

    76

	InitializeEngines();

    77

	InitializeVehicles();

    78

	InitializeWaypoints();

    79

	InitializeDepots();

    80

	InitializeOrders();

    81

	InitializeGroup();

    82

    83

	InitNewsItemStructs();

    84

	InitializeLandscape();

    85

	InitializeClearLand();

    86

	InitializeRailGui();

    87

	InitializeRoadGui();

    88

	InitializeAirportGui();

    89

	InitializeDockGui();

    90

	InitializeTowns();

    91

	InitializeTrees();

    92

	InitializeSigns();

    93

	InitializeStations();

    94

	InitializeCargoPackets();

    95

	InitializeIndustries();

    96

	InitializeBuildingCounts();

    97

    98

	InitializeTrains();

    99

	InitializeNPF();

   100

   101

	AI_Initialize();

   102

	InitializePlayers();

   103

	InitializeCheats();

   104

   105

	InitTextEffects();

   106

	InitChatMessage();

   107

	InitializeAnimatedTiles();

   108

   109

	InitializeLandscapeVariables(false);

   110

   111

	ResetObjectToPlace();

   112

}

   113

   114

   115

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

   116

void InitializeLandscapeVariables(bool only_constants)

   117

{

   118

	if (only_constants) return;

   119

   120

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

   121

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

   122

		_cargo_payment_rates_frac[i] = 0;

   123

	}

   124

}

   125

   126

static const SaveLoadGlobVarList _date_desc[] = {

   127

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

   128

	SLEG_CONDVAR(_date,                   SLE_INT32,                  31, SL_MAX_VERSION),

   129

	    SLEG_VAR(_date_fract,             SLE_UINT16),

   130

	    SLEG_VAR(_tick_counter,           SLE_UINT16),

   131

	    SLEG_VAR(_vehicle_id_ctr_day,     SLE_UINT16),

   132

	    SLEG_VAR(_age_cargo_skip_counter, SLE_UINT8),

   133

	SLE_CONDNULL(1, 0, 45),

   134

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

   135

	SLEG_CONDVAR(_cur_tileloop_tile,      SLE_UINT32,                  6, SL_MAX_VERSION),

   136

	    SLEG_VAR(_disaster_delay,         SLE_UINT16),

   137

	    SLEG_VAR(_station_tick_ctr,       SLE_UINT16),

   138

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

   139

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

   140

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

   141

	SLEG_CONDVAR(_cur_town_ctr,           SLE_UINT32,                 10, SL_MAX_VERSION),

   142

	    SLEG_VAR(_cur_player_tick_index,  SLE_FILE_U8  | SLE_VAR_U32),

   143

	    SLEG_VAR(_next_competitor_start,  SLE_FILE_U16 | SLE_VAR_U32),

   144

	    SLEG_VAR(_trees_tick_ctr,         SLE_UINT8),

   145

	SLEG_CONDVAR(_pause_game,             SLE_UINT8,                   4, SL_MAX_VERSION),

   146

	SLEG_CONDVAR(_cur_town_iter,          SLE_UINT32,                 11, SL_MAX_VERSION),

   147

	    SLEG_END()

   148

};

   149

   150

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

   151

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

   152

static void SaveLoad_DATE()

   153

{

   154

	SlGlobList(_date_desc);

   155

}

   156

   157

   158

static const SaveLoadGlobVarList _view_desc[] = {

   159

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

   160

	SLEG_CONDVAR(_saved_scrollpos_x,    SLE_INT32,                  6, SL_MAX_VERSION),

   161

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

   162

	SLEG_CONDVAR(_saved_scrollpos_y,    SLE_INT32,                  6, SL_MAX_VERSION),

   163

	    SLEG_VAR(_saved_scrollpos_zoom, SLE_UINT8),

   164

	    SLEG_END()

   165

};

   166

   167

static void SaveLoad_VIEW()

   168

{

   169

	SlGlobList(_view_desc);

   170

}

   171

   172

static uint32 _map_dim_x;

   173

static uint32 _map_dim_y;

   174

   175

static const SaveLoadGlobVarList _map_dimensions[] = {

   176

	SLEG_CONDVAR(_map_dim_x, SLE_UINT32, 6, SL_MAX_VERSION),

   177

	SLEG_CONDVAR(_map_dim_y, SLE_UINT32, 6, SL_MAX_VERSION),

   178

	    SLEG_END()

   179

};

   180

   181

static void Save_MAPS()

   182

{

   183

	_map_dim_x = MapSizeX();

   184

	_map_dim_y = MapSizeY();

   185

	SlGlobList(_map_dimensions);

   186

}

   187

   188

static void Load_MAPS()

   189

{

   190

	SlGlobList(_map_dimensions);

   191

	AllocateMap(_map_dim_x, _map_dim_y);

   192

}

   193

   194

enum {

   195

	MAP_SL_BUF_SIZE = 4096

   196

};

   197

   198

static void Load_MAPT()

   199

{

   200

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   201

	TileIndex size = MapSize();

   202

   203

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

   204

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   205

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

   206

	}

   207

}

   208

   209

static void Save_MAPT()

   210

{

   211

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   212

	TileIndex size = MapSize();

   213

   214

	SlSetLength(size);

   215

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

   216

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

   217

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   218

	}

   219

}

   220

   221

static void Load_MAP1()

   222

{

   223

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   224

	TileIndex size = MapSize();

   225

   226

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

   227

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   228

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

   229

	}

   230

}

   231

   232

static void Save_MAP1()

   233

{

   234

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   235

	TileIndex size = MapSize();

   236

   237

	SlSetLength(size);

   238

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

   239

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

   240

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   241

	}

   242

}

   243

   244

static void Load_MAP2()

   245

{

   246

	SmallStackSafeStackAlloc<uint16, MAP_SL_BUF_SIZE> buf;

   247

	TileIndex size = MapSize();

   248

   249

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

   250

		SlArray(buf, MAP_SL_BUF_SIZE,

   251

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

   252

			CheckSavegameVersion(5) ? SLE_FILE_U8 | SLE_VAR_U16 : SLE_UINT16

   253

		);

   254

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

   255

	}

   256

}

   257

   258

static void Save_MAP2()

   259

{

   260

	SmallStackSafeStackAlloc<uint16, MAP_SL_BUF_SIZE> buf;

   261

	TileIndex size = MapSize();

   262

   263

	SlSetLength(size * sizeof(uint16));

   264

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

   265

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

   266

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT16);

   267

	}

   268

}

   269

   270

static void Load_MAP3()

   271

{

   272

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   273

	TileIndex size = MapSize();

   274

   275

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

   276

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   277

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

   278

	}

   279

}

   280

   281

static void Save_MAP3()

   282

{

   283

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   284

	TileIndex size = MapSize();

   285

   286

	SlSetLength(size);

   287

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

   288

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

   289

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   290

	}

   291

}

   292

   293

static void Load_MAP4()

   294

{

   295

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   296

	TileIndex size = MapSize();

   297

   298

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

   299

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   300

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

   301

	}

   302

}

   303

   304

static void Save_MAP4()

   305

{

   306

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   307

	TileIndex size = MapSize();

   308

   309

	SlSetLength(size);

   310

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

   311

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

   312

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   313

	}

   314

}

   315

   316

static void Load_MAP5()

   317

{

   318

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   319

	TileIndex size = MapSize();

   320

   321

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

   322

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   323

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

   324

	}

   325

}

   326

   327

static void Save_MAP5()

   328

{

   329

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   330

	TileIndex size = MapSize();

   331

   332

	SlSetLength(size);

   333

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

   334

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

   335

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   336

	}

   337

}

   338

   339

static void Load_MAP6()

   340

{

   341

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   342

	TileIndex size = MapSize();

   343

   344

	if (CheckSavegameVersion(42)) {

   345

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

   346

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

   347

			SlArray(buf, 1024, SLE_UINT8);

   348

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

   349

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

   350

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

   351

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

   352

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

   353

			}

   354

		}

   355

	} else {

   356

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

   357

			SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   358

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

   359

		}

   360

	}

   361

}

   362

   363

static void Save_MAP6()

   364

{

   365

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   366

	TileIndex size = MapSize();

   367

   368

	SlSetLength(size);

   369

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

   370

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

   371

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   372

	}

   373

}

   374

   375

static void Load_MAP7()

   376

{

   377

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   378

	TileIndex size = MapSize();

   379

   380

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

   381

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   382

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

   383

	}

   384

}

   385

   386

static void Save_MAP7()

   387

{

   388

	SmallStackSafeStackAlloc<byte, MAP_SL_BUF_SIZE> buf;

   389

	TileIndex size = MapSize();

   390

   391

	SlSetLength(size);

   392

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

   393

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

   394

		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);

   395

	}

   396

}

   397

   398

extern const ChunkHandler _misc_chunk_handlers[] = {

   399

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

   400

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

   401

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

   402

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

   403

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

   404

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

   405

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

   406

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

   407

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

   408

   409

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

   410

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

   411

};