1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "tile.h"

     6

#include "town.h"

     7

#include "industry.h"

     8

#include "station.h"

     9

#include "economy.h"

    10

#include "player.h"

    11

#include "engine.h"

    12

#include "vehicle.h"

    13

#include "signs.h"

    14

    15

extern byte _name_array[512][32];

    16

extern TileIndex _animated_tile_list[256];

    17

extern uint16 _custom_sprites_base;

    18

    19

#if defined(_MSC_VER) || defined(__WATCOMC__)

    20

#pragma pack(push, 1)

    21

#endif

    22

    23

typedef struct {

    24

	uint16 string_id;

    25

	uint16 x;

    26

	uint16 right;

    27

	uint16 y;

    28

	uint16 bottom;

    29

	uint16 duration;

    30

	uint32 params[2];

    31

} GCC_PACK OldTextEffect;

    32

assert_compile(sizeof(OldTextEffect) == 0x14);

    33

    34

typedef struct {

    35

	uint16 xy;

    36

	uint16 population;

    37

	uint16 townnametype;

    38

	uint32 townnameparts;

    39

	byte grow_counter;

    40

	byte sort_index;

    41

	int16 sign_left, sign_top;

    42

	byte namewidth_1, namewidth_2;

    43

	uint16 flags12;

    44

	uint16 radius[5];

    45

	uint16 ratings[8];

    46

	uint32 have_ratings;

    47

	uint32 statues;

    48

	uint16 num_houses;

    49

	byte time_until_rebuild;

    50

	byte growth_rate;

    51

	uint16 new_max_pass, new_max_mail;

    52

	uint16 new_act_pass, new_act_mail;

    53

	uint16 max_pass, max_mail;

    54

	uint16 act_pass, act_mail;

    55

	byte pct_pass_transported, pct_mail_transported;

    56

	uint16 new_act_food, new_act_water;

    57

	uint16 act_food, act_water;

    58

	byte road_build_months;

    59

	byte fund_buildings_months;

    60

	// unused bytes at the end of the Town Struct

    61

	uint32 unk56;

    62

	uint32 unk5A;

    63

} GCC_PACK OldTown;

    64

assert_compile(sizeof(OldTown) == 0x5E);

    65

    66

typedef struct {

    67

	uint16 xy;

    68

	uint32 town;

    69

} GCC_PACK OldDepot;

    70

assert_compile(sizeof(OldDepot) == 0x6);

    71

    72

typedef struct {

    73

	uint32 price;

    74

	uint16 frac;

    75

} GCC_PACK OldPrice;

    76

assert_compile(sizeof(OldPrice) == 0x6);

    77

    78

typedef struct {

    79

	uint32 price;

    80

	uint16 frac;

    81

	uint16 unused;

    82

} GCC_PACK OldPaymentRate;

    83

assert_compile(sizeof(OldPaymentRate) == 8);

    84

    85

typedef struct {

    86

	uint16 waiting_acceptance;

    87

	byte days_since_pickup;

    88

	byte rating;

    89

	byte enroute_from;

    90

	byte enroute_time;

    91

	byte last_speed;

    92

	byte last_age;

    93

} GCC_PACK OldGoodsEntry;

    94

assert_compile(sizeof(OldGoodsEntry) == 8);

    95

    96

typedef struct {

    97

	uint16 xy;

    98

	uint32 town;

    99

	uint16 bus_tile, lorry_tile, train_tile, airport_tile, dock_tile;

   100

	byte platforms;

   101

	byte alpha_order_obsolete;	// alpha_order is obsolete since savegame format 4

   102

	byte namewidth_1, namewidth_2;

   103

	uint16 string_id;

   104

	int16 sign_left, sign_top;

   105

	uint16 had_vehicle_of_type;

   106

	OldGoodsEntry goods[12];

   107

	byte time_since_load, time_since_unload;

   108

	byte delete_ctr;

   109

	byte owner;

   110

	byte facilities;

   111

	byte airport_type;

   112

	byte truck_stop_status, bus_stop_status;

   113

	byte blocked_months_obsolete;

   114

	byte unk85;

   115

	uint16 airport_flags;

   116

	uint16 last_vehicle;

   117

	uint32 unk8A;

   118

} GCC_PACK OldStation;

   119

