1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "town.h"

     6

#include "industry.h"

     7

#include "station.h"

     8

#include "economy.h"

     9

#include "player.h"

    10

#include "engine.h"

    11

#include "vehicle.h"

    12

    13

extern byte _name_array[512][32];

    14

extern TileIndex _animated_tile_list[256];

    15

extern uint16 _custom_sprites_base;

    16

    17

#if defined(_MSC_VER)

    18

#pragma pack(push, 1)

    19

#endif

    20

    21

typedef struct {

    22

	uint16 string_id;

    23

	uint16 x;

    24

	uint16 right;

    25

	uint16 y;

    26

	uint16 bottom;

    27

	uint16 duration;

    28

	uint32 params[2];

    29

} GCC_PACK OldTextEffect;

    30

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

    31

    32

typedef struct {

    33

	uint16 xy;

    34

	uint16 population;

    35

	uint16 townnametype;

    36

	uint32 townnameparts;

    37

	byte grow_counter;

    38

	byte sort_index;

    39

	int16 sign_left, sign_top;

    40

	byte namewidth_1, namewidth_2;

    41

	uint16 flags12;

    42

	uint16 radius[5];

    43

	uint16 ratings[8];

    44

	uint32 have_ratings;

    45

	uint32 statues;

    46

	uint16 num_houses;

    47

	byte time_until_rebuild;

    48

	byte growth_rate;

    49

	uint16 new_max_pass, new_max_mail;

    50

	uint16 new_act_pass, new_act_mail;

    51

	uint16 max_pass, max_mail;

    52

	uint16 act_pass, act_mail;

    53

	byte pct_pass_transported, pct_mail_transported;

    54

	uint16 new_act_food, new_act_water;

    55

	uint16 act_food, act_water;

    56

	byte road_build_months;

    57

	byte fund_buildings_months;

    58

	// unused bytes at the end of the Town Struct

    59

	uint32 unk56;

    60

	uint32 unk5A;

    61

} GCC_PACK OldTown;

    62

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

    63

    64

typedef struct {

    65

	uint16 xy;

    66

	uint32 town;

    67

} GCC_PACK OldDepot;

    68

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

    69

    70

typedef struct {

    71

	uint32 price;

    72

	uint16 frac;

    73

} GCC_PACK OldPrice;

    74

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

    75

    76

typedef struct {

    77

	uint32 price;

    78

	uint16 frac;

    79

	uint16 unused;

    80

} GCC_PACK OldPaymentRate;

    81

assert_compile(sizeof(OldPaymentRate) == 8);

    82

    83

typedef struct {

    84

	uint16 waiting_acceptance;

    85

	byte days_since_pickup;

    86

	byte rating;

    87

	byte enroute_from;

    88

	byte enroute_time;

    89

	byte last_speed;

    90

	byte last_age;

    91

} GCC_PACK OldGoodsEntry;

    92

assert_compile(sizeof(OldGoodsEntry) == 8);

    93

    94

typedef struct {

    95

	uint16 xy;

    96

	uint32 town;

    97

	uint16 bus_tile, lorry_tile, train_tile, airport_tile, dock_tile;

    98

	byte platforms;

    99

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

   100

	byte namewidth_1, namewidth_2;

   101

	uint16 string_id;

   102

	int16 sign_left, sign_top;

   103

	uint16 had_vehicle_of_type;

   104

	OldGoodsEntry goods[12];

   105

	byte time_since_load, time_since_unload;

   106

	byte delete_ctr;

   107

	byte owner;

   108

	byte facilities;

   109

	byte airport_type;

   110

	byte truck_stop_status, bus_stop_status;

   111

	byte blocked_months_obsolete;

   112

	byte unk85;

   113

	uint16 airport_flags;

   114

	uint16 last_vehicle;

   115

	uint32 unk8A;

   116

} GCC_PACK OldStation;

   117

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

   118

   119

typedef struct {

   120

	uint16 xy;

   121

	uint32 town;

   122

	byte width;

   123

	byte height;

   124

	byte produced_cargo[2];

   125

	uint16 cargo_waiting[2];

   126

	byte production_rate[2];

   127

	byte accepts_cargo[3];

   128

	byte prod_level;

   129

	uint16 last_mo_production[2];

   130

	uint16 last_mo_transported[2];

   131

	byte pct_transported[2];

   132

	uint16 total_production[2];

   133

	uint16 total_transported[2];

   134

	byte type;

   135

	byte owner;

   136

	byte color_map;

   137

	byte last_prod_year;

   138

	uint16 counter;

   139

	byte was_cargo_delivered;

   140

	byte nothing;

   141

	uint32 unk2E;

   142

	uint32 unk32;

   143

} GCC_PACK OldIndustry;

   144

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

   145

   146

