1

#include "stdafx.h"

     2

#include "ttd.h"

     3

     4

#include "town.h"

     5

#include "industry.h"

     6

#include "station.h"

     7

#include "economy.h"

     8

#include "player.h"

     9

#include "engine.h"

    10

#include "vehicle.h"

    11

    12

extern byte _name_array[512][32];

    13

extern TileIndex _animated_tile_list[256];

    14

    15

#if defined(_MSC_VER)

    16

#pragma pack(push, 1)

    17

#endif

    18

    19

typedef struct {

    20

	uint16 string_id;

    21

	uint16 x;

    22

	uint16 right;

    23

	uint16 y;

    24

	uint16 bottom;

    25

	uint16 duration;

    26

	uint32 params[2];

    27

} GCC_PACK OldTextEffect;

    28

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

    29

    30

typedef struct {

    31

	uint16 xy;

    32

	uint16 population;

    33

	uint16 townnametype;

    34

	uint32 townnameparts;

    35

	byte grow_counter;

    36

	byte sort_index;

    37

	int16 sign_left, sign_top;

    38

	byte namewidth_1, namewidth_2;

    39

	uint16 flags12;

    40

	uint16 radius[5];

    41

	uint16 ratings[8];

    42

	uint32 have_ratings;

    43

	uint32 statues;

    44

	uint16 num_houses;

    45

	byte time_until_rebuild;

    46

	byte growth_rate;

    47

	uint16 new_max_pass, new_max_mail;

    48

	uint16 new_act_pass, new_act_mail;

    49

	uint16 max_pass, max_mail;

    50

	uint16 act_pass, act_mail;

    51

	byte pct_pass_transported, pct_mail_transported;

    52

	uint16 new_act_food, new_act_water;

    53

	uint16 act_food, act_water;

    54

	byte road_build_months;

    55

	byte fund_buildings_months;

    56

	// unused bytes at the end of the Town Struct

    57

	uint32 unk56;

    58

	uint32 unk5A;

    59

} GCC_PACK OldTown;

    60

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

    61

    62

typedef struct {

    63

	uint16 xy;

    64

	uint32 town;

    65

} GCC_PACK OldDepot;

    66

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

    67

    68

typedef struct {

    69

	uint32 price;

    70

	uint16 frac;

    71

} GCC_PACK OldPrice;

    72

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

    73

    74

typedef struct {

    75

	uint32 price;

    76

	uint16 frac;

    77

	uint16 unused;

    78

} GCC_PACK OldPaymentRate;

    79

assert_compile(sizeof(OldPaymentRate) == 8);

    80

    81

typedef struct {

    82

	uint16 waiting_acceptance;

    83

	byte days_since_pickup;

    84

	byte rating;

    85

	byte enroute_from;

    86

	byte enroute_time;

    87

	byte last_speed;

    88

	byte last_age;

    89

} GCC_PACK OldGoodsEntry;

    90

assert_compile(sizeof(OldGoodsEntry) == 8);

    91

    92

typedef struct {

    93

	uint16 xy;

    94

	uint32 town;

    95

	uint16 bus_tile, lorry_tile, train_tile, airport_tile, dock_tile;

    96

	byte platforms;

    97

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

    98

	byte namewidth_1, namewidth_2;

    99

	uint16 string_id;

   100

	int16 sign_left, sign_top;

   101

	uint16 had_vehicle_of_type;

   102

	OldGoodsEntry goods[12];

   103

	byte time_since_load, time_since_unload;

   104

	byte delete_ctr;

   105

	byte owner;

   106

	byte facilities;

   107

	byte airport_type;

   108

	byte truck_stop_status, bus_stop_status;

   109

	byte blocked_months_obsolete;

   110

	byte unk85;

   111

	uint16 airport_flags;

   112

	uint16 last_vehicle;

   113

	uint32 unk8A;

   114

} GCC_PACK OldStation;

   115

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

   116

   117

typedef struct {

   118

	uint16 xy;

   119

	uint32 town;

   120

	byte width;

   121

	byte height;

   122

	byte produced_cargo[2];

   123

	uint16 cargo_waiting[2];

   124

	byte production_rate[2];

   125

	byte accepts_cargo[3];

   126

	byte prod_level;

   127

	uint16 last_mo_production[2];

   128

	uint16 last_mo_transported[2];

   129

	byte pct_transported[2];

   130

	uint16 total_production[2];

   131

	uint16 total_transported[2];

   132

	byte type;

   133

	byte owner;

   134

	byte color_map;

   135

	byte last_prod_year;

   136

	uint16 counter;

   137

	byte was_cargo_delivered;

   138

	byte nothing;

   139

	uint32 unk2E;

   140

	uint32 unk32;

   141

} GCC_PACK OldIndustry;

   142

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

   143

   144

