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

#include "signs.h"

    13

    14

extern byte _name_array[512][32];

    15

extern TileIndex _animated_tile_list[256];

    16

extern uint16 _custom_sprites_base;

    17

    18

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

    19

#pragma pack(push, 1)

    20

#endif

    21

    22

typedef struct {

    23

	uint16 string_id;

    24

	uint16 x;

    25

	uint16 right;

    26

	uint16 y;

    27

	uint16 bottom;

    28

	uint16 duration;

    29

	uint32 params[2];

    30

} GCC_PACK OldTextEffect;

    31

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

    32

    33

typedef struct {

    34

	uint16 xy;

    35

	uint16 population;

    36

	uint16 townnametype;

    37

	uint32 townnameparts;

    38

	byte grow_counter;

    39

	byte sort_index;

    40

	int16 sign_left, sign_top;

    41

	byte namewidth_1, namewidth_2;

    42

	uint16 flags12;

    43

	uint16 radius[5];

    44

	uint16 ratings[8];

    45

	uint32 have_ratings;

    46

	uint32 statues;

    47

	uint16 num_houses;

    48

	byte time_until_rebuild;

    49

	byte growth_rate;

    50

	uint16 new_max_pass, new_max_mail;

    51

	uint16 new_act_pass, new_act_mail;

    52

	uint16 max_pass, max_mail;

    53

	uint16 act_pass, act_mail;

    54

	byte pct_pass_transported, pct_mail_transported;

    55

	uint16 new_act_food, new_act_water;

    56

	uint16 act_food, act_water;

    57

	byte road_build_months;

    58

	byte fund_buildings_months;

    59

	// unused bytes at the end of the Town Struct

    60

	uint32 unk56;

    61

	uint32 unk5A;

    62

} GCC_PACK OldTown;

    63

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

    64

    65

typedef struct {

    66

	uint16 xy;

    67

	uint32 town;

    68

} GCC_PACK OldDepot;

    69

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

    70

    71

typedef struct {

    72

	uint32 price;

    73

	uint16 frac;

    74

} GCC_PACK OldPrice;

    75

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

    76

    77

typedef struct {

    78

	uint32 price;

    79

	uint16 frac;

    80

	uint16 unused;

    81

} GCC_PACK OldPaymentRate;

    82

assert_compile(sizeof(OldPaymentRate) == 8);

    83

    84

typedef struct {

    85

	uint16 waiting_acceptance;

    86

	byte days_since_pickup;

    87

	byte rating;

    88

	byte enroute_from;

    89

	byte enroute_time;

    90

	byte last_speed;

    91

	byte last_age;

    92

} GCC_PACK OldGoodsEntry;

    93

assert_compile(sizeof(OldGoodsEntry) == 8);

    94

    95

typedef struct {

    96

	uint16 xy;

    97

	uint32 town;

    98

	uint16 bus_tile, lorry_tile, train_tile, airport_tile, dock_tile;

    99

	byte platforms;

   100

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

   101

	byte namewidth_1, namewidth_2;

   102

	uint16 string_id;

   103

	int16 sign_left, sign_top;

   104

	uint16 had_vehicle_of_type;

   105

	OldGoodsEntry goods[12];

   106

	byte time_since_load, time_since_unload;

   107

	byte delete_ctr;

   108

	byte owner;

   109

	byte facilities;

   110

	byte airport_type;

   111

	byte truck_stop_status, bus_stop_status;

   112

	byte blocked_months_obsolete;

   113

	byte unk85;

   114

	uint16 airport_flags;

   115

	uint16 last_vehicle;

   116

	uint32 unk8A;

   117

} GCC_PACK OldStation;

   118

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

   119

   120

typedef struct {

   121

	uint16 xy;

   122

	uint32 town;

   123

	byte width;

   124

	byte height;

   125

	byte produced_cargo[2];

   126

	uint16 cargo_waiting[2];

   127

	byte production_rate[2];

   128

	byte accepts_cargo[3];

   129

	byte prod_level;

   130

	uint16 last_mo_production[2];

   131

	uint16 last_mo_transported[2];

   132

	byte pct_transported[2];

   133

	uint16 total_production[2];

   134

	uint16 total_transported[2];

   135

	byte type;

   136

	byte owner;

   137

	byte color_map;

   138

	byte last_prod_year;

   139

	uint16 counter;

   140

	byte was_cargo_delivered;

   141

	byte nothing;

   142

	uint32 unk2E;

   143

	uint32 unk32;

   144

} GCC_PACK OldIndustry;

   145

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

   146

   147

