# newgrf.cpp

Go to the documentation of this file.

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