# newgrf.cpp

Go to the documentation of this file.

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