# newgrf.cpp

Go to the documentation of this file.

    00001 /* $Id: newgrf.cpp 16355 2009-05-18 20:17:28Z rubidium $ */
    00002
    00005 #include "stdafx.h"
    00006
    00007 #include <stdarg.h>
    00008
    00009 #include "openttd.h"
    00010 #include "debug.h"
    00011 #include "fileio_func.h"
    00012 #include "engine_func.h"
    00013 #include "engine_base.h"
    00014 #include "spritecache.h"
    00015 #include "variables.h"
    00016 #include "bridge.h"
    00017 #include "town.h"
    00018 #include "newgrf_engine.h"
    00019 #include "newgrf_text.h"
    00020 #include "fontcache.h"
    00021 #include "currency.h"
    00022 #include "landscape.h"
    00023 #include "newgrf_house.h"
    00024 #include "newgrf_sound.h"
    00025 #include "newgrf_station.h"
    00026 #include "industry.h"
    00027 #include "newgrf_canal.h"
    00028 #include "newgrf_commons.h"
    00029 #include "newgrf_townname.h"
    00030 #include "newgrf_industries.h"
    00031 #include "rev.h"
    00032 #include "fios.h"
    00033 #include "rail.h"
    00034 #include "strings_func.h"
    00035 #include "gfx_func.h"
    00036 #include "date_func.h"
    00037 #include "vehicle_func.h"
    00038 #include "sound_func.h"
    00039 #include "string_func.h"
    00040 #include "network/network.h"
    00041 #include "map_func.h"
    00042 #include <map>
    00043 #include "core/alloc_type.hpp"
    00044
    00045 #include "table/strings.h"
    00046 #include "table/build_industry.h"
    00047
    00048 /* TTDPatch extended GRF format codec
    00049  * (c) Petr Baudis 2004 (GPL'd)
    00050  * Changes by Florian octo Forster are (c) by the OpenTTD development team.
    00051  *
    00052  * Contains portions of documentation by TTDPatch team.
    00053  * Thanks especially to Josef Drexler for the documentation as well as a lot
    00054  * of help at #tycoon. Also thanks to Michael Blunck for is GRF files which
    00055  * served as subject to the initial testing of this codec. */
    00056
    00057
    00058 static int _skip_sprites; // XXX
    00059 static uint _file_index; // XXX
    00060
    00061 static GRFFile *_cur_grffile;
    00062 GRFFile *_first_grffile;
    00063 static SpriteID _cur_spriteid;
    00064 static GrfLoadingStage _cur_stage;
    00065 static uint32 _nfo_line;
    00066
    00067 static GRFConfig *_cur_grfconfig;
    00068
    00069 /* Miscellaneous GRF features, set by Action 0x0D, parameter 0x9E */
    00070 static byte _misc_grf_features = 0;
    00071
    00072 /* 32 * 8 = 256 flags. Apparently TTDPatch uses this many.. */
    00073 static uint32 _ttdpatch_flags[8];
    00074
    00075 /* Indicates which are the newgrf features currently loaded ingame */
    00076 GRFLoadedFeatures _loaded_newgrf_features;
    00077
    00078 enum GrfDataType {
    00079   GDT_SOUND,
    00080 };
    00081
    00082 static byte _grf_data_blocks;
    00083 static GrfDataType _grf_data_type;
    00084
    00085
    00086 typedef void (*SpecialSpriteHandler)(byte *buf, size_t len);
    00087
    00088 enum {
    00089   MAX_STATIONS = 256,
    00090 };
    00091
    00092 /* Temporary data used when loading only */
    00093 struct GRFTempEngineData {
    00094   uint16 cargo_allowed;
    00095   uint16 cargo_disallowed;
    00096   uint8 rv_max_speed;
    00097 };
    00098
    00099 static GRFTempEngineData *_gted;
    00100
    00101 /* Contains the GRF ID of the owner of a vehicle if it has been reserved.
    00102  * GRM for vehicles is only used if dynamic engine allocation is disabled,
    00103  * so 256 is the number of original engines. */
    00104 static uint32 _grm_engines[256];
    00105
    00106 /* Contains the GRF ID of the owner of a cargo if it has been reserved */
    00107 static uint32 _grm_cargos[NUM_CARGO * 2];
    00108
    00109 struct GRFLocation {
    00110   uint32 grfid;
    00111   uint32 nfoline;
    00112
    00113   GRFLocation(uint32 grfid, uint32 nfoline) : grfid(grfid), nfoline(nfoline) { }
    00114
    00115   bool operator<(const GRFLocation &other) const
    00116   {
    00117     return this->grfid < other.grfid || (this->grfid == other.grfid && this->nfoline < other.nfoline);
    00118   }
    00119
    00120   bool operator==(const GRFLocation &other) const
    00121   {
    00122     return this->grfid == other.grfid && this->nfoline == other.nfoline;
    00123   }
    00124 };
    00125
    00126 static std::map<GRFLocation, SpriteID> _grm_sprites;
    00127 typedef std::map<GRFLocation, byte*> GRFLineToSpriteOverride;
    00128 GRFLineToSpriteOverride _grf_line_to_action6_sprite_override;
    00129
    00138 void CDECL grfmsg(int severity, const char *str, ...)
    00139 {
    00140   char buf[1024];
    00141   va_list va;
    00142
    00143   va_start(va, str);
    00144   vsnprintf(buf, sizeof(buf), str, va);
    00145   va_end(va);
    00146
    00147   DEBUG(grf, severity, "[%s:%d] %s", _cur_grfconfig->filename, _nfo_line, buf);
    00148 }
    00149
    00150 static inline bool check_length(size_t real, size_t wanted, const char *str)
    00151 {
    00152   if (real >= wanted) return true;
    00153   grfmsg(0, "%s: Invalid pseudo sprite length " PRINTF_SIZE " (expected " PRINTF_SIZE ")!", str, real, wanted);
    00154   return false;
    00155 }
    00156
    00157 static inline byte grf_load_byte(byte **buf)
    00158 {
    00159   return *(*buf)++;
    00160 }
    00161
    00162 static uint16 grf_load_word(byte **buf)
    00163 {
    00164   uint16 val = grf_load_byte(buf);
    00165   return val | (grf_load_byte(buf) << 8);
    00166 }
    00167
    00168 static uint16 grf_load_extended(byte** buf)
    00169 {
    00170   uint16 val;
    00171   val = grf_load_byte(buf);
    00172   if (val == 0xFF) val = grf_load_word(buf);
    00173   return val;
    00174 }
    00175
    00176 static uint32 grf_load_dword(byte **buf)
    00177 {
    00178   uint32 val = grf_load_word(buf);
    00179   return val | (grf_load_word(buf) << 16);
    00180 }
    00181
    00182 static uint32 grf_load_var(byte size, byte **buf)
    00183 {
    00184   switch (size) {
    00185     case 1: return grf_load_byte(buf);
    00186     case 2: return grf_load_word(buf);
    00187     case 4: return grf_load_dword(buf);
    00188     default:
    00189       NOT_REACHED();
    00190       return 0;
    00191   }
    00192 }
    00193
    00194 static const char *grf_load_string(byte **buf, size_t max_len)
    00195 {
    00196   const char *string   = *(const char **)buf;
    00197   size_t string_length = ttd_strnlen(string, max_len);
    00198
    00199   if (string_length == max_len) {
    00200     /* String was not NUL terminated, so make sure it is now. */
    00201     (*buf)[string_length - 1] = '\0';
    00202     grfmsg(7, "String was not terminated with a zero byte.");
    00203   } else {
    00204     /* Increase the string length to include the NUL byte. */
    00205     string_length++;
    00206   }
    00207   *buf += string_length;
    00208
    00209   return string;
    00210 }
    00211
    00212 static GRFFile *GetFileByGRFID(uint32 grfid)
    00213 {
    00214   GRFFile *file;
    00215
    00216   for (file = _first_grffile; file != NULL; file = file->next) {
    00217     if (file->grfid == grfid) break;
    00218   }
    00219   return file;
    00220 }
    00221
    00222 static GRFFile *GetFileByFilename(const char *filename)
    00223 {
    00224   GRFFile *file;
    00225
    00226   for (file = _first_grffile; file != NULL; file = file->next) {
    00227     if (strcmp(file->filename, filename) == 0) break;
    00228   }
    00229   return file;
    00230 }
    00231
    00233 static void ClearTemporaryNewGRFData(GRFFile *gf)
    00234 {
    00235   /* Clear the GOTO labels used for GRF processing */
    00236   for (GRFLabel *l = gf->label; l != NULL;) {
    00237     GRFLabel *l2 = l->next;
    00238     free(l);
    00239     l = l2;
    00240   }
    00241   gf->label = NULL;
    00242
    00243   /* Clear the list of spritegroups */
    00244   free(gf->spritegroups);
    00245   gf->spritegroups = NULL;
    00246   gf->spritegroups_count = 0;
    00247 }
    00248
    00249
    00250 typedef std::map<StringID *, uint32> StringIDToGRFIDMapping;
    00251 StringIDToGRFIDMapping _string_to_grf_mapping;
    00252
    00259 StringID MapGRFStringID(uint32 grfid, StringID str)
    00260 {
    00261   /* StringID table for TextIDs 0x4E->0x6D */
    00262   static const StringID units_volume[] = {
    00263     STR_NOTHING,    STR_PASSENGERS, STR_TONS,       STR_BAGS,
    00264     STR_LITERS,     STR_ITEMS,      STR_CRATES,     STR_TONS,
    00265     STR_TONS,       STR_TONS,       STR_TONS,       STR_BAGS,
    00266     STR_TONS,       STR_TONS,       STR_TONS,       STR_BAGS,
    00267     STR_TONS,       STR_TONS,       STR_BAGS,       STR_LITERS,
    00268     STR_TONS,       STR_LITERS,     STR_TONS,       STR_NOTHING,
    00269     STR_BAGS,       STR_LITERS,     STR_TONS,       STR_NOTHING,
    00270     STR_TONS,       STR_NOTHING,    STR_LITERS,     STR_NOTHING
    00271   };
    00272
    00273   /* 0xD0 and 0xDC stand for all the TextIDs in the range
    00274    * of 0xD000 (misc graphics texts) and 0xDC00 (misc persistent texts).
    00275    * These strings are unique to each grf file, and thus require to be used with the
    00276    * grfid in which they are declared */
    00277   switch (GB(str, 8, 8)) {
    00278     case 0xD0: case 0xD1: case 0xD2: case 0xD3:
    00279     case 0xDC:
    00280       return GetGRFStringID(grfid, str);
    00281
    00282     case 0xD4: case 0xD5: case 0xD6: case 0xD7:
    00283       /* Strings embedded via 0x81 have 0x400 added to them (no real
    00284        * explanation why...) */
    00285       return GetGRFStringID(grfid, str - 0x400);
    00286
    00287     default: break;
    00288   }
    00289
    00290 #define TEXID_TO_STRINGID(begin, end, stringid) if (str >= begin && str <= end) return str + (stringid - begin)
    00291   /* We have some changes in our cargo strings, resulting in some missing. */
    00292   TEXID_TO_STRINGID(0x000E, 0x002D, STR_000E);
    00293   TEXID_TO_STRINGID(0x002E, 0x004D, STR_002E);
    00294   if (str >= 0x004E && str <= 0x006D) str = units_volume[str - 0x004E];
    00295   TEXID_TO_STRINGID(0x006E, 0x008D, STR_QUANTITY_NOTHING);
    00296   TEXID_TO_STRINGID(0x008E, 0x00AD, STR_ABBREV_NOTHING);
    00297
    00298   /* Map building names according to our lang file changes. There are several
    00299    * ranges of house ids, all of which need to be remapped to allow newgrfs
    00300    * to use original house names. */
    00301   TEXID_TO_STRINGID(0x200F, 0x201F, STR_200F_TALL_OFFICE_BLOCK);
    00302   TEXID_TO_STRINGID(0x2036, 0x2041, STR_2036_COTTAGES);
    00303   TEXID_TO_STRINGID(0x2059, 0x205C, STR_2059_IGLOO);
    00304
    00305   /* Same thing for industries, since the introduction of 4 new strings above STR_482A_PRODUCTION_LAST_MONTH */
    00306   TEXID_TO_STRINGID(0x482A, 0x483B, STR_482A_PRODUCTION_LAST_MONTH);
    00307 #undef TEXTID_TO_STRINGID
    00308
    00309   if (str == STR_NULL) return STR_EMPTY;
    00310
    00311   return str;
    00312 }
    00313
    00314 static inline uint8 MapDOSColour(uint8 colour)
    00315 {
    00316   extern const byte _palmap_d2w[];
    00317   return (_use_palette == PAL_DOS ? colour : _palmap_d2w[colour]);
    00318 }
    00319
    00320 static std::map<uint32, uint32> _grf_id_overrides;
    00321
    00322 static void SetNewGRFOverride(uint32 source_grfid, uint32 target_grfid)
    00323 {
    00324   _grf_id_overrides[source_grfid] = target_grfid;
    00325   grfmsg(5, "SetNewGRFOverride: Added override of 0x%X to 0x%X", BSWAP32(source_grfid), BSWAP32(target_grfid));
    00326 }
    00327
    00336 static Engine *GetNewEngine(const GRFFile *file, VehicleType type, uint16 internal_id, bool static_access = false)
    00337 {
    00338   /* Hack for add-on GRFs that need to modify another GRF's engines. This lets
    00339    * them use the same engine slots. */
    00340   uint32 scope_grfid = INVALID_GRFID; // If not using dynamic_engines, all newgrfs share their ID range
    00341   if (_settings_game.vehicle.dynamic_engines) {
    00342     /* If dynamic_engies is enabled, there can be multiple independent ID ranges. */
    00343     scope_grfid = file->grfid;
    00344     uint32 override = _grf_id_overrides[file->grfid];
    00345     if (override != 0) {
    00346       scope_grfid = override;
    00347       const GRFFile *grf_match = GetFileByGRFID(override);
    00348       if (grf_match == NULL) {
    00349         grfmsg(5, "Tried mapping from GRFID %x to %x but target is not loaded", BSWAP32(file->grfid), BSWAP32(override));
    00350       } else {
    00351         grfmsg(5, "Mapping from GRFID %x to %x", BSWAP32(file->grfid), BSWAP32(override));
    00352       }
    00353     }
    00354
    00355     /* Check if the engine is registered in the override manager */
    00356     EngineID engine = _engine_mngr.GetID(type, internal_id, scope_grfid);
    00357     if (engine != INVALID_ENGINE) return GetEngine(engine);
    00358   }
    00359
    00360   /* Check if there is an unreserved slot */
    00361   EngineID engine = _engine_mngr.GetID(type, internal_id, INVALID_GRFID);
    00362   if (engine != INVALID_ENGINE) {
    00363     Engine *e = GetEngine(engine);
    00364
    00365     if (e->grffile == NULL) {
    00366       e->grffile = file;
    00367       grfmsg(5, "Replaced engine at index %d for GRFID %x, type %d, index %d", e->index, BSWAP32(file->grfid), type, internal_id);
    00368     }
    00369
    00370     /* Reserve the engine slot */
    00371     if (!static_access) {
    00372       EngineIDMapping *eid = _engine_mngr.Get(engine);
    00373       eid->grfid           = scope_grfid; // Note: this is INVALID_GRFID if dynamic_engines is disabled, so no reservation
    00374     }
    00375
    00376     return e;
    00377   }
    00378
    00379   if (static_access) return NULL;
    00380
    00381   uint engine_pool_size = GetEnginePoolSize();
    00382
    00383   /* ... it's not, so create a new one based off an existing engine */
    00384   Engine *e = new Engine(type, internal_id);
    00385   e->grffile = file;
    00386
    00387   /* Reserve the engine slot */
    00388   assert(_engine_mngr.Length() == e->index);
    00389   EngineIDMapping *eid = _engine_mngr.Append();
    00390   eid->type            = type;
    00391   eid->grfid           = scope_grfid; // Note: this is INVALID_GRFID if dynamic_engines is disabled, so no reservation
    00392   eid->internal_id     = internal_id;
    00393   eid->substitute_id   = min(internal_id, _engine_counts[type]); // substitute_id == _engine_counts[subtype] means "no substitute"
    00394
    00395   if (engine_pool_size != GetEnginePoolSize()) {
    00396     /* Resize temporary engine data ... */
    00397     _gted = ReallocT(_gted, GetEnginePoolSize());
    00398
    00399     /* and blank the new block. */
    00400     size_t len = (GetEnginePoolSize() - engine_pool_size) * sizeof(*_gted);
    00401     memset(_gted + engine_pool_size, 0, len);
    00402   }
    00403
    00404   grfmsg(5, "Created new engine at index %d for GRFID %x, type %d, index %d", e->index, BSWAP32(file->grfid), type, internal_id);
    00405
    00406   return e;
    00407 }
    00408
    00409 EngineID GetNewEngineID(const GRFFile *file, VehicleType type, uint16 internal_id)
    00410 {
    00411   uint32 scope_grfid = INVALID_GRFID; // If not using dynamic_engines, all newgrfs share their ID range
    00412   if (_settings_game.vehicle.dynamic_engines) {
    00413     scope_grfid = file->grfid;
    00414     uint32 override = _grf_id_overrides[file->grfid];
    00415     if (override != 0) scope_grfid = override;
    00416   }
    00417
    00418   return _engine_mngr.GetID(type, internal_id, scope_grfid);
    00419 }
    00420
    00424 static void MapSpriteMappingRecolour(PalSpriteID *grf_sprite)
    00425 {
    00426   if (HasBit(grf_sprite->pal, 14)) {
    00427     ClrBit(grf_sprite->pal, 14);
    00428     SetBit(grf_sprite->sprite, SPRITE_MODIFIER_OPAQUE);
    00429   }
    00430
    00431   if (HasBit(grf_sprite->sprite, 14)) {
    00432     ClrBit(grf_sprite->sprite, 14);
    00433     SetBit(grf_sprite->sprite, PALETTE_MODIFIER_TRANSPARENT);
    00434   }
    00435
    00436   if (HasBit(grf_sprite->sprite, 15)) {
    00437     ClrBit(grf_sprite->sprite, 15);
    00438     SetBit(grf_sprite->sprite, PALETTE_MODIFIER_COLOUR);
    00439   }
    00440 }
    00441
    00442 enum ChangeInfoResult {
    00443   CIR_SUCCESS,
    00444   CIR_UNHANDLED,
    00445   CIR_UNKNOWN,
    00446   CIR_INVALID_ID,
    00447 };
    00448
    00449 typedef ChangeInfoResult (*VCI_Handler)(uint engine, int numinfo, int prop, byte **buf, int len);
    00450
    00451 static ChangeInfoResult CommonVehicleChangeInfo(EngineInfo *ei, int prop, byte **buf)
    00452 {
    00453   switch (prop) {
    00454     case 0x00: // Introduction date
    00455       ei->base_intro = grf_load_word(buf) + DAYS_TILL_ORIGINAL_BASE_YEAR;
    00456       break;
    00457
    00458     case 0x02: // Decay speed
    00459       ei->decay_speed = grf_load_byte(buf);
    00460       break;
    00461
    00462     case 0x03: // Vehicle life
    00463       ei->lifelength = grf_load_byte(buf);
    00464       break;
    00465
    00466     case 0x04: // Model life
    00467       ei->base_life = grf_load_byte(buf);
    00468       break;
    00469
    00470     case 0x06: // Climates available
    00471       ei->climates = grf_load_byte(buf);
    00472       /* Sometimes a GRF wants hidden vehicles. Setting climates to
    00473        * zero may cause the ID to be reallocated. */
    00474       if (ei->climates == 0) ei->climates = 0x80;
    00475       break;
    00476
    00477     case 0x07: // Loading speed
    00478       /* Amount of cargo loaded during a vehicle's "loading tick" */
    00479       ei->load_amount = grf_load_byte(buf);
    00480       break;
    00481
    00482     default:
    00483       return CIR_UNKNOWN;
    00484   }
    00485
    00486   return CIR_SUCCESS;
    00487 }
    00488
    00489 static ChangeInfoResult RailVehicleChangeInfo(uint engine, int numinfo, int prop, byte **bufp, int len)
    00490 {
    00491   byte *buf = *bufp;
    00492   ChangeInfoResult ret = CIR_SUCCESS;
    00493
    00494   for (int i = 0; i < numinfo; i++) {
    00495     Engine *e = GetNewEngine(_cur_grffile, VEH_TRAIN, engine + i);
    00496     EngineInfo *ei = &e->info;
    00497     RailVehicleInfo *rvi = &e->u.rail;
    00498
    00499     switch (prop) {
    00500       case 0x05: { // Track type
    00501         uint8 tracktype = grf_load_byte(&buf);
    00502
    00503         if (tracktype < _cur_grffile->railtype_max) {
    00504           RailType railtype = GetRailTypeByLabel(_cur_grffile->railtype_list[tracktype]);
    00505           if (railtype == INVALID_RAILTYPE) {
    00506             /* Rail type is not available, so disable this engine */
    00507             ei[i].climates = 0x80;
    00508           } else {
    00509             rvi[i].railtype = railtype;
    00510           }
    00511           break;
    00512         }
    00513
    00514         switch (tracktype) {
    00515           case 0: rvi->railtype = rvi->engclass >= 2 ? RAILTYPE_ELECTRIC : RAILTYPE_RAIL; break;
    00516           case 1: rvi->railtype = RAILTYPE_MONO; break;
    00517           case 2: rvi->railtype = RAILTYPE_MAGLEV; break;
    00518           default:
    00519             grfmsg(1, "RailVehicleChangeInfo: Invalid track type %d specified, ignoring", tracktype);
    00520             break;
    00521         }
    00522       } break;
    00523
    00524       case 0x08: // AI passenger service
    00525         /* Tells the AI that this engine is designed for
    00526          * passenger services and shouldn't be used for freight. */
    00527         rvi->ai_passenger_only = grf_load_byte(&buf);
    00528         break;
    00529
    00530       case 0x09: { // Speed (1 unit is 1 kmh)
    00531         uint16 speed = grf_load_word(&buf);
    00532         if (speed == 0xFFFF) speed = 0;
    00533
    00534         rvi->max_speed = speed;
    00535       } break;
    00536
    00537       case 0x0B: // Power
    00538         rvi->power = grf_load_word(&buf);
    00539
    00540         /* Set engine / wagon state based on power */
    00541         if (rvi->power != 0) {
    00542           if (rvi->railveh_type == RAILVEH_WAGON) {
    00543             rvi->railveh_type = RAILVEH_SINGLEHEAD;
    00544           }
    00545         } else {
    00546           rvi->railveh_type = RAILVEH_WAGON;
    00547         }
    00548         break;
    00549
    00550       case 0x0D: // Running cost factor
    00551         rvi->running_cost = grf_load_byte(&buf);
    00552         break;
    00553
    00554       case 0x0E: { // Running cost base
    00555         uint32 base = grf_load_dword(&buf);
    00556
    00557         /* These magic numbers are used in GRFs to specify the base cost:
    00558          * http://wiki.ttdpatch.net/tiki-index.php?page=BaseCosts
    00559          */
    00560         if (base == 0) {
    00561           rvi->running_cost_class = 0xFF;
    00562         } else if (base < 0x4B34 || base > 0x4C54 || (base - 0x4B34) % 6 != 0) {
    00563           grfmsg(1, "RailVehicleChangeInfo: Unsupported running cost base 0x%04X, ignoring", base);
    00564         } else {
    00565           /* Convert the magic number to an index into the price data */
    00566           rvi->running_cost_class = (base - 0x4B34) / 6;
    00567         }
    00568       } break;
    00569
    00570       case 0x12: { // Sprite ID
    00571         uint8 spriteid = grf_load_byte(&buf);
    00572
    00573         /* TTD sprite IDs point to a location in a 16bit array, but we use it
    00574          * as an array index, so we need it to be half the original value. */
    00575         if (spriteid < 0xFD) spriteid >>= 1;
    00576
    00577         rvi->image_index = spriteid;
    00578       } break;
    00579
    00580       case 0x13: { // Dual-headed
    00581         uint8 dual = grf_load_byte(&buf);
    00582
    00583         if (dual != 0) {
    00584           rvi->railveh_type = RAILVEH_MULTIHEAD;
    00585         } else {
    00586           rvi->railveh_type = rvi->power == 0 ?
    00587             RAILVEH_WAGON : RAILVEH_SINGLEHEAD;
    00588         }
    00589       } break;
    00590
    00591       case 0x14: // Cargo capacity
    00592         rvi->capacity = grf_load_byte(&buf);
    00593         break;
    00594
    00595       case 0x15: { // Cargo type
    00596         uint8 ctype = grf_load_byte(&buf);
    00597
    00598         if (ctype < NUM_CARGO && HasBit(_cargo_mask, ctype)) {
    00599           rvi->cargo_type = ctype;
    00600         } else if (ctype == 0xFF) {
    00601           /* 0xFF is specified as 'use first refittable' */
    00602           rvi->cargo_type = CT_INVALID;
    00603         } else {
    00604           rvi->cargo_type = CT_INVALID;
    00605           grfmsg(2, "RailVehicleChangeInfo: Invalid cargo type %d, using first refittable", ctype);
    00606         }
    00607       } break;
    00608
    00609       case 0x16: // Weight
    00610         SB(rvi->weight, 0, 8, grf_load_byte(&buf));
    00611         break;
    00612
    00613       case 0x17: // Cost factor
    00614         rvi->cost_factor = grf_load_byte(&buf);
    00615         break;
    00616
    00617       case 0x18: // AI rank
    00618         rvi->ai_rank = grf_load_byte(&buf);
    00619         break;
    00620
    00621       case 0x19: { // Engine traction type
    00622         /* What do the individual numbers mean?
    00623          * 0x00 .. 0x07: Steam
    00624          * 0x08 .. 0x27: Diesel
    00625          * 0x28 .. 0x31: Electric
    00626          * 0x32 .. 0x37: Monorail
    00627          * 0x38 .. 0x41: Maglev
    00628          */
    00629         uint8 traction = grf_load_byte(&buf);
    00630         EngineClass engclass;
    00631
    00632         if (traction <= 0x07) {
    00633           engclass = EC_STEAM;
    00634         } else if (traction <= 0x27) {
    00635           engclass = EC_DIESEL;
    00636         } else if (traction <= 0x31) {
    00637           engclass = EC_ELECTRIC;
    00638         } else if (traction <= 0x37) {
    00639           engclass = EC_MONORAIL;
    00640         } else if (traction <= 0x41) {
    00641           engclass = EC_MAGLEV;
    00642         } else {
    00643           break;
    00644         }
    00645
    00646         if (_cur_grffile->railtype_max == 0) {
    00647           /* Use traction type to select between normal and electrified
    00648            * rail only when no translation list is in place. */
    00649           if (rvi->railtype == RAILTYPE_RAIL     && engclass >= EC_ELECTRIC) rvi->railtype = RAILTYPE_ELECTRIC;
    00650           if (rvi->railtype == RAILTYPE_ELECTRIC && engclass  < EC_ELECTRIC) rvi->railtype = RAILTYPE_RAIL;
    00651         }
    00652
    00653         rvi->engclass = engclass;
    00654       } break;
    00655
    00656       case 0x1A: // Alter purchase list sort order
    00657         AlterVehicleListOrder(e->index, grf_load_extended(&buf));
    00658         break;
    00659
    00660       case 0x1B: // Powered wagons power bonus
    00661         rvi->pow_wag_power = grf_load_word(&buf);
    00662         break;
    00663
    00664       case 0x1C: // Refit cost
    00665         ei->refit_cost = grf_load_byte(&buf);
    00666         break;
    00667
    00668       case 0x1D: // Refit cargo
    00669         ei->refit_mask = grf_load_dword(&buf);
    00670         break;
    00671
    00672       case 0x1E: // Callback
    00673         ei->callbackmask = grf_load_byte(&buf);
    00674         break;
    00675
    00676       case 0x1F: // Tractive effort coefficient
    00677         rvi->tractive_effort = grf_load_byte(&buf);
    00678         break;
    00679
    00680       case 0x20: // Air drag
    00682         grf_load_byte(&buf);
    00683         ret = CIR_UNHANDLED;
    00684         break;
    00685
    00686       case 0x21: // Shorter vehicle
    00687         rvi->shorten_factor = grf_load_byte(&buf);
    00688         break;
    00689
    00690       case 0x22: // Visual effect
    00692         rvi->visual_effect = grf_load_byte(&buf);
    00693         break;
    00694
    00695       case 0x23: // Powered wagons weight bonus
    00696         rvi->pow_wag_weight = grf_load_byte(&buf);
    00697         break;
    00698
    00699       case 0x24: { // High byte of vehicle weight
    00700         byte weight = grf_load_byte(&buf);
    00701
    00702         if (weight > 4) {
    00703           grfmsg(2, "RailVehicleChangeInfo: Nonsensical weight of %d tons, ignoring", weight << 8);
    00704         } else {
    00705           SB(rvi->weight, 8, 8, weight);
    00706         }
    00707       } break;
    00708
    00709       case 0x25: // User-defined bit mask to set when checking veh. var. 42
    00710         rvi->user_def_data = grf_load_byte(&buf);
    00711         break;
    00712
    00713       case 0x26: // Retire vehicle early
    00714         ei->retire_early = grf_load_byte(&buf);
    00715         break;
    00716
    00717       case 0x27: // Miscellaneous flags
    00718         ei->misc_flags = grf_load_byte(&buf);
    00719         _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
    00720         break;
    00721
    00722       case 0x28: // Cargo classes allowed
    00723         _gted[e->index].cargo_allowed = grf_load_word(&buf);
    00724         break;
    00725
    00726       case 0x29: // Cargo classes disallowed
    00727         _gted[e->index].cargo_disallowed = grf_load_word(&buf);
    00728         break;
    00729
    00730       case 0x2A: // Long format introduction date (days since year 0)
    00731         ei->base_intro = grf_load_dword(&buf);
    00732         break;
    00733
    00734       default:
    00735         ret = CommonVehicleChangeInfo(ei, prop, &buf);
    00736         break;
    00737     }
    00738   }
    00739
    00740   *bufp = buf;
    00741   return ret;
    00742 }
    00743
    00744 static ChangeInfoResult RoadVehicleChangeInfo(uint engine, int numinfo, int prop, byte **bufp, int len)
    00745 {
    00746   byte *buf = *bufp;
    00747   ChangeInfoResult ret = CIR_SUCCESS;
    00748
    00749   for (int i = 0; i < numinfo; i++) {
    00750     Engine *e = GetNewEngine(_cur_grffile, VEH_ROAD, engine + i);
    00751     EngineInfo *ei = &e->info;
    00752     RoadVehicleInfo *rvi = &e->u.road;
    00753
    00754     switch (prop) {
    00755       case 0x08: // Speed (1 unit is 0.5 kmh)
    00756         rvi->max_speed = grf_load_byte(&buf);
    00757         break;
    00758
    00759       case 0x09: // Running cost factor
    00760         rvi->running_cost = grf_load_byte(&buf);
    00761         break;
    00762
    00763       case 0x0A: { // Running cost base
    00764         uint32 base = grf_load_dword(&buf);
    00765
    00766         /* These magic numbers are used in GRFs to specify the base cost:
    00767          * http://wiki.ttdpatch.net/tiki-index.php?page=BaseCosts
    00768          */
    00769         if (base == 0) {
    00770           rvi->running_cost_class = 0xFF;
    00771         } else if (base < 0x4B34 || base > 0x4C54 || (base - 0x4B34) % 6 != 0) {
    00772           grfmsg(1, "RailVehicleChangeInfo: Unsupported running cost base 0x%04X, ignoring", base);
    00773         } else {
    00774           /* Convert the magic number to an index into the price data */
    00775           rvi->running_cost_class = (base - 0x4B34) / 6;
    00776         }
    00777
    00778         break;
    00779       }
    00780
    00781       case 0x0E: { // Sprite ID
    00782         uint8 spriteid = grf_load_byte(&buf);
    00783
    00784         /* cars have different custom id in the GRF file */
    00785         if (spriteid == 0xFF) spriteid = 0xFD;
    00786
    00787         if (spriteid < 0xFD) spriteid >>= 1;
    00788
    00789         rvi->image_index = spriteid;
    00790       } break;
    00791
    00792       case 0x0F: // Cargo capacity
    00793         rvi->capacity = grf_load_byte(&buf);
    00794         break;
    00795
    00796       case 0x10: { // Cargo type
    00797         uint8 cargo = grf_load_byte(&buf);
    00798
    00799         if (cargo < NUM_CARGO && HasBit(_cargo_mask, cargo)) {
    00800           rvi->cargo_type = cargo;
    00801         } else if (cargo == 0xFF) {
    00802           rvi->cargo_type = CT_INVALID;
    00803         } else {
    00804           rvi->cargo_type = CT_INVALID;
    00805           grfmsg(2, "RoadVehicleChangeInfo: Invalid cargo type %d, using first refittable", cargo);
    00806         }
    00807       } break;
    00808
    00809       case 0x11: // Cost factor
    00810         rvi->cost_factor = grf_load_byte(&buf);
    00811         break;
    00812
    00813       case 0x12: // SFX
    00814         rvi->sfx = (SoundFx)grf_load_byte(&buf);
    00815         break;
    00816
    00817       case 0x13: // Power in 10hp
    00818         rvi->power = grf_load_byte(&buf);
    00819         break;
    00820
    00821       case 0x14: // Weight in 1/4 tons
    00822         rvi->weight = grf_load_byte(&buf);
    00823         break;
    00824
    00825       case 0x15: // Speed in mph/0.8
    00826         _gted[e->index].rv_max_speed = grf_load_byte(&buf);
    00827         break;
    00828
    00829       case 0x16: // Cargos available for refitting
    00830         ei->refit_mask = grf_load_dword(&buf);
    00831         break;
    00832
    00833       case 0x17: // Callback mask
    00834         ei->callbackmask = grf_load_byte(&buf);
    00835         break;
    00836
    00837       case 0x18: // Tractive effort
    00838         rvi->tractive_effort = grf_load_byte(&buf);
    00839         break;
    00840
    00841       case 0x19: // Air drag
    00842         rvi->air_drag = grf_load_byte(&buf);
    00843         break;
    00844
    00845       case 0x1A: // Refit cost
    00846         ei->refit_cost = grf_load_byte(&buf);
    00847         break;
    00848
    00849       case 0x1B: // Retire vehicle early
    00850         ei->retire_early = grf_load_byte(&buf);
    00851         break;
    00852
    00853       case 0x1C: // Miscellaneous flags
    00854         ei->misc_flags = grf_load_byte(&buf);
    00855         _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
    00856         break;
    00857
    00858       case 0x1D: // Cargo classes allowed
    00859         _gted[e->index].cargo_allowed = grf_load_word(&buf);
    00860         break;
    00861
    00862       case 0x1E: // Cargo classes disallowed
    00863         _gted[e->index].cargo_disallowed = grf_load_word(&buf);
    00864         break;
    00865
    00866       case 0x1F: // Long format introduction date (days since year 0)
    00867         ei->base_intro = grf_load_dword(&buf);
    00868         break;
    00869
    00870       case 0x20: // Alter purchase list sort order
    00871         AlterVehicleListOrder(e->index, grf_load_extended(&buf));
    00872         break;
    00873
    00874       default:
    00875         ret = CommonVehicleChangeInfo(ei, prop, &buf);
    00876         break;
    00877     }
    00878   }
    00879
    00880   *bufp = buf;
    00881   return ret;
    00882 }
    00883
    00884 static ChangeInfoResult ShipVehicleChangeInfo(uint engine, int numinfo, int prop, byte **bufp, int len)
    00885 {
    00886   byte *buf = *bufp;
    00887   ChangeInfoResult ret = CIR_SUCCESS;
    00888
    00889   for (int i = 0; i < numinfo; i++) {
    00890     Engine *e = GetNewEngine(_cur_grffile, VEH_SHIP, engine + i);
    00891     EngineInfo *ei = &e->info;
    00892     ShipVehicleInfo *svi = &e->u.ship;
    00893
    00894     switch (prop) {
    00895       case 0x08: { // Sprite ID
    00896         uint8 spriteid = grf_load_byte(&buf);
    00897
    00898         /* ships have different custom id in the GRF file */
    00899         if (spriteid == 0xFF) spriteid = 0xFD;
    00900
    00901         if (spriteid < 0xFD) spriteid >>= 1;
    00902
    00903         svi->image_index = spriteid;
    00904       } break;
    00905
    00906       case 0x09: // Refittable
    00907         svi->refittable = (grf_load_byte(&buf) != 0);
    00908         break;
    00909
    00910       case 0x0A: // Cost factor
    00911         svi->cost_factor = grf_load_byte(&buf);
    00912         break;
    00913
    00914       case 0x0B: // Speed (1 unit is 0.5 kmh)
    00915         svi->max_speed = grf_load_byte(&buf);
    00916         break;
    00917
    00918       case 0x0C: { // Cargo type
    00919         uint8 cargo = grf_load_byte(&buf);
    00920
    00921         if (cargo < NUM_CARGO && HasBit(_cargo_mask, cargo)) {
    00922           svi->cargo_type = cargo;
    00923         } else if (cargo == 0xFF) {
    00924           svi->cargo_type = CT_INVALID;
    00925         } else {
    00926           svi->cargo_type = CT_INVALID;
    00927           grfmsg(2, "ShipVehicleChangeInfo: Invalid cargo type %d, using first refittable", cargo);
    00928         }
    00929       } break;
    00930
    00931       case 0x0D: // Cargo capacity
    00932         svi->capacity = grf_load_word(&buf);
    00933         break;
    00934
    00935       case 0x0F: // Running cost factor
    00936         svi->running_cost = grf_load_byte(&buf);
    00937         break;
    00938
    00939       case 0x10: // SFX
    00940         svi->sfx = (SoundFx)grf_load_byte(&buf);
    00941         break;
    00942
    00943       case 0x11: // Cargos available for refitting
    00944         ei->refit_mask = grf_load_dword(&buf);
    00945         break;
    00946
    00947       case 0x12: // Callback mask
    00948         ei->callbackmask = grf_load_byte(&buf);
    00949         break;
    00950
    00951       case 0x13: // Refit cost
    00952         ei->refit_cost = grf_load_byte(&buf);
    00953         break;
    00954
    00955       case 0x14: // Ocean speed fraction
    00956       case 0x15: // Canal speed fraction
    00958         grf_load_byte(&buf);
    00959         ret = CIR_UNHANDLED;
    00960         break;
    00961
    00962       case 0x16: // Retire vehicle early
    00963         ei->retire_early = grf_load_byte(&buf);
    00964         break;
    00965
    00966       case 0x17: // Miscellaneous flags
    00967         ei->misc_flags = grf_load_byte(&buf);
    00968         _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
    00969         break;
    00970
    00971       case 0x18: // Cargo classes allowed
    00972         _gted[e->index].cargo_allowed = grf_load_word(&buf);
    00973         break;
    00974
    00975       case 0x19: // Cargo classes disallowed
    00976         _gted[e->index].cargo_disallowed = grf_load_word(&buf);
    00977         break;
    00978
    00979       case 0x1A: // Long format introduction date (days since year 0)
    00980         ei->base_intro = grf_load_dword(&buf);
    00981         break;
    00982
    00983       case 0x1B: // Alter purchase list sort order
    00984         AlterVehicleListOrder(e->index, grf_load_extended(&buf));
    00985         break;
    00986
    00987       default:
    00988         ret = CommonVehicleChangeInfo(ei, prop, &buf);
    00989         break;
    00990     }
    00991   }
    00992
    00993   *bufp = buf;
    00994   return ret;
    00995 }
    00996
    00997 static ChangeInfoResult AircraftVehicleChangeInfo(uint engine, int numinfo, int prop, byte **bufp, int len)
    00998 {
    00999   byte *buf = *bufp;
    01000   ChangeInfoResult ret = CIR_SUCCESS;
    01001
    01002   for (int i = 0; i < numinfo; i++) {
    01003     Engine *e = GetNewEngine(_cur_grffile, VEH_AIRCRAFT, engine + i);
    01004     EngineInfo *ei = &e->info;
    01005     AircraftVehicleInfo *avi = &e->u.air;
    01006
    01007     switch (prop) {
    01008       case 0x08: { // Sprite ID
    01009         uint8 spriteid = grf_load_byte(&buf);
    01010
    01011         /* aircraft have different custom id in the GRF file */
    01012         if (spriteid == 0xFF) spriteid = 0xFD;
    01013
    01014         if (spriteid < 0xFD) spriteid >>= 1;
    01015
    01016         avi->image_index = spriteid;
    01017       } break;
    01018
    01019       case 0x09: // Helicopter
    01020         if (grf_load_byte(&buf) == 0) {
    01021           avi->subtype = AIR_HELI;
    01022         } else {
    01023           SB(avi->subtype, 0, 1, 1); // AIR_CTOL
    01024         }
    01025         break;
    01026
    01027       case 0x0A: // Large
    01028         SB(avi->subtype, 1, 1, (grf_load_byte(&buf) != 0 ? 1 : 0)); // AIR_FAST
    01029         break;
    01030
    01031       case 0x0B: // Cost factor
    01032         avi->cost_factor = grf_load_byte(&buf);
    01033         break;
    01034
    01035       case 0x0C: // Speed (1 unit is 8 mph, we translate to 1 unit is 1 km/h)
    01036         avi->max_speed = (grf_load_byte(&buf) * 129) / 10;
    01037         break;
    01038
    01039       case 0x0D: // Acceleration
    01040         avi->acceleration = (grf_load_byte(&buf) * 129) / 10;
    01041         break;
    01042
    01043       case 0x0E: // Running cost factor
    01044         avi->running_cost = grf_load_byte(&buf);
    01045         break;
    01046
    01047       case 0x0F: // Passenger capacity
    01048         avi->passenger_capacity = grf_load_word(&buf);
    01049         break;
    01050
    01051       case 0x11: // Mail capacity
    01052         avi->mail_capacity = grf_load_byte(&buf);
    01053         break;
    01054
    01055       case 0x12: // SFX
    01056         avi->sfx = (SoundFx)grf_load_byte(&buf);
    01057         break;
    01058
    01059       case 0x13: // Cargos available for refitting
    01060         ei->refit_mask = grf_load_dword(&buf);
    01061         break;
    01062
    01063       case 0x14: // Callback mask
    01064         ei->callbackmask = grf_load_byte(&buf);
    01065         break;
    01066
    01067       case 0x15: // Refit cost
    01068         ei->refit_cost = grf_load_byte(&buf);
    01069         break;
    01070
    01071       case 0x16: // Retire vehicle early
    01072         ei->retire_early = grf_load_byte(&buf);
    01073         break;
    01074
    01075       case 0x17: // Miscellaneous flags
    01076         ei->misc_flags = grf_load_byte(&buf);
    01077         _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
    01078         break;
    01079
    01080       case 0x18: // Cargo classes allowed
    01081         _gted[e->index].cargo_allowed = grf_load_word(&buf);
    01082         break;
    01083
    01084       case 0x19: // Cargo classes disallowed
    01085         _gted[e->index].cargo_disallowed = grf_load_word(&buf);
    01086         break;
    01087
    01088       case 0x1A: // Long format introduction date (days since year 0)
    01089         ei->base_intro = grf_load_dword(&buf);
    01090         break;
    01091
    01092       case 0x1B: // Alter purchase list sort order
    01093         AlterVehicleListOrder(e->index, grf_load_extended(&buf));
    01094         break;
    01095
    01096       default:
    01097         ret = CommonVehicleChangeInfo(ei, prop, &buf);
    01098         break;
    01099     }
    01100   }
    01101
    01102   *bufp = buf;
    01103   return ret;
    01104 }
    01105
    01106 static ChangeInfoResult StationChangeInfo(uint stid, int numinfo, int prop, byte **bufp, int len)
    01107 {
    01108   byte *buf = *bufp;
    01109   ChangeInfoResult ret = CIR_SUCCESS;
    01110
    01111   if (stid + numinfo > MAX_STATIONS) {
    01112     grfmsg(1, "StationChangeInfo: Station %u is invalid, max %u, ignoring", stid + numinfo, MAX_STATIONS);
    01113     return CIR_INVALID_ID;
    01114   }
    01115
    01116   /* Allocate station specs if necessary */
    01117   if (_cur_grffile->stations == NULL) _cur_grffile->stations = CallocT<StationSpec*>(MAX_STATIONS);
    01118
    01119   for (int i = 0; i < numinfo; i++) {
    01120     StationSpec *statspec = _cur_grffile->stations[stid + i];
    01121
    01122     /* Check that the station we are modifying is defined. */
    01123     if (statspec == NULL && prop != 0x08) {
    01124       grfmsg(2, "StationChangeInfo: Attempt to modify undefined station %u, ignoring", stid + i);
    01125       return CIR_INVALID_ID;
    01126     }
    01127
    01128     switch (prop) {
    01129       case 0x08: { // Class ID
    01130         StationSpec **spec = &_cur_grffile->stations[stid + i];
    01131
    01132         /* Property 0x08 is special; it is where the station is allocated */
    01133         if (*spec == NULL) *spec = CallocT<StationSpec>(1);
    01134
    01135         /* Swap classid because we read it in BE meaning WAYP or DFLT */
    01136         uint32 classid = grf_load_dword(&buf);
    01137         (*spec)->sclass = AllocateStationClass(BSWAP32(classid));
    01138       } break;
    01139
    01140       case 0x09: // Define sprite layout
    01141         statspec->tiles = grf_load_extended(&buf);
    01142         statspec->renderdata = CallocT<DrawTileSprites>(statspec->tiles);
    01143         statspec->copied_renderdata = false;
    01144
    01145         for (uint t = 0; t < statspec->tiles; t++) {
    01146           DrawTileSprites *dts = &statspec->renderdata[t];
    01147           uint seq_count = 0;
    01148
    01149           dts->seq = NULL;
    01150           dts->ground.sprite = grf_load_word(&buf);
    01151           dts->ground.pal = grf_load_word(&buf);
    01152           if (dts->ground.sprite == 0) continue;
    01153           if (HasBit(dts->ground.pal, 15)) {
    01154             ClrBit(dts->ground.pal, 15);
    01155             SetBit(dts->ground.sprite, SPRITE_MODIFIER_USE_OFFSET);
    01156           }
    01157
    01158           MapSpriteMappingRecolour(&dts->ground);
    01159
    01160           while (buf < *bufp + len) {
    01161             DrawTileSeqStruct *dtss;
    01162
    01163             /* no relative bounding box support */
    01164             dts->seq = ReallocT((DrawTileSeqStruct*)dts->seq, ++seq_count);
    01165             dtss = (DrawTileSeqStruct*) &dts->seq[seq_count - 1];
    01166
    01167             dtss->delta_x = grf_load_byte(&buf);
    01168             if ((byte) dtss->delta_x == 0x80) break;
    01169             dtss->delta_y = grf_load_byte(&buf);
    01170             dtss->delta_z = grf_load_byte(&buf);
    01171             dtss->size_x = grf_load_byte(&buf);
    01172             dtss->size_y = grf_load_byte(&buf);
    01173             dtss->size_z = grf_load_byte(&buf);
    01174             dtss->image.sprite = grf_load_word(&buf);
    01175             dtss->image.pal = grf_load_word(&buf);
    01176
    01177             /* Remap flags as ours collide */
    01178             if (HasBit(dtss->image.pal, 15)) {
    01179               ClrBit(dtss->image.pal, 15);
    01180               SetBit(dtss->image.sprite, SPRITE_MODIFIER_USE_OFFSET);
    01181             }
    01182
    01183             MapSpriteMappingRecolour(&dtss->image);
    01184           }
    01185         }
    01186         break;
    01187
    01188       case 0x0A: { // Copy sprite layout
    01189         byte srcid = grf_load_byte(&buf);
    01190         const StationSpec *srcstatspec = _cur_grffile->stations[srcid];
    01191
    01192         statspec->tiles = srcstatspec->tiles;
    01193         statspec->renderdata = srcstatspec->renderdata;
    01194         statspec->copied_renderdata = true;
    01195       } break;
    01196
    01197       case 0x0B: // Callback mask
    01198         statspec->callbackmask = grf_load_byte(&buf);
    01199         break;
    01200
    01201       case 0x0C: // Disallowed number of platforms
    01202         statspec->disallowed_platforms = grf_load_byte(&buf);
    01203         break;
    01204
    01205       case 0x0D: // Disallowed platform lengths
    01206         statspec->disallowed_lengths = grf_load_byte(&buf);
    01207         break;
    01208
    01209       case 0x0E: // Define custom layout
    01210         statspec->copied_layouts = false;
    01211
    01212         while (buf < *bufp + len) {
    01213           byte length = grf_load_byte(&buf);
    01214           byte number = grf_load_byte(&buf);
    01215           StationLayout layout;
    01216           uint l, p;
    01217
    01218           if (length == 0 || number == 0) break;
    01219
    01220           if (length > statspec->lengths) {
    01221             statspec->platforms = ReallocT(statspec->platforms, length);
    01222             memset(statspec->platforms + statspec->lengths, 0, length - statspec->lengths);
    01223
    01224             statspec->layouts = ReallocT(statspec->layouts, length);
    01225             memset(statspec->layouts + statspec->lengths, 0,
    01226                    (length - statspec->lengths) * sizeof(*statspec->layouts));
    01227
    01228             statspec->lengths = length;
    01229           }
    01230           l = length - 1; // index is zero-based
    01231
    01232           if (number > statspec->platforms[l]) {
    01233             statspec->layouts[l] = ReallocT(statspec->layouts[l], number);
    01234             /* We expect NULL being 0 here, but C99 guarantees that. */
    01235             memset(statspec->layouts[l] + statspec->platforms[l], 0,
    01236                    (number - statspec->platforms[l]) * sizeof(**statspec->layouts));
    01237
    01238             statspec->platforms[l] = number;
    01239           }
    01240
    01241           p = 0;
    01242           layout = MallocT<byte>(length * number);
    01243           for (l = 0; l < length; l++) {
    01244             for (p = 0; p < number; p++) {
    01245               layout[l * number + p] = grf_load_byte(&buf);
    01246             }
    01247           }
    01248
    01249           l--;
    01250           p--;
    01251           free(statspec->layouts[l][p]);
    01252           statspec->layouts[l][p] = layout;
    01253         }
    01254         break;
    01255
    01256       case 0x0F: { // Copy custom layout
    01257         byte srcid = grf_load_byte(&buf);
    01258         const StationSpec *srcstatspec = _cur_grffile->stations[srcid];
    01259
    01260         statspec->lengths   = srcstatspec->lengths;
    01261         statspec->platforms = srcstatspec->platforms;
    01262         statspec->layouts   = srcstatspec->layouts;
    01263         statspec->copied_layouts = true;
    01264       } break;
    01265
    01266       case 0x10: // Little/lots cargo threshold
    01267         statspec->cargo_threshold = grf_load_word(&buf);
    01268         break;
    01269
    01270       case 0x11: // Pylon placement
    01271         statspec->pylons = grf_load_byte(&buf);
    01272         break;
    01273
    01274       case 0x12: // Cargo types for random triggers
    01275         statspec->cargo_triggers = grf_load_dword(&buf);
    01276         break;
    01277
    01278       case 0x13: // General flags
    01279         statspec->flags = grf_load_byte(&buf);
    01280         break;
    01281
    01282       case 0x14: // Overhead wire placement
    01283         statspec->wires = grf_load_byte(&buf);
    01284         break;
    01285
    01286       case 0x15: // Blocked tiles
    01287         statspec->blocked = grf_load_byte(&buf);
    01288         break;
    01289
    01290       case 0x16: // Animation info
    01291         statspec->anim_frames = grf_load_byte(&buf);
    01292         statspec->anim_status = grf_load_byte(&buf);
    01293         break;
    01294
    01295       case 0x17: // Animation speed
    01296         statspec->anim_speed = grf_load_byte(&buf);
    01297         break;
    01298
    01299       case 0x18: // Animation triggers
    01300         statspec->anim_triggers = grf_load_word(&buf);
    01301         break;
    01302
    01303       default:
    01304         ret = CIR_UNKNOWN;
    01305         break;
    01306     }
    01307   }
    01308
    01309   *bufp = buf;
    01310   return ret;
    01311 }
    01312
    01313 static ChangeInfoResult CanalChangeInfo(uint id, int numinfo, int prop, byte **bufp, int len)
    01314 {
    01315   byte *buf = *bufp;
    01316   ChangeInfoResult ret = CIR_SUCCESS;
    01317
    01318   if (id + numinfo > CF_END) {
    01319     grfmsg(1, "CanalChangeInfo: Canal feature %u is invalid, max %u, ignoreing", id + numinfo, CF_END);
    01320     return CIR_INVALID_ID;
    01321   }
    01322
    01323   for (int i = 0; i < numinfo; i++) {
    01324     WaterFeature *wf = &_water_feature[id + i];
    01325
    01326     switch (prop) {
    01327       case 0x08:
    01328         wf->callbackmask = grf_load_byte(&buf);
    01329         break;
    01330
    01331       case 0x09:
    01332         wf->flags = grf_load_byte(&buf);
    01333         break;
    01334
    01335       default:
    01336         ret = CIR_UNKNOWN;
    01337         break;
    01338     }
    01339   }
    01340
    01341   *bufp = buf;
    01342   return ret;
    01343 }
    01344
    01345 static ChangeInfoResult BridgeChangeInfo(uint brid, int numinfo, int prop, byte **bufp, int len)
    01346 {
    01347   byte *buf = *bufp;
    01348   ChangeInfoResult ret = CIR_SUCCESS;
    01349
    01350   if (brid + numinfo > MAX_BRIDGES) {
    01351     grfmsg(1, "BridgeChangeInfo: Bridge %u is invalid, max %u, ignoring", brid + numinfo, MAX_BRIDGES);
    01352     return CIR_INVALID_ID;
    01353   }
    01354
    01355   for (int i = 0; i < numinfo; i++) {
    01356     BridgeSpec *bridge = &_bridge[brid + i];
    01357
    01358     switch (prop) {
    01359       case 0x08: { // Year of availability
    01360         /* We treat '0' as always available */
    01361         byte year = grf_load_byte(&buf);
    01362         bridge->avail_year = (year > 0 ? ORIGINAL_BASE_YEAR + year : 0);
    01363         break;
    01364       }
    01365
    01366       case 0x09: // Minimum length
    01367         bridge->min_length = grf_load_byte(&buf);
    01368         break;
    01369
    01370       case 0x0A: // Maximum length
    01371         bridge->max_length = grf_load_byte(&buf);
    01372         break;
    01373
    01374       case 0x0B: // Cost factor
    01375         bridge->price = grf_load_byte(&buf);
    01376         break;
    01377
    01378       case 0x0C: // Maximum speed
    01379         bridge->speed = grf_load_word(&buf);
    01380         break;
    01381
    01382       case 0x0D: { // Bridge sprite tables
    01383         byte tableid = grf_load_byte(&buf);
    01384         byte numtables = grf_load_byte(&buf);
    01385
    01386         if (bridge->sprite_table == NULL) {
    01387           /* Allocate memory for sprite table pointers and zero out */
    01388           bridge->sprite_table = CallocT<PalSpriteID*>(7);
    01389         }
    01390
    01391         for (; numtables-- != 0; tableid++) {
    01392           if (tableid >= 7) { // skip invalid data
    01393             grfmsg(1, "BridgeChangeInfo: Table %d >= 7, skipping", tableid);
    01394             for (byte sprite = 0; sprite < 32; sprite++) grf_load_dword(&buf);
    01395             continue;
    01396           }
    01397
    01398           if (bridge->sprite_table[tableid] == NULL) {
    01399             bridge->sprite_table[tableid] = MallocT<PalSpriteID>(32);
    01400           }
    01401
    01402           for (byte sprite = 0; sprite < 32; sprite++) {
    01403             SpriteID image = grf_load_word(&buf);
    01404             SpriteID pal   = grf_load_word(&buf);
    01405
    01406             bridge->sprite_table[tableid][sprite].sprite = image;
    01407             bridge->sprite_table[tableid][sprite].pal    = pal;
    01408
    01409             MapSpriteMappingRecolour(&bridge->sprite_table[tableid][sprite]);
    01410           }
    01411         }
    01412       } break;
    01413
    01414       case 0x0E: // Flags; bit 0 - disable far pillars
    01415         bridge->flags = grf_load_byte(&buf);
    01416         break;
    01417
    01418       case 0x0F: // Long format year of availability (year since year 0)
    01419         bridge->avail_year = Clamp(grf_load_dword(&buf), MIN_YEAR, MAX_YEAR);
    01420         break;
    01421
    01422       case 0x10: { // purchase string
    01423         StringID newone = GetGRFStringID(_cur_grffile->grfid, grf_load_word(&buf));
    01424         if (newone != STR_UNDEFINED) bridge->material = newone;
    01425         } break;
    01426
    01427       case 0x11: // description of bridge with rails or roads
    01428       case 0x12: {
    01429         StringID newone = GetGRFStringID(_cur_grffile->grfid, grf_load_word(&buf));
    01430         if (newone != STR_UNDEFINED) bridge->transport_name[prop - 0x11] = newone;
    01431         } break;
    01432
    01433       case 0x13: // 16 bits cost multiplier
    01434         bridge->price = grf_load_word(&buf);
    01435         break;
    01436
    01437       default:
    01438         ret = CIR_UNKNOWN;
    01439         break;
    01440     }
    01441   }
    01442
    01443   *bufp = buf;
    01444   return ret;
    01445 }
    01446
    01447 static ChangeInfoResult TownHouseChangeInfo(uint hid, int numinfo, int prop, byte **bufp, int len)
    01448 {
    01449   byte *buf = *bufp;
    01450   ChangeInfoResult ret = CIR_SUCCESS;
    01451
    01452   if (hid + numinfo > HOUSE_MAX) {
    01453     grfmsg(1, "TownHouseChangeInfo: Too many houses loaded (%u), max (%u). Ignoring.", hid + numinfo, HOUSE_MAX);
    01454     return CIR_INVALID_ID;
    01455   }
    01456
    01457   /* Allocate house specs if they haven't been allocated already. */
    01458   if (_cur_grffile->housespec == NULL) {
    01459     _cur_grffile->housespec = CallocT<HouseSpec*>(HOUSE_MAX);
    01460   }
    01461
    01462   for (int i = 0; i < numinfo; i++) {
    01463     HouseSpec *housespec = _cur_grffile->housespec[hid + i];
    01464
    01465     if (prop != 0x08 && housespec == NULL) {
    01466       grfmsg(2, "TownHouseChangeInfo: Attempt to modify undefined house %u. Ignoring.", hid + i);
    01467       return CIR_INVALID_ID;
    01468     }
    01469
    01470     switch (prop) {
    01471       case 0x08: { // Substitute building type, and definition of a new house
    01472         HouseSpec **house = &_cur_grffile->housespec[hid + i];
    01473         byte subs_id = grf_load_byte(&buf);
    01474
    01475         if (subs_id == 0xFF) {
    01476           /* Instead of defining a new house, a substitute house id
    01477            * of 0xFF disables the old house with the current id. */
    01478           _house_specs[hid + i].enabled = false;
    01479           continue;
    01480         } else if (subs_id >= NEW_HOUSE_OFFSET) {
    01481           /* The substitute id must be one of the original houses. */
    01482           grfmsg(2, "TownHouseChangeInfo: Attempt to use new house %u as substitute house for %u. Ignoring.", subs_id, hid + i);
    01483           continue;
    01484         }
    01485
    01486         /* Allocate space for this house. */
    01487         if (*house == NULL) *house = CallocT<HouseSpec>(1);
    01488
    01489         housespec = *house;
    01490
    01491         memcpy(housespec, &_house_specs[subs_id], sizeof(_house_specs[subs_id]));
    01492
    01493         housespec->enabled = true;
    01494         housespec->local_id = hid + i;
    01495         housespec->substitute_id = subs_id;
    01496         housespec->grffile = _cur_grffile;
    01497         housespec->random_colour[0] = 0x04;  // those 4 random colours are the base colour
    01498         housespec->random_colour[1] = 0x08;  // for all new houses
    01499         housespec->random_colour[2] = 0x0C;  // they stand for red, blue, orange and green
    01500         housespec->random_colour[3] = 0x06;
    01501
    01502         /* Make sure that the third cargo type is valid in this
    01503          * climate. This can cause problems when copying the properties
    01504          * of a house that accepts food, where the new house is valid
    01505          * in the temperate climate. */
    01506         if (!GetCargo(housespec->accepts_cargo[2])->IsValid()) {
    01507           housespec->cargo_acceptance[2] = 0;
    01508         }
    01509
    01515         if (housespec->min_year < 1930) housespec->min_year = 1930;
    01516
    01517         _loaded_newgrf_features.has_newhouses = true;
    01518       } break;
    01519
    01520       case 0x09: // Building flags
    01521         housespec->building_flags = (BuildingFlags)grf_load_byte(&buf);
    01522         break;
    01523
    01524       case 0x0A: { // Availability years
    01525         uint16 years = grf_load_word(&buf);
    01526         housespec->min_year = GB(years, 0, 8) > 150 ? MAX_YEAR : ORIGINAL_BASE_YEAR + GB(years, 0, 8);
    01527         housespec->max_year = GB(years, 8, 8) > 150 ? MAX_YEAR : ORIGINAL_BASE_YEAR + GB(years, 8, 8);
    01528       } break;
    01529
    01530       case 0x0B: // Population
    01531         housespec->population = grf_load_byte(&buf);
    01532         break;
    01533
    01534       case 0x0C: // Mail generation multiplier
    01535         housespec->mail_generation = grf_load_byte(&buf);
    01536         break;
    01537
    01538       case 0x0D: // Passenger acceptance
    01539       case 0x0E: // Mail acceptance
    01540         housespec->cargo_acceptance[prop - 0x0D] = grf_load_byte(&buf);
    01541         break;
    01542
    01543       case 0x0F: { // Goods/candy, food/fizzy drinks acceptance
    01544         int8 goods = grf_load_byte(&buf);
    01545
    01546         /* If value of goods is negative, it means in fact food or, if in toyland, fizzy_drink acceptance.
    01547          * Else, we have "standard" 3rd cargo type, goods or candy, for toyland once more */
    01548         CargoID cid = (goods >= 0) ? ((_settings_game.game_creation.landscape == LT_TOYLAND) ? CT_CANDY : CT_GOODS) :
    01549             ((_settings_game.game_creation.landscape == LT_TOYLAND) ? CT_FIZZY_DRINKS : CT_FOOD);
    01550
    01551         /* Make sure the cargo type is valid in this climate. */
    01552         if (!GetCargo(cid)->IsValid()) goods = 0;
    01553
    01554         housespec->accepts_cargo[2] = cid;
    01555         housespec->cargo_acceptance[2] = abs(goods); // but we do need positive value here
    01556       } break;
    01557
    01558       case 0x10: // Local authority rating decrease on removal
    01559         housespec->remove_rating_decrease = grf_load_word(&buf);
    01560         break;
    01561
    01562       case 0x11: // Removal cost multiplier
    01563         housespec->removal_cost = grf_load_byte(&buf);
    01564         break;
    01565
    01566       case 0x12: // Building name ID
    01567         housespec->building_name = grf_load_word(&buf);
    01568         _string_to_grf_mapping[&housespec->building_name] = _cur_grffile->grfid;
    01569         break;
    01570
    01571       case 0x13: // Building availability mask
    01572         housespec->building_availability = (HouseZones)grf_load_word(&buf);
    01573         break;
    01574
    01575       case 0x14: // House callback flags
    01576         housespec->callback_mask = grf_load_byte(&buf);
    01577         break;
    01578
    01579       case 0x15: { // House override byte
    01580         byte override = grf_load_byte(&buf);
    01581
    01582         /* The house being overridden must be an original house. */
    01583         if (override >= NEW_HOUSE_OFFSET) {
    01584           grfmsg(2, "TownHouseChangeInfo: Attempt to override new house %u with house id %u. Ignoring.", override, hid + i);
    01585           continue;
    01586         }
    01587
    01588         _house_mngr.Add(hid + i, _cur_grffile->grfid, override);
    01589       } break;
    01590
    01591       case 0x16: // Periodic refresh multiplier
    01592         housespec->processing_time = grf_load_byte(&buf);
    01593         break;
    01594
    01595       case 0x17: // Four random colours to use
    01596         for (uint j = 0; j < 4; j++) housespec->random_colour[j] = grf_load_byte(&buf);
    01597         break;
    01598
    01599       case 0x18: // Relative probability of appearing
    01600         housespec->probability = grf_load_byte(&buf);
    01601         break;
    01602
    01603       case 0x19: // Extra flags
    01604         housespec->extra_flags = (HouseExtraFlags)grf_load_byte(&buf);
    01605         break;
    01606
    01607       case 0x1A: // Animation frames
    01608         housespec->animation_frames = grf_load_byte(&buf);
    01609         break;
    01610
    01611       case 0x1B: // Animation speed
    01612         housespec->animation_speed = Clamp(grf_load_byte(&buf), 2, 16);
    01613         break;
    01614
    01615       case 0x1C: // Class of the building type
    01616         housespec->class_id = AllocateHouseClassID(grf_load_byte(&buf), _cur_grffile->grfid);
    01617         break;
    01618
    01619       case 0x1D: // Callback flags 2
    01620         housespec->callback_mask |= (grf_load_byte(&buf) << 8);
    01621         break;
    01622
    01623       case 0x1E: { // Accepted cargo types
    01624         uint32 cargotypes = grf_load_dword(&buf);
    01625
    01626         /* Check if the cargo types should not be changed */
    01627         if (cargotypes == 0xFFFFFFFF) break;
    01628
    01629         for (uint j = 0; j < 3; j++) {
    01630           /* Get the cargo number from the 'list' */
    01631           uint8 cargo_part = GB(cargotypes, 8 * j, 8);
    01632           CargoID cargo = GetCargoTranslation(cargo_part, _cur_grffile);
    01633
    01634           if (cargo == CT_INVALID) {
    01635             /* Disable acceptance of invalid cargo type */
    01636             housespec->cargo_acceptance[j] = 0;
    01637           } else {
    01638             housespec->accepts_cargo[j] = cargo;
    01639           }
    01640         }
    01641       } break;
    01642
    01643       case 0x1F: // Minimum life span
    01644         housespec->minimum_life = grf_load_byte(&buf);
    01645         break;
    01646
    01647       case 0x20: { // @todo Cargo acceptance watch list
    01648         byte count = grf_load_byte(&buf);
    01649         for (byte j = 0; j < count; j++) grf_load_byte(&buf);
    01650         ret = CIR_UNHANDLED;
    01651       } break;
    01652
    01653       case 0x21: // long introduction year
    01654         housespec->min_year = grf_load_word(&buf);
    01655         break;
    01656
    01657       case 0x22: // long maximum year
    01658         housespec->max_year = grf_load_word(&buf);
    01659         break;
    01660
    01661       default:
    01662         ret = CIR_UNKNOWN;
    01663         break;
    01664     }
    01665   }
    01666
    01667   *bufp = buf;
    01668   return ret;
    01669 }
    01670
    01671 static ChangeInfoResult GlobalVarChangeInfo(uint gvid, int numinfo, int prop, byte **bufp, int len)
    01672 {
    01673   byte *buf = *bufp;
    01674   ChangeInfoResult ret = CIR_SUCCESS;
    01675
    01676   for (int i = 0; i < numinfo; i++) {
    01677     switch (prop) {
    01678       case 0x08: { // Cost base factor
    01679         byte factor = grf_load_byte(&buf);
    01680         uint price = gvid + i;
    01681
    01682         if (price < NUM_PRICES) {
    01683           SetPriceBaseMultiplier(price, factor);
    01684         } else {
    01685           grfmsg(1, "GlobalVarChangeInfo: Price %d out of range, ignoring", price);
    01686         }
    01687       } break;
    01688
    01689       case 0x09: // Cargo translation table
    01690         /* This is loaded during the reservation stage, so just skip it here. */
    01691         /* Each entry is 4 bytes. */
    01692         buf += 4;
    01693         break;
    01694
    01695       case 0x0A: { // Currency display names
    01696         uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
    01697         StringID newone = GetGRFStringID(_cur_grffile->grfid, grf_load_word(&buf));
    01698
    01699         if ((newone != STR_UNDEFINED) && (curidx < NUM_CURRENCY)) {
    01700           _currency_specs[curidx].name = newone;
    01701         }
    01702       } break;
    01703
    01704       case 0x0B: { // Currency multipliers
    01705         uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
    01706         uint32 rate = grf_load_dword(&buf);
    01707
    01708         if (curidx < NUM_CURRENCY) {
    01709           /* TTDPatch uses a multiple of 1000 for its conversion calculations,
    01710            * which OTTD does not. For this reason, divide grf value by 1000,
    01711            * to be compatible */
    01712           _currency_specs[curidx].rate = rate / 1000;
    01713         } else {
    01714           grfmsg(1, "GlobalVarChangeInfo: Currency multipliers %d out of range, ignoring", curidx);
    01715         }
    01716       } break;
    01717
    01718       case 0x0C: { // Currency options
    01719         uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
    01720         uint16 options = grf_load_word(&buf);
    01721
    01722         if (curidx < NUM_CURRENCY) {
    01723           _currency_specs[curidx].separator = GB(options, 0, 8);
    01724           /* By specifying only one bit, we prevent errors,
    01725            * since newgrf specs said that only 0 and 1 can be set for symbol_pos */
    01726           _currency_specs[curidx].symbol_pos = GB(options, 8, 1);
    01727         } else {
    01728           grfmsg(1, "GlobalVarChangeInfo: Currency option %d out of range, ignoring", curidx);
    01729         }
    01730       } break;
    01731
    01732       case 0x0D: { // Currency prefix symbol
    01733         uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
    01734         uint32 tempfix = grf_load_dword(&buf);
    01735
    01736         if (curidx < NUM_CURRENCY) {
    01737           memcpy(_currency_specs[curidx].prefix, &tempfix, 4);
    01738           _currency_specs[curidx].prefix[4] = 0;
    01739         } else {
    01740           grfmsg(1, "GlobalVarChangeInfo: Currency symbol %d out of range, ignoring", curidx);
    01741         }
    01742       } break;
    01743
    01744       case 0x0E: { // Currency suffix symbol
    01745         uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
    01746         uint32 tempfix = grf_load_dword(&buf);
    01747
    01748         if (curidx < NUM_CURRENCY) {
    01749           memcpy(&_currency_specs[curidx].suffix, &tempfix, 4);
    01750           _currency_specs[curidx].suffix[4] = 0;
    01751         } else {
    01752           grfmsg(1, "GlobalVarChangeInfo: Currency symbol %d out of range, ignoring", curidx);
    01753         }
    01754       } break;
    01755
    01756       case 0x0F: { //  Euro introduction dates
    01757         uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
    01758         Year year_euro = grf_load_word(&buf);
    01759
    01760         if (curidx < NUM_CURRENCY) {
    01761           _currency_specs[curidx].to_euro = year_euro;
    01762         } else {
    01763           grfmsg(1, "GlobalVarChangeInfo: Euro intro date %d out of range, ignoring", curidx);
    01764         }
    01765       } break;
    01766
    01767       case 0x10: // Snow line height table
    01768         if (numinfo > 1 || IsSnowLineSet()) {
    01769           grfmsg(1, "GlobalVarChangeInfo: The snowline can only be set once (%d)", numinfo);
    01770         } else if (len < SNOW_LINE_MONTHS * SNOW_LINE_DAYS) {
    01771           grfmsg(1, "GlobalVarChangeInfo: Not enough entries set in the snowline table (%d)", len);
    01772         } else {
    01773           byte table[SNOW_LINE_MONTHS][SNOW_LINE_DAYS];
    01774
    01775           for (uint i = 0; i < SNOW_LINE_MONTHS; i++) {
    01776             for (uint j = 0; j < SNOW_LINE_DAYS; j++) {
    01777               table[i][j] = grf_load_byte(&buf);
    01778             }
    01779           }
    01780           SetSnowLine(table);
    01781         }
    01782         break;
    01783
    01784       case 0x11: // GRF match for engine allocation
    01785         /* This is loaded during the reservation stage, so just skip it here. */
    01786         /* Each entry is 8 bytes. */
    01787         buf += 8;
    01788         break;
    01789
    01790       case 0x12: // Rail type translation table
    01791         /* This is loaded during the reservation stage, so just skip it here. */
    01792         /* Each entry is 4 bytes. */
    01793         buf += 4;
    01794         break;
    01795
    01796       default:
    01797         ret = CIR_UNKNOWN;
    01798         break;
    01799     }
    01800   }
    01801
    01802   *bufp = buf;
    01803   return ret;
    01804 }
    01805
    01806 static ChangeInfoResult GlobalVarReserveInfo(uint gvid, int numinfo, int prop, byte **bufp, int len)
    01807 {
    01808   byte *buf = *bufp;
    01809   ChangeInfoResult ret = CIR_SUCCESS;
    01810
    01811   for (int i = 0; i < numinfo; i++) {
    01812     switch (prop) {
    01813       case 0x08: // Cost base factor
    01814         grf_load_byte(&buf);
    01815         break;
    01816
    01817       case 0x09: { // Cargo Translation Table
    01818         if (i == 0) {
    01819           if (gvid != 0) {
    01820             grfmsg(1, "ReserveChangeInfo: Cargo translation table must start at zero");
    01821             return CIR_INVALID_ID;
    01822           }
    01823
    01824           free(_cur_grffile->cargo_list);
    01825           _cur_grffile->cargo_max = numinfo;
    01826           _cur_grffile->cargo_list = MallocT<CargoLabel>(numinfo);
    01827         }
    01828
    01829         CargoLabel cl = grf_load_dword(&buf);
    01830         _cur_grffile->cargo_list[i] = BSWAP32(cl);
    01831         break;
    01832       }
    01833
    01834       case 0x0A: // Currency display names
    01835       case 0x0C: // Currency options
    01836       case 0x0F: // Euro introduction dates
    01837         grf_load_word(&buf);
    01838         break;
    01839
    01840       case 0x0B: // Currency multipliers
    01841       case 0x0D: // Currency prefix symbol
    01842       case 0x0E: // Currency suffix symbol
    01843         grf_load_dword(&buf);
    01844         break;
    01845
    01846       case 0x10: // Snow line height table
    01847         buf += SNOW_LINE_MONTHS * SNOW_LINE_DAYS;
    01848         break;
    01849
    01850       case 0x11: { // GRF match for engine allocation
    01851         uint32 s = grf_load_dword(&buf);
    01852         uint32 t = grf_load_dword(&buf);
    01853         SetNewGRFOverride(s, t);
    01854         break;
    01855       }
    01856
    01857       case 0x12: { // Rail type translation table
    01858         if (i == 0) {
    01859           if (gvid != 0) {
    01860             grfmsg(1, "ReserveChangeInfo: Rail type translation table must start at zero");
    01861             return CIR_INVALID_ID;
    01862           }
    01863
    01864           free(_cur_grffile->railtype_list);
    01865           _cur_grffile->railtype_max = numinfo;
    01866           _cur_grffile->railtype_list = MallocT<RailTypeLabel>(numinfo);
    01867         }
    01868
    01869         RailTypeLabel rtl = grf_load_dword(&buf);
    01870         _cur_grffile->railtype_list[i] = BSWAP32(rtl);
    01871         break;
    01872       }
    01873
    01874       default:
    01875         ret = CIR_UNKNOWN;
    01876         break;
    01877     }
    01878   }
    01879
    01880   *bufp = buf;
    01881   return ret;
    01882 }
    01883
    01884
    01885 static ChangeInfoResult CargoChangeInfo(uint cid, int numinfo, int prop, byte **bufp, int len)
    01886 {
    01887   byte *buf = *bufp;
    01888   ChangeInfoResult ret = CIR_SUCCESS;
    01889
    01890   if (cid + numinfo > NUM_CARGO) {
    01891     grfmsg(2, "CargoChangeInfo: Cargo type %d out of range (max %d)", cid + numinfo, NUM_CARGO - 1);
    01892     return CIR_INVALID_ID;
    01893   }
    01894
    01895   for (int i = 0; i < numinfo; i++) {
    01896     CargoSpec *cs = &_cargo[cid + i];
    01897
    01898     switch (prop) {
    01899       case 0x08: // Bit number of cargo
    01900         cs->bitnum = grf_load_byte(&buf);
    01901         if (cs->IsValid()) {
    01902           cs->grffile = _cur_grffile;
    01903           SetBit(_cargo_mask, cid + i);
    01904         } else {
    01905           ClrBit(_cargo_mask, cid + i);
    01906         }
    01907         break;
    01908
    01909       case 0x09: // String ID for cargo type name
    01910         cs->name = grf_load_word(&buf);
    01911         _string_to_grf_mapping[&cs->name] = _cur_grffile->grfid;
    01912         break;
    01913
    01914       case 0x0A: // String for 1 unit of cargo
    01915         cs->name_single = grf_load_word(&buf);
    01916         _string_to_grf_mapping[&cs->name_single] = _cur_grffile->grfid;
    01917         break;
    01918
    01919       case 0x0B:
    01920         /* String for units of cargo. This is different in OpenTTD to TTDPatch
    01921          * (e.g. 10 tonnes of coal) */
    01922         cs->units_volume = grf_load_word(&buf);
    01923         _string_to_grf_mapping[&cs->units_volume] = _cur_grffile->grfid;
    01924         break;
    01925
    01926       case 0x0C: // String for quantity of cargo (e.g. 10 tonnes of coal)
    01927         cs->quantifier = grf_load_word(&buf);
    01928         _string_to_grf_mapping[&cs->quantifier] = _cur_grffile->grfid;
    01929         break;
    01930
    01931       case 0x0D: // String for two letter cargo abbreviation
    01932         cs->abbrev = grf_load_word(&buf);
    01933         _string_to_grf_mapping[&cs->abbrev] = _cur_grffile->grfid;
    01934         break;
    01935
    01936       case 0x0E: // Sprite ID for cargo icon
    01937         cs->sprite = grf_load_word(&buf);
    01938         break;
    01939
    01940       case 0x0F: // Weight of one unit of cargo
    01941         cs->weight = grf_load_byte(&buf);
    01942         break;
    01943
    01944       case 0x10: // Used for payment calculation
    01945         cs->transit_days[0] = grf_load_byte(&buf);
    01946         break;
    01947
    01948       case 0x11: // Used for payment calculation
    01949         cs->transit_days[1] = grf_load_byte(&buf);
    01950         break;
    01951
    01952       case 0x12: // Base cargo price
    01953         cs->initial_payment = grf_load_dword(&buf);
    01954         break;
    01955
    01956       case 0x13: // Colour for station rating bars
    01957         cs->rating_colour = MapDOSColour(grf_load_byte(&buf));
    01958         break;
    01959
    01960       case 0x14: // Colour for cargo graph
    01961         cs->legend_colour = MapDOSColour(grf_load_byte(&buf));
    01962         break;
    01963
    01964       case 0x15: // Freight status
    01965         cs->is_freight = (grf_load_byte(&buf) != 0);
    01966         break;
    01967
    01968       case 0x16: // Cargo classes
    01969         cs->classes = grf_load_word(&buf);
    01970         break;
    01971
    01972       case 0x17: // Cargo label
    01973         cs->label = grf_load_dword(&buf);
    01974         cs->label = BSWAP32(cs->label);
    01975         break;
    01976
    01977       case 0x18: { // Town growth substitute type
    01978         uint8 substitute_type = grf_load_byte(&buf);
    01979
    01980         switch (substitute_type) {
    01981           case 0x00: cs->town_effect = TE_PASSENGERS; break;
    01982           case 0x02: cs->town_effect = TE_MAIL; break;
    01983           case 0x05: cs->town_effect = TE_GOODS; break;
    01984           case 0x09: cs->town_effect = TE_WATER; break;
    01985           case 0x0B: cs->town_effect = TE_FOOD; break;
    01986           default:
    01987             grfmsg(1, "CargoChangeInfo: Unknown town growth substitute value %d, setting to none.", substitute_type);
    01988           case 0xFF: cs->town_effect = TE_NONE; break;
    01989         }
    01990       } break;
    01991
    01992       case 0x19: // Town growth coefficient
    01993         cs->multipliertowngrowth = grf_load_word(&buf);
    01994         break;
    01995
    01996       case 0x1A: // Bitmask of callbacks to use
    01997         cs->callback_mask = grf_load_byte(&buf);
    01998         break;
    01999
    02000       default:
    02001         ret = CIR_UNKNOWN;
    02002         break;
    02003     }
    02004   }
    02005
    02006   *bufp = buf;
    02007   return ret;
    02008 }
    02009
    02010
    02011 static ChangeInfoResult SoundEffectChangeInfo(uint sid, int numinfo, int prop, byte **bufp, int len)
    02012 {
    02013   byte *buf = *bufp;
    02014   ChangeInfoResult ret = CIR_SUCCESS;
    02015
    02016   if (_cur_grffile->sound_offset == 0) {
    02017     grfmsg(1, "SoundEffectChangeInfo: No effects defined, skipping");
    02018     return CIR_INVALID_ID;
    02019   }
    02020
    02021   for (int i = 0; i < numinfo; i++) {
    02022     uint sound = sid + i + _cur_grffile->sound_offset - GetNumOriginalSounds();
    02023
    02024     if (sound >= GetNumSounds()) {
    02025       grfmsg(1, "SoundEffectChangeInfo: Sound %d not defined (max %d)", sound, GetNumSounds());
    02026       return CIR_INVALID_ID;
    02027     }
    02028
    02029     switch (prop) {
    02030       case 0x08: // Relative volume
    02031         GetSound(sound)->volume = grf_load_byte(&buf);
    02032         break;
    02033
    02034       case 0x09: // Priority
    02035         GetSound(sound)->priority = grf_load_byte(&buf);
    02036         break;
    02037
    02038       case 0x0A: { // Override old sound
    02039         uint orig_sound = grf_load_byte(&buf);
    02040
    02041         if (orig_sound >= ORIGINAL_SAMPLE_COUNT) {
    02042           grfmsg(1, "SoundEffectChangeInfo: Original sound %d not defined (max %d)", orig_sound, ORIGINAL_SAMPLE_COUNT);
    02043         } else {
    02044           FileEntry *newfe = GetSound(sound);
    02045           FileEntry *oldfe = GetSound(orig_sound);
    02046
    02047           /* Literally copy the data of the new sound over the original */
    02048           *oldfe = *newfe;
    02049         }
    02050       } break;
    02051
    02052       default:
    02053         ret = CIR_UNKNOWN;
    02054         break;
    02055     }
    02056   }
    02057
    02058   *bufp = buf;
    02059   return ret;
    02060 }
    02061
    02062 static ChangeInfoResult IndustrytilesChangeInfo(uint indtid, int numinfo, int prop, byte **bufp, int len)
    02063 {
    02064   byte *buf = *bufp;
    02065   ChangeInfoResult ret = CIR_SUCCESS;
    02066
    02067   if (indtid + numinfo > NUM_INDUSTRYTILES) {
    02068     grfmsg(1, "IndustryTilesChangeInfo: Too many industry tiles loaded (%u), max (%u). Ignoring.", indtid + numinfo, NUM_INDUSTRYTILES);
    02069     return CIR_INVALID_ID;
    02070   }
    02071
    02072   /* Allocate industry tile specs if they haven't been allocated already. */
    02073   if (_cur_grffile->indtspec == NULL) {
    02074     _cur_grffile->indtspec = CallocT<IndustryTileSpec*>(NUM_INDUSTRYTILES);
    02075   }
    02076
    02077   for (int i = 0; i < numinfo; i++) {
    02078     IndustryTileSpec *tsp = _cur_grffile->indtspec[indtid + i];
    02079
    02080     if (prop != 0x08 && tsp == NULL) {
    02081       grfmsg(2, "IndustryTilesChangeInfo: Attempt to modify undefined industry tile %u. Ignoring.", indtid + i);
    02082       return CIR_INVALID_ID;
    02083     }
    02084
    02085     switch (prop) {
    02086       case 0x08: { // Substitute industry tile type
    02087         IndustryTileSpec **tilespec = &_cur_grffile->indtspec[indtid + i];
    02088         byte subs_id = grf_load_byte(&buf);
    02089
    02090         if (subs_id >= NEW_INDUSTRYTILEOFFSET) {
    02091           /* The substitute id must be one of the original industry tile. */
    02092           grfmsg(2, "IndustryTilesChangeInfo: Attempt to use new industry tile %u as substitute industry tile for %u. Ignoring.", subs_id, indtid + i);
    02093           continue;
    02094         }
    02095
    02096         /* Allocate space for this industry. */
    02097         if (*tilespec == NULL) {
    02098           int tempid;
    02099           *tilespec = CallocT<IndustryTileSpec>(1);
    02100           tsp = *tilespec;
    02101
    02102           memcpy(tsp, &_industry_tile_specs[subs_id], sizeof(_industry_tile_specs[subs_id]));
    02103           tsp->enabled = true;
    02104
    02105           /* A copied tile should not have the animation infos copied too.
    02106            * The anim_state should be left untouched, though
    02107            * It is up to the author to animate them himself */
    02108           tsp->anim_production = INDUSTRYTILE_NOANIM;
    02109           tsp->anim_next = INDUSTRYTILE_NOANIM;
    02110
    02111           tsp->grf_prop.local_id = indtid + i;
    02112           tsp->grf_prop.subst_id = subs_id;
    02113           tsp->grf_prop.grffile = _cur_grffile;
    02114           tempid = _industile_mngr.AddEntityID(indtid + i, _cur_grffile->grfid, subs_id); // pre-reserve the tile slot
    02115         }
    02116       } break;
    02117
    02118       case 0x09: { // Industry tile override
    02119         byte ovrid = grf_load_byte(&buf);
    02120
    02121         /* The industry being overridden must be an original industry. */
    02122         if (ovrid >= NEW_INDUSTRYTILEOFFSET) {
    02123           grfmsg(2, "IndustryTilesChangeInfo: Attempt to override new industry tile %u with industry tile id %u. Ignoring.", ovrid, indtid + i);
    02124           continue;
    02125         }
    02126
    02127         _industile_mngr.Add(indtid + i, _cur_grffile->grfid, ovrid);
    02128       } break;
    02129
    02130       case 0x0A: // Tile acceptance
    02131       case 0x0B:
    02132       case 0x0C: {
    02133         uint16 acctp = grf_load_word(&buf);
    02134         tsp->accepts_cargo[prop - 0x0A] = GetCargoTranslation(GB(acctp, 0, 8), _cur_grffile);
    02135         tsp->acceptance[prop - 0x0A] = GB(acctp, 8, 8);
    02136       } break;
    02137
    02138       case 0x0D: // Land shape flags
    02139         tsp->slopes_refused = (Slope)grf_load_byte(&buf);
    02140         break;
    02141
    02142       case 0x0E: // Callback flags
    02143         tsp->callback_flags = grf_load_byte(&buf);
    02144         break;
    02145
    02146       case 0x0F: // Animation information
    02147         tsp->animation_info = grf_load_word(&buf);
    02148         break;
    02149
    02150       case 0x10: // Animation speed
    02151         tsp->animation_speed = grf_load_byte(&buf);
    02152         break;
    02153
    02154       case 0x11: // Triggers for callback 25
    02155         tsp->animation_triggers = grf_load_byte(&buf);
    02156         break;
    02157
    02158       case 0x12: // Special flags
    02159         tsp->animation_special_flags = grf_load_byte(&buf);
    02160         break;
    02161
    02162       default:
    02163         ret = CIR_UNKNOWN;
    02164         break;
    02165     }
    02166   }
    02167
    02168   *bufp = buf;
    02169   return ret;
    02170 }
    02171
    02172 static ChangeInfoResult IndustriesChangeInfo(uint indid, int numinfo, int prop, byte **bufp, int len)
    02173 {
    02174   byte *buf = *bufp;
    02175   ChangeInfoResult ret = CIR_SUCCESS;
    02176
    02177   if (indid + numinfo > NUM_INDUSTRYTYPES) {
    02178     grfmsg(1, "IndustriesChangeInfo: Too many industries loaded (%u), max (%u). Ignoring.", indid + numinfo, NUM_INDUSTRYTYPES);
    02179     return CIR_INVALID_ID;
    02180   }
    02181
    02182   grfmsg(1, "IndustriesChangeInfo: newid %u", indid);
    02183
    02184   /* Allocate industry specs if they haven't been allocated already. */
    02185   if (_cur_grffile->industryspec == NULL) {
    02186     _cur_grffile->industryspec = CallocT<IndustrySpec*>(NUM_INDUSTRYTYPES);
    02187   }
    02188
    02189   for (int i = 0; i < numinfo; i++) {
    02190     IndustrySpec *indsp = _cur_grffile->industryspec[indid + i];
    02191
    02192     if (prop != 0x08 && indsp == NULL) {
    02193       grfmsg(2, "IndustriesChangeInfo: Attempt to modify undefined industry %u. Ignoring.", indid + i);
    02194       return CIR_INVALID_ID;
    02195     }
    02196
    02197     switch (prop) {
    02198       case 0x08: { // Substitute industry type
    02199         IndustrySpec **indspec = &_cur_grffile->industryspec[indid + i];
    02200         byte subs_id = grf_load_byte(&buf);
    02201
    02202         if (subs_id == 0xFF) {
    02203           /* Instead of defining a new industry, a substitute industry id
    02204            * of 0xFF disables the old industry with the current id. */
    02205           _industry_specs[indid + i].enabled = false;
    02206           continue;
    02207         } else if (subs_id >= NEW_INDUSTRYOFFSET) {
    02208           /* The substitute id must be one of the original industry. */
    02209           grfmsg(2, "_industry_specs: Attempt to use new industry %u as substitute industry for %u. Ignoring.", subs_id, indid + i);
    02210           continue;
    02211         }
    02212
    02213         /* Allocate space for this industry.
    02214          * Only need to do it once. If ever it is called again, it should not
    02215          * do anything */
    02216         if (*indspec == NULL) {
    02217           *indspec = CallocT<IndustrySpec>(1);
    02218           indsp = *indspec;
    02219
    02220           memcpy(indsp, &_origin_industry_specs[subs_id], sizeof(_industry_specs[subs_id]));
    02221           indsp->enabled = true;
    02222           indsp->grf_prop.local_id = indid + i;
    02223           indsp->grf_prop.subst_id = subs_id;
    02224           indsp->grf_prop.grffile = _cur_grffile;
    02225           /* If the grf industry needs to check its surounding upon creation, it should
    02226            * rely on callbacks, not on the original placement functions */
    02227           indsp->check_proc = CHECK_NOTHING;
    02228         }
    02229       } break;
    02230
    02231       case 0x09: { // Industry type override
    02232         byte ovrid = grf_load_byte(&buf);
    02233
    02234         /* The industry being overridden must be an original industry. */
    02235         if (ovrid >= NEW_INDUSTRYOFFSET) {
    02236           grfmsg(2, "IndustriesChangeInfo: Attempt to override new industry %u with industry id %u. Ignoring.", ovrid, indid + i);
    02237           continue;
    02238         }
    02239         indsp->grf_prop.override = ovrid;
    02240         _industry_mngr.Add(indid + i, _cur_grffile->grfid, ovrid);
    02241       } break;
    02242
    02243       case 0x0A: { // Set industry layout(s)
    02244         indsp->num_table = grf_load_byte(&buf); // Number of layaouts
    02245         uint32 defsize = grf_load_dword(&buf);  // Total size of the definition
    02246         IndustryTileTable **tile_table = CallocT<IndustryTileTable*>(indsp->num_table); // Table with tiles to compose an industry
    02247         IndustryTileTable *itt = CallocT<IndustryTileTable>(defsize); // Temporary array to read the tile layouts from the GRF
    02248         int size;
    02249         IndustryTileTable *copy_from;
    02250
    02251         for (byte j = 0; j < indsp->num_table; j++) {
    02252           for (int k = 0;; k++) {
    02253             itt[k].ti.x = grf_load_byte(&buf); // Offsets from northermost tile
    02254
    02255             if (itt[k].ti.x == 0xFE && k == 0) {
    02256               /* This means we have to borrow the layout from an old industry */
    02257               IndustryType type = grf_load_byte(&buf);  // industry holding required layout
    02258               byte laynbr = grf_load_byte(&buf);        // layout number to borrow
    02259
    02260               copy_from = (IndustryTileTable*)_origin_industry_specs[type].table[laynbr];
    02261               for (size = 1;; size++) {
    02262                 if (copy_from[size - 1].ti.x == -0x80 && copy_from[size - 1].ti.y == 0) break;
    02263               }
    02264               break;
    02265             }
    02266
    02267             itt[k].ti.y = grf_load_byte(&buf); // Or table definition finalisation
    02268
    02269             if (itt[k].ti.x == 0 && itt[k].ti.y == 0x80) {
    02270               /*  Not the same terminator.  The one we are using is rather
    02271                x= -80, y = x .  So, adjust it. */
    02272               itt[k].ti.x = -0x80;
    02273               itt[k].ti.y =  0;
    02274               itt[k].gfx  =  0;
    02275
    02276               size = k + 1;
    02277               copy_from = itt;
    02278               break;
    02279             }
    02280
    02281             itt[k].gfx = grf_load_byte(&buf);
    02282
    02283             if (itt[k].gfx == 0xFE) {
    02284               /* Use a new tile from this GRF */
    02285               int local_tile_id = grf_load_word(&buf);
    02286
    02287               /* Read the ID from the _industile_mngr. */
    02288               int tempid = _industile_mngr.GetID(local_tile_id, _cur_grffile->grfid);
    02289
    02290               if (tempid == INVALID_INDUSTRYTILE) {
    02291                 grfmsg(2, "IndustriesChangeInfo: Attempt to use industry tile %u with industry id %u, not yet defined. Ignoring.", local_tile_id, indid);
    02292               } else {
    02293                 /* Declared as been valid, can be used */
    02294                 itt[k].gfx = tempid;
    02295                 size = k + 1;
    02296                 copy_from = itt;
    02297               }
    02298             } else if (itt[k].gfx == 0xFF) {
    02299               itt[k].ti.x = (int8)GB(itt[k].ti.x, 0, 8);
    02300               itt[k].ti.y = (int8)GB(itt[k].ti.y, 0, 8);
    02301             }
    02302           }
    02303           tile_table[j] = CallocT<IndustryTileTable>(size);
    02304           memcpy(tile_table[j], copy_from, sizeof(*copy_from) * size);
    02305         }
    02306         /* Install final layout construction in the industry spec */
    02307         indsp->table = tile_table;
    02308         SetBit(indsp->cleanup_flag, 1);
    02309         free(itt);
    02310       } break;
    02311
    02312       case 0x0B: // Industry production flags
    02313         indsp->life_type = (IndustryLifeType)grf_load_byte(&buf);
    02314         break;
    02315
    02316       case 0x0C: // Industry closure message
    02317         indsp->closure_text = grf_load_word(&buf);
    02318         _string_to_grf_mapping[&indsp->closure_text] = _cur_grffile->grfid;
    02319         break;
    02320
    02321       case 0x0D: // Production increase message
    02322         indsp->production_up_text = grf_load_word(&buf);
    02323         _string_to_grf_mapping[&indsp->production_up_text] = _cur_grffile->grfid;
    02324         break;
    02325
    02326       case 0x0E: // Production decrease message
    02327         indsp->production_down_text = grf_load_word(&buf);
    02328         _string_to_grf_mapping[&indsp->production_down_text] = _cur_grffile->grfid;
    02329         break;
    02330
    02331       case 0x0F: // Fund cost multiplier
    02332         indsp->cost_multiplier = grf_load_byte(&buf);
    02333         break;
    02334
    02335       case 0x10: // Production cargo types
    02336         for (byte j = 0; j < 2; j++) {
    02337           indsp->produced_cargo[j] = GetCargoTranslation(grf_load_byte(&buf), _cur_grffile);
    02338         }
    02339         break;
    02340
    02341       case 0x11: // Acceptance cargo types
    02342         for (byte j = 0; j < 3; j++) {
    02343           indsp->accepts_cargo[j] = GetCargoTranslation(grf_load_byte(&buf), _cur_grffile);
    02344         }
    02345         grf_load_byte(&buf); // Unnused, eat it up
    02346         break;
    02347
    02348       case 0x12: // Production multipliers
    02349       case 0x13:
    02350         indsp->production_rate[prop - 0x12] = grf_load_byte(&buf);
    02351         break;
    02352
    02353       case 0x14: // Minimal amount of cargo distributed
    02354         indsp->minimal_cargo = grf_load_byte(&buf);
    02355         break;
    02356
    02357       case 0x15: { // Random sound effects
    02358         indsp->number_of_sounds = grf_load_byte(&buf);
    02359         uint8 *sounds = MallocT<uint8>(indsp->number_of_sounds);
    02360
    02361         for (uint8 j = 0; j < indsp->number_of_sounds; j++) sounds[j] = grf_load_byte(&buf);
    02362         indsp->random_sounds = sounds;
    02363         SetBit(indsp->cleanup_flag, 0);
    02364       } break;
    02365
    02366       case 0x16: // Conflicting industry types
    02367         for (byte j = 0; j < 3; j++) indsp->conflicting[j] = grf_load_byte(&buf);
    02368         break;
    02369
    02370       case 0x17: // Probability in random game
    02371         indsp->appear_creation[_settings_game.game_creation.landscape] = grf_load_byte(&buf);
    02372         break;
    02373
    02374       case 0x18: // Probability during gameplay
    02375         indsp->appear_ingame[_settings_game.game_creation.landscape] = grf_load_byte(&buf);
    02376         break;
    02377
    02378       case 0x19: // Map colour
    02379         indsp->map_colour = MapDOSColour(grf_load_byte(&buf));
    02380         break;
    02381
    02382       case 0x1A: // Special industry flags to define special behavior
    02383         indsp->behaviour = (IndustryBehaviour)grf_load_dword(&buf);
    02384         break;
    02385
    02386       case 0x1B: // New industry text ID
    02387         indsp->new_industry_text = grf_load_word(&buf);
    02388         _string_to_grf_mapping[&indsp->new_industry_text] = _cur_grffile->grfid;
    02389         break;
    02390
    02391       case 0x1C: // Input cargo multipliers for the three input cargo types
    02392       case 0x1D:
    02393       case 0x1E: {
    02394           uint32 multiples = grf_load_dword(&buf);
    02395           indsp->input_cargo_multiplier[prop - 0x1C][0] = GB(multiples, 0, 16);
    02396           indsp->input_cargo_multiplier[prop - 0x1C][1] = GB(multiples, 16, 16);
    02397         } break;
    02398
    02399       case 0x1F: // Industry name
    02400         indsp->name = grf_load_word(&buf);
    02401         _string_to_grf_mapping[&indsp->name] = _cur_grffile->grfid;
    02402         break;
    02403
    02404       case 0x20: // Prospecting success chance
    02405         indsp->prospecting_chance = grf_load_dword(&buf);
    02406         break;
    02407
    02408       case 0x21:   // Callback flags
    02409       case 0x22: { // Callback additional flags
    02410         byte aflag = grf_load_byte(&buf);
    02411         SB(indsp->callback_flags, (prop - 0x21) * 8, 8, aflag);
    02412       } break;
    02413
    02414       case 0x23: // removal cost multiplier
    02415         indsp->removal_cost_multiplier = grf_load_dword(&buf);
    02416         break;
    02417
    02418       case 0x24: // name for nearby station
    02419         indsp->station_name = grf_load_word(&buf);
    02420         _string_to_grf_mapping[&indsp->station_name] = _cur_grffile->grfid;
    02421         break;
    02422
    02423       default:
    02424         ret = CIR_UNKNOWN;
    02425         break;
    02426     }
    02427   }
    02428
    02429   *bufp = buf;
    02430   return ret;
    02431 }
    02432
    02433 static bool HandleChangeInfoResult(const char *caller, ChangeInfoResult cir, uint8 feature, uint8 property)
    02434 {
    02435   switch (cir) {
    02436     default: NOT_REACHED();
    02437
    02438     case CIR_SUCCESS:
    02439       return false;
    02440
    02441     case CIR_UNHANDLED:
    02442       grfmsg(1, "%s: Ignoring property 0x%02X of feature 0x%02X (not implemented)", caller, property, feature);
    02443       return false;
    02444
    02445     case CIR_UNKNOWN:
    02446       grfmsg(0, "%s: Unknown property 0x%02X of feature 0x%02X, disabling", caller, property, feature);
    02447       /* Fall through */
    02448
    02449     case CIR_INVALID_ID:
    02450       /* No debug message for an invalid ID, as it has already been output */
    02451       _skip_sprites = -1;
    02452       _cur_grfconfig->status = GCS_DISABLED;
    02453       _cur_grfconfig->error  = CallocT<GRFError>(1);
    02454       _cur_grfconfig->error->severity = STR_NEWGRF_ERROR_MSG_FATAL;
    02455       _cur_grfconfig->error->message  = (cir == CIR_INVALID_ID) ? STR_NEWGRF_ERROR_INVALID_ID : STR_NEWGRF_ERROR_UNKNOWN_PROPERTY;
    02456       return true;
    02457   }
    02458 }
    02459
    02460 /* Action 0x00 */
    02461 static void FeatureChangeInfo(byte *buf, size_t len)
    02462 {
    02463   byte *bufend = buf + len;
    02464
    02465   /* <00> <feature> <num-props> <num-info> <id> (<property <new-info>)...
    02466    *
    02467    * B feature       0, 1, 2 or 3 for trains, road vehicles, ships or planes
    02468    *                 4 for defining new train station sets
    02469    * B num-props     how many properties to change per vehicle/station
    02470    * B num-info      how many vehicles/stations to change
    02471    * E id            ID of first vehicle/station to change, if num-info is
    02472    *                 greater than one, this one and the following
    02473    *                 vehicles/stations will be changed
    02474    * B property      what property to change, depends on the feature
    02475    * V new-info      new bytes of info (variable size; depends on properties) */
    02476   /* TODO: Bridges, town houses. */
    02477
    02478   static const VCI_Handler handler[] = {
    02479     /* GSF_TRAIN */        RailVehicleChangeInfo,
    02480     /* GSF_ROAD */         RoadVehicleChangeInfo,
    02481     /* GSF_SHIP */         ShipVehicleChangeInfo,
    02482     /* GSF_AIRCRAFT */     AircraftVehicleChangeInfo,
    02483     /* GSF_STATION */      StationChangeInfo,
    02484     /* GSF_CANAL */        CanalChangeInfo,
    02485     /* GSF_BRIDGE */       BridgeChangeInfo,
    02486     /* GSF_TOWNHOUSE */    TownHouseChangeInfo,
    02487     /* GSF_GLOBALVAR */    GlobalVarChangeInfo,
    02488     /* GSF_INDUSTRYTILES */IndustrytilesChangeInfo,
    02489     /* GSF_INDUSTRIES */   IndustriesChangeInfo,
    02490     /* GSF_CARGOS */       NULL, // Cargo is handled during reservation
    02491     /* GSF_SOUNDFX */      SoundEffectChangeInfo,
    02492   };
    02493
    02494   if (!check_length(len, 6, "FeatureChangeInfo")) return;
    02495   buf++;
    02496   uint8 feature  = grf_load_byte(&buf);
    02497   uint8 numprops = grf_load_byte(&buf);
    02498   uint numinfo  = grf_load_byte(&buf);
    02499   uint engine   = grf_load_extended(&buf);
    02500
    02501   grfmsg(6, "FeatureChangeInfo: feature %d, %d properties, to apply to %d+%d",
    02502                  feature, numprops, engine, numinfo);
    02503
    02504   if (feature >= lengthof(handler) || handler[feature] == NULL) {
    02505     grfmsg(1, "FeatureChangeInfo: Unsupported feature %d, skipping", feature);
    02506     return;
    02507   }
    02508
    02509   while (numprops-- && buf < bufend) {
    02510     uint8 prop = grf_load_byte(&buf);
    02511
    02512     ChangeInfoResult cir = handler[feature](engine, numinfo, prop, &buf, bufend - buf);
    02513     if (HandleChangeInfoResult("FeatureChangeInfo", cir, feature, prop)) return;
    02514   }
    02515 }
    02516
    02517 /* Action 0x00 (GLS_SAFETYSCAN) */
    02518 static void SafeChangeInfo(byte *buf, size_t len)
    02519 {
    02520   if (!check_length(len, 6, "SafeChangeInfo")) return;
    02521   buf++;
    02522   uint8 feature  = grf_load_byte(&buf);
    02523   uint8 numprops = grf_load_byte(&buf);
    02524   uint numinfo = grf_load_byte(&buf);
    02525   grf_load_extended(&buf); // id
    02526
    02527   if (feature == GSF_BRIDGE && numprops == 1) {
    02528     uint8 prop = grf_load_byte(&buf);
    02529     /* Bridge property 0x0D is redefinition of sprite layout tables, which
    02530      * is considered safe. */
    02531     if (prop == 0x0D) return;
    02532   } else if (feature == GSF_GLOBALVAR && numprops == 1) {
    02533     uint8 prop = grf_load_byte(&buf);
    02534     /* Engine ID Mappings are safe, if the source is static */
    02535     if (prop == 0x11) {
    02536       bool is_safe = true;
    02537       for (uint i = 0; i < numinfo; i++) {
    02538         uint32 s = grf_load_dword(&buf);
    02539         grf_load_dword(&buf); // dest
    02540         const GRFConfig *grfconfig = GetGRFConfig(s);
    02541         if (grfconfig != NULL && !HasBit(grfconfig->flags, GCF_STATIC)) {
    02542           is_safe = false;
    02543           break;
    02544         }
    02545       }
    02546       if (is_safe) return;
    02547     }
    02548   }
    02549
    02550   SetBit(_cur_grfconfig->flags, GCF_UNSAFE);
    02551
    02552   /* Skip remainder of GRF */
    02553   _skip_sprites = -1;
    02554 }
    02555
    02556 /* Action 0x00 (GLS_RESERVE) */
    02557 static void ReserveChangeInfo(byte *buf, size_t len)
    02558 {
    02559   byte *bufend = buf + len;
    02560
    02561   if (!check_length(len, 6, "ReserveChangeInfo")) return;
    02562   buf++;
    02563   uint8 feature  = grf_load_byte(&buf);
    02564
    02565   if (feature != GSF_CARGOS && feature != GSF_GLOBALVAR) return;
    02566
    02567   uint8 numprops = grf_load_byte(&buf);
    02568   uint8 numinfo  = grf_load_byte(&buf);
    02569   uint8 index    = grf_load_extended(&buf);
    02570
    02571   while (numprops-- && buf < bufend) {
    02572     uint8 prop = grf_load_byte(&buf);
    02573     ChangeInfoResult cir = CIR_SUCCESS;
    02574
    02575     switch (feature) {
    02576       default: NOT_REACHED();
    02577       case GSF_CARGOS:
    02578         cir = CargoChangeInfo(index, numinfo, prop, &buf, bufend - buf);
    02579         break;
    02580
    02581       case GSF_GLOBALVAR:
    02582         cir = GlobalVarReserveInfo(index, numinfo, prop, &buf, bufend - buf);
    02583         break;
    02584     }
    02585
    02586     if (HandleChangeInfoResult("ReserveChangeInfo", cir, feature, prop)) return;
    02587   }
    02588 }
    02589
    02595 static const SpriteGroup *NewCallBackResultSpriteGroup(uint16 value)
    02596 {
    02597   SpriteGroup *group = AllocateSpriteGroup();
    02598
    02599   group->type = SGT_CALLBACK;
    02600
    02601   /* Old style callback results have the highest byte 0xFF so signify it is a callback result
    02602    * New style ones only have the highest bit set (allows 15-bit results, instead of just 8) */
    02603   if ((value >> 8) == 0xFF) {
    02604     value &= ~0xFF00;
    02605   } else {
    02606     value &= ~0x8000;
    02607   }
    02608
    02609   group->g.callback.result = value;
    02610
    02611   return group;
    02612 }
    02613
    02620 static const SpriteGroup *NewResultSpriteGroup(SpriteID sprite, byte num_sprites)
    02621 {
    02622   SpriteGroup *group = AllocateSpriteGroup();
    02623   group->type = SGT_RESULT;
    02624   group->g.result.sprite = sprite;
    02625   group->g.result.num_sprites = num_sprites;
    02626   return group;
    02627 }
    02628
    02629 /* Action 0x01 */
    02630 static void NewSpriteSet(byte *buf, size_t len)
    02631 {
    02632   /* <01> <feature> <num-sets> <num-ent>
    02633    *
    02634    * B feature       feature to define sprites for
    02635    *                 0, 1, 2, 3: veh-type, 4: train stations
    02636    * B num-sets      number of sprite sets
    02637    * E num-ent       how many entries per sprite set
    02638    *                 For vehicles, this is the number of different
    02639    *                         vehicle directions in each sprite set
    02640    *                         Set num-dirs=8, unless your sprites are symmetric.
    02641    *                         In that case, use num-dirs=4.
    02642    */
    02643
    02644   if (!check_length(len, 4, "NewSpriteSet")) return;
    02645   buf++;
    02646   uint8 feature   = grf_load_byte(&buf);
    02647   uint8 num_sets  = grf_load_byte(&buf);
    02648   uint16 num_ents = grf_load_extended(&buf);
    02649
    02650   _cur_grffile->spriteset_start = _cur_spriteid;
    02651   _cur_grffile->spriteset_feature = feature;
    02652   _cur_grffile->spriteset_numsets = num_sets;
    02653   _cur_grffile->spriteset_numents = num_ents;
    02654
    02655   grfmsg(7, "New sprite set at %d of type %d, consisting of %d sets with %d views each (total %d)",
    02656     _cur_spriteid, feature, num_sets, num_ents, num_sets * num_ents
    02657   );
    02658
    02659   for (int i = 0; i < num_sets * num_ents; i++) {
    02660     _nfo_line++;
    02661     LoadNextSprite(_cur_spriteid++, _file_index, _nfo_line);
    02662   }
    02663 }
    02664
    02665 /* Action 0x01 (SKIP) */
    02666 static void SkipAct1(byte *buf, size_t len)
    02667 {
    02668   if (!check_length(len, 4, "SkipAct1")) return;
    02669   buf++;
    02670   grf_load_byte(&buf);
    02671   uint8 num_sets  = grf_load_byte(&buf);
    02672   uint16 num_ents = grf_load_extended(&buf);
    02673
    02674   _skip_sprites = num_sets * num_ents;
    02675
    02676   grfmsg(3, "SkipAct1: Skipping %d sprites", _skip_sprites);
    02677 }
    02678
    02679 /* Helper function to either create a callback or link to a previously
    02680  * defined spritegroup. */
    02681 static const SpriteGroup *GetGroupFromGroupID(byte setid, byte type, uint16 groupid)
    02682 {
    02683   if (HasBit(groupid, 15)) return NewCallBackResultSpriteGroup(groupid);
    02684
    02685   if (groupid >= _cur_grffile->spritegroups_count || _cur_grffile->spritegroups[groupid] == NULL) {
    02686     grfmsg(1, "GetGroupFromGroupID(0x%02X:0x%02X): Groupid 0x%04X does not exist, leaving empty", setid, type, groupid);
    02687     return NULL;
    02688   }
    02689
    02690   return _cur_grffile->spritegroups[groupid];
    02691 }
    02692
    02693 /* Helper function to either create a callback or a result sprite group. */
    02694 static const SpriteGroup *CreateGroupFromGroupID(byte feature, byte setid, byte type, uint16 spriteid, uint16 num_sprites)
    02695 {
    02696   if (HasBit(spriteid, 15)) return NewCallBackResultSpriteGroup(spriteid);
    02697
    02698   if (spriteid >= _cur_grffile->spriteset_numsets) {
    02699     grfmsg(1, "CreateGroupFromGroupID(0x%02X:0x%02X): Sprite set %u invalid, max %u", setid, type, spriteid, _cur_grffile->spriteset_numsets);
    02700     return NULL;
    02701   }
    02702
    02703   /* Check if the sprite is within range. This can fail if the Action 0x01
    02704    * is skipped, as TTDPatch mandates that Action 0x02s must be processed.
    02705    * We don't have that rule, but must live by the Patch... */
    02706   if (_cur_grffile->spriteset_start + spriteid * num_sprites + num_sprites > _cur_spriteid) {
    02707     grfmsg(1, "CreateGroupFromGroupID(0x%02X:0x%02X): Real Sprite IDs 0x%04X - 0x%04X do not (all) exist (max 0x%04X), leaving empty",
    02708         setid, type,
    02709         _cur_grffile->spriteset_start + spriteid * num_sprites,
    02710         _cur_grffile->spriteset_start + spriteid * num_sprites + num_sprites - 1, _cur_spriteid - 1);
    02711     return NULL;
    02712   }
    02713
    02714   if (feature != _cur_grffile->spriteset_feature) {
    02715     grfmsg(1, "CreateGroupFromGroupID(0x%02X:0x%02X): Sprite set feature 0x%02X does not match action feature 0x%02X, skipping",
    02716         setid, type,
    02717         _cur_grffile->spriteset_feature, feature);
    02718     return NULL;
    02719   }
    02720
    02721   return NewResultSpriteGroup(_cur_grffile->spriteset_start + spriteid * num_sprites, num_sprites);
    02722 }
    02723
    02724 /* Action 0x02 */
    02725 static void NewSpriteGroup(byte *buf, size_t len)
    02726 {
    02727   /* <02> <feature> <set-id> <type/num-entries> <feature-specific-data...>
    02728    *
    02729    * B feature       see action 1
    02730    * B set-id        ID of this particular definition
    02731    * B type/num-entries
    02732    *                 if 80 or greater, this is a randomized or variational
    02733    *                 list definition, see below
    02734    *                 otherwise it specifies a number of entries, the exact
    02735    *                 meaning depends on the feature
    02736    * V feature-specific-data (huge mess, don't even look it up --pasky) */
    02737   SpriteGroup *group = NULL;
    02738   byte *bufend = buf + len;
    02739
    02740   if (!check_length(len, 5, "NewSpriteGroup")) return;
    02741   buf++;
    02742
    02743   uint8 feature = grf_load_byte(&buf);
    02744   uint8 setid   = grf_load_byte(&buf);
    02745   uint8 type    = grf_load_byte(&buf);
    02746
    02747   if (setid >= _cur_grffile->spritegroups_count) {
    02748     /* Allocate memory for new sprite group references. */
    02749     _cur_grffile->spritegroups = ReallocT(_cur_grffile->spritegroups, setid + 1);
    02750     /* Initialise new space to NULL */
    02751     for (; _cur_grffile->spritegroups_count < (setid + 1); _cur_grffile->spritegroups_count++)
    02752       _cur_grffile->spritegroups[_cur_grffile->spritegroups_count] = NULL;
    02753   }
    02754
    02755   switch (type) {
    02756     /* Deterministic Sprite Group */
    02757     case 0x81: // Self scope, byte
    02758     case 0x82: // Parent scope, byte
    02759     case 0x85: // Self scope, word
    02760     case 0x86: // Parent scope, word
    02761     case 0x89: // Self scope, dword
    02762     case 0x8A: // Parent scope, dword
    02763     {
    02764       byte varadjust;
    02765       byte varsize;
    02766
    02767       /* Check we can load the var size parameter */
    02768       if (!check_length(bufend - buf, 1, "NewSpriteGroup (Deterministic) (1)")) return;
    02769
    02770       group = AllocateSpriteGroup();
    02771       group->type = SGT_DETERMINISTIC;
    02772       group->g.determ.var_scope = HasBit(type, 1) ? VSG_SCOPE_PARENT : VSG_SCOPE_SELF;
    02773
    02774       switch (GB(type, 2, 2)) {
    02775         default: NOT_REACHED();
    02776         case 0: group->g.determ.size = DSG_SIZE_BYTE;  varsize = 1; break;
    02777         case 1: group->g.determ.size = DSG_SIZE_WORD;  varsize = 2; break;
    02778         case 2: group->g.determ.size = DSG_SIZE_DWORD; varsize = 4; break;
    02779       }
    02780
    02781       if (!check_length(bufend - buf, 5 + varsize, "NewSpriteGroup (Deterministic) (2)")) return;
    02782
    02783       /* Loop through the var adjusts. Unfortunately we don't know how many we have
    02784        * from the outset, so we shall have to keep reallocing. */
    02785       do {
    02786         DeterministicSpriteGroupAdjust *adjust;
    02787
    02788         if (group->g.determ.num_adjusts > 0) {
    02789           if (!check_length(bufend - buf, 2 + varsize + 3, "NewSpriteGroup (Deterministic) (3)")) return;
    02790         }
    02791
    02792         group->g.determ.num_adjusts++;
    02793         group->g.determ.adjusts = ReallocT(group->g.determ.adjusts, group->g.determ.num_adjusts);
    02794
    02795         adjust = &group->g.determ.adjusts[group->g.determ.num_adjusts - 1];
    02796
    02797         /* The first var adjust doesn't have an operation specified, so we set it to add. */
    02798         adjust->operation = group->g.determ.num_adjusts == 1 ? DSGA_OP_ADD : (DeterministicSpriteGroupAdjustOperation)grf_load_byte(&buf);
    02799         adjust->variable  = grf_load_byte(&buf);
    02800         if (adjust->variable == 0x7E) {
    02801           /* Link subroutine group */
    02802           adjust->subroutine = GetGroupFromGroupID(setid, type, grf_load_byte(&buf));
    02803         } else {
    02804           adjust->parameter = IsInsideMM(adjust->variable, 0x60, 0x80) ? grf_load_byte(&buf) : 0;
    02805         }
    02806
    02807         varadjust = grf_load_byte(&buf);
    02808         adjust->shift_num = GB(varadjust, 0, 5);
    02809         adjust->type      = (DeterministicSpriteGroupAdjustType)GB(varadjust, 6, 2);
    02810         adjust->and_mask  = grf_load_var(varsize, &buf);
    02811
    02812         if (adjust->type != DSGA_TYPE_NONE) {
    02813           adjust->add_val    = grf_load_var(varsize, &buf);
    02814           adjust->divmod_val = grf_load_var(varsize, &buf);
    02815         } else {
    02816           adjust->add_val    = 0;
    02817           adjust->divmod_val = 0;
    02818         }
    02819
    02820         /* Continue reading var adjusts while bit 5 is set. */
    02821       } while (HasBit(varadjust, 5));
    02822
    02823       group->g.determ.num_ranges = grf_load_byte(&buf);
    02824       if (group->g.determ.num_ranges > 0) group->g.determ.ranges = CallocT<DeterministicSpriteGroupRange>(group->g.determ.num_ranges);
    02825
    02826       if (!check_length(bufend - buf, 2 + (2 + 2 * varsize) * group->g.determ.num_ranges, "NewSpriteGroup (Deterministic)")) return;
    02827
    02828       for (uint i = 0; i < group->g.determ.num_ranges; i++) {
    02829         group->g.determ.ranges[i].group = GetGroupFromGroupID(setid, type, grf_load_word(&buf));
    02830         group->g.determ.ranges[i].low   = grf_load_var(varsize, &buf);
    02831         group->g.determ.ranges[i].high  = grf_load_var(varsize, &buf);
    02832       }
    02833
    02834       group->g.determ.default_group = GetGroupFromGroupID(setid, type, grf_load_word(&buf));
    02835       break;
    02836     }
    02837
    02838     /* Randomized Sprite Group */
    02839     case 0x80: // Self scope
    02840     case 0x83: // Parent scope
    02841     case 0x84: // Relative scope
    02842     {
    02843       if (!check_length(bufend - buf, HasBit(type, 2) ? 8 : 7, "NewSpriteGroup (Randomized) (1)")) return;
    02844
    02845       group = AllocateSpriteGroup();
    02846       group->type = SGT_RANDOMIZED;
    02847       group->g.random.var_scope = HasBit(type, 1) ? VSG_SCOPE_PARENT : VSG_SCOPE_SELF;
    02848
    02849       if (HasBit(type, 2)) {
    02850         if (feature <= GSF_AIRCRAFT) group->g.random.var_scope = VSG_SCOPE_RELATIVE;
    02851         group->g.random.count = grf_load_byte(&buf);
    02852       }
    02853
    02854       uint8 triggers = grf_load_byte(&buf);
    02855       group->g.random.triggers       = GB(triggers, 0, 7);
    02856       group->g.random.cmp_mode       = HasBit(triggers, 7) ? RSG_CMP_ALL : RSG_CMP_ANY;
    02857       group->g.random.lowest_randbit = grf_load_byte(&buf);
    02858       group->g.random.num_groups     = grf_load_byte(&buf);
    02859       group->g.random.groups = CallocT<const SpriteGroup*>(group->g.random.num_groups);
    02860
    02861       if (!check_length(bufend - buf, 2 * group->g.random.num_groups, "NewSpriteGroup (Randomized) (2)")) return;
    02862
    02863       for (uint i = 0; i < group->g.random.num_groups; i++) {
    02864         group->g.random.groups[i] = GetGroupFromGroupID(setid, type, grf_load_word(&buf));
    02865       }
    02866
    02867       break;
    02868     }
    02869
    02870     /* Neither a variable or randomized sprite group... must be a real group */
    02871     default:
    02872     {
    02873
    02874
    02875       switch (feature) {
    02876         case GSF_TRAIN:
    02877         case GSF_ROAD:
    02878         case GSF_SHIP:
    02879         case GSF_AIRCRAFT:
    02880         case GSF_STATION:
    02881         case GSF_CANAL:
    02882         case GSF_CARGOS:
    02883         {
    02884           byte sprites     = _cur_grffile->spriteset_numents;
    02885           byte num_loaded  = type;
    02886           byte num_loading = grf_load_byte(&buf);
    02887
    02888           if (_cur_grffile->spriteset_start == 0) {
    02889             grfmsg(0, "NewSpriteGroup: No sprite set to work on! Skipping");
    02890             return;
    02891           }
    02892
    02893           if (!check_length(bufend - buf, 2 * num_loaded + 2 * num_loading, "NewSpriteGroup (Real) (1)")) return;
    02894
    02895           group = AllocateSpriteGroup();
    02896           group->type = SGT_REAL;
    02897
    02898           group->g.real.num_loaded  = num_loaded;
    02899           group->g.real.num_loading = num_loading;
    02900           if (num_loaded  > 0) group->g.real.loaded = CallocT<const SpriteGroup*>(num_loaded);
    02901           if (num_loading > 0) group->g.real.loading = CallocT<const SpriteGroup*>(num_loading);
    02902
    02903           grfmsg(6, "NewSpriteGroup: New SpriteGroup 0x%02X, %u views, %u loaded, %u loading",
    02904               setid, sprites, num_loaded, num_loading);
    02905
    02906           for (uint i = 0; i < num_loaded; i++) {
    02907             uint16 spriteid = grf_load_word(&buf);
    02908             group->g.real.loaded[i] = CreateGroupFromGroupID(feature, setid, type, spriteid, sprites);
    02909             grfmsg(8, "NewSpriteGroup: + rg->loaded[%i]  = subset %u", i, spriteid);
    02910           }
    02911
    02912           for (uint i = 0; i < num_loading; i++) {
    02913             uint16 spriteid = grf_load_word(&buf);
    02914             group->g.real.loading[i] = CreateGroupFromGroupID(feature, setid, type, spriteid, sprites);
    02915             grfmsg(8, "NewSpriteGroup: + rg->loading[%i] = subset %u", i, spriteid);
    02916           }
    02917
    02918           break;
    02919         }
    02920
    02921         case GSF_TOWNHOUSE:
    02922         case GSF_INDUSTRYTILES: {
    02923           byte sprites     = _cur_grffile->spriteset_numents;
    02924           byte num_sprites = max((uint8)1, type);
    02925           uint i;
    02926
    02927           group = AllocateSpriteGroup();
    02928           group->type = SGT_TILELAYOUT;
    02929           group->g.layout.num_sprites = sprites;
    02930           group->g.layout.dts = CallocT<DrawTileSprites>(1);
    02931
    02932           /* Groundsprite */
    02933           group->g.layout.dts->ground.sprite = grf_load_word(&buf);
    02934           group->g.layout.dts->ground.pal    = grf_load_word(&buf);
    02935
    02936           /* Remap transparent/colour modifier bits */
    02937           MapSpriteMappingRecolour(&group->g.layout.dts->ground);
    02938
    02939           if (HasBit(group->g.layout.dts->ground.pal, 15)) {
    02940             /* Bit 31 set means this is a custom sprite, so rewrite it to the
    02941              * last spriteset defined. */
    02942             SpriteID sprite = _cur_grffile->spriteset_start + GB(group->g.layout.dts->ground.sprite, 0, 14) * sprites;
    02943             SB(group->g.layout.dts->ground.sprite, 0, SPRITE_WIDTH, sprite);
    02944             ClrBit(group->g.layout.dts->ground.pal, 15);
    02945           }
    02946
    02947           group->g.layout.dts->seq = CallocT<DrawTileSeqStruct>(num_sprites + 1);
    02948
    02949           for (i = 0; i < num_sprites; i++) {
    02950             DrawTileSeqStruct *seq = (DrawTileSeqStruct*)&group->g.layout.dts->seq[i];
    02951
    02952             seq->image.sprite = grf_load_word(&buf);
    02953             seq->image.pal   = grf_load_word(&buf);
    02954             seq->delta_x = grf_load_byte(&buf);
    02955             seq->delta_y = grf_load_byte(&buf);
    02956
    02957             MapSpriteMappingRecolour(&seq->image);
    02958
    02959             if (HasBit(seq->image.pal, 15)) {
    02960               /* Bit 31 set means this is a custom sprite, so rewrite it to the
    02961                * last spriteset defined. */
    02962               SpriteID sprite = _cur_grffile->spriteset_start + GB(seq->image.sprite, 0, 14) * sprites;
    02963               SB(seq->image.sprite, 0, SPRITE_WIDTH, sprite);
    02964               ClrBit(seq->image.pal, 15);
    02965             }
    02966
    02967             if (type > 0) {
    02968               seq->delta_z = grf_load_byte(&buf);
    02969               if ((byte)seq->delta_z == 0x80) continue;
    02970             }
    02971
    02972             seq->size_x = grf_load_byte(&buf);
    02973             seq->size_y = grf_load_byte(&buf);
    02974             seq->size_z = grf_load_byte(&buf);
    02975           }
    02976
    02977           /* Set the terminator value. */
    02978           ((DrawTileSeqStruct*)group->g.layout.dts->seq)[i].delta_x = (byte)0x80;
    02979
    02980           break;
    02981         }
    02982
    02983         case GSF_INDUSTRIES: {
    02984           if (type > 1) {
    02985             grfmsg(1, "NewSpriteGroup: Unsupported industry production version %d, skipping", type);
    02986             break;
    02987           }
    02988
    02989           group = AllocateSpriteGroup();
    02990           group->type = SGT_INDUSTRY_PRODUCTION;
    02991           group->g.indprod.version = type;
    02992           if (type == 0) {
    02993             for (uint i = 0; i < 3; i++) {
    02994               group->g.indprod.substract_input[i] = grf_load_word(&buf);
    02995             }
    02996             for (uint i = 0; i < 2; i++) {
    02997               group->g.indprod.add_output[i] = grf_load_word(&buf);
    02998             }
    02999             group->g.indprod.again = grf_load_byte(&buf);
    03000           } else {
    03001             for (uint i = 0; i < 3; i++) {
    03002               group->g.indprod.substract_input[i] = grf_load_byte(&buf);
    03003             }
    03004             for (uint i = 0; i < 2; i++) {
    03005               group->g.indprod.add_output[i] = grf_load_byte(&buf);
    03006             }
    03007             group->g.indprod.again = grf_load_byte(&buf);
    03008           }
    03009           break;
    03010         }
    03011
    03012         /* Loading of Tile Layout and Production Callback groups would happen here */
    03013         default: grfmsg(1, "NewSpriteGroup: Unsupported feature %d, skipping", feature);
    03014       }
    03015     }
    03016   }
    03017
    03018   _cur_grffile->spritegroups[setid] = group;
    03019 }
    03020
    03021 static CargoID TranslateCargo(uint8 feature, uint8 ctype)
    03022 {
    03023   /* Special cargo types for purchase list and stations */
    03024   if (feature == GSF_STATION && ctype == 0xFE) return CT_DEFAULT_NA;
    03025   if (ctype == 0xFF) return CT_PURCHASE;
    03026
    03027   if (_cur_grffile->cargo_max == 0) {
    03028     /* No cargo table, so use bitnum values */
    03029     if (ctype >= 32) {
    03030       grfmsg(1, "TranslateCargo: Cargo bitnum %d out of range (max 31), skipping.", ctype);
    03031       return CT_INVALID;
    03032     }
    03033
    03034     for (CargoID c = 0; c < NUM_CARGO; c++) {
    03035       const CargoSpec *cs = GetCargo(c);
    03036       if (!cs->IsValid()) continue;
    03037
    03038       if (cs->bitnum == ctype) {
    03039         grfmsg(6, "TranslateCargo: Cargo bitnum %d mapped to cargo type %d.", ctype, c);
    03040         return c;
    03041       }
    03042     }
    03043
    03044     grfmsg(5, "TranslateCargo: Cargo bitnum %d not available in this climate, skipping.", ctype);
    03045     return CT_INVALID;
    03046   }
    03047
    03048   /* Check if the cargo type is out of bounds of the cargo translation table */
    03049   if (ctype >= _cur_grffile->cargo_max) {
    03050     grfmsg(1, "TranslateCargo: Cargo type %d out of range (max %d), skipping.", ctype, _cur_grffile->cargo_max - 1);
    03051     return CT_INVALID;
    03052   }
    03053
    03054   /* Look up the cargo label from the translation table */
    03055   CargoLabel cl = _cur_grffile->cargo_list[ctype];
    03056   if (cl == 0) {
    03057     grfmsg(5, "TranslateCargo: Cargo type %d not available in this climate, skipping.", ctype);
    03058     return CT_INVALID;
    03059   }
    03060
    03061   ctype = GetCargoIDByLabel(cl);
    03062   if (ctype == CT_INVALID) {
    03063     grfmsg(5, "TranslateCargo: Cargo '%c%c%c%c' unsupported, skipping.", GB(cl, 24, 8), GB(cl, 16, 8), GB(cl, 8, 8), GB(cl, 0, 8));
    03064     return CT_INVALID;
    03065   }
    03066
    03067   grfmsg(6, "TranslateCargo: Cargo '%c%c%c%c' mapped to cargo type %d.", GB(cl, 24, 8), GB(cl, 16, 8), GB(cl, 8, 8), GB(cl, 0, 8), ctype);
    03068   return ctype;
    03069 }
    03070
    03071
    03072 static bool IsValidGroupID(uint16 groupid, const char *function)
    03073 {
    03074   if (groupid >= _cur_grffile->spritegroups_count || _cur_grffile->spritegroups[groupid] == NULL) {
    03075     grfmsg(1, "%s: Spriteset 0x%04X out of range (maximum 0x%02X) or empty, skipping.", function, groupid, _cur_grffile->spritegroups_count - 1);
    03076     return false;
    03077   }
    03078
    03079   return true;
    03080 }
    03081
    03082 static void VehicleMapSpriteGroup(byte *buf, byte feature, uint8 idcount)
    03083 {
    03084   static EngineID *last_engines;
    03085   static uint last_engines_count;
    03086   bool wagover = false;
    03087
    03088   /* Test for 'wagon override' flag */
    03089   if (HasBit(idcount, 7)) {
    03090     wagover = true;
    03091     /* Strip off the flag */
    03092     idcount = GB(idcount, 0, 7);
    03093
    03094     if (last_engines_count == 0) {
    03095       grfmsg(0, "VehicleMapSpriteGroup: WagonOverride: No engine to do override with");
    03096       return;
    03097     }
    03098
    03099     grfmsg(6, "VehicleMapSpriteGroup: WagonOverride: %u engines, %u wagons",
    03100         last_engines_count, idcount);
    03101   } else {
    03102     if (last_engines_count != idcount) {
    03103       last_engines = ReallocT(last_engines, idcount);
    03104       last_engines_count = idcount;
    03105     }
    03106   }
    03107
    03108   EngineID *engines = AllocaM(EngineID, idcount);
    03109   for (uint i = 0; i < idcount; i++) {
    03110     engines[i] = GetNewEngine(_cur_grffile, (VehicleType)feature, grf_load_extended(&buf))->index;
    03111     if (!wagover) last_engines[i] = engines[i];
    03112   }
    03113
    03114   uint8 cidcount = grf_load_byte(&buf);
    03115   for (uint c = 0; c < cidcount; c++) {
    03116     uint8 ctype = grf_load_byte(&buf);
    03117     uint16 groupid = grf_load_word(&buf);
    03118     if (!IsValidGroupID(groupid, "VehicleMapSpriteGroup")) continue;
    03119
    03120     grfmsg(8, "VehicleMapSpriteGroup: * [%d] Cargo type 0x%X, group id 0x%02X", c, ctype, groupid);
    03121
    03122     ctype = TranslateCargo(feature, ctype);
    03123     if (ctype == CT_INVALID) continue;
    03124
    03125     for (uint i = 0; i < idcount; i++) {
    03126       EngineID engine = engines[i];
    03127
    03128       grfmsg(7, "VehicleMapSpriteGroup: [%d] Engine %d...", i, engine);
    03129
    03130       if (wagover) {
    03131         SetWagonOverrideSprites(engine, ctype, _cur_grffile->spritegroups[groupid], last_engines, last_engines_count);
    03132       } else {
    03133         SetCustomEngineSprites(engine, ctype, _cur_grffile->spritegroups[groupid]);
    03134       }
    03135     }
    03136   }
    03137
    03138   uint16 groupid = grf_load_word(&buf);
    03139   if (!IsValidGroupID(groupid, "VehicleMapSpriteGroup")) return;
    03140
    03141   grfmsg(8, "-- Default group id 0x%04X", groupid);
    03142
    03143   for (uint i = 0; i < idcount; i++) {
    03144     EngineID engine = engines[i];
    03145
    03146     if (wagover) {
    03147       SetWagonOverrideSprites(engine, CT_DEFAULT, _cur_grffile->spritegroups[groupid], last_engines, last_engines_count);
    03148     } else {
    03149       SetCustomEngineSprites(engine, CT_DEFAULT, _cur_grffile->spritegroups[groupid]);
    03150       SetEngineGRF(engine, _cur_grffile);
    03151     }
    03152   }
    03153 }
    03154
    03155
    03156 static void CanalMapSpriteGroup(byte *buf, uint8 idcount)
    03157 {
    03158   CanalFeature *cfs = AllocaM(CanalFeature, idcount);
    03159   for (uint i = 0; i < idcount; i++) {
    03160     cfs[i] = (CanalFeature)grf_load_byte(&buf);
    03161   }
    03162
    03163   uint8 cidcount = grf_load_byte(&buf);
    03164   buf += cidcount * 3;
    03165
    03166   uint16 groupid = grf_load_word(&buf);
    03167   if (!IsValidGroupID(groupid, "CanalMapSpriteGroup")) return;
    03168
    03169   for (uint i = 0; i < idcount; i++) {
    03170     CanalFeature cf = cfs[i];
    03171
    03172     if (cf >= CF_END) {
    03173       grfmsg(1, "CanalMapSpriteGroup: Canal subset %d out of range, skipping", cf);
    03174       continue;
    03175     }
    03176
    03177     _water_feature[cf].grffile = _cur_grffile;
    03178     _water_feature[cf].group = _cur_grffile->spritegroups[groupid];
    03179   }
    03180 }
    03181
    03182
    03183 static void StationMapSpriteGroup(byte *buf, uint8 idcount)
    03184 {
    03185   uint8 *stations = AllocaM(uint8, idcount);
    03186   for (uint i = 0; i < idcount; i++) {
    03187     stations[i] = grf_load_byte(&buf);
    03188   }
    03189
    03190   uint8 cidcount = grf_load_byte(&buf);
    03191   for (uint c = 0; c < cidcount; c++) {
    03192     uint8 ctype = grf_load_byte(&buf);
    03193     uint16 groupid = grf_load_word(&buf);
    03194     if (!IsValidGroupID(groupid, "StationMapSpriteGroup")) continue;
    03195
    03196     ctype = TranslateCargo(GSF_STATION, ctype);
    03197     if (ctype == CT_INVALID) continue;
    03198
    03199     for (uint i = 0; i < idcount; i++) {
    03200       StationSpec *statspec = _cur_grffile->stations[stations[i]];
    03201
    03202       if (statspec == NULL) {
    03203         grfmsg(1, "StationMapSpriteGroup: Station with ID 0x%02X does not exist, skipping", stations[i]);
    03204         continue;
    03205       }
    03206
    03207       statspec->spritegroup[ctype] = _cur_grffile->spritegroups[groupid];
    03208     }
    03209   }
    03210
    03211   uint16 groupid = grf_load_word(&buf);
    03212   if (!IsValidGroupID(groupid, "StationMapSpriteGroup")) return;
    03213
    03214   for (uint i = 0; i < idcount; i++) {
    03215     StationSpec *statspec = _cur_grffile->stations[stations[i]];
    03216
    03217     if (statspec == NULL) {
    03218       grfmsg(1, "StationMapSpriteGroup: Station with ID 0x%02X does not exist, skipping", stations[i]);
    03219       continue;
    03220     }
    03221
    03222     statspec->spritegroup[CT_DEFAULT] = _cur_grffile->spritegroups[groupid];
    03223     statspec->grffile = _cur_grffile;
    03224     statspec->localidx = stations[i];
    03225     SetCustomStationSpec(statspec);
    03226   }
    03227 }
    03228
    03229
    03230 static void TownHouseMapSpriteGroup(byte *buf, uint8 idcount)
    03231 {
    03232   uint8 *houses = AllocaM(uint8, idcount);
    03233   for (uint i = 0; i < idcount; i++) {
    03234     houses[i] = grf_load_byte(&buf);
    03235   }
    03236
    03237   /* Skip the cargo type section, we only care about the default group */
    03238   uint8 cidcount = grf_load_byte(&buf);
    03239   buf += cidcount * 3;
    03240
    03241   uint16 groupid = grf_load_word(&buf);
    03242   if (!IsValidGroupID(groupid, "TownHouseMapSpriteGroup")) return;
    03243
    03244   for (uint i = 0; i < idcount; i++) {
    03245     HouseSpec *hs = _cur_grffile->housespec[houses[i]];
    03246
    03247     if (hs == NULL) {
    03248       grfmsg(1, "TownHouseMapSpriteGroup: House %d undefined, skipping.", houses[i]);
    03249       continue;
    03250     }
    03251
    03252     hs->spritegroup = _cur_grffile->spritegroups[groupid];
    03253   }
    03254 }
    03255
    03256 static void IndustryMapSpriteGroup(byte *buf, uint8 idcount)
    03257 {
    03258   uint8 *industries = AllocaM(uint8, idcount);
    03259   for (uint i = 0; i < idcount; i++) {
    03260     industries[i] = grf_load_byte(&buf);
    03261   }
    03262
    03263   /* Skip the cargo type section, we only care about the default group */
    03264   uint8 cidcount = grf_load_byte(&buf);
    03265   buf += cidcount * 3;
    03266
    03267   uint16 groupid = grf_load_word(&buf);
    03268   if (!IsValidGroupID(groupid, "IndustryMapSpriteGroup")) return;
    03269
    03270   for (uint i = 0; i < idcount; i++) {
    03271     IndustrySpec *indsp = _cur_grffile->industryspec[industries[i]];
    03272
    03273     if (indsp == NULL) {
    03274       grfmsg(1, "IndustryMapSpriteGroup: Industry %d undefined, skipping", industries[i]);
    03275       continue;
    03276     }
    03277
    03278     indsp->grf_prop.spritegroup = _cur_grffile->spritegroups[groupid];
    03279   }
    03280 }
    03281
    03282 static void IndustrytileMapSpriteGroup(byte *buf, uint8 idcount)
    03283 {
    03284   uint8 *indtiles = AllocaM(uint8, idcount);
    03285   for (uint i = 0; i < idcount; i++) {
    03286     indtiles[i] = grf_load_byte(&buf);
    03287   }
    03288
    03289   /* Skip the cargo type section, we only care about the default group */
    03290   uint8 cidcount = grf_load_byte(&buf);
    03291   buf += cidcount * 3;
    03292
    03293   uint16 groupid = grf_load_word(&buf);
    03294   if (!IsValidGroupID(groupid, "IndustrytileMapSpriteGroup")) return;
    03295
    03296   for (uint i = 0; i < idcount; i++) {
    03297     IndustryTileSpec *indtsp = _cur_grffile->indtspec[indtiles[i]];
    03298
    03299     if (indtsp == NULL) {
    03300       grfmsg(1, "IndustrytileMapSpriteGroup: Industry tile %d undefined, skipping", indtiles[i]);
    03301       continue;
    03302     }
    03303
    03304     indtsp->grf_prop.spritegroup = _cur_grffile->spritegroups[groupid];
    03305   }
    03306 }
    03307
    03308 static void CargoMapSpriteGroup(byte *buf, uint8 idcount)
    03309 {
    03310   CargoID *cargos = AllocaM(CargoID, idcount);
    03311   for (uint i = 0; i < idcount; i++) {
    03312     cargos[i] = grf_load_byte(&buf);
    03313   }
    03314
    03315   /* Skip the cargo type section, we only care about the default group */
    03316   uint8 cidcount = grf_load_byte(&buf);
    03317   buf += cidcount * 3;
    03318
    03319   uint16 groupid = grf_load_word(&buf);
    03320   if (!IsValidGroupID(groupid, "CargoMapSpriteGroup")) return;
    03321
    03322   for (uint i = 0; i < idcount; i++) {
    03323     CargoID cid = cargos[i];
    03324
    03325     if (cid >= NUM_CARGO) {
    03326       grfmsg(1, "CargoMapSpriteGroup: Cargo ID %d out of range, skipping", cid);
    03327       continue;
    03328     }
    03329
    03330     CargoSpec *cs = &_cargo[cid];
    03331     cs->grffile = _cur_grffile;
    03332     cs->group = _cur_grffile->spritegroups[groupid];
    03333   }
    03334 }
    03335
    03336
    03337 /* Action 0x03 */
    03338 static void FeatureMapSpriteGroup(byte *buf, size_t len)
    03339 {
    03340   /* <03> <feature> <n-id> <ids>... <num-cid> [<cargo-type> <cid>]... <def-cid>
    03341    * id-list    := [<id>] [id-list]
    03342    * cargo-list := <cargo-type> <cid> [cargo-list]
    03343    *
    03344    * B feature       see action 0
    03345    * B n-id          bits 0-6: how many IDs this definition applies to
    03346    *                 bit 7: if set, this is a wagon override definition (see below)
    03347    * B ids           the IDs for which this definition applies
    03348    * B num-cid       number of cargo IDs (sprite group IDs) in this definition
    03349    *                 can be zero, in that case the def-cid is used always
    03350    * B cargo-type    type of this cargo type (e.g. mail=2, wood=7, see below)
    03351    * W cid           cargo ID (sprite group ID) for this type of cargo
    03352    * W def-cid       default cargo ID (sprite group ID) */
    03353
    03354   if (_cur_grffile->spritegroups == 0) {
    03355     grfmsg(1, "FeatureMapSpriteGroup: No sprite groups to work on! Skipping");
    03356     return;
    03357   }
    03358
    03359   if (!check_length(len, 6, "FeatureMapSpriteGroup")) return;
    03360
    03361   buf++;
    03362   uint8 feature = grf_load_byte(&buf);
    03363   uint8 idcount = grf_load_byte(&buf);
    03364
    03365   /* If idcount is zero, this is a feature callback */
    03366   if (idcount == 0) {
    03367     /* Skip number of cargo ids? */
    03368     grf_load_byte(&buf);
    03369     uint16 groupid = grf_load_word(&buf);
    03370
    03371     grfmsg(6, "FeatureMapSpriteGroup: Adding generic feature callback for feature %d", feature);
    03372
    03373     AddGenericCallback(feature, _cur_grffile, _cur_grffile->spritegroups[groupid]);
    03374     return;
    03375   }
    03376
    03377   grfmsg(6, "FeatureMapSpriteGroup: Feature %d, %d ids", feature, idcount);
    03378
    03379   switch (feature) {
    03380     case GSF_TRAIN:
    03381     case GSF_ROAD:
    03382     case GSF_SHIP:
    03383     case GSF_AIRCRAFT:
    03384       VehicleMapSpriteGroup(buf, feature, idcount);
    03385       return;
    03386
    03387     case GSF_CANAL:
    03388       CanalMapSpriteGroup(buf, idcount);
    03389       return;
    03390
    03391     case GSF_STATION:
    03392       StationMapSpriteGroup(buf, idcount);
    03393       return;
    03394
    03395     case GSF_TOWNHOUSE:
    03396       TownHouseMapSpriteGroup(buf, idcount);
    03397       return;
    03398
    03399     case GSF_INDUSTRIES:
    03400       IndustryMapSpriteGroup(buf, idcount);
    03401       return;
    03402
    03403     case GSF_INDUSTRYTILES:
    03404       IndustrytileMapSpriteGroup(buf, idcount);
    03405       return;
    03406
    03407     case GSF_CARGOS:
    03408       CargoMapSpriteGroup(buf, idcount);
    03409       return;
    03410
    03411     default:
    03412       grfmsg(1, "FeatureMapSpriteGroup: Unsupported feature %d, skipping", feature);
    03413       return;
    03414   }
    03415 }
    03416
    03417 /* Action 0x04 */
    03418 static void FeatureNewName(byte *buf, size_t len)
    03419 {
    03420   /* <04> <veh-type> <language-id> <num-veh> <offset> <data...>
    03421    *
    03422    * B veh-type      see action 0 (as 00..07, + 0A
    03423    *                 But IF veh-type = 48, then generic text
    03424    * B language-id   If bit 6 is set, This is the extended language scheme,
    03425                      with up to 64 language.
    03426                      Otherwise, it is a mapping where set bits have meaning
    03427                      0 = american, 1 = english, 2 = german, 3 = french, 4 = spanish
    03428                      Bit 7 set means this is a generic text, not a vehicle one (or else)
    03429    * B num-veh       number of vehicles which are getting a new name
    03430    * B/W offset      number of the first vehicle that gets a new name
    03431    *                 Byte : ID of vehicle to change
    03432    *                 Word : ID of string to change/add
    03433    * S data          new texts, each of them zero-terminated, after
    03434    *                 which the next name begins. */
    03435
    03436   bool new_scheme = _cur_grffile->grf_version >= 7;
    03437
    03438   if (!check_length(len, 6, "FeatureNewName")) return;
    03439   buf++;
    03440   uint8 feature  = grf_load_byte(&buf);
    03441   uint8 lang     = grf_load_byte(&buf);
    03442   uint8 num      = grf_load_byte(&buf);
    03443   bool generic   = HasBit(lang, 7);
    03444   uint16 id;
    03445   if (generic) {
    03446     id = grf_load_word(&buf);
    03447   } else if (feature <= GSF_AIRCRAFT) {
    03448     id = grf_load_extended(&buf);
    03449   } else {
    03450     id = grf_load_byte(&buf);
    03451   }
    03452
    03453   ClrBit(lang, 7);
    03454
    03455   uint16 endid = id + num;
    03456
    03457   grfmsg(6, "FeatureNewName: About to rename engines %d..%d (feature %d) in language 0x%02X",
    03458                  id, endid, feature, lang);
    03459
    03460   len -= generic ? 6 : 5;
    03461
    03462   for (; id < endid && len > 0; id++) {
    03463     const char *name   = grf_load_string(&buf, len);
    03464     size_t name_length = strlen(name) + 1;
    03465
    03466     len -= (int)name_length;
    03467
    03468     grfmsg(8, "FeatureNewName: 0x%04X <- %s", id, name);
    03469
    03470     switch (feature) {
    03471       case GSF_TRAIN:
    03472       case GSF_ROAD:
    03473       case GSF_SHIP:
    03474       case GSF_AIRCRAFT:
    03475         if (!generic) {
    03476           Engine *e = GetNewEngine(_cur_grffile, (VehicleType)feature, id, HasBit(_cur_grfconfig->flags, GCF_STATIC));
    03477           if (e == NULL) break;
    03478           StringID string = AddGRFString(_cur_grffile->grfid, e->index, lang, new_scheme, name, e->info.string_id);
    03479           e->info.string_id = string;
    03480         } else {
    03481           AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, id);
    03482         }
    03483         break;
    03484
    03485       case GSF_INDUSTRIES: {
    03486         AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED);
    03487         break;
    03488       }
    03489
    03490       case GSF_TOWNHOUSE:
    03491       default:
    03492         switch (GB(id, 8, 8)) {
    03493           case 0xC4: // Station class name
    03494             if (_cur_grffile->stations == NULL || _cur_grffile->stations[GB(id, 0, 8)] == NULL) {
    03495               grfmsg(1, "FeatureNewName: Attempt to name undefined station 0x%X, ignoring", GB(id, 0, 8));
    03496             } else {
    03497               StationClassID sclass = _cur_grffile->stations[GB(id, 0, 8)]->sclass;
    03498               SetStationClassName(sclass, AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED));
    03499             }
    03500             break;
    03501
    03502           case 0xC5: // Station name
    03503             if (_cur_grffile->stations == NULL || _cur_grffile->stations[GB(id, 0, 8)] == NULL) {
    03504               grfmsg(1, "FeatureNewName: Attempt to name undefined station 0x%X, ignoring", GB(id, 0, 8));
    03505             } else {
    03506               _cur_grffile->stations[GB(id, 0, 8)]->name = AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED);
    03507             }
    03508             break;
    03509
    03510           case 0xC9: // House name
    03511             if (_cur_grffile->housespec == NULL || _cur_grffile->housespec[GB(id, 0, 8)] == NULL) {
    03512               grfmsg(1, "FeatureNewName: Attempt to name undefined house 0x%X, ignoring.", GB(id, 0, 8));
    03513             } else {
    03514               _cur_grffile->housespec[GB(id, 0, 8)]->building_name = AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED);
    03515             }
    03516             break;
    03517
    03518           case 0xD0:
    03519           case 0xD1:
    03520           case 0xD2:
    03521           case 0xD3:
    03522           case 0xDC:
    03523             AddGRFString(_cur_grffile->grfid, id, lang, new_scheme, name, STR_UNDEFINED);
    03524             break;
    03525
    03526           default:
    03527             grfmsg(7, "FeatureNewName: Unsupported ID (0x%04X)", id);
    03528             break;
    03529         }
    03530         break;
    03531
    03532 #if 0
    03533         case GSF_CANAL :
    03534         case GSF_BRIDGE :
    03535           AddGRFString(_cur_spriteid, id, lang, name);
    03536           switch (GB(id, 8, 8)) {
    03537             case 0xC9: // House name
    03538             default:
    03539               grfmsg(7, "FeatureNewName: Unsupported ID (0x%04X)", id);
    03540           }
    03541           break;
    03542
    03543         default :
    03544           grfmsg(7, "FeatureNewName: Unsupported feature (0x%02X)", feature);
    03545           break;
    03546 #endif
    03547     }
    03548   }
    03549 }
    03550
    03559 static uint16 SanitizeSpriteOffset(uint16& num, uint16 offset, int max_sprites, const char *name)
    03560 {
    03561
    03562   if (offset >= max_sprites) {
    03563     grfmsg(1, "GraphicsNew: %s sprite offset must be less than %i, skipping", name, max_sprites);
    03564     uint orig_num = num;
    03565     num = 0;
    03566     return orig_num;
    03567   }
    03568
    03569   if (offset + num > max_sprites) {
    03570     grfmsg(4, "GraphicsNew: %s sprite overflow, truncating...", name);
    03571     uint orig_num = num;
    03572     num = max(max_sprites - offset, 0);
    03573     return orig_num - num;
    03574   }
    03575
    03576   return 0;
    03577 }
    03578
    03579 /* Action 0x05 */
    03580 static void GraphicsNew(byte *buf, size_t len)
    03581 {
    03582   /* <05> <graphics-type> <num-sprites> <other data...>
    03583    *
    03584    * B graphics-type What set of graphics the sprites define.
    03585    * E num-sprites   How many sprites are in this set?
    03586    * V other data    Graphics type specific data.  Currently unused. */
    03587   /* TODO */
    03588
    03589   enum Action5BlockType {
    03590     A5BLOCK_FIXED,
    03591     A5BLOCK_ALLOW_OFFSET,
    03592     A5BLOCK_INVALID,
    03593   };
    03594   struct Action5Type {
    03595     Action5BlockType block_type;
    03596     SpriteID sprite_base;
    03597     uint16 min_sprites;
    03598     uint16 max_sprites;
    03599     const char *name;
    03600   };
    03601
    03602   static const Action5Type action5_types[] = {
    03603     /* Note: min_sprites should not be changed. Therefore these constants are directly here and not in sprites.h */
    03604     /* 0x00 */ { A5BLOCK_INVALID,      0,                            0, 0,                                           "Type 0x00"             },
    03605     /* 0x01 */ { A5BLOCK_INVALID,      0,                            0, 0,                                           "Type 0x01"             },
    03606     /* 0x02 */ { A5BLOCK_INVALID,      0,                            0, 0,                                           "Type 0x02"             },
    03607     /* 0x03 */ { A5BLOCK_INVALID,      0,                            0, 0,                                           "Type 0x03"             },
    03608     /* 0x04 */ { A5BLOCK_FIXED,        SPR_SIGNALS_BASE,            48, PRESIGNAL_SEMAPHORE_AND_PBS_SPRITE_COUNT,    "Signal graphics"       },
    03609     /* 0x05 */ { A5BLOCK_FIXED,        SPR_ELRAIL_BASE,             48, ELRAIL_SPRITE_COUNT,                         "Catenary graphics"     },
    03610     /* 0x06 */ { A5BLOCK_FIXED,        SPR_SLOPES_BASE,             74, NORMAL_AND_HALFTILE_FOUNDATION_SPRITE_COUNT, "Foundation graphics"   },
    03611     /* 0x07 */ { A5BLOCK_INVALID,      0,                           75, 0,                                           "TTDP GUI graphics"     }, // Not used by OTTD.
    03612     /* 0x08 */ { A5BLOCK_FIXED,        SPR_CANALS_BASE,             65, CANALS_SPRITE_COUNT,                         "Canal graphics"        },
    03613     /* 0x09 */ { A5BLOCK_FIXED,        SPR_ONEWAY_BASE,              6, ONEWAY_SPRITE_COUNT,                         "One way road graphics" },
    03614     /* 0x0A */ { A5BLOCK_FIXED,        SPR_2CCMAP_BASE,            256, TWOCCMAP_SPRITE_COUNT,                       "2CC colour maps"       },
    03615     /* 0x0B */ { A5BLOCK_FIXED,        SPR_TRAMWAY_BASE,           113, TRAMWAY_SPRITE_COUNT,                        "Tramway graphics"      },
    03616     /* 0x0C */ { A5BLOCK_INVALID,      0,                          133, 0,                                           "Snowy temperate tree"  }, // Not yet used by OTTD.
    03617     /* 0x0D */ { A5BLOCK_FIXED,        SPR_SHORE_BASE,              16, SPR_SHORE_SPRITE_COUNT,                      "Shore graphics"        },
    03618     /* 0x0E */ { A5BLOCK_INVALID,      0,                            0, 0,                                           "New Signals graphics"  }, // Not yet used by OTTD.
    03619     /* 0x0F */ { A5BLOCK_FIXED,        SPR_TRACKS_FOR_SLOPES_BASE,  12, TRACKS_FOR_SLOPES_SPRITE_COUNT,              "Sloped rail track"     },
    03620     /* 0x10 */ { A5BLOCK_FIXED,        SPR_AIRPORTX_BASE,           15, AIRPORTX_SPRITE_COUNT,                       "Airport graphics"      },
    03621     /* 0x11 */ { A5BLOCK_FIXED,        SPR_ROADSTOP_BASE,            8, ROADSTOP_SPRITE_COUNT,                       "Road stop graphics"    },
    03622     /* 0x12 */ { A5BLOCK_FIXED,        SPR_AQUEDUCT_BASE,            8, AQUEDUCT_SPRITE_COUNT,                       "Aqueduct graphics"     },
    03623     /* 0x13 */ { A5BLOCK_FIXED,        SPR_AUTORAIL_BASE,           55, AUTORAIL_SPRITE_COUNT,                       "Autorail graphics"     },
    03624     /* 0x14 */ { A5BLOCK_ALLOW_OFFSET, SPR_FLAGS_BASE,               1, FLAGS_SPRITE_COUNT,                          "Flag graphics"         },
    03625     /* 0x15 */ { A5BLOCK_ALLOW_OFFSET, SPR_OPENTTD_BASE,             1, OPENTTD_SPRITE_COUNT,                        "OpenTTD GUI graphics"  },
    03626   };
    03627
    03628   if (!check_length(len, 2, "GraphicsNew")) return;
    03629   buf++;
    03630   uint8 type = grf_load_byte(&buf);
    03631   uint16 num = grf_load_extended(&buf);
    03632   uint16 offset = HasBit(type, 7) ? grf_load_extended(&buf) : 0;
    03633   ClrBit(type, 7); // Clear the high bit as that only indicates whether there is an offset.
    03634
    03635   if ((type == 0x0D) && (num == 10) && _cur_grffile->is_ottdfile) {
    03636     /* Special not-TTDP-compatible case used in openttd(d/w).grf
    03637      * Missing shore sprites and initialisation of SPR_SHORE_BASE */
    03638     grfmsg(2, "GraphicsNew: Loading 10 missing shore sprites from openttd(d/w).grf.");
    03639     LoadNextSprite(SPR_SHORE_BASE +  0, _file_index, _nfo_line++); // SLOPE_STEEP_S
    03640     LoadNextSprite(SPR_SHORE_BASE +  5, _file_index, _nfo_line++); // SLOPE_STEEP_W
    03641     LoadNextSprite(SPR_SHORE_BASE +  7, _file_index, _nfo_line++); // SLOPE_WSE
    03642     LoadNextSprite(SPR_SHORE_BASE + 10, _file_index, _nfo_line++); // SLOPE_STEEP_N
    03643     LoadNextSprite(SPR_SHORE_BASE + 11, _file_index, _nfo_line++); // SLOPE_NWS
    03644     LoadNextSprite(SPR_SHORE_BASE + 13, _file_index, _nfo_line++); // SLOPE_ENW
    03645     LoadNextSprite(SPR_SHORE_BASE + 14, _file_index, _nfo_line++); // SLOPE_SEN
    03646     LoadNextSprite(SPR_SHORE_BASE + 15, _file_index, _nfo_line++); // SLOPE_STEEP_E
    03647     LoadNextSprite(SPR_SHORE_BASE + 16, _file_index, _nfo_line++); // SLOPE_EW
    03648     LoadNextSprite(SPR_SHORE_BASE + 17, _file_index, _nfo_line++); // SLOPE_NS
    03649     if (_loaded_newgrf_features.shore == SHORE_REPLACE_NONE) _loaded_newgrf_features.shore = SHORE_REPLACE_ONLY_NEW;
    03650     return;
    03651   }
    03652
    03653   /* Supported type? */
    03654   if ((type >= lengthof(action5_types)) || (action5_types[type].block_type == A5BLOCK_INVALID)) {
    03655     grfmsg(2, "GraphicsNew: Custom graphics (type 0x%02X) sprite block of length %u (unimplemented, ignoring)", type, num);
    03656     _skip_sprites = num;
    03657     return;
    03658   }
    03659
    03660   const Action5Type *action5_type = &action5_types[type];
    03661
    03662   /* Ignore offset if not allowed */
    03663   if ((action5_type->block_type != A5BLOCK_ALLOW_OFFSET) && (offset != 0)) {
    03664     grfmsg(1, "GraphicsNew: %s (type 0x%02X) do not allow an <offset> field. Ignoring offset.", action5_type->name, type);
    03665     offset = 0;
    03666   }
    03667
    03668   /* Ignore action5 if too few sprites are specified. (for TTDP compatibility)
    03669    * This does not make sense, if <offset> is allowed */
    03670   if ((action5_type->block_type == A5BLOCK_FIXED) && (num < action5_type->min_sprites)) {
    03671     grfmsg(1, "GraphicsNew: %s (type 0x%02X) count must be at least %d. Only %d were specified. Skipping.", action5_type->name, type, action5_type->min_sprites, num);
    03672     _skip_sprites = num;
    03673     return;
    03674   }
    03675
    03676   /* Load at most max_sprites sprites. Skip remaining sprites. (for compatibility with TTDP and future extentions) */
    03677   uint16 skip_num = SanitizeSpriteOffset(num, offset, action5_type->max_sprites, action5_type->name);
    03678   SpriteID replace = action5_type->sprite_base + offset;
    03679
    03680   /* Load <num> sprites starting from <replace>, then skip <skip_num> sprites. */
    03681   grfmsg(2, "GraphicsNew: Replacing sprites %d to %d of %s (type 0x%02X) at SpriteID 0x%04X", offset, offset + num - 1, action5_type->name, type, replace);
    03682
    03683   for (; num > 0; num--) {
    03684     _nfo_line++;
    03685     LoadNextSprite(replace == 0 ? _cur_spriteid++ : replace++, _file_index, _nfo_line);
    03686   }
    03687
    03688   if (type == 0x0D) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_5;
    03689
    03690   _skip_sprites = skip_num;
    03691 }
    03692
    03693 /* Action 0x05 (SKIP) */
    03694 static void SkipAct5(byte *buf, size_t len)
    03695 {
    03696   if (!check_length(len, 2, "SkipAct5")) return;
    03697   buf++;
    03698
    03699   /* Ignore type byte */
    03700   grf_load_byte(&buf);
    03701
    03702   /* Skip the sprites of this action */
    03703   _skip_sprites = grf_load_extended(&buf);
    03704
    03705   grfmsg(3, "SkipAct5: Skipping %d sprites", _skip_sprites);
    03706 }
    03707
    03718 bool GetGlobalVariable(byte param, uint32 *value)
    03719 {
    03720   switch (param) {
    03721     case 0x00: // current date
    03722       *value = max(_date - DAYS_TILL_ORIGINAL_BASE_YEAR, 0);
    03723       return true;
    03724
    03725     case 0x01: // current year
    03726       *value = Clamp(_cur_year, ORIGINAL_BASE_YEAR, ORIGINAL_MAX_YEAR) - ORIGINAL_BASE_YEAR;
    03727       return true;
    03728
    03729     case 0x02: { // detailed date information: month of year (bit 0-7), day of month (bit 8-12), leap year (bit 15), day of year (bit 16-24)
    03730       YearMonthDay ymd;
    03731       ConvertDateToYMD(_date, &ymd);
    03732       Date start_of_year = ConvertYMDToDate(ymd.year, 0, 1);
    03733       *value = ymd.month | (ymd.day - 1) << 8 | (IsLeapYear(ymd.year) ? 1 << 15 : 0) | (_date - start_of_year) << 16;
    03734       return true;
    03735     }
    03736
    03737     case 0x03: // current climate, 0=temp, 1=arctic, 2=trop, 3=toyland
    03738       *value = _settings_game.game_creation.landscape;
    03739       return true;
    03740
    03741     case 0x06: // road traffic side, bit 4 clear=left, set=right
    03742       *value = _settings_game.vehicle.road_side << 4;
    03743       return true;
    03744
    03745     case 0x09: // date fraction
    03746       *value = _date_fract;
    03747       return true;
    03748
    03749     case 0x0A: // animation counter
    03750       *value = _tick_counter;
    03751       return true;
    03752
    03753     case 0x0B: { // TTDPatch version
    03754       uint major    = 2;
    03755       uint minor    = 6;
    03756       uint revision = 1; // special case: 2.0.1 is 2.0.10
    03757       uint build    = 1382;
    03758       *value = (major << 24) | (minor << 20) | (revision << 16) | build;
    03759       return true;
    03760     }
    03761
    03762     case 0x0D: // TTD Version, 00=DOS, 01=Windows
    03763       *value = _cur_grfconfig->windows_paletted;
    03764       return true;
    03765
    03766     case 0x0E: // Y-offset for train sprites
    03767       *value = _traininfo_vehicle_pitch;
    03768       return true;
    03769
    03770     case 0x0F: // Rail track type cost factors
    03771       *value = 0;
    03772       SB(*value, 0, 8, GetRailTypeInfo(RAILTYPE_RAIL)->cost_multiplier); // normal rail
    03773       if (_settings_game.vehicle.disable_elrails) {
    03774         /* skip elrail multiplier - disabled */
    03775         SB(*value, 8, 8, GetRailTypeInfo(RAILTYPE_MONO)->cost_multiplier); // monorail
    03776       } else {
    03777         SB(*value, 8, 8, GetRailTypeInfo(RAILTYPE_ELECTRIC)->cost_multiplier); // electified railway
    03778         /* Skip monorail multiplier - no space in result */
    03779       }
    03780       SB(*value, 16, 8, GetRailTypeInfo(RAILTYPE_MAGLEV)->cost_multiplier); // maglev
    03781       return true;
    03782
    03783     case 0x11: // current rail tool type
    03784       *value = 0;
    03785       return true;
    03786
    03787     case 0x12: // Game mode
    03788       *value = _game_mode;
    03789       return true;
    03790
    03791     /* case 0x13: // Tile refresh offset to left    not implemented */
    03792     /* case 0x14: // Tile refresh offset to right   not implemented */
    03793     /* case 0x15: // Tile refresh offset upwards    not implemented */
    03794     /* case 0x16: // Tile refresh offset downwards  not implemented */
    03795     /* case 0x17: // temperate snow line            not implemented */
    03796
    03797     case 0x1A: // Always -1
    03798       *value = UINT_MAX;
    03799       return true;
    03800
    03801     case 0x1B: // Display options
    03802       *value = GB(_display_opt, 0, 6);
    03803       return true;
    03804
    03805     case 0x1D: // TTD Platform, 00=TTDPatch, 01=OpenTTD
    03806       *value = 1;
    03807       return true;
    03808
    03809     case 0x1E: // Miscellaneous GRF features
    03810       *value = _misc_grf_features;
    03811       return true;
    03812
    03813     /* case 0x1F: // locale dependent settings not implemented */
    03814
    03815     case 0x20: // snow line height
    03816       *value = _settings_game.game_creation.landscape == LT_ARCTIC ? GetSnowLine() : 0xFF;
    03817       return true;
    03818
    03819     case 0x21: // OpenTTD version
    03820       *value = _openttd_newgrf_version;
    03821       return true;
    03822
    03823     case 0x22: // difficulty level
    03824       *value = _settings_game.difficulty.diff_level;
    03825       return true;
    03826
    03827     case 0x23: // long format date
    03828       *value = _date;
    03829       return true;
    03830
    03831     case 0x24: // long format year
    03832       *value = _cur_year;
    03833       return true;
    03834
    03835     default: return false;
    03836   }
    03837 }
    03838
    03839 static uint32 GetParamVal(byte param, uint32 *cond_val)
    03840 {
    03841   /* First handle variable common with VarAction2 */
    03842   uint32 value;
    03843   if (GetGlobalVariable(param - 0x80, &value)) return value;
    03844
    03845   /* Non-common variable */
    03846   switch (param) {
    03847     case 0x84: { // GRF loading stage
    03848       uint32 res = 0;
    03849
    03850       if (_cur_stage > GLS_INIT) SetBit(res, 0);
    03851       if (_cur_stage == GLS_RESERVE) SetBit(res, 8);
    03852       if (_cur_stage == GLS_ACTIVATION) SetBit(res, 9);
    03853       return res;
    03854     }
    03855
    03856     case 0x85: // TTDPatch flags, only for bit tests
    03857       if (cond_val == NULL) {
    03858         /* Supported in Action 0x07 and 0x09, not 0x0D */
    03859         return 0;
    03860       } else {
    03861         uint32 param_val = _ttdpatch_flags[*cond_val / 0x20];
    03862         *cond_val %= 0x20;
    03863         return param_val;
    03864       }
    03865
    03866     case 0x88: // GRF ID check
    03867       return 0;
    03868
    03869     /* case 0x99: Global ID offest not implemented */
    03870
    03871     default:
    03872       /* GRF Parameter */
    03873       if (param < 0x80) return _cur_grffile->param[param];
    03874
    03875       /* In-game variable. */
    03876       grfmsg(1, "Unsupported in-game variable 0x%02X", param);
    03877       return UINT_MAX;
    03878   }
    03879 }
    03880
    03881 /* Action 0x06 */
    03882 static void CfgApply(byte *buf, size_t len)
    03883 {
    03884   /* <06> <param-num> <param-size> <offset> ... <FF>
    03885    *
    03886    * B param-num     Number of parameter to substitute (First = "zero")
    03887    *                 Ignored if that parameter was not specified in newgrf.cfg
    03888    * B param-size    How many bytes to replace.  If larger than 4, the
    03889    *                 bytes of the following parameter are used.  In that
    03890    *                 case, nothing is applied unless *all* parameters
    03891    *                 were specified.
    03892    * B offset        Offset into data from beginning of next sprite
    03893    *                 to place where parameter is to be stored. */
    03894
    03895   /* Preload the next sprite */
    03896   size_t pos = FioGetPos();
    03897   uint16 num = FioReadWord();
    03898   uint8 type = FioReadByte();
    03899   byte *preload_sprite = NULL;
    03900
    03901   /* Check if the sprite is a pseudo sprite. We can't operate on real sprites. */
    03902   if (type == 0xFF) {
    03903     preload_sprite = MallocT<byte>(num);
    03904     FioReadBlock(preload_sprite, num);
    03905   }
    03906
    03907   /* Reset the file position to the start of the next sprite */
    03908   FioSeekTo(pos, SEEK_SET);
    03909
    03910   if (type != 0xFF) {
    03911     grfmsg(2, "CfgApply: Ignoring (next sprite is real, unsupported)");
    03912     free(preload_sprite);
    03913     return;
    03914   }
    03915
    03916   GRFLocation location(_cur_grfconfig->grfid, _nfo_line + 1);
    03917   GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.find(location);
    03918   if (it != _grf_line_to_action6_sprite_override.end()) {
    03919     free(preload_sprite);
    03920     preload_sprite = _grf_line_to_action6_sprite_override[location];
    03921   } else {
    03922     _grf_line_to_action6_sprite_override[location] = preload_sprite;
    03923   }
    03924
    03925   /* Now perform the Action 0x06 on our data. */
    03926   buf++;
    03927
    03928   for (;;) {
    03929     uint i;
    03930     uint param_num;
    03931     uint param_size;
    03932     uint offset;
    03933     bool add_value;
    03934
    03935     /* Read the parameter to apply. 0xFF indicates no more data to change. */
    03936     param_num = grf_load_byte(&buf);
    03937     if (param_num == 0xFF) break;
    03938
    03939     /* Get the size of the parameter to use. If the size covers multiple
    03940      * double words, sequential parameter values are used. */
    03941     param_size = grf_load_byte(&buf);
    03942
    03943     /* Bit 7 of param_size indicates we should add to the original value
    03944      * instead of replacing it. */
    03945     add_value  = HasBit(param_size, 7);
    03946     param_size = GB(param_size, 0, 7);
    03947
    03948     /* Where to apply the data to within the pseudo sprite data. */
    03949     offset     = grf_load_extended(&buf);
    03950
    03951     /* If the parameter is a GRF parameter (not an internal variable) check
    03952      * if it (and all further sequential parameters) has been defined. */
    03953     if (param_num < 0x80 && (param_num + (param_size - 1) / 4) >= _cur_grffile->param_end) {
    03954       grfmsg(2, "CfgApply: Ignoring (param %d not set)", (param_num + (param_size - 1) / 4));
    03955       break;
    03956     }
    03957
    03958     grfmsg(8, "CfgApply: Applying %u bytes from parameter 0x%02X at offset 0x%04X", param_size, param_num, offset);
    03959
    03960     bool carry = false;
    03961     for (i = 0; i < param_size && offset + i < num; i++) {
    03962       uint32 value = GetParamVal(param_num + i / 4, NULL);
    03963       /* Reset carry flag for each iteration of the variable (only really
    03964        * matters if param_size is greater than 4) */
    03965       if (i == 0) carry = false;
    03966
    03967       if (add_value) {
    03968         uint new_value = preload_sprite[offset + i] + GB(value, (i % 4) * 8, 8) + (carry ? 1 : 0);
    03969         preload_sprite[offset + i] = GB(new_value, 0, 8);
    03970         /* Check if the addition overflowed */
    03971         carry = new_value >= 256;
    03972       } else {
    03973         preload_sprite[offset + i] = GB(value, (i % 4) * 8, 8);
    03974       }
    03975     }
    03976   }
    03977 }
    03978
    03988 static void DisableStaticNewGRFInfluencingNonStaticNewGRFs(GRFConfig *c)
    03989 {
    03990   if (c->error != NULL) {
    03991     free(c->error->custom_message);
    03992     free(c->error->data);
    03993     free(c->error);
    03994   }
    03995   c->status = GCS_DISABLED;
    03996   c->error  = CallocT<GRFError>(1);
    03997   c->error->data = strdup(_cur_grfconfig->name);
    03998   c->error->severity = STR_NEWGRF_ERROR_MSG_FATAL;
    03999   c->error->message  = STR_NEWGRF_ERROR_STATIC_GRF_CAUSES_DESYNC;
    04000
    04001   ClearTemporaryNewGRFData(GetFileByGRFID(c->grfid));
    04002 }
    04003
    04004 /* Action 0x07
    04005  * Action 0x09 */
    04006 static void SkipIf(byte *buf, size_t len)
    04007 {
    04008   /* <07/09> <param-num> <param-size> <condition-type> <value> <num-sprites>
    04009    *
    04010    * B param-num
    04011    * B param-size
    04012    * B condition-type
    04013    * V value
    04014    * B num-sprites */
    04015   /* TODO: More params. More condition types. */
    04016   uint32 cond_val = 0;
    04017   uint32 mask = 0;
    04018   bool result;
    04019
    04020   if (!check_length(len, 6, "SkipIf")) return;
    04021   buf++;
    04022   uint8 param     = grf_load_byte(&buf);
    04023   uint8 paramsize = grf_load_byte(&buf);
    04024   uint8 condtype  = grf_load_byte(&buf);
    04025
    04026   if (condtype < 2) {
    04027     /* Always 1 for bit tests, the given value should be ignored. */
    04028     paramsize = 1;
    04029   }
    04030
    04031   switch (paramsize) {
    04032     case 8: cond_val = grf_load_dword(&buf); mask = grf_load_dword(&buf); break;
    04033     case 4: cond_val = grf_load_dword(&buf); mask = 0xFFFFFFFF; break;
    04034     case 2: cond_val = grf_load_word(&buf);  mask = 0x0000FFFF; break;
    04035     case 1: cond_val = grf_load_byte(&buf);  mask = 0x000000FF; break;
    04036     default: break;
    04037   }
    04038
    04039   if (param < 0x80 && _cur_grffile->param_end <= param) {
    04040     grfmsg(7, "SkipIf: Param %d undefined, skipping test", param);
    04041     return;
    04042   }
    04043
    04044   uint32 param_val = GetParamVal(param, &cond_val);
    04045
    04046   grfmsg(7, "SkipIf: Test condtype %d, param 0x%08X, condval 0x%08X", condtype, param_val, cond_val);
    04047
    04048   /*
    04049    * Parameter (variable in specs) 0x88 can only have GRF ID checking
    04050    * conditions, except conditions 0x0B and 0x0C (cargo availability)
    04051    * as those ignore the parameter. So, when the condition type is
    04052    * either of those, the specific variable 0x88 code is skipped, so
    04053    * the "general" code for the cargo availability conditions kicks in.
    04054    */
    04055   if (param == 0x88 && condtype != 0x0B && condtype != 0x0C) {
    04056     /* GRF ID checks */
    04057
    04058     GRFConfig *c = GetGRFConfig(cond_val, mask);
    04059
    04060     if (c != NULL && HasBit(c->flags, GCF_STATIC) && !HasBit(_cur_grfconfig->flags, GCF_STATIC) && c->status != GCS_DISABLED && _networking) {
    04061       DisableStaticNewGRFInfluencingNonStaticNewGRFs(c);
    04062       c = NULL;
    04063     }
    04064
    04065     if (condtype != 10 && c == NULL) {
    04066       grfmsg(7, "SkipIf: GRFID 0x%08X unknown, skipping test", BSWAP32(cond_val));
    04067       return;
    04068     }
    04069
    04070     switch (condtype) {
    04071       /* Tests 0x06 to 0x0A are only for param 0x88, GRFID checks */
    04072       case 0x06: // Is GRFID active?
    04073         result = c->status == GCS_ACTIVATED;
    04074         break;
    04075
    04076       case 0x07: // Is GRFID non-active?
    04077         result = c->status != GCS_ACTIVATED;
    04078         break;
    04079
    04080       case 0x08: // GRFID is not but will be active?
    04081         result = c->status == GCS_INITIALISED;
    04082         break;
    04083
    04084       case 0x09: // GRFID is or will be active?
    04085         result = c->status == GCS_ACTIVATED || c->status == GCS_INITIALISED;
    04086         break;
    04087
    04088       case 0x0A: // GRFID is not nor will be active
    04089         /* This is the only condtype that doesn't get ignored if the GRFID is not found */
    04090         result = c == NULL || c->flags == GCS_DISABLED || c->status == GCS_NOT_FOUND;
    04091         break;
    04092
    04093       default: grfmsg(1, "SkipIf: Unsupported GRF condition type %02X. Ignoring", condtype); return;
    04094     }
    04095   } else {
    04096     /* Parameter or variable tests */
    04097     switch (condtype) {
    04098       case 0x00: result = !!(param_val & (1 << cond_val));
    04099         break;
    04100       case 0x01: result = !(param_val & (1 << cond_val));
    04101         break;
    04102       case 0x02: result = (param_val & mask) == cond_val;
    04103         break;
    04104       case 0x03: result = (param_val & mask) != cond_val;
    04105         break;
    04106       case 0x04: result = (param_val & mask) < cond_val;
    04107         break;
    04108       case 0x05: result = (param_val & mask) > cond_val;
    04109         break;
    04110       case 0x0B: result = GetCargoIDByLabel(BSWAP32(cond_val)) == CT_INVALID;
    04111         break;
    04112       case 0x0C: result = GetCargoIDByLabel(BSWAP32(cond_val)) != CT_INVALID;
    04113         break;
    04114       case 0x0D: result = GetRailTypeByLabel(BSWAP32(cond_val)) == INVALID_RAILTYPE;
    04115         break;
    04116       case 0x0E: result = GetRailTypeByLabel(BSWAP32(cond_val)) != INVALID_RAILTYPE;
    04117         break;
    04118
    04119       default: grfmsg(1, "SkipIf: Unsupported condition type %02X. Ignoring", condtype); return;
    04120     }
    04121   }
    04122
    04123   if (!result) {
    04124     grfmsg(2, "SkipIf: Not skipping sprites, test was false");
    04125     return;
    04126   }
    04127
    04128   uint8 numsprites = grf_load_byte(&buf);
    04129
    04130   /* numsprites can be a GOTO label if it has been defined in the GRF
    04131    * file. The jump will always be the first matching label that follows
    04132    * the current nfo_line. If no matching label is found, the first matching
    04133    * label in the file is used. */
    04134   GRFLabel *choice = NULL;
    04135   for (GRFLabel *label = _cur_grffile->label; label != NULL; label = label->next) {
    04136     if (label->label != numsprites) continue;
    04137
    04138     /* Remember a goto before the current line */
    04139     if (choice == NULL) choice = label;
    04140     /* If we find a label here, this is definitely good */
    04141     if (label->nfo_line > _nfo_line) {
    04142       choice = label;
    04143       break;
    04144     }
    04145   }
    04146
    04147   if (choice != NULL) {
    04148     grfmsg(2, "SkipIf: Jumping to label 0x%0X at line %d, test was true", choice->label, choice->nfo_line);
    04149     FioSeekTo(choice->pos, SEEK_SET);
    04150     _nfo_line = choice->nfo_line;
    04151     return;
    04152   }
    04153
    04154   grfmsg(2, "SkipIf: Skipping %d sprites, test was true", numsprites);
    04155   _skip_sprites = numsprites;
    04156   if (_skip_sprites == 0) {
    04157     /* Zero means there are no sprites to skip, so
    04158      * we use -1 to indicate that all further
    04159      * sprites should be skipped. */
    04160     _skip_sprites = -1;
    04161
    04162     /* If an action 8 hasn't been encountered yet, disable the grf. */
    04163     if (_cur_grfconfig->status != GCS_ACTIVATED) {
    04164       _cur_grfconfig->status = GCS_DISABLED;
    04165       ClearTemporaryNewGRFData(_cur_grffile);
    04166     }
    04167   }
    04168 }
    04169
    04170
    04171 /* Action 0x08 (GLS_FILESCAN) */
    04172 static void ScanInfo(byte *buf, size_t len)
    04173 {
    04174   if (!check_length(len, 8, "Info")) return;
    04175   buf++;
    04176   grf_load_byte(&buf);
    04177   uint32 grfid  = grf_load_dword(&buf);
    04178
    04179   _cur_grfconfig->grfid = grfid;
    04180
    04181   /* GRF IDs starting with 0xFF are reserved for internal TTDPatch use */
    04182   if (GB(grfid, 24, 8) == 0xFF) SetBit(_cur_grfconfig->flags, GCF_SYSTEM);
    04183
    04184   len -= 6;
    04185   const char *name = grf_load_string(&buf, len);
    04186   _cur_grfconfig->name = TranslateTTDPatchCodes(grfid, name);
    04187
    04188   len -= strlen(name) + 1;
    04189   if (len > 0) {
    04190     const char *info = grf_load_string(&buf, len);
    04191     _cur_grfconfig->info = TranslateTTDPatchCodes(grfid, info);
    04192   }
    04193
    04194   /* GLS_INFOSCAN only looks for the action 8, so we can skip the rest of the file */
    04195   _skip_sprites = -1;
    04196 }
    04197
    04198 /* Action 0x08 */
    04199 static void GRFInfo(byte *buf, size_t len)
    04200 {
    04201   /* <08> <version> <grf-id> <name> <info>
    04202    *
    04203    * B version       newgrf version, currently 06
    04204    * 4*B grf-id      globally unique ID of this .grf file
    04205    * S name          name of this .grf set
    04206    * S info          string describing the set, and e.g. author and copyright */
    04207
    04208   if (!check_length(len, 8, "GRFInfo")) return;
    04209   buf++;
    04210   uint8 version    = grf_load_byte(&buf);
    04211   uint32 grfid     = grf_load_dword(&buf);
    04212   const char *name = grf_load_string(&buf, len - 6);
    04213
    04214   if (_cur_stage < GLS_RESERVE && _cur_grfconfig->status != GCS_UNKNOWN) {
    04215     _cur_grfconfig->status = GCS_DISABLED;
    04216     _cur_grfconfig->error  = CallocT<GRFError>(1);
    04217     _cur_grfconfig->error->severity = STR_NEWGRF_ERROR_MSG_FATAL;
    04218     _cur_grfconfig->error->message  = STR_NEWGRF_ERROR_MULTIPLE_ACTION_8;
    04219
    04220     _skip_sprites = -1;
    04221     return;
    04222   }
    04223
    04224   _cur_grffile->grfid = grfid;
    04225   _cur_grffile->grf_version = version;
    04226   _cur_grfconfig->status = _cur_stage < GLS_RESERVE ? GCS_INITIALISED : GCS_ACTIVATED;
    04227
    04228   /* Do swap the GRFID for displaying purposes since people expect that */
    04229   DEBUG(grf, 1, "GRFInfo: Loaded GRFv%d set %08X - %s (palette: %s)", version, BSWAP32(grfid), name, _cur_grfconfig->windows_paletted ? "Windows" : "DOS");
    04230 }
    04231
    04232 /* Action 0x0A */
    04233 static void SpriteReplace(byte *buf, size_t len)
    04234 {
    04235   /* <0A> <num-sets> <set1> [<set2> ...]
    04236    * <set>: <num-sprites> <first-sprite>
    04237    *
    04238    * B num-sets      How many sets of sprites to replace.
    04239    * Each set:
    04240    * B num-sprites   How many sprites are in this set
    04241    * W first-sprite  First sprite number to replace */
    04242
    04243   buf++; // skip action byte
    04244   uint8 num_sets = grf_load_byte(&buf);
    04245
    04246   for (uint i = 0; i < num_sets; i++) {
    04247     uint8 num_sprites = grf_load_byte(&buf);
    04248     uint16 first_sprite = grf_load_word(&buf);
    04249
    04250     grfmsg(2, "SpriteReplace: [Set %d] Changing %d sprites, beginning with %d",
    04251       i, num_sprites, first_sprite
    04252     );
    04253
    04254     for (uint j = 0; j < num_sprites; j++) {
    04255       int load_index = first_sprite + j;
    04256       _nfo_line++;
    04257       LoadNextSprite(load_index, _file_index, _nfo_line); // XXX
    04258
    04259       /* Shore sprites now located at different addresses.
    04260        * So detect when the old ones get replaced. */
    04261       if (IsInsideMM(load_index, SPR_ORIGINALSHORE_START, SPR_ORIGINALSHORE_END + 1)) {
    04262         if (_loaded_newgrf_features.shore != SHORE_REPLACE_ACTION_5) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_A;
    04263       }
    04264     }
    04265   }
    04266 }
    04267
    04268 /* Action 0x0A (SKIP) */
    04269 static void SkipActA(byte *buf, size_t len)
    04270 {
    04271   buf++;
    04272   uint8 num_sets = grf_load_byte(&buf);
    04273
    04274   for (uint i = 0; i < num_sets; i++) {
    04275     /* Skip the sprites this replaces */
    04276     _skip_sprites += grf_load_byte(&buf);
    04277     /* But ignore where they go */
    04278     grf_load_word(&buf);
    04279   }
    04280
    04281   grfmsg(3, "SkipActA: Skipping %d sprites", _skip_sprites);
    04282 }
    04283
    04284 /* Action 0x0B */
    04285 static void GRFLoadError(byte *buf, size_t len)
    04286 {
    04287   /* <0B> <severity> <language-id> <message-id> [<message...> 00] [<data...>] 00 [<parnum>]
    04288    *
    04289    * B severity      00: notice, contine loading grf file
    04290    *                 01: warning, continue loading grf file
    04291    *                 02: error, but continue loading grf file, and attempt
    04292    *                     loading grf again when loading or starting next game
    04293    *                 03: error, abort loading and prevent loading again in
    04294    *                     the future (only when restarting the patch)
    04295    * B language-id   see action 4, use 1F for built-in error messages
    04296    * B message-id    message to show, see below
    04297    * S message       for custom messages (message-id FF), text of the message
    04298    *                 not present for built-in messages.
    04299    * V data          additional data for built-in (or custom) messages
    04300    * B parnum        parameter numbers to be shown in the message (maximum of 2) */
    04301
    04302   static const StringID msgstr[] = {
    04303     STR_NEWGRF_ERROR_VERSION_NUMBER,
    04304     STR_NEWGRF_ERROR_DOS_OR_WINDOWS,
    04305     STR_NEWGRF_ERROR_UNSET_SWITCH,
    04306     STR_NEWGRF_ERROR_INVALID_PARAMETER,
    04307     STR_NEWGRF_ERROR_LOAD_BEFORE,
    04308     STR_NEWGRF_ERROR_LOAD_AFTER,
    04309     STR_NEWGRF_ERROR_OTTD_VERSION_NUMBER,
    04310   };
    04311
    04312   static const StringID sevstr[] = {
    04313     STR_NEWGRF_ERROR_MSG_INFO,
    04314     STR_NEWGRF_ERROR_MSG_WARNING,
    04315     STR_NEWGRF_ERROR_MSG_ERROR,
    04316     STR_NEWGRF_ERROR_MSG_FATAL
    04317   };
    04318
    04319   if (!check_length(len, 6, "GRFLoadError")) return;
    04320
    04321   /* For now we can only show one message per newgrf file. */
    04322   if (_cur_grfconfig->error != NULL) return;
    04323
    04324   buf++; // Skip the action byte.
    04325   byte severity   = grf_load_byte(&buf);
    04326   byte lang       = grf_load_byte(&buf);
    04327   byte message_id = grf_load_byte(&buf);
    04328   len -= 4;
    04329
    04330   /* Skip the error if it isn't valid for the current language. */
    04331   if (!CheckGrfLangID(lang, _cur_grffile->grf_version)) return;
    04332
    04333   /* Skip the error until the activation stage unless bit 7 of the severity
    04334    * is set. */
    04335   if (!HasBit(severity, 7) && _cur_stage == GLS_INIT) {
    04336     grfmsg(7, "GRFLoadError: Skipping non-fatal GRFLoadError in stage %d", _cur_stage);
    04337     return;
    04338   }
    04339   ClrBit(severity, 7);
    04340
    04341   if (severity >= lengthof(sevstr)) {
    04342     grfmsg(7, "GRFLoadError: Invalid severity id %d. Setting to 2 (non-fatal error).", severity);
    04343     severity = 2;
    04344   } else if (severity == 3) {
    04345     /* This is a fatal error, so make sure the GRF is deactivated and no
    04346      * more of it gets loaded. */
    04347     _cur_grfconfig->status = GCS_DISABLED;
    04348     ClearTemporaryNewGRFData(_cur_grffile);
    04349     _skip_sprites = -1;
    04350   }
    04351
    04352   if (message_id >= lengthof(msgstr) && message_id != 0xFF) {
    04353     grfmsg(7, "GRFLoadError: Invalid message id.");
    04354     return;
    04355   }
    04356
    04357   if (len <= 1) {
    04358     grfmsg(7, "GRFLoadError: No message data supplied.");
    04359     return;
    04360   }
    04361
    04362   GRFError *error = CallocT<GRFError>(1);
    04363
    04364   error->severity = sevstr[severity];
    04365
    04366   if (message_id == 0xFF) {
    04367     /* This is a custom error message. */
    04368     const char *message = grf_load_string(&buf, len);
    04369     len -= (strlen(message) + 1);
    04370
    04371     error->custom_message = TranslateTTDPatchCodes(_cur_grffile->grfid, message);
    04372   } else {
    04373     error->message = msgstr[message_id];
    04374   }
    04375
    04376   if (len > 0) {
    04377     const char *data = grf_load_string(&buf, len);
    04378     len -= (strlen(data) + 1);
    04379
    04380     error->data = TranslateTTDPatchCodes(_cur_grffile->grfid, data);
    04381   }
    04382
    04383   /* Only two parameter numbers can be used in the string. */
    04384   uint i = 0;
    04385   for (; i < 2 && len > 0; i++) {
    04386     uint param_number = grf_load_byte(&buf);
    04387     error->param_value[i] = (param_number < _cur_grffile->param_end ? _cur_grffile->param[param_number] : 0);
    04388     len--;
    04389   }
    04390   error->num_params = i;
    04391
    04392   _cur_grfconfig->error = error;
    04393 }
    04394
    04395 /* Action 0x0C */
    04396 static void GRFComment(byte *buf, size_t len)
    04397 {
    04398   /* <0C> [<ignored...>]
    04399    *
    04400    * V ignored       Anything following the 0C is ignored */
    04401
    04402   if (len == 1) return;
    04403
    04404   size_t text_len = len - 1;
    04405   const char *text = (const char*)(buf + 1);
    04406   grfmsg(2, "GRFComment: %.*s", (int)text_len, text);
    04407 }
    04408
    04409 /* Action 0x0D (GLS_SAFETYSCAN) */
    04410 static void SafeParamSet(byte *buf, size_t len)
    04411 {
    04412   if (!check_length(len, 5, "SafeParamSet")) return;
    04413   buf++;
    04414   uint8 target = grf_load_byte(&buf);
    04415
    04416   /* Only writing GRF parameters is considered safe */
    04417   if (target < 0x80) return;
    04418
    04419   /* GRM could be unsafe, but as here it can only happen after other GRFs
    04420    * are loaded, it should be okay. If the GRF tried to use the slots it
    04421    * reserved, it would be marked unsafe anyway. GRM for (e.g. bridge)
    04422    * sprites  is considered safe. */
    04423
    04424   SetBit(_cur_grfconfig->flags, GCF_UNSAFE);
    04425
    04426   /* Skip remainder of GRF */
    04427   _skip_sprites = -1;
    04428 }
    04429
    04430
    04431 static uint32 GetPatchVariable(uint8 param)
    04432 {
    04433   switch (param) {
    04434     /* start year - 1920 */
    04435     case 0x0B: return max(_settings_game.game_creation.starting_year, ORIGINAL_BASE_YEAR) - ORIGINAL_BASE_YEAR;
    04436
    04437     /* freight trains weight factor */
    04438     case 0x0E: return _settings_game.vehicle.freight_trains;
    04439
    04440     /* empty wagon speed increase */
    04441     case 0x0F: return 0;
    04442
    04443     /* plane speed factor; our patch option is reversed from TTDPatch's,
    04444      * the following is good for 1x, 2x and 4x (most common?) and...
    04445      * well not really for 3x. */
    04446     case 0x10:
    04447       switch (_settings_game.vehicle.plane_speed) {
    04448         default:
    04449         case 4: return 1;
    04450         case 3: return 2;
    04451         case 2: return 2;
    04452         case 1: return 4;
    04453       }
    04454
    04455
    04456     /* 2CC colourmap base sprite */
    04457     case 0x11: return SPR_2CCMAP_BASE;
    04458
    04459     /* map size: format = -MABXYSS
    04460      * M  : the type of map
    04461      *       bit 0 : set   : squared map. Bit 1 is now not relevant
    04462      *               clear : rectangle map. Bit 1 will indicate the bigger edge of the map
    04463      *       bit 1 : set   : Y is the bigger edge. Bit 0 is clear
    04464      *               clear : X is the bigger edge.
    04465      * A  : minimum edge(log2) of the map
    04466      * B  : maximum edge(log2) of the map
    04467      * XY : edges(log2) of each side of the map.
    04468      * SS : combination of both X and Y, thus giving the size(log2) of the map
    04469      */
    04470     case 0x13: {
    04471       byte map_bits = 0;
    04472       byte log_X = MapLogX() - 6; // substraction is required to make the minimal size (64) zero based
    04473       byte log_Y = MapLogY() - 6;
    04474       byte max_edge = max(log_X, log_Y);
    04475
    04476       if (log_X == log_Y) { // we have a squared map, since both edges are identical
    04477         SetBit(map_bits ,0);
    04478       } else {
    04479         if (max_edge == log_Y) SetBit(map_bits, 1); // edge Y been the biggest, mark it
    04480       }
    04481
    04482       return (map_bits << 24) | (min(log_X, log_Y) << 20) | (max_edge << 16) |
    04483         (log_X << 12) | (log_Y << 8) | (log_X + log_Y);
    04484     }
    04485
    04486     default:
    04487       grfmsg(2, "ParamSet: Unknown Patch variable 0x%02X.", param);
    04488       return 0;
    04489   }
    04490 }
    04491
    04492
    04493 static uint32 PerformGRM(uint32 *grm, uint16 num_ids, uint16 count, uint8 op, uint8 target, const char *type)
    04494 {
    04495   uint start = 0;
    04496   uint size  = 0;
    04497
    04498   if (op == 6) {
    04499     /* Return GRFID of set that reserved ID */
    04500     return grm[_cur_grffile->param[target]];
    04501   }
    04502
    04503   /* With an operation of 2 or 3, we want to reserve a specific block of IDs */
    04504   if (op == 2 || op == 3) start = _cur_grffile->param[target];
    04505
    04506   for (uint i = start; i < num_ids; i++) {
    04507     if (grm[i] == 0) {
    04508       size++;
    04509     } else {
    04510       if (op == 2 || op == 3) break;
    04511       start = i + 1;
    04512       size = 0;
    04513     }
    04514
    04515     if (size == count) break;
    04516   }
    04517
    04518   if (size == count) {
    04519     /* Got the slot... */
    04520     if (op == 0 || op == 3) {
    04521       grfmsg(2, "ParamSet: GRM: Reserving %d %s at %d", count, type, start);
    04522       for (uint i = 0; i < count; i++) grm[start + i] = _cur_grffile->grfid;
    04523     }
    04524     return start;
    04525   }
    04526
    04527   /* Unable to allocate */
    04528   if (op != 4 && op != 5) {
    04529     /* Deactivate GRF */
    04530     grfmsg(0, "ParamSet: GRM: Unable to allocate %d %s, deactivating", count, type);
    04531     _cur_grfconfig->status = GCS_DISABLED;
    04532     ClearTemporaryNewGRFData(_cur_grffile);
    04533     _skip_sprites = -1;
    04534     return UINT_MAX;
    04535   }
    04536
    04537   grfmsg(1, "ParamSet: GRM: Unable to allocate %d %s", count, type);
    04538   return UINT_MAX;
    04539 }
    04540
    04541
    04542 /* Action 0x0D */
    04543 static void ParamSet(byte *buf, size_t len)
    04544 {
    04545   /* <0D> <target> <operation> <source1> <source2> [<data>]
    04546    *
    04547    * B target        parameter number where result is stored
    04548    * B operation     operation to perform, see below
    04549    * B source1       first source operand
    04550    * B source2       second source operand
    04551    * D data          data to use in the calculation, not necessary
    04552    *                 if both source1 and source2 refer to actual parameters
    04553    *
    04554    * Operations
    04555    * 00      Set parameter equal to source1
    04556    * 01      Addition, source1 + source2
    04557    * 02      Subtraction, source1 - source2
    04558    * 03      Unsigned multiplication, source1 * source2 (both unsigned)
    04559    * 04      Signed multiplication, source1 * source2 (both signed)
    04560    * 05      Unsigned bit shift, source1 by source2 (source2 taken to be a
    04561    *         signed quantity; left shift if positive and right shift if
    04562    *         negative, source1 is unsigned)
    04563    * 06      Signed bit shift, source1 by source2
    04564    *         (source2 like in 05, and source1 as well)
    04565    */
    04566
    04567   if (!check_length(len, 5, "ParamSet")) return;
    04568   buf++;
    04569   uint8 target = grf_load_byte(&buf);
    04570   uint8 oper   = grf_load_byte(&buf);
    04571   uint32 src1  = grf_load_byte(&buf);
    04572   uint32 src2  = grf_load_byte(&buf);
    04573
    04574   uint32 data = 0;
    04575   if (len >= 8) data = grf_load_dword(&buf);
    04576
    04577   /* You can add 80 to the operation to make it apply only if the target
    04578    * is not defined yet.  In this respect, a parameter is taken to be
    04579    * defined if any of the following applies:
    04580    * - it has been set to any value in the newgrf(w).cfg parameter list
    04581    * - it OR A PARAMETER WITH HIGHER NUMBER has been set to any value by
    04582    *   an earlier action D */
    04583   if (HasBit(oper, 7)) {
    04584     if (target < 0x80 && target < _cur_grffile->param_end) {
    04585       grfmsg(7, "ParamSet: Param %u already defined, skipping", target);
    04586       return;
    04587     }
    04588
    04589     oper = GB(oper, 0, 7);
    04590   }
    04591
    04592   if (src2 == 0xFE) {
    04593     if (GB(data, 0, 8) == 0xFF) {
    04594       if (data == 0x0000FFFF) {
    04595         /* Patch variables */
    04596         src1 = GetPatchVariable(src1);
    04597       } else {
    04598         /* GRF Resource Management */
    04599         uint8  op      = src1;
    04600         uint8  feature = GB(data, 8, 8);
    04601         uint16 count   = GB(data, 16, 16);
    04602
    04603         if (_cur_stage == GLS_RESERVE) {
    04604           if (feature == 0x08) {
    04605             /* General sprites */
    04606             if (op == 0) {
    04607               /* Check if the allocated sprites will fit below the original sprite limit */
    04608               if (_cur_spriteid + count >= 16384) {
    04609                 grfmsg(0, "ParamSet: GRM: Unable to allocate %d sprites; try changing NewGRF order", count);
    04610                 _cur_grfconfig->status = GCS_DISABLED;
    04611                 ClearTemporaryNewGRFData(_cur_grffile);
    04612                 _skip_sprites = -1;
    04613                 return;
    04614               }
    04615
    04616               /* Reserve space at the current sprite ID */
    04617               grfmsg(4, "ParamSet: GRM: Allocated %d sprites at %d", count, _cur_spriteid);
    04618               _grm_sprites[GRFLocation(_cur_grffile->grfid, _nfo_line)] = _cur_spriteid;
    04619               _cur_spriteid += count;
    04620             }
    04621           }
    04622           /* Ignore GRM result during reservation */
    04623           src1 = 0;
    04624         } else if (_cur_stage == GLS_ACTIVATION) {
    04625           switch (feature) {
    04626             case 0x00: // Trains
    04627             case 0x01: // Road Vehicles
    04628             case 0x02: // Ships
    04629             case 0x03: // Aircraft
    04630               if (!_settings_game.vehicle.dynamic_engines) {
    04631                 src1 = PerformGRM(&_grm_engines[_engine_offsets[feature]], _engine_counts[feature], count, op, target, "vehicles");
    04632                 if (_skip_sprites == -1) return;
    04633               } else {
    04634                 /* GRM does not apply for dynamic engine allocation. */
    04635                 switch (op) {
    04636                   case 2:
    04637                   case 3:
    04638                     src1 = _cur_grffile->param[target];
    04639                     break;
    04640
    04641                   default:
    04642                     src1 = 0;
    04643                     break;
    04644                 }
    04645               }
    04646               break;
    04647
    04648             case 0x08: // General sprites
    04649               switch (op) {
    04650                 case 0:
    04651                   /* Return space reserved during reservation stage */
    04652                   src1 = _grm_sprites[GRFLocation(_cur_grffile->grfid, _nfo_line)];
    04653                   grfmsg(4, "ParamSet: GRM: Using pre-allocated sprites at %d", src1);
    04654                   break;
    04655
    04656                 case 1:
    04657                   src1 = _cur_spriteid;
    04658                   break;
    04659
    04660                 default:
    04661                   grfmsg(1, "ParamSet: GRM: Unsupported operation %d for general sprites", op);
    04662                   return;
    04663               }
    04664               break;
    04665
    04666             case 0x0B: // Cargo
    04667               /* There are two ranges: one for cargo IDs and one for cargo bitmasks */
    04668               src1 = PerformGRM(_grm_cargos, NUM_CARGO * 2, count, op, target, "cargos");
    04669               if (_skip_sprites == -1) return;
    04670               break;
    04671
    04672             default: grfmsg(1, "ParamSet: GRM: Unsupported feature 0x%X", feature); return;
    04673           }
    04674         } else {
    04675           /* Ignore GRM during initialization */
    04676           src1 = 0;
    04677         }
    04678       }
    04679     } else {
    04680       /* Read another GRF File's parameter */
    04681       const GRFFile *file = GetFileByGRFID(data);
    04682       GRFConfig *c = GetGRFConfig(data);
    04683       if (c != NULL && HasBit(c->flags, GCF_STATIC) && !HasBit(_cur_grfconfig->flags, GCF_STATIC) && _networking) {
    04684         /* Disable the read GRF if it is a static NewGRF. */
    04685         DisableStaticNewGRFInfluencingNonStaticNewGRFs(c);
    04686         src1 = 0;
    04687       } else if (file == NULL || src1 >= file->param_end || (c != NULL && c->status == GCS_DISABLED)) {
    04688         src1 = 0;
    04689       } else {
    04690         src1 = file->param[src1];
    04691       }
    04692     }
    04693   } else {
    04694     /* The source1 and source2 operands refer to the grf parameter number
    04695      * like in action 6 and 7.  In addition, they can refer to the special
    04696      * variables available in action 7, or they can be FF to use the value
    04697      * of <data>.  If referring to parameters that are undefined, a value
    04698      * of 0 is used instead.  */
    04699     src1 = (src1 == 0xFF) ? data : GetParamVal(src1, NULL);
    04700     src2 = (src2 == 0xFF) ? data : GetParamVal(src2, NULL);
    04701   }
    04702
    04703   /* TODO: You can access the parameters of another GRF file by using
    04704    * source2=FE, source1=the other GRF's parameter number and data=GRF
    04705    * ID.  This is only valid with operation 00 (set).  If the GRF ID
    04706    * cannot be found, a value of 0 is used for the parameter value
    04707    * instead. */
    04708
    04709   uint32 res;
    04710   switch (oper) {
    04711     case 0x00:
    04712       res = src1;
    04713       break;
    04714
    04715     case 0x01:
    04716       res = src1 + src2;
    04717       break;
    04718
    04719     case 0x02:
    04720       res = src1 - src2;
    04721       break;
    04722
    04723     case 0x03:
    04724       res = src1 * src2;
    04725       break;
    04726
    04727     case 0x04:
    04728       res = (int32)src1 * (int32)src2;
    04729       break;
    04730
    04731     case 0x05:
    04732       if ((int32)src2 < 0) {
    04733         res = src1 >> -(int32)src2;
    04734       } else {
    04735         res = src1 << src2;
    04736       }
    04737       break;
    04738
    04739     case 0x06:
    04740       if ((int32)src2 < 0) {
    04741         res = (int32)src1 >> -(int32)src2;
    04742       } else {
    04743         res = (int32)src1 << src2;
    04744       }
    04745       break;
    04746
    04747     case 0x07: // Bitwise AND
    04748       res = src1 & src2;
    04749       break;
    04750
    04751     case 0x08: // Bitwise OR
    04752       res = src1 | src2;
    04753       break;
    04754
    04755     case 0x09: // Unsigned division
    04756       if (src2 == 0) {
    04757         res = src1;
    04758       } else {
    04759         res = src1 / src2;
    04760       }
    04761       break;
    04762
    04763     case 0x0A: // Signed divison
    04764       if (src2 == 0) {
    04765         res = src1;
    04766       } else {
    04767         res = (int32)src1 / (int32)src2;
    04768       }
    04769       break;
    04770
    04771     case 0x0B: // Unsigned modulo
    04772       if (src2 == 0) {
    04773         res = src1;
    04774       } else {
    04775         res = src1 % src2;
    04776       }
    04777       break;
    04778
    04779     case 0x0C: // Signed modulo
    04780       if (src2 == 0) {
    04781         res = src1;
    04782       } else {
    04783         res = (int32)src1 % (int32)src2;
    04784       }
    04785       break;
    04786
    04787     default: grfmsg(0, "ParamSet: Unknown operation %d, skipping", oper); return;
    04788   }
    04789
    04790   switch (target) {
    04791     case 0x8E: // Y-Offset for train sprites
    04792       _traininfo_vehicle_pitch = res;
    04793       break;
    04794
    04795     case 0x8F: { // Rail track type cost factors
    04796       extern RailtypeInfo _railtypes[RAILTYPE_END];
    04797       _railtypes[RAILTYPE_RAIL].cost_multiplier = GB(res, 0, 8);
    04798       if (_settings_game.vehicle.disable_elrails) {
    04799         _railtypes[RAILTYPE_ELECTRIC].cost_multiplier = GB(res, 0, 8);
    04800         _railtypes[RAILTYPE_MONO].cost_multiplier = GB(res, 8, 8);
    04801       } else {
    04802         _railtypes[RAILTYPE_ELECTRIC].cost_multiplier = GB(res, 8, 8);
    04803         _railtypes[RAILTYPE_MONO].cost_multiplier = GB(res, 16, 8);
    04804       }
    04805       _railtypes[RAILTYPE_MAGLEV].cost_multiplier = GB(res, 16, 8);
    04806       break;
    04807     }
    04808
    04809     /* @todo implement */
    04810     case 0x93: // Tile refresh offset to left
    04811     case 0x94: // Tile refresh offset to right
    04812     case 0x95: // Tile refresh offset upwards
    04813     case 0x96: // Tile refresh offset downwards
    04814     case 0x97: // Snow line height
    04815     case 0x99: // Global ID offset
    04816       grfmsg(7, "ParamSet: Skipping unimplemented target 0x%02X", target);
    04817       break;
    04818
    04819     case 0x9E: // Miscellaneous GRF features
    04820       _misc_grf_features = res;
    04821       /* Set train list engine width */
    04822       _traininfo_vehicle_width = HasGrfMiscBit(GMB_TRAIN_WIDTH_32_PIXELS) ? 32 : 29;
    04823       break;
    04824
    04825     case 0x9F: // locale-dependent settings
    04826       grfmsg(7, "ParamSet: Skipping unimplemented target 0x%02X", target);
    04827       break;
    04828
    04829     default:
    04830       if (target < 0x80) {
    04831         _cur_grffile->param[target] = res;
    04832         if (target + 1U > _cur_grffile->param_end) _cur_grffile->param_end = target + 1;
    04833       } else {
    04834         grfmsg(7, "ParamSet: Skipping unknown target 0x%02X", target);
    04835       }
    04836       break;
    04837   }
    04838 }
    04839
    04840 /* Action 0x0E (GLS_SAFETYSCAN) */
    04841 static void SafeGRFInhibit(byte *buf, size_t len)
    04842 {
    04843   /* <0E> <num> <grfids...>
    04844    *
    04845    * B num           Number of GRFIDs that follow
    04846    * D grfids        GRFIDs of the files to deactivate */
    04847
    04848   if (!check_length(len, 2, "GRFInhibit")) return;
    04849   buf++;
    04850   uint8 num = grf_load_byte(&buf);
    04851   if (!check_length(len, 2 + 4 * num, "GRFInhibit")) return;
    04852
    04853   for (uint i = 0; i < num; i++) {
    04854     uint32 grfid = grf_load_dword(&buf);
    04855
    04856     /* GRF is unsafe it if tries to deactivate other GRFs */
    04857     if (grfid != _cur_grfconfig->grfid) {
    04858       SetBit(_cur_grfconfig->flags, GCF_UNSAFE);
    04859
    04860       /* Skip remainder of GRF */
    04861       _skip_sprites = -1;
    04862
    04863       return;
    04864     }
    04865   }
    04866 }
    04867
    04868 /* Action 0x0E */
    04869 static void GRFInhibit(byte *buf, size_t len)
    04870 {
    04871   /* <0E> <num> <grfids...>
    04872    *
    04873    * B num           Number of GRFIDs that follow
    04874    * D grfids        GRFIDs of the files to deactivate */
    04875
    04876   if (!check_length(len, 2, "GRFInhibit")) return;
    04877   buf++;
    04878   uint8 num = grf_load_byte(&buf);
    04879   if (!check_length(len, 2 + 4 * num, "GRFInhibit")) return;
    04880
    04881   for (uint i = 0; i < num; i++) {
    04882     uint32 grfid = grf_load_dword(&buf);
    04883     GRFConfig *file = GetGRFConfig(grfid);
    04884
    04885     /* Unset activation flag */
    04886     if (file != NULL && file != _cur_grfconfig) {
    04887       grfmsg(2, "GRFInhibit: Deactivating file '%s'", file->filename);
    04888       file->status = GCS_DISABLED;
    04889     }
    04890   }
    04891 }
    04892
    04893 /* Action 0x0F */
    04894 static void FeatureTownName(byte *buf, size_t len)
    04895 {
    04896   /* <0F> <id> <style-name> <num-parts> <parts>
    04897    *
    04898    * B id          ID of this definition in bottom 7 bits (final definition if bit 7 set)
    04899    * V style-name  Name of the style (only for final definition)
    04900    * B num-parts   Number of parts in this definition
    04901    * V parts       The parts */
    04902
    04903   if (!check_length(len, 1, "FeatureTownName: definition ID")) return;
    04904   buf++; len--;
    04905
    04906   uint32 grfid = _cur_grffile->grfid;
    04907
    04908   GRFTownName *townname = AddGRFTownName(grfid);
    04909
    04910   byte id = grf_load_byte(&buf);
    04911   len--;
    04912   grfmsg(6, "FeatureTownName: definition 0x%02X", id & 0x7F);
    04913
    04914   if (HasBit(id, 7)) {
    04915     /* Final definition */
    04916     ClrBit(id, 7);
    04917     bool new_scheme = _cur_grffile->grf_version >= 7;
    04918
    04919     if (!check_length(len, 1, "FeatureTownName: lang_id")) return;
    04920     byte lang = grf_load_byte(&buf);
    04921     len--;
    04922
    04923     byte nb_gen = townname->nb_gen;
    04924     do {
    04925       ClrBit(lang, 7);
    04926
    04927       if (!check_length(len, 1, "FeatureTownName: style name")) return;
    04928       const char *name = grf_load_string(&buf, len);
    04929       len -= strlen(name) + 1;
    04930
    04931       char *lang_name = TranslateTTDPatchCodes(grfid, name);
    04932       grfmsg(6, "FeatureTownName: lang 0x%X -> '%s'", lang, lang_name);
    04933       free(lang_name);
    04934
    04935       townname->name[nb_gen] = AddGRFString(grfid, id, lang, new_scheme, name, STR_UNDEFINED);
    04936
    04937       if (!check_length(len, 1, "FeatureTownName: lang_id")) return;
    04938       lang = grf_load_byte(&buf);
    04939       len--;
    04940     } while (lang != 0);
    04941     townname->id[nb_gen] = id;
    04942     townname->nb_gen++;
    04943   }
    04944
    04945   if (!check_length(len, 1, "FeatureTownName: number of parts")) return;
    04946   byte nb = grf_load_byte(&buf);
    04947   len--;
    04948   grfmsg(6, "FeatureTownName: %u parts", nb);
    04949
    04950   townname->nbparts[id] = nb;
    04951   townname->partlist[id] = CallocT<NamePartList>(nb);
    04952
    04953   for (int i = 0; i < nb; i++) {
    04954     if (!check_length(len, 3, "FeatureTownName: parts header")) return;
    04955     byte nbtext =  grf_load_byte(&buf);
    04956     townname->partlist[id][i].bitstart  = grf_load_byte(&buf);
    04957     townname->partlist[id][i].bitcount  = grf_load_byte(&buf);
    04958     townname->partlist[id][i].maxprob   = 0;
    04959     townname->partlist[id][i].partcount = nbtext;
    04960     townname->partlist[id][i].parts     = CallocT<NamePart>(nbtext);
    04961     len -= 3;
    04962     grfmsg(6, "FeatureTownName: part %d contains %d texts and will use GB(seed, %d, %d)", i, nbtext, townname->partlist[id][i].bitstart, townname->partlist[id][i].bitcount);
    04963
    04964     for (int j = 0; j < nbtext; j++) {
    04965       if (!check_length(len, 2, "FeatureTownName: part")) return;
    04966       byte prob = grf_load_byte(&buf);
    04967       len--;
    04968
    04969       if (HasBit(prob, 7)) {
    04970         byte ref_id = grf_load_byte(&buf);
    04971         len--;
    04972
    04973         if (townname->nbparts[ref_id] == 0) {
    04974           grfmsg(0, "FeatureTownName: definition 0x%02X doesn't exist, deactivating", ref_id);
    04975           DelGRFTownName(grfid);
    04976           _cur_grfconfig->status = GCS_DISABLED;
    04977           ClearTemporaryNewGRFData(_cur_grffile);
    04978           _skip_sprites = -1;
    04979           return;
    04980         }
    04981
    04982         grfmsg(6, "FeatureTownName: part %d, text %d, uses intermediate definition 0x%02X (with probability %d)", i, j, ref_id, prob & 0x7F);
    04983         townname->partlist[id][i].parts[j].data.id = ref_id;
    04984       } else {
    04985         const char *text = grf_load_string(&buf, len);
    04986         len -= strlen(text) + 1;
    04987         townname->partlist[id][i].parts[j].data.text = TranslateTTDPatchCodes(grfid, text);
    04988         grfmsg(6, "FeatureTownName: part %d, text %d, '%s' (with probability %d)", i, j, townname->partlist[id][i].parts[j].data.text, prob);
    04989       }
    04990       townname->partlist[id][i].parts[j].prob = prob;
    04991       townname->partlist[id][i].maxprob += GB(prob, 0, 7);
    04992     }
    04993     grfmsg(6, "FeatureTownName: part %d, total probability %d", i, townname->partlist[id][i].maxprob);
    04994   }
    04995 }
    04996
    04997 /* Action 0x10 */
    04998 static void DefineGotoLabel(byte *buf, size_t len)
    04999 {
    05000   /* <10> <label> [<comment>]
    05001    *
    05002    * B label      The label to define
    05003    * V comment    Optional comment - ignored */
    05004
    05005   if (!check_length(len, 1, "DefineGotoLabel")) return;
    05006   buf++; len--;
    05007
    05008   GRFLabel *label = MallocT<GRFLabel>(1);
    05009   label->label    = grf_load_byte(&buf);
    05010   label->nfo_line = _nfo_line;
    05011   label->pos      = FioGetPos();
    05012   label->next     = NULL;
    05013
    05014   /* Set up a linked list of goto targets which we will search in an Action 0x7/0x9 */
    05015   if (_cur_grffile->label == NULL) {
    05016     _cur_grffile->label = label;
    05017   } else {
    05018     /* Attach the label to the end of the list */
    05019     GRFLabel *l;
    05020     for (l = _cur_grffile->label; l->next != NULL; l = l->next) {}
    05021     l->next = label;
    05022   }
    05023
    05024   grfmsg(2, "DefineGotoLabel: GOTO target with label 0x%02X", label->label);
    05025 }
    05026
    05027 /* Action 0x11 */
    05028 static void GRFSound(byte *buf, size_t len)
    05029 {
    05030   /* <11> <num>
    05031    *
    05032    * W num      Number of sound files that follow */
    05033
    05034   if (!check_length(len, 1, "GRFSound")) return;
    05035   buf++;
    05036   uint16 num = grf_load_word(&buf);
    05037
    05038   _grf_data_blocks = num;
    05039   _grf_data_type   = GDT_SOUND;
    05040
    05041   if (_cur_grffile->sound_offset == 0) _cur_grffile->sound_offset = GetNumSounds();
    05042 }
    05043
    05044 /* Action 0x11 (SKIP) */
    05045 static void SkipAct11(byte *buf, size_t len)
    05046 {
    05047   /* <11> <num>
    05048    *
    05049    * W num      Number of sound files that follow */
    05050
    05051   if (!check_length(len, 1, "SkipAct11")) return;
    05052   buf++;
    05053   _skip_sprites = grf_load_word(&buf);
    05054
    05055   grfmsg(3, "SkipAct11: Skipping %d sprites", _skip_sprites);
    05056 }
    05057
    05058 static void ImportGRFSound(byte *buf, int len)
    05059 {
    05060   const GRFFile *file;
    05061   FileEntry *se = AllocateFileEntry();
    05062   uint32 grfid = grf_load_dword(&buf);
    05063   uint16 sound = grf_load_word(&buf);
    05064
    05065   file = GetFileByGRFID(grfid);
    05066   if (file == NULL || file->sound_offset == 0) {
    05067     grfmsg(1, "ImportGRFSound: Source file not available");
    05068     return;
    05069   }
    05070
    05071   if (file->sound_offset + sound >= GetNumSounds()) {
    05072     grfmsg(1, "ImportGRFSound: Sound effect %d is invalid", sound);
    05073     return;
    05074   }
    05075
    05076   grfmsg(2, "ImportGRFSound: Copying sound %d (%d) from file %X", sound, file->sound_offset + sound, grfid);
    05077
    05078   *se = *GetSound(file->sound_offset + sound);
    05079
    05080   /* Reset volume and priority, which TTDPatch doesn't copy */
    05081   se->volume   = 128;
    05082   se->priority = 0;
    05083 }
    05084
    05085 /* 'Action 0xFE' */
    05086 static void GRFImportBlock(byte *buf, int len)
    05087 {
    05088   if (_grf_data_blocks == 0) {
    05089     grfmsg(2, "GRFImportBlock: Unexpected import block, skipping");
    05090     return;
    05091   }
    05092
    05093   buf++;
    05094
    05095   _grf_data_blocks--;
    05096
    05097   /* XXX 'Action 0xFE' isn't really specified. It is only mentioned for
    05098    * importing sounds, so this is probably all wrong... */
    05099   if (grf_load_byte(&buf) != _grf_data_type) {
    05100     grfmsg(1, "GRFImportBlock: Import type mismatch");
    05101   }
    05102
    05103   switch (_grf_data_type) {
    05104     case GDT_SOUND: ImportGRFSound(buf, len - 1); break;
    05105     default: NOT_REACHED(); break;
    05106   }
    05107 }
    05108
    05109 static void LoadGRFSound(byte *buf, int len)
    05110 {
    05111   byte *buf_start = buf;
    05112
    05113   /* Allocate a sound entry. This is done even if the data is not loaded
    05114    * so that the indices used elsewhere are still correct. */
    05115   FileEntry *se = AllocateFileEntry();
    05116
    05117   if (grf_load_dword(&buf) != BSWAP32('RIFF')) {
    05118     grfmsg(1, "LoadGRFSound: Missing RIFF header");
    05119     return;
    05120   }
    05121
    05122   /* Size of file -- we ignore this */
    05123   grf_load_dword(&buf);
    05124
    05125   if (grf_load_dword(&buf) != BSWAP32('WAVE')) {
    05126     grfmsg(1, "LoadGRFSound: Invalid RIFF type");
    05127     return;
    05128   }
    05129
    05130   for (;;) {
    05131     uint32 tag  = grf_load_dword(&buf);
    05132     uint32 size = grf_load_dword(&buf);
    05133
    05134     switch (tag) {
    05135       case ' tmf': // 'fmt '
    05136         /* Audio format, must be 1 (PCM) */
    05137         if (grf_load_word(&buf) != 1) {
    05138           grfmsg(1, "LoadGRFSound: Invalid audio format");
    05139           return;
    05140         }
    05141         se->channels = grf_load_word(&buf);
    05142         se->rate = grf_load_dword(&buf);
    05143         grf_load_dword(&buf);
    05144         grf_load_word(&buf);
    05145         se->bits_per_sample = grf_load_word(&buf);
    05146
    05147         /* Consume any extra bytes */
    05148         for (; size > 16; size--) grf_load_byte(&buf);
    05149         break;
    05150
    05151       case 'atad': // 'data'
    05152         se->file_size   = size;
    05153         se->file_offset = FioGetPos() - (len - (buf - buf_start)) + 1;
    05154         se->file_slot   = _file_index;
    05155
    05156         /* Set default volume and priority */
    05157         se->volume = 0x80;
    05158         se->priority = 0;
    05159
    05160         grfmsg(2, "LoadGRFSound: channels %u, sample rate %u, bits per sample %u, length %u", se->channels, se->rate, se->bits_per_sample, size);
    05161         return;
    05162
    05163       default:
    05164         se->file_size = 0;
    05165         return;
    05166     }
    05167   }
    05168 }
    05169
    05170 /* Action 0x12 */
    05171 static void LoadFontGlyph(byte *buf, size_t len)
    05172 {
    05173   /* <12> <num_def> <font_size> <num_char> <base_char>
    05174    *
    05175    * B num_def      Number of definitions
    05176    * B font_size    Size of font (0 = normal, 1 = small, 2 = large)
    05177    * B num_char     Number of consecutive glyphs
    05178    * W base_char    First character index */
    05179
    05180   buf++; len--;
    05181   if (!check_length(len, 1, "LoadFontGlyph")) return;
    05182
    05183   uint8 num_def = grf_load_byte(&buf);
    05184
    05185   if (!check_length(len, 1 + num_def * 4, "LoadFontGlyph")) return;
    05186
    05187   for (uint i = 0; i < num_def; i++) {
    05188     FontSize size    = (FontSize)grf_load_byte(&buf);
    05189     uint8  num_char  = grf_load_byte(&buf);
    05190     uint16 base_char = grf_load_word(&buf);
    05191
    05192     grfmsg(7, "LoadFontGlyph: Loading %u glyph(s) at 0x%04X for size %u", num_char, base_char, size);
    05193
    05194     for (uint c = 0; c < num_char; c++) {
    05195       SetUnicodeGlyph(size, base_char + c, _cur_spriteid);
    05196       _nfo_line++;
    05197       LoadNextSprite(_cur_spriteid++, _file_index, _nfo_line);
    05198     }
    05199   }
    05200 }
    05201
    05202 /* Action 0x12 (SKIP) */
    05203 static void SkipAct12(byte *buf, size_t len)
    05204 {
    05205   /* <12> <num_def> <font_size> <num_char> <base_char>
    05206    *
    05207    * B num_def      Number of definitions
    05208    * B font_size    Size of font (0 = normal, 1 = small, 2 = large)
    05209    * B num_char     Number of consecutive glyphs
    05210    * W base_char    First character index */
    05211
    05212   buf++; len--;
    05213   if (!check_length(len, 1, "SkipAct12")) return;
    05214   uint8 num_def = grf_load_byte(&buf);
    05215
    05216   if (!check_length(len, 1 + num_def * 4, "SkipAct12")) return;
    05217
    05218   for (uint i = 0; i < num_def; i++) {
    05219     /* Ignore 'size' byte */
    05220     grf_load_byte(&buf);
    05221
    05222     /* Sum up number of characters */
    05223     _skip_sprites += grf_load_byte(&buf);
    05224
    05225     /* Ignore 'base_char' word */
    05226     grf_load_word(&buf);
    05227   }
    05228
    05229   grfmsg(3, "SkipAct12: Skipping %d sprites", _skip_sprites);
    05230 }
    05231
    05232 /* Action 0x13 */
    05233 static void TranslateGRFStrings(byte *buf, size_t len)
    05234 {
    05235   /* <13> <grfid> <num-ent> <offset> <text...>
    05236    *
    05237    * 4*B grfid     The GRFID of the file whose texts are to be translated
    05238    * B   num-ent   Number of strings
    05239    * W   offset    First text ID
    05240    * S   text...   Zero-terminated strings */
    05241
    05242   buf++; len--;
    05243   if (!check_length(len, 7, "TranslateGRFString")) return;
    05244
    05245   uint32 grfid = grf_load_dword(&buf);
    05246   const GRFConfig *c = GetGRFConfig(grfid);
    05247   if (c == NULL || (c->status != GCS_INITIALISED && c->status != GCS_ACTIVATED)) {
    05248     grfmsg(7, "TranslateGRFStrings: GRFID 0x%08x unknown, skipping action 13", BSWAP32(grfid));
    05249     return;
    05250   }
    05251
    05252   if (c->status == GCS_INITIALISED) {
    05253     /* If the file is not active but will be activated later, give an error
    05254      * and disable this file. */
    05255     GRFError *error = CallocT<GRFError>(1);
    05256
    05257     char tmp[256];
    05258     GetString(tmp, STR_NEWGRF_ERROR_AFTER_TRANSLATED_FILE, lastof(tmp));
    05259     error->data = strdup(tmp);
    05260
    05261     error->message  = STR_NEWGRF_ERROR_LOAD_AFTER;
    05262     error->severity = STR_NEWGRF_ERROR_MSG_FATAL;
    05263
    05264     if (_cur_grfconfig->error != NULL) free(_cur_grfconfig->error);
    05265     _cur_grfconfig->error = error;
    05266
    05267     _cur_grfconfig->status = GCS_DISABLED;
    05268     ClearTemporaryNewGRFData(_cur_grffile);
    05269     _skip_sprites = -1;
    05270     return;
    05271   }
    05272
    05273   byte num_strings = grf_load_byte(&buf);
    05274   uint16 first_id  = grf_load_word(&buf);
    05275
    05276   if (!((first_id >= 0xD000 && first_id + num_strings <= 0xD3FF) || (first_id >= 0xDC00 && first_id + num_strings <= 0xDCFF))) {
    05277     grfmsg(7, "TranslateGRFStrings: Attempting to set out-of-range string IDs in action 13 (first: 0x%4X, number: 0x%2X)", first_id, num_strings);
    05278     return;
    05279   }
    05280
    05281   len -= 7;
    05282
    05283   for (uint i = 0; i < num_strings && len > 0; i++) {
    05284     const char *string   = grf_load_string(&buf, len);
    05285     size_t string_length = strlen(string) + 1;
    05286
    05287     len -= (int)string_length;
    05288
    05289     if (string_length == 1) {
    05290       grfmsg(7, "TranslateGRFString: Ignoring empty string.");
    05291       continue;
    05292     }
    05293
    05294     /* Since no language id is supplied this string has to be added as a
    05295      * generic string, thus the language id of 0x7F. For this to work
    05296      * new_scheme has to be true as well. A language id of 0x7F will be
    05297      * overridden by a non-generic id, so this will not change anything if
    05298      * a string has been provided specifically for this language. */
    05299     AddGRFString(grfid, first_id + i, 0x7F, true, string, STR_UNDEFINED);
    05300   }
    05301 }
    05302
    05303 /* 'Action 0xFF' */
    05304 static void GRFDataBlock(byte *buf, int len)
    05305 {
    05306   if (_grf_data_blocks == 0) {
    05307     grfmsg(2, "GRFDataBlock: unexpected data block, skipping");
    05308     return;
    05309   }
    05310
    05311   buf++;
    05312   uint8 name_len = grf_load_byte(&buf);
    05313   const char *name = (const char *)buf;
    05314   buf += name_len + 1;
    05315
    05316   grfmsg(2, "GRFDataBlock: block name '%s'...", name);
    05317
    05318   _grf_data_blocks--;
    05319
    05320   switch (_grf_data_type) {
    05321     case GDT_SOUND: LoadGRFSound(buf, len - name_len - 2); break;
    05322     default: NOT_REACHED(); break;
    05323   }
    05324 }
    05325
    05326
    05327 /* Used during safety scan on unsafe actions */
    05328 static void GRFUnsafe(byte *buf, size_t len)
    05329 {
    05330   SetBit(_cur_grfconfig->flags, GCF_UNSAFE);
    05331
    05332   /* Skip remainder of GRF */
    05333   _skip_sprites = -1;
    05334 }
    05335
    05336
    05337 static void InitializeGRFSpecial()
    05338 {
    05339   _ttdpatch_flags[0] =  ((_settings_game.station.always_small_airport ? 1 : 0) << 0x0C)  // keepsmallairport
    05340                      |                                                 (1 << 0x0D)  // newairports
    05341                      |                                                 (1 << 0x0E)  // largestations
    05342                      |      ((_settings_game.construction.longbridges ? 1 : 0) << 0x0F)  // longbridges
    05343                      |                                                 (0 << 0x10)  // loadtime
    05344                      |                                                 (1 << 0x12)  // presignals
    05345                      |                                                 (1 << 0x13)  // extpresignals
    05346                      | ((_settings_game.vehicle.never_expire_vehicles ? 1 : 0) << 0x16)  // enginespersist
    05347                      |                                                 (1 << 0x1B)  // multihead
    05348                      |                                                 (1 << 0x1D)  // lowmemory
    05349                      |                                                 (1 << 0x1E); // generalfixes
    05350
    05351   _ttdpatch_flags[1] =   ((_settings_game.economy.station_noise_level ? 1 : 0) << 0x07)  // moreairports - based on units of noise
    05352                      |        ((_settings_game.vehicle.mammoth_trains ? 1 : 0) << 0x08)  // mammothtrains
    05353                      |                                                 (1 << 0x09)  // trainrefit
    05354                      |                                                 (0 << 0x0B)  // subsidiaries
    05355                      |         ((_settings_game.order.gradual_loading ? 1 : 0) << 0x0C)  // gradualloading
    05356                      |                                                 (1 << 0x12)  // unifiedmaglevmode - set bit 0 mode. Not revelant to OTTD
    05357                      |                                                 (1 << 0x13)  // unifiedmaglevmode - set bit 1 mode
    05358                      |                                                 (1 << 0x14)  // bridgespeedlimits
    05359                      |                                                 (1 << 0x16)  // eternalgame
    05360                      |                                                 (1 << 0x17)  // newtrains
    05361                      |                                                 (1 << 0x18)  // newrvs
    05362                      |                                                 (1 << 0x19)  // newships
    05363                      |                                                 (1 << 0x1A)  // newplanes
    05364                      |      ((_settings_game.construction.signal_side ? 1 : 0) << 0x1B)  // signalsontrafficside
    05365                      |       ((_settings_game.vehicle.disable_elrails ? 0 : 1) << 0x1C); // electrifiedrailway
    05366
    05367   _ttdpatch_flags[2] =                                                 (1 << 0x01)  // loadallgraphics - obsolote
    05368                      |                                                 (1 << 0x03)  // semaphores
    05369                      |                                                 (0 << 0x0B)  // enhancedgui
    05370                      |                                                 (0 << 0x0C)  // newagerating
    05371                      |  ((_settings_game.construction.build_on_slopes ? 1 : 0) << 0x0D)  // buildonslopes
    05372                      |                                                 (1 << 0x0E)  // fullloadany
    05373                      |                                                 (1 << 0x0F)  // planespeed
    05374                      |                                                 (0 << 0x10)  // moreindustriesperclimate - obsolete
    05375                      |                                                 (0 << 0x11)  // moretoylandfeatures
    05376                      |                                                 (1 << 0x12)  // newstations
    05377                      |                                                 (1 << 0x13)  // tracktypecostdiff
    05378                      |                                                 (1 << 0x14)  // manualconvert
    05379                      |  ((_settings_game.construction.build_on_slopes ? 1 : 0) << 0x15)  // buildoncoasts
    05380                      |                                                 (1 << 0x16)  // canals
    05381                      |                                                 (1 << 0x17)  // newstartyear
    05382                      |    ((_settings_game.vehicle.freight_trains > 1 ? 1 : 0) << 0x18)  // freighttrains
    05383                      |                                                 (1 << 0x19)  // newhouses
    05384                      |                                                 (1 << 0x1A)  // newbridges
    05385                      |                                                 (1 << 0x1B)  // newtownnames
    05386                      |                                                 (1 << 0x1C)  // moreanimation
    05387                      |    ((_settings_game.vehicle.wagon_speed_limits ? 1 : 0) << 0x1D)  // wagonspeedlimits
    05388                      |                                                 (1 << 0x1E)  // newshistory
    05389                      |                                                 (0 << 0x1F); // custombridgeheads
    05390
    05391   _ttdpatch_flags[3] =                                                 (0 << 0x00)  // newcargodistribution
    05392                      |                                                 (1 << 0x01)  // windowsnap
    05393                      | ((_settings_game.economy.allow_town_roads || _generating_world ? 0 : 1) << 0x02)  // townbuildnoroad
    05394                      |                                                 (1 << 0x03)  // pathbasedsignalling
    05395                      |                                                 (0 << 0x04)  // aichoosechance
    05396                      |                                                 (1 << 0x05)  // resolutionwidth
    05397                      |                                                 (1 << 0x06)  // resolutionheight
    05398                      |                                                 (1 << 0x07)  // newindustries
    05399                      |           ((_settings_game.order.improved_load ? 1 : 0) << 0x08)  // fifoloading
    05400                      |                                                 (0 << 0x09)  // townroadbranchprob
    05401                      |                                                 (0 << 0x0A)  // tempsnowline
    05402                      |                                                 (1 << 0x0B)  // newcargo
    05403                      |                                                 (1 << 0x0C)  // enhancemultiplayer
    05404                      |                                                 (1 << 0x0D)  // onewayroads
    05405                      |   ((_settings_game.station.nonuniform_stations ? 1 : 0) << 0x0E)  // irregularstations
    05406                      |                                                 (1 << 0x0F)  // statistics
    05407                      |                                                 (1 << 0x10)  // newsounds
    05408                      |                                                 (1 << 0x11)  // autoreplace
    05409                      |                                                 (1 << 0x12)  // autoslope
    05410                      |                                                 (0 << 0x13)  // followvehicle
    05411                      |                                                 (1 << 0x14)  // trams
    05412                      |                                                 (0 << 0x15)  // enhancetunnels
    05413                      |                                                 (1 << 0x16)  // shortrvs
    05414                      |                                                 (1 << 0x17)  // articulatedrvs
    05415                      |       ((_settings_game.vehicle.dynamic_engines ? 1 : 0) << 0x18)  // dynamic engines
    05416                      |                                                 (1 << 0x1E)  // variablerunningcosts
    05417                      |                                                 (1 << 0x1F); // any switch is on
    05418 }
    05419
    05420 static void ResetCustomStations()
    05421 {
    05422   for (GRFFile *file = _first_grffile; file != NULL; file = file->next) {
    05423     if (file->stations == NULL) continue;
    05424     for (uint i = 0; i < MAX_STATIONS; i++) {
    05425       if (file->stations[i] == NULL) continue;
    05426       StationSpec *statspec = file->stations[i];
    05427
    05428       /* Release renderdata, if it wasn't copied from another custom station spec  */
    05429       if (!statspec->copied_renderdata) {
    05430         for (uint t = 0; t < statspec->tiles; t++) {
    05431           free((void*)statspec->renderdata[t].seq);
    05432         }
    05433         free(statspec->renderdata);
    05434       }
    05435
    05436       /* Release platforms and layouts */
    05437       if (!statspec->copied_layouts) {
    05438         for (uint l = 0; l < statspec->lengths; l++) {
    05439           for (uint p = 0; p < statspec->platforms[l]; p++) {
    05440             free(statspec->layouts[l][p]);
    05441           }
    05442           free(statspec->layouts[l]);
    05443         }
    05444         free(statspec->layouts);
    05445         free(statspec->platforms);
    05446       }
    05447
    05448       /* Release this station */
    05449       free(statspec);
    05450     }
    05451
    05452     /* Free and reset the station data */
    05453     free(file->stations);
    05454     file->stations = NULL;
    05455   }
    05456 }
    05457
    05458 static void ResetCustomHouses()
    05459 {
    05460   GRFFile *file;
    05461   uint i;
    05462
    05463   for (file = _first_grffile; file != NULL; file = file->next) {
    05464     if (file->housespec == NULL) continue;
    05465     for (i = 0; i < HOUSE_MAX; i++) {
    05466       free(file->housespec[i]);
    05467     }
    05468
    05469     free(file->housespec);
    05470     file->housespec = NULL;
    05471   }
    05472 }
    05473
    05474 static void ResetCustomIndustries()
    05475 {
    05476   GRFFile *file;
    05477
    05478   for (file = _first_grffile; file != NULL; file = file->next) {
    05479     uint i;
    05480     /* We are verifiying both tiles and industries specs loaded from the grf file
    05481      * First, let's deal with industryspec */
    05482     if (file->industryspec != NULL) {
    05483
    05484       for (i = 0; i < NUM_INDUSTRYTYPES; i++) {
    05485         IndustrySpec *ind = file->industryspec[i];
    05486
    05487         if (ind != NULL) {
    05488           /* We need to remove the sounds array */
    05489           if (HasBit(ind->cleanup_flag, CLEAN_RANDOMSOUNDS)) {
    05490             free((void*)ind->random_sounds);
    05491           }
    05492
    05493           /* We need to remove the tiles layouts */
    05494           if (HasBit(ind->cleanup_flag, CLEAN_TILELSAYOUT) && ind->table != NULL) {
    05495             for (int j = 0; j < ind->num_table; j++) {
    05496               /* remove the individual layouts */
    05497               if (ind->table[j] != NULL) {
    05498                 free((IndustryTileTable*)ind->table[j]);
    05499               }
    05500             }
    05501             /* remove the layouts pointers */
    05502             free((IndustryTileTable**)ind->table);
    05503             ind->table = NULL;
    05504           }
    05505
    05506           free(ind);
    05507           ind = NULL;
    05508         }
    05509       }
    05510
    05511       free(file->industryspec);
    05512       file->industryspec = NULL;
    05513     }
    05514
    05515     if (file->indtspec != NULL) {
    05516       for (i = 0; i < NUM_INDUSTRYTILES; i++) {
    05517         if (file->indtspec[i] != NULL) {
    05518           free(file->indtspec[i]);
    05519           file->indtspec[i] = NULL;
    05520         }
    05521       }
    05522
    05523       free(file->indtspec);
    05524       file->indtspec = NULL;
    05525     }
    05526   }
    05527 }
    05528
    05529 static void ResetNewGRF()
    05530 {
    05531   GRFFile *next;
    05532
    05533   for (GRFFile *f = _first_grffile; f != NULL; f = next) {
    05534     next = f->next;
    05535
    05536     free(f->filename);
    05537     free(f->cargo_list);
    05538     free(f->railtype_list);
    05539     free(f);
    05540   }
    05541
    05542   _first_grffile = NULL;
    05543   _cur_grffile   = NULL;
    05544 }
    05545
    05546 static void ResetNewGRFErrors()
    05547 {
    05548   for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
    05549     if (!HasBit(c->flags, GCF_COPY) && c->error != NULL) {
    05550       free(c->error->custom_message);
    05551       free(c->error->data);
    05552       free(c->error);
    05553       c->error = NULL;
    05554     }
    05555   }
    05556 }
    05557
    05562 static void ResetNewGRFData()
    05563 {
    05564   CleanUpStrings();
    05565   CleanUpGRFTownNames();
    05566
    05567   /* Copy/reset original engine info data */
    05568   SetupEngines();
    05569
    05570   /* Copy/reset original bridge info data */
    05571   ResetBridges();
    05572
    05573   /* Reset rail type information */
    05574   ResetRailTypes();
    05575
    05576   /* Allocate temporary refit/cargo class data */
    05577   _gted = CallocT<GRFTempEngineData>(GetEnginePoolSize());
    05578
    05579   /* Reset GRM reservations */
    05580   memset(&_grm_engines, 0, sizeof(_grm_engines));
    05581   memset(&_grm_cargos, 0, sizeof(_grm_cargos));
    05582
    05583   /* Reset generic feature callback lists */
    05584   ResetGenericCallbacks();
    05585
    05586   /* Reset price base data */
    05587   ResetPriceBaseMultipliers();
    05588
    05589   /* Reset the curencies array */
    05590   ResetCurrencies();
    05591
    05592   /* Reset the house array */
    05593   ResetCustomHouses();
    05594   ResetHouses();
    05595
    05596   /* Reset the industries structures*/
    05597   ResetCustomIndustries();
    05598   ResetIndustries();
    05599
    05600   /* Reset station classes */
    05601   ResetStationClasses();
    05602   ResetCustomStations();
    05603
    05604   /* Reset canal sprite groups and flags */
    05605   memset(_water_feature, 0, sizeof(_water_feature));
    05606
    05607   /* Reset the snowline table. */
    05608   ClearSnowLine();
    05609
    05610   /* Reset NewGRF files */
    05611   ResetNewGRF();
    05612
    05613   /* Reset NewGRF errors. */
    05614   ResetNewGRFErrors();
    05615
    05616   /* Set up the default cargo types */
    05617   SetupCargoForClimate(_settings_game.game_creation.landscape);
    05618
    05619   /* Reset misc GRF features and train list display variables */
    05620   _misc_grf_features = 0;
    05621   _traininfo_vehicle_pitch = 0;
    05622   _traininfo_vehicle_width = 29;
    05623
    05624   _loaded_newgrf_features.has_2CC           = false;
    05625   _loaded_newgrf_features.has_newhouses     = false;
    05626   _loaded_newgrf_features.has_newindustries = false;
    05627   _loaded_newgrf_features.shore             = SHORE_REPLACE_NONE;
    05628
    05629   /* Clear all GRF overrides */
    05630   _grf_id_overrides.clear();
    05631
    05632   InitializeSoundPool();
    05633   InitializeSpriteGroupPool();
    05634 }
    05635
    05636 static void BuildCargoTranslationMap()
    05637 {
    05638   memset(_cur_grffile->cargo_map, 0xFF, sizeof(_cur_grffile->cargo_map));
    05639
    05640   for (CargoID c = 0; c < NUM_CARGO; c++) {
    05641     const CargoSpec *cs = GetCargo(c);
    05642     if (!cs->IsValid()) continue;
    05643
    05644     if (_cur_grffile->cargo_max == 0) {
    05645       /* Default translation table, so just a straight mapping to bitnum */
    05646       _cur_grffile->cargo_map[c] = cs->bitnum;
    05647     } else {
    05648       /* Check the translation table for this cargo's label */
    05649       for (uint i = 0; i < _cur_grffile->cargo_max; i++) {
    05650         if (cs->label == _cur_grffile->cargo_list[i]) {
    05651           _cur_grffile->cargo_map[c] = i;
    05652           break;
    05653         }
    05654       }
    05655     }
    05656   }
    05657 }
    05658
    05659 static void InitNewGRFFile(const GRFConfig *config, int sprite_offset)
    05660 {
    05661   GRFFile *newfile = GetFileByFilename(config->filename);
    05662   if (newfile != NULL) {
    05663     /* We already loaded it once. */
    05664     newfile->sprite_offset = sprite_offset;
    05665     _cur_grffile = newfile;
    05666     return;
    05667   }
    05668
    05669   newfile = CallocT<GRFFile>(1);
    05670
    05671   if (newfile == NULL) error ("Out of memory");
    05672
    05673   newfile->filename = strdup(config->filename);
    05674   newfile->sprite_offset = sprite_offset;
    05675
    05676   /* Copy the initial parameter list */
    05677   assert(lengthof(newfile->param) == lengthof(config->param) && lengthof(config->param) == 0x80);
    05678   newfile->param_end = config->num_params;
    05679   memcpy(newfile->param, config->param, sizeof(newfile->param));
    05680
    05681   if (_first_grffile == NULL) {
    05682     _cur_grffile = newfile;
    05683     _first_grffile = newfile;
    05684   } else {
    05685     _cur_grffile->next = newfile;
    05686     _cur_grffile = newfile;
    05687   }
    05688 }
    05689
    05690
    05693 static const CargoLabel _default_refitmasks_rail[] = {
    05694   'PASS', 'COAL', 'MAIL', 'LVST', 'GOOD', 'GRAI', 'WHEA', 'MAIZ', 'WOOD',
    05695   'IORE', 'STEL', 'VALU', 'GOLD', 'DIAM', 'PAPR', 'FOOD', 'FRUT', 'CORE',
    05696   'WATR', 'SUGR', 'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL',
    05697   'PLST', 'FZDR',
    05698   0 };
    05699
    05700 static const CargoLabel _default_refitmasks_road[] = {
    05701   0 };
    05702
    05703 static const CargoLabel _default_refitmasks_ships[] = {
    05704   'COAL', 'MAIL', 'LVST', 'GOOD', 'GRAI', 'WHEA', 'MAIZ', 'WOOD', 'IORE',
    05705   'STEL', 'VALU', 'GOLD', 'DIAM', 'PAPR', 'FOOD', 'FRUT', 'CORE', 'WATR',
    05706   'RUBR', 'SUGR', 'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL',
    05707   'PLST', 'FZDR',
    05708   0 };
    05709
    05710 static const CargoLabel _default_refitmasks_aircraft[] = {
    05711   'PASS', 'MAIL', 'GOOD', 'VALU', 'GOLD', 'DIAM', 'FOOD', 'FRUT', 'SUGR',
    05712   'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL', 'PLST', 'FZDR',
    05713   0 };
    05714
    05715 static const CargoLabel *_default_refitmasks[] = {
    05716   _default_refitmasks_rail,
    05717   _default_refitmasks_road,
    05718   _default_refitmasks_ships,
    05719   _default_refitmasks_aircraft,
    05720 };
    05721
    05722
    05726 static void CalculateRefitMasks()
    05727 {
    05728   Engine *e;
    05729
    05730   FOR_ALL_ENGINES(e) {
    05731     EngineID engine = e->index;
    05732     EngineInfo *ei = &e->info;
    05733     uint32 mask = 0;
    05734     uint32 not_mask = 0;
    05735     uint32 xor_mask = 0;
    05736
    05737     if (ei->refit_mask != 0) {
    05738       const GRFFile *file = e->grffile;
    05739       if (file != NULL && file->cargo_max != 0) {
    05740         /* Apply cargo translation table to the refit mask */
    05741         uint num_cargo = min(32, file->cargo_max);
    05742         for (uint i = 0; i < num_cargo; i++) {
    05743           if (!HasBit(ei->refit_mask, i)) continue;
    05744
    05745           CargoID c = GetCargoIDByLabel(file->cargo_list[i]);
    05746           if (c == CT_INVALID) continue;
    05747
    05748           SetBit(xor_mask, c);
    05749         }
    05750       } else {
    05751         /* No cargo table, so use the cargo bitnum values */
    05752         for (CargoID c = 0; c < NUM_CARGO; c++) {
    05753           const CargoSpec *cs = GetCargo(c);
    05754           if (!cs->IsValid()) continue;
    05755
    05756           if (HasBit(ei->refit_mask, cs->bitnum)) SetBit(xor_mask, c);
    05757         }
    05758       }
    05759     }
    05760
    05761     if (_gted[engine].cargo_allowed != 0) {
    05762       /* Build up the list of cargo types from the set cargo classes. */
    05763       for (CargoID i = 0; i < NUM_CARGO; i++) {
    05764         const CargoSpec *cs = GetCargo(i);
    05765         if (_gted[engine].cargo_allowed    & cs->classes) SetBit(mask,     i);
    05766         if (_gted[engine].cargo_disallowed & cs->classes) SetBit(not_mask, i);
    05767       }
    05768     } else if (xor_mask == 0) {
    05769       /* Don't apply default refit mask to wagons or engines with no capacity */
    05770       if (e->type != VEH_TRAIN || (e->u.rail.capacity != 0 && e->u.rail.railveh_type != RAILVEH_WAGON)) {
    05771         const CargoLabel *cl = _default_refitmasks[e->type];
    05772         for (uint i = 0;; i++) {
    05773           if (cl[i] == 0) break;
    05774
    05775           CargoID cargo = GetCargoIDByLabel(cl[i]);
    05776           if (cargo == CT_INVALID) continue;
    05777
    05778           SetBit(xor_mask, cargo);
    05779         }
    05780       }
    05781     }
    05782
    05783     ei->refit_mask = ((mask & ~not_mask) ^ xor_mask) & _cargo_mask;
    05784
    05785     /* Check if this engine's cargo type is valid. If not, set to the first refittable
    05786      * cargo type. Apparently cargo_type isn't a common property... */
    05787     switch (e->type) {
    05788       default: NOT_REACHED();
    05789       case VEH_AIRCRAFT:
    05790         if (FindFirstRefittableCargo(engine) == CT_INVALID) ei->climates = 0x80;
    05791         break;
    05792
    05793       case VEH_TRAIN: {
    05794         RailVehicleInfo *rvi = &e->u.rail;
    05795         if (rvi->cargo_type == CT_INVALID) rvi->cargo_type = FindFirstRefittableCargo(engine);
    05796         if (rvi->cargo_type == CT_INVALID) ei->climates = 0x80;
    05797         break;
    05798       }
    05799       case VEH_ROAD: {
    05800         RoadVehicleInfo *rvi = &e->u.road;
    05801         if (rvi->cargo_type == CT_INVALID) rvi->cargo_type = FindFirstRefittableCargo(engine);
    05802         if (rvi->cargo_type == CT_INVALID) ei->climates = 0x80;
    05803         break;
    05804       }
    05805       case VEH_SHIP: {
    05806         ShipVehicleInfo *svi = &e->u.ship;
    05807         if (svi->cargo_type == CT_INVALID) svi->cargo_type = FindFirstRefittableCargo(engine);
    05808         if (svi->cargo_type == CT_INVALID) ei->climates = 0x80;
    05809         break;
    05810       }
    05811     }
    05812   }
    05813 }
    05814
    05819 static void FinaliseHouseArray()
    05820 {
    05821   /* If there are no houses with start dates before 1930, then all houses
    05822    * with start dates of 1930 have them reset to 0. This is in order to be
    05823    * compatible with TTDPatch, where if no houses have start dates before
    05824    * 1930 and the date is before 1930, the game pretends that this is 1930.
    05825    * If there have been any houses defined with start dates before 1930 then
    05826    * the dates are left alone.
    05827    * On the other hand, why 1930? Just 'fix' the houses with the lowest
    05828    * minimum introduction date to 0.
    05829    */
    05830   Year min_year = MAX_YEAR;
    05831
    05832   for (GRFFile *file = _first_grffile; file != NULL; file = file->next) {
    05833     if (file->housespec == NULL) continue;
    05834
    05835     for (int i = 0; i < HOUSE_MAX; i++) {
    05836       HouseSpec *hs = file->housespec[i];
    05837
    05838       if (hs == NULL) continue;
    05839
    05840       const HouseSpec *next1 = (i + 1 < HOUSE_MAX ? file->housespec[i + 1] : NULL);
    05841       const HouseSpec *next2 = (i + 2 < HOUSE_MAX ? file->housespec[i + 2] : NULL);
    05842       const HouseSpec *next3 = (i + 3 < HOUSE_MAX ? file->housespec[i + 3] : NULL);
    05843
    05844       if (((hs->building_flags & BUILDING_HAS_2_TILES) != 0 &&
    05845             (next1 == NULL || !next1->enabled || (next1->building_flags & BUILDING_HAS_1_TILE) != 0)) ||
    05846           ((hs->building_flags & BUILDING_HAS_4_TILES) != 0 &&
    05847             (next2 == NULL || !next2->enabled || (next2->building_flags & BUILDING_HAS_1_TILE) != 0 ||
    05848             next3 == NULL || !next3->enabled || (next3->building_flags & BUILDING_HAS_1_TILE) != 0))) {
    05849         hs->enabled = false;
    05850         DEBUG(grf, 1, "FinaliseHouseArray: %s defines house %d as multitile, but no suitable tiles follow. Disabling house.", file->filename, hs->local_id);
    05851         continue;
    05852       }
    05853
    05854       _house_mngr.SetEntitySpec(hs);
    05855       if (hs->min_year < min_year) min_year = hs->min_year;
    05856     }
    05857   }
    05858
    05859   if (min_year != 0) {
    05860     for (int i = 0; i < HOUSE_MAX; i++) {
    05861       HouseSpec *hs = GetHouseSpecs(i);
    05862
    05863       if (hs->enabled && hs->min_year == min_year) hs->min_year = 0;
    05864     }
    05865   }
    05866 }
    05867
    05871 static void FinaliseIndustriesArray()
    05872 {
    05873   for (GRFFile *file = _first_grffile; file != NULL; file = file->next) {
    05874     if (file->industryspec != NULL) {
    05875       for (int i = 0; i < NUM_INDUSTRYTYPES; i++) {
    05876         IndustrySpec *indsp = file->industryspec[i];
    05877
    05878         if (indsp != NULL && indsp->enabled) {
    05879           StringID strid;
    05880           /* process the conversion of text at the end, so to be sure everything will be fine
    05881            * and available.  Check if it does not return undefind marker, which is a very good sign of a
    05882            * substitute industry who has not changed the string been examined, thus using it as such */
    05883           strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->name);
    05884           if (strid != STR_UNDEFINED) indsp->name = strid;
    05885
    05886           strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->closure_text);
    05887           if (strid != STR_UNDEFINED) indsp->closure_text = strid;
    05888
    05889           strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->production_up_text);
    05890           if (strid != STR_UNDEFINED) indsp->production_up_text = strid;
    05891
    05892           strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->production_down_text);
    05893           if (strid != STR_UNDEFINED) indsp->production_down_text = strid;
    05894
    05895           strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->new_industry_text);
    05896           if (strid != STR_UNDEFINED) indsp->new_industry_text = strid;
    05897
    05898           if (indsp->station_name != STR_NULL) {
    05899             /* STR_NULL (0) can be set by grf.  It has a meaning regarding assignation of the
    05900              * station's name. Don't want to lose the value, therefore, do not process. */
    05901             strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->station_name);
    05902             if (strid != STR_UNDEFINED) indsp->station_name = strid;
    05903           }
    05904
    05905           _industry_mngr.SetEntitySpec(indsp);
    05906           _loaded_newgrf_features.has_newindustries = true;
    05907         }
    05908       }
    05909     }
    05910
    05911     if (file->indtspec != NULL) {
    05912       for (int i = 0; i < NUM_INDUSTRYTILES; i++) {
    05913         IndustryTileSpec *indtsp = file->indtspec[i];
    05914         if (indtsp != NULL) {
    05915           _industile_mngr.SetEntitySpec(indtsp);
    05916         }
    05917       }
    05918     }
    05919   }
    05920
    05921   for (uint j = 0; j < NUM_INDUSTRYTYPES; j++) {
    05922     IndustrySpec *indsp = &_industry_specs[j];
    05923     if (indsp->enabled && indsp->grf_prop.grffile != NULL) {
    05924       for (uint i = 0; i < 3; i++) {
    05925         indsp->conflicting[i] = MapNewGRFIndustryType(indsp->conflicting[i], indsp->grf_prop.grffile->grfid);
    05926       }
    05927     }
    05928   }
    05929 }
    05930
    05931 /* Here we perform initial decoding of some special sprites (as are they
    05932  * described at http://www.ttdpatch.net/src/newgrf.txt, but this is only a very
    05933  * partial implementation yet).
    05934  * XXX: We consider GRF files trusted. It would be trivial to exploit OTTD by
    05935  * a crafted invalid GRF file. We should tell that to the user somehow, or
    05936  * better make this more robust in the future. */
    05937 static void DecodeSpecialSprite(byte *buf, uint num, GrfLoadingStage stage)
    05938 {
    05939   /* XXX: There is a difference between staged loading in TTDPatch and
    05940    * here.  In TTDPatch, for some reason actions 1 and 2 are carried out
    05941    * during stage 1, whilst action 3 is carried out during stage 2 (to
    05942    * "resolve" cargo IDs... wtf). This is a little problem, because cargo
    05943    * IDs are valid only within a given set (action 1) block, and may be
    05944    * overwritten after action 3 associates them. But overwriting happens
    05945    * in an earlier stage than associating, so...  We just process actions
    05946    * 1 and 2 in stage 2 now, let's hope that won't get us into problems.
    05947    * --pasky
    05948    * We need a pre-stage to set up GOTO labels of Action 0x10 because the grf
    05949    * is not in memory and scanning the file every time would be too expensive.
    05950    * In other stages we skip action 0x10 since it's already dealt with. */
    05951   static const SpecialSpriteHandler handlers[][GLS_END] = {
    05952     /* 0x00 */ { NULL,     SafeChangeInfo, NULL,       NULL,           ReserveChangeInfo, FeatureChangeInfo, },
    05953     /* 0x01 */ { SkipAct1, SkipAct1,  SkipAct1,        SkipAct1,       SkipAct1,          NewSpriteSet, },
    05954     /* 0x02 */ { NULL,     NULL,      NULL,            NULL,           NULL,              NewSpriteGroup, },
    05955     /* 0x03 */ { NULL,     GRFUnsafe, NULL,            NULL,           NULL,              FeatureMapSpriteGroup, },
    05956     /* 0x04 */ { NULL,     NULL,      NULL,            NULL,           NULL,              FeatureNewName, },
    05957     /* 0x05 */ { SkipAct5, SkipAct5,  SkipAct5,        SkipAct5,       SkipAct5,          GraphicsNew, },
    05958     /* 0x06 */ { NULL,     NULL,      NULL,            CfgApply,       CfgApply,          CfgApply, },
    05959     /* 0x07 */ { NULL,     NULL,      NULL,            NULL,           SkipIf,            SkipIf, },
    05960     /* 0x08 */ { ScanInfo, NULL,      NULL,            GRFInfo,        GRFInfo,           GRFInfo, },
    05961     /* 0x09 */ { NULL,     NULL,      NULL,            SkipIf,         SkipIf,            SkipIf, },
    05962     /* 0x0A */ { SkipActA, SkipActA,  SkipActA,        SkipActA,       SkipActA,          SpriteReplace, },
    05963     /* 0x0B */ { NULL,     NULL,      NULL,            GRFLoadError,   GRFLoadError,      GRFLoadError, },
    05964     /* 0x0C */ { NULL,     NULL,      NULL,            GRFComment,     NULL,              GRFComment, },
    05965     /* 0x0D */ { NULL,     SafeParamSet, NULL,         ParamSet,       ParamSet,          ParamSet, },
    05966     /* 0x0E */ { NULL,     SafeGRFInhibit, NULL,       GRFInhibit,     GRFInhibit,        GRFInhibit, },
    05967     /* 0x0F */ { NULL,     GRFUnsafe, NULL,            FeatureTownName, NULL,             NULL, },
    05968     /* 0x10 */ { NULL,     NULL,      DefineGotoLabel, NULL,           NULL,              NULL, },
    05969     /* 0x11 */ { SkipAct11,GRFUnsafe, SkipAct11,       SkipAct11,      SkipAct11,         GRFSound, },
    05970     /* 0x12 */ { SkipAct12, SkipAct12, SkipAct12,      SkipAct12,      SkipAct12,         LoadFontGlyph, },
    05971     /* 0x13 */ { NULL,     NULL,      NULL,            NULL,           NULL,              TranslateGRFStrings, },
    05972   };
    05973
    05974   GRFLocation location(_cur_grfconfig->grfid, _nfo_line);
    05975
    05976   GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.find(location);
    05977   if (it == _grf_line_to_action6_sprite_override.end()) {
    05978     /* No preloaded sprite to work with; read the
    05979      * pseudo sprite content. */
    05980     FioReadBlock(buf, num);
    05981   } else {
    05982     /* Use the preloaded sprite data. */
    05983     buf = _grf_line_to_action6_sprite_override[location];
    05984     grfmsg(7, "DecodeSpecialSprite: Using preloaded pseudo sprite data");
    05985
    05986     /* Skip the real (original) content of this action. */
    05987     FioSeekTo(num, SEEK_CUR);
    05988   }
    05989
    05990   byte action = buf[0];
    05991
    05992   if (action == 0xFF) {
    05993     grfmsg(7, "DecodeSpecialSprite: Handling data block in stage %d", stage);
    05994     GRFDataBlock(buf, num);
    05995   } else if (action == 0xFE) {
    05996     grfmsg(7, "DecodeSpecialSprite: Handling import block in stage %d", stage);
    05997     GRFImportBlock(buf, num);
    05998   } else if (action >= lengthof(handlers)) {
    05999     grfmsg(7, "DecodeSpecialSprite: Skipping unknown action 0x%02X", action);
    06000   } else if (handlers[action][stage] == NULL) {
    06001     grfmsg(7, "DecodeSpecialSprite: Skipping action 0x%02X in stage %d", action, stage);
    06002   } else {
    06003     grfmsg(7, "DecodeSpecialSprite: Handling action 0x%02X in stage %d", action, stage);
    06004     handlers[action][stage](buf, num);
    06005   }
    06006 }
    06007
    06008
    06009 void LoadNewGRFFile(GRFConfig *config, uint file_index, GrfLoadingStage stage)
    06010 {
    06011   const char *filename = config->filename;
    06012   uint16 num;
    06013
    06014   /* A .grf file is activated only if it was active when the game was
    06015    * started.  If a game is loaded, only its active .grfs will be
    06016    * reactivated, unless "loadallgraphics on" is used.  A .grf file is
    06017    * considered active if its action 8 has been processed, i.e. its
    06018    * action 8 hasn't been skipped using an action 7.
    06019    *
    06020    * During activation, only actions 0, 1, 2, 3, 4, 5, 7, 8, 9, 0A and 0B are
    06021    * carried out.  All others are ignored, because they only need to be
    06022    * processed once at initialization.  */
    06023   if (stage != GLS_FILESCAN && stage != GLS_SAFETYSCAN && stage != GLS_LABELSCAN) {
    06024     _cur_grffile = GetFileByFilename(filename);
    06025     if (_cur_grffile == NULL) usererror("File '%s' lost in cache.\n", filename);
    06026     if (stage == GLS_RESERVE && config->status != GCS_INITIALISED) return;
    06027     if (stage == GLS_ACTIVATION && !HasBit(config->flags, GCF_RESERVED)) return;
    06028     _cur_grffile->is_ottdfile = config->IsOpenTTDBaseGRF();
    06029   }
    06030
    06031   if (file_index > LAST_GRF_SLOT) {
    06032     DEBUG(grf, 0, "'%s' is not loaded as the maximum number of GRFs has been reached", filename);
    06033     config->status = GCS_DISABLED;
    06034     config->error  = CallocT<GRFError>(1);
    06035     config->error->severity = STR_NEWGRF_ERROR_MSG_FATAL;
    06036     config->error->message  = STR_NEWGRF_ERROR_TOO_MANY_NEWGRFS_LOADED;
    06037     return;
    06038   }
    06039
    06040   FioOpenFile(file_index, filename);
    06041   _file_index = file_index; // XXX
    06042   _palette_remap_grf[_file_index] = (config->windows_paletted != (_use_palette == PAL_WINDOWS));
    06043
    06044   _cur_grfconfig = config;
    06045
    06046   DEBUG(grf, 2, "LoadNewGRFFile: Reading NewGRF-file '%s'", filename);
    06047
    06048   /* Skip the first sprite; we don't care about how many sprites this
    06049    * does contain; newest TTDPatches and George's longvehicles don't
    06050    * neither, apparently. */
    06051   if (FioReadWord() == 4 && FioReadByte() == 0xFF) {
    06052     FioReadDword();
    06053   } else {
    06054     DEBUG(grf, 7, "LoadNewGRFFile: Custom .grf has invalid format");
    06055     return;
    06056   }
    06057
    06058   _skip_sprites = 0; // XXX
    06059   _nfo_line = 0;
    06060
    06061   ReusableBuffer<byte> buf;
    06062
    06063   while ((num = FioReadWord()) != 0) {
    06064     byte type = FioReadByte();
    06065     _nfo_line++;
    06066
    06067     if (type == 0xFF) {
    06068       if (_skip_sprites == 0) {
    06069         DecodeSpecialSprite(buf.Allocate(num), num, stage);
    06070
    06071         /* Stop all processing if we are to skip the remaining sprites */
    06072         if (_skip_sprites == -1) break;
    06073
    06074         continue;
    06075       } else {
    06076         FioSkipBytes(num);
    06077       }
    06078     } else {
    06079       if (_skip_sprites == 0) {
    06080         grfmsg(0, "LoadNewGRFFile: Unexpected sprite, disabling");
    06081         config->status = GCS_DISABLED;
    06082         config->error  = CallocT<GRFError>(1);
    06083         config->error->severity = STR_NEWGRF_ERROR_MSG_FATAL;
    06084         config->error->message  = STR_NEWGRF_ERROR_UNEXPECTED_SPRITE;
    06085         break;
    06086       }
    06087
    06088       FioSkipBytes(7);
    06089       SkipSpriteData(type, num - 8);
    06090     }
    06091
    06092     if (_skip_sprites > 0) _skip_sprites--;
    06093   }
    06094 }
    06095
    06103 static void ActivateOldShore()
    06104 {
    06105   /* Use default graphics, if no shore sprites were loaded.
    06106    * Should not happen, as openttd(w/d).grf includes some. */
    06107   if (_loaded_newgrf_features.shore == SHORE_REPLACE_NONE) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_A;
    06108
    06109   if (_loaded_newgrf_features.shore != SHORE_REPLACE_ACTION_5) {
    06110     DupSprite(SPR_ORIGINALSHORE_START +  1, SPR_SHORE_BASE +  1); // SLOPE_W
    06111     DupSprite(SPR_ORIGINALSHORE_START +  2, SPR_SHORE_BASE +  2); // SLOPE_S
    06112     DupSprite(SPR_ORIGINALSHORE_START +  6, SPR_SHORE_BASE +  3); // SLOPE_SW
    06113     DupSprite(SPR_ORIGINALSHORE_START     , SPR_SHORE_BASE +  4); // SLOPE_E
    06114     DupSprite(SPR_ORIGINALSHORE_START +  4, SPR_SHORE_BASE +  6); // SLOPE_SE
    06115     DupSprite(SPR_ORIGINALSHORE_START +  3, SPR_SHORE_BASE +  8); // SLOPE_N
    06116     DupSprite(SPR_ORIGINALSHORE_START +  7, SPR_SHORE_BASE +  9); // SLOPE_NW
    06117     DupSprite(SPR_ORIGINALSHORE_START +  5, SPR_SHORE_BASE + 12); // SLOPE_NE
    06118   }
    06119
    06120   if (_loaded_newgrf_features.shore == SHORE_REPLACE_ACTION_A) {
    06121     DupSprite(SPR_FLAT_GRASS_TILE + 16, SPR_SHORE_BASE +  0); // SLOPE_STEEP_S
    06122     DupSprite(SPR_FLAT_GRASS_TILE + 17, SPR_SHORE_BASE +  5); // SLOPE_STEEP_W
    06123     DupSprite(SPR_FLAT_GRASS_TILE +  7, SPR_SHORE_BASE +  7); // SLOPE_WSE
    06124     DupSprite(SPR_FLAT_GRASS_TILE + 15, SPR_SHORE_BASE + 10); // SLOPE_STEEP_N
    06125     DupSprite(SPR_FLAT_GRASS_TILE + 11, SPR_SHORE_BASE + 11); // SLOPE_NWS
    06126     DupSprite(SPR_FLAT_GRASS_TILE + 13, SPR_SHORE_BASE + 13); // SLOPE_ENW
    06127     DupSprite(SPR_FLAT_GRASS_TILE + 14, SPR_SHORE_BASE + 14); // SLOPE_SEN
    06128     DupSprite(SPR_FLAT_GRASS_TILE + 18, SPR_SHORE_BASE + 15); // SLOPE_STEEP_E
    06129
    06130     /* XXX - SLOPE_EW, SLOPE_NS are currently not used.
    06131      *       If they would be used somewhen, then these grass tiles will most like not look as needed */
    06132     DupSprite(SPR_FLAT_GRASS_TILE +  5, SPR_SHORE_BASE + 16); // SLOPE_EW
    06133     DupSprite(SPR_FLAT_GRASS_TILE + 10, SPR_SHORE_BASE + 17); // SLOPE_NS
    06134   }
    06135 }
    06136
    06137 void InitDepotWindowBlockSizes();
    06138
    06139 extern void InitGRFTownGeneratorNames();
    06140
    06141 static void AfterLoadGRFs()
    06142 {
    06143   for (StringIDToGRFIDMapping::iterator it = _string_to_grf_mapping.begin(); it != _string_to_grf_mapping.end(); it++) {
    06144     *((*it).first) = MapGRFStringID((*it).second, *((*it).first));
    06145   }
    06146   _string_to_grf_mapping.clear();
    06147
    06148   /* Free the action 6 override sprites. */
    06149   for (GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.begin(); it != _grf_line_to_action6_sprite_override.end(); it++) {
    06150     free((*it).second);
    06151   }
    06152   _grf_line_to_action6_sprite_override.clear();
    06153
    06154   /* Pre-calculate all refit masks after loading GRF files. */
    06155   CalculateRefitMasks();
    06156
    06157   /* Set the block size in the depot windows based on vehicle sprite sizes */
    06158   InitDepotWindowBlockSizes();
    06159
    06160   /* Add all new houses to the house array. */
    06161   FinaliseHouseArray();
    06162
    06163   /* Add all new industries to the industry array. */
    06164   FinaliseIndustriesArray();
    06165
    06166   /* Create dynamic list of industry legends for smallmap_gui.cpp */
    06167   BuildIndustriesLegend();
    06168
    06169   /* Update the townname generators list */
    06170   InitGRFTownGeneratorNames();
    06171
    06172   /* Run all queued vehicle list order changes */
    06173   CommitVehicleListOrderChanges();
    06174
    06175   /* Load old shore sprites in new position, if they were replaced by ActionA */
    06176   ActivateOldShore();
    06177
    06178   Engine *e;
    06179   FOR_ALL_ENGINES_OF_TYPE(e, VEH_ROAD) {
    06180     if (_gted[e->index].rv_max_speed != 0) {
    06181       /* Set RV maximum speed from the mph/0.8 unit value */
    06182       e->u.road.max_speed = _gted[e->index].rv_max_speed * 4;
    06183     }
    06184   }
    06185
    06186   SetYearEngineAgingStops();
    06187
    06188   /* Deallocate temporary loading data */
    06189   free(_gted);
    06190   _grm_sprites.clear();
    06191 }
    06192
    06193 void LoadNewGRF(uint load_index, uint file_index)
    06194 {
    06195   /* In case of networking we need to "sync" the start values
    06196    * so all NewGRFs are loaded equally. For this we use the
    06197    * start date of the game and we set the counters, etc. to
    06198    * 0 so they're the same too. */
    06199   Date date            = _date;
    06200   Year year            = _cur_year;
    06201   DateFract date_fract = _date_fract;
    06202   uint16 tick_counter  = _tick_counter;
    06203   byte display_opt     = _display_opt;
    06204
    06205   if (_networking) {
    06206     _cur_year     = _settings_game.game_creation.starting_year;
    06207     _date         = ConvertYMDToDate(_cur_year, 0, 1);
    06208     _date_fract   = 0;
    06209     _tick_counter = 0;
    06210     _display_opt  = 0;
    06211   }
    06212
    06213   InitializeGRFSpecial();
    06214
    06215   ResetNewGRFData();
    06216
    06217   /*
    06218    * Reset the status of all files, so we can 'retry' to load them.
    06219    * This is needed when one for example rearranges the NewGRFs in-game
    06220    * and a previously disabled NewGRF becomes useable. If it would not
    06221    * be reset, the NewGRF would remain disabled even though it should
    06222    * have been enabled.
    06223    */
    06224   for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
    06225     if (c->status != GCS_NOT_FOUND) c->status = GCS_UNKNOWN;
    06226   }
    06227
    06228   _cur_spriteid = load_index;
    06229
    06230   /* Load newgrf sprites
    06231    * in each loading stage, (try to) open each file specified in the config
    06232    * and load information from it. */
    06233   for (GrfLoadingStage stage = GLS_LABELSCAN; stage <= GLS_ACTIVATION; stage++) {
    06234     /* Set activated grfs back to will-be-activated between reservation- and activation-stage.
    06235      * This ensures that action7/9 conditions 0x06 - 0x0A work correctly. */
    06236     for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
    06237       if (c->status == GCS_ACTIVATED) c->status = GCS_INITIALISED;
    06238     }
    06239
    06240     uint slot = file_index;
    06241
    06242     _cur_stage = stage;
    06243     for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
    06244       if (c->status == GCS_DISABLED || c->status == GCS_NOT_FOUND) continue;
    06245       if (stage > GLS_INIT && HasBit(c->flags, GCF_INIT_ONLY)) continue;
    06246
    06247       /* @todo usererror() */
    06248       if (!FioCheckFileExists(c->filename)) usererror("NewGRF file is missing '%s'", c->filename);
    06249
    06250       if (stage == GLS_LABELSCAN) InitNewGRFFile(c, _cur_spriteid);
    06251       LoadNewGRFFile(c, slot++, stage);
    06252       if (stage == GLS_RESERVE) {
    06253         SetBit(c->flags, GCF_RESERVED);
    06254       } else if (stage == GLS_ACTIVATION) {
    06255         ClrBit(c->flags, GCF_RESERVED);
    06256         assert(GetFileByGRFID(c->grfid) == _cur_grffile);
    06257         ClearTemporaryNewGRFData(_cur_grffile);
    06258         BuildCargoTranslationMap();
    06259         DEBUG(sprite, 2, "LoadNewGRF: Currently %i sprites are loaded", _cur_spriteid);
    06260       } else if (stage == GLS_INIT && HasBit(c->flags, GCF_INIT_ONLY)) {
    06261         /* We're not going to activate this, so free whatever data we allocated */
    06262         ClearTemporaryNewGRFData(_cur_grffile);
    06263       }
    06264     }
    06265   }
    06266
    06267   /* Call any functions that should be run after GRFs have been loaded. */
    06268   AfterLoadGRFs();
    06269
    06270   /* Now revert back to the original situation */
    06271   _cur_year     = year;
    06272   _date         = date;
    06273   _date_fract   = date_fract;
    06274   _tick_counter = tick_counter;
    06275   _display_opt  = display_opt;
    06276 }
    06277
    06278 bool HasGrfMiscBit(GrfMiscBit bit)
    06279 {
    06280   return HasBit(_misc_grf_features, bit);
    06281 }