1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     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

extern uint16 _custom_sprites_base;

    15

    16

#if defined(_MSC_VER)

    17

#pragma pack(push, 1)

    18

#endif

    19

    20

typedef struct {

    21

	uint16 string_id;

    22

	uint16 x;

    23

	uint16 right;

    24

	uint16 y;

    25

	uint16 bottom;

    26

	uint16 duration;

    27

	uint32 params[2];

    28

} GCC_PACK OldTextEffect;

    29

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

    30

    31

typedef struct {

    32

	uint16 xy;

    33

	uint16 population;

    34

	uint16 townnametype;

    35

	uint32 townnameparts;

    36

	byte grow_counter;

    37

	byte sort_index;

    38

	int16 sign_left, sign_top;

    39

	byte namewidth_1, namewidth_2;

    40

	uint16 flags12;

    41

	uint16 radius[5];

    42

	uint16 ratings[8];

    43

	uint32 have_ratings;

    44

	uint32 statues;

    45

	uint16 num_houses;

    46

	byte time_until_rebuild;

    47

	byte growth_rate;

    48

	uint16 new_max_pass, new_max_mail;

    49

	uint16 new_act_pass, new_act_mail;

    50

	uint16 max_pass, max_mail;

    51

	uint16 act_pass, act_mail;

    52

	byte pct_pass_transported, pct_mail_transported;

    53

	uint16 new_act_food, new_act_water;

    54

	uint16 act_food, act_water;

    55

	byte road_build_months;

    56

	byte fund_buildings_months;

    57

	// unused bytes at the end of the Town Struct

    58

	uint32 unk56;

    59

	uint32 unk5A;

    60

} GCC_PACK OldTown;

    61

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

    62

    63

typedef struct {

    64

	uint16 xy;

    65

	uint32 town;

    66

} GCC_PACK OldDepot;

    67

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

    68

    69

typedef struct {

    70

	uint32 price;

    71

	uint16 frac;

    72

} GCC_PACK OldPrice;

    73

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

    74

    75

typedef struct {

    76

	uint32 price;

    77

	uint16 frac;

    78

	uint16 unused;

    79

} GCC_PACK OldPaymentRate;

    80

assert_compile(sizeof(OldPaymentRate) == 8);

    81

    82

typedef struct {

    83

	uint16 waiting_acceptance;

    84

	byte days_since_pickup;

    85

	byte rating;

    86

	byte enroute_from;

    87

	byte enroute_time;

    88

	byte last_speed;

    89

	byte last_age;

    90

} GCC_PACK OldGoodsEntry;

    91

assert_compile(sizeof(OldGoodsEntry) == 8);

    92

    93

typedef struct {

    94

	uint16 xy;

    95

	uint32 town;

    96

	uint16 bus_tile, lorry_tile, train_tile, airport_tile, dock_tile;

    97

	byte platforms;

    98

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

    99

	byte namewidth_1, namewidth_2;

   100

	uint16 string_id;

   101

	int16 sign_left, sign_top;

   102

	uint16 had_vehicle_of_type;

   103

	OldGoodsEntry goods[12];

   104

	byte time_since_load, time_since_unload;

   105

	byte delete_ctr;

   106

	byte owner;

   107

	byte facilities;

   108

	byte airport_type;

   109

	byte truck_stop_status, bus_stop_status;

   110

	byte blocked_months_obsolete;

   111

	byte unk85;

   112

	uint16 airport_flags;

   113

	uint16 last_vehicle;

   114

	uint32 unk8A;

   115

} GCC_PACK OldStation;

   116

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

   117

   118

typedef struct {

   119

	uint16 xy;

   120

	uint32 town;

   121

	byte width;

   122

	byte height;

   123

	byte produced_cargo[2];

   124

	uint16 cargo_waiting[2];

   125

	byte production_rate[2];

   126

	byte accepts_cargo[3];

   127

	byte prod_level;

   128

	uint16 last_mo_production[2];

   129

	uint16 last_mo_transported[2];

   130

	byte pct_transported[2];

   131

	uint16 total_production[2];

   132

	uint16 total_transported[2];

   133

	byte type;

   134

	byte owner;

   135

	byte color_map;

   136

	byte last_prod_year;

   137

	uint16 counter;

   138

	byte was_cargo_delivered;

   139

	byte nothing;

   140

	uint32 unk2E;

   141

	uint32 unk32;

   142

} GCC_PACK OldIndustry;

   143

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

   144

   145