typedef struct {

   147

	int32 cost[13];

   148

} GCC_PACK OldPlayerExpenses;

   149

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

   150

   151

typedef struct {

   152

	int32 income;

   153

	int32 expenses;

   154

	uint32 delivered_cargo;

   155

	uint32 performance_history;

   156

	uint32 company_value;

   157

} GCC_PACK OldPlayerEconomy;

   158

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

   159

   160

typedef struct {

   161

	uint16 spec_tile;

   162

	uint16 use_tile;

   163

	byte rand_rng;

   164

	byte cur_rule;

   165

	byte unk6;

   166

	byte unk7;

   167

	byte buildcmd_a;

   168

	byte buildcmd_b;

   169

	byte direction;

   170

	byte cargo;

   171

	byte unused[8];

   172

} GCC_PACK OldAiBuildRec;

   173

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

   174

   175

typedef struct {

   176

	uint16 tile;

   177

	byte data;

   178

} GCC_PACK OldAiBannedTile;

   179

assert_compile(sizeof(OldAiBannedTile) == 3);

   180

   181

typedef struct {

   182

	uint16 name_1;

   183

	uint32 name_2;

   184

	uint32 face;

   185

	uint16 pres_name_1;

   186

	uint32 pres_name_2;

   187

	uint32 money;

   188

	uint32 loan;

   189

	byte color;

   190

	byte money_fract;

   191

	byte quarters_of_bankrupcy;

   192

	byte bankrupt_asked;

   193

	uint32 bankrupt_value;

   194

	uint16 bankrupt_timeout;

   195

	uint32 cargo_types;

   196

	OldPlayerExpenses expenses[3];

   197

	OldPlayerEconomy economy[24 + 1];

   198

	uint16 inaugurated_date;

   199

	uint16 last_build_coordinate;

   200

	byte num_valid_stat_ent;

   201

	byte ai_state;

   202

	byte unused;

   203

	byte ai_state_mode;

   204

	uint16 ai_state_counter;

   205

	uint16 ai_timeout_counter;

   206

	OldAiBuildRec ai_src, ai_dst, ai_mid1, ai_mid2;

   207

	byte unused_2[20];

   208

	byte ai_cargo_type;

   209

	byte ai_num_wagons;

   210

	byte ai_build_kind;

   211

	byte ai_num_build_rec;

   212

	byte ai_num_loco_to_build;

   213

	byte ai_num_want_fullload;

   214

	byte unused_3[14];

   215

	uint16 ai_loco_id; // NOT USED

   216

	uint16 ai_wagonlist[9];

   217

	byte ai_order_list_blocks[20];

   218

	uint16 ai_start_tile_a;

   219

	uint16 ai_start_tile_b;

   220

	uint16 ai_cur_tile_a;

   221

	uint16 ai_cur_tile_b;

   222

	byte ai_start_dir_a;

   223

	byte ai_start_dir_b;

   224

	byte ai_cur_dir_a;

   225

	byte ai_cur_dir_b;

   226

	byte ai_banned_tile_count;

   227

	OldAiBannedTile banned_tiles[16];

   228

	byte ai_railtype_to_use;

   229

	byte ai_route_type_mask;

   230

	byte block_preview;

   231

	byte ai_tick;

   232

	byte max_railtype;

   233

	uint16 location_of_house;

   234

	byte share_owners[4];

   235

	uint32 unk3AA;

   236

	uint32 unk3AE;

   237

} GCC_PACK OldPlayer;

   238

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

   239

   240

typedef struct {

   241

	byte track;

   242

	byte force_proceed;

   243

	uint16 crash_anim_pos;

   244

	byte railtype;

   245

} GCC_PACK OldVehicleRailUnion;

   246

assert_compile(sizeof(OldVehicleRailUnion) == 5);

   247

   248

typedef struct {

   249

	byte unk0;

   250

	byte targetairport;

   251

	uint16 crashed_counter;

   252

	byte state;

   253

} GCC_PACK OldVehicleAirUnion;

   254

assert_compile(sizeof(OldVehicleAirUnion) == 5);

   255

   256

typedef struct {

   257

	byte state;

   258

	byte frame;

   259

	uint16 unk2;

   260

	byte overtaking;

   261

	byte overtaking_ctr;

   262

	uint16 crashed_ctr;

   263

	byte reverse_ctr;

   264

} GCC_PACK OldVehicleRoadUnion;

   265

