newgrf.cpp

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