typedef struct {

   146

	int32 cost[13];

   147

} GCC_PACK OldPlayerExpenses;

   148

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

   149

   150

typedef struct {

   151

	int32 income;

   152

	int32 expenses;

   153

	uint32 delivered_cargo;

   154

	uint32 performance_history;

   155

	uint32 company_value;

   156

} GCC_PACK OldPlayerEconomy;

   157

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

   158

   159

typedef struct {

   160

	uint16 spec_tile;

   161

	uint16 use_tile;

   162

	byte rand_rng;

   163

	byte cur_rule;

   164

	byte unk6;

   165

	byte unk7;

   166

	byte buildcmd_a;

   167

	byte buildcmd_b;

   168

	byte direction;

   169

	byte cargo;

   170

	byte unused[8];

   171

} GCC_PACK OldAiBuildRec;

   172

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

   173

   174

typedef struct {

   175

	uint16 tile;

   176

	byte data;

   177

} GCC_PACK OldAiBannedTile;

   178

assert_compile(sizeof(OldAiBannedTile) == 3);

   179

   180

typedef struct {

   181

	uint16 name_1;

   182

	uint32 name_2;

   183

	uint32 face;

   184

	uint16 pres_name_1;

   185

	uint32 pres_name_2;

   186

	uint32 money;

   187

	uint32 loan;

   188

	byte color;

   189

	byte money_fract;

   190

	byte quarters_of_bankrupcy;

   191

	byte bankrupt_asked;

   192

	uint32 bankrupt_value;

   193

	uint16 bankrupt_timeout;

   194

	uint32 cargo_types;

   195

	OldPlayerExpenses expenses[3];

   196

	OldPlayerEconomy economy[24 + 1];

   197

	uint16 inaugurated_date;

   198

	uint16 last_build_coordinate;

   199

	byte num_valid_stat_ent;

   200

	byte ai_state;

   201

	byte unused;

   202

	byte ai_state_mode;

   203

	uint16 ai_state_counter;

   204

	uint16 ai_timeout_counter;

   205

	OldAiBuildRec ai_src, ai_dst, ai_mid1, ai_mid2;

   206

	byte unused_2[20];

   207

	byte ai_cargo_type;

   208

	byte ai_num_wagons;

   209

	byte ai_build_kind;

   210

	byte ai_num_build_rec;

   211

	byte ai_num_loco_to_build;

   212

	byte ai_num_want_fullload;

   213

	byte unused_3[14];

   214

	uint16 ai_loco_id; // NOT USED

   215

	uint16 ai_wagonlist[9];

   216

	byte ai_order_list_blocks[20];

   217

	uint16 ai_start_tile_a;

   218

	uint16 ai_start_tile_b;

   219

	uint16 ai_cur_tile_a;

   220

	uint16 ai_cur_tile_b;

   221

	byte ai_start_dir_a;

   222

	byte ai_start_dir_b;

   223

	byte ai_cur_dir_a;

   224

	byte ai_cur_dir_b;

   225

	byte ai_banned_tile_count;

   226

	OldAiBannedTile banned_tiles[16];

   227

	byte ai_railtype_to_use;

   228

	byte ai_route_type_mask;

   229

	byte block_preview;

   230

	byte ai_tick;

   231

	byte max_railtype;

   232

	uint16 location_of_house;

   233

	byte share_owners[4];

   234

	uint32 unk3AA;

   235

	uint32 unk3AE;

   236

} GCC_PACK OldPlayer;

   237

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

   238

   239

typedef struct {

   240

	byte track;

   241

	byte force_proceed;

   242

	uint16 crash_anim_pos;

   243

	byte railtype;

   244

} GCC_PACK OldVehicleRailUnion;

   245

assert_compile(sizeof(OldVehicleRailUnion) == 5);

   246

   247

typedef struct {

   248

	byte unk0;

   249

	byte targetairport;

   250

	uint16 crashed_counter;

   251

	byte state;

   252

} GCC_PACK OldVehicleAirUnion;

   253

assert_compile(sizeof(OldVehicleAirUnion) == 5);

   254

   255

typedef struct {

   256

	byte state;

   257

	byte frame;

   258

	uint16 unk2;

   259

	byte overtaking;

   260

	byte overtaking_ctr;

   261

	uint16 crashed_ctr;

   262

	byte reverse_ctr;

   263

} GCC_PACK OldVehicleRoadUnion;

   264

assert_compile(sizeof(OldVehicleRoadUnion) == 9);

   265

   266

