newgrf.cpp

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