typedef struct {

   148

	int32 cost[13];

   149

} GCC_PACK OldPlayerExpenses;

   150

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

   151

   152

typedef struct {

   153

	int32 income;

   154

	int32 expenses;

   155

	uint32 delivered_cargo;

   156

	uint32 performance_history;

   157

	uint32 company_value;

   158

} GCC_PACK OldPlayerEconomy;

   159

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

   160

   161

typedef struct {

   162

	uint16 spec_tile;

   163

	uint16 use_tile;

   164

	byte rand_rng;

   165

	byte cur_rule;

   166

	byte unk6;

   167

	byte unk7;

   168

	byte buildcmd_a;

   169

	byte buildcmd_b;

   170

	byte direction;

   171

	byte cargo;

   172

	byte unused[8];

   173

} GCC_PACK OldAiBuildRec;

   174

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

   175

   176

typedef struct {

   177

	uint16 tile;

   178

	byte data;

   179

} GCC_PACK OldAiBannedTile;

   180

assert_compile(sizeof(OldAiBannedTile) == 3);

   181

   182

typedef struct {

   183

	uint16 name_1;

   184

	uint32 name_2;

   185

	uint32 face;

   186

	uint16 pres_name_1;

   187

	uint32 pres_name_2;

   188

	uint32 money;

   189

	uint32 loan;

   190

	byte color;

   191

	byte money_fract;

   192

	byte quarters_of_bankrupcy;

   193

	byte bankrupt_asked;

   194

	uint32 bankrupt_value;

   195

	uint16 bankrupt_timeout;

   196

	uint32 cargo_types;

   197

	OldPlayerExpenses expenses[3];

   198

	OldPlayerEconomy economy[24 + 1];

   199

	uint16 inaugurated_date;

   200

	uint16 last_build_coordinate;

   201

	byte num_valid_stat_ent;

   202

	byte ai_state;

   203

	byte unused;

   204

	byte ai_state_mode;

   205

	uint16 ai_state_counter;

   206

	uint16 ai_timeout_counter;

   207

	OldAiBuildRec ai_src, ai_dst, ai_mid1, ai_mid2;

   208

	byte unused_2[20];

   209

	byte ai_cargo_type;

   210

	byte ai_num_wagons;

   211

	byte ai_build_kind;

   212

	byte ai_num_build_rec;

   213

	byte ai_num_loco_to_build;

   214

	byte ai_num_want_fullload;

   215

	byte unused_3[14];

   216

	uint16 ai_loco_id; // NOT USED

   217

	uint16 ai_wagonlist[9];

   218

	byte ai_order_list_blocks[20];

   219

	uint16 ai_start_tile_a;

   220

	uint16 ai_start_tile_b;

   221

	uint16 ai_cur_tile_a;

   222

	uint16 ai_cur_tile_b;

   223

	byte ai_start_dir_a;

   224

	byte ai_start_dir_b;

   225

	byte ai_cur_dir_a;

   226

	byte ai_cur_dir_b;

   227

	byte ai_banned_tile_count;

   228

	OldAiBannedTile banned_tiles[16];

   229

	byte ai_railtype_to_use;

   230

	byte ai_route_type_mask;

   231

	byte block_preview;

   232

	byte ai_tick;

   233

	byte max_railtype;

   234

	uint16 location_of_house;

   235

	byte share_owners[4];

   236

	uint32 unk3AA;

   237

	uint32 unk3AE;

   238

} GCC_PACK OldPlayer;

   239

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

   240

   241

typedef struct {

   242

	byte track;

   243

	byte force_proceed;

   244

	uint16 crash_anim_pos;

   245

	byte railtype;

   246

} GCC_PACK OldVehicleRailUnion;

   247

assert_compile(sizeof(OldVehicleRailUnion) == 5);

   248

   249

typedef struct {

   250

	byte unk0;

   251

	byte targetairport;

   252

	uint16 crashed_counter;

   253

	byte state;

   254

} GCC_PACK OldVehicleAirUnion;

   255

assert_compile(sizeof(OldVehicleAirUnion) == 5);

   256

   257

typedef struct {

   258

	byte state;

   259

	byte frame;

   260

	uint16 unk2;

   261

	byte overtaking;

   262

	byte overtaking_ctr;

   263

	uint16 crashed_ctr;

   264

	byte reverse_ctr;

   265

} GCC_PACK OldVehicleRoadUnion;

   266