typedef struct {

   267

	uint16 unk0;

   268

	byte unk2;

   269

} GCC_PACK OldVehicleSpecialUnion;

   270

assert_compile(sizeof(OldVehicleSpecialUnion) == 3);

   271

   272

typedef struct {

   273

	uint16 image_override;

   274

	uint16 unk2;

   275

} GCC_PACK OldVehicleDisasterUnion;

   276

assert_compile(sizeof(OldVehicleDisasterUnion) == 4);

   277

   278

typedef struct {

   279

	byte state;

   280

} OldVehicleShipUnion;

   281

assert_compile(sizeof(OldVehicleShipUnion) == 1);

   282

   283

typedef union {

   284

	OldVehicleRailUnion rail;

   285

	OldVehicleAirUnion air;

   286

	OldVehicleRoadUnion road;

   287

	OldVehicleSpecialUnion special;

   288

	OldVehicleDisasterUnion disaster;

   289

	OldVehicleShipUnion ship;

   290

	byte pad[10];

   291

} GCC_PACK OldVehicleUnion;

   292

assert_compile(sizeof(OldVehicleUnion) == 10);

   293

   294

typedef struct {

   295

	byte type;

   296

	byte subtype;

   297

	uint16 next_hash; // NOLOAD, calculated automatically.

   298

	uint16 index;     // NOLOAD, calculated automatically.

   299

	uint32 schedule_ptr;

   300

	byte next_order, next_order_param;

   301

	byte num_orders;

   302

	byte cur_order_index;

   303

	uint16 dest_tile;

   304

	uint16 load_unload_time_rem;

   305

	uint16 date_of_last_service;

   306

	uint16 service_interval;

   307

	byte last_station_visited;

   308

	byte tick_counter;

   309

	uint16 max_speed;

   310

	uint16 x_pos, y_pos;

   311

	byte z_pos;

   312

	byte direction;

   313

	byte x_offs, y_offs;

   314

	byte sprite_width, sprite_height, z_height;

   315

	byte owner;

   316

	uint16 tile;

   317

	uint16 cur_image;

   318

   319

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

   320

	uint16 vehstatus;

   321

	uint16 cur_speed;

   322

	byte subspeed;

   323

	byte acceleration;

   324

	byte progress;

   325

	byte cargo_type;

   326

	uint16 capacity;

   327

	uint16 number_of_pieces;

   328

	byte source_of_pieces;

   329

	byte days_in_transit;

   330

	uint16 age_in_days, max_age_in_days;

   331

	byte build_year;

   332

	byte unitnumber;

   333

	uint16 engine_type;

   334

	byte spritenum;

   335

	byte day_counter;

   336

	byte breakdowns_since_last_service;

   337

	byte breakdown_ctr, breakdown_delay, breakdown_chance;

   338

	uint16 reliability, reliability_spd_dec;

   339

	uint32 profit_this_year, profit_last_year;

   340

	uint16 next_in_chain;

   341

	uint32 value;

   342

	uint16 string_id;

   343

	OldVehicleUnion u;

   344

	byte unused[20];

   345

} GCC_PACK OldVehicle;

   346

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

   347

   348

typedef struct {

   349

	byte name[32];

   350

} GCC_PACK OldName;

   351

   352

typedef struct {

   353

	uint16 text;

   354

	int16 x,y,z;

   355

	byte namewidth_1, namewidth_2;

   356

	int16 sign_left, sign_top;

   357

} GCC_PACK OldSign;

   358

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

   359

   360

typedef struct {

   361

	uint16 player_avail;

   362

	uint16 intro_date;

   363

	uint16 age;

   364

	uint16 reliability, reliability_spd_dec, reliability_start, reliability_max, reliability_final;

   365

	uint16 duration_phase_1, duration_phase_2, duration_phase_3;

   366

	byte lifelength;

   367

	byte flags;

   368

	byte preview_player;

   369

	byte preview_wait;

   370

	byte railtype;

   371

	byte unk1B;

   372

} GCC_PACK OldEngine;

   373

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

   374

   375

typedef struct {

   376

	byte cargo_type;

   377

	byte age;

   378

	byte from;

   379

	byte to;

   380

} GCC_PACK OldSubsidy;

   381

assert_compile(sizeof(OldSubsidy) == 4);

   382

   383

