newgrf.cpp

Go to the documentation of this file.
00001 /* $Id: newgrf.cpp 26130 2013-11-26 16:08:58Z rubidium $ */
00002 
00003 /*
00004  * This file is part of OpenTTD.
00005  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
00006  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00007  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
00008  */
00009 
00012 #include "stdafx.h"
00013 
00014 #include <stdarg.h>
00015 
00016 #include "debug.h"
00017 #include "fileio_func.h"
00018 #include "engine_func.h"
00019 #include "engine_base.h"
00020 #include "bridge.h"
00021 #include "town.h"
00022 #include "newgrf_engine.h"
00023 #include "newgrf_text.h"
00024 #include "fontcache.h"
00025 #include "currency.h"
00026 #include "landscape.h"
00027 #include "newgrf_cargo.h"
00028 #include "newgrf_house.h"
00029 #include "newgrf_sound.h"
00030 #include "newgrf_station.h"
00031 #include "industrytype.h"
00032 #include "newgrf_canal.h"
00033 #include "newgrf_townname.h"
00034 #include "newgrf_industries.h"
00035 #include "newgrf_airporttiles.h"
00036 #include "newgrf_airport.h"
00037 #include "newgrf_object.h"
00038 #include "rev.h"
00039 #include "fios.h"
00040 #include "strings_func.h"
00041 #include "date_func.h"
00042 #include "string_func.h"
00043 #include "network/network.h"
00044 #include <map>
00045 #include "smallmap_gui.h"
00046 #include "genworld.h"
00047 #include "error.h"
00048 #include "vehicle_func.h"
00049 #include "language.h"
00050 #include "vehicle_base.h"
00051 
00052 #include "table/strings.h"
00053 #include "table/build_industry.h"
00054 
00055 /* TTDPatch extended GRF format codec
00056  * (c) Petr Baudis 2004 (GPL'd)
00057  * Changes by Florian octo Forster are (c) by the OpenTTD development team.
00058  *
00059  * Contains portions of documentation by TTDPatch team.
00060  * Thanks especially to Josef Drexler for the documentation as well as a lot
00061  * of help at #tycoon. Also thanks to Michael Blunck for his GRF files which
00062  * served as subject to the initial testing of this codec. */
00063 
00065 static SmallVector<GRFFile *, 16> _grf_files;
00066 
00068 byte _misc_grf_features = 0;
00069 
00071 static uint32 _ttdpatch_flags[8];
00072 
00074 GRFLoadedFeatures _loaded_newgrf_features;
00075 
00076 static const uint MAX_SPRITEGROUP = UINT8_MAX; 
00077 
00079 struct GrfProcessingState {
00080 private:
00082   struct SpriteSet {
00083     SpriteID sprite;  
00084     uint num_sprites; 
00085   };
00086 
00088   std::map<uint, SpriteSet> spritesets[GSF_END];
00089 
00090 public:
00091   /* Global state */
00092   GrfLoadingStage stage;    
00093   SpriteID spriteid;        
00094 
00095   /* Local state in the file */
00096   uint file_index;          
00097   GRFFile *grffile;         
00098   GRFConfig *grfconfig;     
00099   uint32 nfo_line;          
00100   byte grf_container_ver;   
00101 
00102   /* Kind of return values when processing certain actions */
00103   int skip_sprites;         
00104 
00105   /* Currently referenceable spritegroups */
00106   SpriteGroup *spritegroups[MAX_SPRITEGROUP + 1];
00107 
00109   void ClearDataForNextFile()
00110   {
00111     this->nfo_line = 0;
00112     this->skip_sprites = 0;
00113 
00114     for (uint i = 0; i < GSF_END; i++) {
00115       this->spritesets[i].clear();
00116     }
00117 
00118     memset(this->spritegroups, 0, sizeof(this->spritegroups));
00119   }
00120 
00129   void AddSpriteSets(byte feature, SpriteID first_sprite, uint first_set, uint numsets, uint numents)
00130   {
00131     assert(feature < GSF_END);
00132     for (uint i = 0; i < numsets; i++) {
00133       SpriteSet &set = this->spritesets[feature][first_set + i];
00134       set.sprite = first_sprite + i * numents;
00135       set.num_sprites = numents;
00136     }
00137   }
00138 
00145   bool HasValidSpriteSets(byte feature) const
00146   {
00147     assert(feature < GSF_END);
00148     return !this->spritesets[feature].empty();
00149   }
00150 
00158   bool IsValidSpriteSet(byte feature, uint set) const
00159   {
00160     assert(feature < GSF_END);
00161     return this->spritesets[feature].find(set) != this->spritesets[feature].end();
00162   }
00163 
00170   SpriteID GetSprite(byte feature, uint set) const
00171   {
00172     assert(IsValidSpriteSet(feature, set));
00173     return this->spritesets[feature].find(set)->second.sprite;
00174   }
00175 
00182   uint GetNumEnts(byte feature, uint set) const
00183   {
00184     assert(IsValidSpriteSet(feature, set));
00185     return this->spritesets[feature].find(set)->second.num_sprites;
00186   }
00187 };
00188 
00189 static GrfProcessingState _cur;
00190 
00191 
00198 template <VehicleType T>
00199 static inline bool IsValidNewGRFImageIndex(uint8 image_index)
00200 {
00201   return image_index == 0xFD || IsValidImageIndex<T>(image_index);
00202 }
00203 
00204 class OTTDByteReaderSignal { };
00205 
00207 class ByteReader {
00208 protected:
00209   byte *data;
00210   byte *end;
00211 
00212 public:
00213   ByteReader(byte *data, byte *end) : data(data), end(end) { }
00214 
00215   inline byte ReadByte()
00216   {
00217     if (data < end) return *(data)++;
00218     throw OTTDByteReaderSignal();
00219   }
00220 
00221   uint16 ReadWord()
00222   {
00223     uint16 val = ReadByte();
00224     return val | (ReadByte() << 8);
00225   }
00226 
00227   uint16 ReadExtendedByte()
00228   {
00229     uint16 val = ReadByte();
00230     return val == 0xFF ? ReadWord() : val;
00231   }
00232 
00233   uint32 ReadDWord()
00234   {
00235     uint32 val = ReadWord();
00236     return val | (ReadWord() << 16);
00237   }
00238 
00239   uint32 ReadVarSize(byte size)
00240   {
00241     switch (size) {
00242       case 1: return ReadByte();
00243       case 2: return ReadWord();
00244       case 4: return ReadDWord();
00245       default:
00246         NOT_REACHED();
00247         return 0;
00248     }
00249   }
00250 
00251   const char *ReadString()
00252   {
00253     char *string = reinterpret_cast<char *>(data);
00254     size_t string_length = ttd_strnlen(string, Remaining());
00255 
00256     if (string_length == Remaining()) {
00257       /* String was not NUL terminated, so make sure it is now. */
00258       string[string_length - 1] = '\0';
00259       grfmsg(7, "String was not terminated with a zero byte.");
00260     } else {
00261       /* Increase the string length to include the NUL byte. */
00262       string_length++;
00263     }
00264     Skip(string_length);
00265 
00266     return string;
00267   }
00268 
00269   inline size_t Remaining() const
00270   {
00271     return end - data;
00272   }
00273 
00274   inline bool HasData(size_t count = 1) const
00275   {
00276     return data + count <= end;
00277   }
00278 
00279   inline byte *Data()
00280   {
00281     return data;
00282   }
00283 
00284   inline void Skip(size_t len)
00285   {
00286     data += len;
00287     /* It is valid to move the buffer to exactly the end of the data,
00288      * as there may not be any more data read. */
00289     if (data > end) throw OTTDByteReaderSignal();
00290   }
00291 };
00292 
00293 typedef void (*SpecialSpriteHandler)(ByteReader *buf);
00294 
00295 static const uint NUM_STATIONS_PER_GRF = 255; 
00296 
00298 struct GRFTempEngineData {
00300   enum Refittability {
00301     UNSET    =  0,  
00302     EMPTY,          
00303     NONEMPTY,       
00304   };
00305 
00306   uint16 cargo_allowed;
00307   uint16 cargo_disallowed;
00308   RailTypeLabel railtypelabel;
00309   const GRFFile *defaultcargo_grf; 
00310   Refittability refittability;     
00311   bool prop27_set;         
00312   uint8 rv_max_speed;      
00313   uint32 ctt_include_mask; 
00314   uint32 ctt_exclude_mask; 
00315 
00320   void UpdateRefittability(bool non_empty)
00321   {
00322     if (non_empty) {
00323       this->refittability = NONEMPTY;
00324     } else if (this->refittability == UNSET) {
00325       this->refittability = EMPTY;
00326     }
00327   }
00328 };
00329 
00330 static GRFTempEngineData *_gted;  
00331 
00336 static uint32 _grm_engines[256];
00337 
00339 static uint32 _grm_cargoes[NUM_CARGO * 2];
00340 
00341 struct GRFLocation {
00342   uint32 grfid;
00343   uint32 nfoline;
00344 
00345   GRFLocation(uint32 grfid, uint32 nfoline) : grfid(grfid), nfoline(nfoline) { }
00346 
00347   bool operator<(const GRFLocation &other) const
00348   {
00349     return this->grfid < other.grfid || (this->grfid == other.grfid && this->nfoline < other.nfoline);
00350   }
00351 
00352   bool operator == (const GRFLocation &other) const
00353   {
00354     return this->grfid == other.grfid && this->nfoline == other.nfoline;
00355   }
00356 };
00357 
00358 static std::map<GRFLocation, SpriteID> _grm_sprites;
00359 typedef std::map<GRFLocation, byte*> GRFLineToSpriteOverride;
00360 static GRFLineToSpriteOverride _grf_line_to_action6_sprite_override;
00361 
00372 void CDECL grfmsg(int severity, const char *str, ...)
00373 {
00374   char buf[1024];
00375   va_list va;
00376 
00377   va_start(va, str);
00378   vsnprintf(buf, sizeof(buf), str, va);
00379   va_end(va);
00380 
00381   DEBUG(grf, severity, "[%s:%d] %s", _cur.grfconfig->filename, _cur.nfo_line, buf);
00382 }
00383 
00389 static GRFFile *GetFileByGRFID(uint32 grfid)
00390 {
00391   const GRFFile * const *end = _grf_files.End();
00392   for (GRFFile * const *file = _grf_files.Begin(); file != end; file++) {
00393     if ((*file)->grfid == grfid) return *file;
00394   }
00395   return NULL;
00396 }
00397 
00403 static GRFFile *GetFileByFilename(const char *filename)
00404 {
00405   const GRFFile * const *end = _grf_files.End();
00406   for (GRFFile * const *file = _grf_files.Begin(); file != end; file++) {
00407     if (strcmp((*file)->filename, filename) == 0) return *file;
00408   }
00409   return NULL;
00410 }
00411 
00413 static void ClearTemporaryNewGRFData(GRFFile *gf)
00414 {
00415   /* Clear the GOTO labels used for GRF processing */
00416   for (GRFLabel *l = gf->label; l != NULL;) {
00417     GRFLabel *l2 = l->next;
00418     free(l);
00419     l = l2;
00420   }
00421   gf->label = NULL;
00422 }
00423 
00430 static GRFError *DisableGrf(StringID message = STR_NULL, GRFConfig *config = NULL)
00431 {
00432   GRFFile *file;
00433   if (config != NULL) {
00434     file = GetFileByGRFID(config->ident.grfid);
00435   } else {
00436     config = _cur.grfconfig;
00437     file = _cur.grffile;
00438   }
00439 
00440   config->status = GCS_DISABLED;
00441   if (file != NULL) ClearTemporaryNewGRFData(file);
00442   if (config == _cur.grfconfig) _cur.skip_sprites = -1;
00443 
00444   if (message != STR_NULL) {
00445     delete config->error;
00446     config->error = new GRFError(STR_NEWGRF_ERROR_MSG_FATAL, message);
00447     if (config == _cur.grfconfig) config->error->param_value[0] = _cur.nfo_line;
00448   }
00449 
00450   return config->error;
00451 }
00452 
00453 
00454 typedef std::map<StringID *, uint32> StringIDToGRFIDMapping;
00455 static StringIDToGRFIDMapping _string_to_grf_mapping;
00456 
00464 StringID MapGRFStringID(uint32 grfid, StringID str)
00465 {
00466   /* 0xD0 and 0xDC stand for all the TextIDs in the range
00467    * of 0xD000 (misc graphics texts) and 0xDC00 (misc persistent texts).
00468    * These strings are unique to each grf file, and thus require to be used with the
00469    * grfid in which they are declared */
00470   switch (GB(str, 8, 8)) {
00471     case 0xD0: case 0xD1: case 0xD2: case 0xD3:
00472     case 0xDC:
00473       return GetGRFStringID(grfid, str);
00474 
00475     case 0xD4: case 0xD5: case 0xD6: case 0xD7:
00476       /* Strings embedded via 0x81 have 0x400 added to them (no real
00477        * explanation why...) */
00478       return GetGRFStringID(grfid, str - 0x400);
00479 
00480     default: break;
00481   }
00482 
00483   return TTDPStringIDToOTTDStringIDMapping(str);
00484 }
00485 
00486 static std::map<uint32, uint32> _grf_id_overrides;
00487 
00493 static void SetNewGRFOverride(uint32 source_grfid, uint32 target_grfid)
00494 {
00495   _grf_id_overrides[source_grfid] = target_grfid;
00496   grfmsg(5, "SetNewGRFOverride: Added override of 0x%X to 0x%X", BSWAP32(source_grfid), BSWAP32(target_grfid));
00497 }
00498 
00507 static Engine *GetNewEngine(const GRFFile *file, VehicleType type, uint16 internal_id, bool static_access = false)
00508 {
00509   /* Hack for add-on GRFs that need to modify another GRF's engines. This lets
00510    * them use the same engine slots. */
00511   uint32 scope_grfid = INVALID_GRFID; // If not using dynamic_engines, all newgrfs share their ID range
00512   if (_settings_game.vehicle.dynamic_engines) {
00513     /* If dynamic_engies is enabled, there can be multiple independent ID ranges. */
00514     scope_grfid = file->grfid;
00515     uint32 override = _grf_id_overrides[file->grfid];
00516     if (override != 0) {
00517       scope_grfid = override;
00518       const GRFFile *grf_match = GetFileByGRFID(override);
00519       if (grf_match == NULL) {
00520         grfmsg(5, "Tried mapping from GRFID %x to %x but target is not loaded", BSWAP32(file->grfid), BSWAP32(override));
00521       } else {
00522         grfmsg(5, "Mapping from GRFID %x to %x", BSWAP32(file->grfid), BSWAP32(override));
00523       }
00524     }
00525 
00526     /* Check if the engine is registered in the override manager */
00527     EngineID engine = _engine_mngr.GetID(type, internal_id, scope_grfid);
00528     if (engine != INVALID_ENGINE) {
00529       Engine *e = Engine::Get(engine);
00530       if (e->grf_prop.grffile == NULL) e->grf_prop.grffile = file;
00531       return e;
00532     }
00533   }
00534 
00535   /* Check if there is an unreserved slot */
00536   EngineID engine = _engine_mngr.GetID(type, internal_id, INVALID_GRFID);
00537   if (engine != INVALID_ENGINE) {
00538     Engine *e = Engine::Get(engine);
00539 
00540     if (e->grf_prop.grffile == NULL) {
00541       e->grf_prop.grffile = file;
00542       grfmsg(5, "Replaced engine at index %d for GRFID %x, type %d, index %d", e->index, BSWAP32(file->grfid), type, internal_id);
00543     }
00544 
00545     /* Reserve the engine slot */
00546     if (!static_access) {
00547       EngineIDMapping *eid = _engine_mngr.Get(engine);
00548       eid->grfid           = scope_grfid; // Note: this is INVALID_GRFID if dynamic_engines is disabled, so no reservation
00549     }
00550 
00551     return e;
00552   }
00553 
00554   if (static_access) return NULL;
00555 
00556   if (!Engine::CanAllocateItem()) {
00557     grfmsg(0, "Can't allocate any more engines");
00558     return NULL;
00559   }
00560 
00561   size_t engine_pool_size = Engine::GetPoolSize();
00562 
00563   /* ... it's not, so create a new one based off an existing engine */
00564   Engine *e = new Engine(type, internal_id);
00565   e->grf_prop.grffile = file;
00566 
00567   /* Reserve the engine slot */
00568   assert(_engine_mngr.Length() == e->index);
00569   EngineIDMapping *eid = _engine_mngr.Append();
00570   eid->type            = type;
00571   eid->grfid           = scope_grfid; // Note: this is INVALID_GRFID if dynamic_engines is disabled, so no reservation
00572   eid->internal_id     = internal_id;
00573   eid->substitute_id   = min(internal_id, _engine_counts[type]); // substitute_id == _engine_counts[subtype] means "no substitute"
00574 
00575   if (engine_pool_size != Engine::GetPoolSize()) {
00576     /* Resize temporary engine data ... */
00577     _gted = ReallocT(_gted, Engine::GetPoolSize());
00578 
00579     /* and blank the new block. */
00580     size_t len = (Engine::GetPoolSize() - engine_pool_size) * sizeof(*_gted);
00581     memset(_gted + engine_pool_size, 0, len);
00582   }
00583   if (type == VEH_TRAIN) {
00584     _gted[e->index].railtypelabel = GetRailTypeInfo(e->u.rail.railtype)->label;
00585   }
00586 
00587   grfmsg(5, "Created new engine at index %d for GRFID %x, type %d, index %d", e->index, BSWAP32(file->grfid), type, internal_id);
00588 
00589   return e;
00590 }
00591 
00602 EngineID GetNewEngineID(const GRFFile *file, VehicleType type, uint16 internal_id)
00603 {
00604   uint32 scope_grfid = INVALID_GRFID; // If not using dynamic_engines, all newgrfs share their ID range
00605   if (_settings_game.vehicle.dynamic_engines) {
00606     scope_grfid = file->grfid;
00607     uint32 override = _grf_id_overrides[file->grfid];
00608     if (override != 0) scope_grfid = override;
00609   }
00610 
00611   return _engine_mngr.GetID(type, internal_id, scope_grfid);
00612 }
00613 
00618 static void MapSpriteMappingRecolour(PalSpriteID *grf_sprite)
00619 {
00620   if (HasBit(grf_sprite->pal, 14)) {
00621     ClrBit(grf_sprite->pal, 14);
00622     SetBit(grf_sprite->sprite, SPRITE_MODIFIER_OPAQUE);
00623   }
00624 
00625   if (HasBit(grf_sprite->sprite, 14)) {
00626     ClrBit(grf_sprite->sprite, 14);
00627     SetBit(grf_sprite->sprite, PALETTE_MODIFIER_TRANSPARENT);
00628   }
00629 
00630   if (HasBit(grf_sprite->sprite, 15)) {
00631     ClrBit(grf_sprite->sprite, 15);
00632     SetBit(grf_sprite->sprite, PALETTE_MODIFIER_COLOUR);
00633   }
00634 }
00635 
00649 static TileLayoutFlags ReadSpriteLayoutSprite(ByteReader *buf, bool read_flags, bool invert_action1_flag, bool use_cur_spritesets, int feature, PalSpriteID *grf_sprite, uint16 *max_sprite_offset = NULL, uint16 *max_palette_offset = NULL)
00650 {
00651   grf_sprite->sprite = buf->ReadWord();
00652   grf_sprite->pal = buf->ReadWord();
00653   TileLayoutFlags flags = read_flags ? (TileLayoutFlags)buf->ReadWord() : TLF_NOTHING;
00654 
00655   MapSpriteMappingRecolour(grf_sprite);
00656 
00657   bool custom_sprite = HasBit(grf_sprite->pal, 15) != invert_action1_flag;
00658   ClrBit(grf_sprite->pal, 15);
00659   if (custom_sprite) {
00660     /* Use sprite from Action 1 */
00661     uint index = GB(grf_sprite->sprite, 0, 14);
00662     if (use_cur_spritesets && (!_cur.IsValidSpriteSet(feature, index) || _cur.GetNumEnts(feature, index) == 0)) {
00663       grfmsg(1, "ReadSpriteLayoutSprite: Spritelayout uses undefined custom spriteset %d", index);
00664       grf_sprite->sprite = SPR_IMG_QUERY;
00665       grf_sprite->pal = PAL_NONE;
00666     } else {
00667       SpriteID sprite = use_cur_spritesets ? _cur.GetSprite(feature, index) : index;
00668       if (max_sprite_offset != NULL) *max_sprite_offset = use_cur_spritesets ? _cur.GetNumEnts(feature, index) : UINT16_MAX;
00669       SB(grf_sprite->sprite, 0, SPRITE_WIDTH, sprite);
00670       SetBit(grf_sprite->sprite, SPRITE_MODIFIER_CUSTOM_SPRITE);
00671     }
00672   } else if ((flags & TLF_SPRITE_VAR10) && !(flags & TLF_SPRITE_REG_FLAGS)) {
00673     grfmsg(1, "ReadSpriteLayoutSprite: Spritelayout specifies var10 value for non-action-1 sprite");
00674     DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
00675     return flags;
00676   }
00677 
00678   if (flags & TLF_CUSTOM_PALETTE) {
00679     /* Use palette from Action 1 */
00680     uint index = GB(grf_sprite->pal, 0, 14);
00681     if (use_cur_spritesets && (!_cur.IsValidSpriteSet(feature, index) || _cur.GetNumEnts(feature, index) == 0)) {
00682       grfmsg(1, "ReadSpriteLayoutSprite: Spritelayout uses undefined custom spriteset %d for 'palette'", index);
00683       grf_sprite->pal = PAL_NONE;
00684     } else {
00685       SpriteID sprite = use_cur_spritesets ? _cur.GetSprite(feature, index) : index;
00686       if (max_palette_offset != NULL) *max_palette_offset = use_cur_spritesets ? _cur.GetNumEnts(feature, index) : UINT16_MAX;
00687       SB(grf_sprite->pal, 0, SPRITE_WIDTH, sprite);
00688       SetBit(grf_sprite->pal, SPRITE_MODIFIER_CUSTOM_SPRITE);
00689     }
00690   } else if ((flags & TLF_PALETTE_VAR10) && !(flags & TLF_PALETTE_REG_FLAGS)) {
00691     grfmsg(1, "ReadSpriteLayoutRegisters: Spritelayout specifies var10 value for non-action-1 palette");
00692     DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
00693     return flags;
00694   }
00695 
00696   return flags;
00697 }
00698 
00707 static void ReadSpriteLayoutRegisters(ByteReader *buf, TileLayoutFlags flags, bool is_parent, NewGRFSpriteLayout *dts, uint index)
00708 {
00709   if (!(flags & TLF_DRAWING_FLAGS)) return;
00710 
00711   if (dts->registers == NULL) dts->AllocateRegisters();
00712   TileLayoutRegisters &regs = const_cast<TileLayoutRegisters&>(dts->registers[index]);
00713   regs.flags = flags & TLF_DRAWING_FLAGS;
00714 
00715   if (flags & TLF_DODRAW)  regs.dodraw  = buf->ReadByte();
00716   if (flags & TLF_SPRITE)  regs.sprite  = buf->ReadByte();
00717   if (flags & TLF_PALETTE) regs.palette = buf->ReadByte();
00718 
00719   if (is_parent) {
00720     if (flags & TLF_BB_XY_OFFSET) {
00721       regs.delta.parent[0] = buf->ReadByte();
00722       regs.delta.parent[1] = buf->ReadByte();
00723     }
00724     if (flags & TLF_BB_Z_OFFSET)    regs.delta.parent[2] = buf->ReadByte();
00725   } else {
00726     if (flags & TLF_CHILD_X_OFFSET) regs.delta.child[0]  = buf->ReadByte();
00727     if (flags & TLF_CHILD_Y_OFFSET) regs.delta.child[1]  = buf->ReadByte();
00728   }
00729 
00730   if (flags & TLF_SPRITE_VAR10) {
00731     regs.sprite_var10 = buf->ReadByte();
00732     if (regs.sprite_var10 > TLR_MAX_VAR10) {
00733       grfmsg(1, "ReadSpriteLayoutRegisters: Spritelayout specifies var10 (%d) exceeding the maximal allowed value %d", regs.sprite_var10, TLR_MAX_VAR10);
00734       DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
00735       return;
00736     }
00737   }
00738 
00739   if (flags & TLF_PALETTE_VAR10) {
00740     regs.palette_var10 = buf->ReadByte();
00741     if (regs.palette_var10 > TLR_MAX_VAR10) {
00742       grfmsg(1, "ReadSpriteLayoutRegisters: Spritelayout specifies var10 (%d) exceeding the maximal allowed value %d", regs.palette_var10, TLR_MAX_VAR10);
00743       DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
00744       return;
00745     }
00746   }
00747 }
00748 
00760 static bool ReadSpriteLayout(ByteReader *buf, uint num_building_sprites, bool use_cur_spritesets, byte feature, bool allow_var10, bool no_z_position, NewGRFSpriteLayout *dts)
00761 {
00762   bool has_flags = HasBit(num_building_sprites, 6);
00763   ClrBit(num_building_sprites, 6);
00764   TileLayoutFlags valid_flags = TLF_KNOWN_FLAGS;
00765   if (!allow_var10) valid_flags &= ~TLF_VAR10_FLAGS;
00766   dts->Allocate(num_building_sprites); // allocate before reading groundsprite flags
00767 
00768   uint16 *max_sprite_offset = AllocaM(uint16, num_building_sprites + 1);
00769   uint16 *max_palette_offset = AllocaM(uint16, num_building_sprites + 1);
00770   MemSetT(max_sprite_offset, 0, num_building_sprites + 1);
00771   MemSetT(max_palette_offset, 0, num_building_sprites + 1);
00772 
00773   /* Groundsprite */
00774   TileLayoutFlags flags = ReadSpriteLayoutSprite(buf, has_flags, false, use_cur_spritesets, feature, &dts->ground, max_sprite_offset, max_palette_offset);
00775   if (_cur.skip_sprites < 0) return true;
00776 
00777   if (flags & ~(valid_flags & ~TLF_NON_GROUND_FLAGS)) {
00778     grfmsg(1, "ReadSpriteLayout: Spritelayout uses invalid flag 0x%x for ground sprite", flags & ~(valid_flags & ~TLF_NON_GROUND_FLAGS));
00779     DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
00780     return true;
00781   }
00782 
00783   ReadSpriteLayoutRegisters(buf, flags, false, dts, 0);
00784   if (_cur.skip_sprites < 0) return true;
00785 
00786   for (uint i = 0; i < num_building_sprites; i++) {
00787     DrawTileSeqStruct *seq = const_cast<DrawTileSeqStruct*>(&dts->seq[i]);
00788 
00789     flags = ReadSpriteLayoutSprite(buf, has_flags, false, use_cur_spritesets, feature, &seq->image, max_sprite_offset + i + 1, max_palette_offset + i + 1);
00790     if (_cur.skip_sprites < 0) return true;
00791 
00792     if (flags & ~valid_flags) {
00793       grfmsg(1, "ReadSpriteLayout: Spritelayout uses unknown flag 0x%x", flags & ~valid_flags);
00794       DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
00795       return true;
00796     }
00797 
00798     seq->delta_x = buf->ReadByte();
00799     seq->delta_y = buf->ReadByte();
00800 
00801     if (!no_z_position) seq->delta_z = buf->ReadByte();
00802 
00803     if (seq->IsParentSprite()) {
00804       seq->size_x = buf->ReadByte();
00805       seq->size_y = buf->ReadByte();
00806       seq->size_z = buf->ReadByte();
00807     }
00808 
00809     ReadSpriteLayoutRegisters(buf, flags, seq->IsParentSprite(), dts, i + 1);
00810     if (_cur.skip_sprites < 0) return true;
00811   }
00812 
00813   /* Check if the number of sprites per spriteset is consistent */
00814   bool is_consistent = true;
00815   dts->consistent_max_offset = 0;
00816   for (uint i = 0; i < num_building_sprites + 1; i++) {
00817     if (max_sprite_offset[i] > 0) {
00818       if (dts->consistent_max_offset == 0) {
00819         dts->consistent_max_offset = max_sprite_offset[i];
00820       } else if (dts->consistent_max_offset != max_sprite_offset[i]) {
00821         is_consistent = false;
00822         break;
00823       }
00824     }
00825     if (max_palette_offset[i] > 0) {
00826       if (dts->consistent_max_offset == 0) {
00827         dts->consistent_max_offset = max_palette_offset[i];
00828       } else if (dts->consistent_max_offset != max_palette_offset[i]) {
00829         is_consistent = false;
00830         break;
00831       }
00832     }
00833   }
00834 
00835   /* When the Action1 sets are unknown, everything should be 0 (no spriteset usage) or UINT16_MAX (some spriteset usage) */
00836   assert(use_cur_spritesets || (is_consistent && (dts->consistent_max_offset == 0 || dts->consistent_max_offset == UINT16_MAX)));
00837 
00838   if (!is_consistent || dts->registers != NULL) {
00839     dts->consistent_max_offset = 0;
00840     if (dts->registers == NULL) dts->AllocateRegisters();
00841 
00842     for (uint i = 0; i < num_building_sprites + 1; i++) {
00843       TileLayoutRegisters &regs = const_cast<TileLayoutRegisters&>(dts->registers[i]);
00844       regs.max_sprite_offset = max_sprite_offset[i];
00845       regs.max_palette_offset = max_palette_offset[i];
00846     }
00847   }
00848 
00849   return false;
00850 }
00851 
00855 static uint32 TranslateRefitMask(uint32 refit_mask)
00856 {
00857   uint32 result = 0;
00858   uint8 bit;
00859   FOR_EACH_SET_BIT(bit, refit_mask) {
00860     CargoID cargo = GetCargoTranslation(bit, _cur.grffile, true);
00861     if (cargo != CT_INVALID) SetBit(result, cargo);
00862   }
00863   return result;
00864 }
00865 
00873 static void ConvertTTDBasePrice(uint32 base_pointer, const char *error_location, Price *index)
00874 {
00875   /* Special value for 'none' */
00876   if (base_pointer == 0) {
00877     *index = INVALID_PRICE;
00878     return;
00879   }
00880 
00881   static const uint32 start = 0x4B34; 
00882   static const uint32 size  = 6;      
00883 
00884   if (base_pointer < start || (base_pointer - start) % size != 0 || (base_pointer - start) / size >= PR_END) {
00885     grfmsg(1, "%s: Unsupported running cost base 0x%04X, ignoring", error_location, base_pointer);
00886     return;
00887   }
00888 
00889   *index = (Price)((base_pointer - start) / size);
00890 }
00891 
00893 enum ChangeInfoResult {
00894   CIR_SUCCESS,    
00895   CIR_DISABLED,   
00896   CIR_UNHANDLED,  
00897   CIR_UNKNOWN,    
00898   CIR_INVALID_ID, 
00899 };
00900 
00901 typedef ChangeInfoResult (*VCI_Handler)(uint engine, int numinfo, int prop, ByteReader *buf);
00902 
00910 static ChangeInfoResult CommonVehicleChangeInfo(EngineInfo *ei, int prop, ByteReader *buf)
00911 {
00912   switch (prop) {
00913     case 0x00: // Introduction date
00914       ei->base_intro = buf->ReadWord() + DAYS_TILL_ORIGINAL_BASE_YEAR;
00915       break;
00916 
00917     case 0x02: // Decay speed
00918       ei->decay_speed = buf->ReadByte();
00919       break;
00920 
00921     case 0x03: // Vehicle life
00922       ei->lifelength = buf->ReadByte();
00923       break;
00924 
00925     case 0x04: // Model life
00926       ei->base_life = buf->ReadByte();
00927       break;
00928 
00929     case 0x06: // Climates available
00930       ei->climates = buf->ReadByte();
00931       break;
00932 
00933     case PROP_VEHICLE_LOAD_AMOUNT: // 0x07 Loading speed
00934       /* Amount of cargo loaded during a vehicle's "loading tick" */
00935       ei->load_amount = buf->ReadByte();
00936       break;
00937 
00938     default:
00939       return CIR_UNKNOWN;
00940   }
00941 
00942   return CIR_SUCCESS;
00943 }
00944 
00953 static ChangeInfoResult RailVehicleChangeInfo(uint engine, int numinfo, int prop, ByteReader *buf)
00954 {
00955   ChangeInfoResult ret = CIR_SUCCESS;
00956 
00957   for (int i = 0; i < numinfo; i++) {
00958     Engine *e = GetNewEngine(_cur.grffile, VEH_TRAIN, engine + i);
00959     if (e == NULL) return CIR_INVALID_ID; // No engine could be allocated, so neither can any next vehicles
00960 
00961     EngineInfo *ei = &e->info;
00962     RailVehicleInfo *rvi = &e->u.rail;
00963 
00964     switch (prop) {
00965       case 0x05: { // Track type
00966         uint8 tracktype = buf->ReadByte();
00967 
00968         if (tracktype < _cur.grffile->railtype_list.Length()) {
00969           _gted[e->index].railtypelabel = _cur.grffile->railtype_list[tracktype];
00970           break;
00971         }
00972 
00973         switch (tracktype) {
00974           case 0: _gted[e->index].railtypelabel = rvi->engclass >= 2 ? RAILTYPE_ELECTRIC_LABEL : RAILTYPE_RAIL_LABEL; break;
00975           case 1: _gted[e->index].railtypelabel = RAILTYPE_MONO_LABEL; break;
00976           case 2: _gted[e->index].railtypelabel = RAILTYPE_MAGLEV_LABEL; break;
00977           default:
00978             grfmsg(1, "RailVehicleChangeInfo: Invalid track type %d specified, ignoring", tracktype);
00979             break;
00980         }
00981         break;
00982       }
00983 
00984       case 0x08: // AI passenger service
00985         /* Tells the AI that this engine is designed for
00986          * passenger services and shouldn't be used for freight. */
00987         rvi->ai_passenger_only = buf->ReadByte();
00988         break;
00989 
00990       case PROP_TRAIN_SPEED: { // 0x09 Speed (1 unit is 1 km-ish/h)
00991         uint16 speed = buf->ReadWord();
00992         if (speed == 0xFFFF) speed = 0;
00993 
00994         rvi->max_speed = speed;
00995         break;
00996       }
00997 
00998       case PROP_TRAIN_POWER: // 0x0B Power
00999         rvi->power = buf->ReadWord();
01000 
01001         /* Set engine / wagon state based on power */
01002         if (rvi->power != 0) {
01003           if (rvi->railveh_type == RAILVEH_WAGON) {
01004             rvi->railveh_type = RAILVEH_SINGLEHEAD;
01005           }
01006         } else {
01007           rvi->railveh_type = RAILVEH_WAGON;
01008         }
01009         break;
01010 
01011       case PROP_TRAIN_RUNNING_COST_FACTOR: // 0x0D Running cost factor
01012         rvi->running_cost = buf->ReadByte();
01013         break;
01014 
01015       case 0x0E: // Running cost base
01016         ConvertTTDBasePrice(buf->ReadDWord(), "RailVehicleChangeInfo", &rvi->running_cost_class);
01017         break;
01018 
01019       case 0x12: { // Sprite ID
01020         uint8 spriteid = buf->ReadByte();
01021         uint8 orig_spriteid = spriteid;
01022 
01023         /* TTD sprite IDs point to a location in a 16bit array, but we use it
01024          * as an array index, so we need it to be half the original value. */
01025         if (spriteid < 0xFD) spriteid >>= 1;
01026 
01027         if (IsValidNewGRFImageIndex<VEH_TRAIN>(spriteid)) {
01028           rvi->image_index = spriteid;
01029         } else {
01030           grfmsg(1, "RailVehicleChangeInfo: Invalid Sprite %d specified, ignoring", orig_spriteid);
01031           rvi->image_index = 0;
01032         }
01033         break;
01034       }
01035 
01036       case 0x13: { // Dual-headed
01037         uint8 dual = buf->ReadByte();
01038 
01039         if (dual != 0) {
01040           rvi->railveh_type = RAILVEH_MULTIHEAD;
01041         } else {
01042           rvi->railveh_type = rvi->power == 0 ?
01043             RAILVEH_WAGON : RAILVEH_SINGLEHEAD;
01044         }
01045         break;
01046       }
01047 
01048       case PROP_TRAIN_CARGO_CAPACITY: // 0x14 Cargo capacity
01049         rvi->capacity = buf->ReadByte();
01050         break;
01051 
01052       case 0x15: { // Cargo type
01053         _gted[e->index].defaultcargo_grf = _cur.grffile;
01054         uint8 ctype = buf->ReadByte();
01055 
01056         if (ctype == 0xFF) {
01057           /* 0xFF is specified as 'use first refittable' */
01058           ei->cargo_type = CT_INVALID;
01059         } else if (_cur.grffile->grf_version >= 8) {
01060           /* Use translated cargo. Might result in CT_INVALID (first refittable), if cargo is not defined. */
01061           ei->cargo_type = GetCargoTranslation(ctype, _cur.grffile);
01062         } else if (ctype < NUM_CARGO) {
01063           /* Use untranslated cargo. */
01064           ei->cargo_type = ctype;
01065         } else {
01066           ei->cargo_type = CT_INVALID;
01067           grfmsg(2, "RailVehicleChangeInfo: Invalid cargo type %d, using first refittable", ctype);
01068         }
01069         break;
01070       }
01071 
01072       case PROP_TRAIN_WEIGHT: // 0x16 Weight
01073         SB(rvi->weight, 0, 8, buf->ReadByte());
01074         break;
01075 
01076       case PROP_TRAIN_COST_FACTOR: // 0x17 Cost factor
01077         rvi->cost_factor = buf->ReadByte();
01078         break;
01079 
01080       case 0x18: // AI rank
01081         grfmsg(2, "RailVehicleChangeInfo: Property 0x18 'AI rank' not used by NoAI, ignored.");
01082         buf->ReadByte();
01083         break;
01084 
01085       case 0x19: { // Engine traction type
01086         /* What do the individual numbers mean?
01087          * 0x00 .. 0x07: Steam
01088          * 0x08 .. 0x27: Diesel
01089          * 0x28 .. 0x31: Electric
01090          * 0x32 .. 0x37: Monorail
01091          * 0x38 .. 0x41: Maglev
01092          */
01093         uint8 traction = buf->ReadByte();
01094         EngineClass engclass;
01095 
01096         if (traction <= 0x07) {
01097           engclass = EC_STEAM;
01098         } else if (traction <= 0x27) {
01099           engclass = EC_DIESEL;
01100         } else if (traction <= 0x31) {
01101           engclass = EC_ELECTRIC;
01102         } else if (traction <= 0x37) {
01103           engclass = EC_MONORAIL;
01104         } else if (traction <= 0x41) {
01105           engclass = EC_MAGLEV;
01106         } else {
01107           break;
01108         }
01109 
01110         if (_cur.grffile->railtype_list.Length() == 0) {
01111           /* Use traction type to select between normal and electrified
01112            * rail only when no translation list is in place. */
01113           if (_gted[e->index].railtypelabel == RAILTYPE_RAIL_LABEL     && engclass >= EC_ELECTRIC) _gted[e->index].railtypelabel = RAILTYPE_ELECTRIC_LABEL;
01114           if (_gted[e->index].railtypelabel == RAILTYPE_ELECTRIC_LABEL && engclass  < EC_ELECTRIC) _gted[e->index].railtypelabel = RAILTYPE_RAIL_LABEL;
01115         }
01116 
01117         rvi->engclass = engclass;
01118         break;
01119       }
01120 
01121       case 0x1A: // Alter purchase list sort order
01122         AlterVehicleListOrder(e->index, buf->ReadExtendedByte());
01123         break;
01124 
01125       case 0x1B: // Powered wagons power bonus
01126         rvi->pow_wag_power = buf->ReadWord();
01127         break;
01128 
01129       case 0x1C: // Refit cost
01130         ei->refit_cost = buf->ReadByte();
01131         break;
01132 
01133       case 0x1D: { // Refit cargo
01134         uint32 mask = buf->ReadDWord();
01135         _gted[e->index].UpdateRefittability(mask != 0);
01136         ei->refit_mask = TranslateRefitMask(mask);
01137         _gted[e->index].defaultcargo_grf = _cur.grffile;
01138         break;
01139       }
01140 
01141       case 0x1E: // Callback
01142         ei->callback_mask = buf->ReadByte();
01143         break;
01144 
01145       case PROP_TRAIN_TRACTIVE_EFFORT: // 0x1F Tractive effort coefficient
01146         rvi->tractive_effort = buf->ReadByte();
01147         break;
01148 
01149       case 0x20: // Air drag
01150         rvi->air_drag = buf->ReadByte();
01151         break;
01152 
01153       case PROP_TRAIN_SHORTEN_FACTOR: // 0x21 Shorter vehicle
01154         rvi->shorten_factor = buf->ReadByte();
01155         break;
01156 
01157       case 0x22: // Visual effect
01158         rvi->visual_effect = buf->ReadByte();
01159         /* Avoid accidentally setting visual_effect to the default value
01160          * Since bit 6 (disable effects) is set anyways, we can safely erase some bits. */
01161         if (rvi->visual_effect == VE_DEFAULT) {
01162           assert(HasBit(rvi->visual_effect, VE_DISABLE_EFFECT));
01163           SB(rvi->visual_effect, VE_TYPE_START, VE_TYPE_COUNT, 0);
01164         }
01165         break;
01166 
01167       case 0x23: // Powered wagons weight bonus
01168         rvi->pow_wag_weight = buf->ReadByte();
01169         break;
01170 
01171       case 0x24: { // High byte of vehicle weight
01172         byte weight = buf->ReadByte();
01173 
01174         if (weight > 4) {
01175           grfmsg(2, "RailVehicleChangeInfo: Nonsensical weight of %d tons, ignoring", weight << 8);
01176         } else {
01177           SB(rvi->weight, 8, 8, weight);
01178         }
01179         break;
01180       }
01181 
01182       case PROP_TRAIN_USER_DATA: // 0x25 User-defined bit mask to set when checking veh. var. 42
01183         rvi->user_def_data = buf->ReadByte();
01184         break;
01185 
01186       case 0x26: // Retire vehicle early
01187         ei->retire_early = buf->ReadByte();
01188         break;
01189 
01190       case 0x27: // Miscellaneous flags
01191         ei->misc_flags = buf->ReadByte();
01192         _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
01193         _gted[e->index].prop27_set = true;
01194         break;
01195 
01196       case 0x28: // Cargo classes allowed
01197         _gted[e->index].cargo_allowed = buf->ReadWord();
01198         _gted[e->index].UpdateRefittability(_gted[e->index].cargo_allowed != 0);
01199         _gted[e->index].defaultcargo_grf = _cur.grffile;
01200         break;
01201 
01202       case 0x29: // Cargo classes disallowed
01203         _gted[e->index].cargo_disallowed = buf->ReadWord();
01204         _gted[e->index].UpdateRefittability(false);
01205         break;
01206 
01207       case 0x2A: // Long format introduction date (days since year 0)
01208         ei->base_intro = buf->ReadDWord();
01209         break;
01210 
01211       case PROP_TRAIN_CARGO_AGE_PERIOD: // 0x2B Cargo aging period
01212         ei->cargo_age_period = buf->ReadWord();
01213         break;
01214 
01215       case 0x2C:   // CTT refit include list
01216       case 0x2D: { // CTT refit exclude list
01217         uint8 count = buf->ReadByte();
01218         _gted[e->index].UpdateRefittability(prop == 0x2C && count != 0);
01219         if (prop == 0x2C) _gted[e->index].defaultcargo_grf = _cur.grffile;
01220         uint32 &ctt = prop == 0x2C ? _gted[e->index].ctt_include_mask : _gted[e->index].ctt_exclude_mask;
01221         ctt = 0;
01222         while (count--) {
01223           CargoID ctype = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
01224           if (ctype == CT_INVALID) continue;
01225           SetBit(ctt, ctype);
01226         }
01227         break;
01228       }
01229 
01230       default:
01231         ret = CommonVehicleChangeInfo(ei, prop, buf);
01232         break;
01233     }
01234   }
01235 
01236   return ret;
01237 }
01238 
01247 static ChangeInfoResult RoadVehicleChangeInfo(uint engine, int numinfo, int prop, ByteReader *buf)
01248 {
01249   ChangeInfoResult ret = CIR_SUCCESS;
01250 
01251   for (int i = 0; i < numinfo; i++) {
01252     Engine *e = GetNewEngine(_cur.grffile, VEH_ROAD, engine + i);
01253     if (e == NULL) return CIR_INVALID_ID; // No engine could be allocated, so neither can any next vehicles
01254 
01255     EngineInfo *ei = &e->info;
01256     RoadVehicleInfo *rvi = &e->u.road;
01257 
01258     switch (prop) {
01259       case 0x08: // Speed (1 unit is 0.5 kmh)
01260         rvi->max_speed = buf->ReadByte();
01261         break;
01262 
01263       case PROP_ROADVEH_RUNNING_COST_FACTOR: // 0x09 Running cost factor
01264         rvi->running_cost = buf->ReadByte();
01265         break;
01266 
01267       case 0x0A: // Running cost base
01268         ConvertTTDBasePrice(buf->ReadDWord(), "RoadVehicleChangeInfo", &rvi->running_cost_class);
01269         break;
01270 
01271       case 0x0E: { // Sprite ID
01272         uint8 spriteid = buf->ReadByte();
01273         uint8 orig_spriteid = spriteid;
01274 
01275         /* cars have different custom id in the GRF file */
01276         if (spriteid == 0xFF) spriteid = 0xFD;
01277 
01278         if (spriteid < 0xFD) spriteid >>= 1;
01279 
01280         if (IsValidNewGRFImageIndex<VEH_ROAD>(spriteid)) {
01281           rvi->image_index = spriteid;
01282         } else {
01283           grfmsg(1, "RoadVehicleChangeInfo: Invalid Sprite %d specified, ignoring", orig_spriteid);
01284           rvi->image_index = 0;
01285         }
01286         break;
01287       }
01288 
01289       case PROP_ROADVEH_CARGO_CAPACITY: // 0x0F Cargo capacity
01290         rvi->capacity = buf->ReadByte();
01291         break;
01292 
01293       case 0x10: { // Cargo type
01294         _gted[e->index].defaultcargo_grf = _cur.grffile;
01295         uint8 ctype = buf->ReadByte();
01296 
01297         if (ctype == 0xFF) {
01298           /* 0xFF is specified as 'use first refittable' */
01299           ei->cargo_type = CT_INVALID;
01300         } else if (_cur.grffile->grf_version >= 8) {
01301           /* Use translated cargo. Might result in CT_INVALID (first refittable), if cargo is not defined. */
01302           ei->cargo_type = GetCargoTranslation(ctype, _cur.grffile);
01303         } else if (ctype < NUM_CARGO) {
01304           /* Use untranslated cargo. */
01305           ei->cargo_type = ctype;
01306         } else {
01307           ei->cargo_type = CT_INVALID;
01308           grfmsg(2, "RailVehicleChangeInfo: Invalid cargo type %d, using first refittable", ctype);
01309         }
01310         break;
01311       }
01312 
01313       case PROP_ROADVEH_COST_FACTOR: // 0x11 Cost factor
01314         rvi->cost_factor = buf->ReadByte();
01315         break;
01316 
01317       case 0x12: // SFX
01318         rvi->sfx = buf->ReadByte();
01319         break;
01320 
01321       case PROP_ROADVEH_POWER: // Power in units of 10 HP.
01322         rvi->power = buf->ReadByte();
01323         break;
01324 
01325       case PROP_ROADVEH_WEIGHT: // Weight in units of 1/4 tons.
01326         rvi->weight = buf->ReadByte();
01327         break;
01328 
01329       case PROP_ROADVEH_SPEED: // Speed in mph/0.8
01330         _gted[e->index].rv_max_speed = buf->ReadByte();
01331         break;
01332 
01333       case 0x16: { // Cargoes available for refitting
01334         uint32 mask = buf->ReadDWord();
01335         _gted[e->index].UpdateRefittability(mask != 0);
01336         ei->refit_mask = TranslateRefitMask(mask);
01337         _gted[e->index].defaultcargo_grf = _cur.grffile;
01338         break;
01339       }
01340 
01341       case 0x17: // Callback mask
01342         ei->callback_mask = buf->ReadByte();
01343         break;
01344 
01345       case PROP_ROADVEH_TRACTIVE_EFFORT: // Tractive effort coefficient in 1/256.
01346         rvi->tractive_effort = buf->ReadByte();
01347         break;
01348 
01349       case 0x19: // Air drag
01350         rvi->air_drag = buf->ReadByte();
01351         break;
01352 
01353       case 0x1A: // Refit cost
01354         ei->refit_cost = buf->ReadByte();
01355         break;
01356 
01357       case 0x1B: // Retire vehicle early
01358         ei->retire_early = buf->ReadByte();
01359         break;
01360 
01361       case 0x1C: // Miscellaneous flags
01362         ei->misc_flags = buf->ReadByte();
01363         _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
01364         break;
01365 
01366       case 0x1D: // Cargo classes allowed
01367         _gted[e->index].cargo_allowed = buf->ReadWord();
01368         _gted[e->index].UpdateRefittability(_gted[e->index].cargo_allowed != 0);
01369         _gted[e->index].defaultcargo_grf = _cur.grffile;
01370         break;
01371 
01372       case 0x1E: // Cargo classes disallowed
01373         _gted[e->index].cargo_disallowed = buf->ReadWord();
01374         _gted[e->index].UpdateRefittability(false);
01375         break;
01376 
01377       case 0x1F: // Long format introduction date (days since year 0)
01378         ei->base_intro = buf->ReadDWord();
01379         break;
01380 
01381       case 0x20: // Alter purchase list sort order
01382         AlterVehicleListOrder(e->index, buf->ReadExtendedByte());
01383         break;
01384 
01385       case 0x21: // Visual effect
01386         rvi->visual_effect = buf->ReadByte();
01387         /* Avoid accidentally setting visual_effect to the default value
01388          * Since bit 6 (disable effects) is set anyways, we can safely erase some bits. */
01389         if (rvi->visual_effect == VE_DEFAULT) {
01390           assert(HasBit(rvi->visual_effect, VE_DISABLE_EFFECT));
01391           SB(rvi->visual_effect, VE_TYPE_START, VE_TYPE_COUNT, 0);
01392         }
01393         break;
01394 
01395       case PROP_ROADVEH_CARGO_AGE_PERIOD: // 0x22 Cargo aging period
01396         ei->cargo_age_period = buf->ReadWord();
01397         break;
01398 
01399       case PROP_ROADVEH_SHORTEN_FACTOR: // 0x23 Shorter vehicle
01400         rvi->shorten_factor = buf->ReadByte();
01401         break;
01402 
01403       case 0x24:   // CTT refit include list
01404       case 0x25: { // CTT refit exclude list
01405         uint8 count = buf->ReadByte();
01406         _gted[e->index].UpdateRefittability(prop == 0x24 && count != 0);
01407         if (prop == 0x24) _gted[e->index].defaultcargo_grf = _cur.grffile;
01408         uint32 &ctt = prop == 0x24 ? _gted[e->index].ctt_include_mask : _gted[e->index].ctt_exclude_mask;
01409         ctt = 0;
01410         while (count--) {
01411           CargoID ctype = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
01412           if (ctype == CT_INVALID) continue;
01413           SetBit(ctt, ctype);
01414         }
01415         break;
01416       }
01417 
01418       default:
01419         ret = CommonVehicleChangeInfo(ei, prop, buf);
01420         break;
01421     }
01422   }
01423 
01424   return ret;
01425 }
01426 
01435 static ChangeInfoResult ShipVehicleChangeInfo(uint engine, int numinfo, int prop, ByteReader *buf)
01436 {
01437   ChangeInfoResult ret = CIR_SUCCESS;
01438 
01439   for (int i = 0; i < numinfo; i++) {
01440     Engine *e = GetNewEngine(_cur.grffile, VEH_SHIP, engine + i);
01441     if (e == NULL) return CIR_INVALID_ID; // No engine could be allocated, so neither can any next vehicles
01442 
01443     EngineInfo *ei = &e->info;
01444     ShipVehicleInfo *svi = &e->u.ship;
01445 
01446     switch (prop) {
01447       case 0x08: { // Sprite ID
01448         uint8 spriteid = buf->ReadByte();
01449         uint8 orig_spriteid = spriteid;
01450 
01451         /* ships have different custom id in the GRF file */
01452         if (spriteid == 0xFF) spriteid = 0xFD;
01453 
01454         if (spriteid < 0xFD) spriteid >>= 1;
01455 
01456         if (IsValidNewGRFImageIndex<VEH_SHIP>(spriteid)) {
01457           svi->image_index = spriteid;
01458         } else {
01459           grfmsg(1, "ShipVehicleChangeInfo: Invalid Sprite %d specified, ignoring", orig_spriteid);
01460           svi->image_index = 0;
01461         }
01462         break;
01463       }
01464 
01465       case 0x09: // Refittable
01466         svi->old_refittable = (buf->ReadByte() != 0);
01467         break;
01468 
01469       case PROP_SHIP_COST_FACTOR: // 0x0A Cost factor
01470         svi->cost_factor = buf->ReadByte();
01471         break;
01472 
01473       case PROP_SHIP_SPEED: // 0x0B Speed (1 unit is 0.5 km-ish/h)
01474         svi->max_speed = buf->ReadByte();
01475         break;
01476 
01477       case 0x0C: { // Cargo type
01478         _gted[e->index].defaultcargo_grf = _cur.grffile;
01479         uint8 ctype = buf->ReadByte();
01480 
01481         if (ctype == 0xFF) {
01482           /* 0xFF is specified as 'use first refittable' */
01483           ei->cargo_type = CT_INVALID;
01484         } else if (_cur.grffile->grf_version >= 8) {
01485           /* Use translated cargo. Might result in CT_INVALID (first refittable), if cargo is not defined. */
01486           ei->cargo_type = GetCargoTranslation(ctype, _cur.grffile);
01487         } else if (ctype < NUM_CARGO) {
01488           /* Use untranslated cargo. */
01489           ei->cargo_type = ctype;
01490         } else {
01491           ei->cargo_type = CT_INVALID;
01492           grfmsg(2, "RailVehicleChangeInfo: Invalid cargo type %d, using first refittable", ctype);
01493         }
01494         break;
01495       }
01496 
01497       case PROP_SHIP_CARGO_CAPACITY: // 0x0D Cargo capacity
01498         svi->capacity = buf->ReadWord();
01499         break;
01500 
01501       case PROP_SHIP_RUNNING_COST_FACTOR: // 0x0F Running cost factor
01502         svi->running_cost = buf->ReadByte();
01503         break;
01504 
01505       case 0x10: // SFX
01506         svi->sfx = buf->ReadByte();
01507         break;
01508 
01509       case 0x11: { // Cargoes available for refitting
01510         uint32 mask = buf->ReadDWord();
01511         _gted[e->index].UpdateRefittability(mask != 0);
01512         ei->refit_mask = TranslateRefitMask(mask);
01513         _gted[e->index].defaultcargo_grf = _cur.grffile;
01514         break;
01515       }
01516 
01517       case 0x12: // Callback mask
01518         ei->callback_mask = buf->ReadByte();
01519         break;
01520 
01521       case 0x13: // Refit cost
01522         ei->refit_cost = buf->ReadByte();
01523         break;
01524 
01525       case 0x14: // Ocean speed fraction
01526         svi->ocean_speed_frac = buf->ReadByte();
01527         break;
01528 
01529       case 0x15: // Canal speed fraction
01530         svi->canal_speed_frac = buf->ReadByte();
01531         break;
01532 
01533       case 0x16: // Retire vehicle early
01534         ei->retire_early = buf->ReadByte();
01535         break;
01536 
01537       case 0x17: // Miscellaneous flags
01538         ei->misc_flags = buf->ReadByte();
01539         _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
01540         break;
01541 
01542       case 0x18: // Cargo classes allowed
01543         _gted[e->index].cargo_allowed = buf->ReadWord();
01544         _gted[e->index].UpdateRefittability(_gted[e->index].cargo_allowed != 0);
01545         _gted[e->index].defaultcargo_grf = _cur.grffile;
01546         break;
01547 
01548       case 0x19: // Cargo classes disallowed
01549         _gted[e->index].cargo_disallowed = buf->ReadWord();
01550         _gted[e->index].UpdateRefittability(false);
01551         break;
01552 
01553       case 0x1A: // Long format introduction date (days since year 0)
01554         ei->base_intro = buf->ReadDWord();
01555         break;
01556 
01557       case 0x1B: // Alter purchase list sort order
01558         AlterVehicleListOrder(e->index, buf->ReadExtendedByte());
01559         break;
01560 
01561       case 0x1C: // Visual effect
01562         svi->visual_effect = buf->ReadByte();
01563         /* Avoid accidentally setting visual_effect to the default value
01564          * Since bit 6 (disable effects) is set anyways, we can safely erase some bits. */
01565         if (svi->visual_effect == VE_DEFAULT) {
01566           assert(HasBit(svi->visual_effect, VE_DISABLE_EFFECT));
01567           SB(svi->visual_effect, VE_TYPE_START, VE_TYPE_COUNT, 0);
01568         }
01569         break;
01570 
01571       case PROP_SHIP_CARGO_AGE_PERIOD: // 0x1D Cargo aging period
01572         ei->cargo_age_period = buf->ReadWord();
01573         break;
01574 
01575       case 0x1E:   // CTT refit include list
01576       case 0x1F: { // CTT refit exclude list
01577         uint8 count = buf->ReadByte();
01578         _gted[e->index].UpdateRefittability(prop == 0x1E && count != 0);
01579         if (prop == 0x1E) _gted[e->index].defaultcargo_grf = _cur.grffile;
01580         uint32 &ctt = prop == 0x1E ? _gted[e->index].ctt_include_mask : _gted[e->index].ctt_exclude_mask;
01581         ctt = 0;
01582         while (count--) {
01583           CargoID ctype = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
01584           if (ctype == CT_INVALID) continue;
01585           SetBit(ctt, ctype);
01586         }
01587         break;
01588       }
01589 
01590       default:
01591         ret = CommonVehicleChangeInfo(ei, prop, buf);
01592         break;
01593     }
01594   }
01595 
01596   return ret;
01597 }
01598 
01607 static ChangeInfoResult AircraftVehicleChangeInfo(uint engine, int numinfo, int prop, ByteReader *buf)
01608 {
01609   ChangeInfoResult ret = CIR_SUCCESS;
01610 
01611   for (int i = 0; i < numinfo; i++) {
01612     Engine *e = GetNewEngine(_cur.grffile, VEH_AIRCRAFT, engine + i);
01613     if (e == NULL) return CIR_INVALID_ID; // No engine could be allocated, so neither can any next vehicles
01614 
01615     EngineInfo *ei = &e->info;
01616     AircraftVehicleInfo *avi = &e->u.air;
01617 
01618     switch (prop) {
01619       case 0x08: { // Sprite ID
01620         uint8 spriteid = buf->ReadByte();
01621         uint8 orig_spriteid = spriteid;
01622 
01623         /* aircraft have different custom id in the GRF file */
01624         if (spriteid == 0xFF) spriteid = 0xFD;
01625 
01626         if (spriteid < 0xFD) spriteid >>= 1;
01627 
01628         if (IsValidNewGRFImageIndex<VEH_AIRCRAFT>(spriteid)) {
01629           avi->image_index = spriteid;
01630         } else {
01631           grfmsg(1, "AircraftVehicleChangeInfo: Invalid Sprite %d specified, ignoring", orig_spriteid);
01632           avi->image_index = 0;
01633         }
01634         break;
01635       }
01636 
01637       case 0x09: // Helicopter
01638         if (buf->ReadByte() == 0) {
01639           avi->subtype = AIR_HELI;
01640         } else {
01641           SB(avi->subtype, 0, 1, 1); // AIR_CTOL
01642         }
01643         break;
01644 
01645       case 0x0A: // Large
01646         SB(avi->subtype, 1, 1, (buf->ReadByte() != 0 ? 1 : 0)); // AIR_FAST
01647         break;
01648 
01649       case PROP_AIRCRAFT_COST_FACTOR: // 0x0B Cost factor
01650         avi->cost_factor = buf->ReadByte();
01651         break;
01652 
01653       case PROP_AIRCRAFT_SPEED: // 0x0C Speed (1 unit is 8 mph, we translate to 1 unit is 1 km-ish/h)
01654         avi->max_speed = (buf->ReadByte() * 128) / 10;
01655         break;
01656 
01657       case 0x0D: // Acceleration
01658         avi->acceleration = buf->ReadByte();
01659         break;
01660 
01661       case PROP_AIRCRAFT_RUNNING_COST_FACTOR: // 0x0E Running cost factor
01662         avi->running_cost = buf->ReadByte();
01663         break;
01664 
01665       case PROP_AIRCRAFT_PASSENGER_CAPACITY: // 0x0F Passenger capacity
01666         avi->passenger_capacity = buf->ReadWord();
01667         break;
01668 
01669       case PROP_AIRCRAFT_MAIL_CAPACITY: // 0x11 Mail capacity
01670         avi->mail_capacity = buf->ReadByte();
01671         break;
01672 
01673       case 0x12: // SFX
01674         avi->sfx = buf->ReadByte();
01675         break;
01676 
01677       case 0x13: { // Cargoes available for refitting
01678         uint32 mask = buf->ReadDWord();
01679         _gted[e->index].UpdateRefittability(mask != 0);
01680         ei->refit_mask = TranslateRefitMask(mask);
01681         _gted[e->index].defaultcargo_grf = _cur.grffile;
01682         break;
01683       }
01684 
01685       case 0x14: // Callback mask
01686         ei->callback_mask = buf->ReadByte();
01687         break;
01688 
01689       case 0x15: // Refit cost
01690         ei->refit_cost = buf->ReadByte();
01691         break;
01692 
01693       case 0x16: // Retire vehicle early
01694         ei->retire_early = buf->ReadByte();
01695         break;
01696 
01697       case 0x17: // Miscellaneous flags
01698         ei->misc_flags = buf->ReadByte();
01699         _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
01700         break;
01701 
01702       case 0x18: // Cargo classes allowed
01703         _gted[e->index].cargo_allowed = buf->ReadWord();
01704         _gted[e->index].UpdateRefittability(_gted[e->index].cargo_allowed != 0);
01705         _gted[e->index].defaultcargo_grf = _cur.grffile;
01706         break;
01707 
01708       case 0x19: // Cargo classes disallowed
01709         _gted[e->index].cargo_disallowed = buf->ReadWord();
01710         _gted[e->index].UpdateRefittability(false);
01711         break;
01712 
01713       case 0x1A: // Long format introduction date (days since year 0)
01714         ei->base_intro = buf->ReadDWord();
01715         break;
01716 
01717       case 0x1B: // Alter purchase list sort order
01718         AlterVehicleListOrder(e->index, buf->ReadExtendedByte());
01719         break;
01720 
01721       case PROP_AIRCRAFT_CARGO_AGE_PERIOD: // 0x1C Cargo aging period
01722         ei->cargo_age_period = buf->ReadWord();
01723         break;
01724 
01725       case 0x1D:   // CTT refit include list
01726       case 0x1E: { // CTT refit exclude list
01727         uint8 count = buf->ReadByte();
01728         _gted[e->index].UpdateRefittability(prop == 0x1D && count != 0);
01729         if (prop == 0x1D) _gted[e->index].defaultcargo_grf = _cur.grffile;
01730         uint32 &ctt = prop == 0x1D ? _gted[e->index].ctt_include_mask : _gted[e->index].ctt_exclude_mask;
01731         ctt = 0;
01732         while (count--) {
01733           CargoID ctype = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
01734           if (ctype == CT_INVALID) continue;
01735           SetBit(ctt, ctype);
01736         }
01737         break;
01738       }
01739 
01740       case PROP_AIRCRAFT_RANGE: // 0x1F Max aircraft range
01741         avi->max_range = buf->ReadWord();
01742         break;
01743 
01744       default:
01745         ret = CommonVehicleChangeInfo(ei, prop, buf);
01746         break;
01747     }
01748   }
01749 
01750   return ret;
01751 }
01752 
01761 static ChangeInfoResult StationChangeInfo(uint stid, int numinfo, int prop, ByteReader *buf)
01762 {
01763   ChangeInfoResult ret = CIR_SUCCESS;
01764 
01765   if (stid + numinfo > NUM_STATIONS_PER_GRF) {
01766     grfmsg(1, "StationChangeInfo: Station %u is invalid, max %u, ignoring", stid + numinfo, NUM_STATIONS_PER_GRF);
01767     return CIR_INVALID_ID;
01768   }
01769 
01770   /* Allocate station specs if necessary */
01771   if (_cur.grffile->stations == NULL) _cur.grffile->stations = CallocT<StationSpec*>(NUM_STATIONS_PER_GRF);
01772 
01773   for (int i = 0; i < numinfo; i++) {
01774     StationSpec *statspec = _cur.grffile->stations[stid + i];
01775 
01776     /* Check that the station we are modifying is defined. */
01777     if (statspec == NULL && prop != 0x08) {
01778       grfmsg(2, "StationChangeInfo: Attempt to modify undefined station %u, ignoring", stid + i);
01779       return CIR_INVALID_ID;
01780     }
01781 
01782     switch (prop) {
01783       case 0x08: { // Class ID
01784         StationSpec **spec = &_cur.grffile->stations[stid + i];
01785 
01786         /* Property 0x08 is special; it is where the station is allocated */
01787         if (*spec == NULL) *spec = CallocT<StationSpec>(1);
01788 
01789         /* Swap classid because we read it in BE meaning WAYP or DFLT */
01790         uint32 classid = buf->ReadDWord();
01791         (*spec)->cls_id = StationClass::Allocate(BSWAP32(classid));
01792         break;
01793       }
01794 
01795       case 0x09: // Define sprite layout
01796         statspec->tiles = buf->ReadExtendedByte();
01797         delete[] statspec->renderdata; // delete earlier loaded stuff
01798         statspec->renderdata = new NewGRFSpriteLayout[statspec->tiles];
01799 
01800         for (uint t = 0; t < statspec->tiles; t++) {
01801           NewGRFSpriteLayout *dts = &statspec->renderdata[t];
01802           dts->consistent_max_offset = UINT16_MAX; // Spritesets are unknown, so no limit.
01803 
01804           if (buf->HasData(4) && *(uint32*)buf->Data() == 0) {
01805             buf->Skip(4);
01806             extern const DrawTileSprites _station_display_datas_rail[8];
01807             dts->Clone(&_station_display_datas_rail[t % 8]);
01808             continue;
01809           }
01810 
01811           ReadSpriteLayoutSprite(buf, false, false, false, GSF_STATIONS, &dts->ground);
01812           /* On error, bail out immediately. Temporary GRF data was already freed */
01813           if (_cur.skip_sprites < 0) return CIR_DISABLED;
01814 
01815           static SmallVector<DrawTileSeqStruct, 8> tmp_layout;
01816           tmp_layout.Clear();
01817           for (;;) {
01818             /* no relative bounding box support */
01819             DrawTileSeqStruct *dtss = tmp_layout.Append();
01820             MemSetT(dtss, 0);
01821 
01822             dtss->delta_x = buf->ReadByte();
01823             if (dtss->IsTerminator()) break;
01824             dtss->delta_y = buf->ReadByte();
01825             dtss->delta_z = buf->ReadByte();
01826             dtss->size_x = buf->ReadByte();
01827             dtss->size_y = buf->ReadByte();
01828             dtss->size_z = buf->ReadByte();
01829 
01830             ReadSpriteLayoutSprite(buf, false, true, false, GSF_STATIONS, &dtss->image);
01831             /* On error, bail out immediately. Temporary GRF data was already freed */
01832             if (_cur.skip_sprites < 0) return CIR_DISABLED;
01833           }
01834           dts->Clone(tmp_layout.Begin());
01835         }
01836         break;
01837 
01838       case 0x0A: { // Copy sprite layout
01839         byte srcid = buf->ReadByte();
01840         const StationSpec *srcstatspec = _cur.grffile->stations[srcid];
01841 
01842         if (srcstatspec == NULL) {
01843           grfmsg(1, "StationChangeInfo: Station %u is not defined, cannot copy sprite layout to %u.", srcid, stid + i);
01844           continue;
01845         }
01846 
01847         delete[] statspec->renderdata; // delete earlier loaded stuff
01848 
01849         statspec->tiles = srcstatspec->tiles;
01850         statspec->renderdata = new NewGRFSpriteLayout[statspec->tiles];
01851         for (uint t = 0; t < statspec->tiles; t++) {
01852           statspec->renderdata[t].Clone(&srcstatspec->renderdata[t]);
01853         }
01854         break;
01855       }
01856 
01857       case 0x0B: // Callback mask
01858         statspec->callback_mask = buf->ReadByte();
01859         break;
01860 
01861       case 0x0C: // Disallowed number of platforms
01862         statspec->disallowed_platforms = buf->ReadByte();
01863         break;
01864 
01865       case 0x0D: // Disallowed platform lengths
01866         statspec->disallowed_lengths = buf->ReadByte();
01867         break;
01868 
01869       case 0x0E: // Define custom layout
01870         statspec->copied_layouts = false;
01871 
01872         while (buf->HasData()) {
01873           byte length = buf->ReadByte();
01874           byte number = buf->ReadByte();
01875           StationLayout layout;
01876           uint l, p;
01877 
01878           if (length == 0 || number == 0) break;
01879 
01880           if (length > statspec->lengths) {
01881             statspec->platforms = ReallocT(statspec->platforms, length);
01882             memset(statspec->platforms + statspec->lengths, 0, length - statspec->lengths);
01883 
01884             statspec->layouts = ReallocT(statspec->layouts, length);
01885             memset(statspec->layouts + statspec->lengths, 0,
01886                    (length - statspec->lengths) * sizeof(*statspec->layouts));
01887 
01888             statspec->lengths = length;
01889           }
01890           l = length - 1; // index is zero-based
01891 
01892           if (number > statspec->platforms[l]) {
01893             statspec->layouts[l] = ReallocT(statspec->layouts[l], number);
01894             /* We expect NULL being 0 here, but C99 guarantees that. */
01895             memset(statspec->layouts[l] + statspec->platforms[l], 0,
01896                    (number - statspec->platforms[l]) * sizeof(**statspec->layouts));
01897 
01898             statspec->platforms[l] = number;
01899           }
01900 
01901           p = 0;
01902           layout = MallocT<byte>(length * number);
01903           try {
01904             for (l = 0; l < length; l++) {
01905               for (p = 0; p < number; p++) {
01906                 layout[l * number + p] = buf->ReadByte();
01907               }
01908             }
01909           } catch (...) {
01910             free(layout);
01911             throw;
01912           }
01913 
01914           l--;
01915           p--;
01916           free(statspec->layouts[l][p]);
01917           statspec->layouts[l][p] = layout;
01918         }
01919         break;
01920 
01921       case 0x0F: { // Copy custom layout
01922         byte srcid = buf->ReadByte();
01923         const StationSpec *srcstatspec = _cur.grffile->stations[srcid];
01924 
01925         if (srcstatspec == NULL) {
01926           grfmsg(1, "StationChangeInfo: Station %u is not defined, cannot copy tile layout to %u.", srcid, stid + i);
01927           continue;
01928         }
01929 
01930         statspec->lengths   = srcstatspec->lengths;
01931         statspec->platforms = srcstatspec->platforms;
01932         statspec->layouts   = srcstatspec->layouts;
01933         statspec->copied_layouts = true;
01934         break;
01935       }
01936 
01937       case 0x10: // Little/lots cargo threshold
01938         statspec->cargo_threshold = buf->ReadWord();
01939         break;
01940 
01941       case 0x11: // Pylon placement
01942         statspec->pylons = buf->ReadByte();
01943         break;
01944 
01945       case 0x12: // Cargo types for random triggers
01946         statspec->cargo_triggers = buf->ReadDWord();
01947         if (_cur.grffile->grf_version >= 7) {
01948           statspec->cargo_triggers = TranslateRefitMask(statspec->cargo_triggers);
01949         }
01950         break;
01951 
01952       case 0x13: // General flags
01953         statspec->flags = buf->ReadByte();
01954         break;
01955 
01956       case 0x14: // Overhead wire placement
01957         statspec->wires = buf->ReadByte();
01958         break;
01959 
01960       case 0x15: // Blocked tiles
01961         statspec->blocked = buf->ReadByte();
01962         break;
01963 
01964       case 0x16: // Animation info
01965         statspec->animation.frames = buf->ReadByte();
01966         statspec->animation.status = buf->ReadByte();
01967         break;
01968 
01969       case 0x17: // Animation speed
01970         statspec->animation.speed = buf->ReadByte();
01971         break;
01972 
01973       case 0x18: // Animation triggers
01974         statspec->animation.triggers = buf->ReadWord();
01975         break;
01976 
01977       case 0x1A: // Advanced sprite layout
01978         statspec->tiles = buf->ReadExtendedByte();
01979         delete[] statspec->renderdata; // delete earlier loaded stuff
01980         statspec->renderdata = new NewGRFSpriteLayout[statspec->tiles];
01981 
01982         for (uint t = 0; t < statspec->tiles; t++) {
01983           NewGRFSpriteLayout *dts = &statspec->renderdata[t];
01984           uint num_building_sprites = buf->ReadByte();
01985           /* On error, bail out immediately. Temporary GRF data was already freed */
01986           if (ReadSpriteLayout(buf, num_building_sprites, false, GSF_STATIONS, true, false, dts)) return CIR_DISABLED;
01987         }
01988         break;
01989 
01990       default:
01991         ret = CIR_UNKNOWN;
01992         break;
01993     }
01994   }
01995 
01996   return ret;
01997 }
01998 
02007 static ChangeInfoResult CanalChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
02008 {
02009   ChangeInfoResult ret = CIR_SUCCESS;
02010 
02011   if (id + numinfo > CF_END) {
02012     grfmsg(1, "CanalChangeInfo: Canal feature %u is invalid, max %u, ignoring", id + numinfo, CF_END);
02013     return CIR_INVALID_ID;
02014   }
02015 
02016   for (int i = 0; i < numinfo; i++) {
02017     CanalProperties *cp = &_cur.grffile->canal_local_properties[id + i];
02018 
02019     switch (prop) {
02020       case 0x08:
02021         cp->callback_mask = buf->ReadByte();
02022         break;
02023 
02024       case 0x09:
02025         cp->flags = buf->ReadByte();
02026         break;
02027 
02028       default:
02029         ret = CIR_UNKNOWN;
02030         break;
02031     }
02032   }
02033 
02034   return ret;
02035 }
02036 
02045 static ChangeInfoResult BridgeChangeInfo(uint brid, int numinfo, int prop, ByteReader *buf)
02046 {
02047   ChangeInfoResult ret = CIR_SUCCESS;
02048 
02049   if (brid + numinfo > MAX_BRIDGES) {
02050     grfmsg(1, "BridgeChangeInfo: Bridge %u is invalid, max %u, ignoring", brid + numinfo, MAX_BRIDGES);
02051     return CIR_INVALID_ID;
02052   }
02053 
02054   for (int i = 0; i < numinfo; i++) {
02055     BridgeSpec *bridge = &_bridge[brid + i];
02056 
02057     switch (prop) {
02058       case 0x08: { // Year of availability
02059         /* We treat '0' as always available */
02060         byte year = buf->ReadByte();
02061         bridge->avail_year = (year > 0 ? ORIGINAL_BASE_YEAR + year : 0);
02062         break;
02063       }
02064 
02065       case 0x09: // Minimum length
02066         bridge->min_length = buf->ReadByte();
02067         break;
02068 
02069       case 0x0A: // Maximum length
02070         bridge->max_length = buf->ReadByte();
02071         if (bridge->max_length > 16) bridge->max_length = 0xFFFF;
02072         break;
02073 
02074       case 0x0B: // Cost factor
02075         bridge->price = buf->ReadByte();
02076         break;
02077 
02078       case 0x0C: // Maximum speed
02079         bridge->speed = buf->ReadWord();
02080         break;
02081 
02082       case 0x0D: { // Bridge sprite tables
02083         byte tableid = buf->ReadByte();
02084         byte numtables = buf->ReadByte();
02085 
02086         if (bridge->sprite_table == NULL) {
02087           /* Allocate memory for sprite table pointers and zero out */
02088           bridge->sprite_table = CallocT<PalSpriteID*>(7);
02089         }
02090 
02091         for (; numtables-- != 0; tableid++) {
02092           if (tableid >= 7) { // skip invalid data
02093             grfmsg(1, "BridgeChangeInfo: Table %d >= 7, skipping", tableid);
02094             for (byte sprite = 0; sprite < 32; sprite++) buf->ReadDWord();
02095             continue;
02096           }
02097 
02098           if (bridge->sprite_table[tableid] == NULL) {
02099             bridge->sprite_table[tableid] = MallocT<PalSpriteID>(32);
02100           }
02101 
02102           for (byte sprite = 0; sprite < 32; sprite++) {
02103             SpriteID image = buf->ReadWord();
02104             PaletteID pal  = buf->ReadWord();
02105 
02106             bridge->sprite_table[tableid][sprite].sprite = image;
02107             bridge->sprite_table[tableid][sprite].pal    = pal;
02108 
02109             MapSpriteMappingRecolour(&bridge->sprite_table[tableid][sprite]);
02110           }
02111         }
02112         break;
02113       }
02114 
02115       case 0x0E: // Flags; bit 0 - disable far pillars
02116         bridge->flags = buf->ReadByte();
02117         break;
02118 
02119       case 0x0F: // Long format year of availability (year since year 0)
02120         bridge->avail_year = Clamp(buf->ReadDWord(), MIN_YEAR, MAX_YEAR);
02121         break;
02122 
02123       case 0x10: { // purchase string
02124         StringID newone = GetGRFStringID(_cur.grffile->grfid, buf->ReadWord());
02125         if (newone != STR_UNDEFINED) bridge->material = newone;
02126         break;
02127       }
02128 
02129       case 0x11: // description of bridge with rails or roads
02130       case 0x12: {
02131         StringID newone = GetGRFStringID(_cur.grffile->grfid, buf->ReadWord());
02132         if (newone != STR_UNDEFINED) bridge->transport_name[prop - 0x11] = newone;
02133         break;
02134       }
02135 
02136       case 0x13: // 16 bits cost multiplier
02137         bridge->price = buf->ReadWord();
02138         break;
02139 
02140       default:
02141         ret = CIR_UNKNOWN;
02142         break;
02143     }
02144   }
02145 
02146   return ret;
02147 }
02148 
02155 static ChangeInfoResult IgnoreTownHouseProperty(int prop, ByteReader *buf)
02156 {
02157   ChangeInfoResult ret = CIR_SUCCESS;
02158 
02159   switch (prop) {
02160     case 0x09:
02161     case 0x0B:
02162     case 0x0C:
02163     case 0x0D:
02164     case 0x0E:
02165     case 0x0F:
02166     case 0x11:
02167     case 0x14:
02168     case 0x15:
02169     case 0x16:
02170     case 0x18:
02171     case 0x19:
02172     case 0x1A:
02173     case 0x1B:
02174     case 0x1C:
02175     case 0x1D:
02176     case 0x1F:
02177       buf->ReadByte();
02178       break;
02179 
02180     case 0x0A:
02181     case 0x10:
02182     case 0x12:
02183     case 0x13:
02184     case 0x21:
02185     case 0x22:
02186       buf->ReadWord();
02187       break;
02188 
02189     case 0x1E:
02190       buf->ReadDWord();
02191       break;
02192 
02193     case 0x17:
02194       for (uint j = 0; j < 4; j++) buf->ReadByte();
02195       break;
02196 
02197     case 0x20: {
02198       byte count = buf->ReadByte();
02199       for (byte j = 0; j < count; j++) buf->ReadByte();
02200       break;
02201     }
02202 
02203     default:
02204       ret = CIR_UNKNOWN;
02205       break;
02206   }
02207   return ret;
02208 }
02209 
02218 static ChangeInfoResult TownHouseChangeInfo(uint hid, int numinfo, int prop, ByteReader *buf)
02219 {
02220   ChangeInfoResult ret = CIR_SUCCESS;
02221 
02222   if (hid + numinfo > NUM_HOUSES_PER_GRF) {
02223     grfmsg(1, "TownHouseChangeInfo: Too many houses loaded (%u), max (%u). Ignoring.", hid + numinfo, NUM_HOUSES_PER_GRF);
02224     return CIR_INVALID_ID;
02225   }
02226 
02227   /* Allocate house specs if they haven't been allocated already. */
02228   if (_cur.grffile->housespec == NULL) {
02229     _cur.grffile->housespec = CallocT<HouseSpec*>(NUM_HOUSES_PER_GRF);
02230   }
02231 
02232   for (int i = 0; i < numinfo; i++) {
02233     HouseSpec *housespec = _cur.grffile->housespec[hid + i];
02234 
02235     if (prop != 0x08 && housespec == NULL) {
02236       /* If the house property 08 is not yet set, ignore this property */
02237       ChangeInfoResult cir = IgnoreTownHouseProperty(prop, buf);
02238       if (cir > ret) ret = cir;
02239       continue;
02240     }
02241 
02242     switch (prop) {
02243       case 0x08: { // Substitute building type, and definition of a new house
02244         HouseSpec **house = &_cur.grffile->housespec[hid + i];
02245         byte subs_id = buf->ReadByte();
02246 
02247         if (subs_id == 0xFF) {
02248           /* Instead of defining a new house, a substitute house id
02249            * of 0xFF disables the old house with the current id. */
02250           HouseSpec::Get(hid + i)->enabled = false;
02251           continue;
02252         } else if (subs_id >= NEW_HOUSE_OFFSET) {
02253           /* The substitute id must be one of the original houses. */
02254           grfmsg(2, "TownHouseChangeInfo: Attempt to use new house %u as substitute house for %u. Ignoring.", subs_id, hid + i);
02255           continue;
02256         }
02257 
02258         /* Allocate space for this house. */
02259         if (*house == NULL) *house = CallocT<HouseSpec>(1);
02260 
02261         housespec = *house;
02262 
02263         MemCpyT(housespec, HouseSpec::Get(subs_id));
02264 
02265         housespec->enabled = true;
02266         housespec->grf_prop.local_id = hid + i;
02267         housespec->grf_prop.subst_id = subs_id;
02268         housespec->grf_prop.grffile = _cur.grffile;
02269         housespec->random_colour[0] = 0x04;  // those 4 random colours are the base colour
02270         housespec->random_colour[1] = 0x08;  // for all new houses
02271         housespec->random_colour[2] = 0x0C;  // they stand for red, blue, orange and green
02272         housespec->random_colour[3] = 0x06;
02273 
02274         /* Make sure that the third cargo type is valid in this
02275          * climate. This can cause problems when copying the properties
02276          * of a house that accepts food, where the new house is valid
02277          * in the temperate climate. */
02278         if (!CargoSpec::Get(housespec->accepts_cargo[2])->IsValid()) {
02279           housespec->cargo_acceptance[2] = 0;
02280         }
02281 
02282         _loaded_newgrf_features.has_newhouses = true;
02283         break;
02284       }
02285 
02286       case 0x09: // Building flags
02287         housespec->building_flags = (BuildingFlags)buf->ReadByte();
02288         break;
02289 
02290       case 0x0A: { // Availability years
02291         uint16 years = buf->ReadWord();
02292         housespec->min_year = GB(years, 0, 8) > 150 ? MAX_YEAR : ORIGINAL_BASE_YEAR + GB(years, 0, 8);
02293         housespec->max_year = GB(years, 8, 8) > 150 ? MAX_YEAR : ORIGINAL_BASE_YEAR + GB(years, 8, 8);
02294         break;
02295       }
02296 
02297       case 0x0B: // Population
02298         housespec->population = buf->ReadByte();
02299         break;
02300 
02301       case 0x0C: // Mail generation multiplier
02302         housespec->mail_generation = buf->ReadByte();
02303         break;
02304 
02305       case 0x0D: // Passenger acceptance
02306       case 0x0E: // Mail acceptance
02307         housespec->cargo_acceptance[prop - 0x0D] = buf->ReadByte();
02308         break;
02309 
02310       case 0x0F: { // Goods/candy, food/fizzy drinks acceptance
02311         int8 goods = buf->ReadByte();
02312 
02313         /* If value of goods is negative, it means in fact food or, if in toyland, fizzy_drink acceptance.
02314          * Else, we have "standard" 3rd cargo type, goods or candy, for toyland once more */
02315         CargoID cid = (goods >= 0) ? ((_settings_game.game_creation.landscape == LT_TOYLAND) ? CT_CANDY : CT_GOODS) :
02316             ((_settings_game.game_creation.landscape == LT_TOYLAND) ? CT_FIZZY_DRINKS : CT_FOOD);
02317 
02318         /* Make sure the cargo type is valid in this climate. */
02319         if (!CargoSpec::Get(cid)->IsValid()) goods = 0;
02320 
02321         housespec->accepts_cargo[2] = cid;
02322         housespec->cargo_acceptance[2] = abs(goods); // but we do need positive value here
02323         break;
02324       }
02325 
02326       case 0x10: // Local authority rating decrease on removal
02327         housespec->remove_rating_decrease = buf->ReadWord();
02328         break;
02329 
02330       case 0x11: // Removal cost multiplier
02331         housespec->removal_cost = buf->ReadByte();
02332         break;
02333 
02334       case 0x12: // Building name ID
02335         housespec->building_name = buf->ReadWord();
02336         _string_to_grf_mapping[&housespec->building_name] = _cur.grffile->grfid;
02337         break;
02338 
02339       case 0x13: // Building availability mask
02340         housespec->building_availability = (HouseZones)buf->ReadWord();
02341         break;
02342 
02343       case 0x14: // House callback mask
02344         housespec->callback_mask |= buf->ReadByte();
02345         break;
02346 
02347       case 0x15: { // House override byte
02348         byte override = buf->ReadByte();
02349 
02350         /* The house being overridden must be an original house. */
02351         if (override >= NEW_HOUSE_OFFSET) {
02352           grfmsg(2, "TownHouseChangeInfo: Attempt to override new house %u with house id %u. Ignoring.", override, hid + i);
02353           continue;
02354         }
02355 
02356         _house_mngr.Add(hid + i, _cur.grffile->grfid, override);
02357         break;
02358       }
02359 
02360       case 0x16: // Periodic refresh multiplier
02361         housespec->processing_time = min(buf->ReadByte(), 63);
02362         break;
02363 
02364       case 0x17: // Four random colours to use
02365         for (uint j = 0; j < 4; j++) housespec->random_colour[j] = buf->ReadByte();
02366         break;
02367 
02368       case 0x18: // Relative probability of appearing
02369         housespec->probability = buf->ReadByte();
02370         break;
02371 
02372       case 0x19: // Extra flags
02373         housespec->extra_flags = (HouseExtraFlags)buf->ReadByte();
02374         break;
02375 
02376       case 0x1A: // Animation frames
02377         housespec->animation.frames = buf->ReadByte();
02378         housespec->animation.status = GB(housespec->animation.frames, 7, 1);
02379         SB(housespec->animation.frames, 7, 1, 0);
02380         break;
02381 
02382       case 0x1B: // Animation speed
02383         housespec->animation.speed = Clamp(buf->ReadByte(), 2, 16);
02384         break;
02385 
02386       case 0x1C: // Class of the building type
02387         housespec->class_id = AllocateHouseClassID(buf->ReadByte(), _cur.grffile->grfid);
02388         break;
02389 
02390       case 0x1D: // Callback mask part 2
02391         housespec->callback_mask |= (buf->ReadByte() << 8);
02392         break;
02393 
02394       case 0x1E: { // Accepted cargo types
02395         uint32 cargotypes = buf->ReadDWord();
02396 
02397         /* Check if the cargo types should not be changed */
02398         if (cargotypes == 0xFFFFFFFF) break;
02399 
02400         for (uint j = 0; j < 3; j++) {
02401           /* Get the cargo number from the 'list' */
02402           uint8 cargo_part = GB(cargotypes, 8 * j, 8);
02403           CargoID cargo = GetCargoTranslation(cargo_part, _cur.grffile);
02404 
02405           if (cargo == CT_INVALID) {
02406             /* Disable acceptance of invalid cargo type */
02407             housespec->cargo_acceptance[j] = 0;
02408           } else {
02409             housespec->accepts_cargo[j] = cargo;
02410           }
02411         }
02412         break;
02413       }
02414 
02415       case 0x1F: // Minimum life span
02416         housespec->minimum_life = buf->ReadByte();
02417         break;
02418 
02419       case 0x20: { // Cargo acceptance watch list
02420         byte count = buf->ReadByte();
02421         for (byte j = 0; j < count; j++) {
02422           CargoID cargo = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
02423           if (cargo != CT_INVALID) SetBit(housespec->watched_cargoes, cargo);
02424         }
02425         break;
02426       }
02427 
02428       case 0x21: // long introduction year
02429         housespec->min_year = buf->ReadWord();
02430         break;
02431 
02432       case 0x22: // long maximum year
02433         housespec->max_year = buf->ReadWord();
02434         break;
02435 
02436       default:
02437         ret = CIR_UNKNOWN;
02438         break;
02439     }
02440   }
02441 
02442   return ret;
02443 }
02444 
02451 /* static */ const LanguageMap *LanguageMap::GetLanguageMap(uint32 grfid, uint8 language_id)
02452 {
02453   /* LanguageID "MAX_LANG", i.e. 7F is any. This language can't have a gender/case mapping, but has to be handled gracefully. */
02454   const GRFFile *grffile = GetFileByGRFID(grfid);
02455   return (grffile != NULL && grffile->language_map != NULL && language_id < MAX_LANG) ? &grffile->language_map[language_id] : NULL;
02456 }
02457 
02467 template <typename T>
02468 static ChangeInfoResult LoadTranslationTable(uint gvid, int numinfo, ByteReader *buf, T &translation_table, const char *name)
02469 {
02470   if (gvid != 0) {
02471     grfmsg(1, "LoadTranslationTable: %s translation table must start at zero", name);
02472     return CIR_INVALID_ID;
02473   }
02474 
02475   translation_table.Clear();
02476   for (int i = 0; i < numinfo; i++) {
02477     uint32 item = buf->ReadDWord();
02478     *translation_table.Append() = BSWAP32(item);
02479   }
02480 
02481   return CIR_SUCCESS;
02482 }
02483 
02492 static ChangeInfoResult GlobalVarChangeInfo(uint gvid, int numinfo, int prop, ByteReader *buf)
02493 {
02494   /* Properties which are handled as a whole */
02495   switch (prop) {
02496     case 0x09: // Cargo Translation Table; loading during both reservation and activation stage (in case it is selected depending on defined cargos)
02497       return LoadTranslationTable(gvid, numinfo, buf, _cur.grffile->cargo_list, "Cargo");
02498 
02499     case 0x12: // Rail type translation table; loading during both reservation and activation stage (in case it is selected depending on defined railtypes)
02500       return LoadTranslationTable(gvid, numinfo, buf, _cur.grffile->railtype_list, "Rail type");
02501 
02502     default:
02503       break;
02504   }
02505 
02506   /* Properties which are handled per item */
02507   ChangeInfoResult ret = CIR_SUCCESS;
02508   for (int i = 0; i < numinfo; i++) {
02509     switch (prop) {
02510       case 0x08: { // Cost base factor
02511         int factor = buf->ReadByte();
02512         uint price = gvid + i;
02513 
02514         if (price < PR_END) {
02515           _cur.grffile->price_base_multipliers[price] = min<int>(factor - 8, MAX_PRICE_MODIFIER);
02516         } else {
02517           grfmsg(1, "GlobalVarChangeInfo: Price %d out of range, ignoring", price);
02518         }
02519         break;
02520       }
02521 
02522       case 0x0A: { // Currency display names
02523         uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
02524         StringID newone = GetGRFStringID(_cur.grffile->grfid, buf->ReadWord());
02525 
02526         if ((newone != STR_UNDEFINED) && (curidx < CURRENCY_END)) {
02527           _currency_specs[curidx].name = newone;
02528         }
02529         break;
02530       }
02531 
02532       case 0x0B: { // Currency multipliers
02533         uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
02534         uint32 rate = buf->ReadDWord();
02535 
02536         if (curidx < CURRENCY_END) {
02537           /* TTDPatch uses a multiple of 1000 for its conversion calculations,
02538            * which OTTD does not. For this reason, divide grf value by 1000,
02539            * to be compatible */
02540           _currency_specs[curidx].rate = rate / 1000;
02541         } else {
02542           grfmsg(1, "GlobalVarChangeInfo: Currency multipliers %d out of range, ignoring", curidx);
02543         }
02544         break;
02545       }
02546 
02547       case 0x0C: { // Currency options
02548         uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
02549         uint16 options = buf->ReadWord();
02550 
02551         if (curidx < CURRENCY_END) {
02552           _currency_specs[curidx].separator[0] = GB(options, 0, 8);
02553           _currency_specs[curidx].separator[1] = '\0';
02554           /* By specifying only one bit, we prevent errors,
02555            * since newgrf specs said that only 0 and 1 can be set for symbol_pos */
02556           _currency_specs[curidx].symbol_pos = GB(options, 8, 1);
02557         } else {
02558           grfmsg(1, "GlobalVarChangeInfo: Currency option %d out of range, ignoring", curidx);
02559         }
02560         break;
02561       }
02562 
02563       case 0x0D: { // Currency prefix symbol
02564         uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
02565         uint32 tempfix = buf->ReadDWord();
02566 
02567         if (curidx < CURRENCY_END) {
02568           memcpy(_currency_specs[curidx].prefix, &tempfix, 4);
02569           _currency_specs[curidx].prefix[4] = 0;
02570         } else {
02571           grfmsg(1, "GlobalVarChangeInfo: Currency symbol %d out of range, ignoring", curidx);
02572         }
02573         break;
02574       }
02575 
02576       case 0x0E: { // Currency suffix symbol
02577         uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
02578         uint32 tempfix = buf->ReadDWord();
02579 
02580         if (curidx < CURRENCY_END) {
02581           memcpy(&_currency_specs[curidx].suffix, &tempfix, 4);
02582           _currency_specs[curidx].suffix[4] = 0;
02583         } else {
02584           grfmsg(1, "GlobalVarChangeInfo: Currency symbol %d out of range, ignoring", curidx);
02585         }
02586         break;
02587       }
02588 
02589       case 0x0F: { //  Euro introduction dates
02590         uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
02591         Year year_euro = buf->ReadWord();
02592 
02593         if (curidx < CURRENCY_END) {
02594           _currency_specs[curidx].to_euro = year_euro;
02595         } else {
02596           grfmsg(1, "GlobalVarChangeInfo: Euro intro date %d out of range, ignoring", curidx);
02597         }
02598         break;
02599       }
02600 
02601       case 0x10: // Snow line height table
02602         if (numinfo > 1 || IsSnowLineSet()) {
02603           grfmsg(1, "GlobalVarChangeInfo: The snowline can only be set once (%d)", numinfo);
02604         } else if (buf->Remaining() < SNOW_LINE_MONTHS * SNOW_LINE_DAYS) {
02605           grfmsg(1, "GlobalVarChangeInfo: Not enough entries set in the snowline table (" PRINTF_SIZE ")", buf->Remaining());
02606         } else {
02607           byte table[SNOW_LINE_MONTHS][SNOW_LINE_DAYS];
02608 
02609           for (uint i = 0; i < SNOW_LINE_MONTHS; i++) {
02610             for (uint j = 0; j < SNOW_LINE_DAYS; j++) {
02611               table[i][j] = buf->ReadByte();
02612               if (_cur.grffile->grf_version >= 8) {
02613                 if (table[i][j] != 0xFF) table[i][j] = table[i][j] * (1 + MAX_TILE_HEIGHT) / 256;
02614               } else {
02615                 if (table[i][j] >= 128) {
02616                   /* no snow */
02617                   table[i][j] = 0xFF;
02618                 } else {
02619                   table[i][j] = table[i][j] * (1 + MAX_TILE_HEIGHT) / 128;
02620                 }
02621               }
02622             }
02623           }
02624           SetSnowLine(table);
02625         }
02626         break;
02627 
02628       case 0x11: // GRF match for engine allocation
02629         /* This is loaded during the reservation stage, so just skip it here. */
02630         /* Each entry is 8 bytes. */
02631         buf->Skip(8);
02632         break;
02633 
02634       case 0x13:   // Gender translation table
02635       case 0x14:   // Case translation table
02636       case 0x15: { // Plural form translation
02637         uint curidx = gvid + i; // The current index, i.e. language.
02638         const LanguageMetadata *lang = curidx < MAX_LANG ? GetLanguage(curidx) : NULL;
02639         if (lang == NULL) {
02640           grfmsg(1, "GlobalVarChangeInfo: Language %d is not known, ignoring", curidx);
02641           /* Skip over the data. */
02642           if (prop == 0x15) {
02643             buf->ReadByte();
02644           } else {
02645             while (buf->ReadByte() != 0) {
02646               buf->ReadString();
02647             }
02648           }
02649           break;
02650         }
02651 
02652         if (_cur.grffile->language_map == NULL) _cur.grffile->language_map = new LanguageMap[MAX_LANG];
02653 
02654         if (prop == 0x15) {
02655           uint plural_form = buf->ReadByte();
02656           if (plural_form >= LANGUAGE_MAX_PLURAL) {
02657             grfmsg(1, "GlobalVarChanceInfo: Plural form %d is out of range, ignoring", plural_form);
02658           } else {
02659             _cur.grffile->language_map[curidx].plural_form = plural_form;
02660           }
02661           break;
02662         }
02663 
02664         byte newgrf_id = buf->ReadByte(); // The NewGRF (custom) identifier.
02665         while (newgrf_id != 0) {
02666           const char *name = buf->ReadString(); // The name for the OpenTTD identifier.
02667 
02668           /* We'll just ignore the UTF8 identifier character. This is (fairly)
02669            * safe as OpenTTD's strings gender/cases are usually in ASCII which
02670            * is just a subset of UTF8, or they need the bigger UTF8 characters
02671            * such as Cyrillic. Thus we will simply assume they're all UTF8. */
02672           WChar c;
02673           size_t len = Utf8Decode(&c, name);
02674           if (c == NFO_UTF8_IDENTIFIER) name += len;
02675 
02676           LanguageMap::Mapping map;
02677           map.newgrf_id = newgrf_id;
02678           if (prop == 0x13) {
02679             map.openttd_id = lang->GetGenderIndex(name);
02680             if (map.openttd_id >= MAX_NUM_GENDERS) {
02681               grfmsg(1, "GlobalVarChangeInfo: Gender name %s is not known, ignoring", name);
02682             } else {
02683               *_cur.grffile->language_map[curidx].gender_map.Append() = map;
02684             }
02685           } else {
02686             map.openttd_id = lang->GetCaseIndex(name);
02687             if (map.openttd_id >= MAX_NUM_CASES) {
02688               grfmsg(1, "GlobalVarChangeInfo: Case name %s is not known, ignoring", name);
02689             } else {
02690               *_cur.grffile->language_map[curidx].case_map.Append() = map;
02691             }
02692           }
02693           newgrf_id = buf->ReadByte();
02694         }
02695         break;
02696       }
02697 
02698       default:
02699         ret = CIR_UNKNOWN;
02700         break;
02701     }
02702   }
02703 
02704   return ret;
02705 }
02706 
02707 static ChangeInfoResult GlobalVarReserveInfo(uint gvid, int numinfo, int prop, ByteReader *buf)
02708 {
02709   /* Properties which are handled as a whole */
02710   switch (prop) {
02711     case 0x09: // Cargo Translation Table; loading during both reservation and activation stage (in case it is selected depending on defined cargos)
02712       return LoadTranslationTable(gvid, numinfo, buf, _cur.grffile->cargo_list, "Cargo");
02713 
02714     case 0x12: // Rail type translation table; loading during both reservation and activation stage (in case it is selected depending on defined railtypes)
02715       return LoadTranslationTable(gvid, numinfo, buf, _cur.grffile->railtype_list, "Rail type");
02716 
02717     default:
02718       break;
02719   }
02720 
02721   /* Properties which are handled per item */
02722   ChangeInfoResult ret = CIR_SUCCESS;
02723   for (int i = 0; i < numinfo; i++) {
02724     switch (prop) {
02725       case 0x08: // Cost base factor
02726       case 0x15: // Plural form translation
02727         buf->ReadByte();
02728         break;
02729 
02730       case 0x0A: // Currency display names
02731       case 0x0C: // Currency options
02732       case 0x0F: // Euro introduction dates
02733         buf->ReadWord();
02734         break;
02735 
02736       case 0x0B: // Currency multipliers
02737       case 0x0D: // Currency prefix symbol
02738       case 0x0E: // Currency suffix symbol
02739         buf->ReadDWord();
02740         break;
02741 
02742       case 0x10: // Snow line height table
02743         buf->Skip(SNOW_LINE_MONTHS * SNOW_LINE_DAYS);
02744         break;
02745 
02746       case 0x11: { // GRF match for engine allocation
02747         uint32 s = buf->ReadDWord();
02748         uint32 t = buf->ReadDWord();
02749         SetNewGRFOverride(s, t);
02750         break;
02751       }
02752 
02753       case 0x13: // Gender translation table
02754       case 0x14: // Case translation table
02755         while (buf->ReadByte() != 0) {
02756           buf->ReadString();
02757         }
02758         break;
02759 
02760       default:
02761         ret = CIR_UNKNOWN;
02762         break;
02763     }
02764   }
02765 
02766   return ret;
02767 }
02768 
02769 
02778 static ChangeInfoResult CargoChangeInfo(uint cid, int numinfo, int prop, ByteReader *buf)
02779 {
02780   ChangeInfoResult ret = CIR_SUCCESS;
02781 
02782   if (cid + numinfo > NUM_CARGO) {
02783     grfmsg(2, "CargoChangeInfo: Cargo type %d out of range (max %d)", cid + numinfo, NUM_CARGO - 1);
02784     return CIR_INVALID_ID;
02785   }
02786 
02787   for (int i = 0; i < numinfo; i++) {
02788     CargoSpec *cs = CargoSpec::Get(cid + i);
02789 
02790     switch (prop) {
02791       case 0x08: // Bit number of cargo
02792         cs->bitnum = buf->ReadByte();
02793         if (cs->IsValid()) {
02794           cs->grffile = _cur.grffile;
02795           SetBit(_cargo_mask, cid + i);
02796         } else {
02797           ClrBit(_cargo_mask, cid + i);
02798         }
02799         break;
02800 
02801       case 0x09: // String ID for cargo type name
02802         cs->name = buf->ReadWord();
02803         _string_to_grf_mapping[&cs->name] = _cur.grffile->grfid;
02804         break;
02805 
02806       case 0x0A: // String for 1 unit of cargo
02807         cs->name_single = buf->ReadWord();
02808         _string_to_grf_mapping[&cs->name_single] = _cur.grffile->grfid;
02809         break;
02810 
02811       case 0x0B: // String for singular quantity of cargo (e.g. 1 tonne of coal)
02812       case 0x1B: // String for cargo units
02813         /* String for units of cargo. This is different in OpenTTD
02814          * (e.g. tonnes) to TTDPatch (e.g. {COMMA} tonne of coal).
02815          * Property 1B is used to set OpenTTD's behaviour. */
02816         cs->units_volume = buf->ReadWord();
02817         _string_to_grf_mapping[&cs->units_volume] = _cur.grffile->grfid;
02818         break;
02819 
02820       case 0x0C: // String for plural quantity of cargo (e.g. 10 tonnes of coal)
02821       case 0x1C: // String for any amount of cargo
02822         /* Strings for an amount of cargo. This is different in OpenTTD
02823          * (e.g. {WEIGHT} of coal) to TTDPatch (e.g. {COMMA} tonnes of coal).
02824          * Property 1C is used to set OpenTTD's behaviour. */
02825         cs->quantifier = buf->ReadWord();
02826         _string_to_grf_mapping[&cs->quantifier] = _cur.grffile->grfid;
02827         break;
02828 
02829       case 0x0D: // String for two letter cargo abbreviation
02830         cs->abbrev = buf->ReadWord();
02831         _string_to_grf_mapping[&cs->abbrev] = _cur.grffile->grfid;
02832         break;
02833 
02834       case 0x0E: // Sprite ID for cargo icon
02835         cs->sprite = buf->ReadWord();
02836         break;
02837 
02838       case 0x0F: // Weight of one unit of cargo
02839         cs->weight = buf->ReadByte();
02840         break;
02841 
02842       case 0x10: // Used for payment calculation
02843         cs->transit_days[0] = buf->ReadByte();
02844         break;
02845 
02846       case 0x11: // Used for payment calculation
02847         cs->transit_days[1] = buf->ReadByte();
02848         break;
02849 
02850       case 0x12: // Base cargo price
02851         cs->initial_payment = buf->ReadDWord();
02852         break;
02853 
02854       case 0x13: // Colour for station rating bars
02855         cs->rating_colour = buf->ReadByte();
02856         break;
02857 
02858       case 0x14: // Colour for cargo graph
02859         cs->legend_colour = buf->ReadByte();
02860         break;
02861 
02862       case 0x15: // Freight status
02863         cs->is_freight = (buf->ReadByte() != 0);
02864         break;
02865 
02866       case 0x16: // Cargo classes
02867         cs->classes = buf->ReadWord();
02868         break;
02869 
02870       case 0x17: // Cargo label
02871         cs->label = buf->ReadDWord();
02872         cs->label = BSWAP32(cs->label);
02873         break;
02874 
02875       case 0x18: { // Town growth substitute type
02876         uint8 substitute_type = buf->ReadByte();
02877 
02878         switch (substitute_type) {
02879           case 0x00: cs->town_effect = TE_PASSENGERS; break;
02880           case 0x02: cs->town_effect = TE_MAIL; break;
02881           case 0x05: cs->town_effect = TE_GOODS; break;
02882           case 0x09: cs->town_effect = TE_WATER; break;
02883           case 0x0B: cs->town_effect = TE_FOOD; break;
02884           default:
02885             grfmsg(1, "CargoChangeInfo: Unknown town growth substitute value %d, setting to none.", substitute_type);
02886             /* FALL THROUGH */
02887           case 0xFF: cs->town_effect = TE_NONE; break;
02888         }
02889         break;
02890       }
02891 
02892       case 0x19: // Town growth coefficient
02893         cs->multipliertowngrowth = buf->ReadWord();
02894         break;
02895 
02896       case 0x1A: // Bitmask of callbacks to use
02897         cs->callback_mask = buf->ReadByte();
02898         break;
02899 
02900       case 0x1D: // Vehicle capacity muliplier
02901         cs->multiplier = max<uint16>(1u, buf->ReadWord());
02902         break;
02903 
02904       default:
02905         ret = CIR_UNKNOWN;
02906         break;
02907     }
02908   }
02909 
02910   return ret;
02911 }
02912 
02913 
02922 static ChangeInfoResult SoundEffectChangeInfo(uint sid, int numinfo, int prop, ByteReader *buf)
02923 {
02924   ChangeInfoResult ret = CIR_SUCCESS;
02925 
02926   if (_cur.grffile->sound_offset == 0) {
02927     grfmsg(1, "SoundEffectChangeInfo: No effects defined, skipping");
02928     return CIR_INVALID_ID;
02929   }
02930 
02931   if (sid + numinfo - ORIGINAL_SAMPLE_COUNT > _cur.grffile->num_sounds) {
02932     grfmsg(1, "SoundEffectChangeInfo: Attemting to change undefined sound effect (%u), max (%u). Ignoring.", sid + numinfo, ORIGINAL_SAMPLE_COUNT + _cur.grffile->num_sounds);
02933     return CIR_INVALID_ID;
02934   }
02935 
02936   for (int i = 0; i < numinfo; i++) {
02937     SoundEntry *sound = GetSound(sid + i + _cur.grffile->sound_offset - ORIGINAL_SAMPLE_COUNT);
02938 
02939     switch (prop) {
02940       case 0x08: // Relative volume
02941         sound->volume = buf->ReadByte();
02942         break;
02943 
02944       case 0x09: // Priority
02945         sound->priority = buf->ReadByte();
02946         break;
02947 
02948       case 0x0A: { // Override old sound
02949         SoundID orig_sound = buf->ReadByte();
02950 
02951         if (orig_sound >= ORIGINAL_SAMPLE_COUNT) {
02952           grfmsg(1, "SoundEffectChangeInfo: Original sound %d not defined (max %d)", orig_sound, ORIGINAL_SAMPLE_COUNT);
02953         } else {
02954           SoundEntry *old_sound = GetSound(orig_sound);
02955 
02956           /* Literally copy the data of the new sound over the original */
02957           *old_sound = *sound;
02958         }
02959         break;
02960       }
02961 
02962       default:
02963         ret = CIR_UNKNOWN;
02964         break;
02965     }
02966   }
02967 
02968   return ret;
02969 }
02970 
02977 static ChangeInfoResult IgnoreIndustryTileProperty(int prop, ByteReader *buf)
02978 {
02979   ChangeInfoResult ret = CIR_SUCCESS;
02980 
02981   switch (prop) {
02982     case 0x09:
02983     case 0x0D:
02984     case 0x0E:
02985     case 0x10:
02986     case 0x11:
02987     case 0x12:
02988       buf->ReadByte();
02989       break;
02990 
02991     case 0x0A:
02992     case 0x0B:
02993     case 0x0C:
02994     case 0x0F:
02995       buf->ReadWord();
02996       break;
02997 
02998     default:
02999       ret = CIR_UNKNOWN;
03000       break;
03001   }
03002   return ret;
03003 }
03004 
03013 static ChangeInfoResult IndustrytilesChangeInfo(uint indtid, int numinfo, int prop, ByteReader *buf)
03014 {
03015   ChangeInfoResult ret = CIR_SUCCESS;
03016 
03017   if (indtid + numinfo > NUM_INDUSTRYTILES_PER_GRF) {
03018     grfmsg(1, "IndustryTilesChangeInfo: Too many industry tiles loaded (%u), max (%u). Ignoring.", indtid + numinfo, NUM_INDUSTRYTILES_PER_GRF);
03019     return CIR_INVALID_ID;
03020   }
03021 
03022   /* Allocate industry tile specs if they haven't been allocated already. */
03023   if (_cur.grffile->indtspec == NULL) {
03024     _cur.grffile->indtspec = CallocT<IndustryTileSpec*>(NUM_INDUSTRYTILES_PER_GRF);
03025   }
03026 
03027   for (int i = 0; i < numinfo; i++) {
03028     IndustryTileSpec *tsp = _cur.grffile->indtspec[indtid + i];
03029 
03030     if (prop != 0x08 && tsp == NULL) {
03031       ChangeInfoResult cir = IgnoreIndustryTileProperty(prop, buf);
03032       if (cir > ret) ret = cir;
03033       continue;
03034     }
03035 
03036     switch (prop) {
03037       case 0x08: { // Substitute industry tile type
03038         IndustryTileSpec **tilespec = &_cur.grffile->indtspec[indtid + i];
03039         byte subs_id = buf->ReadByte();
03040 
03041         if (subs_id >= NEW_INDUSTRYTILEOFFSET) {
03042           /* The substitute id must be one of the original industry tile. */
03043           grfmsg(2, "IndustryTilesChangeInfo: Attempt to use new industry tile %u as substitute industry tile for %u. Ignoring.", subs_id, indtid + i);
03044           continue;
03045         }
03046 
03047         /* Allocate space for this industry. */
03048         if (*tilespec == NULL) {
03049           *tilespec = CallocT<IndustryTileSpec>(1);
03050           tsp = *tilespec;
03051 
03052           memcpy(tsp, &_industry_tile_specs[subs_id], sizeof(_industry_tile_specs[subs_id]));
03053           tsp->enabled = true;
03054 
03055           /* A copied tile should not have the animation infos copied too.
03056            * The anim_state should be left untouched, though
03057            * It is up to the author to animate them himself */
03058           tsp->anim_production = INDUSTRYTILE_NOANIM;
03059           tsp->anim_next = INDUSTRYTILE_NOANIM;
03060 
03061           tsp->grf_prop.local_id = indtid + i;
03062           tsp->grf_prop.subst_id = subs_id;
03063           tsp->grf_prop.grffile = _cur.grffile;
03064           _industile_mngr.AddEntityID(indtid + i, _cur.grffile->grfid, subs_id); // pre-reserve the tile slot
03065         }
03066         break;
03067       }
03068 
03069       case 0x09: { // Industry tile override
03070         byte ovrid = buf->ReadByte();
03071 
03072         /* The industry being overridden must be an original industry. */
03073         if (ovrid >= NEW_INDUSTRYTILEOFFSET) {
03074           grfmsg(2, "IndustryTilesChangeInfo: Attempt to override new industry tile %u with industry tile id %u. Ignoring.", ovrid, indtid + i);
03075           continue;
03076         }
03077 
03078         _industile_mngr.Add(indtid + i, _cur.grffile->grfid, ovrid);
03079         break;
03080       }
03081 
03082       case 0x0A: // Tile acceptance
03083       case 0x0B:
03084       case 0x0C: {
03085         uint16 acctp = buf->ReadWord();
03086         tsp->accepts_cargo[prop - 0x0A] = GetCargoTranslation(GB(acctp, 0, 8), _cur.grffile);
03087         tsp->acceptance[prop - 0x0A] = GB(acctp, 8, 8);
03088         break;
03089       }
03090 
03091       case 0x0D: // Land shape flags
03092         tsp->slopes_refused = (Slope)buf->ReadByte();
03093         break;
03094 
03095       case 0x0E: // Callback mask
03096         tsp->callback_mask = buf->ReadByte();
03097         break;
03098 
03099       case 0x0F: // Animation information
03100         tsp->animation.frames = buf->ReadByte();
03101         tsp->animation.status = buf->ReadByte();
03102         break;
03103 
03104       case 0x10: // Animation speed
03105         tsp->animation.speed = buf->ReadByte();
03106         break;
03107 
03108       case 0x11: // Triggers for callback 25
03109         tsp->animation.triggers = buf->ReadByte();
03110         break;
03111 
03112       case 0x12: // Special flags
03113         tsp->special_flags = (IndustryTileSpecialFlags)buf->ReadByte();
03114         break;
03115 
03116       default:
03117         ret = CIR_UNKNOWN;
03118         break;
03119     }
03120   }
03121 
03122   return ret;
03123 }
03124 
03131 static ChangeInfoResult IgnoreIndustryProperty(int prop, ByteReader *buf)
03132 {
03133   ChangeInfoResult ret = CIR_SUCCESS;
03134 
03135   switch (prop) {
03136     case 0x09:
03137     case 0x0B:
03138     case 0x0F:
03139     case 0x12:
03140     case 0x13:
03141     case 0x14:
03142     case 0x17:
03143     case 0x18:
03144     case 0x19:
03145     case 0x21:
03146     case 0x22:
03147       buf->ReadByte();
03148       break;
03149 
03150     case 0x0C:
03151     case 0x0D:
03152     case 0x0E:
03153     case 0x10:
03154     case 0x1B:
03155     case 0x1F:
03156     case 0x24:
03157       buf->ReadWord();
03158       break;
03159 
03160     case 0x11:
03161     case 0x1A:
03162     case 0x1C:
03163     case 0x1D:
03164     case 0x1E:
03165     case 0x20:
03166     case 0x23:
03167       buf->ReadDWord();
03168       break;
03169 
03170     case 0x0A: {
03171       byte num_table = buf->ReadByte();
03172       for (byte j = 0; j < num_table; j++) {
03173         for (uint k = 0;; k++) {
03174           byte x = buf->ReadByte();
03175           if (x == 0xFE && k == 0) {
03176             buf->ReadByte();
03177             buf->ReadByte();
03178             break;
03179           }
03180 
03181           byte y = buf->ReadByte();
03182           if (x == 0 && y == 0x80) break;
03183 
03184           byte gfx = buf->ReadByte();
03185           if (gfx == 0xFE) buf->ReadWord();
03186         }
03187       }
03188       break;
03189     }
03190 
03191     case 0x16:
03192       for (byte j = 0; j < 3; j++) buf->ReadByte();
03193       break;
03194 
03195     case 0x15: {
03196       byte number_of_sounds = buf->ReadByte();
03197       for (uint8 j = 0; j < number_of_sounds; j++) {
03198         buf->ReadByte();
03199       }
03200       break;
03201     }
03202 
03203     default:
03204       ret = CIR_UNKNOWN;
03205       break;
03206   }
03207   return ret;
03208 }
03209 
03216 static bool ValidateIndustryLayout(const IndustryTileTable *layout, int size)
03217 {
03218   for (int i = 0; i < size - 1; i++) {
03219     for (int j = i + 1; j < size; j++) {
03220       if (layout[i].ti.x == layout[j].ti.x &&
03221           layout[i].ti.y == layout[j].ti.y) {
03222         return false;
03223       }
03224     }
03225   }
03226   return true;
03227 }
03228 
03230 static void CleanIndustryTileTable(IndustrySpec *ind)
03231 {
03232   if (HasBit(ind->cleanup_flag, CLEAN_TILELAYOUT) && ind->table != NULL) {
03233     for (int j = 0; j < ind->num_table; j++) {
03234       /* remove the individual layouts */
03235       free(ind->table[j]);
03236     }
03237     /* remove the layouts pointers */
03238     free(ind->table);
03239     ind->table = NULL;
03240   }
03241 }
03242 
03251 static ChangeInfoResult IndustriesChangeInfo(uint indid, int numinfo, int prop, ByteReader *buf)
03252 {
03253   ChangeInfoResult ret = CIR_SUCCESS;
03254 
03255   if (indid + numinfo > NUM_INDUSTRYTYPES_PER_GRF) {
03256     grfmsg(1, "IndustriesChangeInfo: Too many industries loaded (%u), max (%u). Ignoring.", indid + numinfo, NUM_INDUSTRYTYPES_PER_GRF);
03257     return CIR_INVALID_ID;
03258   }
03259 
03260   /* Allocate industry specs if they haven't been allocated already. */
03261   if (_cur.grffile->industryspec == NULL) {
03262     _cur.grffile->industryspec = CallocT<IndustrySpec*>(NUM_INDUSTRYTYPES_PER_GRF);
03263   }
03264 
03265   for (int i = 0; i < numinfo; i++) {
03266     IndustrySpec *indsp = _cur.grffile->industryspec[indid + i];
03267 
03268     if (prop != 0x08 && indsp == NULL) {
03269       ChangeInfoResult cir = IgnoreIndustryProperty(prop, buf);
03270       if (cir > ret) ret = cir;
03271       continue;
03272     }
03273 
03274     switch (prop) {
03275       case 0x08: { // Substitute industry type
03276         IndustrySpec **indspec = &_cur.grffile->industryspec[indid + i];
03277         byte subs_id = buf->ReadByte();
03278 
03279         if (subs_id == 0xFF) {
03280           /* Instead of defining a new industry, a substitute industry id
03281            * of 0xFF disables the old industry with the current id. */
03282           _industry_specs[indid + i].enabled = false;
03283           continue;
03284         } else if (subs_id >= NEW_INDUSTRYOFFSET) {
03285           /* The substitute id must be one of the original industry. */
03286           grfmsg(2, "_industry_specs: Attempt to use new industry %u as substitute industry for %u. Ignoring.", subs_id, indid + i);
03287           continue;
03288         }
03289 
03290         /* Allocate space for this industry.
03291          * Only need to do it once. If ever it is called again, it should not
03292          * do anything */
03293         if (*indspec == NULL) {
03294           *indspec = CallocT<IndustrySpec>(1);
03295           indsp = *indspec;
03296 
03297           memcpy(indsp, &_origin_industry_specs[subs_id], sizeof(_industry_specs[subs_id]));
03298           indsp->enabled = true;
03299           indsp->grf_prop.local_id = indid + i;
03300           indsp->grf_prop.subst_id = subs_id;
03301           indsp->grf_prop.grffile = _cur.grffile;
03302           /* If the grf industry needs to check its surounding upon creation, it should
03303            * rely on callbacks, not on the original placement functions */
03304           indsp->check_proc = CHECK_NOTHING;
03305         }
03306         break;
03307       }
03308 
03309       case 0x09: { // Industry type override
03310         byte ovrid = buf->ReadByte();
03311 
03312         /* The industry being overridden must be an original industry. */
03313         if (ovrid >= NEW_INDUSTRYOFFSET) {
03314           grfmsg(2, "IndustriesChangeInfo: Attempt to override new industry %u with industry id %u. Ignoring.", ovrid, indid + i);
03315           continue;
03316         }
03317         indsp->grf_prop.override = ovrid;
03318         _industry_mngr.Add(indid + i, _cur.grffile->grfid, ovrid);
03319         break;
03320       }
03321 
03322       case 0x0A: { // Set industry layout(s)
03323         byte new_num_layouts = buf->ReadByte(); // Number of layaouts
03324         /* We read the total size in bytes, but we can't rely on the
03325          * newgrf to provide a sane value. First assume the value is
03326          * sane but later on we make sure we enlarge the array if the
03327          * newgrf contains more data. Each tile uses either 3 or 5
03328          * bytes, so to play it safe we assume 3. */
03329         uint32 def_num_tiles = buf->ReadDWord() / 3 + 1;
03330         IndustryTileTable **tile_table = CallocT<IndustryTileTable*>(new_num_layouts); // Table with tiles to compose an industry
03331         IndustryTileTable *itt = CallocT<IndustryTileTable>(def_num_tiles); // Temporary array to read the tile layouts from the GRF
03332         uint size;
03333         const IndustryTileTable *copy_from;
03334 
03335         try {
03336           for (byte j = 0; j < new_num_layouts; j++) {
03337             for (uint k = 0;; k++) {
03338               if (k >= def_num_tiles) {
03339                 grfmsg(3, "IndustriesChangeInfo: Incorrect size for industry tile layout definition for industry %u.", indid);
03340                 /* Size reported by newgrf was not big enough so enlarge the array. */
03341                 def_num_tiles *= 2;
03342                 itt = ReallocT<IndustryTileTable>(itt, def_num_tiles);
03343               }
03344 
03345               itt[k].ti.x = buf->ReadByte(); // Offsets from northermost tile
03346 
03347               if (itt[k].ti.x == 0xFE && k == 0) {
03348                 /* This means we have to borrow the layout from an old industry */
03349                 IndustryType type = buf->ReadByte();  // industry holding required layout
03350                 byte laynbr = buf->ReadByte();        // layout number to borrow
03351 
03352                 copy_from = _origin_industry_specs[type].table[laynbr];
03353                 for (size = 1;; size++) {
03354                   if (copy_from[size - 1].ti.x == -0x80 && copy_from[size - 1].ti.y == 0) break;
03355                 }
03356                 break;
03357               }
03358 
03359               itt[k].ti.y = buf->ReadByte(); // Or table definition finalisation
03360 
03361               if (itt[k].ti.x == 0 && itt[k].ti.y == 0x80) {
03362                 /*  Not the same terminator.  The one we are using is rather
03363                  x = -80, y = x .  So, adjust it. */
03364                 itt[k].ti.x = -0x80;
03365                 itt[k].ti.y =  0;
03366                 itt[k].gfx  =  0;
03367 
03368                 size = k + 1;
03369                 copy_from = itt;
03370                 break;
03371               }
03372 
03373               itt[k].gfx = buf->ReadByte();
03374 
03375               if (itt[k].gfx == 0xFE) {
03376                 /* Use a new tile from this GRF */
03377                 int local_tile_id = buf->ReadWord();
03378 
03379                 /* Read the ID from the _industile_mngr. */
03380                 int tempid = _industile_mngr.GetID(local_tile_id, _cur.grffile->grfid);
03381 
03382                 if (tempid == INVALID_INDUSTRYTILE) {
03383                   grfmsg(2, "IndustriesChangeInfo: Attempt to use industry tile %u with industry id %u, not yet defined. Ignoring.", local_tile_id, indid);
03384                 } else {
03385                   /* Declared as been valid, can be used */
03386                   itt[k].gfx = tempid;
03387                   size = k + 1;
03388                   copy_from = itt;
03389                 }
03390               } else if (itt[k].gfx == 0xFF) {
03391                 itt[k].ti.x = (int8)GB(itt[k].ti.x, 0, 8);
03392                 itt[k].ti.y = (int8)GB(itt[k].ti.y, 0, 8);
03393               }
03394             }
03395 
03396             if (!ValidateIndustryLayout(copy_from, size)) {
03397               /* The industry layout was not valid, so skip this one. */
03398               grfmsg(1, "IndustriesChangeInfo: Invalid industry layout for industry id %u. Ignoring", indid);
03399               new_num_layouts--;
03400               j--;
03401             } else {
03402               tile_table[j] = CallocT<IndustryTileTable>(size);
03403               memcpy(tile_table[j], copy_from, sizeof(*copy_from) * size);
03404             }
03405           }
03406         } catch (...) {
03407           for (int i = 0; i < new_num_layouts; i++) {
03408             free(tile_table[i]);
03409           }
03410           free(tile_table);
03411           free(itt);
03412           throw;
03413         }
03414 
03415         /* Clean the tile table if it was already set by a previous prop A. */
03416         CleanIndustryTileTable(indsp);
03417         /* Install final layout construction in the industry spec */
03418         indsp->num_table = new_num_layouts;
03419         indsp->table = tile_table;
03420         SetBit(indsp->cleanup_flag, CLEAN_TILELAYOUT);
03421         free(itt);
03422         break;
03423       }
03424 
03425       case 0x0B: // Industry production flags
03426         indsp->life_type = (IndustryLifeType)buf->ReadByte();
03427         break;
03428 
03429       case 0x0C: // Industry closure message
03430         indsp->closure_text = buf->ReadWord();
03431         _string_to_grf_mapping[&indsp->closure_text] = _cur.grffile->grfid;
03432         break;
03433 
03434       case 0x0D: // Production increase message
03435         indsp->production_up_text = buf->ReadWord();
03436         _string_to_grf_mapping[&indsp->production_up_text] = _cur.grffile->grfid;
03437         break;
03438 
03439       case 0x0E: // Production decrease message
03440         indsp->production_down_text = buf->ReadWord();
03441         _string_to_grf_mapping[&indsp->production_down_text] = _cur.grffile->grfid;
03442         break;
03443 
03444       case 0x0F: // Fund cost multiplier
03445         indsp->cost_multiplier = buf->ReadByte();
03446         break;
03447 
03448       case 0x10: // Production cargo types
03449         for (byte j = 0; j < 2; j++) {
03450           indsp->produced_cargo[j] = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
03451         }
03452         break;
03453 
03454       case 0x11: // Acceptance cargo types
03455         for (byte j = 0; j < 3; j++) {
03456           indsp->accepts_cargo[j] = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
03457         }
03458         buf->ReadByte(); // Unnused, eat it up
03459         break;
03460 
03461       case 0x12: // Production multipliers
03462       case 0x13:
03463         indsp->production_rate[prop - 0x12] = buf->ReadByte();
03464         break;
03465 
03466       case 0x14: // Minimal amount of cargo distributed
03467         indsp->minimal_cargo = buf->ReadByte();
03468         break;
03469 
03470       case 0x15: { // Random sound effects
03471         indsp->number_of_sounds = buf->ReadByte();
03472         uint8 *sounds = MallocT<uint8>(indsp->number_of_sounds);
03473 
03474         try {
03475           for (uint8 j = 0; j < indsp->number_of_sounds; j++) {
03476             sounds[j] = buf->ReadByte();
03477           }
03478         } catch (...) {
03479           free(sounds);
03480           throw;
03481         }
03482 
03483         if (HasBit(indsp->cleanup_flag, CLEAN_RANDOMSOUNDS)) {
03484           free(indsp->random_sounds);
03485         }
03486         indsp->random_sounds = sounds;
03487         SetBit(indsp->cleanup_flag, CLEAN_RANDOMSOUNDS);
03488         break;
03489       }
03490 
03491       case 0x16: // Conflicting industry types
03492         for (byte j = 0; j < 3; j++) indsp->conflicting[j] = buf->ReadByte();
03493         break;
03494 
03495       case 0x17: // Probability in random game
03496         indsp->appear_creation[_settings_game.game_creation.landscape] = buf->ReadByte();
03497         break;
03498 
03499       case 0x18: // Probability during gameplay
03500         indsp->appear_ingame[_settings_game.game_creation.landscape] = buf->ReadByte();
03501         break;
03502 
03503       case 0x19: // Map colour
03504         indsp->map_colour = buf->ReadByte();
03505         break;
03506 
03507       case 0x1A: // Special industry flags to define special behavior
03508         indsp->behaviour = (IndustryBehaviour)buf->ReadDWord();
03509         break;
03510 
03511       case 0x1B: // New industry text ID
03512         indsp->new_industry_text = buf->ReadWord();
03513         _string_to_grf_mapping[&indsp->new_industry_text] = _cur.grffile->grfid;
03514         break;
03515 
03516       case 0x1C: // Input cargo multipliers for the three input cargo types
03517       case 0x1D:
03518       case 0x1E: {
03519           uint32 multiples = buf->ReadDWord();
03520           indsp->input_cargo_multiplier[prop - 0x1C][0] = GB(multiples, 0, 16);
03521           indsp->input_cargo_multiplier[prop - 0x1C][1] = GB(multiples, 16, 16);
03522           break;
03523         }
03524 
03525       case 0x1F: // Industry name
03526         indsp->name = buf->ReadWord();
03527         _string_to_grf_mapping[&indsp->name] = _cur.grffile->grfid;
03528         break;
03529 
03530       case 0x20: // Prospecting success chance
03531         indsp->prospecting_chance = buf->ReadDWord();
03532         break;
03533 
03534       case 0x21:   // Callback mask
03535       case 0x22: { // Callback additional mask
03536         byte aflag = buf->ReadByte();
03537         SB(indsp->callback_mask, (prop - 0x21) * 8, 8, aflag);
03538         break;
03539       }
03540 
03541       case 0x23: // removal cost multiplier
03542         indsp->removal_cost_multiplier = buf->ReadDWord();
03543         break;
03544 
03545       case 0x24: // name for nearby station
03546         indsp->station_name = buf->ReadWord();
03547         if (indsp->station_name != STR_NULL) _string_to_grf_mapping[&indsp->station_name] = _cur.grffile->grfid;
03548         break;
03549 
03550       default:
03551         ret = CIR_UNKNOWN;
03552         break;
03553     }
03554   }
03555 
03556   return ret;
03557 }
03558 
03564 static void DuplicateTileTable(AirportSpec *as)
03565 {
03566   AirportTileTable **table_list = MallocT<AirportTileTable*>(as->num_table);
03567   for (int i = 0; i < as->num_table; i++) {
03568     uint num_tiles = 1;
03569     const AirportTileTable *it = as->table[0];
03570     do {
03571       num_tiles++;
03572     } while ((++it)->ti.x != -0x80);
03573     table_list[i] = MallocT<AirportTileTable>(num_tiles);
03574     MemCpyT(table_list[i], as->table[i], num_tiles);
03575   }
03576   as->table = table_list;
03577   HangarTileTable *depot_table = MallocT<HangarTileTable>(as->nof_depots);
03578   MemCpyT(depot_table, as->depot_table, as->nof_depots);
03579   as->depot_table = depot_table;
03580 }
03581 
03590 static ChangeInfoResult AirportChangeInfo(uint airport, int numinfo, int prop, ByteReader *buf)
03591 {
03592   ChangeInfoResult ret = CIR_SUCCESS;
03593 
03594   if (airport + numinfo > NUM_AIRPORTS_PER_GRF) {
03595     grfmsg(1, "AirportChangeInfo: Too many airports, trying id (%u), max (%u). Ignoring.", airport + numinfo, NUM_AIRPORTS_PER_GRF);
03596     return CIR_INVALID_ID;
03597   }
03598 
03599   /* Allocate industry specs if they haven't been allocated already. */
03600   if (_cur.grffile->airportspec == NULL) {
03601     _cur.grffile->airportspec = CallocT<AirportSpec*>(NUM_AIRPORTS_PER_GRF);
03602   }
03603 
03604   for (int i = 0; i < numinfo; i++) {
03605     AirportSpec *as = _cur.grffile->airportspec[airport + i];
03606 
03607     if (as == NULL && prop != 0x08 && prop != 0x09) {
03608       grfmsg(2, "AirportChangeInfo: Attempt to modify undefined airport %u, ignoring", airport + i);
03609       return CIR_INVALID_ID;
03610     }
03611 
03612     switch (prop) {
03613       case 0x08: { // Modify original airport
03614         byte subs_id = buf->ReadByte();
03615 
03616         if (subs_id == 0xFF) {
03617           /* Instead of defining a new airport, an airport id
03618            * of 0xFF disables the old airport with the current id. */
03619           AirportSpec::GetWithoutOverride(airport + i)->enabled = false;
03620           continue;
03621         } else if (subs_id >= NEW_AIRPORT_OFFSET) {
03622           /* The substitute id must be one of the original airports. */
03623           grfmsg(2, "AirportChangeInfo: Attempt to use new airport %u as substitute airport for %u. Ignoring.", subs_id, airport + i);
03624           continue;
03625         }
03626 
03627         AirportSpec **spec = &_cur.grffile->airportspec[airport + i];
03628         /* Allocate space for this airport.
03629          * Only need to do it once. If ever it is called again, it should not
03630          * do anything */
03631         if (*spec == NULL) {
03632           *spec = MallocT<AirportSpec>(1);
03633           as = *spec;
03634 
03635           memcpy(as, AirportSpec::GetWithoutOverride(subs_id), sizeof(*as));
03636           as->enabled = true;
03637           as->grf_prop.local_id = airport + i;
03638           as->grf_prop.subst_id = subs_id;
03639           as->grf_prop.grffile = _cur.grffile;
03640           /* override the default airport */
03641           _airport_mngr.Add(airport + i, _cur.grffile->grfid, subs_id);
03642           /* Create a copy of the original tiletable so it can be freed later. */
03643           DuplicateTileTable(as);
03644         }
03645         break;
03646       }
03647 
03648       case 0x0A: { // Set airport layout
03649         as->num_table = buf->ReadByte(); // Number of layaouts
03650         as->rotation = MallocT<Direction>(as->num_table);
03651         uint32 defsize = buf->ReadDWord();  // Total size of the definition
03652         AirportTileTable **tile_table = CallocT<AirportTileTable*>(as->num_table); // Table with tiles to compose the airport
03653         AirportTileTable *att = CallocT<AirportTileTable>(defsize); // Temporary array to read the tile layouts from the GRF
03654         int size;
03655         const AirportTileTable *copy_from;
03656         try {
03657           for (byte j = 0; j < as->num_table; j++) {
03658             as->rotation[j] = (Direction)buf->ReadByte();
03659             for (int k = 0;; k++) {
03660               att[k].ti.x = buf->ReadByte(); // Offsets from northermost tile
03661               att[k].ti.y = buf->ReadByte();
03662 
03663               if (att[k].ti.x == 0 && att[k].ti.y == 0x80) {
03664                 /*  Not the same terminator.  The one we are using is rather
03665                  * x = -80, y = 0 .  So, adjust it. */
03666                 att[k].ti.x = -0x80;
03667                 att[k].ti.y =  0;
03668                 att[k].gfx  =  0;
03669 
03670                 size = k + 1;
03671                 copy_from = att;
03672                 break;
03673               }
03674 
03675               att[k].gfx = buf->ReadByte();
03676 
03677               if (att[k].gfx == 0xFE) {
03678                 /* Use a new tile from this GRF */
03679                 int local_tile_id = buf->ReadWord();
03680 
03681                 /* Read the ID from the _airporttile_mngr. */
03682                 uint16 tempid = _airporttile_mngr.GetID(local_tile_id, _cur.grffile->grfid);
03683 
03684                 if (tempid == INVALID_AIRPORTTILE) {
03685                   grfmsg(2, "AirportChangeInfo: Attempt to use airport tile %u with airport id %u, not yet defined. Ignoring.", local_tile_id, airport + i);
03686                 } else {
03687                   /* Declared as been valid, can be used */
03688                   att[k].gfx = tempid;
03689                   size = k + 1;
03690                   copy_from = att;
03691                 }
03692               } else if (att[k].gfx == 0xFF) {
03693                 att[k].ti.x = (int8)GB(att[k].ti.x, 0, 8);
03694                 att[k].ti.y = (int8)GB(att[k].ti.y, 0, 8);
03695               }
03696 
03697               if (as->rotation[j] == DIR_E || as->rotation[j] == DIR_W) {
03698                 as->size_x = max<byte>(as->size_x, att[k].ti.y + 1);
03699                 as->size_y = max<byte>(as->size_y, att[k].ti.x + 1);
03700               } else {
03701                 as->size_x = max<byte>(as->size_x, att[k].ti.x + 1);
03702                 as->size_y = max<byte>(as->size_y, att[k].ti.y + 1);
03703               }
03704             }
03705             tile_table[j] = CallocT<AirportTileTable>(size);
03706             memcpy(tile_table[j], copy_from, sizeof(*copy_from) * size);
03707           }
03708           /* Install final layout construction in the airport spec */
03709           as->table = tile_table;
03710           free(att);
03711         } catch (...) {
03712           for (int i = 0; i < as->num_table; i++) {
03713             free(tile_table[i]);
03714           }
03715           free(tile_table);
03716           free(att);
03717           throw;
03718         }
03719         break;
03720       }
03721 
03722       case 0x0C:
03723         as->min_year = buf->ReadWord();
03724         as->max_year = buf->ReadWord();
03725         if (as->max_year == 0xFFFF) as->max_year = MAX_YEAR;
03726         break;
03727 
03728       case 0x0D:
03729         as->ttd_airport_type = (TTDPAirportType)buf->ReadByte();
03730         break;
03731 
03732       case 0x0E:
03733         as->catchment = Clamp(buf->ReadByte(), 1, MAX_CATCHMENT);
03734         break;
03735 
03736       case 0x0F:
03737         as->noise_level = buf->ReadByte();
03738         break;
03739 
03740       case 0x10:
03741         as->name = buf->ReadWord();
03742         _string_to_grf_mapping[&as->name] = _cur.grffile->grfid;
03743         break;
03744 
03745       case 0x11: // Maintenance cost factor
03746         as->maintenance_cost = buf->ReadWord();
03747         break;
03748 
03749       default:
03750         ret = CIR_UNKNOWN;
03751         break;
03752     }
03753   }
03754 
03755   return ret;
03756 }
03757 
03764 static ChangeInfoResult IgnoreObjectProperty(uint prop, ByteReader *buf)
03765 {
03766   ChangeInfoResult ret = CIR_SUCCESS;
03767 
03768   switch (prop) {
03769     case 0x0B:
03770     case 0x0C:
03771     case 0x0D:
03772     case 0x12:
03773     case 0x14:
03774     case 0x16:
03775     case 0x17:
03776       buf->ReadByte();
03777       break;
03778 
03779     case 0x09:
03780     case 0x0A:
03781     case 0x10:
03782     case 0x11:
03783     case 0x13:
03784     case 0x15:
03785       buf->ReadWord();
03786       break;
03787 
03788     case 0x08:
03789     case 0x0E:
03790     case 0x0F:
03791       buf->ReadDWord();
03792       break;
03793 
03794     default:
03795       ret = CIR_UNKNOWN;
03796       break;
03797   }
03798 
03799   return ret;
03800 }
03801 
03810 static ChangeInfoResult ObjectChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
03811 {
03812   ChangeInfoResult ret = CIR_SUCCESS;
03813 
03814   if (id + numinfo > NUM_OBJECTS_PER_GRF) {
03815     grfmsg(1, "ObjectChangeInfo: Too many objects loaded (%u), max (%u). Ignoring.", id + numinfo, NUM_OBJECTS_PER_GRF);
03816     return CIR_INVALID_ID;
03817   }
03818 
03819   /* Allocate object specs if they haven't been allocated already. */
03820   if (_cur.grffile->objectspec == NULL) {
03821     _cur.grffile->objectspec = CallocT<ObjectSpec*>(NUM_OBJECTS_PER_GRF);
03822   }
03823 
03824   for (int i = 0; i < numinfo; i++) {
03825     ObjectSpec *spec = _cur.grffile->objectspec[id + i];
03826 
03827     if (prop != 0x08 && spec == NULL) {
03828       /* If the object property 08 is not yet set, ignore this property */
03829       ChangeInfoResult cir = IgnoreObjectProperty(prop, buf);
03830       if (cir > ret) ret = cir;
03831       continue;
03832     }
03833 
03834     switch (prop) {
03835       case 0x08: { // Class ID
03836         ObjectSpec **ospec = &_cur.grffile->objectspec[id + i];
03837 
03838         /* Allocate space for this object. */
03839         if (*ospec == NULL) {
03840           *ospec = CallocT<ObjectSpec>(1);
03841           (*ospec)->views = 1; // Default for NewGRFs that don't set it.
03842         }
03843 
03844         /* Swap classid because we read it in BE. */
03845         uint32 classid = buf->ReadDWord();
03846         (*ospec)->cls_id = ObjectClass::Allocate(BSWAP32(classid));
03847         (*ospec)->enabled = true;
03848         break;
03849       }
03850 
03851       case 0x09: { // Class name
03852         StringID class_name = buf->ReadWord();
03853         ObjectClass *objclass = ObjectClass::Get(spec->cls_id);
03854         objclass->name = class_name;
03855         _string_to_grf_mapping[&objclass->name] = _cur.grffile->grfid;
03856         break;
03857       }
03858 
03859       case 0x0A: // Object name
03860         spec->name = buf->ReadWord();
03861         _string_to_grf_mapping[&spec->name] = _cur.grffile->grfid;
03862         break;
03863 
03864       case 0x0B: // Climate mask
03865         spec->climate = buf->ReadByte();
03866         break;
03867 
03868       case 0x0C: // Size
03869         spec->size = buf->ReadByte();
03870         break;
03871 
03872       case 0x0D: // Build cost multipler
03873         spec->build_cost_multiplier = buf->ReadByte();
03874         spec->clear_cost_multiplier = spec->build_cost_multiplier;
03875         break;
03876 
03877       case 0x0E: // Introduction date
03878         spec->introduction_date = buf->ReadDWord();
03879         break;
03880 
03881       case 0x0F: // End of life
03882         spec->end_of_life_date = buf->ReadDWord();
03883         break;
03884 
03885       case 0x10: // Flags
03886         spec->flags = (ObjectFlags)buf->ReadWord();
03887         _loaded_newgrf_features.has_2CC |= (spec->flags & OBJECT_FLAG_2CC_COLOUR) != 0;
03888         break;
03889 
03890       case 0x11: // Animation info
03891         spec->animation.frames = buf->ReadByte();
03892         spec->animation.status = buf->ReadByte();
03893         break;
03894 
03895       case 0x12: // Animation speed
03896         spec->animation.speed = buf->ReadByte();
03897         break;
03898 
03899       case 0x13: // Animation triggers
03900         spec->animation.triggers = buf->ReadWord();
03901         break;
03902 
03903       case 0x14: // Removal cost multiplier
03904         spec->clear_cost_multiplier = buf->ReadByte();
03905         break;
03906 
03907       case 0x15: // Callback mask
03908         spec->callback_mask = buf->ReadWord();
03909         break;
03910 
03911       case 0x16: // Building height
03912         spec->height = buf->ReadByte();
03913         break;
03914 
03915       case 0x17: // Views
03916         spec->views = buf->ReadByte();
03917         if (spec->views != 1 && spec->views != 2 && spec->views != 4) {
03918           grfmsg(2, "ObjectChangeInfo: Invalid number of views (%u) for object id %u. Ignoring.", spec->views, id + i);
03919           spec->views = 1;
03920         }
03921         break;
03922 
03923       case 0x18: // Amount placed on 256^2 map on map creation
03924         spec->generate_amount = buf->ReadByte();
03925         break;
03926 
03927       default:
03928         ret = CIR_UNKNOWN;
03929         break;
03930     }
03931   }
03932 
03933   return ret;
03934 }
03935 
03944 static ChangeInfoResult RailTypeChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
03945 {
03946   ChangeInfoResult ret = CIR_SUCCESS;
03947 
03948   extern RailtypeInfo _railtypes[RAILTYPE_END];
03949 
03950   if (id + numinfo > RAILTYPE_END) {
03951     grfmsg(1, "RailTypeChangeInfo: Rail type %u is invalid, max %u, ignoring", id + numinfo, RAILTYPE_END);
03952     return CIR_INVALID_ID;
03953   }
03954 
03955   for (int i = 0; i < numinfo; i++) {
03956     RailType rt = _cur.grffile->railtype_map[id + i];
03957     if (rt == INVALID_RAILTYPE) return CIR_INVALID_ID;
03958 
03959     RailtypeInfo *rti = &_railtypes[rt];
03960 
03961     switch (prop) {
03962       case 0x08: // Label of rail type
03963         /* Skipped here as this is loaded during reservation stage. */
03964         buf->ReadDWord();
03965         break;
03966 
03967       case 0x09: // Toolbar caption of railtype (sets name as well for backwards compatibility for grf ver < 8)
03968         rti->strings.toolbar_caption = buf->ReadWord();
03969         _string_to_grf_mapping[&rti->strings.toolbar_caption] = _cur.grffile->grfid;
03970         if (_cur.grffile->grf_version < 8) {
03971           rti->strings.name = rti->strings.toolbar_caption;
03972           _string_to_grf_mapping[&rti->strings.name] = _cur.grffile->grfid;
03973         }
03974         break;
03975 
03976       case 0x0A: // Menu text of railtype
03977         rti->strings.menu_text = buf->ReadWord();
03978         _string_to_grf_mapping[&rti->strings.menu_text] = _cur.grffile->grfid;
03979         break;
03980 
03981       case 0x0B: // Build window caption
03982         rti->strings.build_caption = buf->ReadWord();
03983         _string_to_grf_mapping[&rti->strings.build_caption] = _cur.grffile->grfid;
03984         break;
03985 
03986       case 0x0C: // Autoreplace text
03987         rti->strings.replace_text = buf->ReadWord();
03988         _string_to_grf_mapping[&rti->strings.replace_text] = _cur.grffile->grfid;
03989         break;
03990 
03991       case 0x0D: // New locomotive text
03992         rti->strings.new_loco = buf->ReadWord();
03993         _string_to_grf_mapping[&rti->strings.new_loco] = _cur.grffile->grfid;
03994         break;
03995 
03996       case 0x0E: // Compatible railtype list
03997       case 0x0F: // Powered railtype list
03998       case 0x18: // Railtype list required for date introduction
03999       case 0x19: // Introduced railtype list
04000       {
04001         /* Rail type compatibility bits are added to the existing bits
04002          * to allow multiple GRFs to modify compatibility with the
04003          * default rail types. */
04004         int n = buf->ReadByte();
04005         for (int j = 0; j != n; j++) {
04006           RailTypeLabel label = buf->ReadDWord();
04007           RailType rt = GetRailTypeByLabel(BSWAP32(label), false);
04008           if (rt != INVALID_RAILTYPE) {
04009             switch (prop) {
04010               case 0x0F: SetBit(rti->powered_railtypes, rt); // Powered implies compatible.
04011               case 0x0E: SetBit(rti->compatible_railtypes, rt);            break;
04012               case 0x18: SetBit(rti->introduction_required_railtypes, rt); break;
04013               case 0x19: SetBit(rti->introduces_railtypes, rt);            break;
04014             }
04015           }
04016         }
04017         break;
04018       }
04019 
04020       case 0x10: // Rail Type flags
04021         rti->flags = (RailTypeFlags)buf->ReadByte();
04022         break;
04023 
04024       case 0x11: // Curve speed advantage
04025         rti->curve_speed = buf->ReadByte();
04026         break;
04027 
04028       case 0x12: // Station graphic
04029         rti->fallback_railtype = Clamp(buf->ReadByte(), 0, 2);
04030         break;
04031 
04032       case 0x13: // Construction cost factor
04033         rti->cost_multiplier = buf->ReadWord();
04034         break;
04035 
04036       case 0x14: // Speed limit
04037         rti->max_speed = buf->ReadWord();
04038         break;
04039 
04040       case 0x15: // Acceleration model
04041         rti->acceleration_type = Clamp(buf->ReadByte(), 0, 2);
04042         break;
04043 
04044       case 0x16: // Map colour
04045         rti->map_colour = buf->ReadByte();
04046         break;
04047 
04048       case 0x17: // Introduction date
04049         rti->introduction_date = buf->ReadDWord();
04050         break;
04051 
04052       case 0x1A: // Sort order
04053         rti->sorting_order = buf->ReadByte();
04054         break;
04055 
04056       case 0x1B: // Name of railtype (overridden by prop 09 for grf ver < 8)
04057         rti->strings.name = buf->ReadWord();
04058         _string_to_grf_mapping[&rti->strings.name] = _cur.grffile->grfid;
04059         break;
04060 
04061       case 0x1C: // Maintenance cost factor
04062         rti->maintenance_multiplier = buf->ReadWord();
04063         break;
04064 
04065       case 0x1D: // Alternate rail type label list
04066         /* Skipped here as this is loaded during reservation stage. */
04067         for (int j = buf->ReadByte(); j != 0; j--) buf->ReadDWord();
04068         break;
04069 
04070       default:
04071         ret = CIR_UNKNOWN;
04072         break;
04073     }
04074   }
04075 
04076   return ret;
04077 }
04078 
04079 static ChangeInfoResult RailTypeReserveInfo(uint id, int numinfo, int prop, ByteReader *buf)
04080 {
04081   ChangeInfoResult ret = CIR_SUCCESS;
04082 
04083   extern RailtypeInfo _railtypes[RAILTYPE_END];
04084 
04085   if (id + numinfo > RAILTYPE_END) {
04086     grfmsg(1, "RailTypeReserveInfo: Rail type %u is invalid, max %u, ignoring", id + numinfo, RAILTYPE_END);
04087     return CIR_INVALID_ID;
04088   }
04089 
04090   for (int i = 0; i < numinfo; i++) {
04091     switch (prop) {
04092       case 0x08: // Label of rail type
04093       {
04094         RailTypeLabel rtl = buf->ReadDWord();
04095         rtl = BSWAP32(rtl);
04096 
04097         RailType rt = GetRailTypeByLabel(rtl, false);
04098         if (rt == INVALID_RAILTYPE) {
04099           /* Set up new rail type */
04100           rt = AllocateRailType(rtl);
04101         }
04102 
04103         _cur.grffile->railtype_map[id + i] = rt;
04104         break;
04105       }
04106 
04107       case 0x09: // Toolbar caption of railtype
04108       case 0x0A: // Menu text
04109       case 0x0B: // Build window caption
04110       case 0x0C: // Autoreplace text
04111       case 0x0D: // New loco
04112       case 0x13: // Construction cost
04113       case 0x14: // Speed limit
04114       case 0x1B: // Name of railtype
04115       case 0x1C: // Maintenance cost factor
04116         buf->ReadWord();
04117         break;
04118 
04119       case 0x1D: // Alternate rail type label list
04120         if (_cur.grffile->railtype_map[id + i] != INVALID_RAILTYPE) {
04121           int n = buf->ReadByte();
04122           for (int j = 0; j != n; j++) {
04123             *_railtypes[_cur.grffile->railtype_map[id + i]].alternate_labels.Append() = BSWAP32(buf->ReadDWord());
04124           }
04125           break;
04126         }
04127         grfmsg(1, "RailTypeReserveInfo: Ignoring property 1D for rail type %u because no label was set", id + i);
04128         /* FALL THROUGH */
04129 
04130       case 0x0E: // Compatible railtype list
04131       case 0x0F: // Powered railtype list
04132       case 0x18: // Railtype list required for date introduction
04133       case 0x19: // Introduced railtype list
04134         for (int j = buf->ReadByte(); j != 0; j--) buf->ReadDWord();
04135         break;
04136 
04137       case 0x10: // Rail Type flags
04138       case 0x11: // Curve speed advantage
04139       case 0x12: // Station graphic
04140       case 0x15: // Acceleration model
04141       case 0x16: // Map colour
04142       case 0x1A: // Sort order
04143         buf->ReadByte();
04144         break;
04145 
04146       case 0x17: // Introduction date
04147         buf->ReadDWord();
04148         break;
04149 
04150       default:
04151         ret = CIR_UNKNOWN;
04152         break;
04153     }
04154   }
04155 
04156   return ret;
04157 }
04158 
04159 static ChangeInfoResult AirportTilesChangeInfo(uint airtid, int numinfo, int prop, ByteReader *buf)
04160 {
04161   ChangeInfoResult ret = CIR_SUCCESS;
04162 
04163   if (airtid + numinfo > NUM_AIRPORTTILES_PER_GRF) {
04164     grfmsg(1, "AirportTileChangeInfo: Too many airport tiles loaded (%u), max (%u). Ignoring.", airtid + numinfo, NUM_AIRPORTTILES_PER_GRF);
04165     return CIR_INVALID_ID;
04166   }
04167 
04168   /* Allocate airport tile specs if they haven't been allocated already. */
04169   if (_cur.grffile->airtspec == NULL) {
04170     _cur.grffile->airtspec = CallocT<AirportTileSpec*>(NUM_AIRPORTTILES_PER_GRF);
04171   }
04172 
04173   for (int i = 0; i < numinfo; i++) {
04174     AirportTileSpec *tsp = _cur.grffile->airtspec[airtid + i];
04175 
04176     if (prop != 0x08 && tsp == NULL) {
04177       grfmsg(2, "AirportTileChangeInfo: Attempt to modify undefined airport tile %u. Ignoring.", airtid + i);
04178       return CIR_INVALID_ID;
04179     }
04180 
04181     switch (prop) {
04182       case 0x08: { // Substitute airport tile type
04183         AirportTileSpec **tilespec = &_cur.grffile->airtspec[airtid + i];
04184         byte subs_id = buf->ReadByte();
04185 
04186         if (subs_id >= NEW_AIRPORTTILE_OFFSET) {
04187           /* The substitute id must be one of the original airport tiles. */
04188           grfmsg(2, "AirportTileChangeInfo: Attempt to use new airport tile %u as substitute airport tile for %u. Ignoring.", subs_id, airtid + i);
04189           continue;
04190         }
04191 
04192         /* Allocate space for this airport tile. */
04193         if (*tilespec == NULL) {
04194           *tilespec = CallocT<AirportTileSpec>(1);
04195           tsp = *tilespec;
04196 
04197           memcpy(tsp, AirportTileSpec::Get(subs_id), sizeof(AirportTileSpec));
04198           tsp->enabled = true;
04199 
04200           tsp->animation.status = ANIM_STATUS_NO_ANIMATION;
04201 
04202           tsp->grf_prop.local_id = airtid + i;
04203           tsp->grf_prop.subst_id = subs_id;
04204           tsp->grf_prop.grffile = _cur.grffile;
04205           _airporttile_mngr.AddEntityID(airtid + i, _cur.grffile->grfid, subs_id); // pre-reserve the tile slot
04206         }
04207         break;
04208       }
04209 
04210       case 0x09: { // Airport tile override
04211         byte override = buf->ReadByte();
04212 
04213         /* The airport tile being overridden must be an original airport tile. */
04214         if (override >= NEW_AIRPORTTILE_OFFSET) {
04215           grfmsg(2, "AirportTileChangeInfo: Attempt to override new airport tile %u with airport tile id %u. Ignoring.", override, airtid + i);
04216           continue;
04217         }
04218 
04219         _airporttile_mngr.Add(airtid + i, _cur.grffile->grfid, override);
04220         break;
04221       }
04222 
04223       case 0x0E: // Callback mask
04224         tsp->callback_mask = buf->ReadByte();
04225         break;
04226 
04227       case 0x0F: // Animation information
04228         tsp->animation.frames = buf->ReadByte();
04229         tsp->animation.status = buf->ReadByte();
04230         break;
04231 
04232       case 0x10: // Animation speed
04233         tsp->animation.speed = buf->ReadByte();
04234         break;
04235 
04236       case 0x11: // Animation triggers
04237         tsp->animation.triggers = buf->ReadByte();
04238         break;
04239 
04240       default:
04241         ret = CIR_UNKNOWN;
04242         break;
04243     }
04244   }
04245 
04246   return ret;
04247 }
04248 
04249 static bool HandleChangeInfoResult(const char *caller, ChangeInfoResult cir, uint8 feature, uint8 property)
04250 {
04251   switch (cir) {
04252     default: NOT_REACHED();
04253 
04254     case CIR_DISABLED:
04255       /* Error has already been printed; just stop parsing */
04256       return true;
04257 
04258     case CIR_SUCCESS:
04259       return false;
04260 
04261     case CIR_UNHANDLED:
04262       grfmsg(1, "%s: Ignoring property 0x%02X of feature 0x%02X (not implemented)", caller, property, feature);
04263       return false;
04264 
04265     case CIR_UNKNOWN:
04266       grfmsg(0, "%s: Unknown property 0x%02X of feature 0x%02X, disabling", caller, property, feature);
04267       /* FALL THROUGH */
04268 
04269     case CIR_INVALID_ID: {
04270       /* No debug message for an invalid ID, as it has already been output */
04271       GRFError *error = DisableGrf(cir == CIR_INVALID_ID ? STR_NEWGRF_ERROR_INVALID_ID : STR_NEWGRF_ERROR_UNKNOWN_PROPERTY);
04272       if (cir != CIR_INVALID_ID) error->param_value[1] = property;
04273       return true;
04274     }
04275   }
04276 }
04277 
04278 /* Action 0x00 */
04279 static void FeatureChangeInfo(ByteReader *buf)
04280 {
04281   /* <00> <feature> <num-props> <num-info> <id> (<property <new-info>)...
04282    *
04283    * B feature
04284    * B num-props     how many properties to change per vehicle/station
04285    * B num-info      how many vehicles/stations to change
04286    * E id            ID of first vehicle/station to change, if num-info is
04287    *                 greater than one, this one and the following
04288    *                 vehicles/stations will be changed
04289    * B property      what property to change, depends on the feature
04290    * V new-info      new bytes of info (variable size; depends on properties) */
04291 
04292   static const VCI_Handler handler[] = {
04293     /* GSF_TRAINS */        RailVehicleChangeInfo,
04294     /* GSF_ROADVEHICLES */  RoadVehicleChangeInfo,
04295     /* GSF_SHIPS */         ShipVehicleChangeInfo,
04296     /* GSF_AIRCRAFT */      AircraftVehicleChangeInfo,
04297     /* GSF_STATIONS */      StationChangeInfo,
04298     /* GSF_CANALS */        CanalChangeInfo,
04299     /* GSF_BRIDGES */       BridgeChangeInfo,
04300     /* GSF_HOUSES */        TownHouseChangeInfo,
04301     /* GSF_GLOBALVAR */     GlobalVarChangeInfo,
04302     /* GSF_INDUSTRYTILES */ IndustrytilesChangeInfo,
04303     /* GSF_INDUSTRIES */    IndustriesChangeInfo,
04304     /* GSF_CARGOES */       NULL, // Cargo is handled during reservation
04305     /* GSF_SOUNDFX */       SoundEffectChangeInfo,
04306     /* GSF_AIRPORTS */      AirportChangeInfo,
04307     /* GSF_SIGNALS */       NULL,
04308     /* GSF_OBJECTS */       ObjectChangeInfo,
04309     /* GSF_RAILTYPES */     RailTypeChangeInfo,
04310     /* GSF_AIRPORTTILES */  AirportTilesChangeInfo,
04311   };
04312 
04313   uint8 feature  = buf->ReadByte();
04314   uint8 numprops = buf->ReadByte();
04315   uint numinfo  = buf->ReadByte();
04316   uint engine   = buf->ReadExtendedByte();
04317 
04318   grfmsg(6, "FeatureChangeInfo: feature %d, %d properties, to apply to %d+%d",
04319                  feature, numprops, engine, numinfo);
04320 
04321   if (feature >= lengthof(handler) || handler[feature] == NULL) {
04322     if (feature != GSF_CARGOES) grfmsg(1, "FeatureChangeInfo: Unsupported feature %d, skipping", feature);
04323     return;
04324   }
04325 
04326   /* Mark the feature as used by the grf */
04327   SetBit(_cur.grffile->grf_features, feature);
04328 
04329   while (numprops-- && buf->HasData()) {
04330     uint8 prop = buf->ReadByte();
04331 
04332     ChangeInfoResult cir = handler[feature](engine, numinfo, prop, buf);
04333     if (HandleChangeInfoResult("FeatureChangeInfo", cir, feature, prop)) return;
04334   }
04335 }
04336 
04337 /* Action 0x00 (GLS_SAFETYSCAN) */
04338 static void SafeChangeInfo(ByteReader *buf)
04339 {
04340   uint8 feature  = buf->ReadByte();
04341   uint8 numprops = buf->ReadByte();
04342   uint numinfo = buf->ReadByte();
04343   buf->ReadExtendedByte(); // id
04344 
04345   if (feature == GSF_BRIDGES && numprops == 1) {
04346     uint8 prop = buf->ReadByte();
04347     /* Bridge property 0x0D is redefinition of sprite layout tables, which
04348      * is considered safe. */
04349     if (prop == 0x0D) return;
04350   } else if (feature == GSF_GLOBALVAR && numprops == 1) {
04351     uint8 prop = buf->ReadByte();
04352     /* Engine ID Mappings are safe, if the source is static */
04353     if (prop == 0x11) {
04354       bool is_safe = true;
04355       for (uint i = 0; i < numinfo; i++) {
04356         uint32 s = buf->ReadDWord();
04357         buf->ReadDWord(); // dest
04358         const GRFConfig *grfconfig = GetGRFConfig(s);
04359         if (grfconfig != NULL && !HasBit(grfconfig->flags, GCF_STATIC)) {
04360           is_safe = false;
04361           break;
04362         }
04363       }
04364       if (is_safe) return;
04365     }
04366   }
04367 
04368   SetBit(_cur.grfconfig->flags, GCF_UNSAFE);
04369 
04370   /* Skip remainder of GRF */
04371   _cur.skip_sprites = -1;
04372 }
04373 
04374 /* Action 0x00 (GLS_RESERVE) */
04375 static void ReserveChangeInfo(ByteReader *buf)
04376 {
04377   uint8 feature  = buf->ReadByte();
04378 
04379   if (feature != GSF_CARGOES && feature != GSF_GLOBALVAR && feature != GSF_RAILTYPES) return;
04380 
04381   uint8 numprops = buf->ReadByte();
04382   uint8 numinfo  = buf->ReadByte();
04383   uint8 index    = buf->ReadExtendedByte();
04384 
04385   while (numprops-- && buf->HasData()) {
04386     uint8 prop = buf->ReadByte();
04387     ChangeInfoResult cir = CIR_SUCCESS;
04388 
04389     switch (feature) {
04390       default: NOT_REACHED();
04391       case GSF_CARGOES:
04392         cir = CargoChangeInfo(index, numinfo, prop, buf);
04393         break;
04394 
04395       case GSF_GLOBALVAR:
04396         cir = GlobalVarReserveInfo(index, numinfo, prop, buf);
04397         break;
04398 
04399       case GSF_RAILTYPES:
04400         cir = RailTypeReserveInfo(index, numinfo, prop, buf);
04401         break;
04402     }
04403 
04404     if (HandleChangeInfoResult("ReserveChangeInfo", cir, feature, prop)) return;
04405   }
04406 }
04407 
04408 /* Action 0x01 */
04409 static void NewSpriteSet(ByteReader *buf)
04410 {
04411   /* Basic format:    <01> <feature> <num-sets> <num-ent>
04412    * Extended format: <01> <feature> 00 <first-set> <num-sets> <num-ent>
04413    *
04414    * B feature       feature to define sprites for
04415    *                 0, 1, 2, 3: veh-type, 4: train stations
04416    * E first-set     first sprite set to define
04417    * B num-sets      number of sprite sets (extended byte in extended format)
04418    * E num-ent       how many entries per sprite set
04419    *                 For vehicles, this is the number of different
04420    *                         vehicle directions in each sprite set
04421    *                         Set num-dirs=8, unless your sprites are symmetric.
04422    *                         In that case, use num-dirs=4.
04423    */
04424 
04425   uint8  feature   = buf->ReadByte();
04426   uint16 num_sets  = buf->ReadByte();
04427   uint16 first_set = 0;
04428 
04429   if (num_sets == 0 && buf->HasData(3)) {
04430     /* Extended Action1 format.
04431      * Some GRFs define zero sets of zero sprites, though there is actually no use in that. Ignore them. */
04432     first_set = buf->ReadExtendedByte();
04433     num_sets = buf->ReadExtendedByte();
04434   }
04435   uint16 num_ents = buf->ReadExtendedByte();
04436 
04437   _cur.AddSpriteSets(feature, _cur.spriteid, first_set, num_sets, num_ents);
04438 
04439   grfmsg(7, "New sprite set at %d of type %d, consisting of %d sets with %d views each (total %d)",
04440     _cur.spriteid, feature, num_sets, num_ents, num_sets * num_ents
04441   );
04442 
04443   for (int i = 0; i < num_sets * num_ents; i++) {
04444     _cur.nfo_line++;
04445     LoadNextSprite(_cur.spriteid++, _cur.file_index, _cur.nfo_line, _cur.grf_container_ver);
04446   }
04447 }
04448 
04449 /* Action 0x01 (SKIP) */
04450 static void SkipAct1(ByteReader *buf)
04451 {
04452   buf->ReadByte();
04453   uint16 num_sets  = buf->ReadByte();
04454 
04455   if (num_sets == 0 && buf->HasData(3)) {
04456     /* Extended Action1 format.
04457      * Some GRFs define zero sets of zero sprites, though there is actually no use in that. Ignore them. */
04458     buf->ReadExtendedByte(); // first_set
04459     num_sets = buf->ReadExtendedByte();
04460   }
04461   uint16 num_ents = buf->ReadExtendedByte();
04462 
04463   _cur.skip_sprites = num_sets * num_ents;
04464 
04465   grfmsg(3, "SkipAct1: Skipping %d sprites", _cur.skip_sprites);
04466 }
04467 
04468 /* Helper function to either create a callback or link to a previously
04469  * defined spritegroup. */
04470 static const SpriteGroup *GetGroupFromGroupID(byte setid, byte type, uint16 groupid)
04471 {
04472   if (HasBit(groupid, 15)) {
04473     assert(CallbackResultSpriteGroup::CanAllocateItem());
04474     return new CallbackResultSpriteGroup(groupid, _cur.grffile->grf_version >= 8);
04475   }
04476 
04477   if (groupid > MAX_SPRITEGROUP || _cur.spritegroups[groupid] == NULL) {
04478     grfmsg(1, "GetGroupFromGroupID(0x%02X:0x%02X): Groupid 0x%04X does not exist, leaving empty", setid, type, groupid);
04479     return NULL;
04480   }
04481 
04482   return _cur.spritegroups[groupid];
04483 }
04484 
04493 static const SpriteGroup *CreateGroupFromGroupID(byte feature, byte setid, byte type, uint16 spriteid)
04494 {
04495   if (HasBit(spriteid, 15)) {
04496     assert(CallbackResultSpriteGroup::CanAllocateItem());
04497     return new CallbackResultSpriteGroup(spriteid, _cur.grffile->grf_version >= 8);
04498   }
04499 
04500   if (!_cur.IsValidSpriteSet(feature, spriteid)) {
04501     grfmsg(1, "CreateGroupFromGroupID(0x%02X:0x%02X): Sprite set %u invalid", setid, type, spriteid);
04502     return NULL;
04503   }
04504 
04505   SpriteID spriteset_start = _cur.GetSprite(feature, spriteid);
04506   uint num_sprites = _cur.GetNumEnts(feature, spriteid);
04507 
04508   /* Ensure that the sprites are loeded */
04509   assert(spriteset_start + num_sprites <= _cur.spriteid);
04510 
04511   assert(ResultSpriteGroup::CanAllocateItem());
04512   return new ResultSpriteGroup(spriteset_start, num_sprites);
04513 }
04514 
04515 /* Action 0x02 */
04516 static void NewSpriteGroup(ByteReader *buf)
04517 {
04518   /* <02> <feature> <set-id> <type/num-entries> <feature-specific-data...>
04519    *
04520    * B feature       see action 1
04521    * B set-id        ID of this particular definition
04522    * B type/num-entries
04523    *                 if 80 or greater, this is a randomized or variational
04524    *                 list definition, see below
04525    *                 otherwise it specifies a number of entries, the exact
04526    *                 meaning depends on the feature
04527    * V feature-specific-data (huge mess, don't even look it up --pasky) */
04528   SpriteGroup *act_group = NULL;
04529 
04530   uint8 feature = buf->ReadByte();
04531   uint8 setid   = buf->ReadByte();
04532   uint8 type    = buf->ReadByte();
04533 
04534   /* Sprite Groups are created here but they are allocated from a pool, so
04535    * we do not need to delete anything if there is an exception from the
04536    * ByteReader. */
04537 
04538   switch (type) {
04539     /* Deterministic Sprite Group */
04540     case 0x81: // Self scope, byte
04541     case 0x82: // Parent scope, byte
04542     case 0x85: // Self scope, word
04543     case 0x86: // Parent scope, word
04544     case 0x89: // Self scope, dword
04545     case 0x8A: // Parent scope, dword
04546     {
04547       byte varadjust;
04548       byte varsize;
04549 
04550       assert(DeterministicSpriteGroup::CanAllocateItem());
04551       DeterministicSpriteGroup *group = new DeterministicSpriteGroup();
04552       act_group = group;
04553       group->var_scope = HasBit(type, 1) ? VSG_SCOPE_PARENT : VSG_SCOPE_SELF;
04554 
04555       switch (GB(type, 2, 2)) {
04556         default: NOT_REACHED();
04557         case 0: group->size = DSG_SIZE_BYTE;  varsize = 1; break;
04558         case 1: group->size = DSG_SIZE_WORD;  varsize = 2; break;
04559         case 2: group->size = DSG_SIZE_DWORD; varsize = 4; break;
04560       }
04561 
04562       static SmallVector<DeterministicSpriteGroupAdjust, 16> adjusts;
04563       adjusts.Clear();
04564 
04565       /* Loop through the var adjusts. Unfortunately we don't know how many we have
04566        * from the outset, so we shall have to keep reallocing. */
04567       do {
04568         DeterministicSpriteGroupAdjust *adjust = adjusts.Append();
04569 
04570         /* The first var adjust doesn't have an operation specified, so we set it to add. */
04571         adjust->operation = adjusts.Length() == 1 ? DSGA_OP_ADD : (DeterministicSpriteGroupAdjustOperation)buf->ReadByte();
04572         adjust->variable  = buf->ReadByte();
04573         if (adjust->variable == 0x7E) {
04574           /* Link subroutine group */
04575           adjust->subroutine = GetGroupFromGroupID(setid, type, buf->ReadByte());
04576         } else {
04577           adjust->parameter = IsInsideMM(adjust->variable, 0x60, 0x80) ? buf->ReadByte() : 0;
04578         }
04579 
04580         varadjust = buf->ReadByte();
04581         adjust->shift_num = GB(varadjust, 0, 5);
04582         adjust->type      = (DeterministicSpriteGroupAdjustType)GB(varadjust, 6, 2);
04583         adjust->and_mask  = buf->ReadVarSize(varsize);
04584 
04585         if (adjust->type != DSGA_TYPE_NONE) {
04586           adjust->add_val    = buf->ReadVarSize(varsize);
04587           adjust->divmod_val = buf->ReadVarSize(varsize);
04588         } else {
04589           adjust->add_val    = 0;
04590           adjust->divmod_val = 0;
04591         }
04592 
04593         /* Continue reading var adjusts while bit 5 is set. */
04594       } while (HasBit(varadjust, 5));
04595 
04596       group->num_adjusts = adjusts.Length();
04597       group->adjusts = MallocT<DeterministicSpriteGroupAdjust>(group->num_adjusts);
04598       MemCpyT(group->adjusts, adjusts.Begin(), group->num_adjusts);
04599 
04600       group->num_ranges = buf->ReadByte();
04601       if (group->num_ranges > 0) group->ranges = CallocT<DeterministicSpriteGroupRange>(group->num_ranges);
04602 
04603       for (uint i = 0; i < group->num_ranges; i++) {
04604         group->ranges[i].group = GetGroupFromGroupID(setid, type, buf->ReadWord());
04605         group->ranges[i].low   = buf->ReadVarSize(varsize);
04606         group->ranges[i].high  = buf->ReadVarSize(varsize);
04607       }
04608 
04609       group->default_group = GetGroupFromGroupID(setid, type, buf->ReadWord());
04610       break;
04611     }
04612 
04613     /* Randomized Sprite Group */
04614     case 0x80: // Self scope
04615     case 0x83: // Parent scope
04616     case 0x84: // Relative scope
04617     {
04618       assert(RandomizedSpriteGroup::CanAllocateItem());
04619       RandomizedSpriteGroup *group = new RandomizedSpriteGroup();
04620       act_group = group;
04621       group->var_scope = HasBit(type, 1) ? VSG_SCOPE_PARENT : VSG_SCOPE_SELF;
04622 
04623       if (HasBit(type, 2)) {
04624         if (feature <= GSF_AIRCRAFT) group->var_scope = VSG_SCOPE_RELATIVE;
04625         group->count = buf->ReadByte();
04626       }
04627 
04628       uint8 triggers = buf->ReadByte();
04629       group->triggers       = GB(triggers, 0, 7);
04630       group->cmp_mode       = HasBit(triggers, 7) ? RSG_CMP_ALL : RSG_CMP_ANY;
04631       group->lowest_randbit = buf->ReadByte();
04632       group->num_groups     = buf->ReadByte();
04633       group->groups = CallocT<const SpriteGroup*>(group->num_groups);
04634 
04635       for (uint i = 0; i < group->num_groups; i++) {
04636         group->groups[i] = GetGroupFromGroupID(setid, type, buf->ReadWord());
04637       }
04638 
04639       break;
04640     }
04641 
04642     /* Neither a variable or randomized sprite group... must be a real group */
04643     default:
04644     {
04645       switch (feature) {
04646         case GSF_TRAINS:
04647         case GSF_ROADVEHICLES:
04648         case GSF_SHIPS:
04649         case GSF_AIRCRAFT:
04650         case GSF_STATIONS:
04651         case GSF_CANALS:
04652         case GSF_CARGOES:
04653         case GSF_AIRPORTS:
04654         case GSF_RAILTYPES:
04655         {
04656           byte num_loaded  = type;
04657           byte num_loading = buf->ReadByte();
04658 
04659           if (!_cur.HasValidSpriteSets(feature)) {
04660             grfmsg(0, "NewSpriteGroup: No sprite set to work on! Skipping");
04661             return;
04662           }
04663 
04664           assert(RealSpriteGroup::CanAllocateItem());
04665           RealSpriteGroup *group = new RealSpriteGroup();
04666           act_group = group;
04667 
04668           group->num_loaded  = num_loaded;
04669           group->num_loading = num_loading;
04670           if (num_loaded  > 0) group->loaded = CallocT<const SpriteGroup*>(num_loaded);
04671           if (num_loading > 0) group->loading = CallocT<const SpriteGroup*>(num_loading);
04672 
04673           grfmsg(6, "NewSpriteGroup: New SpriteGroup 0x%02X, %u loaded, %u loading",
04674               setid, num_loaded, num_loading);
04675 
04676           for (uint i = 0; i < num_loaded; i++) {
04677             uint16 spriteid = buf->ReadWord();
04678             group->loaded[i] = CreateGroupFromGroupID(feature, setid, type, spriteid);
04679             grfmsg(8, "NewSpriteGroup: + rg->loaded[%i]  = subset %u", i, spriteid);
04680           }
04681 
04682           for (uint i = 0; i < num_loading; i++) {
04683             uint16 spriteid = buf->ReadWord();
04684             group->loading[i] = CreateGroupFromGroupID(feature, setid, type, spriteid);
04685             grfmsg(8, "NewSpriteGroup: + rg->loading[%i] = subset %u", i, spriteid);
04686           }
04687 
04688           break;
04689         }
04690 
04691         case GSF_HOUSES:
04692         case GSF_AIRPORTTILES:
04693         case GSF_OBJECTS:
04694         case GSF_INDUSTRYTILES: {
04695           byte num_building_sprites = max((uint8)1, type);
04696 
04697           assert(TileLayoutSpriteGroup::CanAllocateItem());
04698           TileLayoutSpriteGroup *group = new TileLayoutSpriteGroup();
04699           act_group = group;
04700 
04701           /* On error, bail out immediately. Temporary GRF data was already freed */
04702           if (ReadSpriteLayout(buf, num_building_sprites, true, feature, false, type == 0, &group->dts)) return;
04703           break;
04704         }
04705 
04706         case GSF_INDUSTRIES: {
04707           if (type > 1) {
04708             grfmsg(1, "NewSpriteGroup: Unsupported industry production version %d, skipping", type);
04709             break;
04710           }
04711 
04712           assert(IndustryProductionSpriteGroup::CanAllocateItem());
04713           IndustryProductionSpriteGroup *group = new IndustryProductionSpriteGroup();
04714           act_group = group;
04715           group->version = type;
04716           if (type == 0) {
04717             for (uint i = 0; i < 3; i++) {
04718               group->subtract_input[i] = (int16)buf->ReadWord(); // signed
04719             }
04720             for (uint i = 0; i < 2; i++) {
04721               group->add_output[i] = buf->ReadWord(); // unsigned
04722             }
04723             group->again = buf->ReadByte();
04724           } else {
04725             for (uint i = 0; i < 3; i++) {
04726               group->subtract_input[i] = buf->ReadByte();
04727             }
04728             for (uint i = 0; i < 2; i++) {
04729               group->add_output[i] = buf->ReadByte();
04730             }
04731             group->again = buf->ReadByte();
04732           }
04733           break;
04734         }
04735 
04736         /* Loading of Tile Layout and Production Callback groups would happen here */
04737         default: grfmsg(1, "NewSpriteGroup: Unsupported feature %d, skipping", feature);
04738       }
04739     }
04740   }
04741 
04742   _cur.spritegroups[setid] = act_group;
04743 }
04744 
04745 static CargoID TranslateCargo(uint8 feature, uint8 ctype)
04746 {
04747   if (feature == GSF_OBJECTS) {
04748     switch (ctype) {
04749       case 0:    return 0;
04750       case 0xFF: return CT_PURCHASE_OBJECT;
04751       default:
04752         grfmsg(1, "TranslateCargo: Invalid cargo bitnum %d for objects, skipping.", ctype);
04753         return CT_INVALID;
04754     }
04755   }
04756   /* Special cargo types for purchase list and stations */
04757   if (feature == GSF_STATIONS && ctype == 0xFE) return CT_DEFAULT_NA;
04758   if (ctype == 0xFF) return CT_PURCHASE;
04759 
04760   if (_cur.grffile->cargo_list.Length() == 0) {
04761     /* No cargo table, so use bitnum values */
04762     if (ctype >= 32) {
04763       grfmsg(1, "TranslateCargo: Cargo bitnum %d out of range (max 31), skipping.", ctype);
04764       return CT_INVALID;
04765     }
04766 
04767     const CargoSpec *cs;
04768     FOR_ALL_CARGOSPECS(cs) {
04769       if (cs->bitnum == ctype) {
04770         grfmsg(6, "TranslateCargo: Cargo bitnum %d mapped to cargo type %d.", ctype, cs->Index());
04771         return cs->Index();
04772       }
04773     }
04774 
04775     grfmsg(5, "TranslateCargo: Cargo bitnum %d not available in this climate, skipping.", ctype);
04776     return CT_INVALID;
04777   }
04778 
04779   /* Check if the cargo type is out of bounds of the cargo translation table */
04780   if (ctype >= _cur.grffile->cargo_list.Length()) {
04781     grfmsg(1, "TranslateCargo: Cargo type %d out of range (max %d), skipping.", ctype, _cur.grffile->cargo_list.Length() - 1);
04782     return CT_INVALID;
04783   }
04784 
04785   /* Look up the cargo label from the translation table */
04786   CargoLabel cl = _cur.grffile->cargo_list[ctype];
04787   if (cl == 0) {
04788     grfmsg(5, "TranslateCargo: Cargo type %d not available in this climate, skipping.", ctype);
04789     return CT_INVALID;
04790   }
04791 
04792   ctype = GetCargoIDByLabel(cl);
04793   if (ctype == CT_INVALID) {
04794     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));
04795     return CT_INVALID;
04796   }
04797 
04798   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);
04799   return ctype;
04800 }
04801 
04802 
04803 static bool IsValidGroupID(uint16 groupid, const char *function)
04804 {
04805   if (groupid > MAX_SPRITEGROUP || _cur.spritegroups[groupid] == NULL) {
04806     grfmsg(1, "%s: Spritegroup 0x%04X out of range or empty, skipping.", function, groupid);
04807     return false;
04808   }
04809 
04810   return true;
04811 }
04812 
04813 static void VehicleMapSpriteGroup(ByteReader *buf, byte feature, uint8 idcount)
04814 {
04815   static EngineID *last_engines;
04816   static uint last_engines_count;
04817   bool wagover = false;
04818 
04819   /* Test for 'wagon override' flag */
04820   if (HasBit(idcount, 7)) {
04821     wagover = true;
04822     /* Strip off the flag */
04823     idcount = GB(idcount, 0, 7);
04824 
04825     if (last_engines_count == 0) {
04826       grfmsg(0, "VehicleMapSpriteGroup: WagonOverride: No engine to do override with");
04827       return;
04828     }
04829 
04830     grfmsg(6, "VehicleMapSpriteGroup: WagonOverride: %u engines, %u wagons",
04831         last_engines_count, idcount);
04832   } else {
04833     if (last_engines_count != idcount) {
04834       last_engines = ReallocT(last_engines, idcount);
04835       last_engines_count = idcount;
04836     }
04837   }
04838 
04839   EngineID *engines = AllocaM(EngineID, idcount);
04840   for (uint i = 0; i < idcount; i++) {
04841     Engine *e = GetNewEngine(_cur.grffile, (VehicleType)feature, buf->ReadExtendedByte());
04842     if (e == NULL) {
04843       /* No engine could be allocated?!? Deal with it. Okay,
04844        * this might look bad. Also make sure this NewGRF
04845        * gets disabled, as a half loaded one is bad. */
04846       HandleChangeInfoResult("VehicleMapSpriteGroup", CIR_INVALID_ID, 0, 0);
04847       return;
04848     }
04849 
04850     engines[i] = e->index;
04851     if (!wagover) last_engines[i] = engines[i];
04852   }
04853 
04854   uint8 cidcount = buf->ReadByte();
04855   for (uint c = 0; c < cidcount; c++) {
04856     uint8 ctype = buf->ReadByte();
04857     uint16 groupid = buf->ReadWord();
04858     if (!IsValidGroupID(groupid, "VehicleMapSpriteGroup")) continue;
04859 
04860     grfmsg(8, "VehicleMapSpriteGroup: * [%d] Cargo type 0x%X, group id 0x%02X", c, ctype, groupid);
04861 
04862     ctype = TranslateCargo(feature, ctype);
04863     if (ctype == CT_INVALID) continue;
04864 
04865     for (uint i = 0; i < idcount; i++) {
04866       EngineID engine = engines[i];
04867 
04868       grfmsg(7, "VehicleMapSpriteGroup: [%d] Engine %d...", i, engine);
04869 
04870       if (wagover) {
04871         SetWagonOverrideSprites(engine, ctype, _cur.spritegroups[groupid], last_engines, last_engines_count);
04872       } else {
04873         SetCustomEngineSprites(engine, ctype, _cur.spritegroups[groupid]);
04874       }
04875     }
04876   }
04877 
04878   uint16 groupid = buf->ReadWord();
04879   if (!IsValidGroupID(groupid, "VehicleMapSpriteGroup")) return;
04880 
04881   grfmsg(8, "-- Default group id 0x%04X", groupid);
04882 
04883   for (uint i = 0; i < idcount; i++) {
04884     EngineID engine = engines[i];
04885 
04886     if (wagover) {
04887       SetWagonOverrideSprites(engine, CT_DEFAULT, _cur.spritegroups[groupid], last_engines, last_engines_count);
04888     } else {
04889       SetCustomEngineSprites(engine, CT_DEFAULT, _cur.spritegroups[groupid]);
04890       SetEngineGRF(engine, _cur.grffile);
04891     }
04892   }
04893 }
04894 
04895 
04896 static void CanalMapSpriteGroup(ByteReader *buf, uint8 idcount)
04897 {
04898   CanalFeature *cfs = AllocaM(CanalFeature, idcount);
04899   for (uint i = 0; i < idcount; i++) {
04900     cfs[i] = (CanalFeature)buf->ReadByte();
04901   }
04902 
04903   uint8 cidcount = buf->ReadByte();
04904   buf->Skip(cidcount * 3);
04905 
04906   uint16 groupid = buf->ReadWord();
04907   if (!IsValidGroupID(groupid, "CanalMapSpriteGroup")) return;
04908 
04909   for (uint i = 0; i < idcount; i++) {
04910     CanalFeature cf = cfs[i];
04911 
04912     if (cf >= CF_END) {
04913       grfmsg(1, "CanalMapSpriteGroup: Canal subset %d out of range, skipping", cf);
04914       continue;
04915     }
04916 
04917     _water_feature[cf].grffile = _cur.grffile;
04918     _water_feature[cf].group = _cur.spritegroups[groupid];
04919   }
04920 }
04921 
04922 
04923 static void StationMapSpriteGroup(ByteReader *buf, uint8 idcount)
04924 {
04925   uint8 *stations = AllocaM(uint8, idcount);
04926   for (uint i = 0; i < idcount; i++) {
04927     stations[i] = buf->ReadByte();
04928   }
04929 
04930   uint8 cidcount = buf->ReadByte();
04931   for (uint c = 0; c < cidcount; c++) {
04932     uint8 ctype = buf->ReadByte();
04933     uint16 groupid = buf->ReadWord();
04934     if (!IsValidGroupID(groupid, "StationMapSpriteGroup")) continue;
04935 
04936     ctype = TranslateCargo(GSF_STATIONS, ctype);
04937     if (ctype == CT_INVALID) continue;
04938 
04939     for (uint i = 0; i < idcount; i++) {
04940       StationSpec *statspec = _cur.grffile->stations == NULL ? NULL : _cur.grffile->stations[stations[i]];
04941 
04942       if (statspec == NULL) {
04943         grfmsg(1, "StationMapSpriteGroup: Station with ID 0x%02X does not exist, skipping", stations[i]);
04944         continue;
04945       }
04946 
04947       statspec->grf_prop.spritegroup[ctype] = _cur.spritegroups[groupid];
04948     }
04949   }
04950 
04951   uint16 groupid = buf->ReadWord();
04952   if (!IsValidGroupID(groupid, "StationMapSpriteGroup")) return;
04953 
04954   for (uint i = 0; i < idcount; i++) {
04955     StationSpec *statspec = _cur.grffile->stations == NULL ? NULL : _cur.grffile->stations[stations[i]];
04956 
04957     if (statspec == NULL) {
04958       grfmsg(1, "StationMapSpriteGroup: Station with ID 0x%02X does not exist, skipping", stations[i]);
04959       continue;
04960     }
04961 
04962     if (statspec->grf_prop.grffile != NULL) {
04963       grfmsg(1, "StationMapSpriteGroup: Station with ID 0x%02X mapped multiple times, skipping", stations[i]);
04964       continue;
04965     }
04966 
04967     statspec->grf_prop.spritegroup[CT_DEFAULT] = _cur.spritegroups[groupid];
04968     statspec->grf_prop.grffile = _cur.grffile;
04969     statspec->grf_prop.local_id = stations[i];
04970     StationClass::Assign(statspec);
04971   }
04972 }
04973 
04974 
04975 static void TownHouseMapSpriteGroup(ByteReader *buf, uint8 idcount)
04976 {
04977   uint8 *houses = AllocaM(uint8, idcount);
04978   for (uint i = 0; i < idcount; i++) {
04979     houses[i] = buf->ReadByte();
04980   }
04981 
04982   /* Skip the cargo type section, we only care about the default group */
04983   uint8 cidcount = buf->ReadByte();
04984   buf->Skip(cidcount * 3);
04985 
04986   uint16 groupid = buf->ReadWord();
04987   if (!IsValidGroupID(groupid, "TownHouseMapSpriteGroup")) return;
04988 
04989   if (_cur.grffile->housespec == NULL) {
04990     grfmsg(1, "TownHouseMapSpriteGroup: No houses defined, skipping");
04991     return;
04992   }
04993 
04994   for (uint i = 0; i < idcount; i++) {
04995     HouseSpec *hs = _cur.grffile->housespec[houses[i]];
04996 
04997     if (hs == NULL) {
04998       grfmsg(1, "TownHouseMapSpriteGroup: House %d undefined, skipping.", houses[i]);
04999       continue;
05000     }
05001 
05002     hs->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
05003   }
05004 }
05005 
05006 static void IndustryMapSpriteGroup(ByteReader *buf, uint8 idcount)
05007 {
05008   uint8 *industries = AllocaM(uint8, idcount);
05009   for (uint i = 0; i < idcount; i++) {
05010     industries[i] = buf->ReadByte();
05011   }
05012 
05013   /* Skip the cargo type section, we only care about the default group */
05014   uint8 cidcount = buf->ReadByte();
05015   buf->Skip(cidcount * 3);
05016 
05017   uint16 groupid = buf->ReadWord();
05018   if (!IsValidGroupID(groupid, "IndustryMapSpriteGroup")) return;
05019 
05020   if (_cur.grffile->industryspec == NULL) {
05021     grfmsg(1, "IndustryMapSpriteGroup: No industries defined, skipping");
05022     return;
05023   }
05024 
05025   for (uint i = 0; i < idcount; i++) {
05026     IndustrySpec *indsp = _cur.grffile->industryspec[industries[i]];
05027 
05028     if (indsp == NULL) {
05029       grfmsg(1, "IndustryMapSpriteGroup: Industry %d undefined, skipping", industries[i]);
05030       continue;
05031     }
05032 
05033     indsp->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
05034   }
05035 }
05036 
05037 static void IndustrytileMapSpriteGroup(ByteReader *buf, uint8 idcount)
05038 {
05039   uint8 *indtiles = AllocaM(uint8, idcount);
05040   for (uint i = 0; i < idcount; i++) {
05041     indtiles[i] = buf->ReadByte();
05042   }
05043 
05044   /* Skip the cargo type section, we only care about the default group */
05045   uint8 cidcount = buf->ReadByte();
05046   buf->Skip(cidcount * 3);
05047 
05048   uint16 groupid = buf->ReadWord();
05049   if (!IsValidGroupID(groupid, "IndustrytileMapSpriteGroup")) return;
05050 
05051   if (_cur.grffile->indtspec == NULL) {
05052     grfmsg(1, "IndustrytileMapSpriteGroup: No industry tiles defined, skipping");
05053     return;
05054   }
05055 
05056   for (uint i = 0; i < idcount; i++) {
05057     IndustryTileSpec *indtsp = _cur.grffile->indtspec[indtiles[i]];
05058 
05059     if (indtsp == NULL) {
05060       grfmsg(1, "IndustrytileMapSpriteGroup: Industry tile %d undefined, skipping", indtiles[i]);
05061       continue;
05062     }
05063 
05064     indtsp->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
05065   }
05066 }
05067 
05068 static void CargoMapSpriteGroup(ByteReader *buf, uint8 idcount)
05069 {
05070   CargoID *cargoes = AllocaM(CargoID, idcount);
05071   for (uint i = 0; i < idcount; i++) {
05072     cargoes[i] = buf->ReadByte();
05073   }
05074 
05075   /* Skip the cargo type section, we only care about the default group */
05076   uint8 cidcount = buf->ReadByte();
05077   buf->Skip(cidcount * 3);
05078 
05079   uint16 groupid = buf->ReadWord();
05080   if (!IsValidGroupID(groupid, "CargoMapSpriteGroup")) return;
05081 
05082   for (uint i = 0; i < idcount; i++) {
05083     CargoID cid = cargoes[i];
05084 
05085     if (cid >= NUM_CARGO) {
05086       grfmsg(1, "CargoMapSpriteGroup: Cargo ID %d out of range, skipping", cid);
05087       continue;
05088     }
05089 
05090     CargoSpec *cs = CargoSpec::Get(cid);
05091     cs->grffile = _cur.grffile;
05092     cs->group = _cur.spritegroups[groupid];
05093   }
05094 }
05095 
05096 static void ObjectMapSpriteGroup(ByteReader *buf, uint8 idcount)
05097 {
05098   if (_cur.grffile->objectspec == NULL) {
05099     grfmsg(1, "ObjectMapSpriteGroup: No object tiles defined, skipping");
05100     return;
05101   }
05102 
05103   uint8 *objects = AllocaM(uint8, idcount);
05104   for (uint i = 0; i < idcount; i++) {
05105     objects[i] = buf->ReadByte();
05106   }
05107 
05108   uint8 cidcount = buf->ReadByte();
05109   for (uint c = 0; c < cidcount; c++) {
05110     uint8 ctype = buf->ReadByte();
05111     uint16 groupid = buf->ReadWord();
05112     if (!IsValidGroupID(groupid, "ObjectMapSpriteGroup")) continue;
05113 
05114     ctype = TranslateCargo(GSF_OBJECTS, ctype);
05115     if (ctype == CT_INVALID) continue;
05116 
05117     for (uint i = 0; i < idcount; i++) {
05118       ObjectSpec *spec = _cur.grffile->objectspec[objects[i]];
05119 
05120       if (spec == NULL) {
05121         grfmsg(1, "ObjectMapSpriteGroup: Object with ID 0x%02X undefined, skipping", objects[i]);
05122         continue;
05123       }
05124 
05125       spec->grf_prop.spritegroup[ctype] = _cur.spritegroups[groupid];
05126     }
05127   }
05128 
05129   uint16 groupid = buf->ReadWord();
05130   if (!IsValidGroupID(groupid, "ObjectMapSpriteGroup")) return;
05131 
05132   for (uint i = 0; i < idcount; i++) {
05133     ObjectSpec *spec = _cur.grffile->objectspec[objects[i]];
05134 
05135     if (spec == NULL) {
05136       grfmsg(1, "ObjectMapSpriteGroup: Object with ID 0x%02X undefined, skipping", objects[i]);
05137       continue;
05138     }
05139 
05140     if (spec->grf_prop.grffile != NULL) {
05141       grfmsg(1, "ObjectMapSpriteGroup: Object with ID 0x%02X mapped multiple times, skipping", objects[i]);
05142       continue;
05143     }
05144 
05145     spec->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
05146     spec->grf_prop.grffile        = _cur.grffile;
05147     spec->grf_prop.local_id       = objects[i];
05148   }
05149 }
05150 
05151 static void RailTypeMapSpriteGroup(ByteReader *buf, uint8 idcount)
05152 {
05153   uint8 *railtypes = AllocaM(uint8, idcount);
05154   for (uint i = 0; i < idcount; i++) {
05155     railtypes[i] = _cur.grffile->railtype_map[buf->ReadByte()];
05156   }
05157 
05158   uint8 cidcount = buf->ReadByte();
05159   for (uint c = 0; c < cidcount; c++) {
05160     uint8 ctype = buf->ReadByte();
05161     uint16 groupid = buf->ReadWord();
05162     if (!IsValidGroupID(groupid, "RailTypeMapSpriteGroup")) continue;
05163 
05164     if (ctype >= RTSG_END) continue;
05165 
05166     extern RailtypeInfo _railtypes[RAILTYPE_END];
05167     for (uint i = 0; i < idcount; i++) {
05168       if (railtypes[i] != INVALID_RAILTYPE) {
05169         RailtypeInfo *rti = &_railtypes[railtypes[i]];
05170 
05171         rti->grffile[ctype] = _cur.grffile;
05172         rti->group[ctype] = _cur.spritegroups[groupid];
05173       }
05174     }
05175   }
05176 
05177   /* Railtypes do not use the default group. */
05178   buf->ReadWord();
05179 }
05180 
05181 static void AirportMapSpriteGroup(ByteReader *buf, uint8 idcount)
05182 {
05183   uint8 *airports = AllocaM(uint8, idcount);
05184   for (uint i = 0; i < idcount; i++) {
05185     airports[i] = buf->ReadByte();
05186   }
05187 
05188   /* Skip the cargo type section, we only care about the default group */
05189   uint8 cidcount = buf->ReadByte();
05190   buf->Skip(cidcount * 3);
05191 
05192   uint16 groupid = buf->ReadWord();
05193   if (!IsValidGroupID(groupid, "AirportMapSpriteGroup")) return;
05194 
05195   if (_cur.grffile->airportspec == NULL) {
05196     grfmsg(1, "AirportMapSpriteGroup: No airports defined, skipping");
05197     return;
05198   }
05199 
05200   for (uint i = 0; i < idcount; i++) {
05201     AirportSpec *as = _cur.grffile->airportspec[airports[i]];
05202 
05203     if (as == NULL) {
05204       grfmsg(1, "AirportMapSpriteGroup: Airport %d undefined, skipping", airports[i]);
05205       continue;
05206     }
05207 
05208     as->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
05209   }
05210 }
05211 
05212 static void AirportTileMapSpriteGroup(ByteReader *buf, uint8 idcount)
05213 {
05214   uint8 *airptiles = AllocaM(uint8, idcount);
05215   for (uint i = 0; i < idcount; i++) {
05216     airptiles[i] = buf->ReadByte();
05217   }
05218 
05219   /* Skip the cargo type section, we only care about the default group */
05220   uint8 cidcount = buf->ReadByte();
05221   buf->Skip(cidcount * 3);
05222 
05223   uint16 groupid = buf->ReadWord();
05224   if (!IsValidGroupID(groupid, "AirportTileMapSpriteGroup")) return;
05225 
05226   if (_cur.grffile->airtspec == NULL) {
05227     grfmsg(1, "AirportTileMapSpriteGroup: No airport tiles defined, skipping");
05228     return;
05229   }
05230 
05231   for (uint i = 0; i < idcount; i++) {
05232     AirportTileSpec *airtsp = _cur.grffile->airtspec[airptiles[i]];
05233 
05234     if (airtsp == NULL) {
05235       grfmsg(1, "AirportTileMapSpriteGroup: Airport tile %d undefined, skipping", airptiles[i]);
05236       continue;
05237     }
05238 
05239     airtsp->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
05240   }
05241 }
05242 
05243 
05244 /* Action 0x03 */
05245 static void FeatureMapSpriteGroup(ByteReader *buf)
05246 {
05247   /* <03> <feature> <n-id> <ids>... <num-cid> [<cargo-type> <cid>]... <def-cid>
05248    * id-list    := [<id>] [id-list]
05249    * cargo-list := <cargo-type> <cid> [cargo-list]
05250    *
05251    * B feature       see action 0
05252    * B n-id          bits 0-6: how many IDs this definition applies to
05253    *                 bit 7: if set, this is a wagon override definition (see below)
05254    * B ids           the IDs for which this definition applies
05255    * B num-cid       number of cargo IDs (sprite group IDs) in this definition
05256    *                 can be zero, in that case the def-cid is used always
05257    * B cargo-type    type of this cargo type (e.g. mail=2, wood=7, see below)
05258    * W cid           cargo ID (sprite group ID) for this type of cargo
05259    * W def-cid       default cargo ID (sprite group ID) */
05260 
05261   uint8 feature = buf->ReadByte();
05262   uint8 idcount = buf->ReadByte();
05263 
05264   /* If idcount is zero, this is a feature callback */
05265   if (idcount == 0) {
05266     /* Skip number of cargo ids? */
05267     buf->ReadByte();
05268     uint16 groupid = buf->ReadWord();
05269     if (!IsValidGroupID(groupid, "FeatureMapSpriteGroup")) return;
05270 
05271     grfmsg(6, "FeatureMapSpriteGroup: Adding generic feature callback for feature %d", feature);
05272 
05273     AddGenericCallback(feature, _cur.grffile, _cur.spritegroups[groupid]);
05274     return;
05275   }
05276 
05277   /* Mark the feature as used by the grf (generic callbacks do not count) */
05278   SetBit(_cur.grffile->grf_features, feature);
05279 
05280   grfmsg(6, "FeatureMapSpriteGroup: Feature %d, %d ids", feature, idcount);
05281 
05282   switch (feature) {
05283     case GSF_TRAINS:
05284     case GSF_ROADVEHICLES:
05285     case GSF_SHIPS:
05286     case GSF_AIRCRAFT:
05287       VehicleMapSpriteGroup(buf, feature, idcount);
05288       return;
05289 
05290     case GSF_CANALS:
05291       CanalMapSpriteGroup(buf, idcount);
05292       return;
05293 
05294     case GSF_STATIONS:
05295       StationMapSpriteGroup(buf, idcount);
05296       return;
05297 
05298     case GSF_HOUSES:
05299       TownHouseMapSpriteGroup(buf, idcount);
05300       return;
05301 
05302     case GSF_INDUSTRIES:
05303       IndustryMapSpriteGroup(buf, idcount);
05304       return;
05305 
05306     case GSF_INDUSTRYTILES:
05307       IndustrytileMapSpriteGroup(buf, idcount);
05308       return;
05309 
05310     case GSF_CARGOES:
05311       CargoMapSpriteGroup(buf, idcount);
05312       return;
05313 
05314     case GSF_AIRPORTS:
05315       AirportMapSpriteGroup(buf, idcount);
05316       return;
05317 
05318     case GSF_OBJECTS:
05319       ObjectMapSpriteGroup(buf, idcount);
05320       break;
05321 
05322     case GSF_RAILTYPES:
05323       RailTypeMapSpriteGroup(buf, idcount);
05324       break;
05325 
05326     case GSF_AIRPORTTILES:
05327       AirportTileMapSpriteGroup(buf, idcount);
05328       return;
05329 
05330     default:
05331       grfmsg(1, "FeatureMapSpriteGroup: Unsupported feature %d, skipping", feature);
05332       return;
05333   }
05334 }
05335 
05336 /* Action 0x04 */
05337 static void FeatureNewName(ByteReader *buf)
05338 {
05339   /* <04> <veh-type> <language-id> <num-veh> <offset> <data...>
05340    *
05341    * B veh-type      see action 0 (as 00..07, + 0A
05342    *                 But IF veh-type = 48, then generic text
05343    * B language-id   If bit 6 is set, This is the extended language scheme,
05344    *                 with up to 64 language.
05345    *                 Otherwise, it is a mapping where set bits have meaning
05346    *                 0 = american, 1 = english, 2 = german, 3 = french, 4 = spanish
05347    *                 Bit 7 set means this is a generic text, not a vehicle one (or else)
05348    * B num-veh       number of vehicles which are getting a new name
05349    * B/W offset      number of the first vehicle that gets a new name
05350    *                 Byte : ID of vehicle to change
05351    *                 Word : ID of string to change/add
05352    * S data          new texts, each of them zero-terminated, after
05353    *                 which the next name begins. */
05354 
05355   bool new_scheme = _cur.grffile->grf_version >= 7;
05356 
05357   uint8 feature  = buf->ReadByte();
05358   uint8 lang     = buf->ReadByte();
05359   uint8 num      = buf->ReadByte();
05360   bool generic   = HasBit(lang, 7);
05361   uint16 id;
05362   if (generic) {
05363     id = buf->ReadWord();
05364   } else if (feature <= GSF_AIRCRAFT) {
05365     id = buf->ReadExtendedByte();
05366   } else {
05367     id = buf->ReadByte();
05368   }
05369 
05370   ClrBit(lang, 7);
05371 
05372   uint16 endid = id + num;
05373 
05374   grfmsg(6, "FeatureNewName: About to rename engines %d..%d (feature %d) in language 0x%02X",
05375                  id, endid, feature, lang);
05376 
05377   for (; id < endid && buf->HasData(); id++) {
05378     const char *name = buf->ReadString();
05379     grfmsg(8, "FeatureNewName: 0x%04X <- %s", id, name);
05380 
05381     switch (feature) {
05382       case GSF_TRAINS:
05383       case GSF_ROADVEHICLES:
05384       case GSF_SHIPS:
05385       case GSF_AIRCRAFT:
05386         if (!generic) {
05387           Engine *e = GetNewEngine(_cur.grffile, (VehicleType)feature, id, HasBit(_cur.grfconfig->flags, GCF_STATIC));
05388           if (e == NULL) break;
05389           StringID string = AddGRFString(_cur.grffile->grfid, e->index, lang, new_scheme, false, name, e->info.string_id);
05390           e->info.string_id = string;
05391         } else {
05392           AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, true, name, STR_UNDEFINED);
05393         }
05394         break;
05395 
05396       case GSF_INDUSTRIES: {
05397         AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, true, name, STR_UNDEFINED);
05398         break;
05399       }
05400 
05401       case GSF_HOUSES:
05402       default:
05403         switch (GB(id, 8, 8)) {
05404           case 0xC4: // Station class name
05405             if (_cur.grffile->stations == NULL || _cur.grffile->stations[GB(id, 0, 8)] == NULL) {
05406               grfmsg(1, "FeatureNewName: Attempt to name undefined station 0x%X, ignoring", GB(id, 0, 8));
05407             } else {
05408               StationClassID cls_id = _cur.grffile->stations[GB(id, 0, 8)]->cls_id;
05409               StationClass::Get(cls_id)->name = AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
05410             }
05411             break;
05412 
05413           case 0xC5: // Station name
05414             if (_cur.grffile->stations == NULL || _cur.grffile->stations[GB(id, 0, 8)] == NULL) {
05415               grfmsg(1, "FeatureNewName: Attempt to name undefined station 0x%X, ignoring", GB(id, 0, 8));
05416             } else {
05417               _cur.grffile->stations[GB(id, 0, 8)]->name = AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
05418             }
05419             break;
05420 
05421           case 0xC7: // Airporttile name
05422             if (_cur.grffile->airtspec == NULL || _cur.grffile->airtspec[GB(id, 0, 8)] == NULL) {
05423               grfmsg(1, "FeatureNewName: Attempt to name undefined airport tile 0x%X, ignoring", GB(id, 0, 8));
05424             } else {
05425               _cur.grffile->airtspec[GB(id, 0, 8)]->name = AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
05426             }
05427             break;
05428 
05429           case 0xC9: // House name
05430             if (_cur.grffile->housespec == NULL || _cur.grffile->housespec[GB(id, 0, 8)] == NULL) {
05431               grfmsg(1, "FeatureNewName: Attempt to name undefined house 0x%X, ignoring.", GB(id, 0, 8));
05432             } else {
05433               _cur.grffile->housespec[GB(id, 0, 8)]->building_name = AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
05434             }
05435             break;
05436 
05437           case 0xD0:
05438           case 0xD1:
05439           case 0xD2:
05440           case 0xD3:
05441           case 0xDC:
05442             AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, true, name, STR_UNDEFINED);
05443             break;
05444 
05445           default:
05446             grfmsg(7, "FeatureNewName: Unsupported ID (0x%04X)", id);
05447             break;
05448         }
05449         break;
05450     }
05451   }
05452 }
05453 
05462 static uint16 SanitizeSpriteOffset(uint16& num, uint16 offset, int max_sprites, const char *name)
05463 {
05464 
05465   if (offset >= max_sprites) {
05466     grfmsg(1, "GraphicsNew: %s sprite offset must be less than %i, skipping", name, max_sprites);
05467     uint orig_num = num;
05468     num = 0;
05469     return orig_num;
05470   }
05471 
05472   if (offset + num > max_sprites) {
05473     grfmsg(4, "GraphicsNew: %s sprite overflow, truncating...", name);
05474     uint orig_num = num;
05475     num = max(max_sprites - offset, 0);
05476     return orig_num - num;
05477   }
05478 
05479   return 0;
05480 }
05481 
05482 
05484 enum Action5BlockType {
05485   A5BLOCK_FIXED,                
05486   A5BLOCK_ALLOW_OFFSET,         
05487   A5BLOCK_INVALID,              
05488 };
05490 struct Action5Type {
05491   Action5BlockType block_type;  
05492   SpriteID sprite_base;         
05493   uint16 min_sprites;           
05494   uint16 max_sprites;           
05495   const char *name;             
05496 };
05497 
05499 static const Action5Type _action5_types[] = {
05500   /* Note: min_sprites should not be changed. Therefore these constants are directly here and not in sprites.h */
05501   /* 0x00 */ { A5BLOCK_INVALID,      0,                            0, 0,                                           "Type 0x00"                },
05502   /* 0x01 */ { A5BLOCK_INVALID,      0,                            0, 0,                                           "Type 0x01"                },
05503   /* 0x02 */ { A5BLOCK_INVALID,      0,                            0, 0,                                           "Type 0x02"                },
05504   /* 0x03 */ { A5BLOCK_INVALID,      0,                            0, 0,                                           "Type 0x03"                },
05505   /* 0x04 */ { A5BLOCK_ALLOW_OFFSET, SPR_SIGNALS_BASE,             1, PRESIGNAL_SEMAPHORE_AND_PBS_SPRITE_COUNT,    "Signal graphics"          },
05506   /* 0x05 */ { A5BLOCK_ALLOW_OFFSET, SPR_ELRAIL_BASE,              1, ELRAIL_SPRITE_COUNT,                         "Catenary graphics"        },
05507   /* 0x06 */ { A5BLOCK_ALLOW_OFFSET, SPR_SLOPES_BASE,              1, NORMAL_AND_HALFTILE_FOUNDATION_SPRITE_COUNT, "Foundation graphics"      },
05508   /* 0x07 */ { A5BLOCK_INVALID,      0,                           75, 0,                                           "TTDP GUI graphics"        }, // Not used by OTTD.
05509   /* 0x08 */ { A5BLOCK_ALLOW_OFFSET, SPR_CANALS_BASE,              1, CANALS_SPRITE_COUNT,                         "Canal graphics"           },
05510   /* 0x09 */ { A5BLOCK_ALLOW_OFFSET, SPR_ONEWAY_BASE,              1, ONEWAY_SPRITE_COUNT,                         "One way road graphics"    },
05511   /* 0x0A */ { A5BLOCK_ALLOW_OFFSET, SPR_2CCMAP_BASE,              1, TWOCCMAP_SPRITE_COUNT,                       "2CC colour maps"          },
05512   /* 0x0B */ { A5BLOCK_ALLOW_OFFSET, SPR_TRAMWAY_BASE,             1, TRAMWAY_SPRITE_COUNT,                        "Tramway graphics"         },
05513   /* 0x0C */ { A5BLOCK_INVALID,      0,                          133, 0,                                           "Snowy temperate tree"     }, // Not yet used by OTTD.
05514   /* 0x0D */ { A5BLOCK_FIXED,        SPR_SHORE_BASE,              16, SPR_SHORE_SPRITE_COUNT,                      "Shore graphics"           },
05515   /* 0x0E */ { A5BLOCK_INVALID,      0,                            0, 0,                                           "New Signals graphics"     }, // Not yet used by OTTD.
05516   /* 0x0F */ { A5BLOCK_ALLOW_OFFSET, SPR_TRACKS_FOR_SLOPES_BASE,   1, TRACKS_FOR_SLOPES_SPRITE_COUNT,              "Sloped rail track"        },
05517   /* 0x10 */ { A5BLOCK_ALLOW_OFFSET, SPR_AIRPORTX_BASE,            1, AIRPORTX_SPRITE_COUNT,                       "Airport graphics"         },
05518   /* 0x11 */ { A5BLOCK_ALLOW_OFFSET, SPR_ROADSTOP_BASE,            1, ROADSTOP_SPRITE_COUNT,                       "Road stop graphics"       },
05519   /* 0x12 */ { A5BLOCK_ALLOW_OFFSET, SPR_AQUEDUCT_BASE,            1, AQUEDUCT_SPRITE_COUNT,                       "Aqueduct graphics"        },
05520   /* 0x13 */ { A5BLOCK_ALLOW_OFFSET, SPR_AUTORAIL_BASE,            1, AUTORAIL_SPRITE_COUNT,                       "Autorail graphics"        },
05521   /* 0x14 */ { A5BLOCK_ALLOW_OFFSET, SPR_FLAGS_BASE,               1, FLAGS_SPRITE_COUNT,                          "Flag graphics"            },
05522   /* 0x15 */ { A5BLOCK_ALLOW_OFFSET, SPR_OPENTTD_BASE,             1, OPENTTD_SPRITE_COUNT,                        "OpenTTD GUI graphics"     },
05523   /* 0x16 */ { A5BLOCK_ALLOW_OFFSET, SPR_AIRPORT_PREVIEW_BASE,     1, SPR_AIRPORT_PREVIEW_COUNT,                   "Airport preview graphics" },
05524   /* 0x17 */ { A5BLOCK_ALLOW_OFFSET, SPR_RAILTYPE_TUNNEL_BASE,     1, RAILTYPE_TUNNEL_BASE_COUNT,                  "Railtype tunnel base"     },
05525 };
05526 
05527 /* Action 0x05 */
05528 static void GraphicsNew(ByteReader *buf)
05529 {
05530   /* <05> <graphics-type> <num-sprites> <other data...>
05531    *
05532    * B graphics-type What set of graphics the sprites define.
05533    * E num-sprites   How many sprites are in this set?
05534    * V other data    Graphics type specific data.  Currently unused. */
05535   /* TODO */
05536 
05537   uint8 type = buf->ReadByte();
05538   uint16 num = buf->ReadExtendedByte();
05539   uint16 offset = HasBit(type, 7) ? buf->ReadExtendedByte() : 0;
05540   ClrBit(type, 7); // Clear the high bit as that only indicates whether there is an offset.
05541 
05542   if ((type == 0x0D) && (num == 10) && _cur.grffile->is_ottdfile) {
05543     /* Special not-TTDP-compatible case used in openttd.grf
05544      * Missing shore sprites and initialisation of SPR_SHORE_BASE */
05545     grfmsg(2, "GraphicsNew: Loading 10 missing shore sprites from extra grf.");
05546     LoadNextSprite(SPR_SHORE_BASE +  0, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_STEEP_S
05547     LoadNextSprite(SPR_SHORE_BASE +  5, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_STEEP_W
05548     LoadNextSprite(SPR_SHORE_BASE +  7, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_WSE
05549     LoadNextSprite(SPR_SHORE_BASE + 10, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_STEEP_N
05550     LoadNextSprite(SPR_SHORE_BASE + 11, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_NWS
05551     LoadNextSprite(SPR_SHORE_BASE + 13, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_ENW
05552     LoadNextSprite(SPR_SHORE_BASE + 14, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_SEN
05553     LoadNextSprite(SPR_SHORE_BASE + 15, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_STEEP_E
05554     LoadNextSprite(SPR_SHORE_BASE + 16, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_EW
05555     LoadNextSprite(SPR_SHORE_BASE + 17, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_NS
05556     if (_loaded_newgrf_features.shore == SHORE_REPLACE_NONE) _loaded_newgrf_features.shore = SHORE_REPLACE_ONLY_NEW;
05557     return;
05558   }
05559 
05560   /* Supported type? */
05561   if ((type >= lengthof(_action5_types)) || (_action5_types[type].block_type == A5BLOCK_INVALID)) {
05562     grfmsg(2, "GraphicsNew: Custom graphics (type 0x%02X) sprite block of length %u (unimplemented, ignoring)", type, num);
05563     _cur.skip_sprites = num;
05564     return;
05565   }
05566 
05567   const Action5Type *action5_type = &_action5_types[type];
05568 
05569   /* Contrary to TTDP we allow always to specify too few sprites as we allow always an offset,
05570    * except for the long version of the shore type:
05571    * Ignore offset if not allowed */
05572   if ((action5_type->block_type != A5BLOCK_ALLOW_OFFSET) && (offset != 0)) {
05573     grfmsg(1, "GraphicsNew: %s (type 0x%02X) do not allow an <offset> field. Ignoring offset.", action5_type->name, type);
05574     offset = 0;
05575   }
05576 
05577   /* Ignore action5 if too few sprites are specified. (for TTDP compatibility)
05578    * This does not make sense, if <offset> is allowed */
05579   if ((action5_type->block_type == A5BLOCK_FIXED) && (num < action5_type->min_sprites)) {
05580     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);
05581     _cur.skip_sprites = num;
05582     return;
05583   }
05584 
05585   /* Load at most max_sprites sprites. Skip remaining sprites. (for compatibility with TTDP and future extentions) */
05586   uint16 skip_num = SanitizeSpriteOffset(num, offset, action5_type->max_sprites, action5_type->name);
05587   SpriteID replace = action5_type->sprite_base + offset;
05588 
05589   /* Load <num> sprites starting from <replace>, then skip <skip_num> sprites. */
05590   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);
05591 
05592   for (; num > 0; num--) {
05593     _cur.nfo_line++;
05594     LoadNextSprite(replace == 0 ? _cur.spriteid++ : replace++, _cur.file_index, _cur.nfo_line, _cur.grf_container_ver);
05595   }
05596 
05597   if (type == 0x0D) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_5;
05598 
05599   _cur.skip_sprites = skip_num;
05600 }
05601 
05602 /* Action 0x05 (SKIP) */
05603 static void SkipAct5(ByteReader *buf)
05604 {
05605   /* Ignore type byte */
05606   buf->ReadByte();
05607 
05608   /* Skip the sprites of this action */
05609   _cur.skip_sprites = buf->ReadExtendedByte();
05610 
05611   grfmsg(3, "SkipAct5: Skipping %d sprites", _cur.skip_sprites);
05612 }
05613 
05619 void CheckForMissingSprites()
05620 {
05621   /* Don't break out quickly, but allow to check the other
05622    * sprites as well, so we can give the best information. */
05623   bool missing = false;
05624   for (uint8 i = 0; i < lengthof(_action5_types); i++) {
05625     const Action5Type *type = &_action5_types[i];
05626     if (type->block_type == A5BLOCK_INVALID) continue;
05627 
05628     for (uint j = 0; j < type->max_sprites; j++) {
05629       if (!SpriteExists(type->sprite_base + j)) {
05630         DEBUG(grf, 0, "%s sprites are missing", type->name);
05631         missing = true;
05632         /* No need to log more of the same. */
05633         break;
05634       }
05635     }
05636   }
05637 
05638   if (missing) {
05639     ShowErrorMessage(IsReleasedVersion() ? STR_NEWGRF_ERROR_MISSING_SPRITES : STR_NEWGRF_ERROR_MISSING_SPRITES_UNSTABLE, INVALID_STRING_ID, WL_CRITICAL);
05640   }
05641 }
05642 
05654 bool GetGlobalVariable(byte param, uint32 *value, const GRFFile *grffile)
05655 {
05656   switch (param) {
05657     case 0x00: // current date
05658       *value = max(_date - DAYS_TILL_ORIGINAL_BASE_YEAR, 0);
05659       return true;
05660 
05661     case 0x01: // current year
05662       *value = Clamp(_cur_year, ORIGINAL_BASE_YEAR, ORIGINAL_MAX_YEAR) - ORIGINAL_BASE_YEAR;
05663       return true;
05664 
05665     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)
05666       YearMonthDay ymd;
05667       ConvertDateToYMD(_date, &ymd);
05668       Date start_of_year = ConvertYMDToDate(ymd.year, 0, 1);
05669       *value = ymd.month | (ymd.day - 1) << 8 | (IsLeapYear(ymd.year) ? 1 << 15 : 0) | (_date - start_of_year) << 16;
05670       return true;
05671     }
05672 
05673     case 0x03: // current climate, 0=temp, 1=arctic, 2=trop, 3=toyland
05674       *value = _settings_game.game_creation.landscape;
05675       return true;
05676 
05677     case 0x06: // road traffic side, bit 4 clear=left, set=right
05678       *value = _settings_game.vehicle.road_side << 4;
05679       return true;
05680 
05681     case 0x09: // date fraction
05682       *value = _date_fract * 885;
05683       return true;
05684 
05685     case 0x0A: // animation counter
05686       *value = _tick_counter;
05687       return true;
05688 
05689     case 0x0B: { // TTDPatch version
05690       uint major    = 2;
05691       uint minor    = 6;
05692       uint revision = 1; // special case: 2.0.1 is 2.0.10
05693       uint build    = 1382;
05694       *value = (major << 24) | (minor << 20) | (revision << 16) | build;
05695       return true;
05696     }
05697 
05698     case 0x0D: // TTD Version, 00=DOS, 01=Windows
05699       *value = _cur.grfconfig->palette & GRFP_USE_MASK;
05700       return true;
05701 
05702     case 0x0E: // Y-offset for train sprites
05703       *value = _cur.grffile->traininfo_vehicle_pitch;
05704       return true;
05705 
05706     case 0x0F: // Rail track type cost factors
05707       *value = 0;
05708       SB(*value, 0, 8, GetRailTypeInfo(RAILTYPE_RAIL)->cost_multiplier); // normal rail
05709       if (_settings_game.vehicle.disable_elrails) {
05710         /* skip elrail multiplier - disabled */
05711         SB(*value, 8, 8, GetRailTypeInfo(RAILTYPE_MONO)->cost_multiplier); // monorail
05712       } else {
05713         SB(*value, 8, 8, GetRailTypeInfo(RAILTYPE_ELECTRIC)->cost_multiplier); // electified railway
05714         /* Skip monorail multiplier - no space in result */
05715       }
05716       SB(*value, 16, 8, GetRailTypeInfo(RAILTYPE_MAGLEV)->cost_multiplier); // maglev
05717       return true;
05718 
05719     case 0x11: // current rail tool type
05720       *value = 0; // constant fake value to avoid desync
05721       return true;
05722 
05723     case 0x12: // Game mode
05724       *value = _game_mode;
05725       return true;
05726 
05727     /* case 0x13: // Tile refresh offset to left    not implemented */
05728     /* case 0x14: // Tile refresh offset to right   not implemented */
05729     /* case 0x15: // Tile refresh offset upwards    not implemented */
05730     /* case 0x16: // Tile refresh offset downwards  not implemented */
05731     /* case 0x17: // temperate snow line            not implemented */
05732 
05733     case 0x1A: // Always -1
05734       *value = UINT_MAX;
05735       return true;
05736 
05737     case 0x1B: // Display options
05738       *value = 0x3F; // constant fake value to avoid desync
05739       return true;
05740 
05741     case 0x1D: // TTD Platform, 00=TTDPatch, 01=OpenTTD
05742       *value = 1;
05743       return true;
05744 
05745     case 0x1E: // Miscellaneous GRF features
05746       *value = _misc_grf_features;
05747 
05748       /* Add the local flags */
05749       assert(!HasBit(*value, GMB_TRAIN_WIDTH_32_PIXELS));
05750       if (_cur.grffile->traininfo_vehicle_width == VEHICLEINFO_FULL_VEHICLE_WIDTH) SetBit(*value, GMB_TRAIN_WIDTH_32_PIXELS);
05751       return true;
05752 
05753     /* case 0x1F: // locale dependent settings not implemented to avoid desync */
05754 
05755     case 0x20: { // snow line height
05756       byte snowline = GetSnowLine();
05757       if (_settings_game.game_creation.landscape == LT_ARCTIC && snowline <= MAX_TILE_HEIGHT) {
05758         *value = Clamp(snowline * (grffile->grf_version >= 8 ? 1 : TILE_HEIGHT), 0, 0xFE);
05759       } else {
05760         /* No snow */
05761         *value = 0xFF;
05762       }
05763       return true;
05764     }
05765 
05766     case 0x21: // OpenTTD version
05767       *value = _openttd_newgrf_version;
05768       return true;
05769 
05770     case 0x22: // difficulty level
05771       *value = SP_CUSTOM;
05772       return true;
05773 
05774     case 0x23: // long format date
05775       *value = _date;
05776       return true;
05777 
05778     case 0x24: // long format year
05779       *value = _cur_year;
05780       return true;
05781 
05782     default: return false;
05783   }
05784 }
05785 
05786 static uint32 GetParamVal(byte param, uint32 *cond_val)
05787 {
05788   /* First handle variable common with VarAction2 */
05789   uint32 value;
05790   if (GetGlobalVariable(param - 0x80, &value, _cur.grffile)) return value;
05791 
05792   /* Non-common variable */
05793   switch (param) {
05794     case 0x84: { // GRF loading stage
05795       uint32 res = 0;
05796 
05797       if (_cur.stage > GLS_INIT) SetBit(res, 0);
05798       if (_cur.stage == GLS_RESERVE) SetBit(res, 8);
05799       if (_cur.stage == GLS_ACTIVATION) SetBit(res, 9);
05800       return res;
05801     }
05802 
05803     case 0x85: // TTDPatch flags, only for bit tests
05804       if (cond_val == NULL) {
05805         /* Supported in Action 0x07 and 0x09, not 0x0D */
05806         return 0;
05807       } else {
05808         uint32 param_val = _ttdpatch_flags[*cond_val / 0x20];
05809         *cond_val %= 0x20;
05810         return param_val;
05811       }
05812 
05813     case 0x88: // GRF ID check
05814       return 0;
05815 
05816     /* case 0x99: Global ID offset not implemented */
05817 
05818     default:
05819       /* GRF Parameter */
05820       if (param < 0x80) return _cur.grffile->GetParam(param);
05821 
05822       /* In-game variable. */
05823       grfmsg(1, "Unsupported in-game variable 0x%02X", param);
05824       return UINT_MAX;
05825   }
05826 }
05827 
05828 /* Action 0x06 */
05829 static void CfgApply(ByteReader *buf)
05830 {
05831   /* <06> <param-num> <param-size> <offset> ... <FF>
05832    *
05833    * B param-num     Number of parameter to substitute (First = "zero")
05834    *                 Ignored if that parameter was not specified in newgrf.cfg
05835    * B param-size    How many bytes to replace.  If larger than 4, the
05836    *                 bytes of the following parameter are used.  In that
05837    *                 case, nothing is applied unless *all* parameters
05838    *                 were specified.
05839    * B offset        Offset into data from beginning of next sprite
05840    *                 to place where parameter is to be stored. */
05841 
05842   /* Preload the next sprite */
05843   size_t pos = FioGetPos();
05844   uint32 num = _cur.grf_container_ver >= 2 ? FioReadDword() : FioReadWord();
05845   uint8 type = FioReadByte();
05846   byte *preload_sprite = NULL;
05847 
05848   /* Check if the sprite is a pseudo sprite. We can't operate on real sprites. */
05849   if (type == 0xFF) {
05850     preload_sprite = MallocT<byte>(num);
05851     FioReadBlock(preload_sprite, num);
05852   }
05853 
05854   /* Reset the file position to the start of the next sprite */
05855   FioSeekTo(pos, SEEK_SET);
05856 
05857   if (type != 0xFF) {
05858     grfmsg(2, "CfgApply: Ignoring (next sprite is real, unsupported)");
05859     free(preload_sprite);
05860     return;
05861   }
05862 
05863   GRFLocation location(_cur.grfconfig->ident.grfid, _cur.nfo_line + 1);
05864   GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.find(location);
05865   if (it != _grf_line_to_action6_sprite_override.end()) {
05866     free(preload_sprite);
05867     preload_sprite = _grf_line_to_action6_sprite_override[location];
05868   } else {
05869     _grf_line_to_action6_sprite_override[location] = preload_sprite;
05870   }
05871 
05872   /* Now perform the Action 0x06 on our data. */
05873 
05874   for (;;) {
05875     uint i;
05876     uint param_num;
05877     uint param_size;
05878     uint offset;
05879     bool add_value;
05880 
05881     /* Read the parameter to apply. 0xFF indicates no more data to change. */
05882     param_num = buf->ReadByte();
05883     if (param_num == 0xFF) break;
05884 
05885     /* Get the size of the parameter to use. If the size covers multiple
05886      * double words, sequential parameter values are used. */
05887     param_size = buf->ReadByte();
05888 
05889     /* Bit 7 of param_size indicates we should add to the original value
05890      * instead of replacing it. */
05891     add_value  = HasBit(param_size, 7);
05892     param_size = GB(param_size, 0, 7);
05893 
05894     /* Where to apply the data to within the pseudo sprite data. */
05895     offset     = buf->ReadExtendedByte();
05896 
05897     /* If the parameter is a GRF parameter (not an internal variable) check
05898      * if it (and all further sequential parameters) has been defined. */
05899     if (param_num < 0x80 && (param_num + (param_size - 1) / 4) >= _cur.grffile->param_end) {
05900       grfmsg(2, "CfgApply: Ignoring (param %d not set)", (param_num + (param_size - 1) / 4));
05901       break;
05902     }
05903 
05904     grfmsg(8, "CfgApply: Applying %u bytes from parameter 0x%02X at offset 0x%04X", param_size, param_num, offset);
05905 
05906     bool carry = false;
05907     for (i = 0; i < param_size && offset + i < num; i++) {
05908       uint32 value = GetParamVal(param_num + i / 4, NULL);
05909       /* Reset carry flag for each iteration of the variable (only really
05910        * matters if param_size is greater than 4) */
05911       if (i % 4 == 0) carry = false;
05912 
05913       if (add_value) {
05914         uint new_value = preload_sprite[offset + i] + GB(value, (i % 4) * 8, 8) + (carry ? 1 : 0);
05915         preload_sprite[offset + i] = GB(new_value, 0, 8);
05916         /* Check if the addition overflowed */
05917         carry = new_value >= 256;
05918       } else {
05919         preload_sprite[offset + i] = GB(value, (i % 4) * 8, 8);
05920       }
05921     }
05922   }
05923 }
05924 
05934 static void DisableStaticNewGRFInfluencingNonStaticNewGRFs(GRFConfig *c)
05935 {
05936   GRFError *error = DisableGrf(STR_NEWGRF_ERROR_STATIC_GRF_CAUSES_DESYNC, c);
05937   error->data = strdup(_cur.grfconfig->GetName());
05938 }
05939 
05940 /* Action 0x07
05941  * Action 0x09 */
05942 static void SkipIf(ByteReader *buf)
05943 {
05944   /* <07/09> <param-num> <param-size> <condition-type> <value> <num-sprites>
05945    *
05946    * B param-num
05947    * B param-size
05948    * B condition-type
05949    * V value
05950    * B num-sprites */
05951   /* TODO: More params. More condition types. */
05952   uint32 cond_val = 0;
05953   uint32 mask = 0;
05954   bool result;
05955 
05956   uint8 param     = buf->ReadByte();
05957   uint8 paramsize = buf->ReadByte();
05958   uint8 condtype  = buf->ReadByte();
05959 
05960   if (condtype < 2) {
05961     /* Always 1 for bit tests, the given value should be ignored. */
05962     paramsize = 1;
05963   }
05964 
05965   switch (paramsize) {
05966     case 8: cond_val = buf->ReadDWord(); mask = buf->ReadDWord(); break;
05967     case 4: cond_val = buf->ReadDWord(); mask = 0xFFFFFFFF; break;
05968     case 2: cond_val = buf->ReadWord();  mask = 0x0000FFFF; break;
05969     case 1: cond_val = buf->ReadByte();  mask = 0x000000FF; break;
05970     default: break;
05971   }
05972 
05973   if (param < 0x80 && _cur.grffile->param_end <= param) {
05974     grfmsg(7, "SkipIf: Param %d undefined, skipping test", param);
05975     return;
05976   }
05977 
05978   uint32 param_val = GetParamVal(param, &cond_val);
05979 
05980   grfmsg(7, "SkipIf: Test condtype %d, param 0x%08X, condval 0x%08X", condtype, param_val, cond_val);
05981 
05982   /*
05983    * Parameter (variable in specs) 0x88 can only have GRF ID checking
05984    * conditions, except conditions 0x0B, 0x0C (cargo availability) and
05985    * 0x0D, 0x0E (Rail type availability) as those ignore the parameter.
05986    * So, when the condition type is one of those, the specific variable
05987    * 0x88 code is skipped, so the "general" code for the cargo
05988    * availability conditions kicks in.
05989    */
05990   if (param == 0x88 && (condtype < 0x0B || condtype > 0x0E)) {
05991     /* GRF ID checks */
05992 
05993     GRFConfig *c = GetGRFConfig(cond_val, mask);
05994 
05995     if (c != NULL && HasBit(c->flags, GCF_STATIC) && !HasBit(_cur.grfconfig->flags, GCF_STATIC) && _networking) {
05996       DisableStaticNewGRFInfluencingNonStaticNewGRFs(c);
05997       c = NULL;
05998     }
05999 
06000     if (condtype != 10 && c == NULL) {
06001       grfmsg(7, "SkipIf: GRFID 0x%08X unknown, skipping test", BSWAP32(cond_val));
06002       return;
06003     }
06004 
06005     switch (condtype) {
06006       /* Tests 0x06 to 0x0A are only for param 0x88, GRFID checks */
06007       case 0x06: // Is GRFID active?
06008         result = c->status == GCS_ACTIVATED;
06009         break;
06010 
06011       case 0x07: // Is GRFID non-active?
06012         result = c->status != GCS_ACTIVATED;
06013         break;
06014 
06015       case 0x08: // GRFID is not but will be active?
06016         result = c->status == GCS_INITIALISED;
06017         break;
06018 
06019       case 0x09: // GRFID is or will be active?
06020         result = c->status == GCS_ACTIVATED || c->status == GCS_INITIALISED;
06021         break;
06022 
06023       case 0x0A: // GRFID is not nor will be active
06024         /* This is the only condtype that doesn't get ignored if the GRFID is not found */
06025         result = c == NULL || c->flags == GCS_DISABLED || c->status == GCS_NOT_FOUND;
06026         break;
06027 
06028       default: grfmsg(1, "SkipIf: Unsupported GRF condition type %02X. Ignoring", condtype); return;
06029     }
06030   } else {
06031     /* Parameter or variable tests */
06032     switch (condtype) {
06033       case 0x00: result = !!(param_val & (1 << cond_val));
06034         break;
06035       case 0x01: result = !(param_val & (1 << cond_val));
06036         break;
06037       case 0x02: result = (param_val & mask) == cond_val;
06038         break;
06039       case 0x03: result = (param_val & mask) != cond_val;
06040         break;
06041       case 0x04: result = (param_val & mask) < cond_val;
06042         break;
06043       case 0x05: result = (param_val & mask) > cond_val;
06044         break;
06045       case 0x0B: result = GetCargoIDByLabel(BSWAP32(cond_val)) == CT_INVALID;
06046         break;
06047       case 0x0C: result = GetCargoIDByLabel(BSWAP32(cond_val)) != CT_INVALID;
06048         break;
06049       case 0x0D: result = GetRailTypeByLabel(BSWAP32(cond_val)) == INVALID_RAILTYPE;
06050         break;
06051       case 0x0E: result = GetRailTypeByLabel(BSWAP32(cond_val)) != INVALID_RAILTYPE;
06052         break;
06053 
06054       default: grfmsg(1, "SkipIf: Unsupported condition type %02X. Ignoring", condtype); return;
06055     }
06056   }
06057 
06058   if (!result) {
06059     grfmsg(2, "SkipIf: Not skipping sprites, test was false");
06060     return;
06061   }
06062 
06063   uint8 numsprites = buf->ReadByte();
06064 
06065   /* numsprites can be a GOTO label if it has been defined in the GRF
06066    * file. The jump will always be the first matching label that follows
06067    * the current nfo_line. If no matching label is found, the first matching
06068    * label in the file is used. */
06069   GRFLabel *choice = NULL;
06070   for (GRFLabel *label = _cur.grffile->label; label != NULL; label = label->next) {
06071     if (label->label != numsprites) continue;
06072 
06073     /* Remember a goto before the current line */
06074     if (choice == NULL) choice = label;
06075     /* If we find a label here, this is definitely good */
06076     if (label->nfo_line > _cur.nfo_line) {
06077       choice = label;
06078       break;
06079     }
06080   }
06081 
06082   if (choice != NULL) {
06083     grfmsg(2, "SkipIf: Jumping to label 0x%0X at line %d, test was true", choice->label, choice->nfo_line);
06084     FioSeekTo(choice->pos, SEEK_SET);
06085     _cur.nfo_line = choice->nfo_line;
06086     return;
06087   }
06088 
06089   grfmsg(2, "SkipIf: Skipping %d sprites, test was true", numsprites);
06090   _cur.skip_sprites = numsprites;
06091   if (_cur.skip_sprites == 0) {
06092     /* Zero means there are no sprites to skip, so
06093      * we use -1 to indicate that all further
06094      * sprites should be skipped. */
06095     _cur.skip_sprites = -1;
06096 
06097     /* If an action 8 hasn't been encountered yet, disable the grf. */
06098     if (_cur.grfconfig->status != (_cur.stage < GLS_RESERVE ? GCS_INITIALISED : GCS_ACTIVATED)) {
06099       DisableGrf();
06100     }
06101   }
06102 }
06103 
06104 
06105 /* Action 0x08 (GLS_FILESCAN) */
06106 static void ScanInfo(ByteReader *buf)
06107 {
06108   uint8 grf_version = buf->ReadByte();
06109   uint32 grfid      = buf->ReadDWord();
06110   const char *name  = buf->ReadString();
06111 
06112   _cur.grfconfig->ident.grfid = grfid;
06113 
06114   if (grf_version < 2 || grf_version > 8) {
06115     SetBit(_cur.grfconfig->flags, GCF_INVALID);
06116     DEBUG(grf, 0, "%s: NewGRF \"%s\" (GRFID %08X) uses GRF version %d, which is incompatible with this version of OpenTTD.", _cur.grfconfig->filename, name, BSWAP32(grfid), grf_version);
06117   }
06118 
06119   /* GRF IDs starting with 0xFF are reserved for internal TTDPatch use */
06120   if (GB(grfid, 24, 8) == 0xFF) SetBit(_cur.grfconfig->flags, GCF_SYSTEM);
06121 
06122   AddGRFTextToList(&_cur.grfconfig->name->text, 0x7F, grfid, false, name);
06123 
06124   if (buf->HasData()) {
06125     const char *info = buf->ReadString();
06126     AddGRFTextToList(&_cur.grfconfig->info->text, 0x7F, grfid, true, info);
06127   }
06128 
06129   /* GLS_INFOSCAN only looks for the action 8, so we can skip the rest of the file */
06130   _cur.skip_sprites = -1;
06131 }
06132 
06133 /* Action 0x08 */
06134 static void GRFInfo(ByteReader *buf)
06135 {
06136   /* <08> <version> <grf-id> <name> <info>
06137    *
06138    * B version       newgrf version, currently 06
06139    * 4*B grf-id      globally unique ID of this .grf file
06140    * S name          name of this .grf set
06141    * S info          string describing the set, and e.g. author and copyright */
06142 
06143   uint8 version    = buf->ReadByte();
06144   uint32 grfid     = buf->ReadDWord();
06145   const char *name = buf->ReadString();
06146 
06147   if (_cur.stage < GLS_RESERVE && _cur.grfconfig->status != GCS_UNKNOWN) {
06148     DisableGrf(STR_NEWGRF_ERROR_MULTIPLE_ACTION_8);
06149     return;
06150   }
06151 
06152   if (_cur.grffile->grfid != grfid) {
06153     DEBUG(grf, 0, "GRFInfo: GRFID %08X in FILESCAN stage does not match GRFID %08X in INIT/RESERVE/ACTIVATION stage", BSWAP32(_cur.grffile->grfid), BSWAP32(grfid));
06154     _cur.grffile->grfid = grfid;
06155   }
06156 
06157   _cur.grffile->grf_version = version;
06158   _cur.grfconfig->status = _cur.stage < GLS_RESERVE ? GCS_INITIALISED : GCS_ACTIVATED;
06159 
06160   /* Do swap the GRFID for displaying purposes since people expect that */
06161   DEBUG(grf, 1, "GRFInfo: Loaded GRFv%d set %08X - %s (palette: %s, version: %i)", version, BSWAP32(grfid), name, (_cur.grfconfig->palette & GRFP_USE_MASK) ? "Windows" : "DOS", _cur.grfconfig->version);
06162 }
06163 
06164 /* Action 0x0A */
06165 static void SpriteReplace(ByteReader *buf)
06166 {
06167   /* <0A> <num-sets> <set1> [<set2> ...]
06168    * <set>: <num-sprites> <first-sprite>
06169    *
06170    * B num-sets      How many sets of sprites to replace.
06171    * Each set:
06172    * B num-sprites   How many sprites are in this set
06173    * W first-sprite  First sprite number to replace */
06174 
06175   uint8 num_sets = buf->ReadByte();
06176 
06177   for (uint i = 0; i < num_sets; i++) {
06178     uint8 num_sprites = buf->ReadByte();
06179     uint16 first_sprite = buf->ReadWord();
06180 
06181     grfmsg(2, "SpriteReplace: [Set %d] Changing %d sprites, beginning with %d",
06182       i, num_sprites, first_sprite
06183     );
06184 
06185     for (uint j = 0; j < num_sprites; j++) {
06186       int load_index = first_sprite + j;
06187       _cur.nfo_line++;
06188       LoadNextSprite(load_index, _cur.file_index, _cur.nfo_line, _cur.grf_container_ver); // XXX
06189 
06190       /* Shore sprites now located at different addresses.
06191        * So detect when the old ones get replaced. */
06192       if (IsInsideMM(load_index, SPR_ORIGINALSHORE_START, SPR_ORIGINALSHORE_END + 1)) {
06193         if (_loaded_newgrf_features.shore != SHORE_REPLACE_ACTION_5) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_A;
06194       }
06195     }
06196   }
06197 }
06198 
06199 /* Action 0x0A (SKIP) */
06200 static void SkipActA(ByteReader *buf)
06201 {
06202   uint8 num_sets = buf->ReadByte();
06203 
06204   for (uint i = 0; i < num_sets; i++) {
06205     /* Skip the sprites this replaces */
06206     _cur.skip_sprites += buf->ReadByte();
06207     /* But ignore where they go */
06208     buf->ReadWord();
06209   }
06210 
06211   grfmsg(3, "SkipActA: Skipping %d sprites", _cur.skip_sprites);
06212 }
06213 
06214 /* Action 0x0B */
06215 static void GRFLoadError(ByteReader *buf)
06216 {
06217   /* <0B> <severity> <language-id> <message-id> [<message...> 00] [<data...>] 00 [<parnum>]
06218    *
06219    * B severity      00: notice, contine loading grf file
06220    *                 01: warning, continue loading grf file
06221    *                 02: error, but continue loading grf file, and attempt
06222    *                     loading grf again when loading or starting next game
06223    *                 03: error, abort loading and prevent loading again in
06224    *                     the future (only when restarting the patch)
06225    * B language-id   see action 4, use 1F for built-in error messages
06226    * B message-id    message to show, see below
06227    * S message       for custom messages (message-id FF), text of the message
06228    *                 not present for built-in messages.
06229    * V data          additional data for built-in (or custom) messages
06230    * B parnum        parameter numbers to be shown in the message (maximum of 2) */
06231 
06232   static const StringID msgstr[] = {
06233     STR_NEWGRF_ERROR_VERSION_NUMBER,
06234     STR_NEWGRF_ERROR_DOS_OR_WINDOWS,
06235     STR_NEWGRF_ERROR_UNSET_SWITCH,
06236     STR_NEWGRF_ERROR_INVALID_PARAMETER,
06237     STR_NEWGRF_ERROR_LOAD_BEFORE,
06238     STR_NEWGRF_ERROR_LOAD_AFTER,
06239     STR_NEWGRF_ERROR_OTTD_VERSION_NUMBER,
06240   };
06241 
06242   static const StringID sevstr[] = {
06243     STR_NEWGRF_ERROR_MSG_INFO,
06244     STR_NEWGRF_ERROR_MSG_WARNING,
06245     STR_NEWGRF_ERROR_MSG_ERROR,
06246     STR_NEWGRF_ERROR_MSG_FATAL
06247   };
06248 
06249   byte severity   = buf->ReadByte();
06250   byte lang       = buf->ReadByte();
06251   byte message_id = buf->ReadByte();
06252 
06253   /* Skip the error if it isn't valid for the current language. */
06254   if (!CheckGrfLangID(lang, _cur.grffile->grf_version)) return;
06255 
06256   /* Skip the error until the activation stage unless bit 7 of the severity
06257    * is set. */
06258   if (!HasBit(severity, 7) && _cur.stage == GLS_INIT) {
06259     grfmsg(7, "GRFLoadError: Skipping non-fatal GRFLoadError in stage %d", _cur.stage);
06260     return;
06261   }
06262   ClrBit(severity, 7);
06263 
06264   if (severity >= lengthof(sevstr)) {
06265     grfmsg(7, "GRFLoadError: Invalid severity id %d. Setting to 2 (non-fatal error).", severity);
06266     severity = 2;
06267   } else if (severity == 3) {
06268     /* This is a fatal error, so make sure the GRF is deactivated and no
06269      * more of it gets loaded. */
06270     DisableGrf();
06271 
06272     /* Make sure we show fatal errors, instead of silly infos from before */
06273     delete _cur.grfconfig->error;
06274     _cur.grfconfig->error = NULL;
06275   }
06276 
06277   if (message_id >= lengthof(msgstr) && message_id != 0xFF) {
06278     grfmsg(7, "GRFLoadError: Invalid message id.");
06279     return;
06280   }
06281 
06282   if (buf->Remaining() <= 1) {
06283     grfmsg(7, "GRFLoadError: No message data supplied.");
06284     return;
06285   }
06286 
06287   /* For now we can only show one message per newgrf file. */
06288   if (_cur.grfconfig->error != NULL) return;
06289 
06290   GRFError *error = new GRFError(sevstr[severity]);
06291 
06292   if (message_id == 0xFF) {
06293     /* This is a custom error message. */
06294     if (buf->HasData()) {
06295       const char *message = buf->ReadString();
06296 
06297       error->custom_message = TranslateTTDPatchCodes(_cur.grffile->grfid, lang, true, message, NULL, SCC_RAW_STRING_POINTER);
06298     } else {
06299       grfmsg(7, "GRFLoadError: No custom message supplied.");
06300       error->custom_message = strdup("");
06301     }
06302   } else {
06303     error->message = msgstr[message_id];
06304   }
06305 
06306   if (buf->HasData()) {
06307     const char *data = buf->ReadString();
06308 
06309     error->data = TranslateTTDPatchCodes(_cur.grffile->grfid, lang, true, data);
06310   } else {
06311     grfmsg(7, "GRFLoadError: No message data supplied.");
06312     error->data = strdup("");
06313   }
06314 
06315   /* Only two parameter numbers can be used in the string. */
06316   for (uint i = 0; i < lengthof(error->param_value) && buf->HasData(); i++) {
06317     uint param_number = buf->ReadByte();
06318     error->param_value[i] = _cur.grffile->GetParam(param_number);
06319   }
06320 
06321   _cur.grfconfig->error = error;
06322 }
06323 
06324 /* Action 0x0C */
06325 static void GRFComment(ByteReader *buf)
06326 {
06327   /* <0C> [<ignored...>]
06328    *
06329    * V ignored       Anything following the 0C is ignored */
06330 
06331   if (!buf->HasData()) return;
06332 
06333   const char *text = buf->ReadString();
06334   grfmsg(2, "GRFComment: %s", text);
06335 }
06336 
06337 /* Action 0x0D (GLS_SAFETYSCAN) */
06338 static void SafeParamSet(ByteReader *buf)
06339 {
06340   uint8 target = buf->ReadByte();
06341 
06342   /* Only writing GRF parameters is considered safe */
06343   if (target < 0x80) return;
06344 
06345   /* GRM could be unsafe, but as here it can only happen after other GRFs
06346    * are loaded, it should be okay. If the GRF tried to use the slots it
06347    * reserved, it would be marked unsafe anyway. GRM for (e.g. bridge)
06348    * sprites  is considered safe. */
06349 
06350   SetBit(_cur.grfconfig->flags, GCF_UNSAFE);
06351 
06352   /* Skip remainder of GRF */
06353   _cur.skip_sprites = -1;
06354 }
06355 
06356 
06357 static uint32 GetPatchVariable(uint8 param)
06358 {
06359   switch (param) {
06360     /* start year - 1920 */
06361     case 0x0B: return max(_settings_game.game_creation.starting_year, ORIGINAL_BASE_YEAR) - ORIGINAL_BASE_YEAR;
06362 
06363     /* freight trains weight factor */
06364     case 0x0E: return _settings_game.vehicle.freight_trains;
06365 
06366     /* empty wagon speed increase */
06367     case 0x0F: return 0;
06368 
06369     /* plane speed factor; our patch option is reversed from TTDPatch's,
06370      * the following is good for 1x, 2x and 4x (most common?) and...
06371      * well not really for 3x. */
06372     case 0x10:
06373       switch (_settings_game.vehicle.plane_speed) {
06374         default:
06375         case 4: return 1;
06376         case 3: return 2;
06377         case 2: return 2;
06378         case 1: return 4;
06379       }
06380 
06381 
06382     /* 2CC colourmap base sprite */
06383     case 0x11: return SPR_2CCMAP_BASE;
06384 
06385     /* map size: format = -MABXYSS
06386      * M  : the type of map
06387      *       bit 0 : set   : squared map. Bit 1 is now not relevant
06388      *               clear : rectangle map. Bit 1 will indicate the bigger edge of the map
06389      *       bit 1 : set   : Y is the bigger edge. Bit 0 is clear
06390      *               clear : X is the bigger edge.
06391      * A  : minimum edge(log2) of the map
06392      * B  : maximum edge(log2) of the map
06393      * XY : edges(log2) of each side of the map.
06394      * SS : combination of both X and Y, thus giving the size(log2) of the map
06395      */
06396     case 0x13: {
06397       byte map_bits = 0;
06398       byte log_X = MapLogX() - 6; // substraction is required to make the minimal size (64) zero based
06399       byte log_Y = MapLogY() - 6;
06400       byte max_edge = max(log_X, log_Y);
06401 
06402       if (log_X == log_Y) { // we have a squared map, since both edges are identical
06403         SetBit(map_bits, 0);
06404       } else {
06405         if (max_edge == log_Y) SetBit(map_bits, 1); // edge Y been the biggest, mark it
06406       }
06407 
06408       return (map_bits << 24) | (min(log_X, log_Y) << 20) | (max_edge << 16) |
06409         (log_X << 12) | (log_Y << 8) | (log_X + log_Y);
06410     }
06411 
06412     /* The maximum height of the map. */
06413     case 0x14:
06414       return MAX_TILE_HEIGHT;
06415 
06416     /* Extra foundations base sprite */
06417     case 0x15:
06418       return SPR_SLOPES_BASE;
06419 
06420     /* Shore base sprite */
06421     case 0x16:
06422       return SPR_SHORE_BASE;
06423 
06424     default:
06425       grfmsg(2, "ParamSet: Unknown Patch variable 0x%02X.", param);
06426       return 0;
06427   }
06428 }
06429 
06430 
06431 static uint32 PerformGRM(uint32 *grm, uint16 num_ids, uint16 count, uint8 op, uint8 target, const char *type)
06432 {
06433   uint start = 0;
06434   uint size  = 0;
06435 
06436   if (op == 6) {
06437     /* Return GRFID of set that reserved ID */
06438     return grm[_cur.grffile->GetParam(target)];
06439   }
06440 
06441   /* With an operation of 2 or 3, we want to reserve a specific block of IDs */
06442   if (op == 2 || op == 3) start = _cur.grffile->GetParam(target);
06443 
06444   for (uint i = start; i < num_ids; i++) {
06445     if (grm[i] == 0) {
06446       size++;
06447     } else {
06448       if (op == 2 || op == 3) break;
06449       start = i + 1;
06450       size = 0;
06451     }
06452 
06453     if (size == count) break;
06454   }
06455 
06456   if (size == count) {
06457     /* Got the slot... */
06458     if (op == 0 || op == 3) {
06459       grfmsg(2, "ParamSet: GRM: Reserving %d %s at %d", count, type, start);
06460       for (uint i = 0; i < count; i++) grm[start + i] = _cur.grffile->grfid;
06461     }
06462     return start;
06463   }
06464 
06465   /* Unable to allocate */
06466   if (op != 4 && op != 5) {
06467     /* Deactivate GRF */
06468     grfmsg(0, "ParamSet: GRM: Unable to allocate %d %s, deactivating", count, type);
06469     DisableGrf(STR_NEWGRF_ERROR_GRM_FAILED);
06470     return UINT_MAX;
06471   }
06472 
06473   grfmsg(1, "ParamSet: GRM: Unable to allocate %d %s", count, type);
06474   return UINT_MAX;
06475 }
06476 
06477 
06479 static void ParamSet(ByteReader *buf)
06480 {
06481   /* <0D> <target> <operation> <source1> <source2> [<data>]
06482    *
06483    * B target        parameter number where result is stored
06484    * B operation     operation to perform, see below
06485    * B source1       first source operand
06486    * B source2       second source operand
06487    * D data          data to use in the calculation, not necessary
06488    *                 if both source1 and source2 refer to actual parameters
06489    *
06490    * Operations
06491    * 00      Set parameter equal to source1
06492    * 01      Addition, source1 + source2
06493    * 02      Subtraction, source1 - source2
06494    * 03      Unsigned multiplication, source1 * source2 (both unsigned)
06495    * 04      Signed multiplication, source1 * source2 (both signed)
06496    * 05      Unsigned bit shift, source1 by source2 (source2 taken to be a
06497    *         signed quantity; left shift if positive and right shift if
06498    *         negative, source1 is unsigned)
06499    * 06      Signed bit shift, source1 by source2
06500    *         (source2 like in 05, and source1 as well)
06501    */
06502 
06503   uint8 target = buf->ReadByte();
06504   uint8 oper   = buf->ReadByte();
06505   uint32 src1  = buf->ReadByte();
06506   uint32 src2  = buf->ReadByte();
06507 
06508   uint32 data = 0;
06509   if (buf->Remaining() >= 4) data = buf->ReadDWord();
06510 
06511   /* You can add 80 to the operation to make it apply only if the target
06512    * is not defined yet.  In this respect, a parameter is taken to be
06513    * defined if any of the following applies:
06514    * - it has been set to any value in the newgrf(w).cfg parameter list
06515    * - it OR A PARAMETER WITH HIGHER NUMBER has been set to any value by
06516    *   an earlier action D */
06517   if (HasBit(oper, 7)) {
06518     if (target < 0x80 && target < _cur.grffile->param_end) {
06519       grfmsg(7, "ParamSet: Param %u already defined, skipping", target);
06520       return;
06521     }
06522 
06523     oper = GB(oper, 0, 7);
06524   }
06525 
06526   if (src2 == 0xFE) {
06527     if (GB(data, 0, 8) == 0xFF) {
06528       if (data == 0x0000FFFF) {
06529         /* Patch variables */
06530         src1 = GetPatchVariable(src1);
06531       } else {
06532         /* GRF Resource Management */
06533         uint8  op      = src1;
06534         uint8  feature = GB(data, 8, 8);
06535         uint16 count   = GB(data, 16, 16);
06536 
06537         if (_cur.stage == GLS_RESERVE) {
06538           if (feature == 0x08) {
06539             /* General sprites */
06540             if (op == 0) {
06541               /* Check if the allocated sprites will fit below the original sprite limit */
06542               if (_cur.spriteid + count >= 16384) {
06543                 grfmsg(0, "ParamSet: GRM: Unable to allocate %d sprites; try changing NewGRF order", count);
06544                 DisableGrf(STR_NEWGRF_ERROR_GRM_FAILED);
06545                 return;
06546               }
06547 
06548               /* Reserve space at the current sprite ID */
06549               grfmsg(4, "ParamSet: GRM: Allocated %d sprites at %d", count, _cur.spriteid);
06550               _grm_sprites[GRFLocation(_cur.grffile->grfid, _cur.nfo_line)] = _cur.spriteid;
06551               _cur.spriteid += count;
06552             }
06553           }
06554           /* Ignore GRM result during reservation */
06555           src1 = 0;
06556         } else if (_cur.stage == GLS_ACTIVATION) {
06557           switch (feature) {
06558             case 0x00: // Trains
06559             case 0x01: // Road Vehicles
06560             case 0x02: // Ships
06561             case 0x03: // Aircraft
06562               if (!_settings_game.vehicle.dynamic_engines) {
06563                 src1 = PerformGRM(&_grm_engines[_engine_offsets[feature]], _engine_counts[feature], count, op, target, "vehicles");
06564                 if (_cur.skip_sprites == -1) return;
06565               } else {
06566                 /* GRM does not apply for dynamic engine allocation. */
06567                 switch (op) {
06568                   case 2:
06569                   case 3:
06570                     src1 = _cur.grffile->GetParam(target);
06571                     break;
06572 
06573                   default:
06574                     src1 = 0;
06575                     break;
06576                 }
06577               }
06578               break;
06579 
06580             case 0x08: // General sprites
06581               switch (op) {
06582                 case 0:
06583                   /* Return space reserved during reservation stage */
06584                   src1 = _grm_sprites[GRFLocation(_cur.grffile->grfid, _cur.nfo_line)];
06585                   grfmsg(4, "ParamSet: GRM: Using pre-allocated sprites at %d", src1);
06586                   break;
06587 
06588                 case 1:
06589                   src1 = _cur.spriteid;
06590                   break;
06591 
06592                 default:
06593                   grfmsg(1, "ParamSet: GRM: Unsupported operation %d for general sprites", op);
06594                   return;
06595               }
06596               break;
06597 
06598             case 0x0B: // Cargo
06599               /* There are two ranges: one for cargo IDs and one for cargo bitmasks */
06600               src1 = PerformGRM(_grm_cargoes, NUM_CARGO * 2, count, op, target, "cargoes");
06601               if (_cur.skip_sprites == -1) return;
06602               break;
06603 
06604             default: grfmsg(1, "ParamSet: GRM: Unsupported feature 0x%X", feature); return;
06605           }
06606         } else {
06607           /* Ignore GRM during initialization */
06608           src1 = 0;
06609         }
06610       }
06611     } else {
06612       /* Read another GRF File's parameter */
06613       const GRFFile *file = GetFileByGRFID(data);
06614       GRFConfig *c = GetGRFConfig(data);
06615       if (c != NULL && HasBit(c->flags, GCF_STATIC) && !HasBit(_cur.grfconfig->flags, GCF_STATIC) && _networking) {
06616         /* Disable the read GRF if it is a static NewGRF. */
06617         DisableStaticNewGRFInfluencingNonStaticNewGRFs(c);
06618         src1 = 0;
06619       } else if (file == NULL || c == NULL || c->status == GCS_DISABLED) {
06620         src1 = 0;
06621       } else if (src1 == 0xFE) {
06622         src1 = c->version;
06623       } else {
06624         src1 = file->GetParam(src1);
06625       }
06626     }
06627   } else {
06628     /* The source1 and source2 operands refer to the grf parameter number
06629      * like in action 6 and 7.  In addition, they can refer to the special
06630      * variables available in action 7, or they can be FF to use the value
06631      * of <data>.  If referring to parameters that are undefined, a value
06632      * of 0 is used instead.  */
06633     src1 = (src1 == 0xFF) ? data : GetParamVal(src1, NULL);
06634     src2 = (src2 == 0xFF) ? data : GetParamVal(src2, NULL);
06635   }
06636 
06637   /* TODO: You can access the parameters of another GRF file by using
06638    * source2=FE, source1=the other GRF's parameter number and data=GRF
06639    * ID.  This is only valid with operation 00 (set).  If the GRF ID
06640    * cannot be found, a value of 0 is used for the parameter value
06641    * instead. */
06642 
06643   uint32 res;
06644   switch (oper) {
06645     case 0x00:
06646       res = src1;
06647       break;
06648 
06649     case 0x01:
06650       res = src1 + src2;
06651       break;
06652 
06653     case 0x02:
06654       res = src1 - src2;
06655       break;
06656 
06657     case 0x03:
06658       res = src1 * src2;
06659       break;
06660 
06661     case 0x04:
06662       res = (int32)src1 * (int32)src2;
06663       break;
06664 
06665     case 0x05:
06666       if ((int32)src2 < 0) {
06667         res = src1 >> -(int32)src2;
06668       } else {
06669         res = src1 << src2;
06670       }
06671       break;
06672 
06673     case 0x06:
06674       if ((int32)src2 < 0) {
06675         res = (int32)src1 >> -(int32)src2;
06676       } else {
06677         res = (int32)src1 << src2;
06678       }
06679       break;
06680 
06681     case 0x07: // Bitwise AND
06682       res = src1 & src2;
06683       break;
06684 
06685     case 0x08: // Bitwise OR
06686       res = src1 | src2;
06687       break;
06688 
06689     case 0x09: // Unsigned division
06690       if (src2 == 0) {
06691         res = src1;
06692       } else {
06693         res = src1 / src2;
06694       }
06695       break;
06696 
06697     case 0x0A: // Signed divison
06698       if (src2 == 0) {
06699         res = src1;
06700       } else {
06701         res = (int32)src1 / (int32)src2;
06702       }
06703       break;
06704 
06705     case 0x0B: // Unsigned modulo
06706       if (src2 == 0) {
06707         res = src1;
06708       } else {
06709         res = src1 % src2;
06710       }
06711       break;
06712 
06713     case 0x0C: // Signed modulo
06714       if (src2 == 0) {
06715         res = src1;
06716       } else {
06717         res = (int32)src1 % (int32)src2;
06718       }
06719       break;
06720 
06721     default: grfmsg(0, "ParamSet: Unknown operation %d, skipping", oper); return;
06722   }
06723 
06724   switch (target) {
06725     case 0x8E: // Y-Offset for train sprites
06726       _cur.grffile->traininfo_vehicle_pitch = res;
06727       break;
06728 
06729     case 0x8F: { // Rail track type cost factors
06730       extern RailtypeInfo _railtypes[RAILTYPE_END];
06731       _railtypes[RAILTYPE_RAIL].cost_multiplier = GB(res, 0, 8);
06732       if (_settings_game.vehicle.disable_elrails) {
06733         _railtypes[RAILTYPE_ELECTRIC].cost_multiplier = GB(res, 0, 8);
06734         _railtypes[RAILTYPE_MONO].cost_multiplier = GB(res, 8, 8);
06735       } else {
06736         _railtypes[RAILTYPE_ELECTRIC].cost_multiplier = GB(res, 8, 8);
06737         _railtypes[RAILTYPE_MONO].cost_multiplier = GB(res, 16, 8);
06738       }
06739       _railtypes[RAILTYPE_MAGLEV].cost_multiplier = GB(res, 16, 8);
06740       break;
06741     }
06742 
06743     /* @todo implement */
06744     case 0x93: // Tile refresh offset to left
06745     case 0x94: // Tile refresh offset to right
06746     case 0x95: // Tile refresh offset upwards
06747     case 0x96: // Tile refresh offset downwards
06748     case 0x97: // Snow line height
06749     case 0x99: // Global ID offset
06750       grfmsg(7, "ParamSet: Skipping unimplemented target 0x%02X", target);
06751       break;
06752 
06753     case 0x9E: // Miscellaneous GRF features
06754       /* Set train list engine width */
06755       _cur.grffile->traininfo_vehicle_width = HasBit(res, GMB_TRAIN_WIDTH_32_PIXELS) ? VEHICLEINFO_FULL_VEHICLE_WIDTH : TRAININFO_DEFAULT_VEHICLE_WIDTH;
06756       /* Remove the local flags from the global flags */
06757       ClrBit(res, GMB_TRAIN_WIDTH_32_PIXELS);
06758 
06759       _misc_grf_features = res;
06760       break;
06761 
06762     case 0x9F: // locale-dependent settings
06763       grfmsg(7, "ParamSet: Skipping unimplemented target 0x%02X", target);
06764       break;
06765 
06766     default:
06767       if (target < 0x80) {
06768         _cur.grffile->param[target] = res;
06769         /* param is zeroed by default */
06770         if (target + 1U > _cur.grffile->param_end) _cur.grffile->param_end = target + 1;
06771       } else {
06772         grfmsg(7, "ParamSet: Skipping unknown target 0x%02X", target);
06773       }
06774       break;
06775   }
06776 }
06777 
06778 /* Action 0x0E (GLS_SAFETYSCAN) */
06779 static void SafeGRFInhibit(ByteReader *buf)
06780 {
06781   /* <0E> <num> <grfids...>
06782    *
06783    * B num           Number of GRFIDs that follow
06784    * D grfids        GRFIDs of the files to deactivate */
06785 
06786   uint8 num = buf->ReadByte();
06787 
06788   for (uint i = 0; i < num; i++) {
06789     uint32 grfid = buf->ReadDWord();
06790 
06791     /* GRF is unsafe it if tries to deactivate other GRFs */
06792     if (grfid != _cur.grfconfig->ident.grfid) {
06793       SetBit(_cur.grfconfig->flags, GCF_UNSAFE);
06794 
06795       /* Skip remainder of GRF */
06796       _cur.skip_sprites = -1;
06797 
06798       return;
06799     }
06800   }
06801 }
06802 
06803 /* Action 0x0E */
06804 static void GRFInhibit(ByteReader *buf)
06805 {
06806   /* <0E> <num> <grfids...>
06807    *
06808    * B num           Number of GRFIDs that follow
06809    * D grfids        GRFIDs of the files to deactivate */
06810 
06811   uint8 num = buf->ReadByte();
06812 
06813   for (uint i = 0; i < num; i++) {
06814     uint32 grfid = buf->ReadDWord();
06815     GRFConfig *file = GetGRFConfig(grfid);
06816 
06817     /* Unset activation flag */
06818     if (file != NULL && file != _cur.grfconfig) {
06819       grfmsg(2, "GRFInhibit: Deactivating file '%s'", file->filename);
06820       GRFError *error = DisableGrf(STR_NEWGRF_ERROR_FORCEFULLY_DISABLED, file);
06821       error->data = strdup(_cur.grfconfig->GetName());
06822     }
06823   }
06824 }
06825 
06827 static void FeatureTownName(ByteReader *buf)
06828 {
06829   /* <0F> <id> <style-name> <num-parts> <parts>
06830    *
06831    * B id          ID of this definition in bottom 7 bits (final definition if bit 7 set)
06832    * V style-name  Name of the style (only for final definition)
06833    * B num-parts   Number of parts in this definition
06834    * V parts       The parts */
06835 
06836   uint32 grfid = _cur.grffile->grfid;
06837 
06838   GRFTownName *townname = AddGRFTownName(grfid);
06839 
06840   byte id = buf->ReadByte();
06841   grfmsg(6, "FeatureTownName: definition 0x%02X", id & 0x7F);
06842 
06843   if (HasBit(id, 7)) {
06844     /* Final definition */
06845     ClrBit(id, 7);
06846     bool new_scheme = _cur.grffile->grf_version >= 7;
06847 
06848     byte lang = buf->ReadByte();
06849 
06850     byte nb_gen = townname->nb_gen;
06851     do {
06852       ClrBit(lang, 7);
06853 
06854       const char *name = buf->ReadString();
06855 
06856       char *lang_name = TranslateTTDPatchCodes(grfid, lang, false, name);
06857       grfmsg(6, "FeatureTownName: lang 0x%X -> '%s'", lang, lang_name);
06858       free(lang_name);
06859 
06860       townname->name[nb_gen] = AddGRFString(grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
06861 
06862       lang = buf->ReadByte();
06863     } while (lang != 0);
06864     townname->id[nb_gen] = id;
06865     townname->nb_gen++;
06866   }
06867 
06868   byte nb = buf->ReadByte();
06869   grfmsg(6, "FeatureTownName: %u parts", nb);
06870 
06871   townname->nbparts[id] = nb;
06872   townname->partlist[id] = CallocT<NamePartList>(nb);
06873 
06874   for (int i = 0; i < nb; i++) {
06875     byte nbtext =  buf->ReadByte();
06876     townname->partlist[id][i].bitstart  = buf->ReadByte();
06877     townname->partlist[id][i].bitcount  = buf->ReadByte();
06878     townname->partlist[id][i].maxprob   = 0;
06879     townname->partlist[id][i].partcount = nbtext;
06880     townname->partlist[id][i].parts     = CallocT<NamePart>(nbtext);
06881     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);
06882 
06883     for (int j = 0; j < nbtext; j++) {
06884       byte prob = buf->ReadByte();
06885 
06886       if (HasBit(prob, 7)) {
06887         byte ref_id = buf->ReadByte();
06888 
06889         if (townname->nbparts[ref_id] == 0) {
06890           grfmsg(0, "FeatureTownName: definition 0x%02X doesn't exist, deactivating", ref_id);
06891           DelGRFTownName(grfid);
06892           DisableGrf(STR_NEWGRF_ERROR_INVALID_ID);
06893           return;
06894         }
06895 
06896         grfmsg(6, "FeatureTownName: part %d, text %d, uses intermediate definition 0x%02X (with probability %d)", i, j, ref_id, prob & 0x7F);
06897         townname->partlist[id][i].parts[j].data.id = ref_id;
06898       } else {
06899         const char *text = buf->ReadString();
06900         townname->partlist[id][i].parts[j].data.text = TranslateTTDPatchCodes(grfid, 0, false, text);
06901         grfmsg(6, "FeatureTownName: part %d, text %d, '%s' (with probability %d)", i, j, townname->partlist[id][i].parts[j].data.text, prob);
06902       }
06903       townname->partlist[id][i].parts[j].prob = prob;
06904       townname->partlist[id][i].maxprob += GB(prob, 0, 7);
06905     }
06906     grfmsg(6, "FeatureTownName: part %d, total probability %d", i, townname->partlist[id][i].maxprob);
06907   }
06908 }
06909 
06911 static void DefineGotoLabel(ByteReader *buf)
06912 {
06913   /* <10> <label> [<comment>]
06914    *
06915    * B label      The label to define
06916    * V comment    Optional comment - ignored */
06917 
06918   byte nfo_label = buf->ReadByte();
06919 
06920   GRFLabel *label = MallocT<GRFLabel>(1);
06921   label->label    = nfo_label;
06922   label->nfo_line = _cur.nfo_line;
06923   label->pos      = FioGetPos();
06924   label->next     = NULL;
06925 
06926   /* Set up a linked list of goto targets which we will search in an Action 0x7/0x9 */
06927   if (_cur.grffile->label == NULL) {
06928     _cur.grffile->label = label;
06929   } else {
06930     /* Attach the label to the end of the list */
06931     GRFLabel *l;
06932     for (l = _cur.grffile->label; l->next != NULL; l = l->next) {}
06933     l->next = label;
06934   }
06935 
06936   grfmsg(2, "DefineGotoLabel: GOTO target with label 0x%02X", label->label);
06937 }
06938 
06943 static void ImportGRFSound(SoundEntry *sound)
06944 {
06945   const GRFFile *file;
06946   uint32 grfid = FioReadDword();
06947   SoundID sound_id = FioReadWord();
06948 
06949   file = GetFileByGRFID(grfid);
06950   if (file == NULL || file->sound_offset == 0) {
06951     grfmsg(1, "ImportGRFSound: Source file not available");
06952     return;
06953   }
06954 
06955   if (sound_id >= file->num_sounds) {
06956     grfmsg(1, "ImportGRFSound: Sound effect %d is invalid", sound_id);
06957     return;
06958   }
06959 
06960   grfmsg(2, "ImportGRFSound: Copying sound %d (%d) from file %X", sound_id, file->sound_offset + sound_id, grfid);
06961 
06962   *sound = *GetSound(file->sound_offset + sound_id);
06963 
06964   /* Reset volume and priority, which TTDPatch doesn't copy */
06965   sound->volume   = 128;
06966   sound->priority = 0;
06967 }
06968 
06974 static void LoadGRFSound(size_t offs, SoundEntry *sound)
06975 {
06976   /* Set default volume and priority */
06977   sound->volume = 0x80;
06978   sound->priority = 0;
06979 
06980   if (offs != SIZE_MAX) {
06981     /* Sound is present in the NewGRF. */
06982     sound->file_slot = _cur.file_index;
06983     sound->file_offset = offs;
06984     sound->grf_container_ver = _cur.grf_container_ver;
06985   }
06986 }
06987 
06988 /* Action 0x11 */
06989 static void GRFSound(ByteReader *buf)
06990 {
06991   /* <11> <num>
06992    *
06993    * W num      Number of sound files that follow */
06994 
06995   uint16 num = buf->ReadWord();
06996   if (num == 0) return;
06997 
06998   SoundEntry *sound;
06999   if (_cur.grffile->sound_offset == 0) {
07000     _cur.grffile->sound_offset = GetNumSounds();
07001     _cur.grffile->num_sounds = num;
07002     sound = AllocateSound(num);
07003   } else {
07004     sound = GetSound(_cur.grffile->sound_offset);
07005   }
07006 
07007   for (int i = 0; i < num; i++) {
07008     _cur.nfo_line++;
07009 
07010     /* Check whether the index is in range. This might happen if multiple action 11 are present.
07011      * While this is invalid, we do not check for this. But we should prevent it from causing bigger trouble */
07012     bool invalid = i >= _cur.grffile->num_sounds;
07013 
07014     size_t offs = FioGetPos();
07015 
07016     uint32 len = _cur.grf_container_ver >= 2 ? FioReadDword() : FioReadWord();
07017     byte type = FioReadByte();
07018 
07019     if (_cur.grf_container_ver >= 2 && type == 0xFD) {
07020       /* Reference to sprite section. */
07021       if (invalid) {
07022         grfmsg(1, "GRFSound: Sound index out of range (multiple Action 11?)");
07023         FioSkipBytes(len);
07024       } else if (len != 4) {
07025         grfmsg(1, "GRFSound: Invalid sprite section import");
07026         FioSkipBytes(len);
07027       } else {
07028         uint32 id = FioReadDword();
07029         if (_cur.stage == GLS_INIT) LoadGRFSound(GetGRFSpriteOffset(id), sound + i);
07030       }
07031       continue;
07032     }
07033 
07034     if (type != 0xFF) {
07035       grfmsg(1, "GRFSound: Unexpected RealSprite found, skipping");
07036       FioSkipBytes(7);
07037       SkipSpriteData(type, len - 8);
07038       continue;
07039     }
07040 
07041     if (invalid) {
07042       grfmsg(1, "GRFSound: Sound index out of range (multiple Action 11?)");
07043       FioSkipBytes(len);
07044     }
07045 
07046     byte action = FioReadByte();
07047     switch (action) {
07048       case 0xFF:
07049         /* Allocate sound only in init stage. */
07050         if (_cur.stage == GLS_INIT) {
07051           if (_cur.grf_container_ver >= 2) {
07052             grfmsg(1, "GRFSound: Inline sounds are not supported for container version >= 2");
07053           } else {
07054             LoadGRFSound(offs, sound + i);
07055           }
07056         }
07057         FioSkipBytes(len - 1); // already read <action>
07058         break;
07059 
07060       case 0xFE:
07061         if (_cur.stage == GLS_ACTIVATION) {
07062           /* XXX 'Action 0xFE' isn't really specified. It is only mentioned for
07063            * importing sounds, so this is probably all wrong... */
07064           if (FioReadByte() != 0) grfmsg(1, "GRFSound: Import type mismatch");
07065           ImportGRFSound(sound + i);
07066         } else {
07067           FioSkipBytes(len - 1); // already read <action>
07068         }
07069         break;
07070 
07071       default:
07072         grfmsg(1, "GRFSound: Unexpected Action %x found, skipping", action);
07073         FioSkipBytes(len - 1); // already read <action>
07074         break;
07075     }
07076   }
07077 }
07078 
07079 /* Action 0x11 (SKIP) */
07080 static void SkipAct11(ByteReader *buf)
07081 {
07082   /* <11> <num>
07083    *
07084    * W num      Number of sound files that follow */
07085 
07086   _cur.skip_sprites = buf->ReadWord();
07087 
07088   grfmsg(3, "SkipAct11: Skipping %d sprites", _cur.skip_sprites);
07089 }
07090 
07092 static void LoadFontGlyph(ByteReader *buf)
07093 {
07094   /* <12> <num_def> <font_size> <num_char> <base_char>
07095    *
07096    * B num_def      Number of definitions
07097    * B font_size    Size of font (0 = normal, 1 = small, 2 = large, 3 = mono)
07098    * B num_char     Number of consecutive glyphs
07099    * W base_char    First character index */
07100 
07101   uint8 num_def = buf->ReadByte();
07102 
07103   for (uint i = 0; i < num_def; i++) {
07104     FontSize size    = (FontSize)buf->ReadByte();
07105     uint8  num_char  = buf->ReadByte();
07106     uint16 base_char = buf->ReadWord();
07107 
07108     if (size >= FS_END) {
07109       grfmsg(1, "LoadFontGlyph: Size %u is not supported, ignoring", size);
07110     }
07111 
07112     grfmsg(7, "LoadFontGlyph: Loading %u glyph(s) at 0x%04X for size %u", num_char, base_char, size);
07113 
07114     for (uint c = 0; c < num_char; c++) {
07115       if (size < FS_END) SetUnicodeGlyph(size, base_char + c, _cur.spriteid);
07116       _cur.nfo_line++;
07117       LoadNextSprite(_cur.spriteid++, _cur.file_index, _cur.nfo_line, _cur.grf_container_ver);
07118     }
07119   }
07120 }
07121 
07123 static void SkipAct12(ByteReader *buf)
07124 {
07125   /* <12> <num_def> <font_size> <num_char> <base_char>
07126    *
07127    * B num_def      Number of definitions
07128    * B font_size    Size of font (0 = normal, 1 = small, 2 = large)
07129    * B num_char     Number of consecutive glyphs
07130    * W base_char    First character index */
07131 
07132   uint8 num_def = buf->ReadByte();
07133 
07134   for (uint i = 0; i < num_def; i++) {
07135     /* Ignore 'size' byte */
07136     buf->ReadByte();
07137 
07138     /* Sum up number of characters */
07139     _cur.skip_sprites += buf->ReadByte();
07140 
07141     /* Ignore 'base_char' word */
07142     buf->ReadWord();
07143   }
07144 
07145   grfmsg(3, "SkipAct12: Skipping %d sprites", _cur.skip_sprites);
07146 }
07147 
07149 static void TranslateGRFStrings(ByteReader *buf)
07150 {
07151   /* <13> <grfid> <num-ent> <offset> <text...>
07152    *
07153    * 4*B grfid     The GRFID of the file whose texts are to be translated
07154    * B   num-ent   Number of strings
07155    * W   offset    First text ID
07156    * S   text...   Zero-terminated strings */
07157 
07158   uint32 grfid = buf->ReadDWord();
07159   const GRFConfig *c = GetGRFConfig(grfid);
07160   if (c == NULL || (c->status != GCS_INITIALISED && c->status != GCS_ACTIVATED)) {
07161     grfmsg(7, "TranslateGRFStrings: GRFID 0x%08x unknown, skipping action 13", BSWAP32(grfid));
07162     return;
07163   }
07164 
07165   if (c->status == GCS_INITIALISED) {
07166     /* If the file is not active but will be activated later, give an error
07167      * and disable this file. */
07168     GRFError *error = DisableGrf(STR_NEWGRF_ERROR_LOAD_AFTER);
07169 
07170     char tmp[256];
07171     GetString(tmp, STR_NEWGRF_ERROR_AFTER_TRANSLATED_FILE, lastof(tmp));
07172     error->data = strdup(tmp);
07173 
07174     return;
07175   }
07176 
07177   /* Since no language id is supplied for with version 7 and lower NewGRFs, this string has
07178    * to be added as a generic string, thus the language id of 0x7F. For this to work
07179    * new_scheme has to be true as well, which will also be implicitly the case for version 8
07180    * and higher. A language id of 0x7F will be overridden by a non-generic id, so this will
07181    * not change anything if a string has been provided specifically for this language. */
07182   byte language = _cur.grffile->grf_version >= 8 ? buf->ReadByte() : 0x7F;
07183   byte num_strings = buf->ReadByte();
07184   uint16 first_id  = buf->ReadWord();
07185 
07186   if (!((first_id >= 0xD000 && first_id + num_strings <= 0xD3FF) || (first_id >= 0xDC00 && first_id + num_strings <= 0xDCFF))) {
07187     grfmsg(7, "TranslateGRFStrings: Attempting to set out-of-range string IDs in action 13 (first: 0x%4X, number: 0x%2X)", first_id, num_strings);
07188     return;
07189   }
07190 
07191   for (uint i = 0; i < num_strings && buf->HasData(); i++) {
07192     const char *string = buf->ReadString();
07193 
07194     if (StrEmpty(string)) {
07195       grfmsg(7, "TranslateGRFString: Ignoring empty string.");
07196       continue;
07197     }
07198 
07199     AddGRFString(grfid, first_id + i, language, true, true, string, STR_UNDEFINED);
07200   }
07201 }
07202 
07204 static bool ChangeGRFName(byte langid, const char *str)
07205 {
07206   AddGRFTextToList(&_cur.grfconfig->name->text, langid, _cur.grfconfig->ident.grfid, false, str);
07207   return true;
07208 }
07209 
07211 static bool ChangeGRFDescription(byte langid, const char *str)
07212 {
07213   AddGRFTextToList(&_cur.grfconfig->info->text, langid, _cur.grfconfig->ident.grfid, true, str);
07214   return true;
07215 }
07216 
07218 static bool ChangeGRFURL(byte langid, const char *str)
07219 {
07220   AddGRFTextToList(&_cur.grfconfig->url->text, langid, _cur.grfconfig->ident.grfid, false, str);
07221   return true;
07222 }
07223 
07225 static bool ChangeGRFNumUsedParams(size_t len, ByteReader *buf)
07226 {
07227   if (len != 1) {
07228     grfmsg(2, "StaticGRFInfo: expected only 1 byte for 'INFO'->'NPAR' but got " PRINTF_SIZE ", ignoring this field", len);
07229     buf->Skip(len);
07230   } else {
07231     _cur.grfconfig->num_valid_params = min(buf->ReadByte(), lengthof(_cur.grfconfig->param));
07232   }
07233   return true;
07234 }
07235 
07237 static bool ChangeGRFPalette(size_t len, ByteReader *buf)
07238 {
07239   if (len != 1) {
07240     grfmsg(2, "StaticGRFInfo: expected only 1 byte for 'INFO'->'PALS' but got " PRINTF_SIZE ", ignoring this field", len);
07241     buf->Skip(len);
07242   } else {
07243     char data = buf->ReadByte();
07244     GRFPalette pal = GRFP_GRF_UNSET;
07245     switch (data) {
07246       case '*':
07247       case 'A': pal = GRFP_GRF_ANY;     break;
07248       case 'W': pal = GRFP_GRF_WINDOWS; break;
07249       case 'D': pal = GRFP_GRF_DOS;     break;
07250       default:
07251         grfmsg(2, "StaticGRFInfo: unexpected value '%02x' for 'INFO'->'PALS', ignoring this field", data);
07252         break;
07253     }
07254     if (pal != GRFP_GRF_UNSET) {
07255       _cur.grfconfig->palette &= ~GRFP_GRF_MASK;
07256       _cur.grfconfig->palette |= pal;
07257     }
07258   }
07259   return true;
07260 }
07261 
07263 static bool ChangeGRFBlitter(size_t len, ByteReader *buf)
07264 {
07265   if (len != 1) {
07266     grfmsg(2, "StaticGRFInfo: expected only 1 byte for 'INFO'->'BLTR' but got " PRINTF_SIZE ", ignoring this field", len);
07267     buf->Skip(len);
07268   } else {
07269     char data = buf->ReadByte();
07270     GRFPalette pal = GRFP_BLT_UNSET;
07271     switch (data) {
07272       case '8': pal = GRFP_BLT_UNSET; break;
07273       case '3': pal = GRFP_BLT_32BPP;  break;
07274       default:
07275         grfmsg(2, "StaticGRFInfo: unexpected value '%02x' for 'INFO'->'BLTR', ignoring this field", data);
07276         return true;
07277     }
07278     _cur.grfconfig->palette &= ~GRFP_BLT_MASK;
07279     _cur.grfconfig->palette |= pal;
07280   }
07281   return true;
07282 }
07283 
07285 static bool ChangeGRFVersion(size_t len, ByteReader *buf)
07286 {
07287   if (len != 4) {
07288     grfmsg(2, "StaticGRFInfo: expected 4 bytes for 'INFO'->'VRSN' but got " PRINTF_SIZE ", ignoring this field", len);
07289     buf->Skip(len);
07290   } else {
07291     /* Set min_loadable_version as well (default to minimal compatibility) */
07292     _cur.grfconfig->version = _cur.grfconfig->min_loadable_version = buf->ReadDWord();
07293   }
07294   return true;
07295 }
07296 
07298 static bool ChangeGRFMinVersion(size_t len, ByteReader *buf)
07299 {
07300   if (len != 4) {
07301     grfmsg(2, "StaticGRFInfo: expected 4 bytes for 'INFO'->'MINV' but got " PRINTF_SIZE ", ignoring this field", len);
07302     buf->Skip(len);
07303   } else {
07304     _cur.grfconfig->min_loadable_version = buf->ReadDWord();
07305     if (_cur.grfconfig->version == 0) {
07306       grfmsg(2, "StaticGRFInfo: 'MINV' defined before 'VRSN' or 'VRSN' set to 0, ignoring this field");
07307       _cur.grfconfig->min_loadable_version = 0;
07308     }
07309     if (_cur.grfconfig->version < _cur.grfconfig->min_loadable_version) {
07310       grfmsg(2, "StaticGRFInfo: 'MINV' defined as %d, limiting it to 'VRSN'", _cur.grfconfig->min_loadable_version);
07311       _cur.grfconfig->min_loadable_version = _cur.grfconfig->version;
07312     }
07313   }
07314   return true;
07315 }
07316 
07317 static GRFParameterInfo *_cur_parameter; 
07318 
07320 static bool ChangeGRFParamName(byte langid, const char *str)
07321 {
07322   AddGRFTextToList(&_cur_parameter->name, langid, _cur.grfconfig->ident.grfid, false, str);
07323   return true;
07324 }
07325 
07327 static bool ChangeGRFParamDescription(byte langid, const char *str)
07328 {
07329   AddGRFTextToList(&_cur_parameter->desc, langid, _cur.grfconfig->ident.grfid, true, str);
07330   return true;
07331 }
07332 
07334 static bool ChangeGRFParamType(size_t len, ByteReader *buf)
07335 {
07336   if (len != 1) {
07337     grfmsg(2, "StaticGRFInfo: expected 1 byte for 'INFO'->'PARA'->'TYPE' but got " PRINTF_SIZE ", ignoring this field", len);
07338     buf->Skip(len);
07339   } else {
07340     GRFParameterType type = (GRFParameterType)buf->ReadByte();
07341     if (type < PTYPE_END) {
07342       _cur_parameter->type = type;
07343     } else {
07344       grfmsg(3, "StaticGRFInfo: unknown parameter type %d, ignoring this field", type);
07345     }
07346   }
07347   return true;
07348 }
07349 
07351 static bool ChangeGRFParamLimits(size_t len, ByteReader *buf)
07352 {
07353   if (_cur_parameter->type != PTYPE_UINT_ENUM) {
07354     grfmsg(2, "StaticGRFInfo: 'INFO'->'PARA'->'LIMI' is only valid for parameters with type uint/enum, ignoring this field");
07355     buf->Skip(len);
07356   } else if (len != 8) {
07357     grfmsg(2, "StaticGRFInfo: expected 8 bytes for 'INFO'->'PARA'->'LIMI' but got " PRINTF_SIZE ", ignoring this field", len);
07358     buf->Skip(len);
07359   } else {
07360     _cur_parameter->min_value = buf->ReadDWord();
07361     _cur_parameter->max_value = buf->ReadDWord();
07362   }
07363   return true;
07364 }
07365 
07367 static bool ChangeGRFParamMask(size_t len, ByteReader *buf)
07368 {
07369   if (len < 1 || len > 3) {
07370     grfmsg(2, "StaticGRFInfo: expected 1 to 3 bytes for 'INFO'->'PARA'->'MASK' but got " PRINTF_SIZE ", ignoring this field", len);
07371     buf->Skip(len);
07372   } else {
07373     byte param_nr = buf->ReadByte();
07374     if (param_nr >= lengthof(_cur.grfconfig->param)) {
07375       grfmsg(2, "StaticGRFInfo: invalid parameter number in 'INFO'->'PARA'->'MASK', param %d, ignoring this field", param_nr);
07376       buf->Skip(len - 1);
07377     } else {
07378       _cur_parameter->param_nr = param_nr;
07379       if (len >= 2) _cur_parameter->first_bit = min(buf->ReadByte(), 31);
07380       if (len >= 3) _cur_parameter->num_bit = min(buf->ReadByte(), 32 - _cur_parameter->first_bit);
07381     }
07382   }
07383 
07384   return true;
07385 }
07386 
07388 static bool ChangeGRFParamDefault(size_t len, ByteReader *buf)
07389 {
07390   if (len != 4) {
07391     grfmsg(2, "StaticGRFInfo: expected 4 bytes for 'INFO'->'PARA'->'DEFA' but got " PRINTF_SIZE ", ignoring this field", len);
07392     buf->Skip(len);
07393   } else {
07394     _cur_parameter->def_value = buf->ReadDWord();
07395   }
07396   _cur.grfconfig->has_param_defaults = true;
07397   return true;
07398 }
07399 
07400 typedef bool (*DataHandler)(size_t, ByteReader *);  
07401 typedef bool (*TextHandler)(byte, const char *str); 
07402 typedef bool (*BranchHandler)(ByteReader *);        
07403 
07411 struct AllowedSubtags {
07413   AllowedSubtags() :
07414     id(0),
07415     type(0)
07416   {}
07417 
07423   AllowedSubtags(uint32 id, DataHandler handler) :
07424     id(id),
07425     type('B')
07426   {
07427     this->handler.data = handler;
07428   }
07429 
07435   AllowedSubtags(uint32 id, TextHandler handler) :
07436     id(id),
07437     type('T')
07438   {
07439     this->handler.text = handler;
07440   }
07441 
07447   AllowedSubtags(uint32 id, BranchHandler handler) :
07448     id(id),
07449     type('C')
07450   {
07451     this->handler.call_handler = true;
07452     this->handler.u.branch = handler;
07453   }
07454 
07460   AllowedSubtags(uint32 id, AllowedSubtags *subtags) :
07461     id(id),
07462     type('C')
07463   {
07464     this->handler.call_handler = false;
07465     this->handler.u.subtags = subtags;
07466   }
07467 
07468   uint32 id; 
07469   byte type; 
07470   union {
07471     DataHandler data; 
07472     TextHandler text; 
07473     struct {
07474       union {
07475         BranchHandler branch;    
07476         AllowedSubtags *subtags; 
07477       } u;
07478       bool call_handler; 
07479     };
07480   } handler;
07481 };
07482 
07483 static bool SkipUnknownInfo(ByteReader *buf, byte type);
07484 static bool HandleNodes(ByteReader *buf, AllowedSubtags *tags);
07485 
07492 static bool ChangeGRFParamValueNames(ByteReader *buf)
07493 {
07494   byte type = buf->ReadByte();
07495   while (type != 0) {
07496     uint32 id = buf->ReadDWord();
07497     if (type != 'T' || id > _cur_parameter->max_value) {
07498       grfmsg(2, "StaticGRFInfo: all child nodes of 'INFO'->'PARA'->param_num->'VALU' should have type 't' and the value/bit number as id");
07499       if (!SkipUnknownInfo(buf, type)) return false;
07500       type = buf->ReadByte();
07501       continue;
07502     }
07503 
07504     byte langid = buf->ReadByte();
07505     const char *name_string = buf->ReadString();
07506 
07507     SmallPair<uint32, GRFText *> *val_name = _cur_parameter->value_names.Find(id);
07508     if (val_name != _cur_parameter->value_names.End()) {
07509       AddGRFTextToList(&val_name->second, langid, _cur.grfconfig->ident.grfid, false, name_string);
07510     } else {
07511       GRFText *list = NULL;
07512       AddGRFTextToList(&list, langid, _cur.grfconfig->ident.grfid, false, name_string);
07513       _cur_parameter->value_names.Insert(id, list);
07514     }
07515 
07516     type = buf->ReadByte();
07517   }
07518   return true;
07519 }
07520 
07522 AllowedSubtags _tags_parameters[] = {
07523   AllowedSubtags('NAME', ChangeGRFParamName),
07524   AllowedSubtags('DESC', ChangeGRFParamDescription),
07525   AllowedSubtags('TYPE', ChangeGRFParamType),
07526   AllowedSubtags('LIMI', ChangeGRFParamLimits),
07527   AllowedSubtags('MASK', ChangeGRFParamMask),
07528   AllowedSubtags('VALU', ChangeGRFParamValueNames),
07529   AllowedSubtags('DFLT', ChangeGRFParamDefault),
07530   AllowedSubtags()
07531 };
07532 
07539 static bool HandleParameterInfo(ByteReader *buf)
07540 {
07541   byte type = buf->ReadByte();
07542   while (type != 0) {
07543     uint32 id = buf->ReadDWord();
07544     if (type != 'C' || id >= _cur.grfconfig->num_valid_params) {
07545       grfmsg(2, "StaticGRFInfo: all child nodes of 'INFO'->'PARA' should have type 'C' and their parameter number as id");
07546       if (!SkipUnknownInfo(buf, type)) return false;
07547       type = buf->ReadByte();
07548       continue;
07549     }
07550 
07551     if (id >= _cur.grfconfig->param_info.Length()) {
07552       uint num_to_add = id - _cur.grfconfig->param_info.Length() + 1;
07553       GRFParameterInfo **newdata = _cur.grfconfig->param_info.Append(num_to_add);
07554       MemSetT<GRFParameterInfo *>(newdata, 0, num_to_add);
07555     }
07556     if (_cur.grfconfig->param_info[id] == NULL) {
07557       _cur.grfconfig->param_info[id] = new GRFParameterInfo(id);
07558     }
07559     _cur_parameter = _cur.grfconfig->param_info[id];
07560     /* Read all parameter-data and process each node. */
07561     if (!HandleNodes(buf, _tags_parameters)) return false;
07562     type = buf->ReadByte();
07563   }
07564   return true;
07565 }
07566 
07568 AllowedSubtags _tags_info[] = {
07569   AllowedSubtags('NAME', ChangeGRFName),
07570   AllowedSubtags('DESC', ChangeGRFDescription),
07571   AllowedSubtags('URL_', ChangeGRFURL),
07572   AllowedSubtags('NPAR', ChangeGRFNumUsedParams),
07573   AllowedSubtags('PALS', ChangeGRFPalette),
07574   AllowedSubtags('BLTR', ChangeGRFBlitter),
07575   AllowedSubtags('VRSN', ChangeGRFVersion),
07576   AllowedSubtags('MINV', ChangeGRFMinVersion),
07577   AllowedSubtags('PARA', HandleParameterInfo),
07578   AllowedSubtags()
07579 };
07580 
07582 AllowedSubtags _tags_root[] = {
07583   AllowedSubtags('INFO', _tags_info),
07584   AllowedSubtags()
07585 };
07586 
07587 
07594 static bool SkipUnknownInfo(ByteReader *buf, byte type)
07595 {
07596   /* type and id are already read */
07597   switch (type) {
07598     case 'C': {
07599       byte new_type = buf->ReadByte();
07600       while (new_type != 0) {
07601         buf->ReadDWord(); // skip the id
07602         if (!SkipUnknownInfo(buf, new_type)) return false;
07603         new_type = buf->ReadByte();
07604       }
07605       break;
07606     }
07607 
07608     case 'T':
07609       buf->ReadByte(); // lang
07610       buf->ReadString(); // actual text
07611       break;
07612 
07613     case 'B': {
07614       uint16 size = buf->ReadWord();
07615       buf->Skip(size);
07616       break;
07617     }
07618 
07619     default:
07620       return false;
07621   }
07622 
07623   return true;
07624 }
07625 
07634 static bool HandleNode(byte type, uint32 id, ByteReader *buf, AllowedSubtags subtags[])
07635 {
07636   uint i = 0;
07637   AllowedSubtags *tag;
07638   while ((tag = &subtags[i++])->type != 0) {
07639     if (tag->id != BSWAP32(id) || tag->type != type) continue;
07640     switch (type) {
07641       default: NOT_REACHED();
07642 
07643       case 'T': {
07644         byte langid = buf->ReadByte();
07645         return tag->handler.text(langid, buf->ReadString());
07646       }
07647 
07648       case 'B': {
07649         size_t len = buf->ReadWord();
07650         if (buf->Remaining() < len) return false;
07651         return tag->handler.data(len, buf);
07652       }
07653 
07654       case 'C': {
07655         if (tag->handler.call_handler) {
07656           return tag->handler.u.branch(buf);
07657         }
07658         return HandleNodes(buf, tag->handler.u.subtags);
07659       }
07660     }
07661   }
07662   grfmsg(2, "StaticGRFInfo: unknown type/id combination found, type=%c, id=%x", type, id);
07663   return SkipUnknownInfo(buf, type);
07664 }
07665 
07672 static bool HandleNodes(ByteReader *buf, AllowedSubtags subtags[])
07673 {
07674   byte type = buf->ReadByte();
07675   while (type != 0) {
07676     uint32 id = buf->ReadDWord();
07677     if (!HandleNode(type, id, buf, subtags)) return false;
07678     type = buf->ReadByte();
07679   }
07680   return true;
07681 }
07682 
07687 static void StaticGRFInfo(ByteReader *buf)
07688 {
07689   /* <14> <type> <id> <text/data...> */
07690   HandleNodes(buf, _tags_root);
07691 }
07692 
07698 static void GRFUnsafe(ByteReader *buf)
07699 {
07700   SetBit(_cur.grfconfig->flags, GCF_UNSAFE);
07701 
07702   /* Skip remainder of GRF */
07703   _cur.skip_sprites = -1;
07704 }
07705 
07706 
07708 static void InitializeGRFSpecial()
07709 {
07710   _ttdpatch_flags[0] = ((_settings_game.station.never_expire_airports ? 1 : 0) << 0x0C)  // keepsmallairport
07711                      |                                                      (1 << 0x0D)  // newairports
07712                      |                                                      (1 << 0x0E)  // largestations
07713                      | ((_settings_game.construction.max_bridge_length > 16 ? 1 : 0) << 0x0F)  // longbridges
07714                      |                                                      (0 << 0x10)  // loadtime
07715                      |                                                      (1 << 0x12)  // presignals
07716                      |                                                      (1 << 0x13)  // extpresignals
07717                      | ((_settings_game.vehicle.never_expire_vehicles ? 1 : 0) << 0x16)  // enginespersist
07718                      |                                                      (1 << 0x1B)  // multihead
07719                      |                                                      (1 << 0x1D)  // lowmemory
07720                      |                                                      (1 << 0x1E); // generalfixes
07721 
07722   _ttdpatch_flags[1] =   ((_settings_game.economy.station_noise_level ? 1 : 0) << 0x07)  // moreairports - based on units of noise
07723                      |                                                      (1 << 0x08)  // mammothtrains
07724                      |                                                      (1 << 0x09)  // trainrefit
07725                      |                                                      (0 << 0x0B)  // subsidiaries
07726                      |         ((_settings_game.order.gradual_loading ? 1 : 0) << 0x0C)  // gradualloading
07727                      |                                                      (1 << 0x12)  // unifiedmaglevmode - set bit 0 mode. Not revelant to OTTD
07728                      |                                                      (1 << 0x13)  // unifiedmaglevmode - set bit 1 mode
07729                      |                                                      (1 << 0x14)  // bridgespeedlimits
07730                      |                                                      (1 << 0x16)  // eternalgame
07731                      |                                                      (1 << 0x17)  // newtrains
07732                      |                                                      (1 << 0x18)  // newrvs
07733                      |                                                      (1 << 0x19)  // newships
07734                      |                                                      (1 << 0x1A)  // newplanes
07735                      | ((_settings_game.construction.train_signal_side == 1 ? 1 : 0) << 0x1B)  // signalsontrafficside
07736                      |       ((_settings_game.vehicle.disable_elrails ? 0 : 1) << 0x1C); // electrifiedrailway
07737 
07738   _ttdpatch_flags[2] =                                                      (1 << 0x01)  // loadallgraphics - obsolote
07739                      |                                                      (1 << 0x03)  // semaphores
07740                      |                                                      (1 << 0x0A)  // newobjects
07741                      |                                                      (0 << 0x0B)  // enhancedgui
07742                      |                                                      (0 << 0x0C)  // newagerating
07743                      |  ((_settings_game.construction.build_on_slopes ? 1 : 0) << 0x0D)  // buildonslopes
07744                      |                                                      (1 << 0x0E)  // fullloadany
07745                      |                                                      (1 << 0x0F)  // planespeed
07746                      |                                                      (0 << 0x10)  // moreindustriesperclimate - obsolete
07747                      |                                                      (0 << 0x11)  // moretoylandfeatures
07748                      |                                                      (1 << 0x12)  // newstations
07749                      |                                                      (1 << 0x13)  // tracktypecostdiff
07750                      |                                                      (1 << 0x14)  // manualconvert
07751                      |  ((_settings_game.construction.build_on_slopes ? 1 : 0) << 0x15)  // buildoncoasts
07752                      |                                                      (1 << 0x16)  // canals
07753                      |                                                      (1 << 0x17)  // newstartyear
07754                      |    ((_settings_game.vehicle.freight_trains > 1 ? 1 : 0) << 0x18)  // freighttrains
07755                      |                                                      (1 << 0x19)  // newhouses
07756                      |                                                      (1 << 0x1A)  // newbridges
07757                      |                                                      (1 << 0x1B)  // newtownnames
07758                      |                                                      (1 << 0x1C)  // moreanimation
07759                      |    ((_settings_game.vehicle.wagon_speed_limits ? 1 : 0) << 0x1D)  // wagonspeedlimits
07760                      |                                                      (1 << 0x1E)  // newshistory
07761                      |                                                      (0 << 0x1F); // custombridgeheads
07762 
07763   _ttdpatch_flags[3] =                                                      (0 << 0x00)  // newcargodistribution
07764                      |                                                      (1 << 0x01)  // windowsnap
07765                      | ((_settings_game.economy.allow_town_roads || _generating_world ? 0 : 1) << 0x02)  // townbuildnoroad
07766                      |                                                      (1 << 0x03)  // pathbasedsignalling
07767                      |                                                      (0 << 0x04)  // aichoosechance
07768                      |                                                      (1 << 0x05)  // resolutionwidth
07769                      |                                                      (1 << 0x06)  // resolutionheight
07770                      |                                                      (1 << 0x07)  // newindustries
07771                      |           ((_settings_game.order.improved_load ? 1 : 0) << 0x08)  // fifoloading
07772                      |                                                      (0 << 0x09)  // townroadbranchprob
07773                      |                                                      (0 << 0x0A)  // tempsnowline
07774                      |                                                      (1 << 0x0B)  // newcargo
07775                      |                                                      (1 << 0x0C)  // enhancemultiplayer
07776                      |                                                      (1 << 0x0D)  // onewayroads
07777                      |                                                      (1 << 0x0E)  // irregularstations
07778                      |                                                      (1 << 0x0F)  // statistics
07779                      |                                                      (1 << 0x10)  // newsounds
07780                      |                                                      (1 << 0x11)  // autoreplace
07781                      |                                                      (1 << 0x12)  // autoslope
07782                      |                                                      (0 << 0x13)  // followvehicle
07783                      |                                                      (1 << 0x14)  // trams
07784                      |                                                      (0 << 0x15)  // enhancetunnels
07785                      |                                                      (1 << 0x16)  // shortrvs
07786                      |                                                      (1 << 0x17)  // articulatedrvs
07787                      |       ((_settings_game.vehicle.dynamic_engines ? 1 : 0) << 0x18)  // dynamic engines
07788                      |                                                      (1 << 0x1E)  // variablerunningcosts
07789                      |                                                      (1 << 0x1F); // any switch is on
07790 }
07791 
07793 static void ResetCustomStations()
07794 {
07795   const GRFFile * const *end = _grf_files.End();
07796   for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
07797     StationSpec **&stations = (*file)->stations;
07798     if (stations == NULL) continue;
07799     for (uint i = 0; i < NUM_STATIONS_PER_GRF; i++) {
07800       if (stations[i] == NULL) continue;
07801       StationSpec *statspec = stations[i];
07802 
07803       delete[] statspec->renderdata;
07804 
07805       /* Release platforms and layouts */
07806       if (!statspec->copied_layouts) {
07807         for (uint l = 0; l < statspec->lengths; l++) {
07808           for (uint p = 0; p < statspec->platforms[l]; p++) {
07809             free(statspec->layouts[l][p]);
07810           }
07811           free(statspec->layouts[l]);
07812         }
07813         free(statspec->layouts);
07814         free(statspec->platforms);
07815       }
07816 
07817       /* Release this station */
07818       free(statspec);
07819     }
07820 
07821     /* Free and reset the station data */
07822     free(stations);
07823     stations = NULL;
07824   }
07825 }
07826 
07828 static void ResetCustomHouses()
07829 {
07830   const GRFFile * const *end = _grf_files.End();
07831   for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
07832     HouseSpec **&housespec = (*file)->housespec;
07833     if (housespec == NULL) continue;
07834     for (uint i = 0; i < NUM_HOUSES_PER_GRF; i++) {
07835       free(housespec[i]);
07836     }
07837 
07838     free(housespec);
07839     housespec = NULL;
07840   }
07841 }
07842 
07844 static void ResetCustomAirports()
07845 {
07846   const GRFFile * const *end = _grf_files.End();
07847   for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
07848     AirportSpec **aslist = (*file)->airportspec;
07849     if (aslist != NULL) {
07850       for (uint i = 0; i < NUM_AIRPORTS_PER_GRF; i++) {
07851         AirportSpec *as = aslist[i];
07852 
07853         if (as != NULL) {
07854           /* We need to remove the tiles layouts */
07855           for (int j = 0; j < as->num_table; j++) {
07856             /* remove the individual layouts */
07857             free(as->table[j]);
07858           }
07859           free(as->table);
07860           free(as->depot_table);
07861 
07862           free(as);
07863         }
07864       }
07865       free(aslist);
07866       (*file)->airportspec = NULL;
07867     }
07868 
07869     AirportTileSpec **&airporttilespec = (*file)->airtspec;
07870     if (airporttilespec != NULL) {
07871       for (uint i = 0; i < NUM_AIRPORTTILES_PER_GRF; i++) {
07872         free(airporttilespec[i]);
07873       }
07874       free(airporttilespec);
07875       airporttilespec = NULL;
07876     }
07877   }
07878 }
07879 
07881 static void ResetCustomIndustries()
07882 {
07883   const GRFFile * const *end = _grf_files.End();
07884   for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
07885     IndustrySpec **&industryspec = (*file)->industryspec;
07886     IndustryTileSpec **&indtspec = (*file)->indtspec;
07887 
07888     /* We are verifiying both tiles and industries specs loaded from the grf file
07889      * First, let's deal with industryspec */
07890     if (industryspec != NULL) {
07891       for (uint i = 0; i < NUM_INDUSTRYTYPES_PER_GRF; i++) {
07892         IndustrySpec *ind = industryspec[i];
07893         if (ind == NULL) continue;
07894 
07895         /* We need to remove the sounds array */
07896         if (HasBit(ind->cleanup_flag, CLEAN_RANDOMSOUNDS)) {
07897           free(ind->random_sounds);
07898         }
07899 
07900         /* We need to remove the tiles layouts */
07901         CleanIndustryTileTable(ind);
07902 
07903         free(ind);
07904       }
07905 
07906       free(industryspec);
07907       industryspec = NULL;
07908     }
07909 
07910     if (indtspec == NULL) continue;
07911     for (uint i = 0; i < NUM_INDUSTRYTILES_PER_GRF; i++) {
07912       free(indtspec[i]);
07913     }
07914 
07915     free(indtspec);
07916     indtspec = NULL;
07917   }
07918 }
07919 
07921 static void ResetCustomObjects()
07922 {
07923   const GRFFile * const *end = _grf_files.End();
07924   for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
07925     ObjectSpec **&objectspec = (*file)->objectspec;
07926     if (objectspec == NULL) continue;
07927     for (uint i = 0; i < NUM_OBJECTS_PER_GRF; i++) {
07928       free(objectspec[i]);
07929     }
07930 
07931     free(objectspec);
07932     objectspec = NULL;
07933   }
07934 }
07935 
07937 static void ResetNewGRF()
07938 {
07939   const GRFFile * const *end = _grf_files.End();
07940   for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
07941     delete *file;
07942   }
07943 
07944   _grf_files.Clear();
07945   _cur.grffile   = NULL;
07946 }
07947 
07949 static void ResetNewGRFErrors()
07950 {
07951   for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
07952     if (!HasBit(c->flags, GCF_COPY) && c->error != NULL) {
07953       delete c->error;
07954       c->error = NULL;
07955     }
07956   }
07957 }
07958 
07963 void ResetNewGRFData()
07964 {
07965   CleanUpStrings();
07966   CleanUpGRFTownNames();
07967 
07968   /* Copy/reset original engine info data */
07969   SetupEngines();
07970 
07971   /* Copy/reset original bridge info data */
07972   ResetBridges();
07973 
07974   /* Reset rail type information */
07975   ResetRailTypes();
07976 
07977   /* Allocate temporary refit/cargo class data */
07978   _gted = CallocT<GRFTempEngineData>(Engine::GetPoolSize());
07979 
07980   /* Fill rail type label temporary data for default trains */
07981   Engine *e;
07982   FOR_ALL_ENGINES_OF_TYPE(e, VEH_TRAIN) {
07983     _gted[e->index].railtypelabel = GetRailTypeInfo(e->u.rail.railtype)->label;
07984   }
07985 
07986   /* Reset GRM reservations */
07987   memset(&_grm_engines, 0, sizeof(_grm_engines));
07988   memset(&_grm_cargoes, 0, sizeof(_grm_cargoes));
07989 
07990   /* Reset generic feature callback lists */
07991   ResetGenericCallbacks();
07992 
07993   /* Reset price base data */
07994   ResetPriceBaseMultipliers();
07995 
07996   /* Reset the curencies array */
07997   ResetCurrencies();
07998 
07999   /* Reset the house array */
08000   ResetCustomHouses();
08001   ResetHouses();
08002 
08003   /* Reset the industries structures*/
08004   ResetCustomIndustries();
08005   ResetIndustries();
08006 
08007   /* Reset the objects. */
08008   ObjectClass::Reset();
08009   ResetCustomObjects();
08010   ResetObjects();
08011 
08012   /* Reset station classes */
08013   StationClass::Reset();
08014   ResetCustomStations();
08015 
08016   /* Reset airport-related structures */
08017   AirportClass::Reset();
08018   ResetCustomAirports();
08019   AirportSpec::ResetAirports();
08020   AirportTileSpec::ResetAirportTiles();
08021 
08022   /* Reset canal sprite groups and flags */
08023   memset(_water_feature, 0, sizeof(_water_feature));
08024 
08025   /* Reset the snowline table. */
08026   ClearSnowLine();
08027 
08028   /* Reset NewGRF files */
08029   ResetNewGRF();
08030 
08031   /* Reset NewGRF errors. */
08032   ResetNewGRFErrors();
08033 
08034   /* Set up the default cargo types */
08035   SetupCargoForClimate(_settings_game.game_creation.landscape);
08036 
08037   /* Reset misc GRF features and train list display variables */
08038   _misc_grf_features = 0;
08039 
08040   _loaded_newgrf_features.has_2CC           = false;
08041   _loaded_newgrf_features.used_liveries     = 1 << LS_DEFAULT;
08042   _loaded_newgrf_features.has_newhouses     = false;
08043   _loaded_newgrf_features.has_newindustries = false;
08044   _loaded_newgrf_features.shore             = SHORE_REPLACE_NONE;
08045 
08046   /* Clear all GRF overrides */
08047   _grf_id_overrides.clear();
08048 
08049   InitializeSoundPool();
08050   _spritegroup_pool.CleanPool();
08051 }
08052 
08056 void ResetPersistentNewGRFData()
08057 {
08058   /* Reset override managers */
08059   _engine_mngr.ResetToDefaultMapping();
08060   _house_mngr.ResetMapping();
08061   _industry_mngr.ResetMapping();
08062   _industile_mngr.ResetMapping();
08063   _airport_mngr.ResetMapping();
08064   _airporttile_mngr.ResetMapping();
08065 }
08066 
08071 static void BuildCargoTranslationMap()
08072 {
08073   memset(_cur.grffile->cargo_map, 0xFF, sizeof(_cur.grffile->cargo_map));
08074 
08075   for (CargoID c = 0; c < NUM_CARGO; c++) {
08076     const CargoSpec *cs = CargoSpec::Get(c);
08077     if (!cs->IsValid()) continue;
08078 
08079     if (_cur.grffile->cargo_list.Length() == 0) {
08080       /* Default translation table, so just a straight mapping to bitnum */
08081       _cur.grffile->cargo_map[c] = cs->bitnum;
08082     } else {
08083       /* Check the translation table for this cargo's label */
08084       int index = _cur.grffile->cargo_list.FindIndex(cs->label);
08085       if (index >= 0) _cur.grffile->cargo_map[c] = index;
08086     }
08087   }
08088 }
08089 
08094 static void InitNewGRFFile(const GRFConfig *config)
08095 {
08096   GRFFile *newfile = GetFileByFilename(config->filename);
08097   if (newfile != NULL) {
08098     /* We already loaded it once. */
08099     _cur.grffile = newfile;
08100     return;
08101   }
08102 
08103   newfile = new GRFFile(config);
08104   *_grf_files.Append() = _cur.grffile = newfile;
08105 }
08106 
08111 GRFFile::GRFFile(const GRFConfig *config)
08112 {
08113   this->filename = strdup(config->filename);
08114   this->grfid = config->ident.grfid;
08115 
08116   /* Initialise local settings to defaults */
08117   this->traininfo_vehicle_pitch = 0;
08118   this->traininfo_vehicle_width = TRAININFO_DEFAULT_VEHICLE_WIDTH;
08119 
08120   /* Mark price_base_multipliers as 'not set' */
08121   for (Price i = PR_BEGIN; i < PR_END; i++) {
08122     this->price_base_multipliers[i] = INVALID_PRICE_MODIFIER;
08123   }
08124 
08125   /* Initialise rail type map with default rail types */
08126   memset(this->railtype_map, INVALID_RAILTYPE, sizeof(this->railtype_map));
08127   this->railtype_map[0] = RAILTYPE_RAIL;
08128   this->railtype_map[1] = RAILTYPE_ELECTRIC;
08129   this->railtype_map[2] = RAILTYPE_MONO;
08130   this->railtype_map[3] = RAILTYPE_MAGLEV;
08131 
08132   /* Copy the initial parameter list
08133    * 'Uninitialised' parameters are zeroed as that is their default value when dynamically creating them. */
08134   assert_compile(lengthof(this->param) == lengthof(config->param) && lengthof(this->param) == 0x80);
08135 
08136   assert(config->num_params <= lengthof(config->param));
08137   this->param_end = config->num_params;
08138   if (this->param_end > 0) {
08139     MemCpyT(this->param, config->param, this->param_end);
08140   }
08141 }
08142 
08143 GRFFile::~GRFFile()
08144 {
08145   free(this->filename);
08146   delete[] this->language_map;
08147 }
08148 
08149 
08154 static const CargoLabel _default_refitmasks_rail[] = {
08155   'PASS', 'COAL', 'MAIL', 'LVST', 'GOOD', 'GRAI', 'WHEA', 'MAIZ', 'WOOD',
08156   'IORE', 'STEL', 'VALU', 'GOLD', 'DIAM', 'PAPR', 'FOOD', 'FRUT', 'CORE',
08157   'WATR', 'SUGR', 'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL',
08158   'PLST', 'FZDR',
08159   0 };
08160 
08161 static const CargoLabel _default_refitmasks_road[] = {
08162   0 };
08163 
08164 static const CargoLabel _default_refitmasks_ships[] = {
08165   'COAL', 'MAIL', 'LVST', 'GOOD', 'GRAI', 'WHEA', 'MAIZ', 'WOOD', 'IORE',
08166   'STEL', 'VALU', 'GOLD', 'DIAM', 'PAPR', 'FOOD', 'FRUT', 'CORE', 'WATR',
08167   'RUBR', 'SUGR', 'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL',
08168   'PLST', 'FZDR',
08169   0 };
08170 
08171 static const CargoLabel _default_refitmasks_aircraft[] = {
08172   'PASS', 'MAIL', 'GOOD', 'VALU', 'GOLD', 'DIAM', 'FOOD', 'FRUT', 'SUGR',
08173   'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL', 'PLST', 'FZDR',
08174   0 };
08175 
08176 static const CargoLabel * const _default_refitmasks[] = {
08177   _default_refitmasks_rail,
08178   _default_refitmasks_road,
08179   _default_refitmasks_ships,
08180   _default_refitmasks_aircraft,
08181 };
08182 
08183 
08187 static void CalculateRefitMasks()
08188 {
08189   Engine *e;
08190 
08191   FOR_ALL_ENGINES(e) {
08192     EngineID engine = e->index;
08193     EngineInfo *ei = &e->info;
08194     bool only_defaultcargo; 
08195 
08196     /* Did the newgrf specify any refitting? If not, use defaults. */
08197     if (_gted[engine].refittability != GRFTempEngineData::UNSET) {
08198       uint32 mask = 0;
08199       uint32 not_mask = 0;
08200       uint32 xor_mask = ei->refit_mask;
08201 
08202       /* If the original masks set by the grf are zero, the vehicle shall only carry the default cargo.
08203        * Note: After applying the translations, the vehicle may end up carrying no defined cargo. It becomes unavailable in that case. */
08204       only_defaultcargo = _gted[engine].refittability == GRFTempEngineData::EMPTY;
08205 
08206       if (_gted[engine].cargo_allowed != 0) {
08207         /* Build up the list of cargo types from the set cargo classes. */
08208         const CargoSpec *cs;
08209         FOR_ALL_CARGOSPECS(cs) {
08210           if (_gted[engine].cargo_allowed    & cs->classes) SetBit(mask,     cs->Index());
08211           if (_gted[engine].cargo_disallowed & cs->classes) SetBit(not_mask, cs->Index());
08212         }
08213       }
08214 
08215       ei->refit_mask = ((mask & ~not_mask) ^ xor_mask) & _cargo_mask;
08216 
08217       /* Apply explicit refit includes/excludes. */
08218       ei->refit_mask |= _gted[engine].ctt_include_mask;
08219       ei->refit_mask &= ~_gted[engine].ctt_exclude_mask;
08220     } else {
08221       uint32 xor_mask = 0;
08222 
08223       /* Don't apply default refit mask to wagons nor engines with no capacity */
08224       if (e->type != VEH_TRAIN || (e->u.rail.capacity != 0 && e->u.rail.railveh_type != RAILVEH_WAGON)) {
08225         const CargoLabel *cl = _default_refitmasks[e->type];
08226         for (uint i = 0;; i++) {
08227           if (cl[i] == 0) break;
08228 
08229           CargoID cargo = GetCargoIDByLabel(cl[i]);
08230           if (cargo == CT_INVALID) continue;
08231 
08232           SetBit(xor_mask, cargo);
08233         }
08234       }
08235 
08236       ei->refit_mask = xor_mask & _cargo_mask;
08237 
08238       /* If the mask is zero, the vehicle shall only carry the default cargo */
08239       only_defaultcargo = (ei->refit_mask == 0);
08240     }
08241 
08242     /* Clear invalid cargoslots (from default vehicles or pre-NewCargo GRFs) */
08243     if (!HasBit(_cargo_mask, ei->cargo_type)) ei->cargo_type = CT_INVALID;
08244 
08245     /* Ensure that the vehicle is either not refittable, or that the default cargo is one of the refittable cargoes.
08246      * Note: Vehicles refittable to no cargo are handle differently to vehicle refittable to a single cargo. The latter might have subtypes. */
08247     if (!only_defaultcargo && (e->type != VEH_SHIP || e->u.ship.old_refittable) && ei->cargo_type != CT_INVALID && !HasBit(ei->refit_mask, ei->cargo_type)) {
08248       ei->cargo_type = CT_INVALID;
08249     }
08250 
08251     /* Check if this engine's cargo type is valid. If not, set to the first refittable
08252      * cargo type. Finally disable the vehicle, if there is still no cargo. */
08253     if (ei->cargo_type == CT_INVALID && ei->refit_mask != 0) {
08254       /* Figure out which CTT to use for the default cargo, if it is 'first refittable'. */
08255       const uint8 *cargo_map_for_first_refittable = NULL;
08256       {
08257         const GRFFile *file = _gted[engine].defaultcargo_grf;
08258         if (file == NULL) file = e->GetGRF();
08259         if (file != NULL && file->grf_version >= 8 && file->cargo_list.Length() != 0) {
08260           cargo_map_for_first_refittable = file->cargo_map;
08261         }
08262       }
08263 
08264       if (cargo_map_for_first_refittable != NULL) {
08265         /* Use first refittable cargo from cargo translation table */
08266         byte best_local_slot = 0xFF;
08267         CargoID cargo_type;
08268         FOR_EACH_SET_CARGO_ID(cargo_type, ei->refit_mask) {
08269           byte local_slot = cargo_map_for_first_refittable[cargo_type];
08270           if (local_slot < best_local_slot) {
08271             best_local_slot = local_slot;
08272             ei->cargo_type = cargo_type;
08273           }
08274         }
08275       }
08276 
08277       if (ei->cargo_type == CT_INVALID) {
08278         /* Use first refittable cargo slot */
08279         ei->cargo_type = (CargoID)FindFirstBit(ei->refit_mask);
08280       }
08281     }
08282     if (ei->cargo_type == CT_INVALID) ei->climates = 0;
08283 
08284     /* Clear refit_mask for not refittable ships */
08285     if (e->type == VEH_SHIP && !e->u.ship.old_refittable) {
08286       ei->refit_mask = 0;
08287     }
08288   }
08289 }
08290 
08292 static void FinaliseCanals()
08293 {
08294   for (uint i = 0; i < CF_END; i++) {
08295     if (_water_feature[i].grffile != NULL) {
08296       _water_feature[i].callback_mask = _water_feature[i].grffile->canal_local_properties[i].callback_mask;
08297       _water_feature[i].flags = _water_feature[i].grffile->canal_local_properties[i].flags;
08298     }
08299   }
08300 }
08301 
08303 static void FinaliseEngineArray()
08304 {
08305   Engine *e;
08306 
08307   FOR_ALL_ENGINES(e) {
08308     if (e->GetGRF() == NULL) {
08309       const EngineIDMapping &eid = _engine_mngr[e->index];
08310       if (eid.grfid != INVALID_GRFID || eid.internal_id != eid.substitute_id) {
08311         e->info.string_id = STR_NEWGRF_INVALID_ENGINE;
08312       }
08313     }
08314 
08315     /* When the train does not set property 27 (misc flags), but it
08316      * is overridden by a NewGRF graphically we want to disable the
08317      * flipping possibility. */
08318     if (e->type == VEH_TRAIN && !_gted[e->index].prop27_set && e->GetGRF() != NULL && is_custom_sprite(e->u.rail.image_index)) {
08319       ClrBit(e->info.misc_flags, EF_RAIL_FLIPS);
08320     }
08321 
08322     /* Skip wagons, there livery is defined via the engine */
08323     if (e->type != VEH_TRAIN || e->u.rail.railveh_type != RAILVEH_WAGON) {
08324       LiveryScheme ls = GetEngineLiveryScheme(e->index, INVALID_ENGINE, NULL);
08325       SetBit(_loaded_newgrf_features.used_liveries, ls);
08326       /* Note: For ships and roadvehicles we assume that they cannot be refitted between passenger and freight */
08327 
08328       if (e->type == VEH_TRAIN) {
08329         SetBit(_loaded_newgrf_features.used_liveries, LS_FREIGHT_WAGON);
08330         switch (ls) {
08331           case LS_STEAM:
08332           case LS_DIESEL:
08333           case LS_ELECTRIC:
08334           case LS_MONORAIL:
08335           case LS_MAGLEV:
08336             SetBit(_loaded_newgrf_features.used_liveries, LS_PASSENGER_WAGON_STEAM + ls - LS_STEAM);
08337             break;
08338 
08339           case LS_DMU:
08340           case LS_EMU:
08341             SetBit(_loaded_newgrf_features.used_liveries, LS_PASSENGER_WAGON_DIESEL + ls - LS_DMU);
08342             break;
08343 
08344           default: NOT_REACHED();
08345         }
08346       }
08347     }
08348   }
08349 }
08350 
08352 static void FinaliseCargoArray()
08353 {
08354   for (CargoID c = 0; c < NUM_CARGO; c++) {
08355     CargoSpec *cs = CargoSpec::Get(c);
08356     if (!cs->IsValid()) {
08357       cs->name = cs->name_single = cs->units_volume = STR_NEWGRF_INVALID_CARGO;
08358       cs->quantifier = STR_NEWGRF_INVALID_CARGO_QUANTITY;
08359       cs->abbrev = STR_NEWGRF_INVALID_CARGO_ABBREV;
08360     }
08361   }
08362 }
08363 
08375 static bool IsHouseSpecValid(HouseSpec *hs, const HouseSpec *next1, const HouseSpec *next2, const HouseSpec *next3, const char *filename)
08376 {
08377   if (((hs->building_flags & BUILDING_HAS_2_TILES) != 0 &&
08378         (next1 == NULL || !next1->enabled || (next1->building_flags & BUILDING_HAS_1_TILE) != 0)) ||
08379       ((hs->building_flags & BUILDING_HAS_4_TILES) != 0 &&
08380         (next2 == NULL || !next2->enabled || (next2->building_flags & BUILDING_HAS_1_TILE) != 0 ||
08381         next3 == NULL || !next3->enabled || (next3->building_flags & BUILDING_HAS_1_TILE) != 0))) {
08382     hs->enabled = false;
08383     if (filename != NULL) DEBUG(grf, 1, "FinaliseHouseArray: %s defines house %d as multitile, but no suitable tiles follow. Disabling house.", filename, hs->grf_prop.local_id);
08384     return false;
08385   }
08386 
08387   /* Some places sum population by only counting north tiles. Other places use all tiles causing desyncs.
08388    * As the newgrf specs define population to be zero for non-north tiles, we just disable the offending house.
08389    * If you want to allow non-zero populations somewhen, make sure to sum the population of all tiles in all places. */
08390   if (((hs->building_flags & BUILDING_HAS_2_TILES) != 0 && next1->population != 0) ||
08391       ((hs->building_flags & BUILDING_HAS_4_TILES) != 0 && (next2->population != 0 || next3->population != 0))) {
08392     hs->enabled = false;
08393     if (filename != NULL) DEBUG(grf, 1, "FinaliseHouseArray: %s defines multitile house %d with non-zero population on additional tiles. Disabling house.", filename, hs->grf_prop.local_id);
08394     return false;
08395   }
08396 
08397   /* Substitute type is also used for override, and having an override with a different size causes crashes.
08398    * This check should only be done for NewGRF houses because grf_prop.subst_id is not set for original houses.*/
08399   if (filename != NULL && (hs->building_flags & BUILDING_HAS_1_TILE) != (HouseSpec::Get(hs->grf_prop.subst_id)->building_flags & BUILDING_HAS_1_TILE)) {
08400     hs->enabled = false;
08401     DEBUG(grf, 1, "FinaliseHouseArray: %s defines house %d with different house size then it's substitute type. Disabling house.", filename, hs->grf_prop.local_id);
08402     return false;
08403   }
08404 
08405   /* Make sure that additional parts of multitile houses are not available. */
08406   if ((hs->building_flags & BUILDING_HAS_1_TILE) == 0 && (hs->building_availability & HZ_ZONALL) != 0 && (hs->building_availability & HZ_CLIMALL) != 0) {
08407     hs->enabled = false;
08408     if (filename != NULL) DEBUG(grf, 1, "FinaliseHouseArray: %s defines house %d without a size but marked it as available. Disabling house.", filename, hs->grf_prop.local_id);
08409     return false;
08410   }
08411 
08412   return true;
08413 }
08414 
08421 static void EnsureEarlyHouse(HouseZones bitmask)
08422 {
08423   Year min_year = MAX_YEAR;
08424 
08425   for (int i = 0; i < NUM_HOUSES; i++) {
08426     HouseSpec *hs = HouseSpec::Get(i);
08427     if (hs == NULL || !hs->enabled) continue;
08428     if ((hs->building_availability & bitmask) != bitmask) continue;
08429     if (hs->min_year < min_year) min_year = hs->min_year;
08430   }
08431 
08432   if (min_year == 0) return;
08433 
08434   for (int i = 0; i < NUM_HOUSES; i++) {
08435     HouseSpec *hs = HouseSpec::Get(i);
08436     if (hs == NULL || !hs->enabled) continue;
08437     if ((hs->building_availability & bitmask) != bitmask) continue;
08438     if (hs->min_year == min_year) hs->min_year = 0;
08439   }
08440 }
08441 
08448 static void FinaliseHouseArray()
08449 {
08450   /* If there are no houses with start dates before 1930, then all houses
08451    * with start dates of 1930 have them reset to 0. This is in order to be
08452    * compatible with TTDPatch, where if no houses have start dates before
08453    * 1930 and the date is before 1930, the game pretends that this is 1930.
08454    * If there have been any houses defined with start dates before 1930 then
08455    * the dates are left alone.
08456    * On the other hand, why 1930? Just 'fix' the houses with the lowest
08457    * minimum introduction date to 0.
08458    */
08459   const GRFFile * const *end = _grf_files.End();
08460   for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
08461     HouseSpec **&housespec = (*file)->housespec;
08462     if (housespec == NULL) continue;
08463 
08464     for (int i = 0; i < NUM_HOUSES_PER_GRF; i++) {
08465       HouseSpec *hs = housespec[i];
08466 
08467       if (hs == NULL) continue;
08468 
08469       const HouseSpec *next1 = (i + 1 < NUM_HOUSES_PER_GRF ? housespec[i + 1] : NULL);
08470       const HouseSpec *next2 = (i + 2 < NUM_HOUSES_PER_GRF ? housespec[i + 2] : NULL);
08471       const HouseSpec *next3 = (i + 3 < NUM_HOUSES_PER_GRF ? housespec[i + 3] : NULL);
08472 
08473       if (!IsHouseSpecValid(hs, next1, next2, next3, (*file)->filename)) continue;
08474 
08475       _house_mngr.SetEntitySpec(hs);
08476     }
08477   }
08478 
08479   for (int i = 0; i < NUM_HOUSES; i++) {
08480     HouseSpec *hs = HouseSpec::Get(i);
08481     const HouseSpec *next1 = (i + 1 < NUM_HOUSES ? HouseSpec::Get(i + 1) : NULL);
08482     const HouseSpec *next2 = (i + 2 < NUM_HOUSES ? HouseSpec::Get(i + 2) : NULL);
08483     const HouseSpec *next3 = (i + 3 < NUM_HOUSES ? HouseSpec::Get(i + 3) : NULL);
08484 
08485     /* We need to check all houses again to we are sure that multitile houses
08486      * did get consecutive IDs and none of the parts are missing. */
08487     if (!IsHouseSpecValid(hs, next1, next2, next3, NULL)) {
08488       /* GetHouseNorthPart checks 3 houses that are directly before
08489        * it in the house pool. If any of those houses have multi-tile
08490        * flags set it assumes it's part of a multitile house. Since
08491        * we can have invalid houses in the pool marked as disabled, we
08492        * don't want to have them influencing valid tiles. As such set
08493        * building_flags to zero here to make sure any house following
08494        * this one in the pool is properly handled as 1x1 house. */
08495       hs->building_flags = TILE_NO_FLAG;
08496     }
08497   }
08498 
08499   HouseZones climate_mask = (HouseZones)(1 << (_settings_game.game_creation.landscape + 12));
08500   EnsureEarlyHouse(HZ_ZON1 | climate_mask);
08501   EnsureEarlyHouse(HZ_ZON2 | climate_mask);
08502   EnsureEarlyHouse(HZ_ZON3 | climate_mask);
08503   EnsureEarlyHouse(HZ_ZON4 | climate_mask);
08504   EnsureEarlyHouse(HZ_ZON5 | climate_mask);
08505 
08506   if (_settings_game.game_creation.landscape == LT_ARCTIC) {
08507     EnsureEarlyHouse(HZ_ZON1 | HZ_SUBARTC_ABOVE);
08508     EnsureEarlyHouse(HZ_ZON2 | HZ_SUBARTC_ABOVE);
08509     EnsureEarlyHouse(HZ_ZON3 | HZ_SUBARTC_ABOVE);
08510     EnsureEarlyHouse(HZ_ZON4 | HZ_SUBARTC_ABOVE);
08511     EnsureEarlyHouse(HZ_ZON5 | HZ_SUBARTC_ABOVE);
08512   }
08513 }
08514 
08520 static void FinaliseIndustriesArray()
08521 {
08522   const GRFFile * const *end = _grf_files.End();
08523   for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
08524     IndustrySpec **&industryspec = (*file)->industryspec;
08525     IndustryTileSpec **&indtspec = (*file)->indtspec;
08526     if (industryspec != NULL) {
08527       for (int i = 0; i < NUM_INDUSTRYTYPES_PER_GRF; i++) {
08528         IndustrySpec *indsp = industryspec[i];
08529 
08530         if (indsp != NULL && indsp->enabled) {
08531           StringID strid;
08532           /* process the conversion of text at the end, so to be sure everything will be fine
08533            * and available.  Check if it does not return undefind marker, which is a very good sign of a
08534            * substitute industry who has not changed the string been examined, thus using it as such */
08535           strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->name);
08536           if (strid != STR_UNDEFINED) indsp->name = strid;
08537 
08538           strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->closure_text);
08539           if (strid != STR_UNDEFINED) indsp->closure_text = strid;
08540 
08541           strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->production_up_text);
08542           if (strid != STR_UNDEFINED) indsp->production_up_text = strid;
08543 
08544           strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->production_down_text);
08545           if (strid != STR_UNDEFINED) indsp->production_down_text = strid;
08546 
08547           strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->new_industry_text);
08548           if (strid != STR_UNDEFINED) indsp->new_industry_text = strid;
08549 
08550           if (indsp->station_name != STR_NULL) {
08551             /* STR_NULL (0) can be set by grf.  It has a meaning regarding assignation of the
08552              * station's name. Don't want to lose the value, therefore, do not process. */
08553             strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->station_name);
08554             if (strid != STR_UNDEFINED) indsp->station_name = strid;
08555           }
08556 
08557           _industry_mngr.SetEntitySpec(indsp);
08558           _loaded_newgrf_features.has_newindustries = true;
08559         }
08560       }
08561     }
08562 
08563     if (indtspec != NULL) {
08564       for (int i = 0; i < NUM_INDUSTRYTILES_PER_GRF; i++) {
08565         IndustryTileSpec *indtsp = indtspec[i];
08566         if (indtsp != NULL) {
08567           _industile_mngr.SetEntitySpec(indtsp);
08568         }
08569       }
08570     }
08571   }
08572 
08573   for (uint j = 0; j < NUM_INDUSTRYTYPES; j++) {
08574     IndustrySpec *indsp = &_industry_specs[j];
08575     if (indsp->enabled && indsp->grf_prop.grffile != NULL) {
08576       for (uint i = 0; i < 3; i++) {
08577         indsp->conflicting[i] = MapNewGRFIndustryType(indsp->conflicting[i], indsp->grf_prop.grffile->grfid);
08578       }
08579     }
08580     if (!indsp->enabled) {
08581       indsp->name = STR_NEWGRF_INVALID_INDUSTRYTYPE;
08582     }
08583   }
08584 }
08585 
08591 static void FinaliseObjectsArray()
08592 {
08593   const GRFFile * const *end = _grf_files.End();
08594   for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
08595     ObjectSpec **&objectspec = (*file)->objectspec;
08596     if (objectspec != NULL) {
08597       for (int i = 0; i < NUM_OBJECTS_PER_GRF; i++) {
08598         if (objectspec[i] != NULL && objectspec[i]->grf_prop.grffile != NULL && objectspec[i]->enabled) {
08599           _object_mngr.SetEntitySpec(objectspec[i]);
08600         }
08601       }
08602     }
08603   }
08604 }
08605 
08611 static void FinaliseAirportsArray()
08612 {
08613   const GRFFile * const *end = _grf_files.End();
08614   for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
08615     AirportSpec **&airportspec = (*file)->airportspec;
08616     if (airportspec != NULL) {
08617       for (int i = 0; i < NUM_AIRPORTS_PER_GRF; i++) {
08618         if (airportspec[i] != NULL && airportspec[i]->enabled) {
08619           _airport_mngr.SetEntitySpec(airportspec[i]);
08620         }
08621       }
08622     }
08623 
08624     AirportTileSpec **&airporttilespec = (*file)->airtspec;
08625     if (airporttilespec != NULL) {
08626       for (uint i = 0; i < NUM_AIRPORTTILES_PER_GRF; i++) {
08627         if (airporttilespec[i] != NULL && airporttilespec[i]->enabled) {
08628           _airporttile_mngr.SetEntitySpec(airporttilespec[i]);
08629         }
08630       }
08631     }
08632   }
08633 }
08634 
08635 /* Here we perform initial decoding of some special sprites (as are they
08636  * described at http://www.ttdpatch.net/src/newgrf.txt, but this is only a very
08637  * partial implementation yet).
08638  * XXX: We consider GRF files trusted. It would be trivial to exploit OTTD by
08639  * a crafted invalid GRF file. We should tell that to the user somehow, or
08640  * better make this more robust in the future. */
08641 static void DecodeSpecialSprite(byte *buf, uint num, GrfLoadingStage stage)
08642 {
08643   /* XXX: There is a difference between staged loading in TTDPatch and
08644    * here.  In TTDPatch, for some reason actions 1 and 2 are carried out
08645    * during stage 1, whilst action 3 is carried out during stage 2 (to
08646    * "resolve" cargo IDs... wtf). This is a little problem, because cargo
08647    * IDs are valid only within a given set (action 1) block, and may be
08648    * overwritten after action 3 associates them. But overwriting happens
08649    * in an earlier stage than associating, so...  We just process actions
08650    * 1 and 2 in stage 2 now, let's hope that won't get us into problems.
08651    * --pasky
08652    * We need a pre-stage to set up GOTO labels of Action 0x10 because the grf
08653    * is not in memory and scanning the file every time would be too expensive.
08654    * In other stages we skip action 0x10 since it's already dealt with. */
08655   static const SpecialSpriteHandler handlers[][GLS_END] = {
08656     /* 0x00 */ { NULL,     SafeChangeInfo, NULL,       NULL,           ReserveChangeInfo, FeatureChangeInfo, },
08657     /* 0x01 */ { SkipAct1, SkipAct1,  SkipAct1,        SkipAct1,       SkipAct1,          NewSpriteSet, },
08658     /* 0x02 */ { NULL,     NULL,      NULL,            NULL,           NULL,              NewSpriteGroup, },
08659     /* 0x03 */ { NULL,     GRFUnsafe, NULL,            NULL,           NULL,              FeatureMapSpriteGroup, },
08660     /* 0x04 */ { NULL,     NULL,      NULL,            NULL,           NULL,              FeatureNewName, },
08661     /* 0x05 */ { SkipAct5, SkipAct5,  SkipAct5,        SkipAct5,       SkipAct5,          GraphicsNew, },
08662     /* 0x06 */ { NULL,     NULL,      NULL,            CfgApply,       CfgApply,          CfgApply, },
08663     /* 0x07 */ { NULL,     NULL,      NULL,            NULL,           SkipIf,            SkipIf, },
08664     /* 0x08 */ { ScanInfo, NULL,      NULL,            GRFInfo,        GRFInfo,           GRFInfo, },
08665     /* 0x09 */ { NULL,     NULL,      NULL,            SkipIf,         SkipIf,            SkipIf, },
08666     /* 0x0A */ { SkipActA, SkipActA,  SkipActA,        SkipActA,       SkipActA,          SpriteReplace, },
08667     /* 0x0B */ { NULL,     NULL,      NULL,            GRFLoadError,   GRFLoadError,      GRFLoadError, },
08668     /* 0x0C */ { NULL,     NULL,      NULL,            GRFComment,     NULL,              GRFComment, },
08669     /* 0x0D */ { NULL,     SafeParamSet, NULL,         ParamSet,       ParamSet,          ParamSet, },
08670     /* 0x0E */ { NULL,     SafeGRFInhibit, NULL,       GRFInhibit,     GRFInhibit,        GRFInhibit, },
08671     /* 0x0F */ { NULL,     GRFUnsafe, NULL,            FeatureTownName, NULL,             NULL, },
08672     /* 0x10 */ { NULL,     NULL,      DefineGotoLabel, NULL,           NULL,              NULL, },
08673     /* 0x11 */ { SkipAct11,GRFUnsafe, SkipAct11,       GRFSound,       SkipAct11,         GRFSound, },
08674     /* 0x12 */ { SkipAct12, SkipAct12, SkipAct12,      SkipAct12,      SkipAct12,         LoadFontGlyph, },
08675     /* 0x13 */ { NULL,     NULL,      NULL,            NULL,           NULL,              TranslateGRFStrings, },
08676     /* 0x14 */ { StaticGRFInfo, NULL, NULL,            NULL,           NULL,              NULL, },
08677   };
08678 
08679   GRFLocation location(_cur.grfconfig->ident.grfid, _cur.nfo_line);
08680 
08681   GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.find(location);
08682   if (it == _grf_line_to_action6_sprite_override.end()) {
08683     /* No preloaded sprite to work with; read the
08684      * pseudo sprite content. */
08685     FioReadBlock(buf, num);
08686   } else {
08687     /* Use the preloaded sprite data. */
08688     buf = _grf_line_to_action6_sprite_override[location];
08689     grfmsg(7, "DecodeSpecialSprite: Using preloaded pseudo sprite data");
08690 
08691     /* Skip the real (original) content of this action. */
08692     FioSeekTo(num, SEEK_CUR);
08693   }
08694 
08695   ByteReader br(buf, buf + num);
08696   ByteReader *bufp = &br;
08697 
08698   try {
08699     byte action = bufp->ReadByte();
08700 
08701     if (action == 0xFF) {
08702       grfmsg(2, "DecodeSpecialSprite: Unexpected data block, skipping");
08703     } else if (action == 0xFE) {
08704       grfmsg(2, "DecodeSpecialSprite: Unexpected import block, skipping");
08705     } else if (action >= lengthof(handlers)) {
08706       grfmsg(7, "DecodeSpecialSprite: Skipping unknown action 0x%02X", action);
08707     } else if (handlers[action][stage] == NULL) {
08708       grfmsg(7, "DecodeSpecialSprite: Skipping action 0x%02X in stage %d", action, stage);
08709     } else {
08710       grfmsg(7, "DecodeSpecialSprite: Handling action 0x%02X in stage %d", action, stage);
08711       handlers[action][stage](bufp);
08712     }
08713   } catch (...) {
08714     grfmsg(1, "DecodeSpecialSprite: Tried to read past end of pseudo-sprite data");
08715     DisableGrf(STR_NEWGRF_ERROR_READ_BOUNDS);
08716   }
08717 }
08718 
08719 
08721 extern const byte _grf_cont_v2_sig[8] = {'G', 'R', 'F', 0x82, 0x0D, 0x0A, 0x1A, 0x0A};
08722 
08727 byte GetGRFContainerVersion()
08728 {
08729   size_t pos = FioGetPos();
08730 
08731   if (FioReadWord() == 0) {
08732     /* Check for GRF container version 2, which is identified by the bytes
08733      * '47 52 46 82 0D 0A 1A 0A' at the start of the file. */
08734     for (uint i = 0; i < lengthof(_grf_cont_v2_sig); i++) {
08735       if (FioReadByte() != _grf_cont_v2_sig[i]) return 0; // Invalid format
08736     }
08737 
08738     return 2;
08739   }
08740 
08741   /* Container version 1 has no header, rewind to start. */
08742   FioSeekTo(pos, SEEK_SET);
08743   return 1;
08744 }
08745 
08753 void LoadNewGRFFile(GRFConfig *config, uint file_index, GrfLoadingStage stage, Subdirectory subdir)
08754 {
08755   const char *filename = config->filename;
08756 
08757   /* A .grf file is activated only if it was active when the game was
08758    * started.  If a game is loaded, only its active .grfs will be
08759    * reactivated, unless "loadallgraphics on" is used.  A .grf file is
08760    * considered active if its action 8 has been processed, i.e. its
08761    * action 8 hasn't been skipped using an action 7.
08762    *
08763    * During activation, only actions 0, 1, 2, 3, 4, 5, 7, 8, 9, 0A and 0B are
08764    * carried out.  All others are ignored, because they only need to be
08765    * processed once at initialization.  */
08766   if (stage != GLS_FILESCAN && stage != GLS_SAFETYSCAN && stage != GLS_LABELSCAN) {
08767     _cur.grffile = GetFileByFilename(filename);
08768     if (_cur.grffile == NULL) usererror("File '%s' lost in cache.\n", filename);
08769     if (stage == GLS_RESERVE && config->status != GCS_INITIALISED) return;
08770     if (stage == GLS_ACTIVATION && !HasBit(config->flags, GCF_RESERVED)) return;
08771     _cur.grffile->is_ottdfile = config->IsOpenTTDBaseGRF();
08772   }
08773 
08774   if (file_index > LAST_GRF_SLOT) {
08775     DEBUG(grf, 0, "'%s' is not loaded as the maximum number of GRFs has been reached", filename);
08776     config->status = GCS_DISABLED;
08777     config->error  = new GRFError(STR_NEWGRF_ERROR_MSG_FATAL, STR_NEWGRF_ERROR_TOO_MANY_NEWGRFS_LOADED);
08778     return;
08779   }
08780 
08781   FioOpenFile(file_index, filename, subdir);
08782   _cur.file_index = file_index; // XXX
08783   _palette_remap_grf[_cur.file_index] = (config->palette & GRFP_USE_MASK);
08784 
08785   _cur.grfconfig = config;
08786 
08787   DEBUG(grf, 2, "LoadNewGRFFile: Reading NewGRF-file '%s'", filename);
08788 
08789   _cur.grf_container_ver = GetGRFContainerVersion();
08790   if (_cur.grf_container_ver == 0) {
08791     DEBUG(grf, 7, "LoadNewGRFFile: Custom .grf has invalid format");
08792     return;
08793   }
08794 
08795   if (stage == GLS_INIT || stage == GLS_ACTIVATION) {
08796     /* We need the sprite offsets in the init stage for NewGRF sounds
08797      * and in the activation stage for real sprites. */
08798     ReadGRFSpriteOffsets(_cur.grf_container_ver);
08799   } else {
08800     /* Skip sprite section offset if present. */
08801     if (_cur.grf_container_ver >= 2) FioReadDword();
08802   }
08803 
08804   if (_cur.grf_container_ver >= 2) {
08805     /* Read compression value. */
08806     byte compression = FioReadByte();
08807     if (compression != 0) {
08808       DEBUG(grf, 7, "LoadNewGRFFile: Unsupported compression format");
08809       return;
08810     }
08811   }
08812 
08813   /* Skip the first sprite; we don't care about how many sprites this
08814    * does contain; newest TTDPatches and George's longvehicles don't
08815    * neither, apparently. */
08816   uint32 num = _cur.grf_container_ver >= 2 ? FioReadDword() : FioReadWord();
08817   if (num == 4 && FioReadByte() == 0xFF) {
08818     FioReadDword();
08819   } else {
08820     DEBUG(grf, 7, "LoadNewGRFFile: Custom .grf has invalid format");
08821     return;
08822   }
08823 
08824   _cur.ClearDataForNextFile();
08825 
08826   ReusableBuffer<byte> buf;
08827 
08828   while ((num = (_cur.grf_container_ver >= 2 ? FioReadDword() : FioReadWord())) != 0) {
08829     byte type = FioReadByte();
08830     _cur.nfo_line++;
08831 
08832     if (type == 0xFF) {
08833       if (_cur.skip_sprites == 0) {
08834         DecodeSpecialSprite(buf.Allocate(num), num, stage);
08835 
08836         /* Stop all processing if we are to skip the remaining sprites */
08837         if (_cur.skip_sprites == -1) break;
08838 
08839         continue;
08840       } else {
08841         FioSkipBytes(num);
08842       }
08843     } else {
08844       if (_cur.skip_sprites == 0) {
08845         grfmsg(0, "LoadNewGRFFile: Unexpected sprite, disabling");
08846         DisableGrf(STR_NEWGRF_ERROR_UNEXPECTED_SPRITE);
08847         break;
08848       }
08849 
08850       if (_cur.grf_container_ver >= 2 && type == 0xFD) {
08851         /* Reference to data section. Container version >= 2 only. */
08852         FioSkipBytes(num);
08853       } else {
08854         FioSkipBytes(7);
08855         SkipSpriteData(type, num - 8);
08856       }
08857     }
08858 
08859     if (_cur.skip_sprites > 0) _cur.skip_sprites--;
08860   }
08861 }
08862 
08870 static void ActivateOldShore()
08871 {
08872   /* Use default graphics, if no shore sprites were loaded.
08873    * Should not happen, as the base set's extra grf should include some. */
08874   if (_loaded_newgrf_features.shore == SHORE_REPLACE_NONE) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_A;
08875 
08876   if (_loaded_newgrf_features.shore != SHORE_REPLACE_ACTION_5) {
08877     DupSprite(SPR_ORIGINALSHORE_START +  1, SPR_SHORE_BASE +  1); // SLOPE_W
08878     DupSprite(SPR_ORIGINALSHORE_START +  2, SPR_SHORE_BASE +  2); // SLOPE_S
08879     DupSprite(SPR_ORIGINALSHORE_START +  6, SPR_SHORE_BASE +  3); // SLOPE_SW
08880     DupSprite(SPR_ORIGINALSHORE_START +  0, SPR_SHORE_BASE +  4); // SLOPE_E
08881     DupSprite(SPR_ORIGINALSHORE_START +  4, SPR_SHORE_BASE +  6); // SLOPE_SE
08882     DupSprite(SPR_ORIGINALSHORE_START +  3, SPR_SHORE_BASE +  8); // SLOPE_N
08883     DupSprite(SPR_ORIGINALSHORE_START +  7, SPR_SHORE_BASE +  9); // SLOPE_NW
08884     DupSprite(SPR_ORIGINALSHORE_START +  5, SPR_SHORE_BASE + 12); // SLOPE_NE
08885   }
08886 
08887   if (_loaded_newgrf_features.shore == SHORE_REPLACE_ACTION_A) {
08888     DupSprite(SPR_FLAT_GRASS_TILE + 16, SPR_SHORE_BASE +  0); // SLOPE_STEEP_S
08889     DupSprite(SPR_FLAT_GRASS_TILE + 17, SPR_SHORE_BASE +  5); // SLOPE_STEEP_W
08890     DupSprite(SPR_FLAT_GRASS_TILE +  7, SPR_SHORE_BASE +  7); // SLOPE_WSE
08891     DupSprite(SPR_FLAT_GRASS_TILE + 15, SPR_SHORE_BASE + 10); // SLOPE_STEEP_N
08892     DupSprite(SPR_FLAT_GRASS_TILE + 11, SPR_SHORE_BASE + 11); // SLOPE_NWS
08893     DupSprite(SPR_FLAT_GRASS_TILE + 13, SPR_SHORE_BASE + 13); // SLOPE_ENW
08894     DupSprite(SPR_FLAT_GRASS_TILE + 14, SPR_SHORE_BASE + 14); // SLOPE_SEN
08895     DupSprite(SPR_FLAT_GRASS_TILE + 18, SPR_SHORE_BASE + 15); // SLOPE_STEEP_E
08896 
08897     /* XXX - SLOPE_EW, SLOPE_NS are currently not used.
08898      *       If they would be used somewhen, then these grass tiles will most like not look as needed */
08899     DupSprite(SPR_FLAT_GRASS_TILE +  5, SPR_SHORE_BASE + 16); // SLOPE_EW
08900     DupSprite(SPR_FLAT_GRASS_TILE + 10, SPR_SHORE_BASE + 17); // SLOPE_NS
08901   }
08902 }
08903 
08907 static void FinalisePriceBaseMultipliers()
08908 {
08909   extern const PriceBaseSpec _price_base_specs[];
08911   static const uint32 override_features = (1 << GSF_TRAINS) | (1 << GSF_ROADVEHICLES) | (1 << GSF_SHIPS) | (1 << GSF_AIRCRAFT);
08912 
08913   /* Evaluate grf overrides */
08914   int num_grfs = _grf_files.Length();
08915   int *grf_overrides = AllocaM(int, num_grfs);
08916   for (int i = 0; i < num_grfs; i++) {
08917     grf_overrides[i] = -1;
08918 
08919     GRFFile *source = _grf_files[i];
08920     uint32 override = _grf_id_overrides[source->grfid];
08921     if (override == 0) continue;
08922 
08923     GRFFile *dest = GetFileByGRFID(override);
08924     if (dest == NULL) continue;
08925 
08926     grf_overrides[i] = _grf_files.FindIndex(dest);
08927     assert(grf_overrides[i] >= 0);
08928   }
08929 
08930   /* Override features and price base multipliers of earlier loaded grfs */
08931   for (int i = 0; i < num_grfs; i++) {
08932     if (grf_overrides[i] < 0 || grf_overrides[i] >= i) continue;
08933     GRFFile *source = _grf_files[i];
08934     GRFFile *dest = _grf_files[grf_overrides[i]];
08935 
08936     uint32 features = (source->grf_features | dest->grf_features) & override_features;
08937     source->grf_features |= features;
08938     dest->grf_features |= features;
08939 
08940     for (Price p = PR_BEGIN; p < PR_END; p++) {
08941       /* No price defined -> nothing to do */
08942       if (!HasBit(features, _price_base_specs[p].grf_feature) || source->price_base_multipliers[p] == INVALID_PRICE_MODIFIER) continue;
08943       DEBUG(grf, 3, "'%s' overrides price base multiplier %d of '%s'", source->filename, p, dest->filename);
08944       dest->price_base_multipliers[p] = source->price_base_multipliers[p];
08945     }
08946   }
08947 
08948   /* Propagate features and price base multipliers of afterwards loaded grfs, if none is present yet */
08949   for (int i = num_grfs - 1; i >= 0; i--) {
08950     if (grf_overrides[i] < 0 || grf_overrides[i] <= i) continue;
08951     GRFFile *source = _grf_files[i];
08952     GRFFile *dest = _grf_files[grf_overrides[i]];
08953 
08954     uint32 features = (source->grf_features | dest->grf_features) & override_features;
08955     source->grf_features |= features;
08956     dest->grf_features |= features;
08957 
08958     for (Price p = PR_BEGIN; p < PR_END; p++) {
08959       /* Already a price defined -> nothing to do */
08960       if (!HasBit(features, _price_base_specs[p].grf_feature) || dest->price_base_multipliers[p] != INVALID_PRICE_MODIFIER) continue;
08961       DEBUG(grf, 3, "Price base multiplier %d from '%s' propagated to '%s'", p, source->filename, dest->filename);
08962       dest->price_base_multipliers[p] = source->price_base_multipliers[p];
08963     }
08964   }
08965 
08966   /* The 'master grf' now have the correct multipliers. Assign them to the 'addon grfs' to make everything consistent. */
08967   for (int i = 0; i < num_grfs; i++) {
08968     if (grf_overrides[i] < 0) continue;
08969     GRFFile *source = _grf_files[i];
08970     GRFFile *dest = _grf_files[grf_overrides[i]];
08971 
08972     uint32 features = (source->grf_features | dest->grf_features) & override_features;
08973     source->grf_features |= features;
08974     dest->grf_features |= features;
08975 
08976     for (Price p = PR_BEGIN; p < PR_END; p++) {
08977       if (!HasBit(features, _price_base_specs[p].grf_feature)) continue;
08978       if (source->price_base_multipliers[p] != dest->price_base_multipliers[p]) {
08979         DEBUG(grf, 3, "Price base multiplier %d from '%s' propagated to '%s'", p, dest->filename, source->filename);
08980       }
08981       source->price_base_multipliers[p] = dest->price_base_multipliers[p];
08982     }
08983   }
08984 
08985   /* Apply fallback prices for grf version < 8 */
08986   const GRFFile * const *end = _grf_files.End();
08987   for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
08988     if ((*file)->grf_version >= 8) continue;
08989     PriceMultipliers &price_base_multipliers = (*file)->price_base_multipliers;
08990     for (Price p = PR_BEGIN; p < PR_END; p++) {
08991       Price fallback_price = _price_base_specs[p].fallback_price;
08992       if (fallback_price != INVALID_PRICE && price_base_multipliers[p] == INVALID_PRICE_MODIFIER) {
08993         /* No price multiplier has been set.
08994          * So copy the multiplier from the fallback price, maybe a multiplier was set there. */
08995         price_base_multipliers[p] = price_base_multipliers[fallback_price];
08996       }
08997     }
08998   }
08999 
09000   /* Decide local/global scope of price base multipliers */
09001   for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
09002     PriceMultipliers &price_base_multipliers = (*file)->price_base_multipliers;
09003     for (Price p = PR_BEGIN; p < PR_END; p++) {
09004       if (price_base_multipliers[p] == INVALID_PRICE_MODIFIER) {
09005         /* No multiplier was set; set it to a neutral value */
09006         price_base_multipliers[p] = 0;
09007       } else {
09008         if (!HasBit((*file)->grf_features, _price_base_specs[p].grf_feature)) {
09009           /* The grf does not define any objects of the feature,
09010            * so it must be a difficulty setting. Apply it globally */
09011           DEBUG(grf, 3, "'%s' sets global price base multiplier %d", (*file)->filename, p);
09012           SetPriceBaseMultiplier(p, price_base_multipliers[p]);
09013           price_base_multipliers[p] = 0;
09014         } else {
09015           DEBUG(grf, 3, "'%s' sets local price base multiplier %d", (*file)->filename, p);
09016         }
09017       }
09018     }
09019   }
09020 }
09021 
09022 void InitDepotWindowBlockSizes();
09023 
09024 extern void InitGRFTownGeneratorNames();
09025 
09027 static void AfterLoadGRFs()
09028 {
09029   for (StringIDToGRFIDMapping::iterator it = _string_to_grf_mapping.begin(); it != _string_to_grf_mapping.end(); it++) {
09030     *((*it).first) = MapGRFStringID((*it).second, *((*it).first));
09031   }
09032   _string_to_grf_mapping.clear();
09033 
09034   /* Free the action 6 override sprites. */
09035   for (GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.begin(); it != _grf_line_to_action6_sprite_override.end(); it++) {
09036     free((*it).second);
09037   }
09038   _grf_line_to_action6_sprite_override.clear();
09039 
09040   /* Polish cargoes */
09041   FinaliseCargoArray();
09042 
09043   /* Pre-calculate all refit masks after loading GRF files. */
09044   CalculateRefitMasks();
09045 
09046   /* Polish engines */
09047   FinaliseEngineArray();
09048 
09049   /* Set the actually used Canal properties */
09050   FinaliseCanals();
09051 
09052   /* Set the block size in the depot windows based on vehicle sprite sizes */
09053   InitDepotWindowBlockSizes();
09054 
09055   /* Add all new houses to the house array. */
09056   FinaliseHouseArray();
09057 
09058   /* Add all new industries to the industry array. */
09059   FinaliseIndustriesArray();
09060 
09061   /* Add all new objects to the object array. */
09062   FinaliseObjectsArray();
09063 
09064   InitializeSortedCargoSpecs();
09065 
09066   /* Sort the list of industry types. */
09067   SortIndustryTypes();
09068 
09069   /* Create dynamic list of industry legends for smallmap_gui.cpp */
09070   BuildIndustriesLegend();
09071 
09072   /* Build the routemap legend, based on the available cargos */
09073   BuildLinkStatsLegend();
09074 
09075   /* Add all new airports to the airports array. */
09076   FinaliseAirportsArray();
09077   BindAirportSpecs();
09078 
09079   /* Update the townname generators list */
09080   InitGRFTownGeneratorNames();
09081 
09082   /* Run all queued vehicle list order changes */
09083   CommitVehicleListOrderChanges();
09084 
09085   /* Load old shore sprites in new position, if they were replaced by ActionA */
09086   ActivateOldShore();
09087 
09088   /* Set up custom rail types */
09089   InitRailTypes();
09090 
09091   Engine *e;
09092   FOR_ALL_ENGINES_OF_TYPE(e, VEH_ROAD) {
09093     if (_gted[e->index].rv_max_speed != 0) {
09094       /* Set RV maximum speed from the mph/0.8 unit value */
09095       e->u.road.max_speed = _gted[e->index].rv_max_speed * 4;
09096     }
09097   }
09098 
09099   FOR_ALL_ENGINES_OF_TYPE(e, VEH_TRAIN) {
09100     RailType railtype = GetRailTypeByLabel(_gted[e->index].railtypelabel);
09101     if (railtype == INVALID_RAILTYPE) {
09102       /* Rail type is not available, so disable this engine */
09103       e->info.climates = 0;
09104     } else {
09105       e->u.rail.railtype = railtype;
09106     }
09107   }
09108 
09109   SetYearEngineAgingStops();
09110 
09111   FinalisePriceBaseMultipliers();
09112 
09113   /* Deallocate temporary loading data */
09114   free(_gted);
09115   _grm_sprites.clear();
09116 }
09117 
09123 void LoadNewGRF(uint load_index, uint file_index)
09124 {
09125   /* In case of networking we need to "sync" the start values
09126    * so all NewGRFs are loaded equally. For this we use the
09127    * start date of the game and we set the counters, etc. to
09128    * 0 so they're the same too. */
09129   Date date            = _date;
09130   Year year            = _cur_year;
09131   DateFract date_fract = _date_fract;
09132   uint16 tick_counter  = _tick_counter;
09133   byte display_opt     = _display_opt;
09134 
09135   if (_networking) {
09136     _cur_year     = _settings_game.game_creation.starting_year;
09137     _date         = ConvertYMDToDate(_cur_year, 0, 1);
09138     _date_fract   = 0;
09139     _tick_counter = 0;
09140     _display_opt  = 0;
09141   }
09142 
09143   InitializeGRFSpecial();
09144 
09145   ResetNewGRFData();
09146 
09147   /*
09148    * Reset the status of all files, so we can 'retry' to load them.
09149    * This is needed when one for example rearranges the NewGRFs in-game
09150    * and a previously disabled NewGRF becomes useable. If it would not
09151    * be reset, the NewGRF would remain disabled even though it should
09152    * have been enabled.
09153    */
09154   for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
09155     if (c->status != GCS_NOT_FOUND) c->status = GCS_UNKNOWN;
09156   }
09157 
09158   _cur.spriteid = load_index;
09159 
09160   /* Load newgrf sprites
09161    * in each loading stage, (try to) open each file specified in the config
09162    * and load information from it. */
09163   for (GrfLoadingStage stage = GLS_LABELSCAN; stage <= GLS_ACTIVATION; stage++) {
09164     /* Set activated grfs back to will-be-activated between reservation- and activation-stage.
09165      * This ensures that action7/9 conditions 0x06 - 0x0A work correctly. */
09166     for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
09167       if (c->status == GCS_ACTIVATED) c->status = GCS_INITIALISED;
09168     }
09169 
09170     if (stage == GLS_RESERVE) {
09171       static const uint32 overrides[][2] = {
09172         { 0x44442202, 0x44440111 }, // UKRS addons modifies UKRS
09173         { 0x6D620402, 0x6D620401 }, // DBSetXL ECS extension modifies DBSetXL
09174         { 0x4D656f20, 0x4D656F17 }, // LV4cut modifies LV4
09175       };
09176       for (size_t i = 0; i < lengthof(overrides); i++) {
09177         SetNewGRFOverride(BSWAP32(overrides[i][0]), BSWAP32(overrides[i][1]));
09178       }
09179     }
09180 
09181     uint slot = file_index;
09182 
09183     _cur.stage = stage;
09184     for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
09185       if (c->status == GCS_DISABLED || c->status == GCS_NOT_FOUND) continue;
09186       if (stage > GLS_INIT && HasBit(c->flags, GCF_INIT_ONLY)) continue;
09187 
09188       Subdirectory subdir = slot == file_index ? BASESET_DIR : NEWGRF_DIR;
09189       if (!FioCheckFileExists(c->filename, subdir)) {
09190         DEBUG(grf, 0, "NewGRF file is missing '%s'; disabling", c->filename);
09191         c->status = GCS_NOT_FOUND;
09192         continue;
09193       }
09194 
09195       if (stage == GLS_LABELSCAN) InitNewGRFFile(c);
09196       LoadNewGRFFile(c, slot++, stage, subdir);
09197       if (stage == GLS_RESERVE) {
09198         SetBit(c->flags, GCF_RESERVED);
09199       } else if (stage == GLS_ACTIVATION) {
09200         ClrBit(c->flags, GCF_RESERVED);
09201         assert(GetFileByGRFID(c->ident.grfid) == _cur.grffile);
09202         ClearTemporaryNewGRFData(_cur.grffile);
09203         BuildCargoTranslationMap();
09204         DEBUG(sprite, 2, "LoadNewGRF: Currently %i sprites are loaded", _cur.spriteid);
09205       } else if (stage == GLS_INIT && HasBit(c->flags, GCF_INIT_ONLY)) {
09206         /* We're not going to activate this, so free whatever data we allocated */
09207         ClearTemporaryNewGRFData(_cur.grffile);
09208       }
09209     }
09210   }
09211 
09212   /* Pseudo sprite processing is finished; free temporary stuff */
09213   _cur.ClearDataForNextFile();
09214 
09215   /* Call any functions that should be run after GRFs have been loaded. */
09216   AfterLoadGRFs();
09217 
09218   /* Now revert back to the original situation */
09219   _cur_year     = year;
09220   _date         = date;
09221   _date_fract   = date_fract;
09222   _tick_counter = tick_counter;
09223   _display_opt  = display_opt;
09224 }