assert_compile(sizeof(OldVehicleRoadUnion) == 9);

   266

   267

typedef struct {

   268

	uint16 unk0;

   269

	byte unk2;

   270

} GCC_PACK OldVehicleSpecialUnion;

   271

assert_compile(sizeof(OldVehicleSpecialUnion) == 3);

   272

   273

typedef struct {

   274

	uint16 image_override;

   275

	uint16 unk2;

   276

} GCC_PACK OldVehicleDisasterUnion;

   277

assert_compile(sizeof(OldVehicleDisasterUnion) == 4);

   278

   279

typedef struct {

   280

	byte state;

   281

} OldVehicleShipUnion;

   282

assert_compile(sizeof(OldVehicleShipUnion) == 1);

   283

   284

typedef union {

   285

	OldVehicleRailUnion rail;

   286

	OldVehicleAirUnion air;

   287

	OldVehicleRoadUnion road;

   288

	OldVehicleSpecialUnion special;

   289

	OldVehicleDisasterUnion disaster;

   290

	OldVehicleShipUnion ship;

   291

	byte pad[10];

   292

} GCC_PACK OldVehicleUnion;

   293

assert_compile(sizeof(OldVehicleUnion) == 10);

   294

   295

typedef struct {

   296

	byte type;

   297

	byte subtype;

   298

	uint16 next_hash; // NOLOAD, calculated automatically.

   299

	uint16 index;     // NOLOAD, calculated automatically.

   300

	uint32 schedule_ptr;

   301

	byte next_order, next_order_param;

   302

	byte num_orders;

   303

	byte cur_order_index;

   304

	uint16 dest_tile;

   305

	uint16 load_unload_time_rem;

   306

	uint16 date_of_last_service;

   307

	uint16 service_interval;

   308

	byte last_station_visited;

   309

	byte tick_counter;

   310

	uint16 max_speed;

   311

	uint16 x_pos, y_pos;

   312

	byte z_pos;

   313

	byte direction;

   314

	byte x_offs, y_offs;

   315

	byte sprite_width, sprite_height, z_height;

   316

	byte owner;

   317

	uint16 tile;

   318

	uint16 cur_image;

   319

   320

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

   321

	uint16 vehstatus;

   322

	uint16 cur_speed;

   323

	byte subspeed;

   324

	byte acceleration;

   325

	byte progress;

   326

	byte cargo_type;

   327

	uint16 capacity;

   328

	uint16 number_of_pieces;

   329

	byte source_of_pieces;

   330

	byte days_in_transit;

   331

	uint16 age_in_days, max_age_in_days;

   332

	byte build_year;

   333

	byte unitnumber;

   334

	uint16 engine_type;

   335

	byte spritenum;

   336

	byte day_counter;

   337

	byte breakdowns_since_last_service;

   338

	byte breakdown_ctr, breakdown_delay, breakdown_chance;

   339

	uint16 reliability, reliability_spd_dec;

   340

	uint32 profit_this_year, profit_last_year;

   341

	uint16 next_in_chain;

   342

	uint32 value;

   343

	uint16 string_id;

   344

	OldVehicleUnion u;

   345

	byte unused[20];

   346

} GCC_PACK OldVehicle;

   347

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

   348

   349

typedef struct {

   350

	byte name[32];

   351

} GCC_PACK OldName;

   352

   353

typedef struct {

   354

	uint16 text;

   355

	int16 x,y,z;

   356

	byte namewidth_1, namewidth_2;

   357

	int16 sign_left, sign_top;

   358

} GCC_PACK OldSign;

   359

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

   360

   361

typedef struct {

   362

	uint16 player_avail;

   363

	uint16 intro_date;

   364

	uint16 age;

   365

	uint16 reliability, reliability_spd_dec, reliability_start, reliability_max, reliability_final;

   366

	uint16 duration_phase_1, duration_phase_2, duration_phase_3;

   367

	byte lifelength;

   368

	byte flags;

   369

	byte preview_player;

   370

	byte preview_wait;

   371

	byte railtype;

   372

	byte unk1B;

   373

} GCC_PACK OldEngine;

   374

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

   375

   376

typedef struct {

   377

	byte cargo_type;

   378

	byte age;

   379

	byte from;

   380

	byte to;

   381

} GCC_PACK OldSubsidy;

   382

assert_compile(sizeof(OldSubsidy) == 4);

   383

   384