assert_compile(sizeof(OldStation) == 0x8E);

   120

   121

typedef struct {

   122

	uint16 xy;

   123

	uint32 town;

   124

	byte width;

   125

	byte height;

   126

	byte produced_cargo[2];

   127

	uint16 cargo_waiting[2];

   128

	byte production_rate[2];

   129

	byte accepts_cargo[3];

   130

	byte prod_level;

   131

	uint16 last_mo_production[2];

   132

	uint16 last_mo_transported[2];

   133

	byte pct_transported[2];

   134

	uint16 total_production[2];

   135

	uint16 total_transported[2];

   136

	byte type;

   137

	byte owner;

   138

	byte color_map;

   139

	byte last_prod_year;

   140

	uint16 counter;

   141

	byte was_cargo_delivered;

   142

	byte nothing;

   143

	uint32 unk2E;

   144

	uint32 unk32;

   145

} GCC_PACK OldIndustry;

   146

assert_compile(sizeof(OldIndustry) == 0x36);

   147

   148

typedef struct {

   149

	int32 cost[13];

   150

} GCC_PACK OldPlayerExpenses;

   151

assert_compile(sizeof(OldPlayerExpenses) == 0x34);

   152

   153

typedef struct {

   154

	int32 income;

   155

	int32 expenses;

   156

	uint32 delivered_cargo;

   157

	uint32 performance_history;

   158

	uint32 company_value;

   159

} GCC_PACK OldPlayerEconomy;

   160

assert_compile(sizeof(OldPlayerEconomy) == 0x14);

   161

   162

typedef struct {

   163

	uint16 spec_tile;

   164

	uint16 use_tile;

   165

	byte rand_rng;

   166

	byte cur_rule;

   167

	byte unk6;

   168

	byte unk7;

   169

	byte buildcmd_a;

   170

	byte buildcmd_b;

   171

	byte direction;

   172

	byte cargo;

   173

	byte unused[8];

   174

} GCC_PACK OldAiBuildRec;

   175

assert_compile(sizeof(OldAiBuildRec) == 0x14);

   176

   177

typedef struct {

   178

	uint16 tile;

   179

	byte data;

   180

} GCC_PACK OldAiBannedTile;

   181

assert_compile(sizeof(OldAiBannedTile) == 3);

   182

   183

typedef struct {

   184

	uint16 name_1;

   185

	uint32 name_2;

   186

	uint32 face;

   187

	uint16 pres_name_1;

   188

	uint32 pres_name_2;

   189

	uint32 money;

   190

	uint32 loan;

   191

	byte color;

   192

	byte money_fract;

   193

	byte quarters_of_bankrupcy;

   194

	byte bankrupt_asked;

   195

	uint32 bankrupt_value;

   196

	uint16 bankrupt_timeout;

   197

	uint32 cargo_types;

   198

	OldPlayerExpenses expenses[3];

   199

	OldPlayerEconomy economy[24 + 1];

   200

	uint16 inaugurated_date;

   201

	uint16 last_build_coordinate;

   202

	byte num_valid_stat_ent;

   203

	byte ai_state;

   204

	byte unused;

   205

	byte ai_state_mode;

   206

	uint16 ai_state_counter;

   207

	uint16 ai_timeout_counter;

   208

	OldAiBuildRec ai_src, ai_dst, ai_mid1, ai_mid2;

   209

	byte unused_2[20];

   210

	byte ai_cargo_type;

   211

	byte ai_num_wagons;

   212

	byte ai_build_kind;

   213

	byte ai_num_build_rec;

   214

	byte ai_num_loco_to_build;

   215

	byte ai_num_want_fullload;

   216

	byte unused_3[14];

   217

	uint16 ai_loco_id; // NOT USED

   218

	uint16 ai_wagonlist[9];

   219

	byte ai_order_list_blocks[20];

   220

	uint16 ai_start_tile_a;

   221

	uint16 ai_start_tile_b;

   222

	uint16 ai_cur_tile_a;

   223

	uint16 ai_cur_tile_b;

   224

	byte ai_start_dir_a;

   225

	byte ai_start_dir_b;

   226

	byte ai_cur_dir_a;

   227

	byte ai_cur_dir_b;

   228

	byte ai_banned_tile_count;

   229

	OldAiBannedTile banned_tiles[16];

   230

	byte ai_railtype_to_use;

   231

	byte ai_route_type_mask;

   232

	byte block_preview;

   233

	byte ai_tick;

   234

	byte max_railtype;

   235

	uint16 location_of_house;

   236

	byte share_owners[4];

   237

	uint32 unk3AA;

   238

	uint32 unk3AE;

   239

} GCC_PACK OldPlayer;

   240