typedef struct {

   145

	int32 cost[13];

   146

} GCC_PACK OldPlayerExpenses;

   147

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

   148

   149

typedef struct {

   150

	int32 income;

   151

	int32 expenses;

   152

	uint32 delivered_cargo;

   153

	uint32 performance_history;

   154

	uint32 company_value;

   155

} GCC_PACK OldPlayerEconomy;

   156

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

   157

   158

typedef struct {

   159

	uint16 spec_tile;

   160

	uint16 use_tile;

   161

	byte rand_rng;

   162

	byte cur_rule;

   163

	byte unk6;

   164

	byte unk7;

   165

	byte buildcmd_a;

   166

	byte buildcmd_b;

   167

	byte direction;

   168

	byte cargo;

   169

	byte unused[8];

   170

} GCC_PACK OldAiBuildRec;

   171

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

   172

   173

typedef struct {

   174

	uint16 tile;

   175

	byte data;

   176

} GCC_PACK OldAiBannedTile;

   177

assert_compile(sizeof(OldAiBannedTile) == 3);

   178

   179

typedef struct {

   180

	uint16 name_1;

   181

	uint32 name_2;

   182

	uint32 face;

   183

	uint16 pres_name_1;

   184

	uint32 pres_name_2;

   185

	uint32 money;

   186

	uint32 loan;

   187

	byte color;

   188

	byte money_fract;

   189

	byte quarters_of_bankrupcy;

   190

	byte bankrupt_asked;

   191

	uint32 bankrupt_value;

   192

	uint16 bankrupt_timeout;

   193

	uint32 cargo_types;

   194

	OldPlayerExpenses expenses[3];

   195

	OldPlayerEconomy economy[24 + 1];

   196

	uint16 inaugurated_date;

   197

	uint16 last_build_coordinate;

   198

	byte num_valid_stat_ent;

   199

	byte ai_state;

   200

	byte unused;

   201

	byte ai_state_mode;

   202

	uint16 ai_state_counter;

   203

	uint16 ai_timeout_counter;

   204

	OldAiBuildRec ai_src, ai_dst, ai_mid1, ai_mid2;

   205

	byte unused_2[20];

   206

	byte ai_cargo_type;

   207

	byte ai_num_wagons;

   208

	byte ai_build_kind;

   209

	byte ai_num_build_rec;

   210

	byte ai_num_loco_to_build;

   211

	byte ai_num_want_fullload;

   212

	byte unused_3[14];

   213

	uint16 ai_loco_id; // NOT USED

   214

	uint16 ai_wagonlist[9];

   215

	byte ai_order_list_blocks[20];

   216

	uint16 ai_start_tile_a;

   217

	uint16 ai_start_tile_b;

   218

	uint16 ai_cur_tile_a;

   219

	uint16 ai_cur_tile_b;

   220

	byte ai_start_dir_a;

   221

	byte ai_start_dir_b;

   222

	byte ai_cur_dir_a;

   223

	byte ai_cur_dir_b;

   224

	byte ai_banned_tile_count;

   225

	OldAiBannedTile banned_tiles[16];

   226

	byte ai_railtype_to_use;

   227

	byte ai_route_type_mask;

   228

	byte block_preview;

   229

	byte ai_tick;

   230

	byte max_railtype;

   231

	uint16 location_of_house;

   232

	byte share_owners[4];

   233

	uint32 unk3AA;

   234

	uint32 unk3AE;

   235

} GCC_PACK OldPlayer;

   236

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

   237

   238

typedef struct {

   239

	byte track;

   240

	byte force_proceed;

   241

	uint16 crash_anim_pos;

   242

	byte railtype;

   243

} GCC_PACK OldVehicleRailUnion;

   244

assert_compile(sizeof(OldVehicleRailUnion) == 5);

   245

   246

typedef struct {

   247

	byte unk0;

   248

	byte targetairport;

   249

	uint16 crashed_counter;

   250

	byte state;

   251

} GCC_PACK OldVehicleAirUnion;

   252

assert_compile(sizeof(OldVehicleAirUnion) == 5);

   253

   254

typedef struct {

   255

	byte state;

   256

	byte frame;

   257

	uint16 unk2;

   258

	byte overtaking;

   259

	byte overtaking_ctr;

   260

	uint16 crashed_ctr;

   261

	byte reverse_ctr;

   262

} GCC_PACK OldVehicleRoadUnion;

   263