assert_compile(sizeof(OldVehicleRoadUnion) == 9);

   267

   268

typedef struct {

   269

	uint16 unk0;

   270

	byte unk2;

   271

} GCC_PACK OldVehicleSpecialUnion;

   272

assert_compile(sizeof(OldVehicleSpecialUnion) == 3);

   273

   274

typedef struct {

   275

	uint16 image_override;

   276

	uint16 unk2;

   277

} GCC_PACK OldVehicleDisasterUnion;

   278

assert_compile(sizeof(OldVehicleDisasterUnion) == 4);

   279

   280

typedef struct {

   281

	byte state;

   282

} GCC_PACK OldVehicleShipUnion;

   283

assert_compile(sizeof(OldVehicleShipUnion) == 1);

   284

   285

typedef union {

   286

	OldVehicleRailUnion rail;

   287

	OldVehicleAirUnion air;

   288

	OldVehicleRoadUnion road;

   289

	OldVehicleSpecialUnion special;

   290

	OldVehicleDisasterUnion disaster;

   291

	OldVehicleShipUnion ship;

   292

	byte pad[10];

   293

} GCC_PACK OldVehicleUnion;

   294

assert_compile(sizeof(OldVehicleUnion) == 10);

   295

   296

typedef struct {

   297

	byte type;

   298

	byte subtype;

   299

	uint16 next_hash; // NOLOAD, calculated automatically.

   300

	uint16 index;     // NOLOAD, calculated automatically.

   301

	uint32 schedule_ptr;

   302

	byte next_order, next_order_param;

   303

	byte num_orders;

   304

	byte cur_order_index;

   305

	uint16 dest_tile;

   306

	uint16 load_unload_time_rem;

   307

	uint16 date_of_last_service;

   308

	uint16 service_interval;

   309

	byte last_station_visited;

   310

	byte tick_counter;

   311

	uint16 max_speed;

   312

	uint16 x_pos, y_pos;

   313

	byte z_pos;

   314

	byte direction;

   315

	byte x_offs, y_offs;

   316

	byte sprite_width, sprite_height, z_height;

   317

	byte owner;

   318

	uint16 tile;

   319

	uint16 cur_image;

   320

   321

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

   322

	uint16 vehstatus;

   323

	uint16 cur_speed;

   324

	byte subspeed;

   325

	byte acceleration;

   326

	byte progress;

   327

	byte cargo_type;

   328

	uint16 capacity;

   329

	uint16 number_of_pieces;

   330

	byte source_of_pieces;

   331

	byte days_in_transit;

   332

	uint16 age_in_days, max_age_in_days;

   333

	byte build_year;

   334

	byte unitnumber;

   335

	uint16 engine_type;

   336

	byte spritenum;

   337

	byte day_counter;

   338

	byte breakdowns_since_last_service;

   339

	byte breakdown_ctr, breakdown_delay, breakdown_chance;

   340

	uint16 reliability, reliability_spd_dec;

   341

	uint32 profit_this_year, profit_last_year;

   342

	uint16 next_in_chain;

   343

	uint32 value;

   344

	uint16 string_id;

   345

	OldVehicleUnion u;

   346

	byte unused[20];

   347

} GCC_PACK OldVehicle;

   348

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

   349

   350

typedef struct {

   351

	byte name[32];

   352

} GCC_PACK OldName;

   353

   354

typedef struct {

   355

	uint16 text;

   356

	int16 x,y,z;

   357

	byte namewidth_1, namewidth_2;

   358

	int16 sign_left, sign_top;

   359

} GCC_PACK OldSign;

   360

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

   361

   362

typedef struct {

   363

	uint16 player_avail;

   364

	uint16 intro_date;

   365

	uint16 age;

   366

	uint16 reliability, reliability_spd_dec, reliability_start, reliability_max, reliability_final;

   367

	uint16 duration_phase_1, duration_phase_2, duration_phase_3;

   368

	byte lifelength;

   369

	byte flags;

   370

	byte preview_player;

   371

	byte preview_wait;

   372

	byte railtype;

   373

	byte unk1B;

   374

} GCC_PACK OldEngine;

   375

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

   376

   377

typedef struct {

   378

	byte cargo_type;

   379

	byte age;

   380

	byte from;

   381

	byte to;

   382

} GCC_PACK OldSubsidy;

   383

assert_compile(sizeof(OldSubsidy) == 4);

   384

   385

