newgrf.cpp

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

Generated on Sun Mar 15 22:49:48 2009 for openttd by  doxygen 1.5.6