assert_compile(sizeof(OldVehicleRoadUnion) == 9);

   264

   265

typedef struct {

   266

	uint16 unk0;

   267

	byte unk2;

   268

} GCC_PACK OldVehicleSpecialUnion;

   269

assert_compile(sizeof(OldVehicleSpecialUnion) == 3);

   270

   271

typedef struct {

   272

	uint16 image_override;

   273

	uint16 unk2;

   274

} GCC_PACK OldVehicleDisasterUnion;

   275

assert_compile(sizeof(OldVehicleDisasterUnion) == 4);

   276

   277

typedef struct {

   278

	byte state;

   279

} OldVehicleShipUnion;

   280

assert_compile(sizeof(OldVehicleShipUnion) == 1);

   281

   282

typedef union {

   283

	OldVehicleRailUnion rail;

   284

	OldVehicleAirUnion air;

   285

	OldVehicleRoadUnion road;

   286

	OldVehicleSpecialUnion special;

   287

	OldVehicleDisasterUnion disaster;

   288

	OldVehicleShipUnion ship;

   289

	byte pad[10];

   290

} GCC_PACK OldVehicleUnion;

   291

assert_compile(sizeof(OldVehicleUnion) == 10);

   292

   293

typedef struct {

   294

	byte type;

   295

	byte subtype;

   296

	uint16 next_hash; // NOLOAD, calculated automatically.

   297

	uint16 index;     // NOLOAD, calculated automatically.

   298

	uint32 schedule_ptr;

   299

	byte next_order, next_order_param;

   300

	byte num_orders;

   301

	byte cur_order_index;

   302

	uint16 dest_tile;

   303

	uint16 load_unload_time_rem;

   304

	uint16 date_of_last_service;

   305

	uint16 service_interval;

   306

	byte last_station_visited;

   307

	byte tick_counter;

   308

	uint16 max_speed;

   309

	uint16 x_pos, y_pos;

   310

	byte z_pos;

   311

	byte direction;

   312

	byte x_offs, y_offs;

   313

	byte sprite_width, sprite_height, z_height;

   314

	byte owner;

   315

	uint16 tile;

   316

	uint16 cur_image;

   318

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

   319

	uint16 vehstatus;

   320

	uint16 cur_speed;

   321

	byte subspeed;

   322

	byte acceleration;

   323

	byte progress;

   324

	byte cargo_type;

   325

	uint16 capacity;

   326

	uint16 number_of_pieces;

   327

	byte source_of_pieces;

   328

	byte days_in_transit;

   329

	uint16 age_in_days, max_age_in_days;

   330

	byte build_year;

   331

	byte unitnumber;

   332

	uint16 engine_type;

   333

	byte spritenum;

   334

	byte day_counter;

   335

	byte breakdowns_since_last_service;

   336

	byte breakdown_ctr, breakdown_delay, breakdown_chance;

   337

	uint16 reliability, reliability_spd_dec;

   338

	uint32 profit_this_year, profit_last_year;

   339

	uint16 next_in_chain;

   340

	uint32 value;

   341

	uint16 string_id;

   342

	OldVehicleUnion u;

   343

	byte unused[20];

   344

} GCC_PACK OldVehicle;

   345

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

   346

   347

typedef struct {

   348

	byte name[32];

   349

} GCC_PACK OldName;

   350

   351

typedef struct {

   352

	uint16 text;

   353

	int16 x,y,z;

   354

	byte namewidth_1, namewidth_2;

   355

	int16 sign_left, sign_top;

   356

} GCC_PACK OldSign;

   357

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

   358

   359

typedef struct {

   360

	uint16 player_avail;

   361

	uint16 intro_date;

   362

	uint16 age;

   363

	uint16 reliability, reliability_spd_dec, reliability_start, reliability_max, reliability_final;

   364

	uint16 duration_phase_1, duration_phase_2, duration_phase_3;

   365

	byte lifelength;

   366

	byte flags;

   367

	byte preview_player;

   368

	byte preview_wait;

   369

	byte railtype;

   370

	byte unk1B;

   371

} GCC_PACK OldEngine;

   372

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

   373

   374

typedef struct {

   375

	byte cargo_type;

   376

	byte age;

   377

	byte from;

   378

	byte to;

   379

} GCC_PACK OldSubsidy;

   380

assert_compile(sizeof(OldSubsidy) == 4);

   381

   382