typedef struct {

   385

	uint16 max_no_competitors;

   386

	uint16 competitor_start_time;

   387

	uint16 number_towns;

   388

	uint16 number_industries;

   389

	uint16 max_loan;

   390

	uint16 initial_interest;

   391

	uint16 vehicle_costs;

   392

	uint16 competitor_speed;

   393

	uint16 competitor_intelligence;

   394

	uint16 vehicle_breakdowns;

   395

	uint16 subsidy_multiplier;

   396

	uint16 construction_cost;

   397

	uint16 terrain_type;

   398

	uint16 quantity_sea_lakes;

   399

	uint16 economy;

   400

	uint16 line_reverse_mode;

   401

	uint16 disasters;

   402

} GCC_PACK OldGameSettings;

   403

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

   404

   405

typedef struct {

   406

	uint16 date;

   407

	uint16 date_fract;

   408

   409

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

   410

	uint32 seed_1, seed_2;

   411

   412

	OldTown town_list[70];

   413

	uint16 order_list[5000];

   414

   415

	uint16 animated_tile_list[256];

   416

	uint32 ptr_to_next_order;

   417

	OldDepot depots[255];

   418

   419

	uint32 cur_town_ptr;

   420

	uint16 timer_counter;

   421

	uint16 land_code; // NOLOAD: never needed in game

   422

	uint16 age_cargo_skip_counter;

   423

	uint16 tick_counter;

   424

	uint16 cur_tileloop_tile;

   425

   426

	OldPrice prices[49];

   427

	OldPaymentRate cargo_payment_rates[12];

   428

   429

	byte map_owner[256*256];

   430

	byte map2[256*256];

   431

	uint16 map3[256*256];

   432

	byte map_extra[256*256/4];

   433

   434

	OldStation stations[250];

   435

	OldIndustry industries[90];

   436

	OldPlayer players[8];

   437

	OldVehicle vehicles[850];

   438

	OldName names[500];

   439

   440

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

   441

   442

	OldSign signs[40];

   443

	OldEngine engines[256];

   444

   445

	uint16 vehicle_id_ctr_day;

   446

	OldSubsidy subsidies[8];

   447

   448

	uint16 next_competitor_start;

   449

   450

	uint16 saved_main_scrollpos_x, saved_main_scrollpos_y, saved_main_scrollpos_zoom;

   451

	uint32 maximum_loan, maximum_loan_unround;

   452

	uint16 economy_fluct;

   453

	uint16 disaster_delay;

   454

   455

	//NOLOAD. These are calculated from InitializeLandscapeVariables

   456

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

   457

	uint16 cargo_sprites[12];

   458

   459

	uint16 engine_name_strings[256];

   460

   461

	//NOLOAD. These are calculated from InitializeLandscapeVariables

   462

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

   463

	uint16 roadveh_by_cargo_start[12];

   464

	byte roadveh_by_cargo_count[12];

   465

	uint16 ship_of_type_start[12];

   466

	byte ship_of_type_count[12];

   467

   468

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

   469

	byte station_tick_ctr;

   470

	byte currency;

   471

	byte use_kilometers;

   472

	byte cur_player_tick_index;

   473

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

   474

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

   475

   476

	byte inflation_amount;

   477

	byte inflation_amount_payment_rates;

   478

	byte interest_rate;

   479

   480

	byte avail_aircraft;

   481

	byte road_side;

   482

	byte town_name_type;

   483

	OldGameSettings game_diff;

   484

	byte difficulty_level;

   485

	byte landscape_type;

   486

	byte trees_tick_ctr;

   487

	byte vehicle_design_names;

   488

	byte snow_line_height;

   489

   490

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

   491

   492

	//NOLOAD. Initialized by InitializeLandscapeVariables

   493

	byte cargo_weights[12];

   494

	byte transit_days_table_1[12];

   495

	byte transit_days_table_2[12];

   496

   497

	byte map_type_and_height[256*256];

   498

	byte map5[256*256];

   499

} GCC_PACK OldMain;

   500

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

   501

   502

#if defined(_MSC_VER)

   503

#pragma pack(pop)

   504

#endif

   505

   506

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

   507

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

   508

   509

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

   510

   511

typedef struct LoadSavegameState {

   512

	int8 mode;

   513

	byte rep_char;

   514

   515

	size_t count;

   516

	size_t buffer_count;

   517

	FILE *fin;

   518

   519

	byte *buffer_cur;

   520

   521

	byte buffer[4096];

   522

   523

} LoadSavegameState;

   524

   525

static LoadSavegameState *_cur_state;

   526

   527

static byte GetSavegameByteFromBuffer()