newgrf.cpp

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

Generated on Thu Oct 1 11:03:14 2009 for OpenTTD by  doxygen 1.5.6