typedef struct {

   383

	uint16 max_no_competitors;

   384

	uint16 competitor_start_time;

   385

	uint16 number_towns;

   386

	uint16 number_industries;

   387

	uint16 max_loan;

   388

	uint16 initial_interest;

   389

	uint16 vehicle_costs;

   390

	uint16 competitor_speed;

   391

	uint16 competitor_intelligence;

   392

	uint16 vehicle_breakdowns;

   393

	uint16 subsidy_multiplier;

   394

	uint16 construction_cost;

   395

	uint16 terrain_type;

   396

	uint16 quantity_sea_lakes;

   397

	uint16 economy;

   398

	uint16 line_reverse_mode;

   399

	uint16 disasters;

   400

} GCC_PACK OldGameSettings;

   401

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

   402

   403

typedef struct {

   404

	uint16 date;

   405

	uint16 date_fract;

   406

   407

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

   408

	uint32 seed_1, seed_2;

   409

   410

	OldTown town_list[70];

   411

	uint16 order_list[5000];

   412

   413

	uint16 animated_tile_list[256];

   414

	uint32 ptr_to_next_order;

   415

	OldDepot depots[255];

   416

   417

	uint32 cur_town_ptr;

   418

	uint16 timer_counter;

   419

	uint16 land_code; // NOLOAD: never needed in game

   420

	uint16 age_cargo_skip_counter;

   421

	uint16 tick_counter;

   422

	uint16 cur_tileloop_tile;

   424

	OldPrice prices[49];

   425

	OldPaymentRate cargo_payment_rates[12];

   427

	byte map_owner[256*256];

   428

	byte map2[256*256];

   429

	uint16 map3[256*256];

   430

	byte map_extra[256*256/4];

   432

	OldStation stations[250];

   433

	OldIndustry industries[90];

   434

	OldPlayer players[8];

   435

	OldVehicle vehicles[850];

   436

	OldName names[500];

   438

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

   439

   440

	OldSign signs[40];

   441

	OldEngine engines[256];

   442

   443

	uint16 vehicle_id_ctr_day;

   444

	OldSubsidy subsidies[8];

   445

   446

	uint16 next_competitor_start;

   447

   448

	uint16 saved_main_scrollpos_x, saved_main_scrollpos_y, saved_main_scrollpos_zoom;

   449

	uint32 maximum_loan, maximum_loan_unround;

   450

	uint16 economy_fluct;

   451

	uint16 disaster_delay;

   452

   453

	//NOLOAD. These are calculated from InitializeLandscapeVariables

   454

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

   455

	uint16 cargo_sprites[12];

   456

   457

	uint16 engine_name_strings[256];

   459

	//NOLOAD. These are calculated from InitializeLandscapeVariables

   460

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

   461

	uint16 roadveh_by_cargo_start[12];

   462

	byte roadveh_by_cargo_count[12];

   463

	uint16 ship_of_type_start[12];

   464

	byte ship_of_type_count[12];

   465

   466

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

   467

	byte station_tick_ctr;

   468

	byte currency;

   469

	byte use_kilometers;

   470

	byte cur_player_tick_index;

   471

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

   472

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

   473

   474

	byte inflation_amount;

   475

	byte inflation_amount_payment_rates;

   476

	byte interest_rate;

   477

   478

	byte avail_aircraft;

   479

	byte road_side;

   480

	byte town_name_type;

   481

	OldGameSettings game_diff;

   482

	byte difficulty_level;

   483

	byte landscape_type;

   484

	byte trees_tick_ctr;

   485

	byte vehicle_design_names;

   486

	byte snow_line_height;

   487

   488

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

   490

	//NOLOAD. Initialized by InitializeLandscapeVariables

   492

	byte transit_days_table_1[12];

   493

	byte transit_days_table_2[12];

   494

   495

	byte map_type_and_height[256*256];

   496

	byte map5[256*256];

   497

} GCC_PACK OldMain;

   498

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

   499

   500

#if defined(_MSC_VER)

   501

#pragma pack(pop)

   502

#endif

   503

   504

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

   505

#define REMAP_TOWN_PTR(x) DEREF_TOWN( REMAP_TOWN_IDX(x) )

   506

   507

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

   508

   509

typedef struct LoadSavegameState {

   510

	int8 mode;

   511

	byte rep_char;

   512

   513

	size_t count;

   514

	size_t buffer_count;

   515

	FILE *fin;

   516

   517

	byte *buffer_cur;

   518

   519

	byte buffer[4096];

   520

   521

} LoadSavegameState;

   522

   523

static LoadSavegameState *_cur_state;

   524

   525

static byte GetSavegameByteFromBuffer()

   526

{

   527

	LoadSavegameState *lss = _cur_state;