assert_compile(sizeof(OldPlayer) == 0x3B2);

   241

   242

typedef struct {

   243

	byte track;

   244

	byte force_proceed;

   245

	uint16 crash_anim_pos;

   246

	byte railtype;

   247

} GCC_PACK OldVehicleRailUnion;

   248

assert_compile(sizeof(OldVehicleRailUnion) == 5);

   249

   250

typedef struct {

   251

	byte unk0;

   252

	byte targetairport;

   253

	uint16 crashed_counter;

   254

	byte state;

   255

} GCC_PACK OldVehicleAirUnion;

   256

assert_compile(sizeof(OldVehicleAirUnion) == 5);

   257

   258

typedef struct {

   259

	byte state;

   260

	byte frame;

   261

	uint16 unk2;

   262

	byte overtaking;

   263

	byte overtaking_ctr;

   264

	uint16 crashed_ctr;

   265

	byte reverse_ctr;

   266

} GCC_PACK OldVehicleRoadUnion;

   267

assert_compile(sizeof(OldVehicleRoadUnion) == 9);

   268

   269

typedef struct {

   270

	uint16 unk0;

   271

	byte unk2;

   272

} GCC_PACK OldVehicleSpecialUnion;

   273

assert_compile(sizeof(OldVehicleSpecialUnion) == 3);

   274

   275

typedef struct {

   276

	uint16 image_override;

   277

	uint16 unk2;

   278

} GCC_PACK OldVehicleDisasterUnion;

   279

assert_compile(sizeof(OldVehicleDisasterUnion) == 4);

   280

   281

typedef struct {

   282

	byte state;

   283

} GCC_PACK OldVehicleShipUnion;

   284

assert_compile(sizeof(OldVehicleShipUnion) == 1);

   285

   286

typedef union {

   287

	OldVehicleRailUnion rail;

   288

	OldVehicleAirUnion air;

   289

	OldVehicleRoadUnion road;

   290

	OldVehicleSpecialUnion special;

   291

	OldVehicleDisasterUnion disaster;

   292

	OldVehicleShipUnion ship;

   293

	byte pad[10];

   294

} GCC_PACK OldVehicleUnion;

   295

assert_compile(sizeof(OldVehicleUnion) == 10);

   296

   297

