# oldloader_sl.cpp

Go to the documentation of this file.

    00001 /* $Id: oldloader_sl.cpp 15903 2009-03-30 23:15:05Z rubidium $ */
    00002
    00005 #include "../stdafx.h"
    00006 #include "../town.h"
    00007 #include "../industry.h"
    00008 #include "../company_func.h"
    00009 #include "../aircraft.h"
    00010 #include "../roadveh.h"
    00011 #include "../ship.h"
    00012 #include "../train.h"
    00013 #include "../signs_base.h"
    00014 #include "../debug.h"
    00015 #include "../depot_base.h"
    00016 #include "../newgrf_config.h"
    00017 #include "../zoom_func.h"
    00018 #include "../date_func.h"
    00019 #include "../vehicle_func.h"
    00020 #include "../variables.h"
    00021 #include "../effectvehicle_base.h"
    00022 #include "../core/mem_func.hpp"
    00023 #include "../core/alloc_type.hpp"
    00024 #include "saveload_internal.h"
    00025 #include "oldloader.h"
    00026
    00027 #include "table/strings.h"
    00028 #include "../table/engines.h"
    00029 #include "../table/namegen.h"
    00030
    00031 static bool   _read_ttdpatch_flags;
    00032
    00033 static uint8  *_old_map3;
    00034
    00035 void FixOldMapArray()
    00036 {
    00037   /* TTO/TTD/TTDP savegames could have buoys at tile 0
    00038    * (without assigned station struct) */
    00039   MemSetT(&_m[0], 0);
    00040   SetTileType(0, MP_WATER);
    00041   SetTileOwner(0, OWNER_WATER);
    00042 }
    00043
    00044 static void FixTTDMapArray()
    00045 {
    00046   /* _old_map3 is moved to _m::m3 and _m::m4 */
    00047   for (TileIndex t = 0; t < OLD_MAP_SIZE; t++) {
    00048     _m[t].m3 = _old_map3[t * 2];
    00049     _m[t].m4 = _old_map3[t * 2 + 1];
    00050   }
    00051
    00052   for (TileIndex t = 0; t < OLD_MAP_SIZE; t++) {
    00053     switch (GetTileType(t)) {
    00054       case MP_STATION:
    00055         _m[t].m4 = 0; // We do not understand this TTDP station mapping (yet)
    00056         switch (_m[t].m5) {
    00057           /* We have drive through stops at a totally different place */
    00058           case 0x53: case 0x54: _m[t].m5 += 170 - 0x53; break; // Bus drive through
    00059           case 0x57: case 0x58: _m[t].m5 += 168 - 0x57; break; // Truck drive through
    00060           case 0x55: case 0x56: _m[t].m5 += 170 - 0x55; break; // Bus tram stop
    00061           case 0x59: case 0x5A: _m[t].m5 += 168 - 0x59; break; // Truck tram stop
    00062           default: break;
    00063         }
    00064         break;
    00065
    00066       case MP_RAILWAY:
    00067         /* We save presignals different from TTDPatch, convert them */
    00068         if (GB(_m[t].m5, 6, 2) == 1) { // RAIL_TILE_SIGNALS
    00069           /* This byte is always zero in TTD for this type of tile */
    00070           if (_m[t].m4) { // Convert the presignals to our own format
    00071             _m[t].m4 = (_m[t].m4 >> 1) & 7;
    00072           }
    00073         }
    00074         /* TTDPatch stores PBS things in L6 and all elsewhere; so we'll just
    00075          * clear it for ourselves and let OTTD's rebuild PBS itself */
    00076         _m[t].m4 &= 0xF; // Only keep the lower four bits; upper four is PBS
    00077         break;
    00078
    00079       case MP_WATER:
    00080         /* if water class == 3, make river there */
    00081         if (GB(_m[t].m3, 0, 2) == 3) {
    00082           SetTileType(t, MP_WATER);
    00083           SetTileOwner(t, OWNER_WATER);
    00084           _m[t].m2 = 0;
    00085           _m[t].m3 = 2; // WATER_CLASS_RIVER
    00086           _m[t].m4 = Random();
    00087           _m[t].m5 = 0;
    00088         }
    00089         break;
    00090
    00091       default:
    00092         break;
    00093     }
    00094   }
    00095
    00096   FixOldMapArray();
    00097 }
    00098
    00099 #define FIXNUM(x, y, z) (((((x) << 16) / (y)) + 1) << z)
    00100
    00101 static uint32 RemapOldTownName(uint32 townnameparts, byte old_town_name_type)
    00102 {
    00103   switch (old_town_name_type) {
    00104     case 0: case 3: // English, American
    00105       /* Already OK */
    00106       return townnameparts;
    00107
    00108     case 1: // French
    00109       /* For some reason 86 needs to be subtracted from townnameparts
    00110        * 0000 0000 0000 0000 0000 0000 1111 1111 */
    00111       return FIXNUM(townnameparts - 86, lengthof(_name_french_real), 0);
    00112
    00113     case 2: // German
    00114       DEBUG(misc, 0, "German Townnames are buggy (%d)", townnameparts);
    00115       return townnameparts;
    00116
    00117     case 4: // Latin-American
    00118       /* 0000 0000 0000 0000 0000 0000 1111 1111 */
    00119       return FIXNUM(townnameparts, lengthof(_name_spanish_real), 0);
    00120
    00121     case 5: // Silly
    00122       /* NUM_SILLY_1 - lower 16 bits
    00123        * NUM_SILLY_2 - upper 16 bits without leading 1 (first 8 bytes)
    00124        * 1000 0000 2222 2222 0000 0000 1111 1111 */
    00125       return FIXNUM(townnameparts, lengthof(_name_silly_1), 0) | FIXNUM(GB(townnameparts, 16, 8), lengthof(_name_silly_2), 16);
    00126   }
    00127   return 0;
    00128 }
    00129
    00130 #undef FIXNUM
    00131
    00132 void FixOldTowns()
    00133 {
    00134   Town *town;
    00135
    00136   /* Convert town-names if needed */
    00137   FOR_ALL_TOWNS(town) {
    00138     if (IsInsideMM(town->townnametype, 0x20C1, 0x20C3)) {
    00139       town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _settings_game.game_creation.town_name;
    00140       town->townnameparts = RemapOldTownName(town->townnameparts, _settings_game.game_creation.town_name);
    00141     }
    00142   }
    00143 }
    00144
    00145 StringID *_old_vehicle_names;
    00146
    00147 void FixOldVehicles()
    00148 {
    00149   Vehicle *v;
    00150
    00151   FOR_ALL_VEHICLES(v) {
    00152     /* For some reason we need to correct for this */
    00153     switch (v->spritenum) {
    00154       case 0xfd: break;
    00155       case 0xff: v->spritenum = 0xfe; break;
    00156       default:   v->spritenum >>= 1; break;
    00157     }
    00158
    00159     /* Vehicle-subtype is different in TTD(Patch) */
    00160     if (v->type == VEH_EFFECT) v->subtype = v->subtype >> 1;
    00161
    00162     v->name = CopyFromOldName(_old_vehicle_names[v->index]);
    00163
    00164     /* We haven't used this bit for stations for ages */
    00165     if (v->type == VEH_ROAD &&
    00166         v->u.road.state != RVSB_IN_DEPOT &&
    00167         v->u.road.state != RVSB_WORMHOLE) {
    00168       ClrBit(v->u.road.state, RVS_IS_STOPPING);
    00169     }
    00170
    00171     /* The subtype should be 0, but it sometimes isn't :( */
    00172     if (v->type == VEH_ROAD || v->type == VEH_SHIP) v->subtype = 0;
    00173
    00174     /* Sometimes primary vehicles would have a nothing (invalid) order
    00175      * or vehicles that could not have an order would still have a
    00176      * (loading) order which causes assertions and the like later on.
    00177      */
    00178     if (!IsCompanyBuildableVehicleType(v) ||
    00179         (v->IsPrimaryVehicle() && v->current_order.IsType(OT_NOTHING))) {
    00180       v->current_order.MakeDummy();
    00181     }
    00182
    00183     /* Shared orders are fixed in AfterLoadVehicles now */
    00184   }
    00185 }
    00186
    00187 static bool FixTTOMapArray()
    00188 {
    00189   for (TileIndex t = 0; t < OLD_MAP_SIZE; t++) {
    00190     TileType tt = GetTileType(t);
    00191
    00192     switch (tt) {
    00193       case MP_CLEAR:
    00194         break;
    00195
    00196       case MP_RAILWAY:
    00197       case 11: // monorail
    00198         if (tt == 11) {
    00199           _m[t].m3 = 1; // rail type = monorail
    00200           _m[t].type_height &= 0x1F; // -> MP_RAILWAY
    00201           _m[t].m2 = 1; // set monorail ground to RAIL_GROUND_GRASS
    00202         }
    00203         switch (GB(_m[t].m5, 6, 2)) {
    00204           case 0: // RAIL_TILE_NORMAL
    00205             break;
    00206           case 1: // RAIL_TILE_SIGNALS
    00207             _m[t].m4 = (~_m[t].m5 & 1) << 2;        // signal variant (present only in OTTD)
    00208             SB(_m[t].m2, 6, 2, GB(_m[t].m5, 3, 2)); // signal status
    00209             _m[t].m3 |= 0xC0;                       // both signals are present
    00210             _m[t].m5 = HasBit(_m[t].m5, 5) ? 2 : 1; // track direction (only X or Y)
    00211             _m[t].m5 |= 0x40;                       // RAIL_TILE_SIGNALS
    00212             break;
    00213           case 3: // RAIL_TILE_DEPOT
    00214             _m[t].m2 = 0;
    00215             break;
    00216           default:
    00217             return false;
    00218         }
    00219         break;
    00220
    00221       case MP_ROAD: // road (depot) or level crossing
    00222         switch (GB(_m[t].m5, 4, 4)) {
    00223           case 0: // ROAD_TILE_NORMAL
    00224             if (_m[t].m2 == 4) _m[t].m2 = 5; // 'small trees' -> ROADSIDE_TREES
    00225             break;
    00226           case 1: // ROAD_TILE_CROSSING (there aren't monorail crossings in TTO)
    00227             _m[t].m3 = _m[t].m1; // set owner of road = owner of rail
    00228             break;
    00229           case 2: // ROAD_TILE_DEPOT
    00230             break;
    00231           default:
    00232             return false;
    00233         }
    00234         break;
    00235
    00236       case MP_HOUSE:
    00237         _m[t].m3 = _m[t].m2 & 0xC0;    // construction stage
    00238         _m[t].m2 &= 0x3F;              // building type
    00239         if (_m[t].m2 >= 5) _m[t].m2++; // skip "large office block on snow"
    00240         break;
    00241
    00242       case MP_TREES:
    00243         _m[t].m3 = GB(_m[t].m5, 3, 3); // type of trees
    00244         _m[t].m5 &= 0xC7;              // number of trees and growth status
    00245         break;
    00246
    00247       case MP_STATION:
    00248         _m[t].m3 = (_m[t].m5 >= 0x08 && _m[t].m5 <= 0x0F) ? 1 : 0; // monorail -> 1, others 0 (rail, road, airport, dock)
    00249         if (_m[t].m5 >= 8) _m[t].m5 -= 8; // shift for monorail
    00250         if (_m[t].m5 >= 0x42) _m[t].m5++; // skip heliport
    00251         break;
    00252
    00253       case MP_WATER:
    00254         _m[t].m3 = _m[t].m2 = 0;
    00255         break;
    00256
    00257       case MP_VOID:
    00258         _m[t].m2 = _m[t].m3 = _m[t].m5 = 0;
    00259         break;
    00260
    00261       case MP_INDUSTRY:
    00262         _m[t].m3 = 0;
    00263         switch (_m[t].m5) {
    00264           case 0x24: // farm silo
    00265             _m[t].m5 = 0x25;
    00266             break;
    00267           case 0x25: case 0x27: // farm
    00268           case 0x28: case 0x29: case 0x2A: case 0x2B: // factory
    00269             _m[t].m5--;
    00270             break;
    00271           default:
    00272             if (_m[t].m5 >= 0x2C) _m[t].m5 += 3; // iron ore mine, steel mill or bank
    00273             break;
    00274         }
    00275         break;
    00276
    00277       case MP_TUNNELBRIDGE:
    00278         if (HasBit(_m[t].m5, 7)) { // bridge
    00279           byte m5 = _m[t].m5;
    00280           _m[t].m5 = m5 & 0xE1; // copy bits 7..5, 1
    00281           if (GB(m5, 1, 2) == 1) _m[t].m5 |= 0x02; // road bridge
    00282           if (GB(m5, 1, 2) == 3) _m[t].m2 |= 0xA0; // monorail bridge -> tubular, steel bridge
    00283           if (!HasBit(m5, 6)) { // bridge head
    00284             _m[t].m3 = (GB(m5, 1, 2) == 3) ? 1 : 0; // track subtype (1 for monorail, 0 for others)
    00285           } else { // middle bridge part
    00286             _m[t].m3 = HasBit(m5, 2) ? 0x10 : 0;  // track subtype on bridge
    00287             if (GB(m5, 3, 2) == 3) _m[t].m3 |= 1; // track subtype under bridge
    00288             if (GB(m5, 3, 2) == 1) _m[t].m5 |= 0x08; // set for road/water under (0 for rail/clear)
    00289           }
    00290         } else { // tunnel entrance/exit
    00291           _m[t].m2 = 0;
    00292           _m[t].m3 = HasBit(_m[t].m5, 3); // monorail
    00293           _m[t].m5 &= HasBit(_m[t].m5, 3) ? 0x03 : 0x07 ; // direction, transport type (== 0 for rail)
    00294         }
    00295         break;
    00296
    00297       case MP_UNMOVABLE:
    00298         _m[t].m2 = 0;
    00299         _m[t].m3 = 0;
    00300         break;
    00301
    00302       default:
    00303         return false;
    00304
    00305     }
    00306   }
    00307
    00308   FixOldMapArray();
    00309
    00310   return true;
    00311 }
    00312
    00313 static Engine *_old_engines;
    00314
    00315 static bool FixTTOEngines()
    00316 {
    00318   static const EngineID ttd_to_tto[] = {
    00319       0, 255, 255, 255, 255, 255, 255, 255,   5,   7,   8,   9,  10,  11,  12,  13,
    00320     255, 255, 255, 255, 255, 255,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,
    00321     25,   26,  27,  28,  29,  30, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    00322     255, 255, 255, 255, 255, 255, 255,  31, 255,  32,  33,  34,  35,  36,  37,  38,
    00323      39,  40,  41,  42, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    00324     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    00325     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    00326     255, 255, 255, 255,  44,  45,  46, 255, 255, 255, 255,  47,  48, 255,  49,  50,
    00327     255, 255, 255, 255,  51,  52, 255,  53,  54, 255,  55,  56, 255,  57,  58, 255,
    00328      59,  60,   255,61,  62, 255,  63,  64, 255,  65,  66, 255, 255, 255, 255, 255,
    00329     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    00330     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    00331     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,  67,  68,  69,  70,
    00332      71, 255, 255,  76,  77, 255, 255,  78,  79,  80,  81,  82,  83,  84,  85,  86,
    00333      87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,  98,  99, 100, 101, 255,
    00334     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 102, 255, 255
    00335   };
    00336
    00338   static const EngineID tto_to_ttd[] = {
    00339       0,   0,   8,   8,   8,   8,   8,   9,  10,  11,  12,  13,  14,  15,  15,  22,
    00340      23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  55,
    00341      57,  58,  59,  60,  61,  62,  63,  64,  65,  66,  67, 116, 116, 117, 118, 123,
    00342     124, 126, 127, 132, 133, 135, 136, 138, 139, 141, 142, 144, 145, 147, 148, 150,
    00343     151, 153, 154, 204, 205, 206, 207, 208, 211, 212, 211, 212, 211, 212, 215, 216,
    00344     217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232,
    00345     233, 234, 235, 236, 237, 238, 253
    00346   };
    00347
    00348   Vehicle *v;
    00349   FOR_ALL_VEHICLES(v) {
    00350     if (v->engine_type >= lengthof(tto_to_ttd)) return false;
    00351     v->engine_type = tto_to_ttd[v->engine_type];
    00352   }
    00353
    00354   /* Load the default engine set. Many of them will be overriden later */
    00355   uint j = 0;
    00356   for (uint i = 0; i < lengthof(_orig_rail_vehicle_info); i++, j++) new (GetTempDataEngine(j)) Engine(VEH_TRAIN, i);
    00357   for (uint i = 0; i < lengthof(_orig_road_vehicle_info); i++, j++) new (GetTempDataEngine(j)) Engine(VEH_ROAD, i);
    00358   for (uint i = 0; i < lengthof(_orig_ship_vehicle_info); i++, j++) new (GetTempDataEngine(j)) Engine(VEH_SHIP, i);
    00359   for (uint i = 0; i < lengthof(_orig_aircraft_vehicle_info); i++, j++) new (GetTempDataEngine(j)) Engine(VEH_AIRCRAFT, i);
    00360
    00361   Date aging_date = min(_date + DAYS_TILL_ORIGINAL_BASE_YEAR, ConvertYMDToDate(2050, 0, 1));
    00362
    00363   for (EngineID i = 0; i < 256; i++) {
    00364     int oi = ttd_to_tto[i];
    00365     Engine *e = GetTempDataEngine(i);
    00366
    00367     if (oi == 255) {
    00368       /* Default engine is used */
    00369       _date += DAYS_TILL_ORIGINAL_BASE_YEAR;
    00370       StartupOneEngine(e, aging_date);
    00371       e->intro_date -= DAYS_TILL_ORIGINAL_BASE_YEAR;
    00372       _date -= DAYS_TILL_ORIGINAL_BASE_YEAR;
    00373
    00374       /* Make sure for example monorail and maglev are available when they should be */
    00375       if (_date >= e->intro_date && HasBit(e->info.climates, 0)) {
    00376         e->flags |= ENGINE_AVAILABLE;
    00377         e->company_avail = (CompanyMask)0xFF;
    00378         e->age = _date > e->intro_date ? (_date - e->intro_date) / 30 : 0;
    00379       }
    00380     } else {
    00381       /* Using data from TTO savegame */
    00382       Engine *oe = &_old_engines[oi];
    00383
    00384       e->intro_date          = oe->intro_date;
    00385       e->age                 = oe->age;
    00386       e->reliability         = oe->reliability;
    00387       e->reliability_spd_dec = oe->reliability_spd_dec;
    00388       e->reliability_start   = oe->reliability_start;
    00389       e->reliability_max     = oe->reliability_max;
    00390       e->reliability_final   = oe->reliability_final;
    00391       e->duration_phase_1    = oe->duration_phase_1;
    00392       e->duration_phase_2    = oe->duration_phase_2;
    00393       e->duration_phase_3    = oe->duration_phase_3;
    00394       e->lifelength          = oe->lifelength;
    00395       e->flags               = oe->flags;
    00396
    00397       e->company_avail = 0;
    00398
    00399       /* One or more engines were remapped to this one. Make this engine available
    00400        * if at least one of them was available. */
    00401       for (uint j = 0; j < lengthof(tto_to_ttd); j++) {
    00402         if (tto_to_ttd[j] == i && _old_engines[j].company_avail != 0) {
    00403           e->company_avail = (CompanyMask)0xFF;
    00404           e->flags |= ENGINE_AVAILABLE;
    00405           break;
    00406         }
    00407       }
    00408
    00409       e->preview_company_rank = 0;
    00410       e->preview_wait = 0;
    00411       e->name = NULL;
    00412
    00413       e->info.climates = 1;
    00414     }
    00415   }
    00416
    00417   return true;
    00418 }
    00419
    00420 static void FixTTOCompanies()
    00421 {
    00422   Company *c;
    00423   FOR_ALL_COMPANIES(c) {
    00424     c->cur_economy.company_value = CalculateCompanyValue(c); // company value history is zeroed
    00425   }
    00426 }
    00427
    00428 static inline byte RemapTTOColour(byte tto)
    00429 {
    00431   static const byte tto_colour_remap[] = {
    00432     COLOUR_DARK_BLUE,  COLOUR_GREY,       COLOUR_YELLOW,     COLOUR_RED,
    00433     COLOUR_PURPLE,     COLOUR_DARK_GREEN, COLOUR_ORANGE,     COLOUR_PALE_GREEN,
    00434     COLOUR_BLUE,       COLOUR_GREEN,      COLOUR_CREAM,      COLOUR_BROWN,
    00435     COLOUR_WHITE,      COLOUR_LIGHT_BLUE, COLOUR_MAUVE,      COLOUR_PINK
    00436   };
    00437
    00438   if ((size_t)tto >= lengthof(tto_colour_remap)) return COLOUR_GREY; // this shouldn't happen
    00439
    00440   return tto_colour_remap[tto];
    00441 }
    00442
    00443 static inline uint RemapTownIndex(uint x)
    00444 {
    00445   return _savegame_type == SGT_TTO ? (x - 0x264) / 78 : (x - 0x264) / 94;
    00446 }
    00447
    00448 static inline uint RemapOrderIndex(uint x)
    00449 {
    00450   return _savegame_type == SGT_TTO ? (x - 0x1AC4) / 2 : (x - 0x1C18) / 2;
    00451 }
    00452
    00453 extern TileIndex *_animated_tile_list;
    00454 extern uint _animated_tile_count;
    00455 extern char *_old_name_array;
    00456
    00457 static byte   _old_vehicle_multiplier;
    00458 static uint32 _old_town_index;
    00459 static uint16 _old_string_id;
    00460 static uint16 _old_string_id_2;
    00461 static uint16 _old_extra_chunk_nums;
    00462
    00463 static void ReadTTDPatchFlags()
    00464 {
    00465   if (_read_ttdpatch_flags) return;
    00466
    00467   _read_ttdpatch_flags = true;
    00468
    00469   if (_savegame_type == SGT_TTO) {
    00470     _old_vehicle_multiplier = 1;
    00471     return;
    00472   }
    00473
    00474   /* TTDPatch misuses _old_map3 for flags.. read them! */
    00475   _old_vehicle_multiplier = _old_map3[0];
    00476   /* Somehow.... there was an error in some savegames, so 0 becomes 1
    00477   and 1 becomes 2. The rest of the values are okay */
    00478   if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;
    00479
    00480   _old_vehicle_names = MallocT<StringID>(_old_vehicle_multiplier * 850);
    00481
    00482   /* TTDPatch increases the Vehicle-part in the middle of the game,
    00483   so if the multipler is anything else but 1, the assert fails..
    00484   bump the assert value so it doesn't!
    00485   (1 multipler == 850 vehicles
    00486   1 vehicle   == 128 bytes */
    00487   _bump_assert_value = (_old_vehicle_multiplier - 1) * 850 * 128;
    00488
    00489   for (uint i = 0; i < 17; i++) { // check tile 0, too
    00490     if (_old_map3[i] != 0) _savegame_type = SGT_TTDP1;
    00491   }
    00492
    00493   /* Check if we have a modern TTDPatch savegame (has extra data all around) */
    00494   if (memcmp(&_old_map3[0x1FFFA], "TTDp", 4) == 0) _savegame_type = SGT_TTDP2;
    00495
    00496   _old_extra_chunk_nums = _old_map3[_savegame_type == SGT_TTDP2 ? 0x1FFFE : 0x2];
    00497
    00498   /* Clean the misused places */
    00499   for (uint i = 0;       i < 17;      i++) _old_map3[i] = 0;
    00500   for (uint i = 0x1FE00; i < 0x20000; i++) _old_map3[i] = 0;
    00501
    00502   if (_savegame_type == SGT_TTDP2) DEBUG(oldloader, 2, "Found TTDPatch game");
    00503
    00504   DEBUG(oldloader, 3, "Vehicle-multiplier is set to %d (%d vehicles)", _old_vehicle_multiplier, _old_vehicle_multiplier * 850);
    00505 }
    00506
    00507 static const OldChunks town_chunk[] = {
    00508   OCL_SVAR(   OC_TILE, Town, xy ),
    00509   OCL_NULL( 2 ),
    00510   OCL_SVAR( OC_UINT16, Town, townnametype ),
    00511   OCL_SVAR( OC_UINT32, Town, townnameparts ),
    00512   OCL_SVAR(  OC_UINT8, Town, grow_counter ),
    00513   OCL_NULL( 1 ),
    00514   OCL_NULL( 4 ),
    00515   OCL_NULL( 2 ),
    00516   OCL_SVAR( OC_UINT16, Town, flags12 ),
    00517   OCL_NULL( 10 ),
    00518
    00519   OCL_SVAR( OC_UINT16, Town, ratings[0] ),
    00520   OCL_SVAR( OC_UINT16, Town, ratings[1] ),
    00521   OCL_SVAR( OC_UINT16, Town, ratings[2] ),
    00522   OCL_SVAR( OC_UINT16, Town, ratings[3] ),
    00523   OCL_SVAR( OC_UINT16, Town, ratings[4] ),
    00524   OCL_SVAR( OC_UINT16, Town, ratings[5] ),
    00525   OCL_SVAR( OC_UINT16, Town, ratings[6] ),
    00526   OCL_SVAR( OC_UINT16, Town, ratings[7] ),
    00527
    00528   OCL_SVAR( OC_FILE_U32 | OC_VAR_U16, Town, have_ratings ),
    00529   OCL_SVAR( OC_FILE_U32 | OC_VAR_U16, Town, statues ),
    00530   OCL_NULL( 2 ),
    00531   OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),
    00532   OCL_SVAR(  OC_UINT8, Town, growth_rate ),
    00533
    00534   OCL_SVAR( OC_UINT16, Town, new_max_pass ),
    00535   OCL_SVAR( OC_UINT16, Town, new_max_mail ),
    00536   OCL_SVAR( OC_UINT16, Town, new_act_pass ),
    00537   OCL_SVAR( OC_UINT16, Town, new_act_mail ),
    00538   OCL_SVAR( OC_UINT16, Town, max_pass ),
    00539   OCL_SVAR( OC_UINT16, Town, max_mail ),
    00540   OCL_SVAR( OC_UINT16, Town, act_pass ),
    00541   OCL_SVAR( OC_UINT16, Town, act_mail ),
    00542
    00543   OCL_SVAR(  OC_UINT8, Town, pct_pass_transported ),
    00544   OCL_SVAR(  OC_UINT8, Town, pct_mail_transported ),
    00545
    00546   OCL_SVAR( OC_TTD | OC_UINT16, Town, new_act_food ),
    00547   OCL_SVAR( OC_TTD | OC_UINT16, Town, new_act_water ),
    00548   OCL_SVAR( OC_TTD | OC_UINT16, Town, act_food ),
    00549   OCL_SVAR( OC_TTD | OC_UINT16, Town, act_water ),
    00550
    00551   OCL_SVAR(  OC_UINT8, Town, road_build_months ),
    00552   OCL_SVAR(  OC_UINT8, Town, fund_buildings_months ),
    00553
    00554   OCL_CNULL( OC_TTD, 8 ),
    00555
    00556   OCL_END()
    00557 };
    00558
    00559 static bool LoadOldTown(LoadgameState *ls, int num)
    00560 {
    00561   Town *t = new (num) Town();
    00562   if (!LoadChunk(ls, t, town_chunk)) return false;
    00563
    00564   if (t->xy != 0) {
    00565     if (_savegame_type == SGT_TTO) {
    00566       /* 0x10B6 is auto-generated name, others are custom names */
    00567       t->townnametype = t->townnametype == 0x10B6 ? 0x20C1 : t->townnametype + 0x2A00;
    00568     }
    00569   } else {
    00570     t->xy = INVALID_TILE;
    00571   }
    00572
    00573   return true;
    00574 }
    00575
    00576 static uint16 _old_order;
    00577 static const OldChunks order_chunk[] = {
    00578   OCL_VAR ( OC_UINT16,   1, &_old_order ),
    00579   OCL_END()
    00580 };
    00581
    00582 static bool LoadOldOrder(LoadgameState *ls, int num)
    00583 {
    00584   if (!LoadChunk(ls, NULL, order_chunk)) return false;
    00585
    00586   new (num) Order(UnpackOldOrder(_old_order));
    00587
    00588   /* Relink the orders to eachother (in the orders for one vehicle are behind eachother,
    00589    * with an invalid order (OT_NOTHING) as indication that it is the last order */
    00590   if (num > 0 && GetOrder(num)->IsValid()) {
    00591     GetOrder(num - 1)->next = GetOrder(num);
    00592   }
    00593
    00594   return true;
    00595 }
    00596
    00597 static bool LoadOldAnimTileList(LoadgameState *ls, int num)
    00598 {
    00599   /* This is sligthly hackish - we must load a chunk into an array whose
    00600    * address isn't static, but instead pointed to by _animated_tile_list.
    00601    * To achieve that, create an OldChunks list on the stack on the fly.
    00602    * The list cannot be static because the value of _animated_tile_list
    00603    * can change between calls. */
    00604
    00605   const OldChunks anim_chunk[] = {
    00606     OCL_VAR (   OC_TILE, 256, _animated_tile_list ),
    00607     OCL_END ()
    00608   };
    00609
    00610   if (!LoadChunk(ls, NULL, anim_chunk)) return false;
    00611
    00612   /* Update the animated tile counter by counting till the first zero in the array */
    00613   for (_animated_tile_count = 0; _animated_tile_count < 256; _animated_tile_count++) {
    00614     if (_animated_tile_list[_animated_tile_count] == 0) break;
    00615   }
    00616
    00617   return true;
    00618 }
    00619
    00620 static const OldChunks depot_chunk[] = {
    00621   OCL_SVAR(   OC_TILE, Depot, xy ),
    00622   OCL_VAR ( OC_UINT32,                1, &_old_town_index ),
    00623   OCL_END()
    00624 };
    00625
    00626 static bool LoadOldDepot(LoadgameState *ls, int num)
    00627 {
    00628   Depot *d = new (num) Depot();
    00629   if (!LoadChunk(ls, d, depot_chunk)) return false;
    00630
    00631   if (d->xy != 0) {
    00632     d->town_index = RemapTownIndex(_old_town_index);
    00633   } else {
    00634     d->xy = INVALID_TILE;
    00635   }
    00636
    00637   return true;
    00638 }
    00639
    00640 static int32 _old_price;
    00641 static uint16 _old_price_frac;
    00642 static const OldChunks price_chunk[] = {
    00643   OCL_VAR (  OC_INT32,   1, &_old_price ),
    00644   OCL_VAR ( OC_UINT16,   1, &_old_price_frac ),
    00645   OCL_END()
    00646 };
    00647
    00648 static bool LoadOldPrice(LoadgameState *ls, int num)
    00649 {
    00650   if (_savegame_type == SGT_TTO && num == 25) {
    00651     /* clear_fields == build_road_depot (TTO didn't have this price) */
    00652     ((Money*)&_price)[25] = ((Money*)&_price)[6];
    00653     _price_frac[25] = _price_frac[6];
    00654     return true;
    00655   }
    00656
    00657   if (!LoadChunk(ls, NULL, price_chunk)) return false;
    00658
    00659   if (_savegame_type == SGT_TTO) {
    00660     /* base prices are different in these two cases */
    00661     if (num == 15) _old_price = ClampToI32(((Money)_old_price) * 20 / 3); // build_railvehicle
    00662     if (num == 17) _old_price = ClampToI32(((Money)_old_price) * 10);     // aircraft_base
    00663   }
    00664
    00665
    00666   /* We use a struct to store the prices, but they are ints in a row..
    00667    * so just access the struct as an array of int32s */
    00668   ((Money*)&_price)[num] = _old_price;
    00669   _price_frac[num] = _old_price_frac;
    00670
    00671   return true;
    00672 }
    00673
    00674 static const OldChunks cargo_payment_rate_chunk[] = {
    00675   OCL_VAR (  OC_INT32,   1, &_old_price ),
    00676   OCL_VAR ( OC_UINT16,   1, &_old_price_frac ),
    00677
    00678   OCL_NULL( 2 ),
    00679   OCL_END()
    00680 };
    00681
    00682 static bool LoadOldCargoPaymentRate(LoadgameState *ls, int num)
    00683 {
    00684   if (_savegame_type == SGT_TTO && num == 11) { // TTD has 1 more cargo type
    00685     _cargo_payment_rates[num] = _cargo_payment_rates[9];
    00686     _cargo_payment_rates_frac[num] = _cargo_payment_rates_frac[9];
    00687     return true;
    00688   }
    00689
    00690   if (!LoadChunk(ls, NULL, cargo_payment_rate_chunk)) return false;
    00691
    00692   if (_savegame_type == SGT_TTO) {
    00693     /* SVXConverter about cargo payment rates correction:
    00694      * "increase them to compensate for the faster time advance in TTD compared to TTO
    00695      * which otherwise would cause much less income while the annual running costs of
    00696      * the vehicles stay the same" */
    00697
    00698     Money m = ((((Money)_old_price) << 16) + (uint)_old_price_frac) * 124 / 74;
    00699
    00700     _old_price = m >> 16;
    00701     _old_price_frac = GB((int64)m, 0, 16);
    00702   }
    00703
    00704   _cargo_payment_rates[num] = -_old_price;
    00705   _cargo_payment_rates_frac[num] = _old_price_frac;
    00706
    00707   return true;
    00708 }
    00709
    00710 static StationID _current_station_id;
    00711 static uint16 _waiting_acceptance;
    00712 static uint8  _cargo_source;
    00713 static uint8  _cargo_days;
    00714
    00715 static const OldChunks goods_chunk[] = {
    00716   OCL_VAR ( OC_UINT16, 1,          &_waiting_acceptance ),
    00717   OCL_SVAR(  OC_UINT8, GoodsEntry, days_since_pickup ),
    00718   OCL_SVAR(  OC_UINT8, GoodsEntry, rating ),
    00719   OCL_VAR (  OC_UINT8, 1,          &_cargo_source ),
    00720   OCL_VAR (  OC_UINT8, 1,          &_cargo_days ),
    00721   OCL_SVAR(  OC_UINT8, GoodsEntry, last_speed ),
    00722   OCL_SVAR(  OC_UINT8, GoodsEntry, last_age ),
    00723
    00724   OCL_END()
    00725 };
    00726
    00727 static bool LoadOldGood(LoadgameState *ls, int num)
    00728 {
    00729   /* for TTO games, 12th (num == 11) goods entry is created in the Station constructor */
    00730   if (_savegame_type == SGT_TTO && num == 11) return true;
    00731
    00732   Station *st = GetStation(_current_station_id);
    00733   GoodsEntry *ge = &st->goods[num];
    00734
    00735   if (!LoadChunk(ls, ge, goods_chunk)) return false;
    00736
    00737   SB(ge->acceptance_pickup, GoodsEntry::ACCEPTANCE, 1, HasBit(_waiting_acceptance, 15));
    00738   SB(ge->acceptance_pickup, GoodsEntry::PICKUP, 1, _cargo_source != 0xFF);
    00739   if (GB(_waiting_acceptance, 0, 12) != 0) {
    00740     CargoPacket *cp = new CargoPacket();
    00741     cp->source          = (_cargo_source == 0xFF) ? INVALID_STATION : _cargo_source;
    00742     cp->count           = GB(_waiting_acceptance, 0, 12);
    00743     cp->days_in_transit = _cargo_days;
    00744     ge->cargo.Append(cp);
    00745   }
    00746
    00747   return true;
    00748 }
    00749
    00750 static const OldChunks station_chunk[] = {
    00751   OCL_SVAR(   OC_TILE, Station, xy ),
    00752   OCL_VAR ( OC_UINT32,   1, &_old_town_index ),
    00753
    00754   OCL_NULL( 4 ),
    00755   OCL_SVAR(   OC_TILE, Station, train_tile ),
    00756   OCL_SVAR(   OC_TILE, Station, airport_tile ),
    00757   OCL_SVAR(   OC_TILE, Station, dock_tile ),
    00758   OCL_SVAR(  OC_UINT8, Station, trainst_w ),
    00759
    00760   OCL_NULL( 1 ),
    00761   OCL_NULL( 2 ),
    00762
    00763   OCL_VAR ( OC_UINT16,   1, &_old_string_id ),
    00764
    00765   OCL_NULL( 4 ),
    00766
    00767   OCL_SVAR( OC_UINT16, Station, had_vehicle_of_type ),
    00768
    00769   OCL_CHUNK( 12, LoadOldGood ),
    00770
    00771   OCL_SVAR(  OC_UINT8, Station, time_since_load ),
    00772   OCL_SVAR(  OC_UINT8, Station, time_since_unload ),
    00773   OCL_SVAR(  OC_UINT8, Station, delete_ctr ),
    00774   OCL_SVAR(  OC_UINT8, Station, owner ),
    00775   OCL_SVAR(  OC_UINT8, Station, facilities ),
    00776   OCL_SVAR( OC_TTD | OC_UINT8, Station, airport_type ),
    00777   OCL_SVAR( OC_TTO | OC_FILE_U16 | OC_VAR_U64, Station, airport_flags ),
    00778   OCL_NULL( 3 ),
    00779   OCL_CNULL( OC_TTD, 1 ),
    00780   OCL_SVAR( OC_TTD | OC_FILE_U16 | OC_VAR_U64, Station, airport_flags ),
    00781   OCL_CNULL( OC_TTD, 2 ),
    00782   OCL_CNULL( OC_TTD, 4 ),
    00783
    00784   OCL_END()
    00785 };
    00786
    00787 static bool LoadOldStation(LoadgameState *ls, int num)
    00788 {
    00789   Station *st = new (num) Station();
    00790   _current_station_id = num;
    00791
    00792   if (!LoadChunk(ls, st, station_chunk)) return false;
    00793
    00794   if (st->xy != 0) {
    00795     st->town = GetTown(RemapTownIndex(_old_town_index));
    00796
    00797     if (_savegame_type == SGT_TTO) {
    00798       if (IsInsideBS(_old_string_id, 0x180F, 32)) {
    00799         st->string_id = STR_SV_STNAME + (_old_string_id - 0x180F); // automatic name
    00800       } else {
    00801         st->string_id = _old_string_id + 0x2800; // custom name
    00802       }
    00803
    00804       if (HasBit(st->airport_flags, 8)) {
    00805         st->airport_type = 1; // large airport
    00806       } else if (HasBit(st->airport_flags, 6)) {
    00807         st->airport_type = 3; // oil rig
    00808       } else {
    00809         st->airport_type = 0; // small airport
    00810       }
    00811     } else {
    00812       st->string_id = RemapOldStringID(_old_string_id);
    00813     }
    00814   } else {
    00815     st->xy = INVALID_TILE;
    00816   }
    00817
    00818   return true;
    00819 }
    00820
    00821 static const OldChunks industry_chunk[] = {
    00822   OCL_SVAR(   OC_TILE, Industry, xy ),
    00823   OCL_VAR ( OC_UINT32,   1, &_old_town_index ),
    00824   OCL_SVAR(  OC_UINT8, Industry, width ),
    00825   OCL_SVAR(  OC_UINT8, Industry, height ),
    00826   OCL_NULL( 2 ),
    00827
    00828   OCL_SVAR( OC_TTD | OC_UINT16, Industry, produced_cargo_waiting[0] ),
    00829   OCL_SVAR( OC_TTD | OC_UINT16, Industry, produced_cargo_waiting[1] ),
    00830   OCL_SVAR( OC_TTO | OC_FILE_U8 | OC_VAR_U16, Industry, produced_cargo_waiting[0] ),
    00831   OCL_SVAR( OC_TTO | OC_FILE_U8 | OC_VAR_U16, Industry, produced_cargo_waiting[1] ),
    00832
    00833   OCL_SVAR(  OC_UINT8, Industry, production_rate[0] ),
    00834   OCL_SVAR(  OC_UINT8, Industry, production_rate[1] ),
    00835
    00836   OCL_NULL( 3 ),
    00837
    00838   OCL_SVAR(  OC_UINT8, Industry, prod_level ),
    00839
    00840   OCL_SVAR( OC_UINT16, Industry, this_month_production[0] ),
    00841   OCL_SVAR( OC_UINT16, Industry, this_month_production[1] ),
    00842   OCL_SVAR( OC_UINT16, Industry, this_month_transported[0] ),
    00843   OCL_SVAR( OC_UINT16, Industry, this_month_transported[1] ),
    00844
    00845   OCL_SVAR(  OC_UINT8, Industry, last_month_pct_transported[0] ),
    00846   OCL_SVAR(  OC_UINT8, Industry, last_month_pct_transported[1] ),
    00847
    00848   OCL_SVAR( OC_UINT16, Industry, last_month_production[0] ),
    00849   OCL_SVAR( OC_UINT16, Industry, last_month_production[1] ),
    00850   OCL_SVAR( OC_UINT16, Industry, last_month_transported[0] ),
    00851   OCL_SVAR( OC_UINT16, Industry, last_month_transported[1] ),
    00852
    00853   OCL_SVAR(  OC_UINT8, Industry, type ),
    00854   OCL_SVAR( OC_TTO | OC_FILE_U8 | OC_VAR_U16, Industry, counter ),
    00855   OCL_SVAR(  OC_UINT8, Industry, owner ),
    00856   OCL_SVAR(  OC_UINT8, Industry, random_colour ),
    00857   OCL_SVAR( OC_TTD | OC_FILE_U8 | OC_VAR_I32, Industry, last_prod_year ),
    00858   OCL_SVAR( OC_TTD | OC_UINT16, Industry, counter ),
    00859   OCL_SVAR( OC_TTD | OC_UINT8, Industry, was_cargo_delivered ),
    00860
    00861   OCL_CNULL( OC_TTD, 9 ),
    00862
    00863   OCL_END()
    00864 };
    00865
    00866 static bool LoadOldIndustry(LoadgameState *ls, int num)
    00867 {
    00868   Industry *i = new (num) Industry();
    00869   if (!LoadChunk(ls, i, industry_chunk)) return false;
    00870
    00871   if (i->xy != 0) {
    00872     i->town = GetTown(RemapTownIndex(_old_town_index));
    00873
    00874     if (_savegame_type == SGT_TTO) {
    00875       if (i->type > 0x06) i->type++; // Printing Works were added
    00876       if (i->type == 0x0A) i->type = 0x12; // Iron Ore Mine has different ID
    00877
    00878       YearMonthDay ymd;
    00879       ConvertDateToYMD(_date, &ymd);
    00880       i->last_prod_year = ymd.year;
    00881
    00882       i->random_colour = RemapTTOColour(i->random_colour);
    00883     }
    00884
    00885     IncIndustryTypeCount(i->type);
    00886   } else {
    00887     i->xy = INVALID_TILE;
    00888   }
    00889
    00890   return true;
    00891 }
    00892
    00893 static CompanyID _current_company_id;
    00894 static int32 _old_yearly;
    00895
    00896 static const OldChunks _company_yearly_chunk[] = {
    00897   OCL_VAR(  OC_INT32,   1, &_old_yearly ),
    00898   OCL_END()
    00899 };
    00900
    00901 static bool LoadOldCompanyYearly(LoadgameState *ls, int num)
    00902 {
    00903   Company *c = GetCompany(_current_company_id);
    00904
    00905   for (uint i = 0; i < 13; i++) {
    00906     if (_savegame_type == SGT_TTO && i == 6) {
    00907       _old_yearly = 0; // property maintenance
    00908     } else {
    00909       if (!LoadChunk(ls, NULL, _company_yearly_chunk)) return false;
    00910     }
    00911
    00912     c->yearly_expenses[num][i] = _old_yearly;
    00913   }
    00914
    00915   return true;
    00916 }
    00917
    00918 static const OldChunks _company_economy_chunk[] = {
    00919   OCL_SVAR( OC_FILE_I32 | OC_VAR_I64, CompanyEconomyEntry, income ),
    00920   OCL_SVAR( OC_FILE_I32 | OC_VAR_I64, CompanyEconomyEntry, expenses ),
    00921   OCL_SVAR( OC_INT32,                 CompanyEconomyEntry, delivered_cargo ),
    00922   OCL_SVAR( OC_INT32,                 CompanyEconomyEntry, performance_history ),
    00923   OCL_SVAR( OC_TTD | OC_FILE_I32 | OC_VAR_I64, CompanyEconomyEntry, company_value ),
    00924
    00925   OCL_END()
    00926 };
    00927
    00928 static bool LoadOldCompanyEconomy(LoadgameState *ls, int num)
    00929 {
    00930   Company *c = GetCompany(_current_company_id);
    00931
    00932   if (!LoadChunk(ls, &c->cur_economy, _company_economy_chunk)) return false;
    00933
    00934   /* Don't ask, but the number in TTD(Patch) are inversed to OpenTTD */
    00935   c->cur_economy.income   = -c->cur_economy.income;
    00936   c->cur_economy.expenses = -c->cur_economy.expenses;
    00937
    00938   for (uint i = 0; i < 24; i++) {
    00939     if (!LoadChunk(ls, &c->old_economy[i], _company_economy_chunk)) return false;
    00940
    00941     c->old_economy[i].income   = -c->old_economy[i].income;
    00942     c->old_economy[i].expenses = -c->old_economy[i].expenses;
    00943   }
    00944
    00945   return true;
    00946 }
    00947
    00948 static const OldChunks _company_chunk[] = {
    00949   OCL_VAR ( OC_UINT16,   1, &_old_string_id ),
    00950   OCL_SVAR( OC_UINT32, Company, name_2 ),
    00951   OCL_SVAR( OC_UINT32, Company, face ),
    00952   OCL_VAR ( OC_UINT16,   1, &_old_string_id_2 ),
    00953   OCL_SVAR( OC_UINT32, Company, president_name_2 ),
    00954
    00955   OCL_SVAR( OC_FILE_I32 | OC_VAR_I64, Company, money ),
    00956   OCL_SVAR( OC_FILE_I32 | OC_VAR_I64, Company, current_loan ),
    00957
    00958   OCL_SVAR(  OC_UINT8, Company, colour ),
    00959   OCL_SVAR(  OC_UINT8, Company, money_fraction ),
    00960   OCL_SVAR(  OC_UINT8, Company, quarters_of_bankrupcy ),
    00961   OCL_SVAR(  OC_UINT8, Company, bankrupt_asked ),
    00962   OCL_SVAR( OC_FILE_U32 | OC_VAR_I64, Company, bankrupt_value ),
    00963   OCL_SVAR( OC_UINT16, Company, bankrupt_timeout ),
    00964
    00965   OCL_SVAR( OC_TTD | OC_UINT32, Company, cargo_types ),
    00966   OCL_SVAR( OC_TTO | OC_FILE_U16 | OC_VAR_U32, Company, cargo_types ),
    00967
    00968   OCL_CHUNK( 3, LoadOldCompanyYearly ),
    00969   OCL_CHUNK( 1, LoadOldCompanyEconomy ),
    00970
    00971   OCL_SVAR( OC_FILE_U16 | OC_VAR_I32, Company, inaugurated_year),
    00972   OCL_SVAR(                  OC_TILE, Company, last_build_coordinate ),
    00973   OCL_SVAR(                 OC_UINT8, Company, num_valid_stat_ent ),
    00974
    00975   OCL_NULL( 230 ),         // Old AI
    00976
    00977   OCL_SVAR(  OC_UINT8, Company, block_preview ),
    00978   OCL_CNULL( OC_TTD, 1 ),           // Old AI
    00979   OCL_SVAR( OC_TTD | OC_UINT8, Company, avail_railtypes ),
    00980   OCL_SVAR(   OC_TILE, Company, location_of_HQ ),
    00981   OCL_SVAR( OC_TTD | OC_UINT8, Company, share_owners[0] ),
    00982   OCL_SVAR( OC_TTD | OC_UINT8, Company, share_owners[1] ),
    00983   OCL_SVAR( OC_TTD | OC_UINT8, Company, share_owners[2] ),
    00984   OCL_SVAR( OC_TTD | OC_UINT8, Company, share_owners[3] ),
    00985
    00986   OCL_CNULL( OC_TTD, 8 ),
    00987
    00988   OCL_END()
    00989 };
    00990
    00991 static bool LoadOldCompany(LoadgameState *ls, int num)
    00992 {
    00993   Company *c = new (num) Company();
    00994
    00995   _current_company_id = (CompanyID)num;
    00996
    00997   if (!LoadChunk(ls, c, _company_chunk)) return false;
    00998
    00999   if (_old_string_id == 0) {
    01000     delete c;
    01001     return true;
    01002   }
    01003
    01004   if (_savegame_type == SGT_TTO) {
    01005     /* adjust manager's face */
    01006     if (HasBit(c->face, 27) && GB(c->face, 26, 1) == GB(c->face, 19, 1)) {
    01007       /* if face would be black in TTD, adjust tie colour and thereby face colour */
    01008       ClrBit(c->face, 27);
    01009     }
    01010
    01011     /* Company name */
    01012     if (_old_string_id == 0 || _old_string_id == 0x4C00) {
    01013       _old_string_id = STR_SV_UNNAMED; // "Unnamed"
    01014     } else if (GB(_old_string_id, 8, 8) == 0x52) {
    01015       _old_string_id += 0x2A00; // Custom name
    01016     } else {
    01017       _old_string_id = RemapOldStringID(_old_string_id += 0x240D); // Automatic name
    01018     }
    01019     c->name_1 = _old_string_id;
    01020
    01021     /* Manager name */
    01022     switch (_old_string_id_2) {
    01023       case 0x4CDA: _old_string_id_2 = SPECSTR_PRESIDENT_NAME;    break; // automatic name
    01024       case 0x0006: _old_string_id_2 = STR_SV_EMPTY;              break; // empty name
    01025       default:     _old_string_id_2 = _old_string_id_2 + 0x2A00; break; // custom name
    01026     }
    01027     c->president_name_1 = _old_string_id_2;
    01028
    01029     c->colour = RemapTTOColour(c->colour);
    01030
    01031     if (num != 0) c->is_ai = true;
    01032   } else {
    01033     c->name_1 = RemapOldStringID(_old_string_id);
    01034     c->president_name_1 = RemapOldStringID(_old_string_id_2);
    01035
    01036     if (num == 0) {
    01037       /* If the first company has no name, make sure we call it UNNAMED */
    01038       if (c->name_1 == 0)
    01039         c->name_1 = STR_SV_UNNAMED;
    01040     } else {
    01041       /* Beside some multiplayer maps (1 on 1), which we don't official support,
    01042        * all other companys are an AI.. mark them as such */
    01043       c->is_ai = true;
    01044     }
    01045
    01046     /* Sometimes it is better to not ask.. in old scenarios, the money
    01047      * was always 893288 pounds. In the newer versions this is correct,
    01048      * but correct for those oldies
    01049      * Ps: this also means that if you had exact 893288 pounds, you will go back
    01050      * to 100000.. this is a very VERY small chance ;) */
    01051     if (c->money == 893288) c->money = c->current_loan = 100000;
    01052   }
    01053
    01054   _company_colours[num] = (Colours)c->colour;
    01055   c->inaugurated_year -= ORIGINAL_BASE_YEAR;
    01056
    01057   return true;
    01058 }
    01059
    01060 static uint32 _old_order_ptr;
    01061 static uint16 _old_next_ptr;
    01062 static VehicleID _current_vehicle_id;
    01063
    01064 static const OldChunks vehicle_train_chunk[] = {
    01065   OCL_SVAR(  OC_UINT8, VehicleRail, track ),
    01066   OCL_SVAR(  OC_UINT8, VehicleRail, force_proceed ),
    01067   OCL_SVAR( OC_UINT16, VehicleRail, crash_anim_pos ),
    01068   OCL_SVAR(  OC_UINT8, VehicleRail, railtype ),
    01069
    01070   OCL_NULL( 5 ),
    01071
    01072   OCL_END()
    01073 };
    01074
    01075 static const OldChunks vehicle_road_chunk[] = {
    01076   OCL_SVAR(  OC_UINT8, VehicleRoad, state ),
    01077   OCL_SVAR(  OC_UINT8, VehicleRoad, frame ),
    01078   OCL_SVAR( OC_UINT16, VehicleRoad, blocked_ctr ),
    01079   OCL_SVAR(  OC_UINT8, VehicleRoad, overtaking ),
    01080   OCL_SVAR(  OC_UINT8, VehicleRoad, overtaking_ctr ),
    01081   OCL_SVAR( OC_UINT16, VehicleRoad, crashed_ctr ),
    01082   OCL_SVAR(  OC_UINT8, VehicleRoad, reverse_ctr ),
    01083
    01084   OCL_NULL( 1 ),
    01085
    01086   OCL_END()
    01087 };
    01088
    01089 static const OldChunks vehicle_ship_chunk[] = {
    01090   OCL_SVAR(  OC_UINT8, VehicleShip, state ),
    01091
    01092   OCL_NULL( 9 ),
    01093
    01094   OCL_END()
    01095 };
    01096
    01097 static const OldChunks vehicle_air_chunk[] = {
    01098   OCL_SVAR(  OC_UINT8, VehicleAir, pos ),
    01099   OCL_SVAR(  OC_FILE_U8 | OC_VAR_U16, VehicleAir, targetairport ),
    01100   OCL_SVAR( OC_UINT16, VehicleAir, crashed_counter ),
    01101   OCL_SVAR(  OC_UINT8, VehicleAir, state ),
    01102
    01103   OCL_NULL( 5 ),
    01104
    01105   OCL_END()
    01106 };
    01107
    01108 static const OldChunks vehicle_effect_chunk[] = {
    01109   OCL_SVAR( OC_UINT16, VehicleEffect, animation_state ),
    01110   OCL_SVAR(  OC_UINT8, VehicleEffect, animation_substate ),
    01111
    01112   OCL_NULL( 7 ), // Junk
    01113
    01114   OCL_END()
    01115 };
    01116
    01117 static const OldChunks vehicle_disaster_chunk[] = {
    01118   OCL_SVAR( OC_UINT16, VehicleDisaster, image_override ),
    01119   OCL_SVAR( OC_UINT16, VehicleDisaster, big_ufo_destroyer_target ),
    01120
    01121   OCL_NULL( 6 ),
    01122
    01123   OCL_END()
    01124 };
    01125
    01126 static const OldChunks vehicle_empty_chunk[] = {
    01127   OCL_NULL( 10 ),
    01128
    01129   OCL_END()
    01130 };
    01131
    01132 static bool LoadOldVehicleUnion(LoadgameState *ls, int num)
    01133 {
    01134   Vehicle *v = GetVehicle(_current_vehicle_id);
    01135   uint temp = ls->total_read;
    01136   bool res;
    01137
    01138   switch (v->type) {
    01139     default: NOT_REACHED();
    01140     case VEH_INVALID : res = LoadChunk(ls, NULL,           vehicle_empty_chunk);    break;
    01141     case VEH_TRAIN   : res = LoadChunk(ls, &v->u.rail,     vehicle_train_chunk);    break;
    01142     case VEH_ROAD    : res = LoadChunk(ls, &v->u.road,     vehicle_road_chunk);     break;
    01143     case VEH_SHIP    : res = LoadChunk(ls, &v->u.ship,     vehicle_ship_chunk);     break;
    01144     case VEH_AIRCRAFT: res = LoadChunk(ls, &v->u.air,      vehicle_air_chunk);      break;
    01145     case VEH_EFFECT  : res = LoadChunk(ls, &v->u.effect,   vehicle_effect_chunk);   break;
    01146     case VEH_DISASTER: res = LoadChunk(ls, &v->u.disaster, vehicle_disaster_chunk); break;
    01147   }
    01148
    01149   /* This chunk size should always be 10 bytes */
    01150   if (ls->total_read - temp != 10) {
    01151     DEBUG(oldloader, 0, "Assert failed in VehicleUnion: invalid chunk size");
    01152     return false;
    01153   }
    01154
    01155   return res;
    01156 }
    01157
    01158 static uint16 _cargo_count;
    01159
    01160 static const OldChunks vehicle_chunk[] = {
    01161   OCL_SVAR(  OC_UINT8, Vehicle, subtype ),
    01162
    01163   OCL_NULL( 2 ),
    01164   OCL_NULL( 2 ),
    01165
    01166   OCL_VAR ( OC_UINT32,   1, &_old_order_ptr ),
    01167   OCL_VAR ( OC_UINT16,   1, &_old_order ),
    01168
    01169   OCL_NULL ( 1 ),
    01170   OCL_SVAR(  OC_UINT8, Vehicle, cur_order_index ),
    01171   OCL_SVAR(   OC_TILE, Vehicle, dest_tile ),
    01172   OCL_SVAR( OC_UINT16, Vehicle, load_unload_time_rem ),
    01173   OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Vehicle, date_of_last_service ),
    01174   OCL_SVAR( OC_UINT16, Vehicle, service_interval ),
    01175   OCL_SVAR( OC_FILE_U8 | OC_VAR_U16, Vehicle, last_station_visited ),
    01176   OCL_SVAR( OC_TTD | OC_UINT8, Vehicle, tick_counter ),
    01177   OCL_SVAR( OC_TTD | OC_UINT16, Vehicle, max_speed ),
    01178   OCL_SVAR( OC_TTO | OC_FILE_U8 | OC_VAR_U16, Vehicle, max_speed ),
    01179
    01180   OCL_SVAR( OC_FILE_U16 | OC_VAR_I32, Vehicle, x_pos ),
    01181   OCL_SVAR( OC_FILE_U16 | OC_VAR_I32, Vehicle, y_pos ),
    01182   OCL_SVAR(  OC_UINT8, Vehicle, z_pos ),
    01183   OCL_SVAR(  OC_UINT8, Vehicle, direction ),
    01184   OCL_NULL( 2 ),
    01185   OCL_NULL( 2 ),
    01186   OCL_NULL( 1 ),
    01187
    01188   OCL_SVAR(  OC_UINT8, Vehicle, owner ),
    01189   OCL_SVAR(   OC_TILE, Vehicle, tile ),
    01190   OCL_SVAR( OC_UINT16, Vehicle, cur_image ),
    01191
    01192   OCL_NULL( 8 ),
    01193
    01194   OCL_SVAR( OC_FILE_U16 | OC_VAR_U8, Vehicle, vehstatus ),
    01195   OCL_SVAR( OC_TTD | OC_UINT16, Vehicle, cur_speed ),
    01196   OCL_SVAR( OC_TTO | OC_FILE_U8 | OC_VAR_U16, Vehicle, cur_speed ),
    01197   OCL_SVAR(  OC_UINT8, Vehicle, subspeed ),
    01198   OCL_SVAR(  OC_UINT8, Vehicle, acceleration ),
    01199   OCL_SVAR(  OC_UINT8, Vehicle, progress ),
    01200
    01201   OCL_SVAR(  OC_UINT8, Vehicle, cargo_type ),
    01202   OCL_SVAR( OC_TTD | OC_UINT16, Vehicle, cargo_cap ),
    01203   OCL_SVAR( OC_TTO | OC_FILE_U8 | OC_VAR_U16, Vehicle, cargo_cap ),
    01204   OCL_VAR ( OC_TTD | OC_UINT16, 1, &_cargo_count ),
    01205   OCL_VAR ( OC_TTO | OC_FILE_U8 | OC_VAR_U16, 1, &_cargo_count ),
    01206   OCL_VAR (  OC_UINT8, 1,       &_cargo_source ),
    01207   OCL_VAR (  OC_UINT8, 1,       &_cargo_days ),
    01208
    01209   OCL_SVAR( OC_TTO | OC_UINT8, Vehicle, tick_counter ),
    01210
    01211   OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Vehicle, age ),
    01212   OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Vehicle, max_age ),
    01213   OCL_SVAR( OC_FILE_U8 | OC_VAR_I32, Vehicle, build_year ),
    01214   OCL_SVAR( OC_FILE_U8 | OC_VAR_U16, Vehicle, unitnumber ),
    01215
    01216   OCL_SVAR( OC_TTD | OC_UINT16, Vehicle, engine_type ),
    01217   OCL_SVAR( OC_TTO | OC_FILE_U8 | OC_VAR_U16, Vehicle, engine_type ),
    01218
    01219   OCL_SVAR(  OC_UINT8, Vehicle, spritenum ),
    01220   OCL_SVAR(  OC_UINT8, Vehicle, day_counter ),
    01221
    01222   OCL_SVAR(  OC_UINT8, Vehicle, breakdowns_since_last_service ),
    01223   OCL_SVAR(  OC_UINT8, Vehicle, breakdown_ctr ),
    01224   OCL_SVAR(  OC_UINT8, Vehicle, breakdown_delay ),
    01225   OCL_SVAR(  OC_UINT8, Vehicle, breakdown_chance ),
    01226
    01227   OCL_CNULL( OC_TTO, 1 ),
    01228
    01229   OCL_SVAR( OC_UINT16, Vehicle, reliability ),
    01230   OCL_SVAR( OC_UINT16, Vehicle, reliability_spd_dec ),
    01231
    01232   OCL_SVAR( OC_FILE_I32 | OC_VAR_I64, Vehicle, profit_this_year ),
    01233   OCL_SVAR( OC_FILE_I32 | OC_VAR_I64, Vehicle, profit_last_year ),
    01234
    01235   OCL_VAR ( OC_UINT16,   1, &_old_next_ptr ),
    01236
    01237   OCL_SVAR( OC_FILE_U32 | OC_VAR_I64, Vehicle, value ),
    01238
    01239   OCL_VAR ( OC_UINT16,   1, &_old_string_id ),
    01240
    01241   OCL_CHUNK( 1, LoadOldVehicleUnion ),
    01242
    01243   OCL_CNULL( OC_TTO, 24 ),
    01244   OCL_CNULL( OC_TTD, 20 ),
    01245
    01246   OCL_END()
    01247 };
    01248
    01249 bool LoadOldVehicle(LoadgameState *ls, int num)
    01250 {
    01251   /* Read the TTDPatch flags, because we need some info from it */
    01252   ReadTTDPatchFlags();
    01253
    01254   for (uint i = 0; i < _old_vehicle_multiplier; i++) {
    01255     _current_vehicle_id = num * _old_vehicle_multiplier + i;
    01256
    01257     Vehicle *v;
    01258
    01259     if (_savegame_type == SGT_TTO) {
    01260       uint type = ReadByte(ls);
    01261       switch (type) {
    01262         default: return false;
    01263         case 0x00 /* VEH_INVALID */: v = new (_current_vehicle_id) InvalidVehicle();  break;
    01264         case 0x25 /* MONORAIL     */:
    01265         case 0x20 /* VEH_TRAIN    */: v = new (_current_vehicle_id) Train();           break;
    01266         case 0x21 /* VEH_ROAD     */: v = new (_current_vehicle_id) RoadVehicle();     break;
    01267         case 0x22 /* VEH_SHIP     */: v = new (_current_vehicle_id) Ship();            break;
    01268         case 0x23 /* VEH_AIRCRAFT */: v = new (_current_vehicle_id) Aircraft();        break;
    01269         case 0x24 /* VEH_EFFECT   */: v = new (_current_vehicle_id) EffectVehicle();   break;
    01270         case 0x26 /* VEH_DISASTER */: v = new (_current_vehicle_id) DisasterVehicle(); break;
    01271       }
    01272
    01273       if (!LoadChunk(ls, v, vehicle_chunk)) return false;
    01274
    01275       SpriteID sprite = v->cur_image;
    01276       /* no need to override other sprites */
    01277       if (IsInsideMM(sprite, 1460, 1465)) {
    01278         sprite += 580; // aircraft smoke puff
    01279       } else if (IsInsideMM(sprite, 2096, 2115)) {
    01280         sprite += 977; // special effects part 1
    01281       } else if (IsInsideMM(sprite, 2396, 2436)) {
    01282         sprite += 1305; // special effects part 2
    01283       } else if (IsInsideMM(sprite, 2516, 2539)) {
    01284         sprite += 1385; // rotor or disaster-related vehicles
    01285       }
    01286       v->cur_image = sprite;
    01287
    01288       switch (v->type) {
    01289         case VEH_TRAIN: {
    01290           static const byte spriteset_rail[] = {
    01291               0,   2,   4,   4,   8,  10,  12,  14,  16,  18,  20,  22,  40,  42,  44,  46,
    01292              48,  52,  54,  66,  68,  70,  72,  74,  76,  78,  80,  82,  84,  86, 120, 122,
    01293             124, 126, 128, 130, 132, 134, 136, 138, 140
    01294           };
    01295           if (v->spritenum / 2 >= lengthof(spriteset_rail)) return false;
    01296           v->spritenum = spriteset_rail[v->spritenum / 2]; // adjust railway sprite set offset
    01297           v->u.rail.railtype = type == 0x25 ? 1 : 0; // monorail / rail
    01298           break;
    01299         }
    01300
    01301         case VEH_ROAD:
    01302           if (v->spritenum >= 22) v->spritenum += 12;
    01303           break;
    01304
    01305         case VEH_SHIP:
    01306           v->spritenum += 2;
    01307
    01308           switch (v->spritenum) {
    01309             case 2: // oil tanker && cargo type != oil
    01310               if (v->cargo_type != CT_OIL) v->spritenum = 0; // make it a coal/goods ship
    01311               break;
    01312             case 4: // passenger ship && cargo type == mail
    01313               if (v->cargo_type == CT_MAIL) v->spritenum = 0; // make it a mail ship
    01314               break;
    01315             default:
    01316               break;
    01317           }
    01318           break;
    01319
    01320         default:
    01321           break;
    01322       }
    01323
    01324       switch (_old_string_id) {
    01325         case 0x0000: break; // empty (invalid vehicles)
    01326         case 0x0006: _old_string_id  = STR_SV_EMPTY;         break; // empty (special vehicles)
    01327         case 0x8495: _old_string_id  = STR_SV_TRAIN_NAME;    break; // "Train X"
    01328         case 0x8842: _old_string_id  = STR_SV_ROADVEH_NAME;  break; // "Road Vehicle X"
    01329         case 0x8C3B: _old_string_id  = STR_SV_SHIP_NAME;     break; // "Ship X"
    01330         case 0x9047: _old_string_id  = STR_SV_AIRCRAFT_NAME; break; // "Aircraft X"
    01331         default:     _old_string_id += 0x2A00;               break; // custom name
    01332       }
    01333
    01334       _old_vehicle_names[_current_vehicle_id] = _old_string_id;
    01335     } else {
    01336       /* Read the vehicle type and allocate the right vehicle */
    01337       switch (ReadByte(ls)) {
    01338         default: NOT_REACHED();
    01339         case 0x00 /* VEH_INVALID */: v = new (_current_vehicle_id) InvalidVehicle();  break;
    01340         case 0x10 /* VEH_TRAIN   */: v = new (_current_vehicle_id) Train();           break;
    01341         case 0x11 /* VEH_ROAD    */: v = new (_current_vehicle_id) RoadVehicle();     break;
    01342         case 0x12 /* VEH_SHIP    */: v = new (_current_vehicle_id) Ship();            break;
    01343         case 0x13 /* VEH_AIRCRAFT*/: v = new (_current_vehicle_id) Aircraft();        break;
    01344         case 0x14 /* VEH_EFFECT  */: v = new (_current_vehicle_id) EffectVehicle();   break;
    01345         case 0x15 /* VEH_DISASTER*/: v = new (_current_vehicle_id) DisasterVehicle(); break;
    01346       }
    01347       if (!LoadChunk(ls, v, vehicle_chunk)) return false;
    01348
    01349       _old_vehicle_names[_current_vehicle_id] = RemapOldStringID(_old_string_id);
    01350
    01351       /* This should be consistent, else we have a big problem... */
    01352       if (v->index != _current_vehicle_id) {
    01353         DEBUG(oldloader, 0, "Loading failed - vehicle-array is invalid");
    01354         return false;
    01355       }
    01356     }
    01357
    01358     if (_old_order_ptr != 0 && _old_order_ptr != 0xFFFFFFFF) {
    01359       uint max = _savegame_type == SGT_TTO ? 3000 : 5000;
    01360       uint old_id = RemapOrderIndex(_old_order_ptr);
    01361       if (old_id < max) v->orders.old = GetOrder(old_id); // don't accept orders > max number of orders
    01362     }
    01363     v->current_order.AssignOrder(UnpackOldOrder(_old_order));
    01364
    01365     if (_old_next_ptr != 0xFFFF) v->next = GetVehiclePoolSize() <= _old_next_ptr ? new (_old_next_ptr) InvalidVehicle() : GetVehicle(_old_next_ptr);
    01366
    01367     if (_cargo_count != 0) {
    01368       CargoPacket *cp = new CargoPacket((_cargo_source == 0xFF) ? INVALID_STATION : _cargo_source, _cargo_count);
    01369       cp->days_in_transit = _cargo_days;
    01370       v->cargo.Append(cp);
    01371     }
    01372   }
    01373
    01374   return true;
    01375 }
    01376
    01377 static const OldChunks sign_chunk[] = {
    01378   OCL_VAR ( OC_UINT16, 1, &_old_string_id ),
    01379   OCL_SVAR( OC_FILE_U16 | OC_VAR_I32, Sign, x ),
    01380   OCL_SVAR( OC_FILE_U16 | OC_VAR_I32, Sign, y ),
    01381   OCL_SVAR( OC_FILE_U16 | OC_VAR_I8, Sign, z ),
    01382
    01383   OCL_NULL( 6 ),
    01384
    01385   OCL_END()
    01386 };
    01387
    01388 static bool LoadOldSign(LoadgameState *ls, int num)
    01389 {
    01390   Sign *si = new (num) Sign();
    01391   if (!LoadChunk(ls, si, sign_chunk)) return false;
    01392
    01393   if (_old_string_id != 0) {
    01394     if (_savegame_type == SGT_TTO) {
    01395       if (_old_string_id != 0x140A) si->name = CopyFromOldName(_old_string_id + 0x2A00);
    01396     } else {
    01397       si->name = CopyFromOldName(RemapOldStringID(_old_string_id));
    01398     }
    01399     si->owner = OWNER_NONE;
    01400   }
    01401
    01402   return true;
    01403 }
    01404
    01405 static const OldChunks engine_chunk[] = {
    01406   OCL_SVAR( OC_UINT16, Engine, company_avail ),
    01407   OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Engine, intro_date ),
    01408   OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Engine, age ),
    01409   OCL_SVAR( OC_UINT16, Engine, reliability ),
    01410   OCL_SVAR( OC_UINT16, Engine, reliability_spd_dec ),
    01411   OCL_SVAR( OC_UINT16, Engine, reliability_start ),
    01412   OCL_SVAR( OC_UINT16, Engine, reliability_max ),
    01413   OCL_SVAR( OC_UINT16, Engine, reliability_final ),
    01414   OCL_SVAR( OC_UINT16, Engine, duration_phase_1 ),
    01415   OCL_SVAR( OC_UINT16, Engine, duration_phase_2 ),
    01416   OCL_SVAR( OC_UINT16, Engine, duration_phase_3 ),
    01417
    01418   OCL_SVAR(  OC_UINT8, Engine, lifelength ),
    01419   OCL_SVAR(  OC_UINT8, Engine, flags ),
    01420   OCL_SVAR(  OC_UINT8, Engine, preview_company_rank ),
    01421   OCL_SVAR(  OC_UINT8, Engine, preview_wait ),
    01422
    01423   OCL_CNULL( OC_TTD, 2 ),
    01424
    01425   OCL_END()
    01426 };
    01427
    01428 static bool LoadOldEngine(LoadgameState *ls, int num)
    01429 {
    01430   Engine *e = _savegame_type == SGT_TTO ? &_old_engines[num] : GetTempDataEngine(num);
    01431   return LoadChunk(ls, e, engine_chunk);
    01432 }
    01433
    01434 static bool LoadOldEngineName(LoadgameState *ls, int num)
    01435 {
    01436   Engine *e = GetTempDataEngine(num);
    01437   e->name = CopyFromOldName(RemapOldStringID(ReadUint16(ls)));
    01438   return true;
    01439 }
    01440
    01441 static const OldChunks subsidy_chunk[] = {
    01442   OCL_SVAR(  OC_UINT8, Subsidy, cargo_type ),
    01443   OCL_SVAR(  OC_UINT8, Subsidy, age ),
    01444   OCL_SVAR(  OC_FILE_U8 | OC_VAR_U16, Subsidy, from ),
    01445   OCL_SVAR(  OC_FILE_U8 | OC_VAR_U16, Subsidy, to ),
    01446
    01447   OCL_END()
    01448 };
    01449
    01450 static bool LoadOldSubsidy(LoadgameState *ls, int num)
    01451 {
    01452   return LoadChunk(ls, &_subsidies[num], subsidy_chunk);
    01453 }
    01454
    01455 static const OldChunks game_difficulty_chunk[] = {
    01456   OCL_SVAR( OC_FILE_U16 |  OC_VAR_U8, DifficultySettings, max_no_competitors ),
    01457   OCL_NULL( 2), // competitor_start_time
    01458   OCL_SVAR( OC_FILE_U16 |  OC_VAR_U8, DifficultySettings, number_towns ),
    01459   OCL_SVAR( OC_FILE_U16 |  OC_VAR_U8, DifficultySettings, number_industries ),
    01460   OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, DifficultySettings, max_loan ),
    01461   OCL_SVAR( OC_FILE_U16 |  OC_VAR_U8, DifficultySettings, initial_interest ),
    01462   OCL_SVAR( OC_FILE_U16 |  OC_VAR_U8, DifficultySettings, vehicle_costs ),
    01463   OCL_SVAR( OC_FILE_U16 |  OC_VAR_U8, DifficultySettings, competitor_speed ),
    01464   OCL_NULL( 2), // competitor_intelligence
    01465   OCL_SVAR( OC_FILE_U16 |  OC_VAR_U8, DifficultySettings, vehicle_breakdowns ),
    01466   OCL_SVAR( OC_FILE_U16 |  OC_VAR_U8, DifficultySettings, subsidy_multiplier ),
    01467   OCL_SVAR( OC_FILE_U16 |  OC_VAR_U8, DifficultySettings, construction_cost ),
    01468   OCL_SVAR( OC_FILE_U16 |  OC_VAR_U8, DifficultySettings, terrain_type ),
    01469   OCL_SVAR( OC_FILE_U16 |  OC_VAR_U8, DifficultySettings, quantity_sea_lakes ),
    01470   OCL_SVAR( OC_FILE_U16 |  OC_VAR_U8, DifficultySettings, economy ),
    01471   OCL_SVAR( OC_FILE_U16 |  OC_VAR_U8, DifficultySettings, line_reverse_mode ),
    01472   OCL_SVAR( OC_FILE_U16 |  OC_VAR_U8, DifficultySettings, disasters ),
    01473   OCL_END()
    01474 };
    01475
    01476 static bool LoadOldGameDifficulty(LoadgameState *ls, int num)
    01477 {
    01478   bool ret = LoadChunk(ls, &_settings_game.difficulty, game_difficulty_chunk);
    01479   _settings_game.difficulty.max_loan *= 1000;
    01480   return ret;
    01481 }
    01482
    01483
    01484 static bool LoadOldMapPart1(LoadgameState *ls, int num)
    01485 {
    01486   if (_savegame_type == SGT_TTO) {
    01487     MemSetT(_m, 0, OLD_MAP_SIZE);
    01488     MemSetT(_me, 0, OLD_MAP_SIZE);
    01489   }
    01490
    01491   for (uint i = 0; i < OLD_MAP_SIZE; i++) {
    01492     _m[i].m1 = ReadByte(ls);
    01493   }
    01494   for (uint i = 0; i < OLD_MAP_SIZE; i++) {
    01495     _m[i].m2 = ReadByte(ls);
    01496   }
    01497
    01498   if (_savegame_type != SGT_TTO) {
    01499     for (uint i = 0; i < OLD_MAP_SIZE; i++) {
    01500       _old_map3[i * 2] = ReadByte(ls);
    01501       _old_map3[i * 2 + 1] = ReadByte(ls);
    01502     }
    01503     for (uint i = 0; i < OLD_MAP_SIZE / 4; i++) {
    01504       byte b = ReadByte(ls);
    01505       _m[i * 4 + 0].m6 = GB(b, 0, 2);
    01506       _m[i * 4 + 1].m6 = GB(b, 2, 2);
    01507       _m[i * 4 + 2].m6 = GB(b, 4, 2);
    01508       _m[i * 4 + 3].m6 = GB(b, 6, 2);
    01509     }
    01510   }
    01511
    01512   return !ls->failed;
    01513 }
    01514
    01515 static bool LoadOldMapPart2(LoadgameState *ls, int num)
    01516 {
    01517   uint i;
    01518
    01519   for (i = 0; i < OLD_MAP_SIZE; i++) {
    01520     _m[i].type_height = ReadByte(ls);
    01521   }
    01522   for (i = 0; i < OLD_MAP_SIZE; i++) {
    01523     _m[i].m5 = ReadByte(ls);
    01524   }
    01525
    01526   return !ls->failed;
    01527 }
    01528
    01529 static bool LoadTTDPatchExtraChunks(LoadgameState *ls, int num)
    01530 {
    01531   ReadTTDPatchFlags();
    01532
    01533   DEBUG(oldloader, 2, "Found %d extra chunk(s)", _old_extra_chunk_nums);
    01534
    01535   for (int i = 0; i != _old_extra_chunk_nums; i++) {
    01536     uint16 id = ReadUint16(ls);
    01537     uint32 len = ReadUint32(ls);
    01538
    01539     switch (id) {
    01540       /* List of GRFIDs, used in the savegame. 0x8004 is the new ID
    01541        * They are saved in a 'GRFID:4 active:1' format, 5 bytes for each entry */
    01542       case 0x2:
    01543       case 0x8004: {
    01544         /* Skip the first element: TTDP hack for the Action D special variables (FFFF0000 01) */
    01545         ReadUint32(ls); ReadByte(ls); len -= 5;
    01546
    01547         ClearGRFConfigList(&_grfconfig);
    01548         while (len != 0) {
    01549           uint32 grfid = ReadUint32(ls);
    01550
    01551           if (ReadByte(ls) == 1) {
    01552             GRFConfig *c = CallocT<GRFConfig>(1);
    01553             c->grfid = grfid;
    01554             c->filename = strdup("TTDP game, no information");
    01555
    01556             AppendToGRFConfigList(&_grfconfig, c);
    01557             DEBUG(oldloader, 3, "TTDPatch game using GRF file with GRFID %0X", BSWAP32(c->grfid));
    01558           }
    01559           len -= 5;
    01560         };
    01561
    01562         /* Append static NewGRF configuration */
    01563         AppendStaticGRFConfigs(&_grfconfig);
    01564       } break;
    01565
    01566       /* TTDPatch version and configuration */
    01567       case 0x3:
    01568         _ttdp_version = ReadUint32(ls);
    01569         DEBUG(oldloader, 3, "Game saved with TTDPatch version %d.%d.%d r%d",
    01570           GB(_ttdp_version, 24, 8), GB(_ttdp_version, 20, 4), GB(_ttdp_version, 16, 4), GB(_ttdp_version, 0, 16));
    01571         len -= 4;
    01572         while (len-- != 0) ReadByte(ls); // skip the configuration
    01573         break;
    01574
    01575       default:
    01576         DEBUG(oldloader, 4, "Skipping unknown extra chunk %X", id);
    01577         while (len-- != 0) ReadByte(ls);
    01578         break;
    01579     }
    01580   }
    01581
    01582   return !ls->failed;
    01583 }
    01584
    01585 extern TileIndex _cur_tileloop_tile;
    01586 static uint32 _old_cur_town_ctr;
    01587 static const OldChunks main_chunk[] = {
    01588   OCL_ASSERT( OC_TTD, 0 ),
    01589   OCL_ASSERT( OC_TTO, 0 ),
    01590   OCL_VAR ( OC_FILE_U16 | OC_VAR_U32, 1, &_date ),
    01591   OCL_VAR ( OC_UINT16,   1, &_date_fract ),
    01592   OCL_NULL( 600 ),
    01593   OCL_VAR ( OC_UINT32,   2, &_random.state ),
    01594
    01595   OCL_ASSERT( OC_TTD, 0x264 ),
    01596   OCL_ASSERT( OC_TTO, 0x264 ),
    01597
    01598   OCL_CCHUNK( OC_TTD, 70, LoadOldTown ),
    01599   OCL_CCHUNK( OC_TTO, 80, LoadOldTown ),
    01600
    01601   OCL_ASSERT( OC_TTD, 0x1C18 ),
    01602   OCL_ASSERT( OC_TTO, 0x1AC4 ),
    01603
    01604   OCL_CCHUNK( OC_TTD, 5000, LoadOldOrder ),
    01605   OCL_CCHUNK( OC_TTO, 3000, LoadOldOrder ),
    01606
    01607   OCL_ASSERT( OC_TTD, 0x4328 ),
    01608   OCL_ASSERT( OC_TTO, 0x3234 ),
    01609
    01610   OCL_CHUNK( 1, LoadOldAnimTileList ),
    01611   OCL_NULL( 4 ),
    01612
    01613   OCL_ASSERT( OC_TTO, 0x3438 ),
    01614
    01615   OCL_CCHUNK( OC_TTD, 255, LoadOldDepot ),
    01616   OCL_CCHUNK( OC_TTO, 252, LoadOldDepot ),
    01617
    01618   OCL_ASSERT( OC_TTD, 0x4B26 ),
    01619   OCL_ASSERT( OC_TTO, 0x3A20 ),
    01620
    01621   OCL_VAR ( OC_UINT32,   1, &_old_cur_town_ctr ),
    01622   OCL_NULL( 2 ),
    01623   OCL_NULL( 2 ),
    01624
    01625   OCL_VAR ( OC_FILE_U16 | OC_VAR_U8, 1, &_age_cargo_skip_counter ),
    01626   OCL_VAR ( OC_UINT16,   1, &_tick_counter ),
    01627   OCL_VAR (   OC_TILE,   1, &_cur_tileloop_tile ),
    01628
    01629   OCL_ASSERT( OC_TTO, 0x3A2E ),
    01630
    01631   OCL_CHUNK( 49, LoadOldPrice ),
    01632
    01633   OCL_ASSERT( OC_TTO, 0x3B4E ),
    01634
    01635   OCL_CHUNK( 12, LoadOldCargoPaymentRate ),
    01636
    01637   OCL_ASSERT( OC_TTD, 0x4CBA ),
    01638   OCL_ASSERT( OC_TTO, 0x3BA6 ),
    01639
    01640   OCL_CHUNK( 1, LoadOldMapPart1 ),
    01641
    01642   OCL_ASSERT( OC_TTD, 0x48CBA ),
    01643   OCL_ASSERT( OC_TTO, 0x23BA6 ),
    01644
    01645   OCL_CCHUNK( OC_TTD, 250, LoadOldStation ),
    01646   OCL_CCHUNK( OC_TTO, 200, LoadOldStation ),
    01647
    01648   OCL_ASSERT( OC_TTO, 0x29E16 ),
    01649
    01650   OCL_CCHUNK( OC_TTD, 90, LoadOldIndustry ),
    01651   OCL_CCHUNK( OC_TTO, 100, LoadOldIndustry ),
    01652
    01653   OCL_ASSERT( OC_TTO, 0x2ADB6 ),
    01654
    01655   OCL_CHUNK(  8, LoadOldCompany ),
    01656
    01657   OCL_ASSERT( OC_TTD, 0x547F2 ),
    01658   OCL_ASSERT( OC_TTO, 0x2C746 ),
    01659
    01660   OCL_CCHUNK( OC_TTD, 850, LoadOldVehicle ),
    01661   OCL_CCHUNK( OC_TTO, 800, LoadOldVehicle ),
    01662
    01663   OCL_ASSERT( OC_TTD, 0x6F0F2 ),
    01664   OCL_ASSERT( OC_TTO, 0x45746 ),
    01665
    01666   OCL_VAR ( OC_TTD | OC_UINT8 | OC_DEREFERENCE_POINTER, 32 * 500, &_old_name_array ),
    01667   OCL_VAR ( OC_TTO | OC_UINT8 | OC_DEREFERENCE_POINTER, 24 * 200, &_old_name_array ),
    01668
    01669   OCL_ASSERT( OC_TTO, 0x46A06 ),
    01670
    01671   OCL_NULL( 0x2000 ),
    01672
    01673   OCL_CHUNK( 40, LoadOldSign ),
    01674
    01675   OCL_ASSERT( OC_TTO, 0x48C36 ),
    01676
    01677   OCL_CCHUNK( OC_TTD, 256, LoadOldEngine ),
    01678   OCL_CCHUNK( OC_TTO, 103, LoadOldEngine ),
    01679
    01680   OCL_ASSERT( OC_TTO, 0x496AC ),
    01681
    01682   OCL_VAR ( OC_UINT16,    1, &_vehicle_id_ctr_day ),
    01683
    01684   OCL_CHUNK(  8, LoadOldSubsidy ),
    01685
    01686   OCL_ASSERT( OC_TTO, 0x496CE ),
    01687
    01688   OCL_VAR ( OC_FILE_U16 | OC_VAR_U32,   1, &_next_competitor_start ),
    01689
    01690   OCL_CNULL( OC_TTO, 2 ),
    01691
    01692   OCL_VAR ( OC_FILE_I16 | OC_VAR_I32,   1, &_saved_scrollpos_x ),
    01693   OCL_VAR ( OC_FILE_I16 | OC_VAR_I32,   1, &_saved_scrollpos_y ),
    01694   OCL_VAR ( OC_FILE_U16 | OC_VAR_U8,    1, &_saved_scrollpos_zoom ),
    01695
    01696   OCL_VAR ( OC_FILE_U32 | OC_VAR_I64,   1, &_economy.max_loan ),
    01697   OCL_VAR ( OC_FILE_U32 | OC_VAR_I64,   1, &_economy.max_loan_unround ),
    01698   OCL_VAR (  OC_INT16,    1, &_economy.fluct ),
    01699
    01700   OCL_VAR ( OC_UINT16,    1, &_disaster_delay ),
    01701
    01702   OCL_ASSERT( OC_TTO, 0x496E4 ),
    01703
    01704   OCL_CNULL( OC_TTD, 144 ),
    01705
    01706   OCL_CCHUNK( OC_TTD, 256, LoadOldEngineName ),
    01707
    01708   OCL_CNULL( OC_TTD, 144 ),
    01709   OCL_NULL( 2 ),
    01710
    01711   OCL_VAR ( OC_FILE_U8 | OC_VAR_U16,    1, &_station_tick_ctr ),
    01712
    01713   OCL_VAR (  OC_UINT8,    1, &_settings_game.locale.currency ),
    01714   OCL_VAR (  OC_UINT8,    1, &_settings_game.locale.units ),
    01715   OCL_VAR ( OC_FILE_U8 | OC_VAR_U32,    1, &_cur_company_tick_index ),
    01716
    01717   OCL_NULL( 2 ),
    01718   OCL_NULL( 8 ),
    01719
    01720   OCL_VAR (  OC_UINT8,    1, &_economy.infl_amount ),
    01721   OCL_VAR (  OC_UINT8,    1, &_economy.infl_amount_pr ),
    01722   OCL_VAR (  OC_UINT8,    1, &_economy.interest_rate ),
    01723   OCL_NULL( 1 ), // available airports
    01724   OCL_VAR (  OC_UINT8,    1, &_settings_game.vehicle.road_side ),
    01725   OCL_VAR (  OC_UINT8,    1, &_settings_game.game_creation.town_name ),
    01726
    01727   OCL_CHUNK( 1, LoadOldGameDifficulty ),
    01728
    01729   OCL_ASSERT( OC_TTD, 0x77130 ),
    01730
    01731   OCL_VAR (  OC_UINT8,    1, &_settings_game.difficulty.diff_level ),
    01732
    01733   OCL_VAR ( OC_TTD | OC_UINT8,    1, &_settings_game.game_creation.landscape ),
    01734   OCL_VAR ( OC_TTD | OC_UINT8,    1, &_trees_tick_ctr ),
    01735
    01736   OCL_CNULL( OC_TTD, 1 ),
    01737   OCL_VAR ( OC_TTD | OC_UINT8,    1, &_settings_game.game_creation.snow_line ),
    01738
    01739   OCL_CNULL( OC_TTD, 32 ),
    01740   OCL_CNULL( OC_TTD, 36 ),
    01741
    01742   OCL_ASSERT( OC_TTD, 0x77179 ),
    01743   OCL_ASSERT( OC_TTO, 0x4971D ),
    01744
    01745   OCL_CHUNK( 1, LoadOldMapPart2 ),
    01746
    01747   OCL_ASSERT( OC_TTD, 0x97179 ),
    01748   OCL_ASSERT( OC_TTO, 0x6971D ),
    01749
    01750   /* Below any (if available) extra chunks from TTDPatch can follow */
    01751   OCL_CHUNK(1, LoadTTDPatchExtraChunks),
    01752
    01753   OCL_END()
    01754 };
    01755
    01756 bool LoadTTDMain(LoadgameState *ls)
    01757 {
    01758   _read_ttdpatch_flags = false;
    01759   _ttdp_version = 0;
    01760
    01761   DEBUG(oldloader, 3, "Reading main chunk...");
    01762   /* Load the biggest chunk */
    01763   SmallStackSafeStackAlloc<byte, OLD_MAP_SIZE * 2> map3;
    01764   _old_map3 = map3.data;
    01765   _old_vehicle_names = NULL;
    01766   if (!LoadChunk(ls, NULL, main_chunk)) {
    01767     DEBUG(oldloader, 0, "Loading failed");
    01768     free(_old_vehicle_names);
    01769     return false;
    01770   }
    01771   DEBUG(oldloader, 3, "Done, converting game data...");
    01772
    01773   FixTTDMapArray();
    01774
    01775   /* Fix some general stuff */
    01776   _settings_game.game_creation.landscape = _settings_game.game_creation.landscape & 0xF;
    01777
    01778   /* Remap some pointers */
    01779   _cur_town_ctr      = RemapTownIndex(_old_cur_town_ctr);
    01780
    01781   /* Fix the game to be compatible with OpenTTD */
    01782   FixOldTowns();
    01783   FixOldVehicles();
    01784
    01785   /* We have a new difficulty setting */
    01786   _settings_game.difficulty.town_council_tolerance = Clamp(_settings_game.difficulty.diff_level, 0, 2);
    01787
    01788   DEBUG(oldloader, 3, "Finished converting game data");
    01789   DEBUG(oldloader, 1, "TTD(Patch) savegame successfully converted");
    01790
    01791   free(_old_vehicle_names);
    01792
    01793   return true;
    01794 }
    01795
    01796 bool LoadTTOMain(LoadgameState *ls)
    01797 {
    01798   DEBUG(oldloader, 3, "Reading main chunk...");
    01799
    01800   SmallStackSafeStackAlloc<byte, 103 * sizeof(Engine)> engines; // we don't want to call Engine constructor here
    01801   _old_engines = (Engine *)engines.data;
    01802   SmallStackSafeStackAlloc<StringID, 800> vehnames;
    01803   _old_vehicle_names = vehnames.data;
    01804
    01805   /* Load the biggest chunk */
    01806   if (!LoadChunk(ls, NULL, main_chunk)) {
    01807     DEBUG(oldloader, 0, "Loading failed");
    01808     return false;
    01809   }
    01810   DEBUG(oldloader, 3, "Done, converting game data...");
    01811
    01812   if (_settings_game.game_creation.town_name != 0) _settings_game.game_creation.town_name++;
    01813
    01814   _settings_game.game_creation.landscape = 0;
    01815   _trees_tick_ctr = 0xFF;
    01816
    01817   _cur_town_ctr = RemapTownIndex(_old_cur_town_ctr);
    01818
    01819   if (!FixTTOMapArray() || !FixTTOEngines()) {
    01820     DEBUG(oldloader, 0, "Conversion failed");
    01821     return false;
    01822   }
    01823
    01824   FixOldTowns();
    01825   FixOldVehicles();
    01826   FixTTOCompanies();
    01827
    01828   /* We have a new difficulty setting */
    01829   _settings_game.difficulty.town_council_tolerance = Clamp(_settings_game.difficulty.diff_level, 0, 2);
    01830
    01831   DEBUG(oldloader, 3, "Finished converting game data");
    01832   DEBUG(oldloader, 1, "TTO savegame successfully converted");
    01833
    01834   return true;
    01835 }