typedef struct {

   386

	uint16 max_no_competitors;

   387

	uint16 competitor_start_time;

   388

	uint16 number_towns;

   389

	uint16 number_industries;

   390

	uint16 max_loan;

   391

	uint16 initial_interest;

   392

	uint16 vehicle_costs;

   393

	uint16 competitor_speed;

   394

	uint16 competitor_intelligence;

   395

	uint16 vehicle_breakdowns;

   396

	uint16 subsidy_multiplier;

   397

	uint16 construction_cost;

   398

	uint16 terrain_type;

   399

	uint16 quantity_sea_lakes;

   400

	uint16 economy;

   401

	uint16 line_reverse_mode;

   402

	uint16 disasters;

   403

} GCC_PACK OldGameSettings;

   404

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

   405

   406

typedef struct {

   407

	uint16 date;

   408

	uint16 date_fract;

   409

   410

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

   411

	uint32 seed_1, seed_2;

   412

   413

	OldTown town_list[70];

   414

	uint16 order_list[5000];

   415

   416

	uint16 animated_tile_list[256];

   417

	uint32 ptr_to_next_order;

   418

	OldDepot depots[255];

   419

   420

	uint32 cur_town_ptr;

   421

	uint16 timer_counter;

   422

	uint16 land_code; // NOLOAD: never needed in game

   423

	uint16 age_cargo_skip_counter;

   424

	uint16 tick_counter;

   425

	uint16 cur_tileloop_tile;

   426

   427

	OldPrice prices[49];

   428

	OldPaymentRate cargo_payment_rates[12];

   429

   430

	byte map_owner[256*256];

   431

	byte map2[256*256];

   432

	uint16 map3[256*256];

   433

	byte map_extra[256*256/4];

   434

   435

	OldStation stations[250];

   436

	OldIndustry industries[90];

   437

	OldPlayer players[8];

   438

	OldVehicle vehicles[850];

   439

	OldName names[500];

   440

   441

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

   442

   443

	OldSign signs[40];

   444

	OldEngine engines[256];

   445

   446

	uint16 vehicle_id_ctr_day;

   447

	OldSubsidy subsidies[8];

   448

   449

	uint16 next_competitor_start;

   450

   451

	uint16 saved_main_scrollpos_x, saved_main_scrollpos_y, saved_main_scrollpos_zoom;

   452

	uint32 maximum_loan, maximum_loan_unround;

   453

	uint16 economy_fluct;

   454

	uint16 disaster_delay;

   455

   456

	//NOLOAD. These are calculated from InitializeLandscapeVariables

   457

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

   458

	uint16 cargo_sprites[12];

   459

   460

	uint16 engine_name_strings[256];

   461

   462

	//NOLOAD. These are calculated from InitializeLandscapeVariables

   463

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

   464

	uint16 roadveh_by_cargo_start[12];

   465

	byte roadveh_by_cargo_count[12];

   466

	uint16 ship_of_type_start[12];

   467

	byte ship_of_type_count[12];

   468

   469

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

   470

	byte station_tick_ctr;

   471

	byte currency;

   472

	byte use_kilometers;

   473

	byte cur_player_tick_index;

   474

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

   475

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

   476

   477

	byte inflation_amount;

   478

	byte inflation_amount_payment_rates;

   479

	byte interest_rate;

   480

   481

	byte avail_aircraft;

   482

	byte road_side;

   483

	byte town_name_type;

   484

	OldGameSettings game_diff;

   485

	byte difficulty_level;

   486

	byte landscape_type;

   487

	byte trees_tick_ctr;

   488

	byte vehicle_design_names;

   489

	byte snow_line_height;

   490

   491

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

   492

   493

	//NOLOAD. Initialized by InitializeLandscapeVariables

   494

	byte cargo_weights[12];

   495

	byte transit_days_table_1[12];

   496

	byte transit_days_table_2[12];

   497

   498

	byte map_type_and_height[256*256];

   499

	byte map5[256*256];

   500

} GCC_PACK OldMain;

   501

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

   502

   503

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

   504

#pragma pack(pop)

   505

#endif

   506

   507

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

   508

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

   509

   510

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

   511

   512

typedef struct LoadSavegameState {

   513

	int8 mode;

   514

	byte rep_char;

   515

   516

	size_t count;

   517

	size_t buffer_count;

   518

	FILE *fin;

   519

   520

	byte *buffer_cur;

   521

   522

	byte buffer[4096];

   523

   524

} LoadSavegameState;

   525

   526