typedef struct {

   298

	byte type;

   299

	byte subtype;

   300

	uint16 next_hash; // NOLOAD, calculated automatically.

   301

	uint16 index;     // NOLOAD, calculated automatically.

   302

	uint32 schedule_ptr;

   303

	byte next_order, next_order_param;

   304

	byte num_orders;

   305

	byte cur_order_index;

   306

	uint16 dest_tile;

   307

	uint16 load_unload_time_rem;

   308

	uint16 date_of_last_service;

   309

	uint16 service_interval;

   310

	byte last_station_visited;

   311

	byte tick_counter;

   312

	uint16 max_speed;

   313

	uint16 x_pos, y_pos;

   314

	byte z_pos;

   315

	byte direction;

   316

	byte x_offs, y_offs;

   317

	byte sprite_width, sprite_height, z_height;

   318

	byte owner;

   319

	uint16 tile;

   320

	uint16 cur_image;

   321

   322

	int16 left_coord, right_coord, top_coord, bottom_coord; // NOLOAD, calculated automatically.

   323

	uint16 vehstatus;

   324

	uint16 cur_speed;

   325

	byte subspeed;

   326

	byte acceleration;

   327

	byte progress;

   328

	byte cargo_type;

   329

	uint16 capacity;

   330

	uint16 number_of_pieces;

   331

	byte source_of_pieces;

   332

	byte days_in_transit;

   333

	uint16 age_in_days, max_age_in_days;

   334

	byte build_year;

   335

	byte unitnumber;

   336

	uint16 engine_type;

   337

	byte spritenum;

   338

	byte day_counter;

   339

	byte breakdowns_since_last_service;

   340

	byte breakdown_ctr, breakdown_delay, breakdown_chance;

   341

	uint16 reliability, reliability_spd_dec;

   342

	uint32 profit_this_year, profit_last_year;

   343

	uint16 next_in_chain;

   344

	uint32 value;

   345

	uint16 string_id;

   346

	OldVehicleUnion u;

   347

	byte unused[20];

   348

} GCC_PACK OldVehicle;

   349

assert_compile(sizeof(OldVehicle) == 0x80);

   350

   351

typedef struct {

   352

	byte name[32];

   353

} GCC_PACK OldName;

   354

   355

typedef struct {

   356

	uint16 text;

   357

	int16 x,y,z;

   358

	byte namewidth_1, namewidth_2;

   359

	int16 sign_left, sign_top;

   360

} GCC_PACK OldSign;

   361

assert_compile(sizeof(OldSign) == 0xE);

   362

   363

typedef struct {

   364

	uint16 player_avail;

   365

	uint16 intro_date;

   366

	uint16 age;

   367

	uint16 reliability, reliability_spd_dec, reliability_start, reliability_max, reliability_final;

   368

	uint16 duration_phase_1, duration_phase_2, duration_phase_3;

   369

	byte lifelength;

   370

	byte flags;

   371

	byte preview_player;

   372

	byte preview_wait;

   373

	byte railtype;

   374

	byte unk1B;

   375

} GCC_PACK OldEngine;

   376

assert_compile(sizeof(OldEngine) == 0x1C);

   377

   378

typedef struct {

   379

	byte cargo_type;

   380

	byte age;

   381

	byte from;

   382

	byte to;

   383

} GCC_PACK OldSubsidy;

   384

assert_compile(sizeof(OldSubsidy) == 4);

   385

   386

typedef struct {

   387

	uint16 max_no_competitors;

   388

	uint16 competitor_start_time;

   389

	uint16 number_towns;

   390

	uint16 number_industries;

   391

	uint16 max_loan;

   392

	uint16 initial_interest;

   393

	uint16 vehicle_costs;

   394

	uint16 competitor_speed;

   395

	uint16 competitor_intelligence;

   396

	uint16 vehicle_breakdowns;

   397

	uint16 subsidy_multiplier;

   398

	uint16 construction_cost;

   399

	uint16 terrain_type;

   400

	uint16 quantity_sea_lakes;

   401

	uint16 economy;

   402

	uint16 line_reverse_mode;

   403

	uint16 disasters;

   404

} GCC_PACK OldGameSettings;

   405

assert_compile(sizeof(OldGameSettings) == 0x22);

   406

   407