typedef struct {

   384

	uint16 max_no_competitors;

   385

	uint16 competitor_start_time;

   386

	uint16 number_towns;

   387

	uint16 number_industries;

   388

	uint16 max_loan;

   389

	uint16 initial_interest;

   390

	uint16 vehicle_costs;

   391

	uint16 competitor_speed;

   392

	uint16 competitor_intelligence;

   393

	uint16 vehicle_breakdowns;

   394

	uint16 subsidy_multiplier;

   395

	uint16 construction_cost;

   396

	uint16 terrain_type;

   397

	uint16 quantity_sea_lakes;

   398

	uint16 economy;

   399

	uint16 line_reverse_mode;

   400

	uint16 disasters;

   401

} GCC_PACK OldGameSettings;

   402

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

   403

   404

typedef struct {

   405

	uint16 date;

   406

	uint16 date_fract;

   407

   408

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

   409

	uint32 seed_1, seed_2;

   410

   411

	OldTown town_list[70];

   412

	uint16 order_list[5000];

   413

   414

	uint16 animated_tile_list[256];

   415

	uint32 ptr_to_next_order;

   416

	OldDepot depots[255];

   417

   418

	uint32 cur_town_ptr;

   419

	uint16 timer_counter;

   420

	uint16 land_code; // NOLOAD: never needed in game

   421

	uint16 age_cargo_skip_counter;

   422

	uint16 tick_counter;

   423

	uint16 cur_tileloop_tile;

   424

   425

	OldPrice prices[49];

   426

	OldPaymentRate cargo_payment_rates[12];

   427

   428

	byte map_owner[256*256];

   429

	byte map2[256*256];

   430

	uint16 map3[256*256];

   431

	byte map_extra[256*256/4];

   432

   433

	OldStation stations[250];

   434

	OldIndustry industries[90];

   435

	OldPlayer players[8];

   436

	OldVehicle vehicles[850];

   437

	OldName names[500];

   438

   439

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

   440

   441

	OldSign signs[40];

   442

	OldEngine engines[256];

   443

   444

	uint16 vehicle_id_ctr_day;

   445

	OldSubsidy subsidies[8];

   446

   447

	uint16 next_competitor_start;

   448

   449

	uint16 saved_main_scrollpos_x, saved_main_scrollpos_y, saved_main_scrollpos_zoom;

   450

	uint32 maximum_loan, maximum_loan_unround;

   451

	uint16 economy_fluct;

   452

	uint16 disaster_delay;

   453

   454

	//NOLOAD. These are calculated from InitializeLandscapeVariables

   455

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

   456

	uint16 cargo_sprites[12];

   457

   458

	uint16 engine_name_strings[256];

   459

   460

	//NOLOAD. These are calculated from InitializeLandscapeVariables

   461

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

   462

	uint16 roadveh_by_cargo_start[12];

   463

	byte roadveh_by_cargo_count[12];

   464

	uint16 ship_of_type_start[12];

   465

	byte ship_of_type_count[12];

   466

   467

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

   468

	byte station_tick_ctr;

   469

	byte currency;

   470

	byte use_kilometers;

   471

	byte cur_player_tick_index;

   472

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

   473

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

   474

   475

	byte inflation_amount;

   476

	byte inflation_amount_payment_rates;

   477

	byte interest_rate;

   478

   479

	byte avail_aircraft;

   480

	byte road_side;

   481

	byte town_name_type;

   482

	OldGameSettings game_diff;

   483

	byte difficulty_level;

   484

	byte landscape_type;

   485

	byte trees_tick_ctr;

   486

	byte vehicle_design_names;

   487

	byte snow_line_height;

   488

   489

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

   490

   491

	//NOLOAD. Initialized by InitializeLandscapeVariables

   492

	byte cargo_weights[12];

   493

	byte transit_days_table_1[12];

   494

	byte transit_days_table_2[12];

   495

   496

	byte map_type_and_height[256*256];

   497

	byte map5[256*256];

   498

} GCC_PACK OldMain;

   499

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

   500

   501

#if defined(_MSC_VER)

   502

#pragma pack(pop)

   503

#endif

   504

   505

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

   506

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

   507

   508

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

   509

   510

typedef struct LoadSavegameState {

   511

	int8 mode;

   512

	byte rep_char;

   513

   514

	size_t count;

   515

	size_t buffer_count;

   516

	FILE *fin;

   517

   518

	byte *buffer_cur;

   519

   520

	byte buffer[4096];

   521

   522

} LoadSavegameState;

   523

   524

static LoadSavegameState *_cur_state;

   525

   526

static byte GetSavegameByteFromBuffer()

   527

{