typedef struct {

   408

	uint16 date;

   409

	uint16 date_fract;

   410

   411

	OldTextEffect te_list[30]; // NOLOAD: not so important.

   412

	uint32 seed_1, seed_2;

   413

   414

	OldTown town_list[70];

   415

	uint16 order_list[5000];

   416

   417

	uint16 animated_tile_list[256];

   418

	uint32 ptr_to_next_order;

   419

	OldDepot depots[255];

   420

   421

	uint32 cur_town_ptr;

   422

	uint16 timer_counter;

   423

	uint16 land_code; // NOLOAD: never needed in game

   424

	uint16 age_cargo_skip_counter;

   425

	uint16 tick_counter;

   426

	uint16 cur_tileloop_tile;

   427

   428

	OldPrice prices[49];

   429

	OldPaymentRate cargo_payment_rates[12];

   430

   431

	byte map_owner[256*256];

   432

	byte map2[256*256];

   433

	uint16 map3[256*256];

   434

	byte map_extra[256*256/4];

   435

   436

	OldStation stations[250];

   437

	OldIndustry industries[90];

   438

	OldPlayer players[8];

   439

	OldVehicle vehicles[850];

   440

	OldName names[500];

   441

   442

	uint16 vehicle_position_hash[0x1000]; // NOLOAD, calculated automatically.

   443

   444

	OldSign signs[40];

   445

	OldEngine engines[256];

   446

   447

	uint16 vehicle_id_ctr_day;

   448

	OldSubsidy subsidies[8];

   449

   450

	uint16 next_competitor_start;

   451

   452

	uint16 saved_main_scrollpos_x, saved_main_scrollpos_y, saved_main_scrollpos_zoom;

   453

	uint32 maximum_loan, maximum_loan_unround;

   454

	uint16 economy_fluct;

   455

	uint16 disaster_delay;

   456

   457

	//NOLOAD. These are calculated from InitializeLandscapeVariables

   458

	uint16 cargo_names_s[12], cargo_names_p[12], cargo_names_long_s[12], cargo_names_long_p[12], cargo_names_short[12];

   459

	uint16 cargo_sprites[12];

   460

   461

	uint16 engine_name_strings[256];

   462

   463

	//NOLOAD. These are calculated from InitializeLandscapeVariables

   464

	uint16 railveh_by_cargo_1[12], railveh_by_cargo_2[12], railveh_by_cargo_3[12];

   465

	uint16 roadveh_by_cargo_start[12];

   466

	byte roadveh_by_cargo_count[12];

   467

	uint16 ship_of_type_start[12];

   468

	byte ship_of_type_count[12];

   469

   470

	byte human_player_1, human_player_2; //NOLOAD. Calculated automatically.

   471

	byte station_tick_ctr;

   472

	byte currency;

   473

	byte use_kilometers;

   474

	byte cur_player_tick_index;

   475

	byte cur_year, cur_month;		//NOLOAD. Calculated automatically.

   476

	byte player_colors[8];			//NOLOAD. Calculated automatically

   477

   478

	byte inflation_amount;

   479

	byte inflation_amount_payment_rates;

   480

	byte interest_rate;

   481

   482

	byte avail_aircraft;

   483

	byte road_side;

   484

	byte town_name_type;

   485

	OldGameSettings game_diff;

   486

	byte difficulty_level;

   487

	byte landscape_type;

   488

	byte trees_tick_ctr;

   489

	byte vehicle_design_names;

   490

	byte snow_line_height;

   491

   492

	byte new_industry_randtable[32]; // NOLOAD. Not needed due to different code design.

   493

   494

	//NOLOAD. Initialized by InitializeLandscapeVariables

   495

	byte cargo_weights[12];

   496

	byte transit_days_table_1[12];

   497

	byte transit_days_table_2[12];

   498

   499

	byte map_type_and_height[256*256];

   500

	byte map5[256*256];

   501

} GCC_PACK OldMain;

   502

assert_compile(sizeof(OldMain) == 487801 + 256*256*2);

   503

   504

#if defined(_MSC_VER) || defined(__WATCOMC__)

   505

#pragma pack(pop)

   506

#endif

   507

   508

#define REMAP_TOWN_IDX(x) (x - (0x0459154 - 0x0458EF0)) / sizeof(OldTown)

   509

#define REMAP_TOWN_PTR(x) GetTown( REMAP_TOWN_IDX(x) )

   510

   511

#define REMAP_ORDER_IDX(x) (x - (0x045AB08 - 0x0458EF0)) / sizeof(uint16)

   512

   513

typedef struct LoadSavegameState {

   514

	int8 mode;

   515

	byte rep_char;

   516

   517

	size_t count;

   518

	size_t buffer_count;

   519

	FILE *fin;

   520

   521

	byte *buffer_cur;

   522

   523

	byte buffer[4096];

   524

   525

} LoadSavegameState;

   526