OpenTTD
newgrf.cpp
Go to the documentation of this file.
1 /* $Id: newgrf.cpp 27974 2018-03-06 07:48:29Z peter1138 $ */
2 
3 /*
4  * This file is part of OpenTTD.
5  * 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.
6  * 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.
7  * 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/>.
8  */
9 
12 #include "stdafx.h"
13 
14 #include <stdarg.h>
15 
16 #include "debug.h"
17 #include "fileio_func.h"
18 #include "engine_func.h"
19 #include "engine_base.h"
20 #include "bridge.h"
21 #include "town.h"
22 #include "newgrf_engine.h"
23 #include "newgrf_text.h"
24 #include "fontcache.h"
25 #include "currency.h"
26 #include "landscape.h"
27 #include "newgrf_cargo.h"
28 #include "newgrf_house.h"
29 #include "newgrf_sound.h"
30 #include "newgrf_station.h"
31 #include "industrytype.h"
32 #include "newgrf_canal.h"
33 #include "newgrf_townname.h"
34 #include "newgrf_industries.h"
35 #include "newgrf_airporttiles.h"
36 #include "newgrf_airport.h"
37 #include "newgrf_object.h"
38 #include "rev.h"
39 #include "fios.h"
40 #include "strings_func.h"
41 #include "date_func.h"
42 #include "string_func.h"
43 #include "network/network.h"
44 #include <map>
45 #include "smallmap_gui.h"
46 #include "genworld.h"
47 #include "error.h"
48 #include "vehicle_func.h"
49 #include "language.h"
50 #include "vehicle_base.h"
51 
52 #include "table/strings.h"
53 #include "table/build_industry.h"
54 
55 #include "safeguards.h"
56 
57 /* TTDPatch extended GRF format codec
58  * (c) Petr Baudis 2004 (GPL'd)
59  * Changes by Florian octo Forster are (c) by the OpenTTD development team.
60  *
61  * Contains portions of documentation by TTDPatch team.
62  * Thanks especially to Josef Drexler for the documentation as well as a lot
63  * of help at #tycoon. Also thanks to Michael Blunck for his GRF files which
64  * served as subject to the initial testing of this codec. */
65 
68 
71 
73 static uint32 _ttdpatch_flags[8];
74 
77 
78 static const uint MAX_SPRITEGROUP = UINT8_MAX;
79 
82 private:
84  struct SpriteSet {
86  uint num_sprites;
87  };
88 
90  std::map<uint, SpriteSet> spritesets[GSF_END];
91 
92 public:
93  /* Global state */
94  GrfLoadingStage stage;
96 
97  /* Local state in the file */
98  uint file_index;
101  uint32 nfo_line;
103 
104  /* Kind of return values when processing certain actions */
106 
107  /* Currently referenceable spritegroups */
108  SpriteGroup *spritegroups[MAX_SPRITEGROUP + 1];
109 
112  {
113  this->nfo_line = 0;
114  this->skip_sprites = 0;
115 
116  for (uint i = 0; i < GSF_END; i++) {
117  this->spritesets[i].clear();
118  }
119 
120  memset(this->spritegroups, 0, sizeof(this->spritegroups));
121  }
122 
131  void AddSpriteSets(byte feature, SpriteID first_sprite, uint first_set, uint numsets, uint numents)
132  {
133  assert(feature < GSF_END);
134  for (uint i = 0; i < numsets; i++) {
135  SpriteSet &set = this->spritesets[feature][first_set + i];
136  set.sprite = first_sprite + i * numents;
137  set.num_sprites = numents;
138  }
139  }
140 
147  bool HasValidSpriteSets(byte feature) const
148  {
149  assert(feature < GSF_END);
150  return !this->spritesets[feature].empty();
151  }
152 
160  bool IsValidSpriteSet(byte feature, uint set) const
161  {
162  assert(feature < GSF_END);
163  return this->spritesets[feature].find(set) != this->spritesets[feature].end();
164  }
165 
172  SpriteID GetSprite(byte feature, uint set) const
173  {
174  assert(IsValidSpriteSet(feature, set));
175  return this->spritesets[feature].find(set)->second.sprite;
176  }
177 
184  uint GetNumEnts(byte feature, uint set) const
185  {
186  assert(IsValidSpriteSet(feature, set));
187  return this->spritesets[feature].find(set)->second.num_sprites;
188  }
189 };
190 
191 static GrfProcessingState _cur;
192 
193 
200 template <VehicleType T>
201 static inline bool IsValidNewGRFImageIndex(uint8 image_index)
202 {
203  return image_index == 0xFD || IsValidImageIndex<T>(image_index);
204 }
205 
207 
209 class ByteReader {
210 protected:
211  byte *data;
212  byte *end;
213 
214 public:
215  ByteReader(byte *data, byte *end) : data(data), end(end) { }
216 
217  inline byte ReadByte()
218  {
219  if (data < end) return *(data)++;
220  throw OTTDByteReaderSignal();
221  }
222 
223  uint16 ReadWord()
224  {
225  uint16 val = ReadByte();
226  return val | (ReadByte() << 8);
227  }
228 
229  uint16 ReadExtendedByte()
230  {
231  uint16 val = ReadByte();
232  return val == 0xFF ? ReadWord() : val;
233  }
234 
235  uint32 ReadDWord()
236  {
237  uint32 val = ReadWord();
238  return val | (ReadWord() << 16);
239  }
240 
241  uint32 ReadVarSize(byte size)
242  {
243  switch (size) {
244  case 1: return ReadByte();
245  case 2: return ReadWord();
246  case 4: return ReadDWord();
247  default:
248  NOT_REACHED();
249  return 0;
250  }
251  }
252 
253  const char *ReadString()
254  {
255  char *string = reinterpret_cast<char *>(data);
256  size_t string_length = ttd_strnlen(string, Remaining());
257 
258  if (string_length == Remaining()) {
259  /* String was not NUL terminated, so make sure it is now. */
260  string[string_length - 1] = '\0';
261  grfmsg(7, "String was not terminated with a zero byte.");
262  } else {
263  /* Increase the string length to include the NUL byte. */
264  string_length++;
265  }
266  Skip(string_length);
267 
268  return string;
269  }
270 
271  inline size_t Remaining() const
272  {
273  return end - data;
274  }
275 
276  inline bool HasData(size_t count = 1) const
277  {
278  return data + count <= end;
279  }
280 
281  inline byte *Data()
282  {
283  return data;
284  }
285 
286  inline void Skip(size_t len)
287  {
288  data += len;
289  /* It is valid to move the buffer to exactly the end of the data,
290  * as there may not be any more data read. */
291  if (data > end) throw OTTDByteReaderSignal();
292  }
293 };
294 
295 typedef void (*SpecialSpriteHandler)(ByteReader *buf);
296 
297 static const uint NUM_STATIONS_PER_GRF = 255;
298 
303  UNSET = 0,
306  };
307 
308  uint16 cargo_allowed;
309  uint16 cargo_disallowed;
310  RailTypeLabel railtypelabel;
313  bool prop27_set;
314  uint8 rv_max_speed;
317 
322  void UpdateRefittability(bool non_empty)
323  {
324  if (non_empty) {
325  this->refittability = NONEMPTY;
326  } else if (this->refittability == UNSET) {
327  this->refittability = EMPTY;
328  }
329  }
330 };
331 
333 
338 static uint32 _grm_engines[256];
339 
341 static uint32 _grm_cargoes[NUM_CARGO * 2];
342 
343 struct GRFLocation {
344  uint32 grfid;
345  uint32 nfoline;
346 
347  GRFLocation(uint32 grfid, uint32 nfoline) : grfid(grfid), nfoline(nfoline) { }
348 
349  bool operator<(const GRFLocation &other) const
350  {
351  return this->grfid < other.grfid || (this->grfid == other.grfid && this->nfoline < other.nfoline);
352  }
353 
354  bool operator == (const GRFLocation &other) const
355  {
356  return this->grfid == other.grfid && this->nfoline == other.nfoline;
357  }
358 };
359 
360 static std::map<GRFLocation, SpriteID> _grm_sprites;
361 typedef std::map<GRFLocation, byte*> GRFLineToSpriteOverride;
362 static GRFLineToSpriteOverride _grf_line_to_action6_sprite_override;
363 
374 void CDECL grfmsg(int severity, const char *str, ...)
375 {
376  char buf[1024];
377  va_list va;
378 
379  va_start(va, str);
380  vseprintf(buf, lastof(buf), str, va);
381  va_end(va);
382 
383  DEBUG(grf, severity, "[%s:%d] %s", _cur.grfconfig->filename, _cur.nfo_line, buf);
384 }
385 
391 static GRFFile *GetFileByGRFID(uint32 grfid)
392 {
393  const GRFFile * const *end = _grf_files.End();
394  for (GRFFile * const *file = _grf_files.Begin(); file != end; file++) {
395  if ((*file)->grfid == grfid) return *file;
396  }
397  return NULL;
398 }
399 
405 static GRFFile *GetFileByFilename(const char *filename)
406 {
407  const GRFFile * const *end = _grf_files.End();
408  for (GRFFile * const *file = _grf_files.Begin(); file != end; file++) {
409  if (strcmp((*file)->filename, filename) == 0) return *file;
410  }
411  return NULL;
412 }
413 
416 {
417  /* Clear the GOTO labels used for GRF processing */
418  for (GRFLabel *l = gf->label; l != NULL;) {
419  GRFLabel *l2 = l->next;
420  free(l);
421  l = l2;
422  }
423  gf->label = NULL;
424 }
425 
432 static GRFError *DisableGrf(StringID message = STR_NULL, GRFConfig *config = NULL)
433 {
434  GRFFile *file;
435  if (config != NULL) {
436  file = GetFileByGRFID(config->ident.grfid);
437  } else {
438  config = _cur.grfconfig;
439  file = _cur.grffile;
440  }
441 
442  config->status = GCS_DISABLED;
443  if (file != NULL) ClearTemporaryNewGRFData(file);
444  if (config == _cur.grfconfig) _cur.skip_sprites = -1;
445 
446  if (message != STR_NULL) {
447  delete config->error;
448  config->error = new GRFError(STR_NEWGRF_ERROR_MSG_FATAL, message);
449  if (config == _cur.grfconfig) config->error->param_value[0] = _cur.nfo_line;
450  }
451 
452  return config->error;
453 }
454 
459  uint32 grfid;
462 };
464 static StringIDMappingVector _string_to_grf_mapping;
465 
471 static void AddStringForMapping(StringID source, StringID *target)
472 {
473  *target = STR_UNDEFINED;
474  StringIDMapping *item = _string_to_grf_mapping.Append();
475  item->grfid = _cur.grffile->grfid;
476  item->source = source;
477  item->target = target;
478 }
479 
488 {
489  /* StringID table for TextIDs 0x4E->0x6D */
490  static const StringID units_volume[] = {
491  STR_ITEMS, STR_PASSENGERS, STR_TONS, STR_BAGS,
492  STR_LITERS, STR_ITEMS, STR_CRATES, STR_TONS,
493  STR_TONS, STR_TONS, STR_TONS, STR_BAGS,
494  STR_TONS, STR_TONS, STR_TONS, STR_BAGS,
495  STR_TONS, STR_TONS, STR_BAGS, STR_LITERS,
496  STR_TONS, STR_LITERS, STR_TONS, STR_ITEMS,
497  STR_BAGS, STR_LITERS, STR_TONS, STR_ITEMS,
498  STR_TONS, STR_ITEMS, STR_LITERS, STR_ITEMS
499  };
500 
501  /* A string straight from a NewGRF; this was already translated by MapGRFStringID(). */
502  assert(!IsInsideMM(str, 0xD000, 0xD7FF));
503 
504 #define TEXTID_TO_STRINGID(begin, end, stringid, stringend) \
505  assert_compile(stringend - stringid == end - begin); \
506  if (str >= begin && str <= end) return str + (stringid - begin)
507 
508  /* We have some changes in our cargo strings, resulting in some missing. */
509  TEXTID_TO_STRINGID(0x000E, 0x002D, STR_CARGO_PLURAL_NOTHING, STR_CARGO_PLURAL_FIZZY_DRINKS);
510  TEXTID_TO_STRINGID(0x002E, 0x004D, STR_CARGO_SINGULAR_NOTHING, STR_CARGO_SINGULAR_FIZZY_DRINK);
511  if (str >= 0x004E && str <= 0x006D) return units_volume[str - 0x004E];
512  TEXTID_TO_STRINGID(0x006E, 0x008D, STR_QUANTITY_NOTHING, STR_QUANTITY_FIZZY_DRINKS);
513  TEXTID_TO_STRINGID(0x008E, 0x00AD, STR_ABBREV_NOTHING, STR_ABBREV_FIZZY_DRINKS);
514  TEXTID_TO_STRINGID(0x00D1, 0x00E0, STR_COLOUR_DARK_BLUE, STR_COLOUR_WHITE);
515 
516  /* Map building names according to our lang file changes. There are several
517  * ranges of house ids, all of which need to be remapped to allow newgrfs
518  * to use original house names. */
519  TEXTID_TO_STRINGID(0x200F, 0x201F, STR_TOWN_BUILDING_NAME_TALL_OFFICE_BLOCK_1, STR_TOWN_BUILDING_NAME_OLD_HOUSES_1);
520  TEXTID_TO_STRINGID(0x2036, 0x2041, STR_TOWN_BUILDING_NAME_COTTAGES_1, STR_TOWN_BUILDING_NAME_SHOPPING_MALL_1);
521  TEXTID_TO_STRINGID(0x2059, 0x205C, STR_TOWN_BUILDING_NAME_IGLOO_1, STR_TOWN_BUILDING_NAME_PIGGY_BANK_1);
522 
523  /* Same thing for industries */
524  TEXTID_TO_STRINGID(0x4802, 0x4826, STR_INDUSTRY_NAME_COAL_MINE, STR_INDUSTRY_NAME_SUGAR_MINE);
525  TEXTID_TO_STRINGID(0x482D, 0x482E, STR_NEWS_INDUSTRY_CONSTRUCTION, STR_NEWS_INDUSTRY_PLANTED);
526  TEXTID_TO_STRINGID(0x4832, 0x4834, STR_NEWS_INDUSTRY_CLOSURE_GENERAL, STR_NEWS_INDUSTRY_CLOSURE_LACK_OF_TREES);
527  TEXTID_TO_STRINGID(0x4835, 0x4838, STR_NEWS_INDUSTRY_PRODUCTION_INCREASE_GENERAL, STR_NEWS_INDUSTRY_PRODUCTION_INCREASE_FARM);
528  TEXTID_TO_STRINGID(0x4839, 0x483A, STR_NEWS_INDUSTRY_PRODUCTION_DECREASE_GENERAL, STR_NEWS_INDUSTRY_PRODUCTION_DECREASE_FARM);
529 
530  switch (str) {
531  case 0x4830: return STR_ERROR_CAN_T_CONSTRUCT_THIS_INDUSTRY;
532  case 0x4831: return STR_ERROR_FOREST_CAN_ONLY_BE_PLANTED;
533  case 0x483B: return STR_ERROR_CAN_ONLY_BE_POSITIONED;
534  }
535 #undef TEXTID_TO_STRINGID
536 
537  if (str == STR_NULL) return STR_EMPTY;
538 
539  DEBUG(grf, 0, "Unknown StringID 0x%04X remapped to STR_EMPTY. Please open a Feature Request if you need it", str);
540 
541  return STR_EMPTY;
542 }
543 
551 StringID MapGRFStringID(uint32 grfid, StringID str)
552 {
553  if (IsInsideMM(str, 0xD800, 0xE000)) {
554  /* General text provided by NewGRF.
555  * In the specs this is called the 0xDCxx range (misc presistent texts),
556  * but we meanwhile extended the range to 0xD800-0xDFFF.
557  * Note: We are not involved in the "persistent" business, since we do not store
558  * any NewGRF strings in savegames. */
559  return GetGRFStringID(grfid, str);
560  } else if (IsInsideMM(str, 0xD000, 0xD800)) {
561  /* Callback text provided by NewGRF.
562  * In the specs this is called the 0xD0xx range (misc graphics texts).
563  * These texts can be returned by various callbacks.
564  *
565  * Due to how TTDP implements the GRF-local- to global-textid translation
566  * texts included via 0x80 or 0x81 control codes have to add 0x400 to the textid.
567  * We do not care about that difference and just mask out the 0x400 bit.
568  */
569  str &= ~0x400;
570  return GetGRFStringID(grfid, str);
571  } else {
572  /* The NewGRF wants to include/reference an original TTD string.
573  * Try our best to find an equivalent one. */
575  }
576 }
577 
578 static std::map<uint32, uint32> _grf_id_overrides;
579 
585 static void SetNewGRFOverride(uint32 source_grfid, uint32 target_grfid)
586 {
587  _grf_id_overrides[source_grfid] = target_grfid;
588  grfmsg(5, "SetNewGRFOverride: Added override of 0x%X to 0x%X", BSWAP32(source_grfid), BSWAP32(target_grfid));
589 }
590 
599 static Engine *GetNewEngine(const GRFFile *file, VehicleType type, uint16 internal_id, bool static_access = false)
600 {
601  /* Hack for add-on GRFs that need to modify another GRF's engines. This lets
602  * them use the same engine slots. */
603  uint32 scope_grfid = INVALID_GRFID; // If not using dynamic_engines, all newgrfs share their ID range
605  /* If dynamic_engies is enabled, there can be multiple independent ID ranges. */
606  scope_grfid = file->grfid;
607  uint32 override = _grf_id_overrides[file->grfid];
608  if (override != 0) {
609  scope_grfid = override;
610  const GRFFile *grf_match = GetFileByGRFID(override);
611  if (grf_match == NULL) {
612  grfmsg(5, "Tried mapping from GRFID %x to %x but target is not loaded", BSWAP32(file->grfid), BSWAP32(override));
613  } else {
614  grfmsg(5, "Mapping from GRFID %x to %x", BSWAP32(file->grfid), BSWAP32(override));
615  }
616  }
617 
618  /* Check if the engine is registered in the override manager */
619  EngineID engine = _engine_mngr.GetID(type, internal_id, scope_grfid);
620  if (engine != INVALID_ENGINE) {
621  Engine *e = Engine::Get(engine);
622  if (e->grf_prop.grffile == NULL) e->grf_prop.grffile = file;
623  return e;
624  }
625  }
626 
627  /* Check if there is an unreserved slot */
628  EngineID engine = _engine_mngr.GetID(type, internal_id, INVALID_GRFID);
629  if (engine != INVALID_ENGINE) {
630  Engine *e = Engine::Get(engine);
631 
632  if (e->grf_prop.grffile == NULL) {
633  e->grf_prop.grffile = file;
634  grfmsg(5, "Replaced engine at index %d for GRFID %x, type %d, index %d", e->index, BSWAP32(file->grfid), type, internal_id);
635  }
636 
637  /* Reserve the engine slot */
638  if (!static_access) {
639  EngineIDMapping *eid = _engine_mngr.Get(engine);
640  eid->grfid = scope_grfid; // Note: this is INVALID_GRFID if dynamic_engines is disabled, so no reservation
641  }
642 
643  return e;
644  }
645 
646  if (static_access) return NULL;
647 
648  if (!Engine::CanAllocateItem()) {
649  grfmsg(0, "Can't allocate any more engines");
650  return NULL;
651  }
652 
653  size_t engine_pool_size = Engine::GetPoolSize();
654 
655  /* ... it's not, so create a new one based off an existing engine */
656  Engine *e = new Engine(type, internal_id);
657  e->grf_prop.grffile = file;
658 
659  /* Reserve the engine slot */
660  assert(_engine_mngr.Length() == e->index);
661  EngineIDMapping *eid = _engine_mngr.Append();
662  eid->type = type;
663  eid->grfid = scope_grfid; // Note: this is INVALID_GRFID if dynamic_engines is disabled, so no reservation
664  eid->internal_id = internal_id;
665  eid->substitute_id = min(internal_id, _engine_counts[type]); // substitute_id == _engine_counts[subtype] means "no substitute"
666 
667  if (engine_pool_size != Engine::GetPoolSize()) {
668  /* Resize temporary engine data ... */
669  _gted = ReallocT(_gted, Engine::GetPoolSize());
670 
671  /* and blank the new block. */
672  size_t len = (Engine::GetPoolSize() - engine_pool_size) * sizeof(*_gted);
673  memset(_gted + engine_pool_size, 0, len);
674  }
675  if (type == VEH_TRAIN) {
676  _gted[e->index].railtypelabel = GetRailTypeInfo(e->u.rail.railtype)->label;
677  }
678 
679  grfmsg(5, "Created new engine at index %d for GRFID %x, type %d, index %d", e->index, BSWAP32(file->grfid), type, internal_id);
680 
681  return e;
682 }
683 
694 EngineID GetNewEngineID(const GRFFile *file, VehicleType type, uint16 internal_id)
695 {
696  uint32 scope_grfid = INVALID_GRFID; // If not using dynamic_engines, all newgrfs share their ID range
698  scope_grfid = file->grfid;
699  uint32 override = _grf_id_overrides[file->grfid];
700  if (override != 0) scope_grfid = override;
701  }
702 
703  return _engine_mngr.GetID(type, internal_id, scope_grfid);
704 }
705 
710 static void MapSpriteMappingRecolour(PalSpriteID *grf_sprite)
711 {
712  if (HasBit(grf_sprite->pal, 14)) {
713  ClrBit(grf_sprite->pal, 14);
714  SetBit(grf_sprite->sprite, SPRITE_MODIFIER_OPAQUE);
715  }
716 
717  if (HasBit(grf_sprite->sprite, 14)) {
718  ClrBit(grf_sprite->sprite, 14);
720  }
721 
722  if (HasBit(grf_sprite->sprite, 15)) {
723  ClrBit(grf_sprite->sprite, 15);
724  SetBit(grf_sprite->sprite, PALETTE_MODIFIER_COLOUR);
725  }
726 }
727 
741 static TileLayoutFlags ReadSpriteLayoutSprite(ByteReader *buf, bool read_flags, bool invert_action1_flag, bool use_cur_spritesets, int feature, PalSpriteID *grf_sprite, uint16 *max_sprite_offset = NULL, uint16 *max_palette_offset = NULL)
742 {
743  grf_sprite->sprite = buf->ReadWord();
744  grf_sprite->pal = buf->ReadWord();
745  TileLayoutFlags flags = read_flags ? (TileLayoutFlags)buf->ReadWord() : TLF_NOTHING;
746 
747  MapSpriteMappingRecolour(grf_sprite);
748 
749  bool custom_sprite = HasBit(grf_sprite->pal, 15) != invert_action1_flag;
750  ClrBit(grf_sprite->pal, 15);
751  if (custom_sprite) {
752  /* Use sprite from Action 1 */
753  uint index = GB(grf_sprite->sprite, 0, 14);
754  if (use_cur_spritesets && (!_cur.IsValidSpriteSet(feature, index) || _cur.GetNumEnts(feature, index) == 0)) {
755  grfmsg(1, "ReadSpriteLayoutSprite: Spritelayout uses undefined custom spriteset %d", index);
756  grf_sprite->sprite = SPR_IMG_QUERY;
757  grf_sprite->pal = PAL_NONE;
758  } else {
759  SpriteID sprite = use_cur_spritesets ? _cur.GetSprite(feature, index) : index;
760  if (max_sprite_offset != NULL) *max_sprite_offset = use_cur_spritesets ? _cur.GetNumEnts(feature, index) : UINT16_MAX;
761  SB(grf_sprite->sprite, 0, SPRITE_WIDTH, sprite);
763  }
764  } else if ((flags & TLF_SPRITE_VAR10) && !(flags & TLF_SPRITE_REG_FLAGS)) {
765  grfmsg(1, "ReadSpriteLayoutSprite: Spritelayout specifies var10 value for non-action-1 sprite");
766  DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
767  return flags;
768  }
769 
770  if (flags & TLF_CUSTOM_PALETTE) {
771  /* Use palette from Action 1 */
772  uint index = GB(grf_sprite->pal, 0, 14);
773  if (use_cur_spritesets && (!_cur.IsValidSpriteSet(feature, index) || _cur.GetNumEnts(feature, index) == 0)) {
774  grfmsg(1, "ReadSpriteLayoutSprite: Spritelayout uses undefined custom spriteset %d for 'palette'", index);
775  grf_sprite->pal = PAL_NONE;
776  } else {
777  SpriteID sprite = use_cur_spritesets ? _cur.GetSprite(feature, index) : index;
778  if (max_palette_offset != NULL) *max_palette_offset = use_cur_spritesets ? _cur.GetNumEnts(feature, index) : UINT16_MAX;
779  SB(grf_sprite->pal, 0, SPRITE_WIDTH, sprite);
781  }
782  } else if ((flags & TLF_PALETTE_VAR10) && !(flags & TLF_PALETTE_REG_FLAGS)) {
783  grfmsg(1, "ReadSpriteLayoutRegisters: Spritelayout specifies var10 value for non-action-1 palette");
784  DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
785  return flags;
786  }
787 
788  return flags;
789 }
790 
799 static void ReadSpriteLayoutRegisters(ByteReader *buf, TileLayoutFlags flags, bool is_parent, NewGRFSpriteLayout *dts, uint index)
800 {
801  if (!(flags & TLF_DRAWING_FLAGS)) return;
802 
803  if (dts->registers == NULL) dts->AllocateRegisters();
804  TileLayoutRegisters &regs = const_cast<TileLayoutRegisters&>(dts->registers[index]);
805  regs.flags = flags & TLF_DRAWING_FLAGS;
806 
807  if (flags & TLF_DODRAW) regs.dodraw = buf->ReadByte();
808  if (flags & TLF_SPRITE) regs.sprite = buf->ReadByte();
809  if (flags & TLF_PALETTE) regs.palette = buf->ReadByte();
810 
811  if (is_parent) {
812  if (flags & TLF_BB_XY_OFFSET) {
813  regs.delta.parent[0] = buf->ReadByte();
814  regs.delta.parent[1] = buf->ReadByte();
815  }
816  if (flags & TLF_BB_Z_OFFSET) regs.delta.parent[2] = buf->ReadByte();
817  } else {
818  if (flags & TLF_CHILD_X_OFFSET) regs.delta.child[0] = buf->ReadByte();
819  if (flags & TLF_CHILD_Y_OFFSET) regs.delta.child[1] = buf->ReadByte();
820  }
821 
822  if (flags & TLF_SPRITE_VAR10) {
823  regs.sprite_var10 = buf->ReadByte();
824  if (regs.sprite_var10 > TLR_MAX_VAR10) {
825  grfmsg(1, "ReadSpriteLayoutRegisters: Spritelayout specifies var10 (%d) exceeding the maximal allowed value %d", regs.sprite_var10, TLR_MAX_VAR10);
826  DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
827  return;
828  }
829  }
830 
831  if (flags & TLF_PALETTE_VAR10) {
832  regs.palette_var10 = buf->ReadByte();
833  if (regs.palette_var10 > TLR_MAX_VAR10) {
834  grfmsg(1, "ReadSpriteLayoutRegisters: Spritelayout specifies var10 (%d) exceeding the maximal allowed value %d", regs.palette_var10, TLR_MAX_VAR10);
835  DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
836  return;
837  }
838  }
839 }
840 
852 static bool ReadSpriteLayout(ByteReader *buf, uint num_building_sprites, bool use_cur_spritesets, byte feature, bool allow_var10, bool no_z_position, NewGRFSpriteLayout *dts)
853 {
854  bool has_flags = HasBit(num_building_sprites, 6);
855  ClrBit(num_building_sprites, 6);
856  TileLayoutFlags valid_flags = TLF_KNOWN_FLAGS;
857  if (!allow_var10) valid_flags &= ~TLF_VAR10_FLAGS;
858  dts->Allocate(num_building_sprites); // allocate before reading groundsprite flags
859 
860  uint16 *max_sprite_offset = AllocaM(uint16, num_building_sprites + 1);
861  uint16 *max_palette_offset = AllocaM(uint16, num_building_sprites + 1);
862  MemSetT(max_sprite_offset, 0, num_building_sprites + 1);
863  MemSetT(max_palette_offset, 0, num_building_sprites + 1);
864 
865  /* Groundsprite */
866  TileLayoutFlags flags = ReadSpriteLayoutSprite(buf, has_flags, false, use_cur_spritesets, feature, &dts->ground, max_sprite_offset, max_palette_offset);
867  if (_cur.skip_sprites < 0) return true;
868 
869  if (flags & ~(valid_flags & ~TLF_NON_GROUND_FLAGS)) {
870  grfmsg(1, "ReadSpriteLayout: Spritelayout uses invalid flag 0x%x for ground sprite", flags & ~(valid_flags & ~TLF_NON_GROUND_FLAGS));
871  DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
872  return true;
873  }
874 
875  ReadSpriteLayoutRegisters(buf, flags, false, dts, 0);
876  if (_cur.skip_sprites < 0) return true;
877 
878  for (uint i = 0; i < num_building_sprites; i++) {
879  DrawTileSeqStruct *seq = const_cast<DrawTileSeqStruct*>(&dts->seq[i]);
880 
881  flags = ReadSpriteLayoutSprite(buf, has_flags, false, use_cur_spritesets, feature, &seq->image, max_sprite_offset + i + 1, max_palette_offset + i + 1);
882  if (_cur.skip_sprites < 0) return true;
883 
884  if (flags & ~valid_flags) {
885  grfmsg(1, "ReadSpriteLayout: Spritelayout uses unknown flag 0x%x", flags & ~valid_flags);
886  DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
887  return true;
888  }
889 
890  seq->delta_x = buf->ReadByte();
891  seq->delta_y = buf->ReadByte();
892 
893  if (!no_z_position) seq->delta_z = buf->ReadByte();
894 
895  if (seq->IsParentSprite()) {
896  seq->size_x = buf->ReadByte();
897  seq->size_y = buf->ReadByte();
898  seq->size_z = buf->ReadByte();
899  }
900 
901  ReadSpriteLayoutRegisters(buf, flags, seq->IsParentSprite(), dts, i + 1);
902  if (_cur.skip_sprites < 0) return true;
903  }
904 
905  /* Check if the number of sprites per spriteset is consistent */
906  bool is_consistent = true;
907  dts->consistent_max_offset = 0;
908  for (uint i = 0; i < num_building_sprites + 1; i++) {
909  if (max_sprite_offset[i] > 0) {
910  if (dts->consistent_max_offset == 0) {
911  dts->consistent_max_offset = max_sprite_offset[i];
912  } else if (dts->consistent_max_offset != max_sprite_offset[i]) {
913  is_consistent = false;
914  break;
915  }
916  }
917  if (max_palette_offset[i] > 0) {
918  if (dts->consistent_max_offset == 0) {
919  dts->consistent_max_offset = max_palette_offset[i];
920  } else if (dts->consistent_max_offset != max_palette_offset[i]) {
921  is_consistent = false;
922  break;
923  }
924  }
925  }
926 
927  /* When the Action1 sets are unknown, everything should be 0 (no spriteset usage) or UINT16_MAX (some spriteset usage) */
928  assert(use_cur_spritesets || (is_consistent && (dts->consistent_max_offset == 0 || dts->consistent_max_offset == UINT16_MAX)));
929 
930  if (!is_consistent || dts->registers != NULL) {
931  dts->consistent_max_offset = 0;
932  if (dts->registers == NULL) dts->AllocateRegisters();
933 
934  for (uint i = 0; i < num_building_sprites + 1; i++) {
935  TileLayoutRegisters &regs = const_cast<TileLayoutRegisters&>(dts->registers[i]);
936  regs.max_sprite_offset = max_sprite_offset[i];
937  regs.max_palette_offset = max_palette_offset[i];
938  }
939  }
940 
941  return false;
942 }
943 
947 static uint32 TranslateRefitMask(uint32 refit_mask)
948 {
949  uint32 result = 0;
950  uint8 bit;
951  FOR_EACH_SET_BIT(bit, refit_mask) {
952  CargoID cargo = GetCargoTranslation(bit, _cur.grffile, true);
953  if (cargo != CT_INVALID) SetBit(result, cargo);
954  }
955  return result;
956 }
957 
965 static void ConvertTTDBasePrice(uint32 base_pointer, const char *error_location, Price *index)
966 {
967  /* Special value for 'none' */
968  if (base_pointer == 0) {
969  *index = INVALID_PRICE;
970  return;
971  }
972 
973  static const uint32 start = 0x4B34;
974  static const uint32 size = 6;
975 
976  if (base_pointer < start || (base_pointer - start) % size != 0 || (base_pointer - start) / size >= PR_END) {
977  grfmsg(1, "%s: Unsupported running cost base 0x%04X, ignoring", error_location, base_pointer);
978  return;
979  }
980 
981  *index = (Price)((base_pointer - start) / size);
982 }
983 
991 };
992 
993 typedef ChangeInfoResult (*VCI_Handler)(uint engine, int numinfo, int prop, ByteReader *buf);
994 
1003 {
1004  switch (prop) {
1005  case 0x00: // Introduction date
1006  ei->base_intro = buf->ReadWord() + DAYS_TILL_ORIGINAL_BASE_YEAR;
1007  break;
1008 
1009  case 0x02: // Decay speed
1010  ei->decay_speed = buf->ReadByte();
1011  break;
1012 
1013  case 0x03: // Vehicle life
1014  ei->lifelength = buf->ReadByte();
1015  break;
1016 
1017  case 0x04: // Model life
1018  ei->base_life = buf->ReadByte();
1019  break;
1020 
1021  case 0x06: // Climates available
1022  ei->climates = buf->ReadByte();
1023  break;
1024 
1025  case PROP_VEHICLE_LOAD_AMOUNT: // 0x07 Loading speed
1026  /* Amount of cargo loaded during a vehicle's "loading tick" */
1027  ei->load_amount = buf->ReadByte();
1028  break;
1029 
1030  default:
1031  return CIR_UNKNOWN;
1032  }
1033 
1034  return CIR_SUCCESS;
1035 }
1036 
1045 static ChangeInfoResult RailVehicleChangeInfo(uint engine, int numinfo, int prop, ByteReader *buf)
1046 {
1048 
1049  for (int i = 0; i < numinfo; i++) {
1050  Engine *e = GetNewEngine(_cur.grffile, VEH_TRAIN, engine + i);
1051  if (e == NULL) return CIR_INVALID_ID; // No engine could be allocated, so neither can any next vehicles
1052 
1053  EngineInfo *ei = &e->info;
1054  RailVehicleInfo *rvi = &e->u.rail;
1055 
1056  switch (prop) {
1057  case 0x05: { // Track type
1058  uint8 tracktype = buf->ReadByte();
1059 
1060  if (tracktype < _cur.grffile->railtype_list.Length()) {
1061  _gted[e->index].railtypelabel = _cur.grffile->railtype_list[tracktype];
1062  break;
1063  }
1064 
1065  switch (tracktype) {
1066  case 0: _gted[e->index].railtypelabel = rvi->engclass >= 2 ? RAILTYPE_ELECTRIC_LABEL : RAILTYPE_RAIL_LABEL; break;
1067  case 1: _gted[e->index].railtypelabel = RAILTYPE_MONO_LABEL; break;
1068  case 2: _gted[e->index].railtypelabel = RAILTYPE_MAGLEV_LABEL; break;
1069  default:
1070  grfmsg(1, "RailVehicleChangeInfo: Invalid track type %d specified, ignoring", tracktype);
1071  break;
1072  }
1073  break;
1074  }
1075 
1076  case 0x08: // AI passenger service
1077  /* Tells the AI that this engine is designed for
1078  * passenger services and shouldn't be used for freight. */
1079  rvi->ai_passenger_only = buf->ReadByte();
1080  break;
1081 
1082  case PROP_TRAIN_SPEED: { // 0x09 Speed (1 unit is 1 km-ish/h)
1083  uint16 speed = buf->ReadWord();
1084  if (speed == 0xFFFF) speed = 0;
1085 
1086  rvi->max_speed = speed;
1087  break;
1088  }
1089 
1090  case PROP_TRAIN_POWER: // 0x0B Power
1091  rvi->power = buf->ReadWord();
1092 
1093  /* Set engine / wagon state based on power */
1094  if (rvi->power != 0) {
1095  if (rvi->railveh_type == RAILVEH_WAGON) {
1096  rvi->railveh_type = RAILVEH_SINGLEHEAD;
1097  }
1098  } else {
1099  rvi->railveh_type = RAILVEH_WAGON;
1100  }
1101  break;
1102 
1103  case PROP_TRAIN_RUNNING_COST_FACTOR: // 0x0D Running cost factor
1104  rvi->running_cost = buf->ReadByte();
1105  break;
1106 
1107  case 0x0E: // Running cost base
1108  ConvertTTDBasePrice(buf->ReadDWord(), "RailVehicleChangeInfo", &rvi->running_cost_class);
1109  break;
1110 
1111  case 0x12: { // Sprite ID
1112  uint8 spriteid = buf->ReadByte();
1113  uint8 orig_spriteid = spriteid;
1114 
1115  /* TTD sprite IDs point to a location in a 16bit array, but we use it
1116  * as an array index, so we need it to be half the original value. */
1117  if (spriteid < 0xFD) spriteid >>= 1;
1118 
1119  if (IsValidNewGRFImageIndex<VEH_TRAIN>(spriteid)) {
1120  rvi->image_index = spriteid;
1121  } else {
1122  grfmsg(1, "RailVehicleChangeInfo: Invalid Sprite %d specified, ignoring", orig_spriteid);
1123  rvi->image_index = 0;
1124  }
1125  break;
1126  }
1127 
1128  case 0x13: { // Dual-headed
1129  uint8 dual = buf->ReadByte();
1130 
1131  if (dual != 0) {
1132  rvi->railveh_type = RAILVEH_MULTIHEAD;
1133  } else {
1134  rvi->railveh_type = rvi->power == 0 ?
1136  }
1137  break;
1138  }
1139 
1140  case PROP_TRAIN_CARGO_CAPACITY: // 0x14 Cargo capacity
1141  rvi->capacity = buf->ReadByte();
1142  break;
1143 
1144  case 0x15: { // Cargo type
1145  _gted[e->index].defaultcargo_grf = _cur.grffile;
1146  uint8 ctype = buf->ReadByte();
1147 
1148  if (ctype == 0xFF) {
1149  /* 0xFF is specified as 'use first refittable' */
1150  ei->cargo_type = CT_INVALID;
1151  } else if (_cur.grffile->grf_version >= 8) {
1152  /* Use translated cargo. Might result in CT_INVALID (first refittable), if cargo is not defined. */
1153  ei->cargo_type = GetCargoTranslation(ctype, _cur.grffile);
1154  } else if (ctype < NUM_CARGO) {
1155  /* Use untranslated cargo. */
1156  ei->cargo_type = ctype;
1157  } else {
1158  ei->cargo_type = CT_INVALID;
1159  grfmsg(2, "RailVehicleChangeInfo: Invalid cargo type %d, using first refittable", ctype);
1160  }
1161  break;
1162  }
1163 
1164  case PROP_TRAIN_WEIGHT: // 0x16 Weight
1165  SB(rvi->weight, 0, 8, buf->ReadByte());
1166  break;
1167 
1168  case PROP_TRAIN_COST_FACTOR: // 0x17 Cost factor
1169  rvi->cost_factor = buf->ReadByte();
1170  break;
1171 
1172  case 0x18: // AI rank
1173  grfmsg(2, "RailVehicleChangeInfo: Property 0x18 'AI rank' not used by NoAI, ignored.");
1174  buf->ReadByte();
1175  break;
1176 
1177  case 0x19: { // Engine traction type
1178  /* What do the individual numbers mean?
1179  * 0x00 .. 0x07: Steam
1180  * 0x08 .. 0x27: Diesel
1181  * 0x28 .. 0x31: Electric
1182  * 0x32 .. 0x37: Monorail
1183  * 0x38 .. 0x41: Maglev
1184  */
1185  uint8 traction = buf->ReadByte();
1186  EngineClass engclass;
1187 
1188  if (traction <= 0x07) {
1189  engclass = EC_STEAM;
1190  } else if (traction <= 0x27) {
1191  engclass = EC_DIESEL;
1192  } else if (traction <= 0x31) {
1193  engclass = EC_ELECTRIC;
1194  } else if (traction <= 0x37) {
1195  engclass = EC_MONORAIL;
1196  } else if (traction <= 0x41) {
1197  engclass = EC_MAGLEV;
1198  } else {
1199  break;
1200  }
1201 
1202  if (_cur.grffile->railtype_list.Length() == 0) {
1203  /* Use traction type to select between normal and electrified
1204  * rail only when no translation list is in place. */
1205  if (_gted[e->index].railtypelabel == RAILTYPE_RAIL_LABEL && engclass >= EC_ELECTRIC) _gted[e->index].railtypelabel = RAILTYPE_ELECTRIC_LABEL;
1206  if (_gted[e->index].railtypelabel == RAILTYPE_ELECTRIC_LABEL && engclass < EC_ELECTRIC) _gted[e->index].railtypelabel = RAILTYPE_RAIL_LABEL;
1207  }
1208 
1209  rvi->engclass = engclass;
1210  break;
1211  }
1212 
1213  case 0x1A: // Alter purchase list sort order
1214  AlterVehicleListOrder(e->index, buf->ReadExtendedByte());
1215  break;
1216 
1217  case 0x1B: // Powered wagons power bonus
1218  rvi->pow_wag_power = buf->ReadWord();
1219  break;
1220 
1221  case 0x1C: // Refit cost
1222  ei->refit_cost = buf->ReadByte();
1223  break;
1224 
1225  case 0x1D: { // Refit cargo
1226  uint32 mask = buf->ReadDWord();
1227  _gted[e->index].UpdateRefittability(mask != 0);
1228  ei->refit_mask = TranslateRefitMask(mask);
1229  _gted[e->index].defaultcargo_grf = _cur.grffile;
1230  break;
1231  }
1232 
1233  case 0x1E: // Callback
1234  ei->callback_mask = buf->ReadByte();
1235  break;
1236 
1237  case PROP_TRAIN_TRACTIVE_EFFORT: // 0x1F Tractive effort coefficient
1238  rvi->tractive_effort = buf->ReadByte();
1239  break;
1240 
1241  case 0x20: // Air drag
1242  rvi->air_drag = buf->ReadByte();
1243  break;
1244 
1245  case PROP_TRAIN_SHORTEN_FACTOR: // 0x21 Shorter vehicle
1246  rvi->shorten_factor = buf->ReadByte();
1247  break;
1248 
1249  case 0x22: // Visual effect
1250  rvi->visual_effect = buf->ReadByte();
1251  /* Avoid accidentally setting visual_effect to the default value
1252  * Since bit 6 (disable effects) is set anyways, we can safely erase some bits. */
1253  if (rvi->visual_effect == VE_DEFAULT) {
1254  assert(HasBit(rvi->visual_effect, VE_DISABLE_EFFECT));
1256  }
1257  break;
1258 
1259  case 0x23: // Powered wagons weight bonus
1260  rvi->pow_wag_weight = buf->ReadByte();
1261  break;
1262 
1263  case 0x24: { // High byte of vehicle weight
1264  byte weight = buf->ReadByte();
1265 
1266  if (weight > 4) {
1267  grfmsg(2, "RailVehicleChangeInfo: Nonsensical weight of %d tons, ignoring", weight << 8);
1268  } else {
1269  SB(rvi->weight, 8, 8, weight);
1270  }
1271  break;
1272  }
1273 
1274  case PROP_TRAIN_USER_DATA: // 0x25 User-defined bit mask to set when checking veh. var. 42
1275  rvi->user_def_data = buf->ReadByte();
1276  break;
1277 
1278  case 0x26: // Retire vehicle early
1279  ei->retire_early = buf->ReadByte();
1280  break;
1281 
1282  case 0x27: // Miscellaneous flags
1283  ei->misc_flags = buf->ReadByte();
1284  _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
1285  _gted[e->index].prop27_set = true;
1286  break;
1287 
1288  case 0x28: // Cargo classes allowed
1289  _gted[e->index].cargo_allowed = buf->ReadWord();
1290  _gted[e->index].UpdateRefittability(_gted[e->index].cargo_allowed != 0);
1291  _gted[e->index].defaultcargo_grf = _cur.grffile;
1292  break;
1293 
1294  case 0x29: // Cargo classes disallowed
1295  _gted[e->index].cargo_disallowed = buf->ReadWord();
1296  _gted[e->index].UpdateRefittability(false);
1297  break;
1298 
1299  case 0x2A: // Long format introduction date (days since year 0)
1300  ei->base_intro = buf->ReadDWord();
1301  break;
1302 
1303  case PROP_TRAIN_CARGO_AGE_PERIOD: // 0x2B Cargo aging period
1304  ei->cargo_age_period = buf->ReadWord();
1305  break;
1306 
1307  case 0x2C: // CTT refit include list
1308  case 0x2D: { // CTT refit exclude list
1309  uint8 count = buf->ReadByte();
1310  _gted[e->index].UpdateRefittability(prop == 0x2C && count != 0);
1311  if (prop == 0x2C) _gted[e->index].defaultcargo_grf = _cur.grffile;
1312  uint32 &ctt = prop == 0x2C ? _gted[e->index].ctt_include_mask : _gted[e->index].ctt_exclude_mask;
1313  ctt = 0;
1314  while (count--) {
1315  CargoID ctype = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
1316  if (ctype == CT_INVALID) continue;
1317  SetBit(ctt, ctype);
1318  }
1319  break;
1320  }
1321 
1322  default:
1323  ret = CommonVehicleChangeInfo(ei, prop, buf);
1324  break;
1325  }
1326  }
1327 
1328  return ret;
1329 }
1330 
1339 static ChangeInfoResult RoadVehicleChangeInfo(uint engine, int numinfo, int prop, ByteReader *buf)
1340 {
1342 
1343  for (int i = 0; i < numinfo; i++) {
1344  Engine *e = GetNewEngine(_cur.grffile, VEH_ROAD, engine + i);
1345  if (e == NULL) return CIR_INVALID_ID; // No engine could be allocated, so neither can any next vehicles
1346 
1347  EngineInfo *ei = &e->info;
1348  RoadVehicleInfo *rvi = &e->u.road;
1349 
1350  switch (prop) {
1351  case 0x08: // Speed (1 unit is 0.5 kmh)
1352  rvi->max_speed = buf->ReadByte();
1353  break;
1354 
1355  case PROP_ROADVEH_RUNNING_COST_FACTOR: // 0x09 Running cost factor
1356  rvi->running_cost = buf->ReadByte();
1357  break;
1358 
1359  case 0x0A: // Running cost base
1360  ConvertTTDBasePrice(buf->ReadDWord(), "RoadVehicleChangeInfo", &rvi->running_cost_class);
1361  break;
1362 
1363  case 0x0E: { // Sprite ID
1364  uint8 spriteid = buf->ReadByte();
1365  uint8 orig_spriteid = spriteid;
1366 
1367  /* cars have different custom id in the GRF file */
1368  if (spriteid == 0xFF) spriteid = 0xFD;
1369 
1370  if (spriteid < 0xFD) spriteid >>= 1;
1371 
1372  if (IsValidNewGRFImageIndex<VEH_ROAD>(spriteid)) {
1373  rvi->image_index = spriteid;
1374  } else {
1375  grfmsg(1, "RoadVehicleChangeInfo: Invalid Sprite %d specified, ignoring", orig_spriteid);
1376  rvi->image_index = 0;
1377  }
1378  break;
1379  }
1380 
1381  case PROP_ROADVEH_CARGO_CAPACITY: // 0x0F Cargo capacity
1382  rvi->capacity = buf->ReadByte();
1383  break;
1384 
1385  case 0x10: { // Cargo type
1386  _gted[e->index].defaultcargo_grf = _cur.grffile;
1387  uint8 ctype = buf->ReadByte();
1388 
1389  if (ctype == 0xFF) {
1390  /* 0xFF is specified as 'use first refittable' */
1391  ei->cargo_type = CT_INVALID;
1392  } else if (_cur.grffile->grf_version >= 8) {
1393  /* Use translated cargo. Might result in CT_INVALID (first refittable), if cargo is not defined. */
1394  ei->cargo_type = GetCargoTranslation(ctype, _cur.grffile);
1395  } else if (ctype < NUM_CARGO) {
1396  /* Use untranslated cargo. */
1397  ei->cargo_type = ctype;
1398  } else {
1399  ei->cargo_type = CT_INVALID;
1400  grfmsg(2, "RailVehicleChangeInfo: Invalid cargo type %d, using first refittable", ctype);
1401  }
1402  break;
1403  }
1404 
1405  case PROP_ROADVEH_COST_FACTOR: // 0x11 Cost factor
1406  rvi->cost_factor = buf->ReadByte();
1407  break;
1408 
1409  case 0x12: // SFX
1410  rvi->sfx = GetNewGRFSoundID(_cur.grffile, buf->ReadByte());
1411  break;
1412 
1413  case PROP_ROADVEH_POWER: // Power in units of 10 HP.
1414  rvi->power = buf->ReadByte();
1415  break;
1416 
1417  case PROP_ROADVEH_WEIGHT: // Weight in units of 1/4 tons.
1418  rvi->weight = buf->ReadByte();
1419  break;
1420 
1421  case PROP_ROADVEH_SPEED: // Speed in mph/0.8
1422  _gted[e->index].rv_max_speed = buf->ReadByte();
1423  break;
1424 
1425  case 0x16: { // Cargoes available for refitting
1426  uint32 mask = buf->ReadDWord();
1427  _gted[e->index].UpdateRefittability(mask != 0);
1428  ei->refit_mask = TranslateRefitMask(mask);
1429  _gted[e->index].defaultcargo_grf = _cur.grffile;
1430  break;
1431  }
1432 
1433  case 0x17: // Callback mask
1434  ei->callback_mask = buf->ReadByte();
1435  break;
1436 
1437  case PROP_ROADVEH_TRACTIVE_EFFORT: // Tractive effort coefficient in 1/256.
1438  rvi->tractive_effort = buf->ReadByte();
1439  break;
1440 
1441  case 0x19: // Air drag
1442  rvi->air_drag = buf->ReadByte();
1443  break;
1444 
1445  case 0x1A: // Refit cost
1446  ei->refit_cost = buf->ReadByte();
1447  break;
1448 
1449  case 0x1B: // Retire vehicle early
1450  ei->retire_early = buf->ReadByte();
1451  break;
1452 
1453  case 0x1C: // Miscellaneous flags
1454  ei->misc_flags = buf->ReadByte();
1455  _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
1456  break;
1457 
1458  case 0x1D: // Cargo classes allowed
1459  _gted[e->index].cargo_allowed = buf->ReadWord();
1460  _gted[e->index].UpdateRefittability(_gted[e->index].cargo_allowed != 0);
1461  _gted[e->index].defaultcargo_grf = _cur.grffile;
1462  break;
1463 
1464  case 0x1E: // Cargo classes disallowed
1465  _gted[e->index].cargo_disallowed = buf->ReadWord();
1466  _gted[e->index].UpdateRefittability(false);
1467  break;
1468 
1469  case 0x1F: // Long format introduction date (days since year 0)
1470  ei->base_intro = buf->ReadDWord();
1471  break;
1472 
1473  case 0x20: // Alter purchase list sort order
1474  AlterVehicleListOrder(e->index, buf->ReadExtendedByte());
1475  break;
1476 
1477  case 0x21: // Visual effect
1478  rvi->visual_effect = buf->ReadByte();
1479  /* Avoid accidentally setting visual_effect to the default value
1480  * Since bit 6 (disable effects) is set anyways, we can safely erase some bits. */
1481  if (rvi->visual_effect == VE_DEFAULT) {
1482  assert(HasBit(rvi->visual_effect, VE_DISABLE_EFFECT));
1484  }
1485  break;
1486 
1487  case PROP_ROADVEH_CARGO_AGE_PERIOD: // 0x22 Cargo aging period
1488  ei->cargo_age_period = buf->ReadWord();
1489  break;
1490 
1491  case PROP_ROADVEH_SHORTEN_FACTOR: // 0x23 Shorter vehicle
1492  rvi->shorten_factor = buf->ReadByte();
1493  break;
1494 
1495  case 0x24: // CTT refit include list
1496  case 0x25: { // CTT refit exclude list
1497  uint8 count = buf->ReadByte();
1498  _gted[e->index].UpdateRefittability(prop == 0x24 && count != 0);
1499  if (prop == 0x24) _gted[e->index].defaultcargo_grf = _cur.grffile;
1500  uint32 &ctt = prop == 0x24 ? _gted[e->index].ctt_include_mask : _gted[e->index].ctt_exclude_mask;
1501  ctt = 0;
1502  while (count--) {
1503  CargoID ctype = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
1504  if (ctype == CT_INVALID) continue;
1505  SetBit(ctt, ctype);
1506  }
1507  break;
1508  }
1509 
1510  default:
1511  ret = CommonVehicleChangeInfo(ei, prop, buf);
1512  break;
1513  }
1514  }
1515 
1516  return ret;
1517 }
1518 
1527 static ChangeInfoResult ShipVehicleChangeInfo(uint engine, int numinfo, int prop, ByteReader *buf)
1528 {
1530 
1531  for (int i = 0; i < numinfo; i++) {
1532  Engine *e = GetNewEngine(_cur.grffile, VEH_SHIP, engine + i);
1533  if (e == NULL) return CIR_INVALID_ID; // No engine could be allocated, so neither can any next vehicles
1534 
1535  EngineInfo *ei = &e->info;
1536  ShipVehicleInfo *svi = &e->u.ship;
1537 
1538  switch (prop) {
1539  case 0x08: { // Sprite ID
1540  uint8 spriteid = buf->ReadByte();
1541  uint8 orig_spriteid = spriteid;
1542 
1543  /* ships have different custom id in the GRF file */
1544  if (spriteid == 0xFF) spriteid = 0xFD;
1545 
1546  if (spriteid < 0xFD) spriteid >>= 1;
1547 
1548  if (IsValidNewGRFImageIndex<VEH_SHIP>(spriteid)) {
1549  svi->image_index = spriteid;
1550  } else {
1551  grfmsg(1, "ShipVehicleChangeInfo: Invalid Sprite %d specified, ignoring", orig_spriteid);
1552  svi->image_index = 0;
1553  }
1554  break;
1555  }
1556 
1557  case 0x09: // Refittable
1558  svi->old_refittable = (buf->ReadByte() != 0);
1559  break;
1560 
1561  case PROP_SHIP_COST_FACTOR: // 0x0A Cost factor
1562  svi->cost_factor = buf->ReadByte();
1563  break;
1564 
1565  case PROP_SHIP_SPEED: // 0x0B Speed (1 unit is 0.5 km-ish/h)
1566  svi->max_speed = buf->ReadByte();
1567  break;
1568 
1569  case 0x0C: { // Cargo type
1570  _gted[e->index].defaultcargo_grf = _cur.grffile;
1571  uint8 ctype = buf->ReadByte();
1572 
1573  if (ctype == 0xFF) {
1574  /* 0xFF is specified as 'use first refittable' */
1575  ei->cargo_type = CT_INVALID;
1576  } else if (_cur.grffile->grf_version >= 8) {
1577  /* Use translated cargo. Might result in CT_INVALID (first refittable), if cargo is not defined. */
1578  ei->cargo_type = GetCargoTranslation(ctype, _cur.grffile);
1579  } else if (ctype < NUM_CARGO) {
1580  /* Use untranslated cargo. */
1581  ei->cargo_type = ctype;
1582  } else {
1583  ei->cargo_type = CT_INVALID;
1584  grfmsg(2, "RailVehicleChangeInfo: Invalid cargo type %d, using first refittable", ctype);
1585  }
1586  break;
1587  }
1588 
1589  case PROP_SHIP_CARGO_CAPACITY: // 0x0D Cargo capacity
1590  svi->capacity = buf->ReadWord();
1591  break;
1592 
1593  case PROP_SHIP_RUNNING_COST_FACTOR: // 0x0F Running cost factor
1594  svi->running_cost = buf->ReadByte();
1595  break;
1596 
1597  case 0x10: // SFX
1598  svi->sfx = GetNewGRFSoundID(_cur.grffile, buf->ReadByte());
1599  break;
1600 
1601  case 0x11: { // Cargoes available for refitting
1602  uint32 mask = buf->ReadDWord();
1603  _gted[e->index].UpdateRefittability(mask != 0);
1604  ei->refit_mask = TranslateRefitMask(mask);
1605  _gted[e->index].defaultcargo_grf = _cur.grffile;
1606  break;
1607  }
1608 
1609  case 0x12: // Callback mask
1610  ei->callback_mask = buf->ReadByte();
1611  break;
1612 
1613  case 0x13: // Refit cost
1614  ei->refit_cost = buf->ReadByte();
1615  break;
1616 
1617  case 0x14: // Ocean speed fraction
1618  svi->ocean_speed_frac = buf->ReadByte();
1619  break;
1620 
1621  case 0x15: // Canal speed fraction
1622  svi->canal_speed_frac = buf->ReadByte();
1623  break;
1624 
1625  case 0x16: // Retire vehicle early
1626  ei->retire_early = buf->ReadByte();
1627  break;
1628 
1629  case 0x17: // Miscellaneous flags
1630  ei->misc_flags = buf->ReadByte();
1631  _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
1632  break;
1633 
1634  case 0x18: // Cargo classes allowed
1635  _gted[e->index].cargo_allowed = buf->ReadWord();
1636  _gted[e->index].UpdateRefittability(_gted[e->index].cargo_allowed != 0);
1637  _gted[e->index].defaultcargo_grf = _cur.grffile;
1638  break;
1639 
1640  case 0x19: // Cargo classes disallowed
1641  _gted[e->index].cargo_disallowed = buf->ReadWord();
1642  _gted[e->index].UpdateRefittability(false);
1643  break;
1644 
1645  case 0x1A: // Long format introduction date (days since year 0)
1646  ei->base_intro = buf->ReadDWord();
1647  break;
1648 
1649  case 0x1B: // Alter purchase list sort order
1650  AlterVehicleListOrder(e->index, buf->ReadExtendedByte());
1651  break;
1652 
1653  case 0x1C: // Visual effect
1654  svi->visual_effect = buf->ReadByte();
1655  /* Avoid accidentally setting visual_effect to the default value
1656  * Since bit 6 (disable effects) is set anyways, we can safely erase some bits. */
1657  if (svi->visual_effect == VE_DEFAULT) {
1658  assert(HasBit(svi->visual_effect, VE_DISABLE_EFFECT));
1660  }
1661  break;
1662 
1663  case PROP_SHIP_CARGO_AGE_PERIOD: // 0x1D Cargo aging period
1664  ei->cargo_age_period = buf->ReadWord();
1665  break;
1666 
1667  case 0x1E: // CTT refit include list
1668  case 0x1F: { // CTT refit exclude list
1669  uint8 count = buf->ReadByte();
1670  _gted[e->index].UpdateRefittability(prop == 0x1E && count != 0);
1671  if (prop == 0x1E) _gted[e->index].defaultcargo_grf = _cur.grffile;
1672  uint32 &ctt = prop == 0x1E ? _gted[e->index].ctt_include_mask : _gted[e->index].ctt_exclude_mask;
1673  ctt = 0;
1674  while (count--) {
1675  CargoID ctype = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
1676  if (ctype == CT_INVALID) continue;
1677  SetBit(ctt, ctype);
1678  }
1679  break;
1680  }
1681 
1682  default:
1683  ret = CommonVehicleChangeInfo(ei, prop, buf);
1684  break;
1685  }
1686  }
1687 
1688  return ret;
1689 }
1690 
1699 static ChangeInfoResult AircraftVehicleChangeInfo(uint engine, int numinfo, int prop, ByteReader *buf)
1700 {
1702 
1703  for (int i = 0; i < numinfo; i++) {
1704  Engine *e = GetNewEngine(_cur.grffile, VEH_AIRCRAFT, engine + i);
1705  if (e == NULL) return CIR_INVALID_ID; // No engine could be allocated, so neither can any next vehicles
1706 
1707  EngineInfo *ei = &e->info;
1708  AircraftVehicleInfo *avi = &e->u.air;
1709 
1710  switch (prop) {
1711  case 0x08: { // Sprite ID
1712  uint8 spriteid = buf->ReadByte();
1713  uint8 orig_spriteid = spriteid;
1714 
1715  /* aircraft have different custom id in the GRF file */
1716  if (spriteid == 0xFF) spriteid = 0xFD;
1717 
1718  if (spriteid < 0xFD) spriteid >>= 1;
1719 
1720  if (IsValidNewGRFImageIndex<VEH_AIRCRAFT>(spriteid)) {
1721  avi->image_index = spriteid;
1722  } else {
1723  grfmsg(1, "AircraftVehicleChangeInfo: Invalid Sprite %d specified, ignoring", orig_spriteid);
1724  avi->image_index = 0;
1725  }
1726  break;
1727  }
1728 
1729  case 0x09: // Helicopter
1730  if (buf->ReadByte() == 0) {
1731  avi->subtype = AIR_HELI;
1732  } else {
1733  SB(avi->subtype, 0, 1, 1); // AIR_CTOL
1734  }
1735  break;
1736 
1737  case 0x0A: // Large
1738  SB(avi->subtype, 1, 1, (buf->ReadByte() != 0 ? 1 : 0)); // AIR_FAST
1739  break;
1740 
1741  case PROP_AIRCRAFT_COST_FACTOR: // 0x0B Cost factor
1742  avi->cost_factor = buf->ReadByte();
1743  break;
1744 
1745  case PROP_AIRCRAFT_SPEED: // 0x0C Speed (1 unit is 8 mph, we translate to 1 unit is 1 km-ish/h)
1746  avi->max_speed = (buf->ReadByte() * 128) / 10;
1747  break;
1748 
1749  case 0x0D: // Acceleration
1750  avi->acceleration = buf->ReadByte();
1751  break;
1752 
1753  case PROP_AIRCRAFT_RUNNING_COST_FACTOR: // 0x0E Running cost factor
1754  avi->running_cost = buf->ReadByte();
1755  break;
1756 
1757  case PROP_AIRCRAFT_PASSENGER_CAPACITY: // 0x0F Passenger capacity
1758  avi->passenger_capacity = buf->ReadWord();
1759  break;
1760 
1761  case PROP_AIRCRAFT_MAIL_CAPACITY: // 0x11 Mail capacity
1762  avi->mail_capacity = buf->ReadByte();
1763  break;
1764 
1765  case 0x12: // SFX
1766  avi->sfx = GetNewGRFSoundID(_cur.grffile, buf->ReadByte());
1767  break;
1768 
1769  case 0x13: { // Cargoes available for refitting
1770  uint32 mask = buf->ReadDWord();
1771  _gted[e->index].UpdateRefittability(mask != 0);
1772  ei->refit_mask = TranslateRefitMask(mask);
1773  _gted[e->index].defaultcargo_grf = _cur.grffile;
1774  break;
1775  }
1776 
1777  case 0x14: // Callback mask
1778  ei->callback_mask = buf->ReadByte();
1779  break;
1780 
1781  case 0x15: // Refit cost
1782  ei->refit_cost = buf->ReadByte();
1783  break;
1784 
1785  case 0x16: // Retire vehicle early
1786  ei->retire_early = buf->ReadByte();
1787  break;
1788 
1789  case 0x17: // Miscellaneous flags
1790  ei->misc_flags = buf->ReadByte();
1791  _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
1792  break;
1793 
1794  case 0x18: // Cargo classes allowed
1795  _gted[e->index].cargo_allowed = buf->ReadWord();
1796  _gted[e->index].UpdateRefittability(_gted[e->index].cargo_allowed != 0);
1797  _gted[e->index].defaultcargo_grf = _cur.grffile;
1798  break;
1799 
1800  case 0x19: // Cargo classes disallowed
1801  _gted[e->index].cargo_disallowed = buf->ReadWord();
1802  _gted[e->index].UpdateRefittability(false);
1803  break;
1804 
1805  case 0x1A: // Long format introduction date (days since year 0)
1806  ei->base_intro = buf->ReadDWord();
1807  break;
1808 
1809  case 0x1B: // Alter purchase list sort order
1810  AlterVehicleListOrder(e->index, buf->ReadExtendedByte());
1811  break;
1812 
1813  case PROP_AIRCRAFT_CARGO_AGE_PERIOD: // 0x1C Cargo aging period
1814  ei->cargo_age_period = buf->ReadWord();
1815  break;
1816 
1817  case 0x1D: // CTT refit include list
1818  case 0x1E: { // CTT refit exclude list
1819  uint8 count = buf->ReadByte();
1820  _gted[e->index].UpdateRefittability(prop == 0x1D && count != 0);
1821  if (prop == 0x1D) _gted[e->index].defaultcargo_grf = _cur.grffile;
1822  uint32 &ctt = prop == 0x1D ? _gted[e->index].ctt_include_mask : _gted[e->index].ctt_exclude_mask;
1823  ctt = 0;
1824  while (count--) {
1825  CargoID ctype = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
1826  if (ctype == CT_INVALID) continue;
1827  SetBit(ctt, ctype);
1828  }
1829  break;
1830  }
1831 
1832  case PROP_AIRCRAFT_RANGE: // 0x1F Max aircraft range
1833  avi->max_range = buf->ReadWord();
1834  break;
1835 
1836  default:
1837  ret = CommonVehicleChangeInfo(ei, prop, buf);
1838  break;
1839  }
1840  }
1841 
1842  return ret;
1843 }
1844 
1853 static ChangeInfoResult StationChangeInfo(uint stid, int numinfo, int prop, ByteReader *buf)
1854 {
1856 
1857  if (stid + numinfo > NUM_STATIONS_PER_GRF) {
1858  grfmsg(1, "StationChangeInfo: Station %u is invalid, max %u, ignoring", stid + numinfo, NUM_STATIONS_PER_GRF);
1859  return CIR_INVALID_ID;
1860  }
1861 
1862  /* Allocate station specs if necessary */
1863  if (_cur.grffile->stations == NULL) _cur.grffile->stations = CallocT<StationSpec*>(NUM_STATIONS_PER_GRF);
1864 
1865  for (int i = 0; i < numinfo; i++) {
1866  StationSpec *statspec = _cur.grffile->stations[stid + i];
1867 
1868  /* Check that the station we are modifying is defined. */
1869  if (statspec == NULL && prop != 0x08) {
1870  grfmsg(2, "StationChangeInfo: Attempt to modify undefined station %u, ignoring", stid + i);
1871  return CIR_INVALID_ID;
1872  }
1873 
1874  switch (prop) {
1875  case 0x08: { // Class ID
1876  StationSpec **spec = &_cur.grffile->stations[stid + i];
1877 
1878  /* Property 0x08 is special; it is where the station is allocated */
1879  if (*spec == NULL) *spec = CallocT<StationSpec>(1);
1880 
1881  /* Swap classid because we read it in BE meaning WAYP or DFLT */
1882  uint32 classid = buf->ReadDWord();
1883  (*spec)->cls_id = StationClass::Allocate(BSWAP32(classid));
1884  break;
1885  }
1886 
1887  case 0x09: // Define sprite layout
1888  statspec->tiles = buf->ReadExtendedByte();
1889  delete[] statspec->renderdata; // delete earlier loaded stuff
1890  statspec->renderdata = new NewGRFSpriteLayout[statspec->tiles];
1891 
1892  for (uint t = 0; t < statspec->tiles; t++) {
1893  NewGRFSpriteLayout *dts = &statspec->renderdata[t];
1894  dts->consistent_max_offset = UINT16_MAX; // Spritesets are unknown, so no limit.
1895 
1896  if (buf->HasData(4) && *(uint32*)buf->Data() == 0) {
1897  buf->Skip(4);
1898  extern const DrawTileSprites _station_display_datas_rail[8];
1899  dts->Clone(&_station_display_datas_rail[t % 8]);
1900  continue;
1901  }
1902 
1903  ReadSpriteLayoutSprite(buf, false, false, false, GSF_STATIONS, &dts->ground);
1904  /* On error, bail out immediately. Temporary GRF data was already freed */
1905  if (_cur.skip_sprites < 0) return CIR_DISABLED;
1906 
1907  static SmallVector<DrawTileSeqStruct, 8> tmp_layout;
1908  tmp_layout.Clear();
1909  for (;;) {
1910  /* no relative bounding box support */
1911  DrawTileSeqStruct *dtss = tmp_layout.Append();
1912  MemSetT(dtss, 0);
1913 
1914  dtss->delta_x = buf->ReadByte();
1915  if (dtss->IsTerminator()) break;
1916  dtss->delta_y = buf->ReadByte();
1917  dtss->delta_z = buf->ReadByte();
1918  dtss->size_x = buf->ReadByte();
1919  dtss->size_y = buf->ReadByte();
1920  dtss->size_z = buf->ReadByte();
1921 
1922  ReadSpriteLayoutSprite(buf, false, true, false, GSF_STATIONS, &dtss->image);
1923  /* On error, bail out immediately. Temporary GRF data was already freed */
1924  if (_cur.skip_sprites < 0) return CIR_DISABLED;
1925  }
1926  dts->Clone(tmp_layout.Begin());
1927  }
1928  break;
1929 
1930  case 0x0A: { // Copy sprite layout
1931  byte srcid = buf->ReadByte();
1932  const StationSpec *srcstatspec = _cur.grffile->stations[srcid];
1933 
1934  if (srcstatspec == NULL) {
1935  grfmsg(1, "StationChangeInfo: Station %u is not defined, cannot copy sprite layout to %u.", srcid, stid + i);
1936  continue;
1937  }
1938 
1939  delete[] statspec->renderdata; // delete earlier loaded stuff
1940 
1941  statspec->tiles = srcstatspec->tiles;
1942  statspec->renderdata = new NewGRFSpriteLayout[statspec->tiles];
1943  for (uint t = 0; t < statspec->tiles; t++) {
1944  statspec->renderdata[t].Clone(&srcstatspec->renderdata[t]);
1945  }
1946  break;
1947  }
1948 
1949  case 0x0B: // Callback mask
1950  statspec->callback_mask = buf->ReadByte();
1951  break;
1952 
1953  case 0x0C: // Disallowed number of platforms
1954  statspec->disallowed_platforms = buf->ReadByte();
1955  break;
1956 
1957  case 0x0D: // Disallowed platform lengths
1958  statspec->disallowed_lengths = buf->ReadByte();
1959  break;
1960 
1961  case 0x0E: // Define custom layout
1962  statspec->copied_layouts = false;
1963 
1964  while (buf->HasData()) {
1965  byte length = buf->ReadByte();
1966  byte number = buf->ReadByte();
1967  StationLayout layout;
1968  uint l, p;
1969 
1970  if (length == 0 || number == 0) break;
1971 
1972  if (length > statspec->lengths) {
1973  statspec->platforms = ReallocT(statspec->platforms, length);
1974  memset(statspec->platforms + statspec->lengths, 0, length - statspec->lengths);
1975 
1976  statspec->layouts = ReallocT(statspec->layouts, length);
1977  memset(statspec->layouts + statspec->lengths, 0,
1978  (length - statspec->lengths) * sizeof(*statspec->layouts));
1979 
1980  statspec->lengths = length;
1981  }
1982  l = length - 1; // index is zero-based
1983 
1984  if (number > statspec->platforms[l]) {
1985  statspec->layouts[l] = ReallocT(statspec->layouts[l], number);
1986  /* We expect NULL being 0 here, but C99 guarantees that. */
1987  memset(statspec->layouts[l] + statspec->platforms[l], 0,
1988  (number - statspec->platforms[l]) * sizeof(**statspec->layouts));
1989 
1990  statspec->platforms[l] = number;
1991  }
1992 
1993  p = 0;
1994  layout = MallocT<byte>(length * number);
1995  try {
1996  for (l = 0; l < length; l++) {
1997  for (p = 0; p < number; p++) {
1998  layout[l * number + p] = buf->ReadByte();
1999  }
2000  }
2001  } catch (...) {
2002  free(layout);
2003  throw;
2004  }
2005 
2006  l--;
2007  p--;
2008  free(statspec->layouts[l][p]);
2009  statspec->layouts[l][p] = layout;
2010  }
2011  break;
2012 
2013  case 0x0F: { // Copy custom layout
2014  byte srcid = buf->ReadByte();
2015  const StationSpec *srcstatspec = _cur.grffile->stations[srcid];
2016 
2017  if (srcstatspec == NULL) {
2018  grfmsg(1, "StationChangeInfo: Station %u is not defined, cannot copy tile layout to %u.", srcid, stid + i);
2019  continue;
2020  }
2021 
2022  statspec->lengths = srcstatspec->lengths;
2023  statspec->platforms = srcstatspec->platforms;
2024  statspec->layouts = srcstatspec->layouts;
2025  statspec->copied_layouts = true;
2026  break;
2027  }
2028 
2029  case 0x10: // Little/lots cargo threshold
2030  statspec->cargo_threshold = buf->ReadWord();
2031  break;
2032 
2033  case 0x11: // Pylon placement
2034  statspec->pylons = buf->ReadByte();
2035  break;
2036 
2037  case 0x12: // Cargo types for random triggers
2038  statspec->cargo_triggers = buf->ReadDWord();
2039  if (_cur.grffile->grf_version >= 7) {
2040  statspec->cargo_triggers = TranslateRefitMask(statspec->cargo_triggers);
2041  }
2042  break;
2043 
2044  case 0x13: // General flags
2045  statspec->flags = buf->ReadByte();
2046  break;
2047 
2048  case 0x14: // Overhead wire placement
2049  statspec->wires = buf->ReadByte();
2050  break;
2051 
2052  case 0x15: // Blocked tiles
2053  statspec->blocked = buf->ReadByte();
2054  break;
2055 
2056  case 0x16: // Animation info
2057  statspec->animation.frames = buf->ReadByte();
2058  statspec->animation.status = buf->ReadByte();
2059  break;
2060 
2061  case 0x17: // Animation speed
2062  statspec->animation.speed = buf->ReadByte();
2063  break;
2064 
2065  case 0x18: // Animation triggers
2066  statspec->animation.triggers = buf->ReadWord();
2067  break;
2068 
2069  case 0x1A: // Advanced sprite layout
2070  statspec->tiles = buf->ReadExtendedByte();
2071  delete[] statspec->renderdata; // delete earlier loaded stuff
2072  statspec->renderdata = new NewGRFSpriteLayout[statspec->tiles];
2073 
2074  for (uint t = 0; t < statspec->tiles; t++) {
2075  NewGRFSpriteLayout *dts = &statspec->renderdata[t];
2076  uint num_building_sprites = buf->ReadByte();
2077  /* On error, bail out immediately. Temporary GRF data was already freed */
2078  if (ReadSpriteLayout(buf, num_building_sprites, false, GSF_STATIONS, true, false, dts)) return CIR_DISABLED;
2079  }
2080  break;
2081 
2082  default:
2083  ret = CIR_UNKNOWN;
2084  break;
2085  }
2086  }
2087 
2088  return ret;
2089 }
2090 
2099 static ChangeInfoResult CanalChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
2100 {
2102 
2103  if (id + numinfo > CF_END) {
2104  grfmsg(1, "CanalChangeInfo: Canal feature %u is invalid, max %u, ignoring", id + numinfo, CF_END);
2105  return CIR_INVALID_ID;
2106  }
2107 
2108  for (int i = 0; i < numinfo; i++) {
2109  CanalProperties *cp = &_cur.grffile->canal_local_properties[id + i];
2110 
2111  switch (prop) {
2112  case 0x08:
2113  cp->callback_mask = buf->ReadByte();
2114  break;
2115 
2116  case 0x09:
2117  cp->flags = buf->ReadByte();
2118  break;
2119 
2120  default:
2121  ret = CIR_UNKNOWN;
2122  break;
2123  }
2124  }
2125 
2126  return ret;
2127 }
2128 
2137 static ChangeInfoResult BridgeChangeInfo(uint brid, int numinfo, int prop, ByteReader *buf)
2138 {
2140 
2141  if (brid + numinfo > MAX_BRIDGES) {
2142  grfmsg(1, "BridgeChangeInfo: Bridge %u is invalid, max %u, ignoring", brid + numinfo, MAX_BRIDGES);
2143  return CIR_INVALID_ID;
2144  }
2145 
2146  for (int i = 0; i < numinfo; i++) {
2147  BridgeSpec *bridge = &_bridge[brid + i];
2148 
2149  switch (prop) {
2150  case 0x08: { // Year of availability
2151  /* We treat '0' as always available */
2152  byte year = buf->ReadByte();
2153  bridge->avail_year = (year > 0 ? ORIGINAL_BASE_YEAR + year : 0);
2154  break;
2155  }
2156 
2157  case 0x09: // Minimum length
2158  bridge->min_length = buf->ReadByte();
2159  break;
2160 
2161  case 0x0A: // Maximum length
2162  bridge->max_length = buf->ReadByte();
2163  if (bridge->max_length > 16) bridge->max_length = 0xFFFF;
2164  break;
2165 
2166  case 0x0B: // Cost factor
2167  bridge->price = buf->ReadByte();
2168  break;
2169 
2170  case 0x0C: // Maximum speed
2171  bridge->speed = buf->ReadWord();
2172  break;
2173 
2174  case 0x0D: { // Bridge sprite tables
2175  byte tableid = buf->ReadByte();
2176  byte numtables = buf->ReadByte();
2177 
2178  if (bridge->sprite_table == NULL) {
2179  /* Allocate memory for sprite table pointers and zero out */
2180  bridge->sprite_table = CallocT<PalSpriteID*>(7);
2181  }
2182 
2183  for (; numtables-- != 0; tableid++) {
2184  if (tableid >= 7) { // skip invalid data
2185  grfmsg(1, "BridgeChangeInfo: Table %d >= 7, skipping", tableid);
2186  for (byte sprite = 0; sprite < 32; sprite++) buf->ReadDWord();
2187  continue;
2188  }
2189 
2190  if (bridge->sprite_table[tableid] == NULL) {
2191  bridge->sprite_table[tableid] = MallocT<PalSpriteID>(32);
2192  }
2193 
2194  for (byte sprite = 0; sprite < 32; sprite++) {
2195  SpriteID image = buf->ReadWord();
2196  PaletteID pal = buf->ReadWord();
2197 
2198  bridge->sprite_table[tableid][sprite].sprite = image;
2199  bridge->sprite_table[tableid][sprite].pal = pal;
2200 
2201  MapSpriteMappingRecolour(&bridge->sprite_table[tableid][sprite]);
2202  }
2203  }
2204  break;
2205  }
2206 
2207  case 0x0E: // Flags; bit 0 - disable far pillars
2208  bridge->flags = buf->ReadByte();
2209  break;
2210 
2211  case 0x0F: // Long format year of availability (year since year 0)
2212  bridge->avail_year = Clamp(buf->ReadDWord(), MIN_YEAR, MAX_YEAR);
2213  break;
2214 
2215  case 0x10: { // purchase string
2216  StringID newone = GetGRFStringID(_cur.grffile->grfid, buf->ReadWord());
2217  if (newone != STR_UNDEFINED) bridge->material = newone;
2218  break;
2219  }
2220 
2221  case 0x11: // description of bridge with rails or roads
2222  case 0x12: {
2223  StringID newone = GetGRFStringID(_cur.grffile->grfid, buf->ReadWord());
2224  if (newone != STR_UNDEFINED) bridge->transport_name[prop - 0x11] = newone;
2225  break;
2226  }
2227 
2228  case 0x13: // 16 bits cost multiplier
2229  bridge->price = buf->ReadWord();
2230  break;
2231 
2232  default:
2233  ret = CIR_UNKNOWN;
2234  break;
2235  }
2236  }
2237 
2238  return ret;
2239 }
2240 
2248 {
2250 
2251  switch (prop) {
2252  case 0x09:
2253  case 0x0B:
2254  case 0x0C:
2255  case 0x0D:
2256  case 0x0E:
2257  case 0x0F:
2258  case 0x11:
2259  case 0x14:
2260  case 0x15:
2261  case 0x16:
2262  case 0x18:
2263  case 0x19:
2264  case 0x1A:
2265  case 0x1B:
2266  case 0x1C:
2267  case 0x1D:
2268  case 0x1F:
2269  buf->ReadByte();
2270  break;
2271 
2272  case 0x0A:
2273  case 0x10:
2274  case 0x12:
2275  case 0x13:
2276  case 0x21:
2277  case 0x22:
2278  buf->ReadWord();
2279  break;
2280 
2281  case 0x1E:
2282  buf->ReadDWord();
2283  break;
2284 
2285  case 0x17:
2286  for (uint j = 0; j < 4; j++) buf->ReadByte();
2287  break;
2288 
2289  case 0x20: {
2290  byte count = buf->ReadByte();
2291  for (byte j = 0; j < count; j++) buf->ReadByte();
2292  break;
2293  }
2294 
2295  default:
2296  ret = CIR_UNKNOWN;
2297  break;
2298  }
2299  return ret;
2300 }
2301 
2310 static ChangeInfoResult TownHouseChangeInfo(uint hid, int numinfo, int prop, ByteReader *buf)
2311 {
2313 
2314  if (hid + numinfo > NUM_HOUSES_PER_GRF) {
2315  grfmsg(1, "TownHouseChangeInfo: Too many houses loaded (%u), max (%u). Ignoring.", hid + numinfo, NUM_HOUSES_PER_GRF);
2316  return CIR_INVALID_ID;
2317  }
2318 
2319  /* Allocate house specs if they haven't been allocated already. */
2320  if (_cur.grffile->housespec == NULL) {
2321  _cur.grffile->housespec = CallocT<HouseSpec*>(NUM_HOUSES_PER_GRF);
2322  }
2323 
2324  for (int i = 0; i < numinfo; i++) {
2325  HouseSpec *housespec = _cur.grffile->housespec[hid + i];
2326 
2327  if (prop != 0x08 && housespec == NULL) {
2328  /* If the house property 08 is not yet set, ignore this property */
2329  ChangeInfoResult cir = IgnoreTownHouseProperty(prop, buf);
2330  if (cir > ret) ret = cir;
2331  continue;
2332  }
2333 
2334  switch (prop) {
2335  case 0x08: { // Substitute building type, and definition of a new house
2336  HouseSpec **house = &_cur.grffile->housespec[hid + i];
2337  byte subs_id = buf->ReadByte();
2338 
2339  if (subs_id == 0xFF) {
2340  /* Instead of defining a new house, a substitute house id
2341  * of 0xFF disables the old house with the current id. */
2342  HouseSpec::Get(hid + i)->enabled = false;
2343  continue;
2344  } else if (subs_id >= NEW_HOUSE_OFFSET) {
2345  /* The substitute id must be one of the original houses. */
2346  grfmsg(2, "TownHouseChangeInfo: Attempt to use new house %u as substitute house for %u. Ignoring.", subs_id, hid + i);
2347  continue;
2348  }
2349 
2350  /* Allocate space for this house. */
2351  if (*house == NULL) *house = CallocT<HouseSpec>(1);
2352 
2353  housespec = *house;
2354 
2355  MemCpyT(housespec, HouseSpec::Get(subs_id));
2356 
2357  housespec->enabled = true;
2358  housespec->grf_prop.local_id = hid + i;
2359  housespec->grf_prop.subst_id = subs_id;
2360  housespec->grf_prop.grffile = _cur.grffile;
2361  housespec->random_colour[0] = 0x04; // those 4 random colours are the base colour
2362  housespec->random_colour[1] = 0x08; // for all new houses
2363  housespec->random_colour[2] = 0x0C; // they stand for red, blue, orange and green
2364  housespec->random_colour[3] = 0x06;
2365 
2366  /* Make sure that the third cargo type is valid in this
2367  * climate. This can cause problems when copying the properties
2368  * of a house that accepts food, where the new house is valid
2369  * in the temperate climate. */
2370  if (!CargoSpec::Get(housespec->accepts_cargo[2])->IsValid()) {
2371  housespec->cargo_acceptance[2] = 0;
2372  }
2373 
2374  _loaded_newgrf_features.has_newhouses = true;
2375  break;
2376  }
2377 
2378  case 0x09: // Building flags
2379  housespec->building_flags = (BuildingFlags)buf->ReadByte();
2380  break;
2381 
2382  case 0x0A: { // Availability years
2383  uint16 years = buf->ReadWord();
2384  housespec->min_year = GB(years, 0, 8) > 150 ? MAX_YEAR : ORIGINAL_BASE_YEAR + GB(years, 0, 8);
2385  housespec->max_year = GB(years, 8, 8) > 150 ? MAX_YEAR : ORIGINAL_BASE_YEAR + GB(years, 8, 8);
2386  break;
2387  }
2388 
2389  case 0x0B: // Population
2390  housespec->population = buf->ReadByte();
2391  break;
2392 
2393  case 0x0C: // Mail generation multiplier
2394  housespec->mail_generation = buf->ReadByte();
2395  break;
2396 
2397  case 0x0D: // Passenger acceptance
2398  case 0x0E: // Mail acceptance
2399  housespec->cargo_acceptance[prop - 0x0D] = buf->ReadByte();
2400  break;
2401 
2402  case 0x0F: { // Goods/candy, food/fizzy drinks acceptance
2403  int8 goods = buf->ReadByte();
2404 
2405  /* If value of goods is negative, it means in fact food or, if in toyland, fizzy_drink acceptance.
2406  * Else, we have "standard" 3rd cargo type, goods or candy, for toyland once more */
2407  CargoID cid = (goods >= 0) ? ((_settings_game.game_creation.landscape == LT_TOYLAND) ? CT_CANDY : CT_GOODS) :
2408  ((_settings_game.game_creation.landscape == LT_TOYLAND) ? CT_FIZZY_DRINKS : CT_FOOD);
2409 
2410  /* Make sure the cargo type is valid in this climate. */
2411  if (!CargoSpec::Get(cid)->IsValid()) goods = 0;
2412 
2413  housespec->accepts_cargo[2] = cid;
2414  housespec->cargo_acceptance[2] = abs(goods); // but we do need positive value here
2415  break;
2416  }
2417 
2418  case 0x10: // Local authority rating decrease on removal
2419  housespec->remove_rating_decrease = buf->ReadWord();
2420  break;
2421 
2422  case 0x11: // Removal cost multiplier
2423  housespec->removal_cost = buf->ReadByte();
2424  break;
2425 
2426  case 0x12: // Building name ID
2427  AddStringForMapping(buf->ReadWord(), &housespec->building_name);
2428  break;
2429 
2430  case 0x13: // Building availability mask
2431  housespec->building_availability = (HouseZones)buf->ReadWord();
2432  break;
2433 
2434  case 0x14: // House callback mask
2435  housespec->callback_mask |= buf->ReadByte();
2436  break;
2437 
2438  case 0x15: { // House override byte
2439  byte override = buf->ReadByte();
2440 
2441  /* The house being overridden must be an original house. */
2442  if (override >= NEW_HOUSE_OFFSET) {
2443  grfmsg(2, "TownHouseChangeInfo: Attempt to override new house %u with house id %u. Ignoring.", override, hid + i);
2444  continue;
2445  }
2446 
2447  _house_mngr.Add(hid + i, _cur.grffile->grfid, override);
2448  break;
2449  }
2450 
2451  case 0x16: // Periodic refresh multiplier
2452  housespec->processing_time = min(buf->ReadByte(), 63);
2453  break;
2454 
2455  case 0x17: // Four random colours to use
2456  for (uint j = 0; j < 4; j++) housespec->random_colour[j] = buf->ReadByte();
2457  break;
2458 
2459  case 0x18: // Relative probability of appearing
2460  housespec->probability = buf->ReadByte();
2461  break;
2462 
2463  case 0x19: // Extra flags
2464  housespec->extra_flags = (HouseExtraFlags)buf->ReadByte();
2465  break;
2466 
2467  case 0x1A: // Animation frames
2468  housespec->animation.frames = buf->ReadByte();
2469  housespec->animation.status = GB(housespec->animation.frames, 7, 1);
2470  SB(housespec->animation.frames, 7, 1, 0);
2471  break;
2472 
2473  case 0x1B: // Animation speed
2474  housespec->animation.speed = Clamp(buf->ReadByte(), 2, 16);
2475  break;
2476 
2477  case 0x1C: // Class of the building type
2478  housespec->class_id = AllocateHouseClassID(buf->ReadByte(), _cur.grffile->grfid);
2479  break;
2480 
2481  case 0x1D: // Callback mask part 2
2482  housespec->callback_mask |= (buf->ReadByte() << 8);
2483  break;
2484 
2485  case 0x1E: { // Accepted cargo types
2486  uint32 cargotypes = buf->ReadDWord();
2487 
2488  /* Check if the cargo types should not be changed */
2489  if (cargotypes == 0xFFFFFFFF) break;
2490 
2491  for (uint j = 0; j < 3; j++) {
2492  /* Get the cargo number from the 'list' */
2493  uint8 cargo_part = GB(cargotypes, 8 * j, 8);
2494  CargoID cargo = GetCargoTranslation(cargo_part, _cur.grffile);
2495 
2496  if (cargo == CT_INVALID) {
2497  /* Disable acceptance of invalid cargo type */
2498  housespec->cargo_acceptance[j] = 0;
2499  } else {
2500  housespec->accepts_cargo[j] = cargo;
2501  }
2502  }
2503  break;
2504  }
2505 
2506  case 0x1F: // Minimum life span
2507  housespec->minimum_life = buf->ReadByte();
2508  break;
2509 
2510  case 0x20: { // Cargo acceptance watch list
2511  byte count = buf->ReadByte();
2512  for (byte j = 0; j < count; j++) {
2513  CargoID cargo = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
2514  if (cargo != CT_INVALID) SetBit(housespec->watched_cargoes, cargo);
2515  }
2516  break;
2517  }
2518 
2519  case 0x21: // long introduction year
2520  housespec->min_year = buf->ReadWord();
2521  break;
2522 
2523  case 0x22: // long maximum year
2524  housespec->max_year = buf->ReadWord();
2525  break;
2526 
2527  default:
2528  ret = CIR_UNKNOWN;
2529  break;
2530  }
2531  }
2532 
2533  return ret;
2534 }
2535 
2542 /* static */ const LanguageMap *LanguageMap::GetLanguageMap(uint32 grfid, uint8 language_id)
2543 {
2544  /* LanguageID "MAX_LANG", i.e. 7F is any. This language can't have a gender/case mapping, but has to be handled gracefully. */
2545  const GRFFile *grffile = GetFileByGRFID(grfid);
2546  return (grffile != NULL && grffile->language_map != NULL && language_id < MAX_LANG) ? &grffile->language_map[language_id] : NULL;
2547 }
2548 
2558 template <typename T>
2559 static ChangeInfoResult LoadTranslationTable(uint gvid, int numinfo, ByteReader *buf, T &translation_table, const char *name)
2560 {
2561  if (gvid != 0) {
2562  grfmsg(1, "LoadTranslationTable: %s translation table must start at zero", name);
2563  return CIR_INVALID_ID;
2564  }
2565 
2566  translation_table.Clear();
2567  for (int i = 0; i < numinfo; i++) {
2568  uint32 item = buf->ReadDWord();
2569  *translation_table.Append() = BSWAP32(item);
2570  }
2571 
2572  return CIR_SUCCESS;
2573 }
2574 
2583 static ChangeInfoResult GlobalVarChangeInfo(uint gvid, int numinfo, int prop, ByteReader *buf)
2584 {
2585  /* Properties which are handled as a whole */
2586  switch (prop) {
2587  case 0x09: // Cargo Translation Table; loading during both reservation and activation stage (in case it is selected depending on defined cargos)
2588  return LoadTranslationTable(gvid, numinfo, buf, _cur.grffile->cargo_list, "Cargo");
2589 
2590  case 0x12: // Rail type translation table; loading during both reservation and activation stage (in case it is selected depending on defined railtypes)
2591  return LoadTranslationTable(gvid, numinfo, buf, _cur.grffile->railtype_list, "Rail type");
2592 
2593  default:
2594  break;
2595  }
2596 
2597  /* Properties which are handled per item */
2599  for (int i = 0; i < numinfo; i++) {
2600  switch (prop) {
2601  case 0x08: { // Cost base factor
2602  int factor = buf->ReadByte();
2603  uint price = gvid + i;
2604 
2605  if (price < PR_END) {
2606  _cur.grffile->price_base_multipliers[price] = min<int>(factor - 8, MAX_PRICE_MODIFIER);
2607  } else {
2608  grfmsg(1, "GlobalVarChangeInfo: Price %d out of range, ignoring", price);
2609  }
2610  break;
2611  }
2612 
2613  case 0x0A: { // Currency display names
2614  uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
2615  StringID newone = GetGRFStringID(_cur.grffile->grfid, buf->ReadWord());
2616 
2617  if ((newone != STR_UNDEFINED) && (curidx < CURRENCY_END)) {
2618  _currency_specs[curidx].name = newone;
2619  }
2620  break;
2621  }
2622 
2623  case 0x0B: { // Currency multipliers
2624  uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
2625  uint32 rate = buf->ReadDWord();
2626 
2627  if (curidx < CURRENCY_END) {
2628  /* TTDPatch uses a multiple of 1000 for its conversion calculations,
2629  * which OTTD does not. For this reason, divide grf value by 1000,
2630  * to be compatible */
2631  _currency_specs[curidx].rate = rate / 1000;
2632  } else {
2633  grfmsg(1, "GlobalVarChangeInfo: Currency multipliers %d out of range, ignoring", curidx);
2634  }
2635  break;
2636  }
2637 
2638  case 0x0C: { // Currency options
2639  uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
2640  uint16 options = buf->ReadWord();
2641 
2642  if (curidx < CURRENCY_END) {
2643  _currency_specs[curidx].separator[0] = GB(options, 0, 8);
2644  _currency_specs[curidx].separator[1] = '\0';
2645  /* By specifying only one bit, we prevent errors,
2646  * since newgrf specs said that only 0 and 1 can be set for symbol_pos */
2647  _currency_specs[curidx].symbol_pos = GB(options, 8, 1);
2648  } else {
2649  grfmsg(1, "GlobalVarChangeInfo: Currency option %d out of range, ignoring", curidx);
2650  }
2651  break;
2652  }
2653 
2654  case 0x0D: { // Currency prefix symbol
2655  uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
2656  uint32 tempfix = buf->ReadDWord();
2657 
2658  if (curidx < CURRENCY_END) {
2659  memcpy(_currency_specs[curidx].prefix, &tempfix, 4);
2660  _currency_specs[curidx].prefix[4] = 0;
2661  } else {
2662  grfmsg(1, "GlobalVarChangeInfo: Currency symbol %d out of range, ignoring", curidx);
2663  }
2664  break;
2665  }
2666 
2667  case 0x0E: { // Currency suffix symbol
2668  uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
2669  uint32 tempfix = buf->ReadDWord();
2670 
2671  if (curidx < CURRENCY_END) {
2672  memcpy(&_currency_specs[curidx].suffix, &tempfix, 4);
2673  _currency_specs[curidx].suffix[4] = 0;
2674  } else {
2675  grfmsg(1, "GlobalVarChangeInfo: Currency symbol %d out of range, ignoring", curidx);
2676  }
2677  break;
2678  }
2679 
2680  case 0x0F: { // Euro introduction dates
2681  uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
2682  Year year_euro = buf->ReadWord();
2683 
2684  if (curidx < CURRENCY_END) {
2685  _currency_specs[curidx].to_euro = year_euro;
2686  } else {
2687  grfmsg(1, "GlobalVarChangeInfo: Euro intro date %d out of range, ignoring", curidx);
2688  }
2689  break;
2690  }
2691 
2692  case 0x10: // Snow line height table
2693  if (numinfo > 1 || IsSnowLineSet()) {
2694  grfmsg(1, "GlobalVarChangeInfo: The snowline can only be set once (%d)", numinfo);
2695  } else if (buf->Remaining() < SNOW_LINE_MONTHS * SNOW_LINE_DAYS) {
2696  grfmsg(1, "GlobalVarChangeInfo: Not enough entries set in the snowline table (" PRINTF_SIZE ")", buf->Remaining());
2697  } else {
2698  byte table[SNOW_LINE_MONTHS][SNOW_LINE_DAYS];
2699 
2700  for (uint i = 0; i < SNOW_LINE_MONTHS; i++) {
2701  for (uint j = 0; j < SNOW_LINE_DAYS; j++) {
2702  table[i][j] = buf->ReadByte();
2703  if (_cur.grffile->grf_version >= 8) {
2704  if (table[i][j] != 0xFF) table[i][j] = table[i][j] * (1 + _settings_game.construction.max_heightlevel) / 256;
2705  } else {
2706  if (table[i][j] >= 128) {
2707  /* no snow */
2708  table[i][j] = 0xFF;
2709  } else {
2710  table[i][j] = table[i][j] * (1 + _settings_game.construction.max_heightlevel) / 128;
2711  }
2712  }
2713  }
2714  }
2715  SetSnowLine(table);
2716  }
2717  break;
2718 
2719  case 0x11: // GRF match for engine allocation
2720  /* This is loaded during the reservation stage, so just skip it here. */
2721  /* Each entry is 8 bytes. */
2722  buf->Skip(8);
2723  break;
2724 
2725  case 0x13: // Gender translation table
2726  case 0x14: // Case translation table
2727  case 0x15: { // Plural form translation
2728  uint curidx = gvid + i; // The current index, i.e. language.
2729  const LanguageMetadata *lang = curidx < MAX_LANG ? GetLanguage(curidx) : NULL;
2730  if (lang == NULL) {
2731  grfmsg(1, "GlobalVarChangeInfo: Language %d is not known, ignoring", curidx);
2732  /* Skip over the data. */
2733  if (prop == 0x15) {
2734  buf->ReadByte();
2735  } else {
2736  while (buf->ReadByte() != 0) {
2737  buf->ReadString();
2738  }
2739  }
2740  break;
2741  }
2742 
2743  if (_cur.grffile->language_map == NULL) _cur.grffile->language_map = new LanguageMap[MAX_LANG];
2744 
2745  if (prop == 0x15) {
2746  uint plural_form = buf->ReadByte();
2747  if (plural_form >= LANGUAGE_MAX_PLURAL) {
2748  grfmsg(1, "GlobalVarChanceInfo: Plural form %d is out of range, ignoring", plural_form);
2749  } else {
2750  _cur.grffile->language_map[curidx].plural_form = plural_form;
2751  }
2752  break;
2753  }
2754 
2755  byte newgrf_id = buf->ReadByte(); // The NewGRF (custom) identifier.
2756  while (newgrf_id != 0) {
2757  const char *name = buf->ReadString(); // The name for the OpenTTD identifier.
2758 
2759  /* We'll just ignore the UTF8 identifier character. This is (fairly)
2760  * safe as OpenTTD's strings gender/cases are usually in ASCII which
2761  * is just a subset of UTF8, or they need the bigger UTF8 characters
2762  * such as Cyrillic. Thus we will simply assume they're all UTF8. */
2763  WChar c;
2764  size_t len = Utf8Decode(&c, name);
2765  if (c == NFO_UTF8_IDENTIFIER) name += len;
2766 
2768  map.newgrf_id = newgrf_id;
2769  if (prop == 0x13) {
2770  map.openttd_id = lang->GetGenderIndex(name);
2771  if (map.openttd_id >= MAX_NUM_GENDERS) {
2772  grfmsg(1, "GlobalVarChangeInfo: Gender name %s is not known, ignoring", name);
2773  } else {
2774  *_cur.grffile->language_map[curidx].gender_map.Append() = map;
2775  }
2776  } else {
2777  map.openttd_id = lang->GetCaseIndex(name);
2778  if (map.openttd_id >= MAX_NUM_CASES) {
2779  grfmsg(1, "GlobalVarChangeInfo: Case name %s is not known, ignoring", name);
2780  } else {
2781  *_cur.grffile->language_map[curidx].case_map.Append() = map;
2782  }
2783  }
2784  newgrf_id = buf->ReadByte();
2785  }
2786  break;
2787  }
2788 
2789  default:
2790  ret = CIR_UNKNOWN;
2791  break;
2792  }
2793  }
2794 
2795  return ret;
2796 }
2797 
2798 static ChangeInfoResult GlobalVarReserveInfo(uint gvid, int numinfo, int prop, ByteReader *buf)
2799 {
2800  /* Properties which are handled as a whole */
2801  switch (prop) {
2802  case 0x09: // Cargo Translation Table; loading during both reservation and activation stage (in case it is selected depending on defined cargos)
2803  return LoadTranslationTable(gvid, numinfo, buf, _cur.grffile->cargo_list, "Cargo");
2804 
2805  case 0x12: // Rail type translation table; loading during both reservation and activation stage (in case it is selected depending on defined railtypes)
2806  return LoadTranslationTable(gvid, numinfo, buf, _cur.grffile->railtype_list, "Rail type");
2807 
2808  default:
2809  break;
2810  }
2811 
2812  /* Properties which are handled per item */
2814  for (int i = 0; i < numinfo; i++) {
2815  switch (prop) {
2816  case 0x08: // Cost base factor
2817  case 0x15: // Plural form translation
2818  buf->ReadByte();
2819  break;
2820 
2821  case 0x0A: // Currency display names
2822  case 0x0C: // Currency options
2823  case 0x0F: // Euro introduction dates
2824  buf->ReadWord();
2825  break;
2826 
2827  case 0x0B: // Currency multipliers
2828  case 0x0D: // Currency prefix symbol
2829  case 0x0E: // Currency suffix symbol
2830  buf->ReadDWord();
2831  break;
2832 
2833  case 0x10: // Snow line height table
2834  buf->Skip(SNOW_LINE_MONTHS * SNOW_LINE_DAYS);
2835  break;
2836 
2837  case 0x11: { // GRF match for engine allocation
2838  uint32 s = buf->ReadDWord();
2839  uint32 t = buf->ReadDWord();
2840  SetNewGRFOverride(s, t);
2841  break;
2842  }
2843 
2844  case 0x13: // Gender translation table
2845  case 0x14: // Case translation table
2846  while (buf->ReadByte() != 0) {
2847  buf->ReadString();
2848  }
2849  break;
2850 
2851  default:
2852  ret = CIR_UNKNOWN;
2853  break;
2854  }
2855  }
2856 
2857  return ret;
2858 }
2859 
2860 
2869 static ChangeInfoResult CargoChangeInfo(uint cid, int numinfo, int prop, ByteReader *buf)
2870 {
2872 
2873  if (cid + numinfo > NUM_CARGO) {
2874  grfmsg(2, "CargoChangeInfo: Cargo type %d out of range (max %d)", cid + numinfo, NUM_CARGO - 1);
2875  return CIR_INVALID_ID;
2876  }
2877 
2878  for (int i = 0; i < numinfo; i++) {
2879  CargoSpec *cs = CargoSpec::Get(cid + i);
2880 
2881  switch (prop) {
2882  case 0x08: // Bit number of cargo
2883  cs->bitnum = buf->ReadByte();
2884  if (cs->IsValid()) {
2885  cs->grffile = _cur.grffile;
2886  SetBit(_cargo_mask, cid + i);
2887  } else {
2888  ClrBit(_cargo_mask, cid + i);
2889  }
2890  break;
2891 
2892  case 0x09: // String ID for cargo type name
2893  AddStringForMapping(buf->ReadWord(), &cs->name);
2894  break;
2895 
2896  case 0x0A: // String for 1 unit of cargo
2897  AddStringForMapping(buf->ReadWord(), &cs->name_single);
2898  break;
2899 
2900  case 0x0B: // String for singular quantity of cargo (e.g. 1 tonne of coal)
2901  case 0x1B: // String for cargo units
2902  /* String for units of cargo. This is different in OpenTTD
2903  * (e.g. tonnes) to TTDPatch (e.g. {COMMA} tonne of coal).
2904  * Property 1B is used to set OpenTTD's behaviour. */
2905  AddStringForMapping(buf->ReadWord(), &cs->units_volume);
2906  break;
2907 
2908  case 0x0C: // String for plural quantity of cargo (e.g. 10 tonnes of coal)
2909  case 0x1C: // String for any amount of cargo
2910  /* Strings for an amount of cargo. This is different in OpenTTD
2911  * (e.g. {WEIGHT} of coal) to TTDPatch (e.g. {COMMA} tonnes of coal).
2912  * Property 1C is used to set OpenTTD's behaviour. */
2913  AddStringForMapping(buf->ReadWord(), &cs->quantifier);
2914  break;
2915 
2916  case 0x0D: // String for two letter cargo abbreviation
2917  AddStringForMapping(buf->ReadWord(), &cs->abbrev);
2918  break;
2919 
2920  case 0x0E: // Sprite ID for cargo icon
2921  cs->sprite = buf->ReadWord();
2922  break;
2923 
2924  case 0x0F: // Weight of one unit of cargo
2925  cs->weight = buf->ReadByte();
2926  break;
2927 
2928  case 0x10: // Used for payment calculation
2929  cs->transit_days[0] = buf->ReadByte();
2930  break;
2931 
2932  case 0x11: // Used for payment calculation
2933  cs->transit_days[1] = buf->ReadByte();
2934  break;
2935 
2936  case 0x12: // Base cargo price
2937  cs->initial_payment = buf->ReadDWord();
2938  break;
2939 
2940  case 0x13: // Colour for station rating bars
2941  cs->rating_colour = buf->ReadByte();
2942  break;
2943 
2944  case 0x14: // Colour for cargo graph
2945  cs->legend_colour = buf->ReadByte();
2946  break;
2947 
2948  case 0x15: // Freight status
2949  cs->is_freight = (buf->ReadByte() != 0);
2950  break;
2951 
2952  case 0x16: // Cargo classes
2953  cs->classes = buf->ReadWord();
2954  break;
2955 
2956  case 0x17: // Cargo label
2957  cs->label = buf->ReadDWord();
2958  cs->label = BSWAP32(cs->label);
2959  break;
2960 
2961  case 0x18: { // Town growth substitute type
2962  uint8 substitute_type = buf->ReadByte();
2963 
2964  switch (substitute_type) {
2965  case 0x00: cs->town_effect = TE_PASSENGERS; break;
2966  case 0x02: cs->town_effect = TE_MAIL; break;
2967  case 0x05: cs->town_effect = TE_GOODS; break;
2968  case 0x09: cs->town_effect = TE_WATER; break;
2969  case 0x0B: cs->town_effect = TE_FOOD; break;
2970  default:
2971  grfmsg(1, "CargoChangeInfo: Unknown town growth substitute value %d, setting to none.", substitute_type);
2972  FALLTHROUGH;
2973  case 0xFF: cs->town_effect = TE_NONE; break;
2974  }
2975  break;
2976  }
2977 
2978  case 0x19: // Town growth coefficient
2979  cs->multipliertowngrowth = buf->ReadWord();
2980  break;
2981 
2982  case 0x1A: // Bitmask of callbacks to use
2983  cs->callback_mask = buf->ReadByte();
2984  break;
2985 
2986  case 0x1D: // Vehicle capacity muliplier
2987  cs->multiplier = max<uint16>(1u, buf->ReadWord());
2988  break;
2989 
2990  default:
2991  ret = CIR_UNKNOWN;
2992  break;
2993  }
2994  }
2995 
2996  return ret;
2997 }
2998 
2999 
3008 static ChangeInfoResult SoundEffectChangeInfo(uint sid, int numinfo, int prop, ByteReader *buf)
3009 {
3011 
3012  if (_cur.grffile->sound_offset == 0) {
3013  grfmsg(1, "SoundEffectChangeInfo: No effects defined, skipping");
3014  return CIR_INVALID_ID;
3015  }
3016 
3017  if (sid + numinfo - ORIGINAL_SAMPLE_COUNT > _cur.grffile->num_sounds) {
3018  grfmsg(1, "SoundEffectChangeInfo: Attempting to change undefined sound effect (%u), max (%u). Ignoring.", sid + numinfo, ORIGINAL_SAMPLE_COUNT + _cur.grffile->num_sounds);
3019  return CIR_INVALID_ID;
3020  }
3021 
3022  for (int i = 0; i < numinfo; i++) {
3023  SoundEntry *sound = GetSound(sid + i + _cur.grffile->sound_offset - ORIGINAL_SAMPLE_COUNT);
3024 
3025  switch (prop) {
3026  case 0x08: // Relative volume
3027  sound->volume = buf->ReadByte();
3028  break;
3029 
3030  case 0x09: // Priority
3031  sound->priority = buf->ReadByte();
3032  break;
3033 
3034  case 0x0A: { // Override old sound
3035  SoundID orig_sound = buf->ReadByte();
3036 
3037  if (orig_sound >= ORIGINAL_SAMPLE_COUNT) {
3038  grfmsg(1, "SoundEffectChangeInfo: Original sound %d not defined (max %d)", orig_sound, ORIGINAL_SAMPLE_COUNT);
3039  } else {
3040  SoundEntry *old_sound = GetSound(orig_sound);
3041 
3042  /* Literally copy the data of the new sound over the original */
3043  *old_sound = *sound;
3044  }
3045  break;
3046  }
3047 
3048  default:
3049  ret = CIR_UNKNOWN;
3050  break;
3051  }
3052  }
3053 
3054  return ret;
3055 }
3056 
3064 {
3066 
3067  switch (prop) {
3068  case 0x09:
3069  case 0x0D:
3070  case 0x0E:
3071  case 0x10:
3072  case 0x11:
3073  case 0x12:
3074  buf->ReadByte();
3075  break;
3076 
3077  case 0x0A:
3078  case 0x0B:
3079  case 0x0C:
3080  case 0x0F:
3081  buf->ReadWord();
3082  break;
3083 
3084  default:
3085  ret = CIR_UNKNOWN;
3086  break;
3087  }
3088  return ret;
3089 }
3090 
3099 static ChangeInfoResult IndustrytilesChangeInfo(uint indtid, int numinfo, int prop, ByteReader *buf)
3100 {
3102 
3103  if (indtid + numinfo > NUM_INDUSTRYTILES_PER_GRF) {
3104  grfmsg(1, "IndustryTilesChangeInfo: Too many industry tiles loaded (%u), max (%u). Ignoring.", indtid + numinfo, NUM_INDUSTRYTILES_PER_GRF);
3105  return CIR_INVALID_ID;
3106  }
3107 
3108  /* Allocate industry tile specs if they haven't been allocated already. */
3109  if (_cur.grffile->indtspec == NULL) {
3110  _cur.grffile->indtspec = CallocT<IndustryTileSpec*>(NUM_INDUSTRYTILES_PER_GRF);
3111  }
3112 
3113  for (int i = 0; i < numinfo; i++) {
3114  IndustryTileSpec *tsp = _cur.grffile->indtspec[indtid + i];
3115 
3116  if (prop != 0x08 && tsp == NULL) {
3118  if (cir > ret) ret = cir;
3119  continue;
3120  }
3121 
3122  switch (prop) {
3123  case 0x08: { // Substitute industry tile type
3124  IndustryTileSpec **tilespec = &_cur.grffile->indtspec[indtid + i];
3125  byte subs_id = buf->ReadByte();
3126 
3127  if (subs_id >= NEW_INDUSTRYTILEOFFSET) {
3128  /* The substitute id must be one of the original industry tile. */
3129  grfmsg(2, "IndustryTilesChangeInfo: Attempt to use new industry tile %u as substitute industry tile for %u. Ignoring.", subs_id, indtid + i);
3130  continue;
3131  }
3132 
3133  /* Allocate space for this industry. */
3134  if (*tilespec == NULL) {
3135  *tilespec = CallocT<IndustryTileSpec>(1);
3136  tsp = *tilespec;
3137 
3138  memcpy(tsp, &_industry_tile_specs[subs_id], sizeof(_industry_tile_specs[subs_id]));
3139  tsp->enabled = true;
3140 
3141  /* A copied tile should not have the animation infos copied too.
3142  * The anim_state should be left untouched, though
3143  * It is up to the author to animate them himself */
3144  tsp->anim_production = INDUSTRYTILE_NOANIM;
3145  tsp->anim_next = INDUSTRYTILE_NOANIM;
3146 
3147  tsp->grf_prop.local_id = indtid + i;
3148  tsp->grf_prop.subst_id = subs_id;
3149  tsp->grf_prop.grffile = _cur.grffile;
3150  _industile_mngr.AddEntityID(indtid + i, _cur.grffile->grfid, subs_id); // pre-reserve the tile slot
3151  }
3152  break;
3153  }
3154 
3155  case 0x09: { // Industry tile override
3156  byte ovrid = buf->ReadByte();
3157 
3158  /* The industry being overridden must be an original industry. */
3159  if (ovrid >= NEW_INDUSTRYTILEOFFSET) {
3160  grfmsg(2, "IndustryTilesChangeInfo: Attempt to override new industry tile %u with industry tile id %u. Ignoring.", ovrid, indtid + i);
3161  continue;
3162  }
3163 
3164  _industile_mngr.Add(indtid + i, _cur.grffile->grfid, ovrid);
3165  break;
3166  }
3167 
3168  case 0x0A: // Tile acceptance
3169  case 0x0B:
3170  case 0x0C: {
3171  uint16 acctp = buf->ReadWord();
3172  tsp->accepts_cargo[prop - 0x0A] = GetCargoTranslation(GB(acctp, 0, 8), _cur.grffile);
3173  tsp->acceptance[prop - 0x0A] = GB(acctp, 8, 8);
3174  break;
3175  }
3176 
3177  case 0x0D: // Land shape flags
3178  tsp->slopes_refused = (Slope)buf->ReadByte();
3179  break;
3180 
3181  case 0x0E: // Callback mask
3182  tsp->callback_mask = buf->ReadByte();
3183  break;
3184 
3185  case 0x0F: // Animation information
3186  tsp->animation.frames = buf->ReadByte();
3187  tsp->animation.status = buf->ReadByte();
3188  break;
3189 
3190  case 0x10: // Animation speed
3191  tsp->animation.speed = buf->ReadByte();
3192  break;
3193 
3194  case 0x11: // Triggers for callback 25
3195  tsp->animation.triggers = buf->ReadByte();
3196  break;
3197 
3198  case 0x12: // Special flags
3199  tsp->special_flags = (IndustryTileSpecialFlags)buf->ReadByte();
3200  break;
3201 
3202  default:
3203  ret = CIR_UNKNOWN;
3204  break;
3205  }
3206  }
3207 
3208  return ret;
3209 }
3210 
3218 {
3220 
3221  switch (prop) {
3222  case 0x09:
3223  case 0x0B:
3224  case 0x0F:
3225  case 0x12:
3226  case 0x13:
3227  case 0x14:
3228  case 0x17:
3229  case 0x18:
3230  case 0x19:
3231  case 0x21:
3232  case 0x22:
3233  buf->ReadByte();
3234  break;
3235 
3236  case 0x0C:
3237  case 0x0D:
3238  case 0x0E:
3239  case 0x10:
3240  case 0x1B:
3241  case 0x1F:
3242  case 0x24:
3243  buf->ReadWord();
3244  break;
3245 
3246  case 0x11:
3247  case 0x1A:
3248  case 0x1C:
3249  case 0x1D:
3250  case 0x1E:
3251  case 0x20:
3252  case 0x23:
3253  buf->ReadDWord();
3254  break;
3255 
3256  case 0x0A: {
3257  byte num_table = buf->ReadByte();
3258  for (byte j = 0; j < num_table; j++) {
3259  for (uint k = 0;; k++) {
3260  byte x = buf->ReadByte();
3261  if (x == 0xFE && k == 0) {
3262  buf->ReadByte();
3263  buf->ReadByte();
3264  break;
3265  }
3266 
3267  byte y = buf->ReadByte();
3268  if (x == 0 && y == 0x80) break;
3269 
3270  byte gfx = buf->ReadByte();
3271  if (gfx == 0xFE) buf->ReadWord();
3272  }
3273  }
3274  break;
3275  }
3276 
3277  case 0x16:
3278  for (byte j = 0; j < 3; j++) buf->ReadByte();
3279  break;
3280 
3281  case 0x15: {
3282  byte number_of_sounds = buf->ReadByte();
3283  for (uint8 j = 0; j < number_of_sounds; j++) {
3284  buf->ReadByte();
3285  }
3286  break;
3287  }
3288 
3289  default:
3290  ret = CIR_UNKNOWN;
3291  break;
3292  }
3293  return ret;
3294 }
3295 
3302 static bool ValidateIndustryLayout(const IndustryTileTable *layout, int size)
3303 {
3304  for (int i = 0; i < size - 1; i++) {
3305  for (int j = i + 1; j < size; j++) {
3306  if (layout[i].ti.x == layout[j].ti.x &&
3307  layout[i].ti.y == layout[j].ti.y) {
3308  return false;
3309  }
3310  }
3311  }
3312  return true;
3313 }
3314 
3317 {
3318  if (HasBit(ind->cleanup_flag, CLEAN_TILELAYOUT) && ind->table != NULL) {
3319  for (int j = 0; j < ind->num_table; j++) {
3320  /* remove the individual layouts */
3321  free(ind->table[j]);
3322  }
3323  /* remove the layouts pointers */
3324  free(ind->table);
3325  ind->table = NULL;
3326  }
3327 }
3328 
3337 static ChangeInfoResult IndustriesChangeInfo(uint indid, int numinfo, int prop, ByteReader *buf)
3338 {
3340 
3341  if (indid + numinfo > NUM_INDUSTRYTYPES_PER_GRF) {
3342  grfmsg(1, "IndustriesChangeInfo: Too many industries loaded (%u), max (%u). Ignoring.", indid + numinfo, NUM_INDUSTRYTYPES_PER_GRF);
3343  return CIR_INVALID_ID;
3344  }
3345 
3346  /* Allocate industry specs if they haven't been allocated already. */
3347  if (_cur.grffile->industryspec == NULL) {
3348  _cur.grffile->industryspec = CallocT<IndustrySpec*>(NUM_INDUSTRYTYPES_PER_GRF);
3349  }
3350 
3351  for (int i = 0; i < numinfo; i++) {
3352  IndustrySpec *indsp = _cur.grffile->industryspec[indid + i];
3353 
3354  if (prop != 0x08 && indsp == NULL) {
3355  ChangeInfoResult cir = IgnoreIndustryProperty(prop, buf);
3356  if (cir > ret) ret = cir;
3357  continue;
3358  }
3359 
3360  switch (prop) {
3361  case 0x08: { // Substitute industry type
3362  IndustrySpec **indspec = &_cur.grffile->industryspec[indid + i];
3363  byte subs_id = buf->ReadByte();
3364 
3365  if (subs_id == 0xFF) {
3366  /* Instead of defining a new industry, a substitute industry id
3367  * of 0xFF disables the old industry with the current id. */
3368  _industry_specs[indid + i].enabled = false;
3369  continue;
3370  } else if (subs_id >= NEW_INDUSTRYOFFSET) {
3371  /* The substitute id must be one of the original industry. */
3372  grfmsg(2, "_industry_specs: Attempt to use new industry %u as substitute industry for %u. Ignoring.", subs_id, indid + i);
3373  continue;
3374  }
3375 
3376  /* Allocate space for this industry.
3377  * Only need to do it once. If ever it is called again, it should not
3378  * do anything */
3379  if (*indspec == NULL) {
3380  *indspec = CallocT<IndustrySpec>(1);
3381  indsp = *indspec;
3382 
3383  memcpy(indsp, &_origin_industry_specs[subs_id], sizeof(_industry_specs[subs_id]));
3384  indsp->enabled = true;
3385  indsp->grf_prop.local_id = indid + i;
3386  indsp->grf_prop.subst_id = subs_id;
3387  indsp->grf_prop.grffile = _cur.grffile;
3388  /* If the grf industry needs to check its surounding upon creation, it should
3389  * rely on callbacks, not on the original placement functions */
3390  indsp->check_proc = CHECK_NOTHING;
3391  }
3392  break;
3393  }
3394 
3395  case 0x09: { // Industry type override
3396  byte ovrid = buf->ReadByte();
3397 
3398  /* The industry being overridden must be an original industry. */
3399  if (ovrid >= NEW_INDUSTRYOFFSET) {
3400  grfmsg(2, "IndustriesChangeInfo: Attempt to override new industry %u with industry id %u. Ignoring.", ovrid, indid + i);
3401  continue;
3402  }
3403  indsp->grf_prop.override = ovrid;
3404  _industry_mngr.Add(indid + i, _cur.grffile->grfid, ovrid);
3405  break;
3406  }
3407 
3408  case 0x0A: { // Set industry layout(s)
3409  byte new_num_layouts = buf->ReadByte(); // Number of layaouts
3410  /* We read the total size in bytes, but we can't rely on the
3411  * newgrf to provide a sane value. First assume the value is
3412  * sane but later on we make sure we enlarge the array if the
3413  * newgrf contains more data. Each tile uses either 3 or 5
3414  * bytes, so to play it safe we assume 3. */
3415  uint32 def_num_tiles = buf->ReadDWord() / 3 + 1;
3416  IndustryTileTable **tile_table = CallocT<IndustryTileTable*>(new_num_layouts); // Table with tiles to compose an industry
3417  IndustryTileTable *itt = CallocT<IndustryTileTable>(def_num_tiles); // Temporary array to read the tile layouts from the GRF
3418  uint size;
3419  const IndustryTileTable *copy_from;
3420 
3421  try {
3422  for (byte j = 0; j < new_num_layouts; j++) {
3423  for (uint k = 0;; k++) {
3424  if (k >= def_num_tiles) {
3425  grfmsg(3, "IndustriesChangeInfo: Incorrect size for industry tile layout definition for industry %u.", indid);
3426  /* Size reported by newgrf was not big enough so enlarge the array. */
3427  def_num_tiles *= 2;
3428  itt = ReallocT<IndustryTileTable>(itt, def_num_tiles);
3429  }
3430 
3431  itt[k].ti.x = buf->ReadByte(); // Offsets from northermost tile
3432 
3433  if (itt[k].ti.x == 0xFE && k == 0) {
3434  /* This means we have to borrow the layout from an old industry */
3435  IndustryType type = buf->ReadByte(); // industry holding required layout
3436  byte laynbr = buf->ReadByte(); // layout number to borrow
3437 
3438  copy_from = _origin_industry_specs[type].table[laynbr];
3439  for (size = 1;; size++) {
3440  if (copy_from[size - 1].ti.x == -0x80 && copy_from[size - 1].ti.y == 0) break;
3441  }
3442  break;
3443  }
3444 
3445  itt[k].ti.y = buf->ReadByte(); // Or table definition finalisation
3446 
3447  if (itt[k].ti.x == 0 && itt[k].ti.y == 0x80) {
3448  /* Not the same terminator. The one we are using is rather
3449  x = -80, y = x . So, adjust it. */
3450  itt[k].ti.x = -0x80;
3451  itt[k].ti.y = 0;
3452  itt[k].gfx = 0;
3453 
3454  size = k + 1;
3455  copy_from = itt;
3456  break;
3457  }
3458 
3459  itt[k].gfx = buf->ReadByte();
3460 
3461  if (itt[k].gfx == 0xFE) {
3462  /* Use a new tile from this GRF */
3463  int local_tile_id = buf->ReadWord();
3464 
3465  /* Read the ID from the _industile_mngr. */
3466  int tempid = _industile_mngr.GetID(local_tile_id, _cur.grffile->grfid);
3467 
3468  if (tempid == INVALID_INDUSTRYTILE) {
3469  grfmsg(2, "IndustriesChangeInfo: Attempt to use industry tile %u with industry id %u, not yet defined. Ignoring.", local_tile_id, indid);
3470  } else {
3471  /* Declared as been valid, can be used */
3472  itt[k].gfx = tempid;
3473  size = k + 1;
3474  copy_from = itt;
3475  }
3476  } else if (itt[k].gfx == 0xFF) {
3477  itt[k].ti.x = (int8)GB(itt[k].ti.x, 0, 8);
3478  itt[k].ti.y = (int8)GB(itt[k].ti.y, 0, 8);
3479 
3480  /* When there were only 256x256 maps, TileIndex was a uint16 and
3481  * itt[k].ti was just a TileIndexDiff that was added to it.
3482  * As such negative "x" values were shifted into the "y" position.
3483  * x = -1, y = 1 -> x = 255, y = 0
3484  * Since GRF version 8 the position is interpreted as pair of independent int8.
3485  * For GRF version < 8 we need to emulate the old shifting behaviour.
3486  */
3487  if (_cur.grffile->grf_version < 8 && itt[k].ti.x < 0) itt[k].ti.y += 1;
3488  }
3489  }
3490 
3491  if (!ValidateIndustryLayout(copy_from, size)) {
3492  /* The industry layout was not valid, so skip this one. */
3493  grfmsg(1, "IndustriesChangeInfo: Invalid industry layout for industry id %u. Ignoring", indid);
3494  new_num_layouts--;
3495  j--;
3496  } else {
3497  tile_table[j] = CallocT<IndustryTileTable>(size);
3498  memcpy(tile_table[j], copy_from, sizeof(*copy_from) * size);
3499  }
3500  }
3501  } catch (...) {
3502  for (int i = 0; i < new_num_layouts; i++) {
3503  free(tile_table[i]);
3504  }
3505  free(tile_table);
3506  free(itt);
3507  throw;
3508  }
3509 
3510  /* Clean the tile table if it was already set by a previous prop A. */
3511  CleanIndustryTileTable(indsp);
3512  /* Install final layout construction in the industry spec */
3513  indsp->num_table = new_num_layouts;
3514  indsp->table = tile_table;
3516  free(itt);
3517  break;
3518  }
3519 
3520  case 0x0B: // Industry production flags
3521  indsp->life_type = (IndustryLifeType)buf->ReadByte();
3522  break;
3523 
3524  case 0x0C: // Industry closure message
3525  AddStringForMapping(buf->ReadWord(), &indsp->closure_text);
3526  break;
3527 
3528  case 0x0D: // Production increase message
3529  AddStringForMapping(buf->ReadWord(), &indsp->production_up_text);
3530  break;
3531 
3532  case 0x0E: // Production decrease message
3533  AddStringForMapping(buf->ReadWord(), &indsp->production_down_text);
3534  break;
3535 
3536  case 0x0F: // Fund cost multiplier
3537  indsp->cost_multiplier = buf->ReadByte();
3538  break;
3539 
3540  case 0x10: // Production cargo types
3541  for (byte j = 0; j < 2; j++) {
3542  indsp->produced_cargo[j] = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
3543  }
3544  break;
3545 
3546  case 0x11: // Acceptance cargo types
3547  for (byte j = 0; j < 3; j++) {
3548  indsp->accepts_cargo[j] = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
3549  }
3550  buf->ReadByte(); // Unnused, eat it up
3551  break;
3552 
3553  case 0x12: // Production multipliers
3554  case 0x13:
3555  indsp->production_rate[prop - 0x12] = buf->ReadByte();
3556  break;
3557 
3558  case 0x14: // Minimal amount of cargo distributed
3559  indsp->minimal_cargo = buf->ReadByte();
3560  break;
3561 
3562  case 0x15: { // Random sound effects
3563  indsp->number_of_sounds = buf->ReadByte();
3564  uint8 *sounds = MallocT<uint8>(indsp->number_of_sounds);
3565 
3566  try {
3567  for (uint8 j = 0; j < indsp->number_of_sounds; j++) {
3568  sounds[j] = buf->ReadByte();
3569  }
3570  } catch (...) {
3571  free(sounds);
3572  throw;
3573  }
3574 
3575  if (HasBit(indsp->cleanup_flag, CLEAN_RANDOMSOUNDS)) {
3576  free(indsp->random_sounds);
3577  }
3578  indsp->random_sounds = sounds;
3580  break;
3581  }
3582 
3583  case 0x16: // Conflicting industry types
3584  for (byte j = 0; j < 3; j++) indsp->conflicting[j] = buf->ReadByte();
3585  break;
3586 
3587  case 0x17: // Probability in random game
3588  indsp->appear_creation[_settings_game.game_creation.landscape] = buf->ReadByte();
3589  break;
3590 
3591  case 0x18: // Probability during gameplay
3592  indsp->appear_ingame[_settings_game.game_creation.landscape] = buf->ReadByte();
3593  break;
3594 
3595  case 0x19: // Map colour
3596  indsp->map_colour = buf->ReadByte();
3597  break;
3598 
3599  case 0x1A: // Special industry flags to define special behavior
3600  indsp->behaviour = (IndustryBehaviour)buf->ReadDWord();
3601  break;
3602 
3603  case 0x1B: // New industry text ID
3604  AddStringForMapping(buf->ReadWord(), &indsp->new_industry_text);
3605  break;
3606 
3607  case 0x1C: // Input cargo multipliers for the three input cargo types
3608  case 0x1D:
3609  case 0x1E: {
3610  uint32 multiples = buf->ReadDWord();
3611  indsp->input_cargo_multiplier[prop - 0x1C][0] = GB(multiples, 0, 16);
3612  indsp->input_cargo_multiplier[prop - 0x1C][1] = GB(multiples, 16, 16);
3613  break;
3614  }
3615 
3616  case 0x1F: // Industry name
3617  AddStringForMapping(buf->ReadWord(), &indsp->name);
3618  break;
3619 
3620  case 0x20: // Prospecting success chance
3621  indsp->prospecting_chance = buf->ReadDWord();
3622  break;
3623 
3624  case 0x21: // Callback mask
3625  case 0x22: { // Callback additional mask
3626  byte aflag = buf->ReadByte();
3627  SB(indsp->callback_mask, (prop - 0x21) * 8, 8, aflag);
3628  break;
3629  }
3630 
3631  case 0x23: // removal cost multiplier
3632  indsp->removal_cost_multiplier = buf->ReadDWord();
3633  break;
3634 
3635  case 0x24: { // name for nearby station
3636  uint16 str = buf->ReadWord();
3637  if (str == 0) {
3638  indsp->station_name = STR_NULL;
3639  } else {
3640  AddStringForMapping(str, &indsp->station_name);
3641  }
3642  break;
3643  }
3644 
3645  default:
3646  ret = CIR_UNKNOWN;
3647  break;
3648  }
3649  }
3650 
3651  return ret;
3652 }
3653 
3660 {
3661  AirportTileTable **table_list = MallocT<AirportTileTable*>(as->num_table);
3662  for (int i = 0; i < as->num_table; i++) {
3663  uint num_tiles = 1;
3664  const AirportTileTable *it = as->table[0];
3665  do {
3666  num_tiles++;
3667  } while ((++it)->ti.x != -0x80);
3668  table_list[i] = MallocT<AirportTileTable>(num_tiles);
3669  MemCpyT(table_list[i], as->table[i], num_tiles);
3670  }
3671  as->table = table_list;
3672  HangarTileTable *depot_table = MallocT<HangarTileTable>(as->nof_depots);
3673  MemCpyT(depot_table, as->depot_table, as->nof_depots);
3674  as->depot_table = depot_table;
3675  Direction *rotation = MallocT<Direction>(as->num_table);
3676  MemCpyT(rotation, as->rotation, as->num_table);
3677  as->rotation = rotation;
3678 }
3679 
3688 static ChangeInfoResult AirportChangeInfo(uint airport, int numinfo, int prop, ByteReader *buf)
3689 {
3691 
3692  if (airport + numinfo > NUM_AIRPORTS_PER_GRF) {
3693  grfmsg(1, "AirportChangeInfo: Too many airports, trying id (%u), max (%u). Ignoring.", airport + numinfo, NUM_AIRPORTS_PER_GRF);
3694  return CIR_INVALID_ID;
3695  }
3696 
3697  /* Allocate industry specs if they haven't been allocated already. */
3698  if (_cur.grffile->airportspec == NULL) {
3699  _cur.grffile->airportspec = CallocT<AirportSpec*>(NUM_AIRPORTS_PER_GRF);
3700  }
3701 
3702  for (int i = 0; i < numinfo; i++) {
3703  AirportSpec *as = _cur.grffile->airportspec[airport + i];
3704 
3705  if (as == NULL && prop != 0x08 && prop != 0x09) {
3706  grfmsg(2, "AirportChangeInfo: Attempt to modify undefined airport %u, ignoring", airport + i);
3707  return CIR_INVALID_ID;
3708  }
3709 
3710  switch (prop) {
3711  case 0x08: { // Modify original airport
3712  byte subs_id = buf->ReadByte();
3713 
3714  if (subs_id == 0xFF) {
3715  /* Instead of defining a new airport, an airport id
3716  * of 0xFF disables the old airport with the current id. */
3717  AirportSpec::GetWithoutOverride(airport + i)->enabled = false;
3718  continue;
3719  } else if (subs_id >= NEW_AIRPORT_OFFSET) {
3720  /* The substitute id must be one of the original airports. */
3721  grfmsg(2, "AirportChangeInfo: Attempt to use new airport %u as substitute airport for %u. Ignoring.", subs_id, airport + i);
3722  continue;
3723  }
3724 
3725  AirportSpec **spec = &_cur.grffile->airportspec[airport + i];
3726  /* Allocate space for this airport.
3727  * Only need to do it once. If ever it is called again, it should not
3728  * do anything */
3729  if (*spec == NULL) {
3730  *spec = MallocT<AirportSpec>(1);
3731  as = *spec;
3732 
3733  memcpy(as, AirportSpec::GetWithoutOverride(subs_id), sizeof(*as));
3734  as->enabled = true;
3735  as->grf_prop.local_id = airport + i;
3736  as->grf_prop.subst_id = subs_id;
3737  as->grf_prop.grffile = _cur.grffile;
3738  /* override the default airport */
3739  _airport_mngr.Add(airport + i, _cur.grffile->grfid, subs_id);
3740  /* Create a copy of the original tiletable so it can be freed later. */
3741  DuplicateTileTable(as);
3742  }
3743  break;
3744  }
3745 
3746  case 0x0A: { // Set airport layout
3747  free(as->rotation);
3748  as->num_table = buf->ReadByte(); // Number of layaouts
3749  as->rotation = MallocT<Direction>(as->num_table);
3750  uint32 defsize = buf->ReadDWord(); // Total size of the definition
3751  AirportTileTable **tile_table = CallocT<AirportTileTable*>(as->num_table); // Table with tiles to compose the airport
3752  AirportTileTable *att = CallocT<AirportTileTable>(defsize); // Temporary array to read the tile layouts from the GRF
3753  int size;
3754  const AirportTileTable *copy_from;
3755  try {
3756  for (byte j = 0; j < as->num_table; j++) {
3757  const_cast<Direction&>(as->rotation[j]) = (Direction)buf->ReadByte();
3758  for (int k = 0;; k++) {
3759  att[k].ti.x = buf->ReadByte(); // Offsets from northermost tile
3760  att[k].ti.y = buf->ReadByte();
3761 
3762  if (att[k].ti.x == 0 && att[k].ti.y == 0x80) {
3763  /* Not the same terminator. The one we are using is rather
3764  * x = -80, y = 0 . So, adjust it. */
3765  att[k].ti.x = -0x80;
3766  att[k].ti.y = 0;
3767  att[k].gfx = 0;
3768 
3769  size = k + 1;
3770  copy_from = att;
3771  break;
3772  }
3773 
3774  att[k].gfx = buf->ReadByte();
3775 
3776  if (att[k].gfx == 0xFE) {
3777  /* Use a new tile from this GRF */
3778  int local_tile_id = buf->ReadWord();
3779 
3780  /* Read the ID from the _airporttile_mngr. */
3781  uint16 tempid = _airporttile_mngr.GetID(local_tile_id, _cur.grffile->grfid);
3782 
3783  if (tempid == INVALID_AIRPORTTILE) {
3784  grfmsg(2, "AirportChangeInfo: Attempt to use airport tile %u with airport id %u, not yet defined. Ignoring.", local_tile_id, airport + i);
3785  } else {
3786  /* Declared as been valid, can be used */
3787  att[k].gfx = tempid;
3788  size = k + 1;
3789  copy_from = att;
3790  }
3791  } else if (att[k].gfx == 0xFF) {
3792  att[k].ti.x = (int8)GB(att[k].ti.x, 0, 8);
3793  att[k].ti.y = (int8)GB(att[k].ti.y, 0, 8);
3794  }
3795 
3796  if (as->rotation[j] == DIR_E || as->rotation[j] == DIR_W) {
3797  as->size_x = max<byte>(as->size_x, att[k].ti.y + 1);
3798  as->size_y = max<byte>(as->size_y, att[k].ti.x + 1);
3799  } else {
3800  as->size_x = max<byte>(as->size_x, att[k].ti.x + 1);
3801  as->size_y = max<byte>(as->size_y, att[k].ti.y + 1);
3802  }
3803  }
3804  tile_table[j] = CallocT<AirportTileTable>(size);
3805  memcpy(tile_table[j], copy_from, sizeof(*copy_from) * size);
3806  }
3807  /* Install final layout construction in the airport spec */
3808  as->table = tile_table;
3809  free(att);
3810  } catch (...) {
3811  for (int i = 0; i < as->num_table; i++) {
3812  free(tile_table[i]);
3813  }
3814  free(tile_table);
3815  free(att);
3816  throw;
3817  }
3818  break;
3819  }
3820 
3821  case 0x0C:
3822  as->min_year = buf->ReadWord();
3823  as->max_year = buf->ReadWord();
3824  if (as->max_year == 0xFFFF) as->max_year = MAX_YEAR;
3825  break;
3826 
3827  case 0x0D:
3828  as->ttd_airport_type = (TTDPAirportType)buf->ReadByte();
3829  break;
3830 
3831  case 0x0E:
3832  as->catchment = Clamp(buf->ReadByte(), 1, MAX_CATCHMENT);
3833  break;
3834 
3835  case 0x0F:
3836  as->noise_level = buf->ReadByte();
3837  break;
3838 
3839  case 0x10:
3840  AddStringForMapping(buf->ReadWord(), &as->name);
3841  break;
3842 
3843  case 0x11: // Maintenance cost factor
3844  as->maintenance_cost = buf->ReadWord();
3845  break;
3846 
3847  default:
3848  ret = CIR_UNKNOWN;
3849  break;
3850  }
3851  }
3852 
3853  return ret;
3854 }
3855 
3863 {
3865 
3866  switch (prop) {
3867  case 0x0B:
3868  case 0x0C:
3869  case 0x0D:
3870  case 0x12:
3871  case 0x14:
3872  case 0x16:
3873  case 0x17:
3874  buf->ReadByte();
3875  break;
3876 
3877  case 0x09:
3878  case 0x0A:
3879  case 0x10:
3880  case 0x11:
3881  case 0x13:
3882  case 0x15:
3883  buf->ReadWord();
3884  break;
3885 
3886  case 0x08:
3887  case 0x0E:
3888  case 0x0F:
3889  buf->ReadDWord();
3890  break;
3891 
3892  default:
3893  ret = CIR_UNKNOWN;
3894  break;
3895  }
3896 
3897  return ret;
3898 }
3899 
3908 static ChangeInfoResult ObjectChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
3909 {
3911 
3912  if (id + numinfo > NUM_OBJECTS_PER_GRF) {
3913  grfmsg(1, "ObjectChangeInfo: Too many objects loaded (%u), max (%u). Ignoring.", id + numinfo, NUM_OBJECTS_PER_GRF);
3914  return CIR_INVALID_ID;
3915  }
3916 
3917  /* Allocate object specs if they haven't been allocated already. */
3918  if (_cur.grffile->objectspec == NULL) {
3919  _cur.grffile->objectspec = CallocT<ObjectSpec*>(NUM_OBJECTS_PER_GRF);
3920  }
3921 
3922  for (int i = 0; i < numinfo; i++) {
3923  ObjectSpec *spec = _cur.grffile->objectspec[id + i];
3924 
3925  if (prop != 0x08 && spec == NULL) {
3926  /* If the object property 08 is not yet set, ignore this property */
3927  ChangeInfoResult cir = IgnoreObjectProperty(prop, buf);
3928  if (cir > ret) ret = cir;
3929  continue;
3930  }
3931 
3932  switch (prop) {
3933  case 0x08: { // Class ID
3934  ObjectSpec **ospec = &_cur.grffile->objectspec[id + i];
3935 
3936  /* Allocate space for this object. */
3937  if (*ospec == NULL) {
3938  *ospec = CallocT<ObjectSpec>(1);
3939  (*ospec)->views = 1; // Default for NewGRFs that don't set it.
3940  }
3941 
3942  /* Swap classid because we read it in BE. */
3943  uint32 classid = buf->ReadDWord();
3944  (*ospec)->cls_id = ObjectClass::Allocate(BSWAP32(classid));
3945  (*ospec)->enabled = true;
3946  break;
3947  }
3948 
3949  case 0x09: { // Class name
3950  ObjectClass *objclass = ObjectClass::Get(spec->cls_id);
3951  AddStringForMapping(buf->ReadWord(), &objclass->name);
3952  break;
3953  }
3954 
3955  case 0x0A: // Object name
3956  AddStringForMapping(buf->ReadWord(), &spec->name);
3957  break;
3958 
3959  case 0x0B: // Climate mask
3960  spec->climate = buf->ReadByte();
3961  break;
3962 
3963  case 0x0C: // Size
3964  spec->size = buf->ReadByte();
3965  break;
3966 
3967  case 0x0D: // Build cost multipler
3968  spec->build_cost_multiplier = buf->ReadByte();
3970  break;
3971 
3972  case 0x0E: // Introduction date
3973  spec->introduction_date = buf->ReadDWord();
3974  break;
3975 
3976  case 0x0F: // End of life
3977  spec->end_of_life_date = buf->ReadDWord();
3978  break;
3979 
3980  case 0x10: // Flags
3981  spec->flags = (ObjectFlags)buf->ReadWord();
3982  _loaded_newgrf_features.has_2CC |= (spec->flags & OBJECT_FLAG_2CC_COLOUR) != 0;
3983  break;
3984 
3985  case 0x11: // Animation info
3986  spec->animation.frames = buf->ReadByte();
3987  spec->animation.status = buf->ReadByte();
3988  break;
3989 
3990  case 0x12: // Animation speed
3991  spec->animation.speed = buf->ReadByte();
3992  break;
3993 
3994  case 0x13: // Animation triggers
3995  spec->animation.triggers = buf->ReadWord();
3996  break;
3997 
3998  case 0x14: // Removal cost multiplier
3999  spec->clear_cost_multiplier = buf->ReadByte();
4000  break;
4001 
4002  case 0x15: // Callback mask
4003  spec->callback_mask = buf->ReadWord();
4004  break;
4005 
4006  case 0x16: // Building height
4007  spec->height = buf->ReadByte();
4008  break;
4009 
4010  case 0x17: // Views
4011  spec->views = buf->ReadByte();
4012  if (spec->views != 1 && spec->views != 2 && spec->views != 4) {
4013  grfmsg(2, "ObjectChangeInfo: Invalid number of views (%u) for object id %u. Ignoring.", spec->views, id + i);
4014  spec->views = 1;
4015  }
4016  break;
4017 
4018  case 0x18: // Amount placed on 256^2 map on map creation
4019  spec->generate_amount = buf->ReadByte();
4020  break;
4021 
4022  default:
4023  ret = CIR_UNKNOWN;
4024  break;
4025  }
4026  }
4027 
4028  return ret;
4029 }
4030 
4039 static ChangeInfoResult RailTypeChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
4040 {
4042 
4043  extern RailtypeInfo _railtypes[RAILTYPE_END];
4044 
4045  if (id + numinfo > RAILTYPE_END) {
4046  grfmsg(1, "RailTypeChangeInfo: Rail type %u is invalid, max %u, ignoring", id + numinfo, RAILTYPE_END);
4047  return CIR_INVALID_ID;
4048  }
4049 
4050  for (int i = 0; i < numinfo; i++) {
4051  RailType rt = _cur.grffile->railtype_map[id + i];
4052  if (rt == INVALID_RAILTYPE) return CIR_INVALID_ID;
4053 
4054  RailtypeInfo *rti = &_railtypes[rt];
4055 
4056  switch (prop) {
4057  case 0x08: // Label of rail type
4058  /* Skipped here as this is loaded during reservation stage. */
4059  buf->ReadDWord();
4060  break;
4061 
4062  case 0x09: { // Toolbar caption of railtype (sets name as well for backwards compatibility for grf ver < 8)
4063  uint16 str = buf->ReadWord();
4065  if (_cur.grffile->grf_version < 8) {
4066  AddStringForMapping(str, &rti->strings.name);
4067  }
4068  break;
4069  }
4070 
4071  case 0x0A: // Menu text of railtype
4072  AddStringForMapping(buf->ReadWord(), &rti->strings.menu_text);
4073  break;
4074 
4075  case 0x0B: // Build window caption
4076  AddStringForMapping(buf->ReadWord(), &rti->strings.build_caption);
4077  break;
4078 
4079  case 0x0C: // Autoreplace text
4080  AddStringForMapping(buf->ReadWord(), &rti->strings.replace_text);
4081  break;
4082 
4083  case 0x0D: // New locomotive text
4084  AddStringForMapping(buf->ReadWord(), &rti->strings.new_loco);
4085  break;
4086 
4087  case 0x0E: // Compatible railtype list
4088  case 0x0F: // Powered railtype list
4089  case 0x18: // Railtype list required for date introduction
4090  case 0x19: // Introduced railtype list
4091  {
4092  /* Rail type compatibility bits are added to the existing bits
4093  * to allow multiple GRFs to modify compatibility with the
4094  * default rail types. */
4095  int n = buf->ReadByte();
4096  for (int j = 0; j != n; j++) {
4097  RailTypeLabel label = buf->ReadDWord();
4098  RailType rt = GetRailTypeByLabel(BSWAP32(label), false);
4099  if (rt != INVALID_RAILTYPE) {
4100  switch (prop) {
4101  case 0x0F: SetBit(rti->powered_railtypes, rt); FALLTHROUGH; // Powered implies compatible.
4102  case 0x0E: SetBit(rti->compatible_railtypes, rt); break;
4103  case 0x18: SetBit(rti->introduction_required_railtypes, rt); break;
4104  case 0x19: SetBit(rti->introduces_railtypes, rt); break;
4105  }
4106  }
4107  }
4108  break;
4109  }
4110 
4111  case 0x10: // Rail Type flags
4112  rti->flags = (RailTypeFlags)buf->ReadByte();
4113  break;
4114 
4115  case 0x11: // Curve speed advantage
4116  rti->curve_speed = buf->ReadByte();
4117  break;
4118 
4119  case 0x12: // Station graphic
4120  rti->fallback_railtype = Clamp(buf->ReadByte(), 0, 2);
4121  break;
4122 
4123  case 0x13: // Construction cost factor
4124  rti->cost_multiplier = buf->ReadWord();
4125  break;
4126 
4127  case 0x14: // Speed limit
4128  rti->max_speed = buf->ReadWord();
4129  break;
4130 
4131  case 0x15: // Acceleration model
4132  rti->acceleration_type = Clamp(buf->ReadByte(), 0, 2);
4133  break;
4134 
4135  case 0x16: // Map colour
4136  rti->map_colour = buf->ReadByte();
4137  break;
4138 
4139  case 0x17: // Introduction date
4140  rti->introduction_date = buf->ReadDWord();
4141  break;
4142 
4143  case 0x1A: // Sort order
4144  rti->sorting_order = buf->ReadByte();
4145  break;
4146 
4147  case 0x1B: // Name of railtype (overridden by prop 09 for grf ver < 8)
4148  AddStringForMapping(buf->ReadWord(), &rti->strings.name);
4149  break;
4150 
4151  case 0x1C: // Maintenance cost factor
4152  rti->maintenance_multiplier = buf->ReadWord();
4153  break;
4154 
4155  case 0x1D: // Alternate rail type label list
4156  /* Skipped here as this is loaded during reservation stage. */
4157  for (int j = buf->ReadByte(); j != 0; j--) buf->ReadDWord();
4158  break;
4159 
4160  default:
4161  ret = CIR_UNKNOWN;
4162  break;
4163  }
4164  }
4165 
4166  return ret;
4167 }
4168 
4169 static ChangeInfoResult RailTypeReserveInfo(uint id, int numinfo, int prop, ByteReader *buf)
4170 {
4172 
4173  extern RailtypeInfo _railtypes[RAILTYPE_END];
4174 
4175  if (id + numinfo > RAILTYPE_END) {
4176  grfmsg(1, "RailTypeReserveInfo: Rail type %u is invalid, max %u, ignoring", id + numinfo, RAILTYPE_END);
4177  return CIR_INVALID_ID;
4178  }
4179 
4180  for (int i = 0; i < numinfo; i++) {
4181  switch (prop) {
4182  case 0x08: // Label of rail type
4183  {
4184  RailTypeLabel rtl = buf->ReadDWord();
4185  rtl = BSWAP32(rtl);
4186 
4187  RailType rt = GetRailTypeByLabel(rtl, false);
4188  if (rt == INVALID_RAILTYPE) {
4189  /* Set up new rail type */
4190  rt = AllocateRailType(rtl);
4191  }
4192 
4193  _cur.grffile->railtype_map[id + i] = rt;
4194  break;
4195  }
4196 
4197  case 0x09: // Toolbar caption of railtype
4198  case 0x0A: // Menu text
4199  case 0x0B: // Build window caption
4200  case 0x0C: // Autoreplace text
4201  case 0x0D: // New loco
4202  case 0x13: // Construction cost
4203  case 0x14: // Speed limit
4204  case 0x1B: // Name of railtype
4205  case 0x1C: // Maintenance cost factor
4206  buf->ReadWord();
4207  break;
4208 
4209  case 0x1D: // Alternate rail type label list
4210  if (_cur.grffile->railtype_map[id + i] != INVALID_RAILTYPE) {
4211  int n = buf->ReadByte();
4212  for (int j = 0; j != n; j++) {
4213  *_railtypes[_cur.grffile->railtype_map[id + i]].alternate_labels.Append() = BSWAP32(buf->ReadDWord());
4214  }
4215  break;
4216  }
4217  grfmsg(1, "RailTypeReserveInfo: Ignoring property 1D for rail type %u because no label was set", id + i);
4218  FALLTHROUGH;
4219 
4220  case 0x0E: // Compatible railtype list
4221  case 0x0F: // Powered railtype list
4222  case 0x18: // Railtype list required for date introduction
4223  case 0x19: // Introduced railtype list
4224  for (int j = buf->ReadByte(); j != 0; j--) buf->ReadDWord();
4225  break;
4226 
4227  case 0x10: // Rail Type flags
4228  case 0x11: // Curve speed advantage
4229  case 0x12: // Station graphic
4230  case 0x15: // Acceleration model
4231  case 0x16: // Map colour
4232  case 0x1A: // Sort order
4233  buf->ReadByte();
4234  break;
4235 
4236  case 0x17: // Introduction date
4237  buf->ReadDWord();
4238  break;
4239 
4240  default:
4241  ret = CIR_UNKNOWN;
4242  break;
4243  }
4244  }
4245 
4246  return ret;
4247 }
4248 
4249 static ChangeInfoResult AirportTilesChangeInfo(uint airtid, int numinfo, int prop, ByteReader *buf)
4250 {
4252 
4253  if (airtid + numinfo > NUM_AIRPORTTILES_PER_GRF) {
4254  grfmsg(1, "AirportTileChangeInfo: Too many airport tiles loaded (%u), max (%u). Ignoring.", airtid + numinfo, NUM_AIRPORTTILES_PER_GRF);
4255  return CIR_INVALID_ID;
4256  }
4257 
4258  /* Allocate airport tile specs if they haven't been allocated already. */
4259  if (_cur.grffile->airtspec == NULL) {
4260  _cur.grffile->airtspec = CallocT<AirportTileSpec*>(NUM_AIRPORTTILES_PER_GRF);
4261  }
4262 
4263  for (int i = 0; i < numinfo; i++) {
4264  AirportTileSpec *tsp = _cur.grffile->airtspec[airtid + i];
4265 
4266  if (prop != 0x08 && tsp == NULL) {
4267  grfmsg(2, "AirportTileChangeInfo: Attempt to modify undefined airport tile %u. Ignoring.", airtid + i);
4268  return CIR_INVALID_ID;
4269  }
4270 
4271  switch (prop) {
4272  case 0x08: { // Substitute airport tile type
4273  AirportTileSpec **tilespec = &_cur.grffile->airtspec[airtid + i];
4274  byte subs_id = buf->ReadByte();
4275 
4276  if (subs_id >= NEW_AIRPORTTILE_OFFSET) {
4277  /* The substitute id must be one of the original airport tiles. */
4278  grfmsg(2, "AirportTileChangeInfo: Attempt to use new airport tile %u as substitute airport tile for %u. Ignoring.", subs_id, airtid + i);
4279  continue;
4280  }
4281 
4282  /* Allocate space for this airport tile. */
4283  if (*tilespec == NULL) {
4284  *tilespec = CallocT<AirportTileSpec>(1);
4285  tsp = *tilespec;
4286 
4287  memcpy(tsp, AirportTileSpec::Get(subs_id), sizeof(AirportTileSpec));
4288  tsp->enabled = true;
4289 
4290  tsp->animation.status = ANIM_STATUS_NO_ANIMATION;
4291 
4292  tsp->grf_prop.local_id = airtid + i;
4293  tsp->grf_prop.subst_id = subs_id;
4294  tsp->grf_prop.grffile = _cur.grffile;
4295  _airporttile_mngr.AddEntityID(airtid + i, _cur.grffile->grfid, subs_id); // pre-reserve the tile slot
4296  }
4297  break;
4298  }
4299 
4300  case 0x09: { // Airport tile override
4301  byte override = buf->ReadByte();
4302 
4303  /* The airport tile being overridden must be an original airport tile. */
4304  if (override >= NEW_AIRPORTTILE_OFFSET) {
4305  grfmsg(2, "AirportTileChangeInfo: Attempt to override new airport tile %u with airport tile id %u. Ignoring.", override, airtid + i);
4306  continue;
4307  }
4308 
4309  _airporttile_mngr.Add(airtid + i, _cur.grffile->grfid, override);
4310  break;
4311  }
4312 
4313  case 0x0E: // Callback mask
4314  tsp->callback_mask = buf->ReadByte();
4315  break;
4316 
4317  case 0x0F: // Animation information
4318  tsp->animation.frames = buf->ReadByte();
4319  tsp->animation.status = buf->ReadByte();
4320  break;
4321 
4322  case 0x10: // Animation speed
4323  tsp->animation.speed = buf->ReadByte();
4324  break;
4325 
4326  case 0x11: // Animation triggers
4327  tsp->animation.triggers = buf->ReadByte();
4328  break;
4329 
4330  default:
4331  ret = CIR_UNKNOWN;
4332  break;
4333  }
4334  }
4335 
4336  return ret;
4337 }
4338 
4339 static bool HandleChangeInfoResult(const char *caller, ChangeInfoResult cir, uint8 feature, uint8 property)
4340 {
4341  switch (cir) {
4342  default: NOT_REACHED();
4343 
4344  case CIR_DISABLED:
4345  /* Error has already been printed; just stop parsing */
4346  return true;
4347 
4348  case CIR_SUCCESS:
4349  return false;
4350 
4351  case CIR_UNHANDLED:
4352  grfmsg(1, "%s: Ignoring property 0x%02X of feature 0x%02X (not implemented)", caller, property, feature);
4353  return false;
4354 
4355  case CIR_UNKNOWN:
4356  grfmsg(0, "%s: Unknown property 0x%02X of feature 0x%02X, disabling", caller, property, feature);
4357  FALLTHROUGH;
4358 
4359  case CIR_INVALID_ID: {
4360  /* No debug message for an invalid ID, as it has already been output */
4361  GRFError *error = DisableGrf(cir == CIR_INVALID_ID ? STR_NEWGRF_ERROR_INVALID_ID : STR_NEWGRF_ERROR_UNKNOWN_PROPERTY);
4362  if (cir != CIR_INVALID_ID) error->param_value[1] = property;
4363  return true;
4364  }
4365  }
4366 }
4367 
4368 /* Action 0x00 */
4369 static void FeatureChangeInfo(ByteReader *buf)
4370 {
4371  /* <00> <feature> <num-props> <num-info> <id> (<property <new-info>)...
4372  *
4373  * B feature
4374  * B num-props how many properties to change per vehicle/station
4375  * B num-info how many vehicles/stations to change
4376  * E id ID of first vehicle/station to change, if num-info is
4377  * greater than one, this one and the following
4378  * vehicles/stations will be changed
4379  * B property what property to change, depends on the feature
4380  * V new-info new bytes of info (variable size; depends on properties) */
4381 
4382  static const VCI_Handler handler[] = {
4383  /* GSF_TRAINS */ RailVehicleChangeInfo,
4384  /* GSF_ROADVEHICLES */ RoadVehicleChangeInfo,
4385  /* GSF_SHIPS */ ShipVehicleChangeInfo,
4386  /* GSF_AIRCRAFT */ AircraftVehicleChangeInfo,
4387  /* GSF_STATIONS */ StationChangeInfo,
4388  /* GSF_CANALS */ CanalChangeInfo,
4389  /* GSF_BRIDGES */ BridgeChangeInfo,
4390  /* GSF_HOUSES */ TownHouseChangeInfo,
4391  /* GSF_GLOBALVAR */ GlobalVarChangeInfo,
4392  /* GSF_INDUSTRYTILES */ IndustrytilesChangeInfo,
4393  /* GSF_INDUSTRIES */ IndustriesChangeInfo,
4394  /* GSF_CARGOES */ NULL, // Cargo is handled during reservation
4395  /* GSF_SOUNDFX */ SoundEffectChangeInfo,
4396  /* GSF_AIRPORTS */ AirportChangeInfo,
4397  /* GSF_SIGNALS */ NULL,
4398  /* GSF_OBJECTS */ ObjectChangeInfo,
4399  /* GSF_RAILTYPES */ RailTypeChangeInfo,
4400  /* GSF_AIRPORTTILES */ AirportTilesChangeInfo,
4401  };
4402 
4403  uint8 feature = buf->ReadByte();
4404  uint8 numprops = buf->ReadByte();
4405  uint numinfo = buf->ReadByte();
4406  uint engine = buf->ReadExtendedByte();
4407 
4408  grfmsg(6, "FeatureChangeInfo: feature %d, %d properties, to apply to %d+%d",
4409  feature, numprops, engine, numinfo);
4410 
4411  if (feature >= lengthof(handler) || handler[feature] == NULL) {
4412  if (feature != GSF_CARGOES) grfmsg(1, "FeatureChangeInfo: Unsupported feature %d, skipping", feature);
4413  return;
4414  }
4415 
4416  /* Mark the feature as used by the grf */
4417  SetBit(_cur.grffile->grf_features, feature);
4418 
4419  while (numprops-- && buf->HasData()) {
4420  uint8 prop = buf->ReadByte();
4421 
4422  ChangeInfoResult cir = handler[feature](engine, numinfo, prop, buf);
4423  if (HandleChangeInfoResult("FeatureChangeInfo", cir, feature, prop)) return;
4424  }
4425 }
4426 
4427 /* Action 0x00 (GLS_SAFETYSCAN) */
4428 static void SafeChangeInfo(ByteReader *buf)
4429 {
4430  uint8 feature = buf->ReadByte();
4431  uint8 numprops = buf->ReadByte();
4432  uint numinfo = buf->ReadByte();
4433  buf->ReadExtendedByte(); // id
4434 
4435  if (feature == GSF_BRIDGES && numprops == 1) {
4436  uint8 prop = buf->ReadByte();
4437  /* Bridge property 0x0D is redefinition of sprite layout tables, which
4438  * is considered safe. */
4439  if (prop == 0x0D) return;
4440  } else if (feature == GSF_GLOBALVAR && numprops == 1) {
4441  uint8 prop = buf->ReadByte();
4442  /* Engine ID Mappings are safe, if the source is static */
4443  if (prop == 0x11) {
4444  bool is_safe = true;
4445  for (uint i = 0; i < numinfo; i++) {
4446  uint32 s = buf->ReadDWord();
4447  buf->ReadDWord(); // dest
4448  const GRFConfig *grfconfig = GetGRFConfig(s);
4449  if (grfconfig != NULL && !HasBit(grfconfig->flags, GCF_STATIC)) {
4450  is_safe = false;
4451  break;
4452  }
4453  }
4454  if (is_safe) return;
4455  }
4456  }
4457 
4458  SetBit(_cur.grfconfig->flags, GCF_UNSAFE);
4459 
4460  /* Skip remainder of GRF */
4461  _cur.skip_sprites = -1;
4462 }
4463 
4464 /* Action 0x00 (GLS_RESERVE) */
4465 static void ReserveChangeInfo(ByteReader *buf)
4466 {
4467  uint8 feature = buf->ReadByte();
4468 
4469  if (feature != GSF_CARGOES && feature != GSF_GLOBALVAR && feature != GSF_RAILTYPES) return;
4470 
4471  uint8 numprops = buf->ReadByte();
4472  uint8 numinfo = buf->ReadByte();
4473  uint8 index = buf->ReadExtendedByte();
4474 
4475  while (numprops-- && buf->HasData()) {
4476  uint8 prop = buf->ReadByte();
4478 
4479  switch (feature) {
4480  default: NOT_REACHED();
4481  case GSF_CARGOES:
4482  cir = CargoChangeInfo(index, numinfo, prop, buf);
4483  break;
4484 
4485  case GSF_GLOBALVAR:
4486  cir = GlobalVarReserveInfo(index, numinfo, prop, buf);
4487  break;
4488 
4489  case GSF_RAILTYPES:
4490  cir = RailTypeReserveInfo(index, numinfo, prop, buf);
4491  break;
4492  }
4493 
4494  if (HandleChangeInfoResult("ReserveChangeInfo", cir, feature, prop)) return;
4495  }
4496 }
4497 
4498 /* Action 0x01 */
4499 static void NewSpriteSet(ByteReader *buf)
4500 {
4501  /* Basic format: <01> <feature> <num-sets> <num-ent>
4502  * Extended format: <01> <feature> 00 <first-set> <num-sets> <num-ent>
4503  *
4504  * B feature feature to define sprites for
4505  * 0, 1, 2, 3: veh-type, 4: train stations
4506  * E first-set first sprite set to define
4507  * B num-sets number of sprite sets (extended byte in extended format)
4508  * E num-ent how many entries per sprite set
4509  * For vehicles, this is the number of different
4510  * vehicle directions in each sprite set
4511  * Set num-dirs=8, unless your sprites are symmetric.
4512  * In that case, use num-dirs=4.
4513  */
4514 
4515  uint8 feature = buf->ReadByte();
4516  uint16 num_sets = buf->ReadByte();
4517  uint16 first_set = 0;
4518 
4519  if (num_sets == 0 && buf->HasData(3)) {
4520  /* Extended Action1 format.
4521  * Some GRFs define zero sets of zero sprites, though there is actually no use in that. Ignore them. */
4522  first_set = buf->ReadExtendedByte();
4523  num_sets = buf->ReadExtendedByte();
4524  }
4525  uint16 num_ents = buf->ReadExtendedByte();
4526 
4527  _cur.AddSpriteSets(feature, _cur.spriteid, first_set, num_sets, num_ents);
4528 
4529  grfmsg(7, "New sprite set at %d of type %d, consisting of %d sets with %d views each (total %d)",
4530  _cur.spriteid, feature, num_sets, num_ents, num_sets * num_ents
4531  );
4532 
4533  for (int i = 0; i < num_sets * num_ents; i++) {
4534  _cur.nfo_line++;
4535  LoadNextSprite(_cur.spriteid++, _cur.file_index, _cur.nfo_line, _cur.grf_container_ver);
4536  }
4537 }
4538 
4539 /* Action 0x01 (SKIP) */
4540 static void SkipAct1(ByteReader *buf)
4541 {
4542  buf->ReadByte();
4543  uint16 num_sets = buf->ReadByte();
4544 
4545  if (num_sets == 0 && buf->HasData(3)) {
4546  /* Extended Action1 format.
4547  * Some GRFs define zero sets of zero sprites, though there is actually no use in that. Ignore them. */
4548  buf->ReadExtendedByte(); // first_set
4549  num_sets = buf->ReadExtendedByte();
4550  }
4551  uint16 num_ents = buf->ReadExtendedByte();
4552 
4553  _cur.skip_sprites = num_sets * num_ents;
4554 
4555  grfmsg(3, "SkipAct1: Skipping %d sprites", _cur.skip_sprites);
4556 }
4557 
4558 /* Helper function to either create a callback or link to a previously
4559  * defined spritegroup. */
4560 static const SpriteGroup *GetGroupFromGroupID(byte setid, byte type, uint16 groupid)
4561 {
4562  if (HasBit(groupid, 15)) {
4564  return new CallbackResultSpriteGroup(groupid, _cur.grffile->grf_version >= 8);
4565  }
4566 
4567  if (groupid > MAX_SPRITEGROUP || _cur.spritegroups[groupid] == NULL) {
4568  grfmsg(1, "GetGroupFromGroupID(0x%02X:0x%02X): Groupid 0x%04X does not exist, leaving empty", setid, type, groupid);
4569  return NULL;
4570  }
4571 
4572  return _cur.spritegroups[groupid];
4573 }
4574 
4583 static const SpriteGroup *CreateGroupFromGroupID(byte feature, byte setid, byte type, uint16 spriteid)
4584 {
4585  if (HasBit(spriteid, 15)) {
4587  return new CallbackResultSpriteGroup(spriteid, _cur.grffile->grf_version >= 8);
4588  }
4589 
4590  if (!_cur.IsValidSpriteSet(feature, spriteid)) {
4591  grfmsg(1, "CreateGroupFromGroupID(0x%02X:0x%02X): Sprite set %u invalid", setid, type, spriteid);
4592  return NULL;
4593  }
4594 
4595  SpriteID spriteset_start = _cur.GetSprite(feature, spriteid);
4596  uint num_sprites = _cur.GetNumEnts(feature, spriteid);
4597 
4598  /* Ensure that the sprites are loeded */
4599  assert(spriteset_start + num_sprites <= _cur.spriteid);
4600 
4602  return new ResultSpriteGroup(spriteset_start, num_sprites);
4603 }
4604 
4605 /* Action 0x02 */
4606 static void NewSpriteGroup(ByteReader *buf)
4607 {
4608  /* <02> <feature> <set-id> <type/num-entries> <feature-specific-data...>
4609  *
4610  * B feature see action 1
4611  * B set-id ID of this particular definition
4612  * B type/num-entries
4613  * if 80 or greater, this is a randomized or variational
4614  * list definition, see below
4615  * otherwise it specifies a number of entries, the exact
4616  * meaning depends on the feature
4617  * V feature-specific-data (huge mess, don't even look it up --pasky) */
4618  SpriteGroup *act_group = NULL;
4619 
4620  uint8 feature = buf->ReadByte();
4621  uint8 setid = buf->ReadByte();
4622  uint8 type = buf->ReadByte();
4623 
4624  /* Sprite Groups are created here but they are allocated from a pool, so
4625  * we do not need to delete anything if there is an exception from the
4626  * ByteReader. */
4627 
4628  switch (type) {
4629  /* Deterministic Sprite Group */
4630  case 0x81: // Self scope, byte
4631  case 0x82: // Parent scope, byte
4632  case 0x85: // Self scope, word
4633  case 0x86: // Parent scope, word
4634  case 0x89: // Self scope, dword
4635  case 0x8A: // Parent scope, dword
4636  {
4637  byte varadjust;
4638  byte varsize;
4639 
4642  act_group = group;
4643  group->var_scope = HasBit(type, 1) ? VSG_SCOPE_PARENT : VSG_SCOPE_SELF;
4644 
4645  switch (GB(type, 2, 2)) {
4646  default: NOT_REACHED();
4647  case 0: group->size = DSG_SIZE_BYTE; varsize = 1; break;
4648  case 1: group->size = DSG_SIZE_WORD; varsize = 2; break;
4649  case 2: group->size = DSG_SIZE_DWORD; varsize = 4; break;
4650  }
4651 
4653  adjusts.Clear();
4654 
4655  /* Loop through the var adjusts. Unfortunately we don't know how many we have
4656  * from the outset, so we shall have to keep reallocing. */
4657  do {
4658  DeterministicSpriteGroupAdjust *adjust = adjusts.Append();
4659 
4660  /* The first var adjust doesn't have an operation specified, so we set it to add. */
4661  adjust->operation = adjusts.Length() == 1 ? DSGA_OP_ADD : (DeterministicSpriteGroupAdjustOperation)buf->ReadByte();
4662  adjust->variable = buf->ReadByte();
4663  if (adjust->variable == 0x7E) {
4664  /* Link subroutine group */
4665  adjust->subroutine = GetGroupFromGroupID(setid, type, buf->ReadByte());
4666  } else {
4667  adjust->parameter = IsInsideMM(adjust->variable, 0x60, 0x80) ? buf->ReadByte() : 0;
4668  }
4669 
4670  varadjust = buf->ReadByte();
4671  adjust->shift_num = GB(varadjust, 0, 5);
4672  adjust->type = (DeterministicSpriteGroupAdjustType)GB(varadjust, 6, 2);
4673  adjust->and_mask = buf->ReadVarSize(varsize);
4674 
4675  if (adjust->type != DSGA_TYPE_NONE) {
4676  adjust->add_val = buf->ReadVarSize(varsize);
4677  adjust->divmod_val = buf->ReadVarSize(varsize);
4678  } else {
4679  adjust->add_val = 0;
4680  adjust->divmod_val = 0;
4681  }
4682 
4683  /* Continue reading var adjusts while bit 5 is set. */
4684  } while (HasBit(varadjust, 5));
4685 
4686  group->num_adjusts = adjusts.Length();
4687  group->adjusts = MallocT<DeterministicSpriteGroupAdjust>(group->num_adjusts);
4688  MemCpyT(group->adjusts, adjusts.Begin(), group->num_adjusts);
4689 
4690  group->num_ranges = buf->ReadByte();
4691  if (group->num_ranges > 0) group->ranges = CallocT<DeterministicSpriteGroupRange>(group->num_ranges);
4692 
4693  for (uint i = 0; i < group->num_ranges; i++) {
4694  group->ranges[i].group = GetGroupFromGroupID(setid, type, buf->ReadWord());
4695  group->ranges[i].low = buf->ReadVarSize(varsize);
4696  group->ranges[i].high = buf->ReadVarSize(varsize);
4697  }
4698 
4699  group->default_group = GetGroupFromGroupID(setid, type, buf->ReadWord());
4700  break;
4701  }
4702 
4703  /* Randomized Sprite Group */
4704  case 0x80: // Self scope
4705  case 0x83: // Parent scope
4706  case 0x84: // Relative scope
4707  {
4710  act_group = group;
4711  group->var_scope = HasBit(type, 1) ? VSG_SCOPE_PARENT : VSG_SCOPE_SELF;
4712 
4713  if (HasBit(type, 2)) {
4714  if (feature <= GSF_AIRCRAFT) group->var_scope = VSG_SCOPE_RELATIVE;
4715  group->count = buf->ReadByte();
4716  }
4717 
4718  uint8 triggers = buf->ReadByte();
4719  group->triggers = GB(triggers, 0, 7);
4720  group->cmp_mode = HasBit(triggers, 7) ? RSG_CMP_ALL : RSG_CMP_ANY;
4721  group->lowest_randbit = buf->ReadByte();
4722  group->num_groups = buf->ReadByte();
4723  group->groups = CallocT<const SpriteGroup*>(group->num_groups);
4724 
4725  for (uint i = 0; i < group->num_groups; i++) {
4726  group->groups[i] = GetGroupFromGroupID(setid, type, buf->ReadWord());
4727  }
4728 
4729  break;
4730  }
4731 
4732  /* Neither a variable or randomized sprite group... must be a real group */
4733  default:
4734  {
4735  switch (feature) {
4736  case GSF_TRAINS:
4737  case GSF_ROADVEHICLES:
4738  case GSF_SHIPS:
4739  case GSF_AIRCRAFT:
4740  case GSF_STATIONS:
4741  case GSF_CANALS:
4742  case GSF_CARGOES:
4743  case GSF_AIRPORTS:
4744  case GSF_RAILTYPES:
4745  {
4746  byte num_loaded = type;
4747  byte num_loading = buf->ReadByte();
4748 
4749  if (!_cur.HasValidSpriteSets(feature)) {
4750  grfmsg(0, "NewSpriteGroup: No sprite set to work on! Skipping");
4751  return;
4752  }
4753 
4755  RealSpriteGroup *group = new RealSpriteGroup();
4756  act_group = group;
4757 
4758  group->num_loaded = num_loaded;
4759  group->num_loading = num_loading;
4760  if (num_loaded > 0) group->loaded = CallocT<const SpriteGroup*>(num_loaded);
4761  if (num_loading > 0) group->loading = CallocT<const SpriteGroup*>(num_loading);
4762 
4763  grfmsg(6, "NewSpriteGroup: New SpriteGroup 0x%02X, %u loaded, %u loading",
4764  setid, num_loaded, num_loading);
4765 
4766  for (uint i = 0; i < num_loaded; i++) {
4767  uint16 spriteid = buf->ReadWord();
4768  group->loaded[i] = CreateGroupFromGroupID(feature, setid, type, spriteid);
4769  grfmsg(8, "NewSpriteGroup: + rg->loaded[%i] = subset %u", i, spriteid);
4770  }
4771 
4772  for (uint i = 0; i < num_loading; i++) {
4773  uint16 spriteid = buf->ReadWord();
4774  group->loading[i] = CreateGroupFromGroupID(feature, setid, type, spriteid);
4775  grfmsg(8, "NewSpriteGroup: + rg->loading[%i] = subset %u", i, spriteid);
4776  }
4777 
4778  break;
4779  }
4780 
4781  case GSF_HOUSES:
4782  case GSF_AIRPORTTILES:
4783  case GSF_OBJECTS:
4784  case GSF_INDUSTRYTILES: {
4785  byte num_building_sprites = max((uint8)1, type);
4786 
4789  act_group = group;
4790 
4791  /* On error, bail out immediately. Temporary GRF data was already freed */
4792  if (ReadSpriteLayout(buf, num_building_sprites, true, feature, false, type == 0, &group->dts)) return;
4793  break;
4794  }
4795 
4796  case GSF_INDUSTRIES: {
4797  if (type > 1) {
4798  grfmsg(1, "NewSpriteGroup: Unsupported industry production version %d, skipping", type);
4799  break;
4800  }
4801 
4804  act_group = group;
4805  group->version = type;
4806  if (type == 0) {
4807  for (uint i = 0; i < 3; i++) {
4808  group->subtract_input[i] = (int16)buf->ReadWord(); // signed
4809  }
4810  for (uint i = 0; i < 2; i++) {
4811  group->add_output[i] = buf->ReadWord(); // unsigned
4812  }
4813  group->again = buf->ReadByte();
4814  } else {
4815  for (uint i = 0; i < 3; i++) {
4816  group->subtract_input[i] = buf->ReadByte();
4817  }
4818  for (uint i = 0; i < 2; i++) {
4819  group->add_output[i] = buf->ReadByte();
4820  }
4821  group->again = buf->ReadByte();
4822  }
4823  break;
4824  }
4825 
4826  /* Loading of Tile Layout and Production Callback groups would happen here */
4827  default: grfmsg(1, "NewSpriteGroup: Unsupported feature %d, skipping", feature);
4828  }
4829  }
4830  }
4831 
4832  _cur.spritegroups[setid] = act_group;
4833 }
4834 
4835 static CargoID TranslateCargo(uint8 feature, uint8 ctype)
4836 {
4837  if (feature == GSF_OBJECTS) {
4838  switch (ctype) {
4839  case 0: return 0;
4840  case 0xFF: return CT_PURCHASE_OBJECT;
4841  default:
4842  grfmsg(1, "TranslateCargo: Invalid cargo bitnum %d for objects, skipping.", ctype);
4843  return CT_INVALID;
4844  }
4845  }
4846  /* Special cargo types for purchase list and stations */
4847  if (feature == GSF_STATIONS && ctype == 0xFE) return CT_DEFAULT_NA;
4848  if (ctype == 0xFF) return CT_PURCHASE;
4849 
4850  if (_cur.grffile->cargo_list.Length() == 0) {
4851  /* No cargo table, so use bitnum values */
4852  if (ctype >= 32) {
4853  grfmsg(1, "TranslateCargo: Cargo bitnum %d out of range (max 31), skipping.", ctype);
4854  return CT_INVALID;
4855  }
4856 
4857  const CargoSpec *cs;
4858  FOR_ALL_CARGOSPECS(cs) {
4859  if (cs->bitnum == ctype) {
4860  grfmsg(6, "TranslateCargo: Cargo bitnum %d mapped to cargo type %d.", ctype, cs->Index());
4861  return cs->Index();
4862  }
4863  }
4864 
4865  grfmsg(5, "TranslateCargo: Cargo bitnum %d not available in this climate, skipping.", ctype);
4866  return CT_INVALID;
4867  }
4868 
4869  /* Check if the cargo type is out of bounds of the cargo translation table */
4870  if (ctype >= _cur.grffile->cargo_list.Length()) {
4871  grfmsg(1, "TranslateCargo: Cargo type %d out of range (max %d), skipping.", ctype, _cur.grffile->cargo_list.Length() - 1);
4872  return CT_INVALID;
4873  }
4874 
4875  /* Look up the cargo label from the translation table */
4876  CargoLabel cl = _cur.grffile->cargo_list[ctype];
4877  if (cl == 0) {
4878  grfmsg(5, "TranslateCargo: Cargo type %d not available in this climate, skipping.", ctype);
4879  return CT_INVALID;
4880  }
4881 
4882  ctype = GetCargoIDByLabel(cl);
4883  if (ctype == CT_INVALID) {
4884  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));
4885  return CT_INVALID;
4886  }
4887 
4888  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);
4889  return ctype;
4890 }
4891 
4892 
4893 static bool IsValidGroupID(uint16 groupid, const char *function)
4894 {
4895  if (groupid > MAX_SPRITEGROUP || _cur.spritegroups[groupid] == NULL) {
4896  grfmsg(1, "%s: Spritegroup 0x%04X out of range or empty, skipping.", function, groupid);
4897  return false;
4898  }
4899 
4900  return true;
4901 }
4902 
4903 static void VehicleMapSpriteGroup(ByteReader *buf, byte feature, uint8 idcount)
4904 {
4905  static EngineID *last_engines;
4906  static uint last_engines_count;
4907  bool wagover = false;
4908 
4909  /* Test for 'wagon override' flag */
4910  if (HasBit(idcount, 7)) {
4911  wagover = true;
4912  /* Strip off the flag */
4913  idcount = GB(idcount, 0, 7);
4914 
4915  if (last_engines_count == 0) {
4916  grfmsg(0, "VehicleMapSpriteGroup: WagonOverride: No engine to do override with");
4917  return;
4918  }
4919 
4920  grfmsg(6, "VehicleMapSpriteGroup: WagonOverride: %u engines, %u wagons",
4921  last_engines_count, idcount);
4922  } else {
4923  if (last_engines_count != idcount) {
4924  last_engines = ReallocT(last_engines, idcount);
4925  last_engines_count = idcount;
4926  }
4927  }
4928 
4929  EngineID *engines = AllocaM(EngineID, idcount);
4930  for (uint i = 0; i < idcount; i++) {
4931  Engine *e = GetNewEngine(_cur.grffile, (VehicleType)feature, buf->ReadExtendedByte());
4932  if (e == NULL) {
4933  /* No engine could be allocated?!? Deal with it. Okay,
4934  * this might look bad. Also make sure this NewGRF
4935  * gets disabled, as a half loaded one is bad. */
4936  HandleChangeInfoResult("VehicleMapSpriteGroup", CIR_INVALID_ID, 0, 0);
4937  return;
4938  }
4939 
4940  engines[i] = e->index;
4941  if (!wagover) last_engines[i] = engines[i];
4942  }
4943 
4944  uint8 cidcount = buf->ReadByte();
4945  for (uint c = 0; c < cidcount; c++) {
4946  uint8 ctype = buf->ReadByte();
4947  uint16 groupid = buf->ReadWord();
4948  if (!IsValidGroupID(groupid, "VehicleMapSpriteGroup")) continue;
4949 
4950  grfmsg(8, "VehicleMapSpriteGroup: * [%d] Cargo type 0x%X, group id 0x%02X", c, ctype, groupid);
4951 
4952  ctype = TranslateCargo(feature, ctype);
4953  if (ctype == CT_INVALID) continue;
4954 
4955  for (uint i = 0; i < idcount; i++) {
4956  EngineID engine = engines[i];
4957 
4958  grfmsg(7, "VehicleMapSpriteGroup: [%d] Engine %d...", i, engine);
4959 
4960  if (wagover) {
4961  SetWagonOverrideSprites(engine, ctype, _cur.spritegroups[groupid], last_engines, last_engines_count);
4962  } else {
4963  SetCustomEngineSprites(engine, ctype, _cur.spritegroups[groupid]);
4964  }
4965  }
4966  }
4967 
4968  uint16 groupid = buf->ReadWord();
4969  if (!IsValidGroupID(groupid, "VehicleMapSpriteGroup")) return;
4970 
4971  grfmsg(8, "-- Default group id 0x%04X", groupid);
4972 
4973  for (uint i = 0; i < idcount; i++) {
4974  EngineID engine = engines[i];
4975 
4976  if (wagover) {
4977  SetWagonOverrideSprites(engine, CT_DEFAULT, _cur.spritegroups[groupid], last_engines, last_engines_count);
4978  } else {
4979  SetCustomEngineSprites(engine, CT_DEFAULT, _cur.spritegroups[groupid]);
4980  SetEngineGRF(engine, _cur.grffile);
4981  }
4982  }
4983 }
4984 
4985 
4986 static void CanalMapSpriteGroup(ByteReader *buf, uint8 idcount)
4987 {
4988  CanalFeature *cfs = AllocaM(CanalFeature, idcount);
4989  for (uint i = 0; i < idcount; i++) {
4990  cfs[i] = (CanalFeature)buf->ReadByte();
4991  }
4992 
4993  uint8 cidcount = buf->ReadByte();
4994  buf->Skip(cidcount * 3);
4995 
4996  uint16 groupid = buf->ReadWord();
4997  if (!IsValidGroupID(groupid, "CanalMapSpriteGroup")) return;
4998 
4999  for (uint i = 0; i < idcount; i++) {
5000  CanalFeature cf = cfs[i];
5001 
5002  if (cf >= CF_END) {
5003  grfmsg(1, "CanalMapSpriteGroup: Canal subset %d out of range, skipping", cf);
5004  continue;
5005  }
5006 
5007  _water_feature[cf].grffile = _cur.grffile;
5008  _water_feature[cf].group = _cur.spritegroups[groupid];
5009  }
5010 }
5011 
5012 
5013 static void StationMapSpriteGroup(ByteReader *buf, uint8 idcount)
5014 {
5015  uint8 *stations = AllocaM(uint8, idcount);
5016  for (uint i = 0; i < idcount; i++) {
5017  stations[i] = buf->ReadByte();
5018  }
5019 
5020  uint8 cidcount = buf->ReadByte();
5021  for (uint c = 0; c < cidcount; c++) {
5022  uint8 ctype = buf->ReadByte();
5023  uint16 groupid = buf->ReadWord();
5024  if (!IsValidGroupID(groupid, "StationMapSpriteGroup")) continue;
5025 
5026  ctype = TranslateCargo(GSF_STATIONS, ctype);
5027  if (ctype == CT_INVALID) continue;
5028 
5029  for (uint i = 0; i < idcount; i++) {
5030  StationSpec *statspec = _cur.grffile->stations == NULL ? NULL : _cur.grffile->stations[stations[i]];
5031 
5032  if (statspec == NULL) {
5033  grfmsg(1, "StationMapSpriteGroup: Station with ID 0x%02X does not exist, skipping", stations[i]);
5034  continue;
5035  }
5036 
5037  statspec->grf_prop.spritegroup[ctype] = _cur.spritegroups[groupid];
5038  }
5039  }
5040 
5041  uint16 groupid = buf->ReadWord();
5042  if (!IsValidGroupID(groupid, "StationMapSpriteGroup")) return;
5043 
5044  for (uint i = 0; i < idcount; i++) {
5045  StationSpec *statspec = _cur.grffile->stations == NULL ? NULL : _cur.grffile->stations[stations[i]];
5046 
5047  if (statspec == NULL) {
5048  grfmsg(1, "StationMapSpriteGroup: Station with ID 0x%02X does not exist, skipping", stations[i]);
5049  continue;
5050  }
5051 
5052  if (statspec->grf_prop.grffile != NULL) {
5053  grfmsg(1, "StationMapSpriteGroup: Station with ID 0x%02X mapped multiple times, skipping", stations[i]);
5054  continue;
5055  }
5056 
5057  statspec->grf_prop.spritegroup[CT_DEFAULT] = _cur.spritegroups[groupid];
5058  statspec->grf_prop.grffile = _cur.grffile;
5059  statspec->grf_prop.local_id = stations[i];
5060  StationClass::Assign(statspec);
5061  }
5062 }
5063 
5064 
5065 static void TownHouseMapSpriteGroup(ByteReader *buf, uint8 idcount)
5066 {
5067  uint8 *houses = AllocaM(uint8, idcount);
5068  for (uint i = 0; i < idcount; i++) {
5069  houses[i] = buf->ReadByte();
5070  }
5071 
5072  /* Skip the cargo type section, we only care about the default group */
5073  uint8 cidcount = buf->ReadByte();
5074  buf->Skip(cidcount * 3);
5075 
5076  uint16 groupid = buf->ReadWord();
5077  if (!IsValidGroupID(groupid, "TownHouseMapSpriteGroup")) return;
5078 
5079  if (_cur.grffile->housespec == NULL) {
5080  grfmsg(1, "TownHouseMapSpriteGroup: No houses defined, skipping");
5081  return;
5082  }
5083 
5084  for (uint i = 0; i < idcount; i++) {
5085  HouseSpec *hs = _cur.grffile->housespec[houses[i]];
5086 
5087  if (hs == NULL) {
5088  grfmsg(1, "TownHouseMapSpriteGroup: House %d undefined, skipping.", houses[i]);
5089  continue;
5090  }
5091 
5092  hs->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
5093  }
5094 }
5095 
5096 static void IndustryMapSpriteGroup(ByteReader *buf, uint8 idcount)
5097 {
5098  uint8 *industries = AllocaM(uint8, idcount);
5099  for (uint i = 0; i < idcount; i++) {
5100  industries[i] = buf->ReadByte();
5101  }
5102 
5103  /* Skip the cargo type section, we only care about the default group */
5104  uint8 cidcount = buf->ReadByte();
5105  buf->Skip(cidcount * 3);
5106 
5107  uint16 groupid = buf->ReadWord();
5108  if (!IsValidGroupID(groupid, "IndustryMapSpriteGroup")) return;
5109 
5110  if (_cur.grffile->industryspec == NULL) {
5111  grfmsg(1, "IndustryMapSpriteGroup: No industries defined, skipping");
5112  return;
5113  }
5114 
5115  for (uint i = 0; i < idcount; i++) {
5116  IndustrySpec *indsp = _cur.grffile->industryspec[industries[i]];
5117 
5118  if (indsp == NULL) {
5119  grfmsg(1, "IndustryMapSpriteGroup: Industry %d undefined, skipping", industries[i]);
5120  continue;
5121  }
5122 
5123  indsp->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
5124  }
5125 }
5126 
5127 static void IndustrytileMapSpriteGroup(ByteReader *buf, uint8 idcount)
5128 {
5129  uint8 *indtiles = AllocaM(uint8, idcount);
5130  for (uint i = 0; i < idcount; i++) {
5131  indtiles[i] = buf->ReadByte();
5132  }
5133 
5134  /* Skip the cargo type section, we only care about the default group */
5135  uint8 cidcount = buf->ReadByte();
5136  buf->Skip(cidcount * 3);
5137 
5138  uint16 groupid = buf->ReadWord();
5139  if (!IsValidGroupID(groupid, "IndustrytileMapSpriteGroup")) return;
5140 
5141  if (_cur.grffile->indtspec == NULL) {
5142  grfmsg(1, "IndustrytileMapSpriteGroup: No industry tiles defined, skipping");
5143  return;
5144  }
5145 
5146  for (uint i = 0; i < idcount; i++) {
5147  IndustryTileSpec *indtsp = _cur.grffile->indtspec[indtiles[i]];
5148 
5149  if (indtsp == NULL) {
5150  grfmsg(1, "IndustrytileMapSpriteGroup: Industry tile %d undefined, skipping", indtiles[i]);
5151  continue;
5152  }
5153 
5154  indtsp->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
5155  }
5156 }
5157 
5158 static void CargoMapSpriteGroup(ByteReader *buf, uint8 idcount)
5159 {
5160  CargoID *cargoes = AllocaM(CargoID, idcount);
5161  for (uint i = 0; i < idcount; i++) {
5162  cargoes[i] = buf->ReadByte();
5163  }
5164 
5165  /* Skip the cargo type section, we only care about the default group */
5166  uint8 cidcount = buf->ReadByte();
5167  buf->Skip(cidcount * 3);
5168 
5169  uint16 groupid = buf->ReadWord();
5170  if (!IsValidGroupID(groupid, "CargoMapSpriteGroup")) return;
5171 
5172  for (uint i = 0; i < idcount; i++) {
5173  CargoID cid = cargoes[i];
5174 
5175  if (cid >= NUM_CARGO) {
5176  grfmsg(1, "CargoMapSpriteGroup: Cargo ID %d out of range, skipping", cid);
5177  continue;
5178  }
5179 
5180  CargoSpec *cs = CargoSpec::Get(cid);
5181  cs->grffile = _cur.grffile;
5182  cs->group = _cur.spritegroups[groupid];
5183  }
5184 }
5185 
5186 static void ObjectMapSpriteGroup(ByteReader *buf, uint8 idcount)
5187 {
5188  if (_cur.grffile->objectspec == NULL) {
5189  grfmsg(1, "ObjectMapSpriteGroup: No object tiles defined, skipping");
5190  return;
5191  }
5192 
5193  uint8 *objects = AllocaM(uint8, idcount);
5194  for (uint i = 0; i < idcount; i++) {
5195  objects[i] = buf->ReadByte();
5196  }
5197 
5198  uint8 cidcount = buf->ReadByte();
5199  for (uint c = 0; c < cidcount; c++) {
5200  uint8 ctype = buf->ReadByte();
5201  uint16 groupid = buf->ReadWord();
5202  if (!IsValidGroupID(groupid, "ObjectMapSpriteGroup")) continue;
5203 
5204  ctype = TranslateCargo(GSF_OBJECTS, ctype);
5205  if (ctype == CT_INVALID) continue;
5206 
5207  for (uint i = 0; i < idcount; i++) {
5208  ObjectSpec *spec = _cur.grffile->objectspec[objects[i]];
5209 
5210  if (spec == NULL) {
5211  grfmsg(1, "ObjectMapSpriteGroup: Object with ID 0x%02X undefined, skipping", objects[i]);
5212  continue;
5213  }
5214 
5215  spec->grf_prop.spritegroup[ctype] = _cur.spritegroups[groupid];
5216  }
5217  }
5218 
5219  uint16 groupid = buf->ReadWord();
5220  if (!IsValidGroupID(groupid, "ObjectMapSpriteGroup")) return;
5221 
5222  for (uint i = 0; i < idcount; i++) {
5223  ObjectSpec *spec = _cur.grffile->objectspec[objects[i]];
5224 
5225  if (spec == NULL) {
5226  grfmsg(1, "ObjectMapSpriteGroup: Object with ID 0x%02X undefined, skipping", objects[i]);
5227  continue;
5228  }
5229 
5230  if (spec->grf_prop.grffile != NULL) {
5231  grfmsg(1, "ObjectMapSpriteGroup: Object with ID 0x%02X mapped multiple times, skipping", objects[i]);
5232  continue;
5233  }
5234 
5235  spec->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
5236  spec->grf_prop.grffile = _cur.grffile;
5237  spec->grf_prop.local_id = objects[i];
5238  }
5239 }
5240 
5241 static void RailTypeMapSpriteGroup(ByteReader *buf, uint8 idcount)
5242 {
5243  uint8 *railtypes = AllocaM(uint8, idcount);
5244  for (uint i = 0; i < idcount; i++) {
5245  railtypes[i] = _cur.grffile->railtype_map[buf->ReadByte()];
5246  }
5247 
5248  uint8 cidcount = buf->ReadByte();
5249  for (uint c = 0; c < cidcount; c++) {
5250  uint8 ctype = buf->ReadByte();
5251  uint16 groupid = buf->ReadWord();
5252  if (!IsValidGroupID(groupid, "RailTypeMapSpriteGroup")) continue;
5253 
5254  if (ctype >= RTSG_END) continue;
5255 
5256  extern RailtypeInfo _railtypes[RAILTYPE_END];
5257  for (uint i = 0; i < idcount; i++) {
5258  if (railtypes[i] != INVALID_RAILTYPE) {
5259  RailtypeInfo *rti = &_railtypes[railtypes[i]];
5260 
5261  rti->grffile[ctype] = _cur.grffile;
5262  rti->group[ctype] = _cur.spritegroups[groupid];
5263  }
5264  }
5265  }
5266 
5267  /* Railtypes do not use the default group. */
5268  buf->ReadWord();
5269 }
5270 
5271 static void AirportMapSpriteGroup(ByteReader *buf, uint8 idcount)
5272 {
5273  uint8 *airports = AllocaM(uint8, idcount);
5274  for (uint i = 0; i < idcount; i++) {
5275  airports[i] = buf->ReadByte();
5276  }
5277 
5278  /* Skip the cargo type section, we only care about the default group */
5279  uint8 cidcount = buf->ReadByte();
5280  buf->Skip(cidcount * 3);
5281 
5282  uint16 groupid = buf->ReadWord();
5283  if (!IsValidGroupID(groupid, "AirportMapSpriteGroup")) return;
5284 
5285  if (_cur.grffile->airportspec == NULL) {
5286  grfmsg(1, "AirportMapSpriteGroup: No airports defined, skipping");
5287  return;
5288  }
5289 
5290  for (uint i = 0; i < idcount; i++) {
5291  AirportSpec *as = _cur.grffile->airportspec[airports[i]];
5292 
5293  if (as == NULL) {
5294  grfmsg(1, "AirportMapSpriteGroup: Airport %d undefined, skipping", airports[i]);
5295  continue;
5296  }
5297 
5298  as->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
5299  }
5300 }
5301 
5302 static void AirportTileMapSpriteGroup(ByteReader *buf, uint8 idcount)
5303 {
5304  uint8 *airptiles = AllocaM(uint8, idcount);
5305  for (uint i = 0; i < idcount; i++) {
5306  airptiles[i] = buf->ReadByte();
5307  }
5308 
5309  /* Skip the cargo type section, we only care about the default group */
5310  uint8 cidcount = buf->ReadByte();
5311  buf->Skip(cidcount * 3);
5312 
5313  uint16 groupid = buf->ReadWord();
5314  if (!IsValidGroupID(groupid, "AirportTileMapSpriteGroup")) return;
5315 
5316  if (_cur.grffile->airtspec == NULL) {
5317  grfmsg(1, "AirportTileMapSpriteGroup: No airport tiles defined, skipping");
5318  return;
5319  }
5320 
5321  for (uint i = 0; i < idcount; i++) {
5322  AirportTileSpec *airtsp = _cur.grffile->airtspec[airptiles[i]];
5323 
5324  if (airtsp == NULL) {
5325  grfmsg(1, "AirportTileMapSpriteGroup: Airport tile %d undefined, skipping", airptiles[i]);
5326  continue;
5327  }
5328 
5329  airtsp->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
5330  }
5331 }
5332 
5333 
5334 /* Action 0x03 */
5335 static void FeatureMapSpriteGroup(ByteReader *buf)
5336 {
5337  /* <03> <feature> <n-id> <ids>... <num-cid> [<cargo-type> <cid>]... <def-cid>
5338  * id-list := [<id>] [id-list]
5339  * cargo-list := <cargo-type> <cid> [cargo-list]
5340  *
5341  * B feature see action 0
5342  * B n-id bits 0-6: how many IDs this definition applies to
5343  * bit 7: if set, this is a wagon override definition (see below)
5344  * B ids the IDs for which this definition applies
5345  * B num-cid number of cargo IDs (sprite group IDs) in this definition
5346  * can be zero, in that case the def-cid is used always
5347  * B cargo-type type of this cargo type (e.g. mail=2, wood=7, see below)
5348  * W cid cargo ID (sprite group ID) for this type of cargo
5349  * W def-cid default cargo ID (sprite group ID) */
5350 
5351  uint8 feature = buf->ReadByte();
5352  uint8 idcount = buf->ReadByte();
5353 
5354  /* If idcount is zero, this is a feature callback */
5355  if (idcount == 0) {
5356  /* Skip number of cargo ids? */
5357  buf->ReadByte();
5358  uint16 groupid = buf->ReadWord();
5359  if (!IsValidGroupID(groupid, "FeatureMapSpriteGroup")) return;
5360 
5361  grfmsg(6, "FeatureMapSpriteGroup: Adding generic feature callback for feature %d", feature);
5362 
5363  AddGenericCallback(feature, _cur.grffile, _cur.spritegroups[groupid]);
5364  return;
5365  }
5366 
5367  /* Mark the feature as used by the grf (generic callbacks do not count) */
5368  SetBit(_cur.grffile->grf_features, feature);
5369 
5370  grfmsg(6, "FeatureMapSpriteGroup: Feature %d, %d ids", feature, idcount);
5371 
5372  switch (feature) {
5373  case GSF_TRAINS:
5374  case GSF_ROADVEHICLES:
5375  case GSF_SHIPS:
5376  case GSF_AIRCRAFT:
5377  VehicleMapSpriteGroup(buf, feature, idcount);
5378  return;
5379 
5380  case GSF_CANALS:
5381  CanalMapSpriteGroup(buf, idcount);
5382  return;
5383 
5384  case GSF_STATIONS:
5385  StationMapSpriteGroup(buf, idcount);
5386  return;
5387 
5388  case GSF_HOUSES:
5389  TownHouseMapSpriteGroup(buf, idcount);
5390  return;
5391 
5392  case GSF_INDUSTRIES:
5393  IndustryMapSpriteGroup(buf, idcount);
5394  return;
5395 
5396  case GSF_INDUSTRYTILES:
5397  IndustrytileMapSpriteGroup(buf, idcount);
5398  return;
5399 
5400  case GSF_CARGOES:
5401  CargoMapSpriteGroup(buf, idcount);
5402  return;
5403 
5404  case GSF_AIRPORTS:
5405  AirportMapSpriteGroup(buf, idcount);
5406  return;
5407 
5408  case GSF_OBJECTS:
5409  ObjectMapSpriteGroup(buf, idcount);
5410  break;
5411 
5412  case GSF_RAILTYPES:
5413  RailTypeMapSpriteGroup(buf, idcount);
5414  break;
5415 
5416  case GSF_AIRPORTTILES:
5417  AirportTileMapSpriteGroup(buf, idcount);
5418  return;
5419 
5420  default:
5421  grfmsg(1, "FeatureMapSpriteGroup: Unsupported feature %d, skipping", feature);
5422  return;
5423  }
5424 }
5425 
5426 /* Action 0x04 */
5427 static void FeatureNewName(ByteReader *buf)
5428 {
5429  /* <04> <veh-type> <language-id> <num-veh> <offset> <data...>
5430  *
5431  * B veh-type see action 0 (as 00..07, + 0A
5432  * But IF veh-type = 48, then generic text
5433  * B language-id If bit 6 is set, This is the extended language scheme,
5434  * with up to 64 language.
5435  * Otherwise, it is a mapping where set bits have meaning
5436  * 0 = american, 1 = english, 2 = german, 3 = french, 4 = spanish
5437  * Bit 7 set means this is a generic text, not a vehicle one (or else)
5438  * B num-veh number of vehicles which are getting a new name
5439  * B/W offset number of the first vehicle that gets a new name
5440  * Byte : ID of vehicle to change
5441  * Word : ID of string to change/add
5442  * S data new texts, each of them zero-terminated, after
5443  * which the next name begins. */
5444 
5445  bool new_scheme = _cur.grffile->grf_version >= 7;
5446 
5447  uint8 feature = buf->ReadByte();
5448  uint8 lang = buf->ReadByte();
5449  uint8 num = buf->ReadByte();
5450  bool generic = HasBit(lang, 7);
5451  uint16 id;
5452  if (generic) {
5453  id = buf->ReadWord();
5454  } else if (feature <= GSF_AIRCRAFT) {
5455  id = buf->ReadExtendedByte();
5456  } else {
5457  id = buf->ReadByte();
5458  }
5459 
5460  ClrBit(lang, 7);
5461 
5462  uint16 endid = id + num;
5463 
5464  grfmsg(6, "FeatureNewName: About to rename engines %d..%d (feature %d) in language 0x%02X",
5465  id, endid, feature, lang);
5466 
5467  for (; id < endid && buf->HasData(); id++) {
5468  const char *name = buf->ReadString();
5469  grfmsg(8, "FeatureNewName: 0x%04X <- %s", id, name);
5470 
5471  switch (feature) {
5472  case GSF_TRAINS:
5473  case GSF_ROADVEHICLES:
5474  case GSF_SHIPS:
5475  case GSF_AIRCRAFT:
5476  if (!generic) {
5477  Engine *e = GetNewEngine(_cur.grffile, (VehicleType)feature, id, HasBit(_cur.grfconfig->flags, GCF_STATIC));
5478  if (e == NULL) break;
5479  StringID string = AddGRFString(_cur.grffile->grfid, e->index, lang, new_scheme, false, name, e->info.string_id);
5480  e->info.string_id = string;
5481  } else {
5482  AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, true, name, STR_UNDEFINED);
5483  }
5484  break;
5485 
5486  default:
5487  if (IsInsideMM(id, 0xD000, 0xD400) || IsInsideMM(id, 0xD800, 0xE000)) {
5488  AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, true, name, STR_UNDEFINED);
5489  break;
5490  }
5491 
5492  switch (GB(id, 8, 8)) {
5493  case 0xC4: // Station class name
5494  if (_cur.grffile->stations == NULL || _cur.grffile->stations[GB(id, 0, 8)] == NULL) {
5495  grfmsg(1, "FeatureNewName: Attempt to name undefined station 0x%X, ignoring", GB(id, 0, 8));
5496  } else {
5497  StationClassID cls_id = _cur.grffile->stations[GB(id, 0, 8)]->cls_id;
5498  StationClass::Get(cls_id)->name = AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
5499  }
5500  break;
5501 
5502  case 0xC5: // Station name
5503  if (_cur.grffile->stations == NULL || _cur.grffile->stations[GB(id, 0, 8)] == NULL) {
5504  grfmsg(1, "FeatureNewName: Attempt to name undefined station 0x%X, ignoring", GB(id, 0, 8));
5505  } else {
5506  _cur.grffile->stations[GB(id, 0, 8)]->name = AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
5507  }
5508  break;
5509 
5510  case 0xC7: // Airporttile name
5511  if (_cur.grffile->airtspec == NULL || _cur.grffile->airtspec[GB(id, 0, 8)] == NULL) {
5512  grfmsg(1, "FeatureNewName: Attempt to name undefined airport tile 0x%X, ignoring", GB(id, 0, 8));
5513  } else {
5514  _cur.grffile->airtspec[GB(id, 0, 8)]->name = AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
5515  }
5516  break;
5517 
5518  case 0xC9: // House name
5519  if (_cur.grffile->housespec == NULL || _cur.grffile->housespec[GB(id, 0, 8)] == NULL) {
5520  grfmsg(1, "FeatureNewName: Attempt to name undefined house 0x%X, ignoring.", GB(id, 0, 8));
5521  } else {
5522  _cur.grffile->housespec[GB(id, 0, 8)]->building_name = AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
5523  }
5524  break;
5525 
5526  default:
5527  grfmsg(7, "FeatureNewName: Unsupported ID (0x%04X)", id);
5528  break;
5529  }
5530  break;
5531  }
5532  }
5533 }
5534 
5543 static uint16 SanitizeSpriteOffset(uint16& num, uint16 offset, int max_sprites, const char *name)
5544 {
5545 
5546  if (offset >= max_sprites) {
5547  grfmsg(1, "GraphicsNew: %s sprite offset must be less than %i, skipping", name, max_sprites);
5548  uint orig_num = num;
5549  num = 0;
5550  return orig_num;
5551  }
5552 
5553  if (offset + num > max_sprites) {
5554  grfmsg(4, "GraphicsNew: %s sprite overflow, truncating...", name);
5555  uint orig_num = num;
5556  num = max(max_sprites - offset, 0);
5557  return orig_num - num;
5558  }
5559 
5560  return 0;
5561 }
5562 
5563 
5569 };
5571 struct Action5Type {
5574  uint16 min_sprites;
5575  uint16 max_sprites;
5576  const char *name;
5577 };
5578 
5580 static const Action5Type _action5_types[] = {
5581  /* Note: min_sprites should not be changed. Therefore these constants are directly here and not in sprites.h */
5582  /* 0x00 */ { A5BLOCK_INVALID, 0, 0, 0, "Type 0x00" },
5583  /* 0x01 */ { A5BLOCK_INVALID, 0, 0, 0, "Type 0x01" },
5584  /* 0x02 */ { A5BLOCK_INVALID, 0, 0, 0, "Type 0x02" },
5585  /* 0x03 */ { A5BLOCK_INVALID, 0, 0, 0, "Type 0x03" },
5586  /* 0x04 */ { A5BLOCK_ALLOW_OFFSET, SPR_SIGNALS_BASE, 1, PRESIGNAL_SEMAPHORE_AND_PBS_SPRITE_COUNT, "Signal graphics" },
5587  /* 0x05 */ { A5BLOCK_ALLOW_OFFSET, SPR_ELRAIL_BASE, 1, ELRAIL_SPRITE_COUNT, "Rail catenary graphics" },
5588  /* 0x06 */ { A5BLOCK_ALLOW_OFFSET, SPR_SLOPES_BASE, 1, NORMAL_AND_HALFTILE_FOUNDATION_SPRITE_COUNT, "Foundation graphics" },
5589  /* 0x07 */ { A5BLOCK_INVALID, 0, 75, 0, "TTDP GUI graphics" }, // Not used by OTTD.
5590  /* 0x08 */ { A5BLOCK_ALLOW_OFFSET, SPR_CANALS_BASE, 1, CANALS_SPRITE_COUNT, "Canal graphics" },
5591  /* 0x09 */ { A5BLOCK_ALLOW_OFFSET, SPR_ONEWAY_BASE, 1, ONEWAY_SPRITE_COUNT, "One way road graphics" },
5592  /* 0x0A */ { A5BLOCK_ALLOW_OFFSET, SPR_2CCMAP_BASE, 1, TWOCCMAP_SPRITE_COUNT, "2CC colour maps" },
5593  /* 0x0B */ { A5BLOCK_ALLOW_OFFSET, SPR_TRAMWAY_BASE, 1, TRAMWAY_SPRITE_COUNT, "Tramway graphics" },
5594  /* 0x0C */ { A5BLOCK_INVALID, 0, 133, 0, "Snowy temperate tree" }, // Not yet used by OTTD.
5595  /* 0x0D */ { A5BLOCK_FIXED, SPR_SHORE_BASE, 16, SPR_SHORE_SPRITE_COUNT, "Shore graphics" },
5596  /* 0x0E */ { A5BLOCK_INVALID, 0, 0, 0, "New Signals graphics" }, // Not yet used by OTTD.
5597  /* 0x0F */ { A5BLOCK_ALLOW_OFFSET, SPR_TRACKS_FOR_SLOPES_BASE, 1, TRACKS_FOR_SLOPES_SPRITE_COUNT, "Sloped rail track" },
5598  /* 0x10 */ { A5BLOCK_ALLOW_OFFSET, SPR_AIRPORTX_BASE, 1, AIRPORTX_SPRITE_COUNT, "Airport graphics" },
5599  /* 0x11 */ { A5BLOCK_ALLOW_OFFSET, SPR_ROADSTOP_BASE, 1, ROADSTOP_SPRITE_COUNT, "Road stop graphics" },
5600  /* 0x12 */ { A5BLOCK_ALLOW_OFFSET, SPR_AQUEDUCT_BASE, 1, AQUEDUCT_SPRITE_COUNT, "Aqueduct graphics" },
5601  /* 0x13 */ { A5BLOCK_ALLOW_OFFSET, SPR_AUTORAIL_BASE, 1, AUTORAIL_SPRITE_COUNT, "Autorail graphics" },
5602  /* 0x14 */ { A5BLOCK_ALLOW_OFFSET, SPR_FLAGS_BASE, 1, FLAGS_SPRITE_COUNT, "Flag graphics" },
5603  /* 0x15 */ { A5BLOCK_ALLOW_OFFSET, SPR_OPENTTD_BASE, 1, OPENTTD_SPRITE_COUNT, "OpenTTD GUI graphics" },
5604  /* 0x16 */ { A5BLOCK_ALLOW_OFFSET, SPR_AIRPORT_PREVIEW_BASE, 1, SPR_AIRPORT_PREVIEW_COUNT, "Airport preview graphics" },
5605  /* 0x17 */ { A5BLOCK_ALLOW_OFFSET, SPR_RAILTYPE_TUNNEL_BASE, 1, RAILTYPE_TUNNEL_BASE_COUNT, "Railtype tunnel base" },
5606  /* 0x18 */ { A5BLOCK_ALLOW_OFFSET, SPR_PALETTE_BASE, 1, PALETTE_SPRITE_COUNT, "Palette" },
5607 };
5608 
5609 /* Action 0x05 */
5610 static void GraphicsNew(ByteReader *buf)
5611 {
5612  /* <05> <graphics-type> <num-sprites> <other data...>
5613  *
5614  * B graphics-type What set of graphics the sprites define.
5615  * E num-sprites How many sprites are in this set?
5616  * V other data Graphics type specific data. Currently unused. */
5617  /* TODO */
5618 
5619  uint8 type = buf->ReadByte();
5620  uint16 num = buf->ReadExtendedByte();
5621  uint16 offset = HasBit(type, 7) ? buf->ReadExtendedByte() : 0;
5622  ClrBit(type, 7); // Clear the high bit as that only indicates whether there is an offset.
5623 
5624  if ((type == 0x0D) && (num == 10) && HasBit(_cur.grfconfig->flags, GCF_SYSTEM)) {
5625  /* Special not-TTDP-compatible case used in openttd.grf
5626  * Missing shore sprites and initialisation of SPR_SHORE_BASE */
5627  grfmsg(2, "GraphicsNew: Loading 10 missing shore sprites from extra grf.");
5628  LoadNextSprite(SPR_SHORE_BASE + 0, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_STEEP_S
5629  LoadNextSprite(SPR_SHORE_BASE + 5, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_STEEP_W
5630  LoadNextSprite(SPR_SHORE_BASE + 7, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_WSE
5631  LoadNextSprite(SPR_SHORE_BASE + 10, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_STEEP_N
5632  LoadNextSprite(SPR_SHORE_BASE + 11, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_NWS
5633  LoadNextSprite(SPR_SHORE_BASE + 13, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_ENW
5634  LoadNextSprite(SPR_SHORE_BASE + 14, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_SEN
5635  LoadNextSprite(SPR_SHORE_BASE + 15, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_STEEP_E
5636  LoadNextSprite(SPR_SHORE_BASE + 16, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_EW
5637  LoadNextSprite(SPR_SHORE_BASE + 17, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_NS
5638  if (_loaded_newgrf_features.shore == SHORE_REPLACE_NONE) _loaded_newgrf_features.shore = SHORE_REPLACE_ONLY_NEW;
5639  return;
5640  }
5641 
5642  /* Supported type? */
5643  if ((type >= lengthof(_action5_types)) || (_action5_types[type].block_type == A5BLOCK_INVALID)) {
5644  grfmsg(2, "GraphicsNew: Custom graphics (type 0x%02X) sprite block of length %u (unimplemented, ignoring)", type, num);
5645  _cur.skip_sprites = num;
5646  return;
5647  }
5648 
5649  const Action5Type *action5_type = &_action5_types[type];
5650 
5651  /* Contrary to TTDP we allow always to specify too few sprites as we allow always an offset,
5652  * except for the long version of the shore type:
5653  * Ignore offset if not allowed */
5654  if ((action5_type->block_type != A5BLOCK_ALLOW_OFFSET) && (offset != 0)) {
5655  grfmsg(1, "GraphicsNew: %s (type 0x%02X) do not allow an <offset> field. Ignoring offset.", action5_type->name, type);
5656  offset = 0;
5657  }
5658 
5659  /* Ignore action5 if too few sprites are specified. (for TTDP compatibility)
5660  * This does not make sense, if <offset> is allowed */
5661  if ((action5_type->block_type == A5BLOCK_FIXED) && (num < action5_type->min_sprites)) {
5662  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);
5663  _cur.skip_sprites = num;
5664  return;
5665  }
5666 
5667  /* Load at most max_sprites sprites. Skip remaining sprites. (for compatibility with TTDP and future extentions) */
5668  uint16 skip_num = SanitizeSpriteOffset(num, offset, action5_type->max_sprites, action5_type->name);
5669  SpriteID replace = action5_type->sprite_base + offset;
5670 
5671  /* Load <num> sprites starting from <replace>, then skip <skip_num> sprites. */
5672  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);
5673 
5674  for (; num > 0; num--) {
5675  _cur.nfo_line++;
5676  LoadNextSprite(replace == 0 ? _cur.spriteid++ : replace++, _cur.file_index, _cur.nfo_line, _cur.grf_container_ver);
5677  }
5678 
5679  if (type == 0x0D) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_5;
5680 
5681  _cur.skip_sprites = skip_num;
5682 }
5683 
5684 /* Action 0x05 (SKIP) */
5685 static void SkipAct5(ByteReader *buf)
5686 {
5687  /* Ignore type byte */
5688  buf->ReadByte();
5689 
5690  /* Skip the sprites of this action */
5691  _cur.skip_sprites = buf->ReadExtendedByte();
5692 
5693  grfmsg(3, "SkipAct5: Skipping %d sprites", _cur.skip_sprites);
5694 }
5695 
5707 bool GetGlobalVariable(byte param, uint32 *value, const GRFFile *grffile)
5708 {
5709  switch (param) {
5710  case 0x00: // current date
5711  *value = max(_date - DAYS_TILL_ORIGINAL_BASE_YEAR, 0);
5712  return true;
5713 
5714  case 0x01: // current year
5716  return true;
5717 
5718  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)
5719  YearMonthDay ymd;
5720  ConvertDateToYMD(_date, &ymd);
5721  Date start_of_year = ConvertYMDToDate(ymd.year, 0, 1);
5722  *value = ymd.month | (ymd.day - 1) << 8 | (IsLeapYear(ymd.year) ? 1 << 15 : 0) | (_date - start_of_year) << 16;
5723  return true;
5724  }
5725 
5726  case 0x03: // current climate, 0=temp, 1=arctic, 2=trop, 3=toyland
5728  return true;
5729 
5730  case 0x06: // road traffic side, bit 4 clear=left, set=right
5731  *value = _settings_game.vehicle.road_side << 4;
5732  return true;
5733 
5734  case 0x09: // date fraction
5735  *value = _date_fract * 885;
5736  return true;
5737 
5738  case 0x0A: // animation counter
5739  *value = _tick_counter;
5740  return true;
5741 
5742  case 0x0B: { // TTDPatch version
5743  uint major = 2;
5744  uint minor = 6;
5745  uint revision = 1; // special case: 2.0.1 is 2.0.10
5746  uint build = 1382;
5747  *value = (major << 24) | (minor << 20) | (revision << 16) | build;
5748  return true;
5749  }
5750 
5751  case 0x0D: // TTD Version, 00=DOS, 01=Windows
5752  *value = _cur.grfconfig->palette & GRFP_USE_MASK;
5753  return true;
5754 
5755  case 0x0E: // Y-offset for train sprites
5756  *value = _cur.grffile->traininfo_vehicle_pitch;
5757  return true;
5758 
5759  case 0x0F: // Rail track type cost factors
5760  *value = 0;
5761  SB(*value, 0, 8, GetRailTypeInfo(RAILTYPE_RAIL)->cost_multiplier); // normal rail
5763  /* skip elrail multiplier - disabled */
5764  SB(*value, 8, 8, GetRailTypeInfo(RAILTYPE_MONO)->cost_multiplier); // monorail
5765  } else {
5766  SB(*value, 8, 8, GetRailTypeInfo(RAILTYPE_ELECTRIC)->cost_multiplier); // electified railway
5767  /* Skip monorail multiplier - no space in result */
5768  }
5769  SB(*value, 16, 8, GetRailTypeInfo(RAILTYPE_MAGLEV)->cost_multiplier); // maglev
5770  return true;
5771 
5772  case 0x11: // current rail tool type
5773  *value = 0; // constant fake value to avoid desync
5774  return true;
5775 
5776  case 0x12: // Game mode
5777  *value = _game_mode;
5778  return true;
5779 
5780  /* case 0x13: // Tile refresh offset to left not implemented */
5781  /* case 0x14: // Tile refresh offset to right not implemented */
5782  /* case 0x15: // Tile refresh offset upwards not implemented */
5783  /* case 0x16: // Tile refresh offset downwards not implemented */
5784  /* case 0x17: // temperate snow line not implemented */
5785 
5786  case 0x1A: // Always -1
5787  *value = UINT_MAX;
5788  return true;
5789 
5790  case 0x1B: // Display options
5791  *value = 0x3F; // constant fake value to avoid desync
5792  return true;
5793 
5794  case 0x1D: // TTD Platform, 00=TTDPatch, 01=OpenTTD
5795  *value = 1;
5796  return true;
5797 
5798  case 0x1E: // Miscellaneous GRF features
5799  *value = _misc_grf_features;
5800 
5801  /* Add the local flags */
5802  assert(!HasBit(*value, GMB_TRAIN_WIDTH_32_PIXELS));
5803  if (_cur.grffile->traininfo_vehicle_width == VEHICLEINFO_FULL_VEHICLE_WIDTH) SetBit(*value, GMB_TRAIN_WIDTH_32_PIXELS);
5804  return true;
5805 
5806  /* case 0x1F: // locale dependent settings not implemented to avoid desync */
5807 
5808  case 0x20: { // snow line height
5809  byte snowline = GetSnowLine();
5811  *value = Clamp(snowline * (grffile->grf_version >= 8 ? 1 : TILE_HEIGHT), 0, 0xFE);
5812  } else {
5813  /* No snow */
5814  *value = 0xFF;
5815  }
5816  return true;
5817  }
5818 
5819  case 0x21: // OpenTTD version
5820  *value = _openttd_newgrf_version;
5821  return true;
5822 
5823  case 0x22: // difficulty level
5824  *value = SP_CUSTOM;
5825  return true;
5826 
5827  case 0x23: // long format date
5828  *value = _date;
5829  return true;
5830 
5831  case 0x24: // long format year
5832  *value = _cur_year;
5833  return true;
5834 
5835  default: return false;
5836  }
5837 }
5838 
5839 static uint32 GetParamVal(byte param, uint32 *cond_val)
5840 {
5841  /* First handle variable common with VarAction2 */
5842  uint32 value;
5843  if (GetGlobalVariable(param - 0x80, &value, _cur.grffile)) return value;
5844 
5845  /* Non-common variable */
5846  switch (param) {
5847  case 0x84: { // GRF loading stage
5848  uint32 res = 0;
5849 
5850  if (_cur.stage > GLS_INIT) SetBit(res, 0);
5851  if (_cur.stage == GLS_RESERVE) SetBit(res, 8);
5852  if (_cur.stage == GLS_ACTIVATION) SetBit(res, 9);
5853  return res;
5854  }
5855 
5856  case 0x85: // TTDPatch flags, only for bit tests
5857  if (cond_val == NULL) {
5858  /* Supported in Action 0x07 and 0x09, not 0x0D */
5859  return 0;
5860  } else {
5861  uint32 param_val = _ttdpatch_flags[*cond_val / 0x20];
5862  *cond_val %= 0x20;
5863  return param_val;
5864  }
5865 
5866  case 0x88: // GRF ID check
5867  return 0;
5868 
5869  /* case 0x99: Global ID offset not implemented */
5870 
5871  default:
5872  /* GRF Parameter */
5873  if (param < 0x80) return _cur.grffile->GetParam(param);
5874 
5875  /* In-game variable. */
5876  grfmsg(1, "Unsupported in-game variable 0x%02X", param);
5877  return UINT_MAX;
5878  }
5879 }
5880 
5881 /* Action 0x06 */
5882 static void CfgApply(ByteReader *buf)
5883 {
5884  /* <06> <param-num> <param-size> <offset> ... <FF>
5885  *
5886  * B param-num Number of parameter to substitute (First = "zero")
5887  * Ignored if that parameter was not specified in newgrf.cfg
5888  * B param-size How many bytes to replace. If larger than 4, the
5889  * bytes of the following parameter are used. In that
5890  * case, nothing is applied unless *all* parameters
5891  * were specified.
5892  * B offset Offset into data from beginning of next sprite
5893  * to place where parameter is to be stored. */
5894 
5895  /* Preload the next sprite */
5896  size_t pos = FioGetPos();
5897  uint32 num = _cur.grf_container_ver >= 2 ? FioReadDword() : FioReadWord();
5898  uint8 type = FioReadByte();
5899  byte *preload_sprite = NULL;
5900 
5901  /* Check if the sprite is a pseudo sprite. We can't operate on real sprites. */
5902  if (type == 0xFF) {
5903  preload_sprite = MallocT<byte>(num);
5904  FioReadBlock(preload_sprite, num);
5905  }
5906 
5907  /* Reset the file position to the start of the next sprite */
5908  FioSeekTo(pos, SEEK_SET);
5909 
5910  if (type != 0xFF) {
5911  grfmsg(2, "CfgApply: Ignoring (next sprite is real, unsupported)");
5912  free(preload_sprite);
5913  return;
5914  }
5915 
5916  GRFLocation location(_cur.grfconfig->ident.grfid, _cur.nfo_line + 1);
5917  GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.find(location);
5918  if (it != _grf_line_to_action6_sprite_override.end()) {
5919  free(preload_sprite);
5920  preload_sprite = _grf_line_to_action6_sprite_override[location];
5921  } else {
5922  _grf_line_to_action6_sprite_override[location] = preload_sprite;
5923  }
5924 
5925  /* Now perform the Action 0x06 on our data. */
5926 
5927  for (;;) {
5928  uint i;
5929  uint param_num;
5930  uint param_size;
5931  uint offset;
5932  bool add_value;
5933 
5934  /* Read the parameter to apply. 0xFF indicates no more data to change. */
5935  param_num = buf->ReadByte();
5936  if (param_num == 0xFF) break;
5937 
5938  /* Get the size of the parameter to use. If the size covers multiple
5939  * double words, sequential parameter values are used. */
5940  param_size = buf->ReadByte();
5941 
5942  /* Bit 7 of param_size indicates we should add to the original value
5943  * instead of replacing it. */
5944  add_value = HasBit(param_size, 7);
5945  param_size = GB(param_size, 0, 7);
5946 
5947  /* Where to apply the data to within the pseudo sprite data. */
5948  offset = buf->ReadExtendedByte();
5949 
5950  /* If the parameter is a GRF parameter (not an internal variable) check
5951  * if it (and all further sequential parameters) has been defined. */
5952  if (param_num < 0x80 && (param_num + (param_size - 1) / 4) >= _cur.grffile->param_end) {
5953  grfmsg(2, "CfgApply: Ignoring (param %d not set)", (param_num + (param_size - 1) / 4));
5954  break;
5955  }
5956 
5957  grfmsg(8, "CfgApply: Applying %u bytes from parameter 0x%02X at offset 0x%04X", param_size, param_num, offset);
5958 
5959  bool carry = false;
5960  for (i = 0; i < param_size && offset + i < num; i++) {
5961  uint32 value = GetParamVal(param_num + i / 4, NULL);
5962  /* Reset carry flag for each iteration of the variable (only really
5963  * matters if param_size is greater than 4) */
5964  if (i % 4 == 0) carry = false;
5965 
5966  if (add_value) {
5967  uint new_value = preload_sprite[offset + i] + GB(value, (i % 4) * 8, 8) + (carry ? 1 : 0);
5968  preload_sprite[offset + i] = GB(new_value, 0, 8);
5969  /* Check if the addition overflowed */
5970  carry = new_value >= 256;
5971  } else {
5972  preload_sprite[offset + i] = GB(value, (i % 4) * 8, 8);
5973  }
5974  }
5975  }
5976 }
5977 
5988 {
5989  GRFError *error = DisableGrf(STR_NEWGRF_ERROR_STATIC_GRF_CAUSES_DESYNC, c);
5990  error->data = stredup(_cur.grfconfig->GetName());
5991 }
5992 
5993 /* Action 0x07
5994  * Action 0x09 */
5995 static void SkipIf(ByteReader *buf)
5996 {
5997  /* <07/09> <param-num> <param-size> <condition-type> <value> <num-sprites>
5998  *
5999  * B param-num
6000  * B param-size
6001  * B condition-type
6002  * V value
6003  * B num-sprites */
6004  /* TODO: More params. More condition types. */
6005  uint32 cond_val = 0;
6006  uint32 mask = 0;
6007  bool result;
6008 
6009  uint8 param = buf->ReadByte();
6010  uint8 paramsize = buf->ReadByte();
6011  uint8 condtype = buf->ReadByte();
6012 
6013  if (condtype < 2) {
6014  /* Always 1 for bit tests, the given value should be ignored. */
6015  paramsize = 1;
6016  }
6017 
6018  switch (paramsize) {
6019  case 8: cond_val = buf->ReadDWord(); mask = buf->ReadDWord(); break;
6020  case 4: cond_val = buf->ReadDWord(); mask = 0xFFFFFFFF; break;
6021  case 2: cond_val = buf->ReadWord(); mask = 0x0000FFFF; break;
6022  case 1: cond_val = buf->ReadByte(); mask = 0x000000FF; break;
6023  default: break;
6024  }
6025 
6026  if (param < 0x80 && _cur.grffile->param_end <= param) {
6027  grfmsg(7, "SkipIf: Param %d undefined, skipping test", param);
6028  return;
6029  }
6030 
6031  uint32 param_val = GetParamVal(param, &cond_val);
6032 
6033  grfmsg(7, "SkipIf: Test condtype %d, param 0x%08X, condval 0x%08X", condtype, param_val, cond_val);
6034 
6035  /*
6036  * Parameter (variable in specs) 0x88 can only have GRF ID checking
6037  * conditions, except conditions 0x0B, 0x0C (cargo availability) and
6038  * 0x0D, 0x0E (Rail type availability) as those ignore the parameter.
6039  * So, when the condition type is one of those, the specific variable
6040  * 0x88 code is skipped, so the "general" code for the cargo
6041  * availability conditions kicks in.
6042  */
6043  if (param == 0x88 && (condtype < 0x0B || condtype > 0x0E)) {
6044  /* GRF ID checks */
6045 
6046  GRFConfig *c = GetGRFConfig(cond_val, mask);
6047 
6048  if (c != NULL && HasBit(c->flags, GCF_STATIC) && !HasBit(_cur.grfconfig->flags, GCF_STATIC) && _networking) {
6050  c = NULL;
6051  }
6052 
6053  if (condtype != 10 && c == NULL) {
6054  grfmsg(7, "SkipIf: GRFID 0x%08X unknown, skipping test", BSWAP32(cond_val));
6055  return;
6056  }
6057 
6058  switch (condtype) {
6059  /* Tests 0x06 to 0x0A are only for param 0x88, GRFID checks */
6060  case 0x06: // Is GRFID active?
6061  result = c->status == GCS_ACTIVATED;
6062  break;
6063 
6064  case 0x07: // Is GRFID non-active?
6065  result = c->status != GCS_ACTIVATED;
6066  break;
6067 
6068  case 0x08: // GRFID is not but will be active?
6069  result = c->status == GCS_INITIALISED;
6070  break;
6071 
6072  case 0x09: // GRFID is or will be active?
6073  result = c->status == GCS_ACTIVATED || c->status == GCS_INITIALISED;
6074  break;
6075 
6076  case 0x0A: // GRFID is not nor will be active
6077  /* This is the only condtype that doesn't get ignored if the GRFID is not found */
6078  result = c == NULL || c->status == GCS_DISABLED || c->status == GCS_NOT_FOUND;
6079  break;
6080 
6081  default: grfmsg(1, "SkipIf: Unsupported GRF condition type %02X. Ignoring", condtype); return;
6082  }
6083  } else {
6084  /* Parameter or variable tests */
6085  switch (condtype) {
6086  case 0x00: result = !!(param_val & (1 << cond_val));
6087  break;
6088  case 0x01: result = !(param_val & (1 << cond_val));
6089  break;
6090  case 0x02: result = (param_val & mask) == cond_val;
6091  break;
6092  case 0x03: result = (param_val & mask) != cond_val;
6093  break;
6094  case 0x04: result = (param_val & mask) < cond_val;
6095  break;
6096  case 0x05: result = (param_val & mask) > cond_val;
6097  break;
6098  case 0x0B: result = GetCargoIDByLabel(BSWAP32(cond_val)) == CT_INVALID;
6099  break;
6100  case 0x0C: result = GetCargoIDByLabel(BSWAP32(cond_val)) != CT_INVALID;
6101  break;
6102  case 0x0D: result = GetRailTypeByLabel(BSWAP32(cond_val)) == INVALID_RAILTYPE;
6103  break;
6104  case 0x0E: result = GetRailTypeByLabel(BSWAP32(cond_val)) != INVALID_RAILTYPE;
6105  break;
6106 
6107  default: grfmsg(1, "SkipIf: Unsupported condition type %02X. Ignoring", condtype); return;
6108  }
6109  }
6110 
6111  if (!result) {
6112  grfmsg(2, "SkipIf: Not skipping sprites, test was false");
6113  return;
6114  }
6115 
6116  uint8 numsprites = buf->ReadByte();
6117 
6118  /* numsprites can be a GOTO label if it has been defined in the GRF
6119  * file. The jump will always be the first matching label that follows
6120  * the current nfo_line. If no matching label is found, the first matching
6121  * label in the file is used. */
6122  GRFLabel *choice = NULL;
6123  for (GRFLabel *label = _cur.grffile->label; label != NULL; label = label->next) {
6124  if (label->label != numsprites) continue;
6125 
6126  /* Remember a goto before the current line */
6127  if (choice == NULL) choice = label;
6128  /* If we find a label here, this is definitely good */
6129  if (label->nfo_line > _cur.nfo_line) {
6130  choice = label;
6131  break;
6132  }
6133  }
6134 
6135  if (choice != NULL) {
6136  grfmsg(2, "SkipIf: Jumping to label 0x%0X at line %d, test was true", choice->label, choice->nfo_line);
6137  FioSeekTo(choice->pos, SEEK_SET);
6138  _cur.nfo_line = choice->nfo_line;
6139  return;
6140  }
6141 
6142  grfmsg(2, "SkipIf: Skipping %d sprites, test was true", numsprites);
6143  _cur.skip_sprites = numsprites;
6144  if (_cur.skip_sprites == 0) {
6145  /* Zero means there are no sprites to skip, so
6146  * we use -1 to indicate that all further
6147  * sprites should be skipped. */
6148  _cur.skip_sprites = -1;
6149 
6150  /* If an action 8 hasn't been encountered yet, disable the grf. */
6151  if (_cur.grfconfig->status != (_cur.stage < GLS_RESERVE ? GCS_INITIALISED : GCS_ACTIVATED)) {
6152  DisableGrf();
6153  }
6154  }
6155 }
6156 
6157 
6158 /* Action 0x08 (GLS_FILESCAN) */
6159 static void ScanInfo(ByteReader *buf)
6160 {
6161  uint8 grf_version = buf->ReadByte();
6162  uint32 grfid = buf->ReadDWord();
6163  const char *name = buf->ReadString();
6164 
6165  _cur.grfconfig->ident.grfid = grfid;
6166 
6167  if (grf_version < 2 || grf_version > 8) {
6169  DEBUG(grf, 0, "%s: NewGRF \"%s\" (GRFID %08X) uses GRF version %d, which is incompatible with this version of OpenTTD.", _cur.grfconfig->filename, name, BSWAP32(grfid), grf_version);
6170  }
6171 
6172  /* GRF IDs starting with 0xFF are reserved for internal TTDPatch use */
6173  if (GB(grfid, 0, 8) == 0xFF) SetBit(_cur.grfconfig->flags, GCF_SYSTEM);
6174 
6175  AddGRFTextToList(&_cur.grfconfig->name->text, 0x7F, grfid, false, name);
6176 
6177  if (buf->HasData()) {
6178  const char *info = buf->ReadString();
6179  AddGRFTextToList(&_cur.grfconfig->info->text, 0x7F, grfid, true, info);
6180  }
6181 
6182  /* GLS_INFOSCAN only looks for the action 8, so we can skip the rest of the file */
6183  _cur.skip_sprites = -1;
6184 }
6185 
6186 /* Action 0x08 */
6187 static void GRFInfo(ByteReader *buf)
6188 {
6189  /* <08> <version> <grf-id> <name> <info>
6190  *
6191  * B version newgrf version, currently 06
6192  * 4*B grf-id globally unique ID of this .grf file
6193  * S name name of this .grf set
6194  * S info string describing the set, and e.g. author and copyright */
6195 
6196  uint8 version = buf->ReadByte();
6197  uint32 grfid = buf->ReadDWord();
6198  const char *name = buf->ReadString();
6199 
6200  if (_cur.stage < GLS_RESERVE && _cur.grfconfig->status != GCS_UNKNOWN) {
6201  DisableGrf(STR_NEWGRF_ERROR_MULTIPLE_ACTION_8);
6202  return;
6203  }
6204 
6205  if (_cur.grffile->grfid != grfid) {
6206  DEBUG(grf, 0, "GRFInfo: GRFID %08X in FILESCAN stage does not match GRFID %08X in INIT/RESERVE/ACTIVATION stage", BSWAP32(_cur.grffile->grfid), BSWAP32(grfid));
6207  _cur.grffile->grfid = grfid;
6208  }
6209 
6210  _cur.grffile->grf_version = version;
6211  _cur.grfconfig->status = _cur.stage < GLS_RESERVE ? GCS_INITIALISED : GCS_ACTIVATED;
6212 
6213  /* Do swap the GRFID for displaying purposes since people expect that */
6214  DEBUG(grf, 1, "GRFInfo: Loaded GRFv%d set %08X - %s (palette: %s, version: %i)", version, BSWAP32(grfid), name, (_cur.grfconfig->palette & GRFP_USE_MASK) ? "Windows" : "DOS", _cur.grfconfig->version);
6215 }
6216 
6217 /* Action 0x0A */
6218 static void SpriteReplace(ByteReader *buf)
6219 {
6220  /* <0A> <num-sets> <set1> [<set2> ...]
6221  * <set>: <num-sprites> <first-sprite>
6222  *
6223  * B num-sets How many sets of sprites to replace.
6224  * Each set:
6225  * B num-sprites How many sprites are in this set
6226  * W first-sprite First sprite number to replace */
6227 
6228  uint8 num_sets = buf->ReadByte();
6229 
6230  for (uint i = 0; i < num_sets; i++) {
6231  uint8 num_sprites = buf->ReadByte();
6232  uint16 first_sprite = buf->ReadWord();
6233 
6234  grfmsg(2, "SpriteReplace: [Set %d] Changing %d sprites, beginning with %d",
6235  i, num_sprites, first_sprite
6236  );
6237 
6238  for (uint j = 0; j < num_sprites; j++) {
6239  int load_index = first_sprite + j;
6240  _cur.nfo_line++;
6241  LoadNextSprite(load_index, _cur.file_index, _cur.nfo_line, _cur.grf_container_ver); // XXX
6242 
6243  /* Shore sprites now located at different addresses.
6244  * So detect when the old ones get replaced. */
6245  if (IsInsideMM(load_index, SPR_ORIGINALSHORE_START, SPR_ORIGINALSHORE_END + 1)) {
6246  if (_loaded_newgrf_features.shore != SHORE_REPLACE_ACTION_5) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_A;
6247  }
6248  }
6249  }
6250 }
6251 
6252 /* Action 0x0A (SKIP) */
6253 static void SkipActA(ByteReader *buf)
6254 {
6255  uint8 num_sets = buf->ReadByte();
6256 
6257  for (uint i = 0; i < num_sets; i++) {
6258  /* Skip the sprites this replaces */
6259  _cur.skip_sprites += buf->ReadByte();
6260  /* But ignore where they go */
6261  buf->ReadWord();
6262  }
6263 
6264  grfmsg(3, "SkipActA: Skipping %d sprites", _cur.skip_sprites);
6265 }
6266 
6267 /* Action 0x0B */
6268 static void GRFLoadError(ByteReader *buf)
6269 {
6270  /* <0B> <severity> <language-id> <message-id> [<message...> 00] [<data...>] 00 [<parnum>]
6271  *
6272  * B severity 00: notice, contine loading grf file
6273  * 01: warning, continue loading grf file
6274  * 02: error, but continue loading grf file, and attempt
6275  * loading grf again when loading or starting next game
6276  * 03: error, abort loading and prevent loading again in
6277  * the future (only when restarting the patch)
6278  * B language-id see action 4, use 1F for built-in error messages
6279  * B message-id message to show, see below
6280  * S message for custom messages (message-id FF), text of the message
6281  * not present for built-in messages.
6282  * V data additional data for built-in (or custom) messages
6283  * B parnum parameter numbers to be shown in the message (maximum of 2) */
6284 
6285  static const StringID msgstr[] = {
6286  STR_NEWGRF_ERROR_VERSION_NUMBER,
6287  STR_NEWGRF_ERROR_DOS_OR_WINDOWS,
6288  STR_NEWGRF_ERROR_UNSET_SWITCH,
6289  STR_NEWGRF_ERROR_INVALID_PARAMETER,
6290  STR_NEWGRF_ERROR_LOAD_BEFORE,
6291  STR_NEWGRF_ERROR_LOAD_AFTER,
6292  STR_NEWGRF_ERROR_OTTD_VERSION_NUMBER,
6293  };
6294 
6295  static const StringID sevstr[] = {
6296  STR_NEWGRF_ERROR_MSG_INFO,
6297  STR_NEWGRF_ERROR_MSG_WARNING,
6298  STR_NEWGRF_ERROR_MSG_ERROR,
6299  STR_NEWGRF_ERROR_MSG_FATAL
6300  };
6301 
6302  byte severity = buf->ReadByte();
6303  byte lang = buf->ReadByte();
6304  byte message_id = buf->ReadByte();
6305 
6306  /* Skip the error if it isn't valid for the current language. */
6307  if (!CheckGrfLangID(lang, _cur.grffile->grf_version)) return;
6308 
6309  /* Skip the error until the activation stage unless bit 7 of the severity
6310  * is set. */
6311  if (!HasBit(severity, 7) && _cur.stage == GLS_INIT) {
6312  grfmsg(7, "GRFLoadError: Skipping non-fatal GRFLoadError in stage %d", _cur.stage);
6313  return;
6314  }
6315  ClrBit(severity, 7);
6316 
6317  if (severity >= lengthof(sevstr)) {
6318  grfmsg(7, "GRFLoadError: Invalid severity id %d. Setting to 2 (non-fatal error).", severity);
6319  severity = 2;
6320  } else if (severity == 3) {
6321  /* This is a fatal error, so make sure the GRF is deactivated and no
6322  * more of it gets loaded. */
6323  DisableGrf();
6324 
6325  /* Make sure we show fatal errors, instead of silly infos from before */
6326  delete _cur.grfconfig->error;
6327  _cur.grfconfig->error = NULL;
6328  }
6329 
6330  if (message_id >= lengthof(msgstr) && message_id != 0xFF) {
6331  grfmsg(7, "GRFLoadError: Invalid message id.");
6332  return;
6333  }
6334 
6335  if (buf->Remaining() <= 1) {
6336  grfmsg(7, "GRFLoadError: No message data supplied.");
6337  return;
6338  }
6339 
6340  /* For now we can only show one message per newgrf file. */
6341  if (_cur.grfconfig->error != NULL) return;
6342 
6343  GRFError *error = new GRFError(sevstr[severity]);
6344 
6345  if (message_id == 0xFF) {
6346  /* This is a custom error message. */
6347  if (buf->HasData()) {
6348  const char *message = buf->ReadString();
6349 
6350  error->custom_message = TranslateTTDPatchCodes(_cur.grffile->grfid, lang, true, message, NULL, SCC_RAW_STRING_POINTER);
6351  } else {
6352  grfmsg(7, "GRFLoadError: No custom message supplied.");
6353  error->custom_message = stredup("");
6354  }
6355  } else {
6356  error->message = msgstr[message_id];
6357  }
6358 
6359  if (buf->HasData()) {
6360  const char *data = buf->ReadString();
6361 
6362  error->data = TranslateTTDPatchCodes(_cur.grffile->grfid, lang, true, data);
6363  } else {
6364  grfmsg(7, "GRFLoadError: No message data supplied.");
6365  error->data = stredup("");
6366  }
6367 
6368  /* Only two parameter numbers can be used in the string. */
6369  for (uint i = 0; i < lengthof(error->param_value) && buf->HasData(); i++) {
6370  uint param_number = buf->ReadByte();
6371  error->param_value[i] = _cur.grffile->GetParam(param_number);
6372  }
6373 
6374  _cur.grfconfig->error = error;
6375 }
6376 
6377 /* Action 0x0C */
6378 static void GRFComment(ByteReader *buf)
6379 {
6380  /* <0C> [<ignored...>]
6381  *
6382  * V ignored Anything following the 0C is ignored */
6383 
6384  if (!buf->HasData()) return;
6385 
6386  const char *text = buf->ReadString();
6387  grfmsg(2, "GRFComment: %s", text);
6388 }
6389 
6390 /* Action 0x0D (GLS_SAFETYSCAN) */
6391 static void SafeParamSet(ByteReader *buf)
6392 {
6393  uint8 target = buf->ReadByte();
6394 
6395  /* Writing GRF parameters and some bits of 'misc GRF features' are safe. */
6396  if (target < 0x80 || target == 0x9E) return;
6397 
6398  /* GRM could be unsafe, but as here it can only happen after other GRFs
6399  * are loaded, it should be okay. If the GRF tried to use the slots it
6400  * reserved, it would be marked unsafe anyway. GRM for (e.g. bridge)
6401  * sprites is considered safe. */
6402 
6403  SetBit(_cur.grfconfig->flags, GCF_UNSAFE);
6404 
6405  /* Skip remainder of GRF */
6406  _cur.skip_sprites = -1;
6407 }
6408 
6409 
6410 static uint32 GetPatchVariable(uint8 param)
6411 {
6412  switch (param) {
6413  /* start year - 1920 */
6415 
6416  /* freight trains weight factor */
6417  case 0x0E: return _settings_game.vehicle.freight_trains;
6418 
6419  /* empty wagon speed increase */
6420  case 0x0F: return 0;
6421 
6422  /* plane speed factor; our patch option is reversed from TTDPatch's,
6423  * the following is good for 1x, 2x and 4x (most common?) and...
6424  * well not really for 3x. */
6425  case 0x10:
6427  default:
6428  case 4: return 1;
6429  case 3: return 2;
6430  case 2: return 2;
6431  case 1: return 4;
6432  }
6433 
6434 
6435  /* 2CC colourmap base sprite */
6436  case 0x11: return SPR_2CCMAP_BASE;
6437 
6438  /* map size: format = -MABXYSS
6439  * M : the type of map
6440  * bit 0 : set : squared map. Bit 1 is now not relevant
6441  * clear : rectangle map. Bit 1 will indicate the bigger edge of the map
6442  * bit 1 : set : Y is the bigger edge. Bit 0 is clear
6443  * clear : X is the bigger edge.
6444  * A : minimum edge(log2) of the map
6445  * B : maximum edge(log2) of the map
6446  * XY : edges(log2) of each side of the map.
6447  * SS : combination of both X and Y, thus giving the size(log2) of the map
6448  */
6449  case 0x13: {
6450  byte map_bits = 0;
6451  byte log_X = MapLogX() - 6; // substraction is required to make the minimal size (64) zero based
6452  byte log_Y = MapLogY() - 6;
6453  byte max_edge = max(log_X, log_Y);
6454 
6455  if (log_X == log_Y) { // we have a squared map, since both edges are identical
6456  SetBit(map_bits, 0);
6457  } else {
6458  if (max_edge == log_Y) SetBit(map_bits, 1); // edge Y been the biggest, mark it
6459  }
6460 
6461  return (map_bits << 24) | (min(log_X, log_Y) << 20) | (max_edge << 16) |
6462  (log_X << 12) | (log_Y << 8) | (log_X + log_Y);
6463  }
6464 
6465  /* The maximum height of the map. */
6466  case 0x14:
6468 
6469  /* Extra foundations base sprite */
6470  case 0x15:
6471  return SPR_SLOPES_BASE;
6472 
6473  /* Shore base sprite */
6474  case 0x16:
6475  return SPR_SHORE_BASE;
6476 
6477  default:
6478  grfmsg(2, "ParamSet: Unknown Patch variable 0x%02X.", param);
6479  return 0;
6480  }
6481 }
6482 
6483 
6484 static uint32 PerformGRM(uint32 *grm, uint16 num_ids, uint16 count, uint8 op, uint8 target, const char *type)
6485 {
6486  uint start = 0;
6487  uint size = 0;
6488 
6489  if (op == 6) {
6490  /* Return GRFID of set that reserved ID */
6491  return grm[_cur.grffile->GetParam(target)];
6492  }
6493 
6494  /* With an operation of 2 or 3, we want to reserve a specific block of IDs */
6495  if (op == 2 || op == 3) start = _cur.grffile->GetParam(target);
6496 
6497  for (uint i = start; i < num_ids; i++) {
6498  if (grm[i] == 0) {
6499  size++;
6500  } else {
6501  if (op == 2 || op == 3) break;
6502  start = i + 1;
6503  size = 0;
6504  }
6505 
6506  if (size == count) break;
6507  }
6508 
6509  if (size == count) {
6510  /* Got the slot... */
6511  if (op == 0 || op == 3) {
6512  grfmsg(2, "ParamSet: GRM: Reserving %d %s at %d", count, type, start);
6513  for (uint i = 0; i < count; i++) grm[start + i] = _cur.grffile->grfid;
6514  }
6515  return start;
6516  }
6517 
6518  /* Unable to allocate */
6519  if (op != 4 && op != 5) {
6520  /* Deactivate GRF */
6521  grfmsg(0, "ParamSet: GRM: Unable to allocate %d %s, deactivating", count, type);
6522  DisableGrf(STR_NEWGRF_ERROR_GRM_FAILED);
6523  return UINT_MAX;
6524  }
6525 
6526  grfmsg(1, "ParamSet: GRM: Unable to allocate %d %s", count, type);
6527  return UINT_MAX;
6528 }
6529 
6530 
6532 static void ParamSet(ByteReader *buf)
6533 {
6534  /* <0D> <target> <operation> <source1> <source2> [<data>]
6535  *
6536  * B target parameter number where result is stored
6537  * B operation operation to perform, see below
6538  * B source1 first source operand
6539  * B source2 second source operand
6540  * D data data to use in the calculation, not necessary
6541  * if both source1 and source2 refer to actual parameters
6542  *
6543  * Operations
6544  * 00 Set parameter equal to source1
6545  * 01 Addition, source1 + source2
6546  * 02 Subtraction, source1 - source2
6547  * 03 Unsigned multiplication, source1 * source2 (both unsigned)
6548  * 04 Signed multiplication, source1 * source2 (both signed)
6549  * 05 Unsigned bit shift, source1 by source2 (source2 taken to be a
6550  * signed quantity; left shift if positive and right shift if
6551  * negative, source1 is unsigned)
6552  * 06 Signed bit shift, source1 by source2
6553  * (source2 like in 05, and source1 as well)
6554  */
6555 
6556  uint8 target = buf->ReadByte();
6557  uint8 oper = buf->ReadByte();
6558  uint32 src1 = buf->ReadByte();
6559  uint32 src2 = buf->ReadByte();
6560 
6561  uint32 data = 0;
6562  if (buf->Remaining() >= 4) data = buf->ReadDWord();
6563 
6564  /* You can add 80 to the operation to make it apply only if the target
6565  * is not defined yet. In this respect, a parameter is taken to be
6566  * defined if any of the following applies:
6567  * - it has been set to any value in the newgrf(w).cfg parameter list
6568  * - it OR A PARAMETER WITH HIGHER NUMBER has been set to any value by
6569  * an earlier action D */
6570  if (HasBit(oper, 7)) {
6571  if (target < 0x80 && target < _cur.grffile->param_end) {
6572  grfmsg(7, "ParamSet: Param %u already defined, skipping", target);
6573  return;
6574  }
6575 
6576  oper = GB(oper, 0, 7);
6577  }
6578 
6579  if (src2 == 0xFE) {
6580  if (GB(data, 0, 8) == 0xFF) {
6581  if (data == 0x0000FFFF) {
6582  /* Patch variables */
6583  src1 = GetPatchVariable(src1);
6584  } else {
6585  /* GRF Resource Management */
6586  uint8 op = src1;
6587  uint8 feature = GB(data, 8, 8);
6588  uint16 count = GB(data, 16, 16);
6589 
6590  if (_cur.stage == GLS_RESERVE) {
6591  if (feature == 0x08) {
6592  /* General sprites */
6593  if (op == 0) {
6594  /* Check if the allocated sprites will fit below the original sprite limit */
6595  if (_cur.spriteid + count >= 16384) {
6596  grfmsg(0, "ParamSet: GRM: Unable to allocate %d sprites; try changing NewGRF order", count);
6597  DisableGrf(STR_NEWGRF_ERROR_GRM_FAILED);
6598  return;
6599  }
6600 
6601  /* Reserve space at the current sprite ID */
6602  grfmsg(4, "ParamSet: GRM: Allocated %d sprites at %d", count, _cur.spriteid);
6603  _grm_sprites[GRFLocation(_cur.grffile->grfid, _cur.nfo_line)] = _cur.spriteid;
6604  _cur.spriteid += count;
6605  }
6606  }
6607  /* Ignore GRM result during reservation */
6608  src1 = 0;
6609  } else if (_cur.stage == GLS_ACTIVATION) {
6610  switch (feature) {
6611  case 0x00: // Trains
6612  case 0x01: // Road Vehicles
6613  case 0x02: // Ships
6614  case 0x03: // Aircraft
6616  src1 = PerformGRM(&_grm_engines[_engine_offsets[feature]], _engine_counts[feature], count, op, target, "vehicles");
6617  if (_cur.skip_sprites == -1) return;
6618  } else {
6619  /* GRM does not apply for dynamic engine allocation. */
6620  switch (op) {
6621  case 2:
6622  case 3:
6623  src1 = _cur.grffile->GetParam(target);
6624  break;
6625 
6626  default:
6627  src1 = 0;
6628  break;
6629  }
6630  }
6631  break;
6632 
6633  case 0x08: // General sprites
6634  switch (op) {
6635  case 0:
6636  /* Return space reserved during reservation stage */
6637  src1 = _grm_sprites[GRFLocation(_cur.grffile->grfid, _cur.nfo_line)];
6638  grfmsg(4, "ParamSet: GRM: Using pre-allocated sprites at %d", src1);
6639  break;
6640 
6641  case 1:
6642  src1 = _cur.spriteid;
6643  break;
6644 
6645  default:
6646  grfmsg(1, "ParamSet: GRM: Unsupported operation %d for general sprites", op);
6647  return;
6648  }
6649  break;
6650 
6651  case 0x0B: // Cargo
6652  /* There are two ranges: one for cargo IDs and one for cargo bitmasks */
6653  src1 = PerformGRM(_grm_cargoes, NUM_CARGO * 2, count, op, target, "cargoes");
6654  if (_cur.skip_sprites == -1) return;
6655  break;
6656 
6657  default: grfmsg(1, "ParamSet: GRM: Unsupported feature 0x%X", feature); return;
6658  }
6659  } else {
6660  /* Ignore GRM during initialization */
6661  src1 = 0;
6662  }
6663  }
6664  } else {
6665  /* Read another GRF File's parameter */
6666  const GRFFile *file = GetFileByGRFID(data);
6667  GRFConfig *c = GetGRFConfig(data);
6668  if (c != NULL && HasBit(c->flags, GCF_STATIC) && !HasBit(_cur.grfconfig->flags, GCF_STATIC) && _networking) {
6669  /* Disable the read GRF if it is a static NewGRF. */
6671  src1 = 0;
6672  } else if (file == NULL || c == NULL || c->status == GCS_DISABLED) {
6673  src1 = 0;
6674  } else if (src1 == 0xFE) {
6675  src1 = c->version;
6676  } else {
6677  src1 = file->GetParam(src1);
6678  }
6679  }
6680  } else {
6681  /* The source1 and source2 operands refer to the grf parameter number
6682  * like in action 6 and 7. In addition, they can refer to the special
6683  * variables available in action 7, or they can be FF to use the value
6684  * of <data>. If referring to parameters that are undefined, a value
6685  * of 0 is used instead. */
6686  src1 = (src1 == 0xFF) ? data : GetParamVal(src1, NULL);
6687  src2 = (src2 == 0xFF) ? data : GetParamVal(src2, NULL);
6688  }
6689 
6690  /* TODO: You can access the parameters of another GRF file by using
6691  * source2=FE, source1=the other GRF's parameter number and data=GRF
6692  * ID. This is only valid with operation 00 (set). If the GRF ID
6693  * cannot be found, a value of 0 is used for the parameter value
6694  * instead. */
6695 
6696  uint32 res;
6697  switch (oper) {
6698  case 0x00:
6699  res = src1;
6700  break;
6701 
6702  case 0x01:
6703  res = src1 + src2;
6704  break;
6705 
6706  case 0x02:
6707  res = src1 - src2;
6708  break;
6709 
6710  case 0x03:
6711  res = src1 * src2;
6712  break;
6713 
6714  case 0x04:
6715  res = (int32)src1 * (int32)src2;
6716  break;
6717 
6718  case 0x05:
6719  if ((int32)src2 < 0) {
6720  res = src1 >> -(int32)src2;
6721  } else {
6722  res = src1 << (src2 & 0x1F); // Same behaviour as in EvalAdjustT, mask 'value' to 5 bits, which should behave the same on all architectures.
6723  }
6724  break;
6725 
6726  case 0x06:
6727  if ((int32)src2 < 0) {
6728  res = (int32)src1 >> -(int32)src2;
6729  } else {
6730  res = (int32)src1 << (src2 & 0x1F); // Same behaviour as in EvalAdjustT, mask 'value' to 5 bits, which should behave the same on all architectures.
6731  }
6732  break;
6733 
6734  case 0x07: // Bitwise AND
6735  res = src1 & src2;
6736  break;
6737 
6738  case 0x08: // Bitwise OR
6739  res = src1 | src2;
6740  break;
6741 
6742  case 0x09: // Unsigned division
6743  if (src2 == 0) {
6744  res = src1;
6745  } else {
6746  res = src1 / src2;
6747  }
6748  break;
6749 
6750  case 0x0A: // Signed divison
6751  if (src2 == 0) {
6752  res = src1;
6753  } else {
6754  res = (int32)src1 / (int32)src2;
6755  }
6756  break;
6757 
6758  case 0x0B: // Unsigned modulo
6759  if (src2 == 0) {
6760  res = src1;
6761  } else {
6762  res = src1 % src2;
6763  }
6764  break;
6765 
6766  case 0x0C: // Signed modulo
6767  if (src2 == 0) {
6768  res = src1;
6769  } else {
6770  res = (int32)src1 % (int32)src2;
6771  }
6772  break;
6773 
6774  default: grfmsg(0, "ParamSet: Unknown operation %d, skipping", oper); return;
6775  }
6776 
6777  switch (target) {
6778  case 0x8E: // Y-Offset for train sprites
6779  _cur.grffile->traininfo_vehicle_pitch = res;
6780  break;
6781 
6782  case 0x8F: { // Rail track type cost factors
6783  extern RailtypeInfo _railtypes[RAILTYPE_END];
6784  _railtypes[RAILTYPE_RAIL].cost_multiplier = GB(res, 0, 8);
6786  _railtypes[RAILTYPE_ELECTRIC].cost_multiplier = GB(res, 0, 8);
6787  _railtypes[RAILTYPE_MONO].cost_multiplier = GB(res, 8, 8);
6788  } else {
6789  _railtypes[RAILTYPE_ELECTRIC].cost_multiplier = GB(res, 8, 8);
6790  _railtypes[RAILTYPE_MONO].cost_multiplier = GB(res, 16, 8);
6791  }
6792  _railtypes[RAILTYPE_MAGLEV].cost_multiplier = GB(res, 16, 8);
6793  break;
6794  }
6795 
6796  /* @todo implement */
6797  case 0x93: // Tile refresh offset to left
6798  case 0x94: // Tile refresh offset to right
6799  case 0x95: // Tile refresh offset upwards
6800  case 0x96: // Tile refresh offset downwards
6801  case 0x97: // Snow line height
6802  case 0x99: // Global ID offset
6803  grfmsg(7, "ParamSet: Skipping unimplemented target 0x%02X", target);
6804  break;
6805 
6806  case 0x9E: // Miscellaneous GRF features
6807  /* Set train list engine width */
6808  _cur.grffile->traininfo_vehicle_width = HasBit(res, GMB_TRAIN_WIDTH_32_PIXELS) ? VEHICLEINFO_FULL_VEHICLE_WIDTH : TRAININFO_DEFAULT_VEHICLE_WIDTH;
6809  /* Remove the local flags from the global flags */
6811 
6812  /* Only copy safe bits for static grfs */
6813  if (HasBit(_cur.grfconfig->flags, GCF_STATIC)) {
6814  uint32 safe_bits = 0;
6815  SetBit(safe_bits, GMB_SECOND_ROCKY_TILE_SET);
6816 
6817  _misc_grf_features = (_misc_grf_features & ~safe_bits) | (res & safe_bits);
6818  } else {
6819  _misc_grf_features = res;
6820  }
6821  break;
6822 
6823  case 0x9F: // locale-dependent settings
6824  grfmsg(7, "ParamSet: Skipping unimplemented target 0x%02X", target);
6825  break;
6826 
6827  default:
6828  if (target < 0x80) {
6829  _cur.grffile->param[target] = res;
6830  /* param is zeroed by default */
6831  if (target + 1U > _cur.grffile->param_end) _cur.grffile->param_end = target + 1;
6832  } else {
6833  grfmsg(7, "ParamSet: Skipping unknown target 0x%02X", target);
6834  }
6835  break;
6836  }
6837 }
6838 
6839 /* Action 0x0E (GLS_SAFETYSCAN) */
6840 static void SafeGRFInhibit(ByteReader *buf)
6841 {
6842  /* <0E> <num> <grfids...>
6843  *
6844  * B num Number of GRFIDs that follow
6845  * D grfids GRFIDs of the files to deactivate */
6846 
6847  uint8 num = buf->ReadByte();
6848 
6849  for (uint i = 0; i < num; i++) {
6850  uint32 grfid = buf->ReadDWord();
6851 
6852  /* GRF is unsafe it if tries to deactivate other GRFs */
6853  if (grfid != _cur.grfconfig->ident.grfid) {
6854  SetBit(_cur.grfconfig->flags, GCF_UNSAFE);
6855 
6856  /* Skip remainder of GRF */
6857  _cur.skip_sprites = -1;
6858 
6859  return;
6860  }
6861  }
6862 }
6863 
6864 /* Action 0x0E */
6865 static void GRFInhibit(ByteReader *buf)
6866 {
6867  /* <0E> <num> <grfids...>
6868  *
6869  * B num Number of GRFIDs that follow
6870  * D grfids GRFIDs of the files to deactivate */
6871 
6872  uint8 num = buf->ReadByte();
6873 
6874  for (uint i = 0; i < num; i++) {
6875  uint32 grfid = buf->ReadDWord();
6876  GRFConfig *file = GetGRFConfig(grfid);
6877 
6878  /* Unset activation flag */
6879  if (file != NULL && file != _cur.grfconfig) {
6880  grfmsg(2, "GRFInhibit: Deactivating file '%s'", file->filename);
6881  GRFError *error = DisableGrf(STR_NEWGRF_ERROR_FORCEFULLY_DISABLED, file);
6882  error->data = stredup(_cur.grfconfig->GetName());
6883  }
6884  }
6885 }
6886 
6888 static void FeatureTownName(ByteReader *buf)
6889 {
6890  /* <0F> <id> <style-name> <num-parts> <parts>
6891  *
6892  * B id ID of this definition in bottom 7 bits (final definition if bit 7 set)
6893  * V style-name Name of the style (only for final definition)
6894  * B num-parts Number of parts in this definition
6895  * V parts The parts */
6896 
6897  uint32 grfid = _cur.grffile->grfid;
6898 
6899  GRFTownName *townname = AddGRFTownName(grfid);
6900 
6901  byte id = buf->ReadByte();
6902  grfmsg(6, "FeatureTownName: definition 0x%02X", id & 0x7F);
6903 
6904  if (HasBit(id, 7)) {
6905  /* Final definition */
6906  ClrBit(id, 7);
6907  bool new_scheme = _cur.grffile->grf_version >= 7;
6908 
6909  byte lang = buf->ReadByte();
6910 
6911  byte nb_gen = townname->nb_gen;
6912  do {
6913  ClrBit(lang, 7);
6914 
6915  const char *name = buf->ReadString();
6916 
6917  char *lang_name = TranslateTTDPatchCodes(grfid, lang, false, name);
6918  grfmsg(6, "FeatureTownName: lang 0x%X -> '%s'", lang, lang_name);
6919  free(lang_name);
6920 
6921  townname->name[nb_gen] = AddGRFString(grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
6922 
6923  lang = buf->ReadByte();
6924  } while (lang != 0);
6925  townname->id[nb_gen] = id;
6926  townname->nb_gen++;
6927  }
6928 
6929  byte nb = buf->ReadByte();
6930  grfmsg(6, "FeatureTownName: %u parts", nb);
6931 
6932  townname->nbparts[id] = nb;
6933  townname->partlist[id] = CallocT<NamePartList>(nb);
6934 
6935  for (int i = 0; i < nb; i++) {
6936  byte nbtext = buf->ReadByte();
6937  townname->partlist[id][i].bitstart = buf->ReadByte();
6938  townname->partlist[id][i].bitcount = buf->ReadByte();
6939  townname->partlist[id][i].maxprob = 0;
6940  townname->partlist[id][i].partcount = nbtext;
6941  townname->partlist[id][i].parts = CallocT<NamePart>(nbtext);
6942  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);
6943 
6944  for (int j = 0; j < nbtext; j++) {
6945  byte prob = buf->ReadByte();
6946 
6947  if (HasBit(prob, 7)) {
6948  byte ref_id = buf->ReadByte();
6949 
6950  if (townname->nbparts[ref_id] == 0) {
6951  grfmsg(0, "FeatureTownName: definition 0x%02X doesn't exist, deactivating", ref_id);
6952  DelGRFTownName(grfid);
6953  DisableGrf(STR_NEWGRF_ERROR_INVALID_ID);
6954  return;
6955  }
6956 
6957  grfmsg(6, "FeatureTownName: part %d, text %d, uses intermediate definition 0x%02X (with probability %d)", i, j, ref_id, prob & 0x7F);
6958  townname->partlist[id][i].parts[j].data.id = ref_id;
6959  } else {
6960  const char *text = buf->ReadString();
6961  townname->partlist[id][i].parts[j].data.text = TranslateTTDPatchCodes(grfid, 0, false, text);
6962  grfmsg(6, "FeatureTownName: part %d, text %d, '%s' (with probability %d)", i, j, townname->partlist[id][i].parts[j].data.text, prob);
6963  }
6964  townname->partlist[id][i].parts[j].prob = prob;
6965  townname->partlist[id][i].maxprob += GB(prob, 0, 7);
6966  }
6967  grfmsg(6, "FeatureTownName: part %d, total probability %d", i, townname->partlist[id][i].maxprob);
6968  }
6969 }
6970 
6972 static void DefineGotoLabel(ByteReader *buf)
6973 {
6974  /* <10> <label> [<comment>]
6975  *
6976  * B label The label to define
6977  * V comment Optional comment - ignored */
6978 
6979  byte nfo_label = buf->ReadByte();
6980 
6981  GRFLabel *label = MallocT<GRFLabel>(1);
6982  label->label = nfo_label;
6983  label->nfo_line = _cur.nfo_line;
6984  label->pos = FioGetPos();
6985  label->next = NULL;
6986 
6987  /* Set up a linked list of goto targets which we will search in an Action 0x7/0x9 */
6988  if (_cur.grffile->label == NULL) {
6989  _cur.grffile->label = label;
6990  } else {
6991  /* Attach the label to the end of the list */
6992  GRFLabel *l;
6993  for (l = _cur.grffile->label; l->next != NULL; l = l->next) {}
6994  l->next = label;
6995  }
6996 
6997  grfmsg(2, "DefineGotoLabel: GOTO target with label 0x%02X", label->label);
6998 }
6999 
7004 static void ImportGRFSound(SoundEntry *sound)
7005 {
7006  const GRFFile *file;
7007  uint32 grfid = FioReadDword();
7008  SoundID sound_id = FioReadWord();
7009 
7010  file = GetFileByGRFID(grfid);
7011  if (file == NULL || file->sound_offset == 0) {
7012  grfmsg(1, "ImportGRFSound: Source file not available");
7013  return;
7014  }
7015 
7016  if (sound_id >= file->num_sounds) {
7017  grfmsg(1, "ImportGRFSound: Sound effect %d is invalid", sound_id);
7018  return;
7019  }
7020 
7021  grfmsg(2, "ImportGRFSound: Copying sound %d (%d) from file %X", sound_id, file->sound_offset + sound_id, grfid);
7022 
7023  *sound = *GetSound(file->sound_offset + sound_id);
7024 
7025  /* Reset volume and priority, which TTDPatch doesn't copy */
7026  sound->volume = 128;
7027  sound->priority = 0;
7028 }
7029 
7035 static void LoadGRFSound(size_t offs, SoundEntry *sound)
7036 {
7037  /* Set default volume and priority */
7038  sound->volume = 0x80;
7039  sound->priority = 0;
7040 
7041  if (offs != SIZE_MAX) {
7042  /* Sound is present in the NewGRF. */
7043  sound->file_slot = _cur.file_index;
7044  sound->file_offset = offs;
7045  sound->grf_container_ver = _cur.grf_container_ver;
7046  }
7047 }
7048 
7049 /* Action 0x11 */
7050 static void GRFSound(ByteReader *buf)
7051 {
7052  /* <11> <num>
7053  *
7054  * W num Number of sound files that follow */
7055 
7056  uint16 num = buf->ReadWord();
7057  if (num == 0) return;
7058 
7059  SoundEntry *sound;
7060  if (_cur.grffile->sound_offset == 0) {
7061  _cur.grffile->sound_offset = GetNumSounds();
7062  _cur.grffile->num_sounds = num;
7063  sound = AllocateSound(num);
7064  } else {
7065  sound = GetSound(_cur.grffile->sound_offset);
7066  }
7067 
7068  for (int i = 0; i < num; i++) {
7069  _cur.nfo_line++;
7070 
7071  /* Check whether the index is in range. This might happen if multiple action 11 are present.
7072  * While this is invalid, we do not check for this. But we should prevent it from causing bigger trouble */
7073  bool invalid = i >= _cur.grffile->num_sounds;
7074 
7075  size_t offs = FioGetPos();
7076 
7077  uint32 len = _cur.grf_container_ver >= 2 ? FioReadDword() : FioReadWord();
7078  byte type = FioReadByte();
7079 
7080  if (_cur.grf_container_ver >= 2 && type == 0xFD) {
7081  /* Reference to sprite section. */
7082  if (invalid) {
7083  grfmsg(1, "GRFSound: Sound index out of range (multiple Action 11?)");
7084  FioSkipBytes(len);
7085  } else if (len != 4) {
7086  grfmsg(1, "GRFSound: Invalid sprite section import");
7087  FioSkipBytes(len);
7088  } else {
7089  uint32 id = FioReadDword();
7090  if (_cur.stage == GLS_INIT) LoadGRFSound(GetGRFSpriteOffset(id), sound + i);
7091  }
7092  continue;
7093  }
7094 
7095  if (type != 0xFF) {
7096  grfmsg(1, "GRFSound: Unexpected RealSprite found, skipping");
7097  FioSkipBytes(7);
7098  SkipSpriteData(type, len - 8);
7099  continue;
7100  }
7101 
7102  if (invalid) {
7103  grfmsg(1, "GRFSound: Sound index out of range (multiple Action 11?)");
7104  FioSkipBytes(len);
7105  }
7106 
7107  byte action = FioReadByte();
7108  switch (action) {
7109  case 0xFF:
7110  /* Allocate sound only in init stage. */
7111  if (_cur.stage == GLS_INIT) {
7112  if (_cur.grf_container_ver >= 2) {
7113  grfmsg(1, "GRFSound: Inline sounds are not supported for container version >= 2");
7114  } else {
7115  LoadGRFSound(offs, sound + i);
7116  }
7117  }
7118  FioSkipBytes(len - 1); // already read <action>
7119  break;
7120 
7121  case 0xFE:
7122  if (_cur.stage == GLS_ACTIVATION) {
7123  /* XXX 'Action 0xFE' isn't really specified. It is only mentioned for
7124  * importing sounds, so this is probably all wrong... */
7125  if (FioReadByte() != 0) grfmsg(1, "GRFSound: Import type mismatch");
7126  ImportGRFSound(sound + i);
7127  } else {
7128  FioSkipBytes(len - 1); // already read <action>
7129  }
7130  break;
7131 
7132  default:
7133  grfmsg(1, "GRFSound: Unexpected Action %x found, skipping", action);
7134  FioSkipBytes(len - 1); // already read <action>
7135  break;
7136  }
7137  }
7138 }
7139 
7140 /* Action 0x11 (SKIP) */
7141 static void SkipAct11(ByteReader *buf)
7142 {
7143  /* <11> <num>
7144  *
7145  * W num Number of sound files that follow */
7146 
7147  _cur.skip_sprites = buf->ReadWord();
7148 
7149  grfmsg(3, "SkipAct11: Skipping %d sprites", _cur.skip_sprites);
7150 }
7151 
7153 static void LoadFontGlyph(ByteReader *buf)
7154 {
7155  /* <12> <num_def> <font_size> <num_char> <base_char>
7156  *
7157  * B num_def Number of definitions
7158  * B font_size Size of font (0 = normal, 1 = small, 2 = large, 3 = mono)
7159  * B num_char Number of consecutive glyphs
7160  * W base_char First character index */
7161 
7162  uint8 num_def = buf->ReadByte();
7163 
7164  for (uint i = 0; i < num_def; i++) {
7165  FontSize size = (FontSize)buf->ReadByte();
7166  uint8 num_char = buf->ReadByte();
7167  uint16 base_char = buf->ReadWord();
7168 
7169  if (size >= FS_END) {
7170  grfmsg(1, "LoadFontGlyph: Size %u is not supported, ignoring", size);
7171  }
7172 
7173  grfmsg(7, "LoadFontGlyph: Loading %u glyph(s) at 0x%04X for size %u", num_char, base_char, size);
7174 
7175  for (uint c = 0; c < num_char; c++) {
7176  if (size < FS_END) SetUnicodeGlyph(size, base_char + c, _cur.spriteid);
7177  _cur.nfo_line++;
7178  LoadNextSprite(_cur.spriteid++, _cur.file_index, _cur.nfo_line, _cur.grf_container_ver);
7179  }
7180  }
7181 }
7182 
7184 static void SkipAct12(ByteReader *buf)
7185 {
7186  /* <12> <num_def> <font_size> <num_char> <base_char>
7187  *
7188  * B num_def Number of definitions
7189  * B font_size Size of font (0 = normal, 1 = small, 2 = large)
7190  * B num_char Number of consecutive glyphs
7191  * W base_char First character index */
7192 
7193  uint8 num_def = buf->ReadByte();
7194 
7195  for (uint i = 0; i < num_def; i++) {
7196  /* Ignore 'size' byte */
7197  buf->ReadByte();
7198 
7199  /* Sum up number of characters */
7200  _cur.skip_sprites += buf->ReadByte();
7201 
7202  /* Ignore 'base_char' word */
7203  buf->ReadWord();
7204  }
7205 
7206  grfmsg(3, "SkipAct12: Skipping %d sprites", _cur.skip_sprites);
7207 }
7208 
7211 {
7212  /* <13> <grfid> <num-ent> <offset> <text...>
7213  *
7214  * 4*B grfid The GRFID of the file whose texts are to be translated
7215  * B num-ent Number of strings
7216  * W offset First text ID
7217  * S text... Zero-terminated strings */
7218 
7219  uint32 grfid = buf->ReadDWord();
7220  const GRFConfig *c = GetGRFConfig(grfid);
7221  if (c == NULL || (c->status != GCS_INITIALISED && c->status != GCS_ACTIVATED)) {
7222  grfmsg(7, "TranslateGRFStrings: GRFID 0x%08x unknown, skipping action 13", BSWAP32(grfid));
7223  return;
7224  }
7225 
7226  if (c->status == GCS_INITIALISED) {
7227  /* If the file is not active but will be activated later, give an error
7228  * and disable this file. */
7229  GRFError *error = DisableGrf(STR_NEWGRF_ERROR_LOAD_AFTER);
7230 
7231  char tmp[256];
7232  GetString(tmp, STR_NEWGRF_ERROR_AFTER_TRANSLATED_FILE, lastof(tmp));
7233  error->data = stredup(tmp);
7234 
7235  return;
7236  }
7237 
7238  /* Since no language id is supplied for with version 7 and lower NewGRFs, this string has
7239  * to be added as a generic string, thus the language id of 0x7F. For this to work
7240  * new_scheme has to be true as well, which will also be implicitly the case for version 8
7241  * and higher. A language id of 0x7F will be overridden by a non-generic id, so this will
7242  * not change anything if a string has been provided specifically for this language. */
7243  byte language = _cur.grffile->grf_version >= 8 ? buf->ReadByte() : 0x7F;
7244  byte num_strings = buf->ReadByte();
7245  uint16 first_id = buf->ReadWord();
7246 
7247  if (!((first_id >= 0xD000 && first_id + num_strings <= 0xD400) || (first_id >= 0xD800 && first_id + num_strings <= 0xE000))) {
7248  grfmsg(7, "TranslateGRFStrings: Attempting to set out-of-range string IDs in action 13 (first: 0x%4X, number: 0x%2X)", first_id, num_strings);
7249  return;
7250  }
7251 
7252  for (uint i = 0; i < num_strings && buf->HasData(); i++) {
7253  const char *string = buf->ReadString();
7254 
7255  if (StrEmpty(string)) {
7256  grfmsg(7, "TranslateGRFString: Ignoring empty string.");
7257  continue;
7258  }
7259 
7260  AddGRFString(grfid, first_id + i, language, true, true, string, STR_UNDEFINED);
7261  }
7262 }
7263 
7265 static bool ChangeGRFName(byte langid, const char *str)
7266 {
7267  AddGRFTextToList(&_cur.grfconfig->name->text, langid, _cur.grfconfig->ident.grfid, false, str);
7268  return true;
7269 }
7270 
7272 static bool ChangeGRFDescription(byte langid, const char *str)
7273 {
7274  AddGRFTextToList(&_cur.grfconfig->info->text, langid, _cur.grfconfig->ident.grfid, true, str);
7275  return true;
7276 }
7277 
7279 static bool ChangeGRFURL(byte langid, const char *str)
7280 {
7281  AddGRFTextToList(&_cur.grfconfig->url->text, langid, _cur.grfconfig->ident.grfid, false, str);
7282  return true;
7283 }
7284 
7286 static bool ChangeGRFNumUsedParams(size_t len, ByteReader *buf)
7287 {
7288  if (len != 1) {
7289  grfmsg(2, "StaticGRFInfo: expected only 1 byte for 'INFO'->'NPAR' but got " PRINTF_SIZE ", ignoring this field", len);
7290  buf->Skip(len);
7291  } else {
7292  _cur.grfconfig->num_valid_params = min(buf->ReadByte(), lengthof(_cur.grfconfig->param));
7293  }
7294  return true;
7295 }
7296 
7298 static bool ChangeGRFPalette(size_t len, ByteReader *buf)
7299 {
7300  if (len != 1) {
7301  grfmsg(2, "StaticGRFInfo: expected only 1 byte for 'INFO'->'PALS' but got " PRINTF_SIZE ", ignoring this field", len);
7302  buf->Skip(len);
7303  } else {
7304  char data = buf->ReadByte();
7305  GRFPalette pal = GRFP_GRF_UNSET;
7306  switch (data) {
7307  case '*':
7308  case 'A': pal = GRFP_GRF_ANY; break;
7309  case 'W': pal = GRFP_GRF_WINDOWS; break;
7310  case 'D': pal = GRFP_GRF_DOS; break;
7311  default:
7312  grfmsg(2, "StaticGRFInfo: unexpected value '%02x' for 'INFO'->'PALS', ignoring this field", data);
7313  break;
7314  }
7315  if (pal != GRFP_GRF_UNSET) {
7316  _cur.grfconfig->palette &= ~GRFP_GRF_MASK;
7317  _cur.grfconfig->palette |= pal;
7318  }
7319  }
7320  return true;
7321 }
7322 
7324 static bool ChangeGRFBlitter(size_t len, ByteReader *buf)
7325 {
7326  if (len != 1) {
7327  grfmsg(2, "StaticGRFInfo: expected only 1 byte for 'INFO'->'BLTR' but got " PRINTF_SIZE ", ignoring this field", len);
7328  buf->Skip(len);
7329  } else {
7330  char data = buf->ReadByte();
7331  GRFPalette pal = GRFP_BLT_UNSET;
7332  switch (data) {
7333  case '8': pal = GRFP_BLT_UNSET; break;
7334  case '3': pal = GRFP_BLT_32BPP; break;
7335  default:
7336  grfmsg(2, "StaticGRFInfo: unexpected value '%02x' for 'INFO'->'BLTR', ignoring this field", data);
7337  return true;
7338  }
7339  _cur.grfconfig->palette &= ~GRFP_BLT_MASK;
7340  _cur.grfconfig->palette |= pal;
7341  }
7342  return true;
7343 }
7344 
7346 static bool ChangeGRFVersion(size_t len, ByteReader *buf)
7347 {
7348  if (len != 4) {
7349  grfmsg(2, "StaticGRFInfo: expected 4 bytes for 'INFO'->'VRSN' but got " PRINTF_SIZE ", ignoring this field", len);
7350  buf->Skip(len);
7351  } else {
7352  /* Set min_loadable_version as well (default to minimal compatibility) */
7353  _cur.grfconfig->version = _cur.grfconfig->min_loadable_version = buf->ReadDWord();
7354  }
7355  return true;
7356 }
7357 
7359 static bool ChangeGRFMinVersion(size_t len, ByteReader *buf)
7360 {
7361  if (len != 4) {
7362  grfmsg(2, "StaticGRFInfo: expected 4 bytes for 'INFO'->'MINV' but got " PRINTF_SIZE ", ignoring this field", len);
7363  buf->Skip(len);
7364  } else {
7365  _cur.grfconfig->min_loadable_version = buf->ReadDWord();
7366  if (_cur.grfconfig->version == 0) {
7367  grfmsg(2, "StaticGRFInfo: 'MINV' defined before 'VRSN' or 'VRSN' set to 0, ignoring this field");
7368  _cur.grfconfig->min_loadable_version = 0;
7369  }
7370  if (_cur.grfconfig->version < _cur.grfconfig->min_loadable_version) {
7371  grfmsg(2, "StaticGRFInfo: 'MINV' defined as %d, limiting it to 'VRSN'", _cur.grfconfig->min_loadable_version);
7373  }
7374  }
7375  return true;
7376 }
7377 
7379 
7381 static bool ChangeGRFParamName(byte langid, const char *str)
7382 {
7383  AddGRFTextToList(&_cur_parameter->name, langid, _cur.grfconfig->ident.grfid, false, str);
7384  return true;
7385 }
7386 
7388 static bool ChangeGRFParamDescription(byte langid, const char *str)
7389 {
7390  AddGRFTextToList(&_cur_parameter->desc, langid, _cur.grfconfig->ident.grfid, true, str);
7391  return true;
7392 }
7393 
7395 static bool ChangeGRFParamType(size_t len, ByteReader *buf)
7396 {
7397  if (len != 1) {
7398  grfmsg(2, "StaticGRFInfo: expected 1 byte for 'INFO'->'PARA'->'TYPE' but got " PRINTF_SIZE ", ignoring this field", len);
7399  buf->Skip(len);
7400  } else {
7401  GRFParameterType type = (GRFParameterType)buf->ReadByte();
7402  if (type < PTYPE_END) {
7403  _cur_parameter->type = type;
7404  } else {
7405  grfmsg(3, "StaticGRFInfo: unknown parameter type %d, ignoring this field", type);
7406  }
7407  }
7408  return true;
7409 }
7410 
7412 static bool ChangeGRFParamLimits(size_t len, ByteReader *buf)
7413 {
7414  if (_cur_parameter->type != PTYPE_UINT_ENUM) {
7415  grfmsg(2, "StaticGRFInfo: 'INFO'->'PARA'->'LIMI' is only valid for parameters with type uint/enum, ignoring this field");
7416  buf->Skip(len);
7417  } else if (len != 8) {
7418  grfmsg(2, "StaticGRFInfo: expected 8 bytes for 'INFO'->'PARA'->'LIMI' but got " PRINTF_SIZE ", ignoring this field", len);
7419  buf->Skip(len);
7420  } else {
7421  _cur_parameter->min_value = buf->ReadDWord();
7422  _cur_parameter->max_value = buf->ReadDWord();
7423  }
7424  return true;
7425 }
7426 
7428 static bool ChangeGRFParamMask(size_t len, ByteReader *buf)
7429 {
7430  if (len < 1 || len > 3) {
7431  grfmsg(2, "StaticGRFInfo: expected 1 to 3 bytes for 'INFO'->'PARA'->'MASK' but got " PRINTF_SIZE ", ignoring this field", len);
7432  buf->Skip(len);
7433  } else {
7434  byte param_nr = buf->ReadByte();
7435  if (param_nr >= lengthof(_cur.grfconfig->param)) {
7436  grfmsg(2, "StaticGRFInfo: invalid parameter number in 'INFO'->'PARA'->'MASK', param %d, ignoring this field", param_nr);
7437  buf->Skip(len - 1);
7438  } else {
7439  _cur_parameter->param_nr = param_nr;
7440  if (len >= 2) _cur_parameter->first_bit = min(buf->ReadByte(), 31);
7441  if (len >= 3) _cur_parameter->num_bit = min(buf->ReadByte(), 32 - _cur_parameter->first_bit);
7442  }
7443  }
7444 
7445  return true;
7446 }
7447 
7449 static bool ChangeGRFParamDefault(size_t len, ByteReader *buf)
7450 {
7451  if (len != 4) {
7452  grfmsg(2, "StaticGRFInfo: expected 4 bytes for 'INFO'->'PARA'->'DEFA' but got " PRINTF_SIZE ", ignoring this field", len);
7453  buf->Skip(len);
7454  } else {
7455  _cur_parameter->def_value = buf->ReadDWord();
7456  }
7457  _cur.grfconfig->has_param_defaults = true;
7458  return true;
7459 }
7460 
7461 typedef bool (*DataHandler)(size_t, ByteReader *);
7462 typedef bool (*TextHandler)(byte, const char *str);
7463 typedef bool (*BranchHandler)(ByteReader *);
7464 
7475  id(0),
7476  type(0)
7477  {}
7478 
7484  AllowedSubtags(uint32 id, DataHandler handler) :
7485  id(id),
7486  type('B')
7487  {
7488  this->handler.data = handler;
7489  }
7490 
7496  AllowedSubtags(uint32 id, TextHandler handler) :
7497  id(id),
7498  type('T')
7499  {
7500  this->handler.text = handler;
7501  }
7502 
7508  AllowedSubtags(uint32 id, BranchHandler handler) :
7509  id(id),
7510  type('C')
7511  {
7512  this->handler.call_handler = true;
7513  this->handler.u.branch = handler;
7514  }
7515 
7522  id(id),
7523  type('C')
7524  {
7525  this->handler.call_handler = false;
7526  this->handler.u.subtags = subtags;
7527  }
7528 
7529  uint32 id;
7530  byte type;
7531  union {
7534  struct {
7535  union {
7538  } u;
7540  };
7541  } handler;
7542 };
7543 
7544 static bool SkipUnknownInfo(ByteReader *buf, byte type);
7545 static bool HandleNodes(ByteReader *buf, AllowedSubtags *tags);
7546 
7554 {
7555  byte type = buf->ReadByte();
7556  while (type != 0) {
7557  uint32 id = buf->ReadDWord();
7558  if (type != 'T' || id > _cur_parameter->max_value) {
7559  grfmsg(2, "StaticGRFInfo: all child nodes of 'INFO'->'PARA'->param_num->'VALU' should have type 't' and the value/bit number as id");
7560  if (!SkipUnknownInfo(buf, type)) return false;
7561  type = buf->ReadByte();
7562  continue;
7563  }
7564 
7565  byte langid = buf->ReadByte();
7566  const char *name_string = buf->ReadString();
7567 
7568  SmallPair<uint32, GRFText *> *val_name = _cur_parameter->value_names.Find(id);
7569  if (val_name != _cur_parameter->value_names.End()) {
7570  AddGRFTextToList(&val_name->second, langid, _cur.grfconfig->ident.grfid, false, name_string);
7571  } else {
7572  GRFText *list = NULL;
7573  AddGRFTextToList(&list, langid, _cur.grfconfig->ident.grfid, false, name_string);
7574  _cur_parameter->value_names.Insert(id, list);
7575  }
7576 
7577  type = buf->ReadByte();
7578  }
7579  return true;
7580 }
7581 
7591  AllowedSubtags()
7592 };
7593 
7601 {
7602  byte type = buf->ReadByte();
7603  while (type != 0) {
7604  uint32 id = buf->ReadDWord();
7605  if (type != 'C' || id >= _cur.grfconfig->num_valid_params) {
7606  grfmsg(2, "StaticGRFInfo: all child nodes of 'INFO'->'PARA' should have type 'C' and their parameter number as id");
7607  if (!SkipUnknownInfo(buf, type)) return false;
7608  type = buf->ReadByte();
7609  continue;
7610  }
7611 
7612  if (id >= _cur.grfconfig->param_info.Length()) {
7613  uint num_to_add = id - _cur.grfconfig->param_info.Length() + 1;
7614  GRFParameterInfo **newdata = _cur.grfconfig->param_info.Append(num_to_add);
7615  MemSetT<GRFParameterInfo *>(newdata, 0, num_to_add);
7616  }
7617  if (_cur.grfconfig->param_info[id] == NULL) {
7618  _cur.grfconfig->param_info[id] = new GRFParameterInfo(id);
7619  }
7620  _cur_parameter = _cur.grfconfig->param_info[id];
7621  /* Read all parameter-data and process each node. */
7622  if (!HandleNodes(buf, _tags_parameters)) return false;
7623  type = buf->ReadByte();
7624  }
7625  return true;
7626 }
7627 
7630  AllowedSubtags('NAME', ChangeGRFName),
7632  AllowedSubtags('URL_', ChangeGRFURL),
7639  AllowedSubtags()
7640 };
7641 
7644  AllowedSubtags('INFO', _tags_info),
7645  AllowedSubtags()
7646 };
7647 
7648 
7655 static bool SkipUnknownInfo(ByteReader *buf, byte type)
7656 {
7657  /* type and id are already read */
7658  switch (type) {
7659  case 'C': {
7660  byte new_type = buf->ReadByte();
7661  while (new_type != 0) {
7662  buf->ReadDWord(); // skip the id
7663  if (!SkipUnknownInfo(buf, new_type)) return false;
7664  new_type = buf->ReadByte();
7665  }
7666  break;
7667  }
7668 
7669  case 'T':
7670  buf->ReadByte(); // lang
7671  buf->ReadString(); // actual text
7672  break;
7673 
7674  case 'B': {
7675  uint16 size = buf->ReadWord();
7676  buf->Skip(size);
7677  break;
7678  }
7679 
7680  default:
7681  return false;
7682  }
7683 
7684  return true;
7685 }
7686 
7695 static bool HandleNode(byte type, uint32 id, ByteReader *buf, AllowedSubtags subtags[])
7696 {
7697  uint i = 0;
7698  AllowedSubtags *tag;
7699  while ((tag = &subtags[i++])->type != 0) {
7700  if (tag->id != BSWAP32(id) || tag->type != type) continue;
7701  switch (type) {
7702  default: NOT_REACHED();
7703 
7704  case 'T': {
7705  byte langid = buf->ReadByte();
7706  return tag->handler.text(langid, buf->ReadString());
7707  }
7708 
7709  case 'B': {
7710  size_t len = buf->ReadWord();
7711  if (buf->Remaining() < len) return false;
7712  return tag->handler.data(len, buf);
7713  }
7714 
7715  case 'C': {
7716  if (tag->handler.call_handler) {
7717  return tag->handler.u.branch(buf);
7718  }
7719  return HandleNodes(buf, tag->handler.u.subtags);
7720  }
7721  }
7722  }
7723  grfmsg(2, "StaticGRFInfo: unknown type/id combination found, type=%c, id=%x", type, id);
7724  return SkipUnknownInfo(buf, type);
7725 }
7726 
7733 static bool HandleNodes(ByteReader *buf, AllowedSubtags subtags[])
7734 {
7735  byte type = buf->ReadByte();
7736  while (type != 0) {
7737  uint32 id = buf->ReadDWord();
7738  if (!HandleNode(type, id, buf, subtags)) return false;
7739  type = buf->ReadByte();
7740  }
7741  return true;
7742 }
7743 
7748 static void StaticGRFInfo(ByteReader *buf)
7749 {
7750  /* <14> <type> <id> <text/data...> */
7751  HandleNodes(buf, _tags_root);
7752 }
7753 
7759 static void GRFUnsafe(ByteReader *buf)
7760 {
7761  SetBit(_cur.grfconfig->flags, GCF_UNSAFE);
7762 
7763  /* Skip remainder of GRF */
7764  _cur.skip_sprites = -1;
7765 }
7766 
7767 
7770 {
7771  _ttdpatch_flags[0] = ((_settings_game.station.never_expire_airports ? 1 : 0) << 0x0C) // keepsmallairport
7772  | (1 << 0x0D) // newairports
7773  | (1 << 0x0E) // largestations
7774  | ((_settings_game.construction.max_bridge_length > 16 ? 1 : 0) << 0x0F) // longbridges
7775  | (0 << 0x10) // loadtime
7776  | (1 << 0x12) // presignals
7777  | (1 << 0x13) // extpresignals
7778  | ((_settings_game.vehicle.never_expire_vehicles ? 1 : 0) << 0x16) // enginespersist
7779  | (1 << 0x1B) // multihead
7780  | (1 << 0x1D) // lowmemory
7781  | (1 << 0x1E); // generalfixes
7782 
7783  _ttdpatch_flags[1] = ((_settings_game.economy.station_noise_level ? 1 : 0) << 0x07) // moreairports - based on units of noise
7784  | (1 << 0x08) // mammothtrains
7785  | (1 << 0x09) // trainrefit
7786  | (0 << 0x0B) // subsidiaries
7787  | ((_settings_game.order.gradual_loading ? 1 : 0) << 0x0C) // gradualloading
7788  | (1 << 0x12) // unifiedmaglevmode - set bit 0 mode. Not revelant to OTTD
7789  | (1 << 0x13) // unifiedmaglevmode - set bit 1 mode
7790  | (1 << 0x14) // bridgespeedlimits
7791  | (1 << 0x16) // eternalgame
7792  | (1 << 0x17) // newtrains
7793  | (1 << 0x18) // newrvs
7794  | (1 << 0x19) // newships
7795  | (1 << 0x1A) // newplanes
7796  | ((_settings_game.construction.train_signal_side == 1 ? 1 : 0) << 0x1B) // signalsontrafficside
7797  | ((_settings_game.vehicle.disable_elrails ? 0 : 1) << 0x1C); // electrifiedrailway
7798 
7799  _ttdpatch_flags[2] = (1 << 0x01) // loadallgraphics - obsolote
7800  | (1 << 0x03) // semaphores
7801  | (1 << 0x0A) // newobjects
7802  | (0 << 0x0B) // enhancedgui
7803  | (0 << 0x0C) // newagerating
7804  | ((_settings_game.construction.build_on_slopes ? 1 : 0) << 0x0D) // buildonslopes
7805  | (1 << 0x0E) // fullloadany
7806  | (1 << 0x0F) // planespeed
7807  | (0 << 0x10) // moreindustriesperclimate - obsolete
7808  | (0 << 0x11) // moretoylandfeatures
7809  | (1 << 0x12) // newstations
7810  | (1 << 0x13) // tracktypecostdiff
7811  | (1 << 0x14) // manualconvert
7812  | ((_settings_game.construction.build_on_slopes ? 1 : 0) << 0x15) // buildoncoasts
7813  | (1 << 0x16) // canals
7814  | (1 << 0x17) // newstartyear
7815  | ((_settings_game.vehicle.freight_trains > 1 ? 1 : 0) << 0x18) // freighttrains
7816  | (1 << 0x19) // newhouses
7817  | (1 << 0x1A) // newbridges
7818  | (1 << 0x1B) // newtownnames
7819  | (1 << 0x1C) // moreanimation
7820  | ((_settings_game.vehicle.wagon_speed_limits ? 1 : 0) << 0x1D) // wagonspeedlimits
7821  | (1 << 0x1E) // newshistory
7822  | (0 << 0x1F); // custombridgeheads
7823 
7824  _ttdpatch_flags[3] = (0 << 0x00) // newcargodistribution
7825  | (1 << 0x01) // windowsnap
7826  | ((_settings_game.economy.allow_town_roads || _generating_world ? 0 : 1) << 0x02) // townbuildnoroad
7827  | (1 << 0x03) // pathbasedsignalling
7828  | (0 << 0x04) // aichoosechance
7829  | (1 << 0x05) // resolutionwidth
7830  | (1 << 0x06) // resolutionheight
7831  | (1 << 0x07) // newindustries
7832  | ((_settings_game.order.improved_load ? 1 : 0) << 0x08) // fifoloading
7833  | (0 << 0x09) // townroadbranchprob
7834  | (0 << 0x0A) // tempsnowline
7835  | (1 << 0x0B) // newcargo
7836  | (1 << 0x0C) // enhancemultiplayer
7837  | (1 << 0x0D) // onewayroads
7838  | (1 << 0x0E) // irregularstations
7839  | (1 << 0x0F) // statistics
7840  | (1 << 0x10) // newsounds
7841  | (1 << 0x11) // autoreplace
7842  | (1 << 0x12) // autoslope
7843  | (0 << 0x13) // followvehicle
7844  | (1 << 0x14) // trams
7845  | (0 << 0x15) // enhancetunnels
7846  | (1 << 0x16) // shortrvs
7847  | (1 << 0x17) // articulatedrvs
7848  | ((_settings_game.vehicle.dynamic_engines ? 1 : 0) << 0x18) // dynamic engines
7849  | (1 << 0x1E) // variablerunningcosts
7850  | (1 << 0x1F); // any switch is on
7851 }
7852 
7854 static void ResetCustomStations()
7855 {
7856  const GRFFile * const *end = _grf_files.End();
7857  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
7858  StationSpec **&stations = (*file)->stations;
7859  if (stations == NULL) continue;
7860  for (uint i = 0; i < NUM_STATIONS_PER_GRF; i++) {
7861  if (stations[i] == NULL) continue;
7862  StationSpec *statspec = stations[i];
7863 
7864  delete[] statspec->renderdata;
7865 
7866  /* Release platforms and layouts */
7867  if (!statspec->copied_layouts) {
7868  for (uint l = 0; l < statspec->lengths; l++) {
7869  for (uint p = 0; p < statspec->platforms[l]; p++) {
7870  free(statspec->layouts[l][p]);
7871  }
7872  free(statspec->layouts[l]);
7873  }
7874  free(statspec->layouts);
7875  free(statspec->platforms);
7876  }
7877 
7878  /* Release this station */
7879  free(statspec);
7880  }
7881 
7882  /* Free and reset the station data */
7883  free(stations);
7884  stations = NULL;
7885  }
7886 }
7887 
7889 static void ResetCustomHouses()
7890 {
7891  const GRFFile * const *end = _grf_files.End();
7892  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
7893  HouseSpec **&housespec = (*file)->housespec;
7894  if (housespec == NULL) continue;
7895  for (uint i = 0; i < NUM_HOUSES_PER_GRF; i++) {
7896  free(housespec[i]);
7897  }
7898 
7899  free(housespec);
7900  housespec = NULL;
7901  }
7902 }
7903 
7905 static void ResetCustomAirports()
7906 {
7907  const GRFFile * const *end = _grf_files.End();
7908  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
7909  AirportSpec **aslist = (*file)->airportspec;
7910  if (aslist != NULL) {
7911  for (uint i = 0; i < NUM_AIRPORTS_PER_GRF; i++) {
7912  AirportSpec *as = aslist[i];
7913 
7914  if (as != NULL) {
7915  /* We need to remove the tiles layouts */
7916  for (int j = 0; j < as->num_table; j++) {
7917  /* remove the individual layouts */
7918  free(as->table[j]);
7919  }
7920  free(as->table);
7921  free(as->depot_table);
7922  free(as->rotation);
7923 
7924  free(as);
7925  }
7926  }
7927  free(aslist);
7928  (*file)->airportspec = NULL;
7929  }
7930 
7931  AirportTileSpec **&airporttilespec = (*file)->airtspec;
7932  if (airporttilespec != NULL) {
7933  for (uint i = 0; i < NUM_AIRPORTTILES_PER_GRF; i++) {
7934  free(airporttilespec[i]);
7935  }
7936  free(airporttilespec);
7937  airporttilespec = NULL;
7938  }
7939  }
7940 }
7941 
7944 {
7945  const GRFFile * const *end = _grf_files.End();
7946  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
7947  IndustrySpec **&industryspec = (*file)->industryspec;
7948  IndustryTileSpec **&indtspec = (*file)->indtspec;
7949 
7950  /* We are verifiying both tiles and industries specs loaded from the grf file
7951  * First, let's deal with industryspec */
7952  if (industryspec != NULL) {
7953  for (uint i = 0; i < NUM_INDUSTRYTYPES_PER_GRF; i++) {
7954  IndustrySpec *ind = industryspec[i];
7955  if (ind == NULL) continue;
7956 
7957  /* We need to remove the sounds array */
7958  if (HasBit(ind->cleanup_flag, CLEAN_RANDOMSOUNDS)) {
7959  free(ind->random_sounds);
7960  }
7961 
7962  /* We need to remove the tiles layouts */
7964 
7965  free(ind);
7966  }
7967 
7968  free(industryspec);
7969  industryspec = NULL;
7970  }
7971 
7972  if (indtspec == NULL) continue;
7973  for (uint i = 0; i < NUM_INDUSTRYTILES_PER_GRF; i++) {
7974  free(indtspec[i]);
7975  }
7976 
7977  free(indtspec);
7978  indtspec = NULL;
7979  }
7980 }
7981 
7983 static void ResetCustomObjects()
7984 {
7985  const GRFFile * const *end = _grf_files.End();
7986  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
7987  ObjectSpec **&objectspec = (*file)->objectspec;
7988  if (objectspec == NULL) continue;
7989  for (uint i = 0; i < NUM_OBJECTS_PER_GRF; i++) {
7990  free(objectspec[i]);
7991  }
7992 
7993  free(objectspec);
7994  objectspec = NULL;
7995  }
7996 }
7997 
7999 static void ResetNewGRF()
8000 {
8001  const GRFFile * const *end = _grf_files.End();
8002  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
8003  delete *file;
8004  }
8005 
8006  _grf_files.Clear();
8007  _cur.grffile = NULL;
8008 }
8009 
8011 static void ResetNewGRFErrors()
8012 {
8013  for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
8014  if (!HasBit(c->flags, GCF_COPY) && c->error != NULL) {
8015  delete c->error;
8016  c->error = NULL;
8017  }
8018  }
8019 }
8020 
8026 {
8027  CleanUpStrings();
8028  CleanUpGRFTownNames();
8029 
8030  /* Copy/reset original engine info data */
8031  SetupEngines();
8032 
8033  /* Copy/reset original bridge info data */
8034  ResetBridges();
8035 
8036  /* Reset rail type information */
8037  ResetRailTypes();
8038 
8039  /* Allocate temporary refit/cargo class data */
8040  _gted = CallocT<GRFTempEngineData>(Engine::GetPoolSize());
8041 
8042  /* Fill rail type label temporary data for default trains */
8043  Engine *e;
8044  FOR_ALL_ENGINES_OF_TYPE(e, VEH_TRAIN) {
8045  _gted[e->index].railtypelabel = GetRailTypeInfo(e->u.rail.railtype)->label;
8046  }
8047 
8048  /* Reset GRM reservations */
8049  memset(&_grm_engines, 0, sizeof(_grm_engines));
8050  memset(&_grm_cargoes, 0, sizeof(_grm_cargoes));
8051 
8052  /* Reset generic feature callback lists */
8054 
8055  /* Reset price base data */
8057 
8058  /* Reset the curencies array */
8059  ResetCurrencies();
8060 
8061  /* Reset the house array */
8063  ResetHouses();
8064 
8065  /* Reset the industries structures*/
8067  ResetIndustries();
8068 
8069  /* Reset the objects. */
8070  ObjectClass::Reset();
8072  ResetObjects();
8073 
8074  /* Reset station classes */
8075  StationClass::Reset();
8077 
8078  /* Reset airport-related structures */
8079  AirportClass::Reset();
8083 
8084  /* Reset canal sprite groups and flags */
8085  memset(_water_feature, 0, sizeof(_water_feature));
8086 
8087  /* Reset the snowline table. */
8088  ClearSnowLine();
8089 
8090  /* Reset NewGRF files */
8091  ResetNewGRF();
8092 
8093  /* Reset NewGRF errors. */
8095 
8096  /* Set up the default cargo types */
8098 
8099  /* Reset misc GRF features and train list display variables */
8100  _misc_grf_features = 0;
8101 
8102  _loaded_newgrf_features.has_2CC = false;
8103  _loaded_newgrf_features.used_liveries = 1 << LS_DEFAULT;
8104  _loaded_newgrf_features.has_newhouses = false;
8105  _loaded_newgrf_features.has_newindustries = false;
8106  _loaded_newgrf_features.shore = SHORE_REPLACE_NONE;
8107 
8108  /* Clear all GRF overrides */
8109  _grf_id_overrides.clear();
8110 
8111  InitializeSoundPool();
8112  _spritegroup_pool.CleanPool();
8113 }
8114 
8119 {
8120  /* Reset override managers */
8121  _engine_mngr.ResetToDefaultMapping();
8122  _house_mngr.ResetMapping();
8123  _industry_mngr.ResetMapping();
8124  _industile_mngr.ResetMapping();
8125  _airport_mngr.ResetMapping();
8126  _airporttile_mngr.ResetMapping();
8127 }
8128 
8134 {
8135  memset(_cur.grffile->cargo_map, 0xFF, sizeof(_cur.grffile->cargo_map));
8136 
8137  for (CargoID c = 0; c < NUM_CARGO; c++) {
8138  const CargoSpec *cs = CargoSpec::Get(c);
8139  if (!cs->IsValid()) continue;
8140 
8141  if (_cur.grffile->cargo_list.Length() == 0) {
8142  /* Default translation table, so just a straight mapping to bitnum */
8143  _cur.grffile->cargo_map[c] = cs->bitnum;
8144  } else {
8145  /* Check the translation table for this cargo's label */
8146  int index = _cur.grffile->cargo_list.FindIndex(cs->label);
8147  if (index >= 0) _cur.grffile->cargo_map[c] = index;
8148  }
8149  }
8150 }
8151 
8156 static void InitNewGRFFile(const GRFConfig *config)
8157 {
8158  GRFFile *newfile = GetFileByFilename(config->filename);
8159  if (newfile != NULL) {
8160  /* We already loaded it once. */
8161  _cur.grffile = newfile;
8162  return;
8163  }
8164 
8165  newfile = new GRFFile(config);
8166  *_grf_files.Append() = _cur.grffile = newfile;
8167 }
8168 
8174 {
8175  this->filename = stredup(config->filename);
8176  this->grfid = config->ident.grfid;
8177 
8178  /* Initialise local settings to defaults */
8179  this->traininfo_vehicle_pitch = 0;
8180  this->traininfo_vehicle_width = TRAININFO_DEFAULT_VEHICLE_WIDTH;
8181 
8182  /* Mark price_base_multipliers as 'not set' */
8183  for (Price i = PR_BEGIN; i < PR_END; i++) {
8184  this->price_base_multipliers[i] = INVALID_PRICE_MODIFIER;
8185  }
8186 
8187  /* Initialise rail type map with default rail types */
8188  memset(this->railtype_map, INVALID_RAILTYPE, sizeof(this->railtype_map));
8189  this->railtype_map[0] = RAILTYPE_RAIL;
8190  this->railtype_map[1] = RAILTYPE_ELECTRIC;
8191  this->railtype_map[2] = RAILTYPE_MONO;
8192  this->railtype_map[3] = RAILTYPE_MAGLEV;
8193 
8194  /* Copy the initial parameter list
8195  * 'Uninitialised' parameters are zeroed as that is their default value when dynamically creating them. */
8196  assert_compile(lengthof(this->param) == lengthof(config->param) && lengthof(this->param) == 0x80);
8197 
8198  assert(config->num_params <= lengthof(config->param));
8199  this->param_end = config->num_params;
8200  if (this->param_end > 0) {
8201  MemCpyT(this->param, config->param, this->param_end);
8202  }
8203 }
8204 
8205 GRFFile::~GRFFile()
8206 {
8207  free(this->filename);
8208  delete[] this->language_map;
8209 }
8210 
8211 
8217  'PASS', 'COAL', 'MAIL', 'LVST', 'GOOD', 'GRAI', 'WHEA', 'MAIZ', 'WOOD',
8218  'IORE', 'STEL', 'VALU', 'GOLD', 'DIAM', 'PAPR', 'FOOD', 'FRUT', 'CORE',
8219  'WATR', 'SUGR', 'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL',
8220  'PLST', 'FZDR',
8221  0 };
8222 
8223 static const CargoLabel _default_refitmasks_road[] = {
8224  0 };
8225 
8226 static const CargoLabel _default_refitmasks_ships[] = {
8227  'COAL', 'MAIL', 'LVST', 'GOOD', 'GRAI', 'WHEA', 'MAIZ', 'WOOD', 'IORE',
8228  'STEL', 'VALU', 'GOLD', 'DIAM', 'PAPR', 'FOOD', 'FRUT', 'CORE', 'WATR',
8229  'RUBR', 'SUGR', 'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL',
8230  'PLST', 'FZDR',
8231  0 };
8232 
8233 static const CargoLabel _default_refitmasks_aircraft[] = {
8234  'PASS', 'MAIL', 'GOOD', 'VALU', 'GOLD', 'DIAM', 'FOOD', 'FRUT', 'SUGR',
8235  'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL', 'PLST', 'FZDR',
8236  0 };
8237 
8238 static const CargoLabel * const _default_refitmasks[] = {
8240  _default_refitmasks_road,
8241  _default_refitmasks_ships,
8242  _default_refitmasks_aircraft,
8243 };
8244 
8245 
8249 static void CalculateRefitMasks()
8250 {
8251  Engine *e;
8252 
8253  FOR_ALL_ENGINES(e) {
8254  EngineID engine = e->index;
8255  EngineInfo *ei = &e->info;
8256  bool only_defaultcargo;
8257 
8258  /* Did the newgrf specify any refitting? If not, use defaults. */
8259  if (_gted[engine].refittability != GRFTempEngineData::UNSET) {
8260  uint32 mask = 0;
8261  uint32 not_mask = 0;
8262  uint32 xor_mask = ei->refit_mask;
8263 
8264  /* If the original masks set by the grf are zero, the vehicle shall only carry the default cargo.
8265  * Note: After applying the translations, the vehicle may end up carrying no defined cargo. It becomes unavailable in that case. */
8266  only_defaultcargo = _gted[engine].refittability == GRFTempEngineData::EMPTY;
8267 
8268  if (_gted[engine].cargo_allowed != 0) {
8269  /* Build up the list of cargo types from the set cargo classes. */
8270  const CargoSpec *cs;
8271  FOR_ALL_CARGOSPECS(cs) {
8272  if (_gted[engine].cargo_allowed & cs->classes) SetBit(mask, cs->Index());
8273  if (_gted[engine].cargo_disallowed & cs->classes) SetBit(not_mask, cs->Index());
8274  }
8275  }
8276 
8277  ei->refit_mask = ((mask & ~not_mask) ^ xor_mask) & _cargo_mask;
8278 
8279  /* Apply explicit refit includes/excludes. */
8280  ei->refit_mask |= _gted[engine].ctt_include_mask;
8281  ei->refit_mask &= ~_gted[engine].ctt_exclude_mask;
8282  } else {
8283  uint32 xor_mask = 0;
8284 
8285  /* Don't apply default refit mask to wagons nor engines with no capacity */
8286  if (e->type != VEH_TRAIN || (e->u.rail.capacity != 0 && e->u.rail.railveh_type != RAILVEH_WAGON)) {
8287  const CargoLabel *cl = _default_refitmasks[e->type];
8288  for (uint i = 0;; i++) {
8289  if (cl[i] == 0) break;
8290 
8291  CargoID cargo = GetCargoIDByLabel(cl[i]);
8292  if (cargo == CT_INVALID) continue;
8293 
8294  SetBit(xor_mask, cargo);
8295  }
8296  }
8297 
8298  ei->refit_mask = xor_mask & _cargo_mask;
8299 
8300  /* If the mask is zero, the vehicle shall only carry the default cargo */
8301  only_defaultcargo = (ei->refit_mask == 0);
8302  }
8303 
8304  /* Clear invalid cargoslots (from default vehicles or pre-NewCargo GRFs) */
8305  if (!HasBit(_cargo_mask, ei->cargo_type)) ei->cargo_type = CT_INVALID;
8306 
8307  /* Ensure that the vehicle is either not refittable, or that the default cargo is one of the refittable cargoes.
8308  * Note: Vehicles refittable to no cargo are handle differently to vehicle refittable to a single cargo. The latter might have subtypes. */
8309  if (!only_defaultcargo && (e->type != VEH_SHIP || e->u.ship.old_refittable) && ei->cargo_type != CT_INVALID && !HasBit(ei->refit_mask, ei->cargo_type)) {
8310  ei->cargo_type = CT_INVALID;
8311  }
8312 
8313  /* Check if this engine's cargo type is valid. If not, set to the first refittable
8314  * cargo type. Finally disable the vehicle, if there is still no cargo. */
8315  if (ei->cargo_type == CT_INVALID && ei->refit_mask != 0) {
8316  /* Figure out which CTT to use for the default cargo, if it is 'first refittable'. */
8317  const uint8 *cargo_map_for_first_refittable = NULL;
8318  {
8319  const GRFFile *file = _gted[engine].defaultcargo_grf;
8320  if (file == NULL) file = e->GetGRF();
8321  if (file != NULL && file->grf_version >= 8 && file->cargo_list.Length() != 0) {
8322  cargo_map_for_first_refittable = file->cargo_map;
8323  }
8324  }
8325 
8326  if (cargo_map_for_first_refittable != NULL) {
8327  /* Use first refittable cargo from cargo translation table */
8328  byte best_local_slot = 0xFF;
8329  CargoID cargo_type;
8330  FOR_EACH_SET_CARGO_ID(cargo_type, ei->refit_mask) {
8331  byte local_slot = cargo_map_for_first_refittable[cargo_type];
8332  if (local_slot < best_local_slot) {
8333  best_local_slot = local_slot;
8334  ei->cargo_type = cargo_type;
8335  }
8336  }
8337  }
8338 
8339  if (ei->cargo_type == CT_INVALID) {
8340  /* Use first refittable cargo slot */
8341  ei->cargo_type = (CargoID)FindFirstBit(ei->refit_mask);
8342  }
8343  }
8344  if (ei->cargo_type == CT_INVALID) ei->climates = 0;
8345 
8346  /* Clear refit_mask for not refittable ships */
8347  if (e->type == VEH_SHIP && !e->u.ship.old_refittable) {
8348  ei->refit_mask = 0;
8349  }
8350  }
8351 }
8352 
8354 static void FinaliseCanals()
8355 {
8356  for (uint i = 0; i < CF_END; i++) {
8357  if (_water_feature[i].grffile != NULL) {
8360  }
8361  }
8362 }
8363 
8365 static void FinaliseEngineArray()
8366 {
8367  Engine *e;
8368 
8369  FOR_ALL_ENGINES(e) {
8370  if (e->GetGRF() == NULL) {
8371  const EngineIDMapping &eid = _engine_mngr[e->index];
8372  if (eid.grfid != INVALID_GRFID || eid.internal_id != eid.substitute_id) {
8373  e->info.string_id = STR_NEWGRF_INVALID_ENGINE;
8374  }
8375  }
8376 
8377  /* When the train does not set property 27 (misc flags), but it
8378  * is overridden by a NewGRF graphically we want to disable the
8379  * flipping possibility. */
8380  if (e->type == VEH_TRAIN && !_gted[e->index].prop27_set && e->GetGRF() != NULL && is_custom_sprite(e->u.rail.image_index)) {
8381  ClrBit(e->info.misc_flags, EF_RAIL_FLIPS);
8382  }
8383 
8384  /* Skip wagons, there livery is defined via the engine */
8385  if (e->type != VEH_TRAIN || e->u.rail.railveh_type != RAILVEH_WAGON) {
8387  SetBit(_loaded_newgrf_features.used_liveries, ls);
8388  /* Note: For ships and roadvehicles we assume that they cannot be refitted between passenger and freight */
8389 
8390  if (e->type == VEH_TRAIN) {
8391  SetBit(_loaded_newgrf_features.used_liveries, LS_FREIGHT_WAGON);
8392  switch (ls) {
8393  case LS_STEAM:
8394  case LS_DIESEL:
8395  case LS_ELECTRIC:
8396  case LS_MONORAIL:
8397  case LS_MAGLEV:
8398  SetBit(_loaded_newgrf_features.used_liveries, LS_PASSENGER_WAGON_STEAM + ls - LS_STEAM);
8399  break;
8400 
8401  case LS_DMU:
8402  case LS_EMU:
8403  SetBit(_loaded_newgrf_features.used_liveries, LS_PASSENGER_WAGON_DIESEL + ls - LS_DMU);
8404  break;
8405 
8406  default: NOT_REACHED();
8407  }
8408  }
8409  }
8410  }
8411 }
8412 
8414 static void FinaliseCargoArray()
8415 {
8416  for (CargoID c = 0; c < NUM_CARGO; c++) {
8417  CargoSpec *cs = CargoSpec::Get(c);
8418  if (!cs->IsValid()) {
8419  cs->name = cs->name_single = cs->units_volume = STR_NEWGRF_INVALID_CARGO;
8420  cs->quantifier = STR_NEWGRF_INVALID_CARGO_QUANTITY;
8421  cs->abbrev = STR_NEWGRF_INVALID_CARGO_ABBREV;
8422  }
8423  }
8424 }
8425 
8437 static bool IsHouseSpecValid(HouseSpec *hs, const HouseSpec *next1, const HouseSpec *next2, const HouseSpec *next3, const char *filename)
8438 {
8439  if (((hs->building_flags & BUILDING_HAS_2_TILES) != 0 &&
8440  (next1 == NULL || !next1->enabled || (next1->building_flags & BUILDING_HAS_1_TILE) != 0)) ||
8441  ((hs->building_flags & BUILDING_HAS_4_TILES) != 0 &&
8442  (next2 == NULL || !next2->enabled || (next2->building_flags & BUILDING_HAS_1_TILE) != 0 ||
8443  next3 == NULL || !next3->enabled || (next3->building_flags & BUILDING_HAS_1_TILE) != 0))) {
8444  hs->enabled = false;
8445  if (filename != NULL) DEBUG(grf, 1, "FinaliseHouseArray: %s defines house %d as multitile, but no suitable tiles follow. Disabling house.", filename, hs->grf_prop.local_id);
8446  return false;
8447  }
8448 
8449  /* Some places sum population by only counting north tiles. Other places use all tiles causing desyncs.
8450  * As the newgrf specs define population to be zero for non-north tiles, we just disable the offending house.
8451  * If you want to allow non-zero populations somewhen, make sure to sum the population of all tiles in all places. */
8452  if (((hs->building_flags & BUILDING_HAS_2_TILES) != 0 && next1->population != 0) ||
8453  ((hs->building_flags & BUILDING_HAS_4_TILES) != 0 && (next2->population != 0 || next3->population != 0))) {
8454  hs->enabled = false;
8455  if (filename != NULL) DEBUG(grf, 1, "FinaliseHouseArray: %s defines multitile house %d with non-zero population on additional tiles. Disabling house.", filename, hs->grf_prop.local_id);
8456  return false;
8457  }
8458 
8459  /* Substitute type is also used for override, and having an override with a different size causes crashes.
8460  * This check should only be done for NewGRF houses because grf_prop.subst_id is not set for original houses.*/
8461  if (filename != NULL && (hs->building_flags & BUILDING_HAS_1_TILE) != (HouseSpec::Get(hs->grf_prop.subst_id)->building_flags & BUILDING_HAS_1_TILE)) {
8462  hs->enabled = false;
8463  DEBUG(grf, 1, "FinaliseHouseArray: %s defines house %d with different house size then it's substitute type. Disabling house.", filename, hs->grf_prop.local_id);
8464  return false;
8465  }
8466 
8467  /* Make sure that additional parts of multitile houses are not available. */
8468  if ((hs->building_flags & BUILDING_HAS_1_TILE) == 0 && (hs->building_availability & HZ_ZONALL) != 0 && (hs->building_availability & HZ_CLIMALL) != 0) {
8469  hs->enabled = false;
8470  if (filename != NULL) DEBUG(grf, 1, "FinaliseHouseArray: %s defines house %d without a size but marked it as available. Disabling house.", filename, hs->grf_prop.local_id);
8471  return false;
8472  }
8473 
8474  return true;
8475 }
8476 
8483 static void EnsureEarlyHouse(HouseZones bitmask)
8484 {
8485  Year min_year = MAX_YEAR;
8486 
8487  for (int i = 0; i < NUM_HOUSES; i++) {
8488  HouseSpec *hs = HouseSpec::Get(i);
8489  if (hs == NULL || !hs->enabled) continue;
8490  if ((hs->building_availability & bitmask) != bitmask) continue;
8491  if (hs->min_year < min_year) min_year = hs->min_year;
8492  }
8493 
8494  if (min_year == 0) return;
8495 
8496  for (int i = 0; i < NUM_HOUSES; i++) {
8497  HouseSpec *hs = HouseSpec::Get(i);
8498  if (hs == NULL || !hs->enabled) continue;
8499  if ((hs->building_availability & bitmask) != bitmask) continue;
8500  if (hs->min_year == min_year) hs->min_year = 0;
8501  }
8502 }
8503 
8510 static void FinaliseHouseArray()
8511 {
8512  /* If there are no houses with start dates before 1930, then all houses
8513  * with start dates of 1930 have them reset to 0. This is in order to be
8514  * compatible with TTDPatch, where if no houses have start dates before
8515  * 1930 and the date is before 1930, the game pretends that this is 1930.
8516  * If there have been any houses defined with start dates before 1930 then
8517  * the dates are left alone.
8518  * On the other hand, why 1930? Just 'fix' the houses with the lowest
8519  * minimum introduction date to 0.
8520  */
8521  const GRFFile * const *end = _grf_files.End();
8522  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
8523  HouseSpec **&housespec = (*file)->housespec;
8524  if (housespec == NULL) continue;
8525 
8526  for (int i = 0; i < NUM_HOUSES_PER_GRF; i++) {
8527  HouseSpec *hs = housespec[i];
8528 
8529  if (hs == NULL) continue;
8530 
8531  const HouseSpec *next1 = (i + 1 < NUM_HOUSES_PER_GRF ? housespec[i + 1] : NULL);
8532  const HouseSpec *next2 = (i + 2 < NUM_HOUSES_PER_GRF ? housespec[i + 2] : NULL);
8533  const HouseSpec *next3 = (i + 3 < NUM_HOUSES_PER_GRF ? housespec[i + 3] : NULL);
8534 
8535  if (!IsHouseSpecValid(hs, next1, next2, next3, (*file)->filename)) continue;
8536 
8537  _house_mngr.SetEntitySpec(hs);
8538  }
8539  }
8540 
8541  for (int i = 0; i < NUM_HOUSES; i++) {
8542  HouseSpec *hs = HouseSpec::Get(i);
8543  const HouseSpec *next1 = (i + 1 < NUM_HOUSES ? HouseSpec::Get(i + 1) : NULL);
8544  const HouseSpec *next2 = (i + 2 < NUM_HOUSES ? HouseSpec::Get(i + 2) : NULL);
8545  const HouseSpec *next3 = (i + 3 < NUM_HOUSES ? HouseSpec::Get(i + 3) : NULL);
8546 
8547  /* We need to check all houses again to we are sure that multitile houses
8548  * did get consecutive IDs and none of the parts are missing. */
8549  if (!IsHouseSpecValid(hs, next1, next2, next3, NULL)) {
8550  /* GetHouseNorthPart checks 3 houses that are directly before
8551  * it in the house pool. If any of those houses have multi-tile
8552  * flags set it assumes it's part of a multitile house. Since
8553  * we can have invalid houses in the pool marked as disabled, we
8554  * don't want to have them influencing valid tiles. As such set
8555  * building_flags to zero here to make sure any house following
8556  * this one in the pool is properly handled as 1x1 house. */
8557  hs->building_flags = TILE_NO_FLAG;
8558  }
8559  }
8560 
8561  HouseZones climate_mask = (HouseZones)(1 << (_settings_game.game_creation.landscape + 12));
8562  EnsureEarlyHouse(HZ_ZON1 | climate_mask);
8563  EnsureEarlyHouse(HZ_ZON2 | climate_mask);
8564  EnsureEarlyHouse(HZ_ZON3 | climate_mask);
8565  EnsureEarlyHouse(HZ_ZON4 | climate_mask);
8566  EnsureEarlyHouse(HZ_ZON5 | climate_mask);
8567 
8568  if (_settings_game.game_creation.landscape == LT_ARCTIC) {
8574  }
8575 }
8576 
8583 {
8584  const GRFFile * const *end = _grf_files.End();
8585  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
8586  IndustrySpec **&industryspec = (*file)->industryspec;
8587  IndustryTileSpec **&indtspec = (*file)->indtspec;
8588  if (industryspec != NULL) {
8589  for (int i = 0; i < NUM_INDUSTRYTYPES_PER_GRF; i++) {
8590  IndustrySpec *indsp = industryspec[i];
8591 
8592  if (indsp != NULL && indsp->enabled) {
8593  StringID strid;
8594  /* process the conversion of text at the end, so to be sure everything will be fine
8595  * and available. Check if it does not return undefind marker, which is a very good sign of a
8596  * substitute industry who has not changed the string been examined, thus using it as such */
8597  strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->name);
8598  if (strid != STR_UNDEFINED) indsp->name = strid;
8599 
8600  strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->closure_text);
8601  if (strid != STR_UNDEFINED) indsp->closure_text = strid;
8602 
8603  strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->production_up_text);
8604  if (strid != STR_UNDEFINED) indsp->production_up_text = strid;
8605 
8606  strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->production_down_text);
8607  if (strid != STR_UNDEFINED) indsp->production_down_text = strid;
8608 
8609  strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->new_industry_text);
8610  if (strid != STR_UNDEFINED) indsp->new_industry_text = strid;
8611 
8612  if (indsp->station_name != STR_NULL) {
8613  /* STR_NULL (0) can be set by grf. It has a meaning regarding assignation of the
8614  * station's name. Don't want to lose the value, therefore, do not process. */
8615  strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->station_name);
8616  if (strid != STR_UNDEFINED) indsp->station_name = strid;
8617  }
8618 
8619  _industry_mngr.SetEntitySpec(indsp);
8620  _loaded_newgrf_features.has_newindustries = true;
8621  }
8622  }
8623  }
8624 
8625  if (indtspec != NULL) {
8626  for (int i = 0; i < NUM_INDUSTRYTILES_PER_GRF; i++) {
8627  IndustryTileSpec *indtsp = indtspec[i];
8628  if (indtsp != NULL) {
8629  _industile_mngr.SetEntitySpec(indtsp);
8630  }
8631  }
8632  }
8633  }
8634 
8635  for (uint j = 0; j < NUM_INDUSTRYTYPES; j++) {
8636  IndustrySpec *indsp = &_industry_specs[j];
8637  if (indsp->enabled && indsp->grf_prop.grffile != NULL) {
8638  for (uint i = 0; i < 3; i++) {
8639  indsp->conflicting[i] = MapNewGRFIndustryType(indsp->conflicting[i], indsp->grf_prop.grffile->grfid);
8640  }
8641  }
8642  if (!indsp->enabled) {
8643  indsp->name = STR_NEWGRF_INVALID_INDUSTRYTYPE;
8644  }
8645  }
8646 }
8647 
8654 {
8655  const GRFFile * const *end = _grf_files.End();
8656  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
8657  ObjectSpec **&objectspec = (*file)->objectspec;
8658  if (objectspec != NULL) {
8659  for (int i = 0; i < NUM_OBJECTS_PER_GRF; i++) {
8660  if (objectspec[i] != NULL && objectspec[i]->grf_prop.grffile != NULL && objectspec[i]->enabled) {
8661  _object_mngr.SetEntitySpec(objectspec[i]);
8662  }
8663  }
8664  }
8665  }
8666 }
8667 
8674 {
8675  const GRFFile * const *end = _grf_files.End();
8676  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
8677  AirportSpec **&airportspec = (*file)->airportspec;
8678  if (airportspec != NULL) {
8679  for (int i = 0; i < NUM_AIRPORTS_PER_GRF; i++) {
8680  if (airportspec[i] != NULL && airportspec[i]->enabled) {
8681  _airport_mngr.SetEntitySpec(airportspec[i]);
8682  }
8683  }
8684  }
8685 
8686  AirportTileSpec **&airporttilespec = (*file)->airtspec;
8687  if (airporttilespec != NULL) {
8688  for (uint i = 0; i < NUM_AIRPORTTILES_PER_GRF; i++) {
8689  if (airporttilespec[i] != NULL && airporttilespec[i]->enabled) {
8690  _airporttile_mngr.SetEntitySpec(airporttilespec[i]);
8691  }
8692  }
8693  }
8694  }
8695 }
8696 
8697 /* Here we perform initial decoding of some special sprites (as are they
8698  * described at http://www.ttdpatch.net/src/newgrf.txt, but this is only a very
8699  * partial implementation yet).
8700  * XXX: We consider GRF files trusted. It would be trivial to exploit OTTD by
8701  * a crafted invalid GRF file. We should tell that to the user somehow, or
8702  * better make this more robust in the future. */
8703 static void DecodeSpecialSprite(byte *buf, uint num, GrfLoadingStage stage)
8704 {
8705  /* XXX: There is a difference between staged loading in TTDPatch and
8706  * here. In TTDPatch, for some reason actions 1 and 2 are carried out
8707  * during stage 1, whilst action 3 is carried out during stage 2 (to
8708  * "resolve" cargo IDs... wtf). This is a little problem, because cargo
8709  * IDs are valid only within a given set (action 1) block, and may be
8710  * overwritten after action 3 associates them. But overwriting happens
8711  * in an earlier stage than associating, so... We just process actions
8712  * 1 and 2 in stage 2 now, let's hope that won't get us into problems.
8713  * --pasky
8714  * We need a pre-stage to set up GOTO labels of Action 0x10 because the grf
8715  * is not in memory and scanning the file every time would be too expensive.
8716  * In other stages we skip action 0x10 since it's already dealt with. */
8717  static const SpecialSpriteHandler handlers[][GLS_END] = {
8718  /* 0x00 */ { NULL, SafeChangeInfo, NULL, NULL, ReserveChangeInfo, FeatureChangeInfo, },
8719  /* 0x01 */ { SkipAct1, SkipAct1, SkipAct1, SkipAct1, SkipAct1, NewSpriteSet, },
8720  /* 0x02 */ { NULL, NULL, NULL, NULL, NULL, NewSpriteGroup, },
8721  /* 0x03 */ { NULL, GRFUnsafe, NULL, NULL, NULL, FeatureMapSpriteGroup, },
8722  /* 0x04 */ { NULL, NULL, NULL, NULL, NULL, FeatureNewName, },
8723  /* 0x05 */ { SkipAct5, SkipAct5, SkipAct5, SkipAct5, SkipAct5, GraphicsNew, },
8724  /* 0x06 */ { NULL, NULL, NULL, CfgApply, CfgApply, CfgApply, },
8725  /* 0x07 */ { NULL, NULL, NULL, NULL, SkipIf, SkipIf, },
8726  /* 0x08 */ { ScanInfo, NULL, NULL, GRFInfo, GRFInfo, GRFInfo, },
8727  /* 0x09 */ { NULL, NULL, NULL, SkipIf, SkipIf, SkipIf, },
8728  /* 0x0A */ { SkipActA, SkipActA, SkipActA, SkipActA, SkipActA, SpriteReplace, },
8729  /* 0x0B */ { NULL, NULL, NULL, GRFLoadError, GRFLoadError, GRFLoadError, },
8730  /* 0x0C */ { NULL, NULL, NULL, GRFComment, NULL, GRFComment, },
8731  /* 0x0D */ { NULL, SafeParamSet, NULL, ParamSet, ParamSet, ParamSet, },
8732  /* 0x0E */ { NULL, SafeGRFInhibit, NULL, GRFInhibit, GRFInhibit, GRFInhibit, },
8733  /* 0x0F */ { NULL, GRFUnsafe, NULL, FeatureTownName, NULL, NULL, },
8734  /* 0x10 */ { NULL, NULL, DefineGotoLabel, NULL, NULL, NULL, },
8735  /* 0x11 */ { SkipAct11,GRFUnsafe, SkipAct11, GRFSound, SkipAct11, GRFSound, },
8737  /* 0x13 */ { NULL, NULL, NULL, NULL, NULL, TranslateGRFStrings, },
8738  /* 0x14 */ { StaticGRFInfo, NULL, NULL, NULL, NULL, NULL, },
8739  };
8740 
8741  GRFLocation location(_cur.grfconfig->ident.grfid, _cur.nfo_line);
8742 
8743  GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.find(location);
8744  if (it == _grf_line_to_action6_sprite_override.end()) {
8745  /* No preloaded sprite to work with; read the
8746  * pseudo sprite content. */
8747  FioReadBlock(buf, num);
8748  } else {
8749  /* Use the preloaded sprite data. */
8750  buf = _grf_line_to_action6_sprite_override[location];
8751  grfmsg(7, "DecodeSpecialSprite: Using preloaded pseudo sprite data");
8752 
8753  /* Skip the real (original) content of this action. */
8754  FioSeekTo(num, SEEK_CUR);
8755  }
8756 
8757  ByteReader br(buf, buf + num);
8758  ByteReader *bufp = &br;
8759 
8760  try {
8761  byte action = bufp->ReadByte();
8762 
8763  if (action == 0xFF) {
8764  grfmsg(2, "DecodeSpecialSprite: Unexpected data block, skipping");
8765  } else if (action == 0xFE) {
8766  grfmsg(2, "DecodeSpecialSprite: Unexpected import block, skipping");
8767  } else if (action >= lengthof(handlers)) {
8768  grfmsg(7, "DecodeSpecialSprite: Skipping unknown action 0x%02X", action);
8769  } else if (handlers[action][stage] == NULL) {
8770  grfmsg(7, "DecodeSpecialSprite: Skipping action 0x%02X in stage %d", action, stage);
8771  } else {
8772  grfmsg(7, "DecodeSpecialSprite: Handling action 0x%02X in stage %d", action, stage);
8773  handlers[action][stage](bufp);
8774  }
8775  } catch (...) {
8776  grfmsg(1, "DecodeSpecialSprite: Tried to read past end of pseudo-sprite data");
8777  DisableGrf(STR_NEWGRF_ERROR_READ_BOUNDS);
8778  }
8779 }
8780 
8781 
8783 extern const byte _grf_cont_v2_sig[8] = {'G', 'R', 'F', 0x82, 0x0D, 0x0A, 0x1A, 0x0A};
8784 
8790 {
8791  size_t pos = FioGetPos();
8792 
8793  if (FioReadWord() == 0) {
8794  /* Check for GRF container version 2, which is identified by the bytes
8795  * '47 52 46 82 0D 0A 1A 0A' at the start of the file. */
8796  for (uint i = 0; i < lengthof(_grf_cont_v2_sig); i++) {
8797  if (FioReadByte() != _grf_cont_v2_sig[i]) return 0; // Invalid format
8798  }
8799 
8800  return 2;
8801  }
8802 
8803  /* Container version 1 has no header, rewind to start. */
8804  FioSeekTo(pos, SEEK_SET);
8805  return 1;
8806 }
8807 
8815 void LoadNewGRFFile(GRFConfig *config, uint file_index, GrfLoadingStage stage, Subdirectory subdir)
8816 {
8817  const char *filename = config->filename;
8818 
8819  /* A .grf file is activated only if it was active when the game was
8820  * started. If a game is loaded, only its active .grfs will be
8821  * reactivated, unless "loadallgraphics on" is used. A .grf file is
8822  * considered active if its action 8 has been processed, i.e. its
8823  * action 8 hasn't been skipped using an action 7.
8824  *
8825  * During activation, only actions 0, 1, 2, 3, 4, 5, 7, 8, 9, 0A and 0B are
8826  * carried out. All others are ignored, because they only need to be
8827  * processed once at initialization. */
8828  if (stage != GLS_FILESCAN && stage != GLS_SAFETYSCAN && stage != GLS_LABELSCAN) {
8829  _cur.grffile = GetFileByFilename(filename);
8830  if (_cur.grffile == NULL) usererror("File '%s' lost in cache.\n", filename);
8831  if (stage == GLS_RESERVE && config->status != GCS_INITIALISED) return;
8832  if (stage == GLS_ACTIVATION && !HasBit(config->flags, GCF_RESERVED)) return;
8833  }
8834 
8835  if (file_index >= MAX_FILE_SLOTS) {
8836  DEBUG(grf, 0, "'%s' is not loaded as the maximum number of file slots has been reached", filename);
8837  config->status = GCS_DISABLED;
8838  config->error = new GRFError(STR_NEWGRF_ERROR_MSG_FATAL, STR_NEWGRF_ERROR_TOO_MANY_NEWGRFS_LOADED);
8839  return;
8840  }
8841 
8842  FioOpenFile(file_index, filename, subdir);
8843  _cur.file_index = file_index; // XXX
8844  _palette_remap_grf[_cur.file_index] = (config->palette & GRFP_USE_MASK);
8845 
8846  _cur.grfconfig = config;
8847 
8848  DEBUG(grf, 2, "LoadNewGRFFile: Reading NewGRF-file '%s'", filename);
8849 
8851  if (_cur.grf_container_ver == 0) {
8852  DEBUG(grf, 7, "LoadNewGRFFile: Custom .grf has invalid format");
8853  return;
8854  }
8855 
8856  if (stage == GLS_INIT || stage == GLS_ACTIVATION) {
8857  /* We need the sprite offsets in the init stage for NewGRF sounds
8858  * and in the activation stage for real sprites. */
8860  } else {
8861  /* Skip sprite section offset if present. */
8862  if (_cur.grf_container_ver >= 2) FioReadDword();
8863  }
8864 
8865  if (_cur.grf_container_ver >= 2) {
8866  /* Read compression value. */
8867  byte compression = FioReadByte();
8868  if (compression != 0) {
8869  DEBUG(grf, 7, "LoadNewGRFFile: Unsupported compression format");
8870  return;
8871  }
8872  }
8873 
8874  /* Skip the first sprite; we don't care about how many sprites this
8875  * does contain; newest TTDPatches and George's longvehicles don't
8876  * neither, apparently. */
8877  uint32 num = _cur.grf_container_ver >= 2 ? FioReadDword() : FioReadWord();
8878  if (num == 4 && FioReadByte() == 0xFF) {
8879  FioReadDword();
8880  } else {
8881  DEBUG(grf, 7, "LoadNewGRFFile: Custom .grf has invalid format");
8882  return;
8883  }
8884 
8885  _cur.ClearDataForNextFile();
8886 
8888 
8889  while ((num = (_cur.grf_container_ver >= 2 ? FioReadDword() : FioReadWord())) != 0) {
8890  byte type = FioReadByte();
8891  _cur.nfo_line++;
8892 
8893  if (type == 0xFF) {
8894  if (_cur.skip_sprites == 0) {
8895  DecodeSpecialSprite(buf.Allocate(num), num, stage);
8896 
8897  /* Stop all processing if we are to skip the remaining sprites */
8898  if (_cur.skip_sprites == -1) break;
8899 
8900  continue;
8901  } else {
8902  FioSkipBytes(num);
8903  }
8904  } else {
8905  if (_cur.skip_sprites == 0) {
8906  grfmsg(0, "LoadNewGRFFile: Unexpected sprite, disabling");
8907  DisableGrf(STR_NEWGRF_ERROR_UNEXPECTED_SPRITE);
8908  break;
8909  }
8910 
8911  if (_cur.grf_container_ver >= 2 && type == 0xFD) {
8912  /* Reference to data section. Container version >= 2 only. */
8913  FioSkipBytes(num);
8914  } else {
8915  FioSkipBytes(7);
8916  SkipSpriteData(type, num - 8);
8917  }
8918  }
8919 
8920  if (_cur.skip_sprites > 0) _cur.skip_sprites--;
8921  }
8922 }
8923 
8931 static void ActivateOldShore()
8932 {
8933  /* Use default graphics, if no shore sprites were loaded.
8934  * Should not happen, as the base set's extra grf should include some. */
8935  if (_loaded_newgrf_features.shore == SHORE_REPLACE_NONE) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_A;
8936 
8937  if (_loaded_newgrf_features.shore != SHORE_REPLACE_ACTION_5) {
8938  DupSprite(SPR_ORIGINALSHORE_START + 1, SPR_SHORE_BASE + 1); // SLOPE_W
8939  DupSprite(SPR_ORIGINALSHORE_START + 2, SPR_SHORE_BASE + 2); // SLOPE_S
8940  DupSprite(SPR_ORIGINALSHORE_START + 6, SPR_SHORE_BASE + 3); // SLOPE_SW
8941  DupSprite(SPR_ORIGINALSHORE_START + 0, SPR_SHORE_BASE + 4); // SLOPE_E
8942  DupSprite(SPR_ORIGINALSHORE_START + 4, SPR_SHORE_BASE + 6); // SLOPE_SE
8943  DupSprite(SPR_ORIGINALSHORE_START + 3, SPR_SHORE_BASE + 8); // SLOPE_N
8944  DupSprite(SPR_ORIGINALSHORE_START + 7, SPR_SHORE_BASE + 9); // SLOPE_NW
8945  DupSprite(SPR_ORIGINALSHORE_START + 5, SPR_SHORE_BASE + 12); // SLOPE_NE
8946  }
8947 
8948  if (_loaded_newgrf_features.shore == SHORE_REPLACE_ACTION_A) {
8949  DupSprite(SPR_FLAT_GRASS_TILE + 16, SPR_SHORE_BASE + 0); // SLOPE_STEEP_S
8950  DupSprite(SPR_FLAT_GRASS_TILE + 17, SPR_SHORE_BASE + 5); // SLOPE_STEEP_W
8951  DupSprite(SPR_FLAT_GRASS_TILE + 7, SPR_SHORE_BASE + 7); // SLOPE_WSE
8952  DupSprite(SPR_FLAT_GRASS_TILE + 15, SPR_SHORE_BASE + 10); // SLOPE_STEEP_N
8953  DupSprite(SPR_FLAT_GRASS_TILE + 11, SPR_SHORE_BASE + 11); // SLOPE_NWS
8954  DupSprite(SPR_FLAT_GRASS_TILE + 13, SPR_SHORE_BASE + 13); // SLOPE_ENW
8955  DupSprite(SPR_FLAT_GRASS_TILE + 14, SPR_SHORE_BASE + 14); // SLOPE_SEN
8956  DupSprite(SPR_FLAT_GRASS_TILE + 18, SPR_SHORE_BASE + 15); // SLOPE_STEEP_E
8957 
8958  /* XXX - SLOPE_EW, SLOPE_NS are currently not used.
8959  * If they would be used somewhen, then these grass tiles will most like not look as needed */
8960  DupSprite(SPR_FLAT_GRASS_TILE + 5, SPR_SHORE_BASE + 16); // SLOPE_EW
8961  DupSprite(SPR_FLAT_GRASS_TILE + 10, SPR_SHORE_BASE + 17); // SLOPE_NS
8962  }
8963 }
8964 
8969 {
8970  extern const PriceBaseSpec _price_base_specs[];
8972  static const uint32 override_features = (1 << GSF_TRAINS) | (1 << GSF_ROADVEHICLES) | (1 << GSF_SHIPS) | (1 << GSF_AIRCRAFT);
8973 
8974  /* Evaluate grf overrides */
8975  int num_grfs = _grf_files.Length();
8976  int *grf_overrides = AllocaM(int, num_grfs);
8977  for (int i = 0; i < num_grfs; i++) {
8978  grf_overrides[i] = -1;
8979 
8980  GRFFile *source = _grf_files[i];
8981  uint32 override = _grf_id_overrides[source->grfid];
8982  if (override == 0) continue;
8983 
8984  GRFFile *dest = GetFileByGRFID(override);
8985  if (dest == NULL) continue;
8986 
8987  grf_overrides[i] = _grf_files.FindIndex(dest);
8988  assert(grf_overrides[i] >= 0);
8989  }
8990 
8991  /* Override features and price base multipliers of earlier loaded grfs */
8992  for (int i = 0; i < num_grfs; i++) {
8993  if (grf_overrides[i] < 0 || grf_overrides[i] >= i) continue;
8994  GRFFile *source = _grf_files[i];
8995  GRFFile *dest = _grf_files[grf_overrides[i]];
8996 
8997  uint32 features = (source->grf_features | dest->grf_features) & override_features;
8998  source->grf_features |= features;
8999  dest->grf_features |= features;
9000 
9001  for (Price p = PR_BEGIN; p < PR_END; p++) {
9002  /* No price defined -> nothing to do */
9003  if (!HasBit(features, _price_base_specs[p].grf_feature) || source->price_base_multipliers[p] == INVALID_PRICE_MODIFIER) continue;
9004  DEBUG(grf, 3, "'%s' overrides price base multiplier %d of '%s'", source->filename, p, dest->filename);
9005  dest->price_base_multipliers[p] = source->price_base_multipliers[p];
9006  }
9007  }
9008 
9009  /* Propagate features and price base multipliers of afterwards loaded grfs, if none is present yet */
9010  for (int i = num_grfs - 1; i >= 0; i--) {
9011  if (grf_overrides[i] < 0 || grf_overrides[i] <= i) continue;
9012  GRFFile *source = _grf_files[i];
9013  GRFFile *dest = _grf_files[grf_overrides[i]];
9014 
9015  uint32 features = (source->grf_features | dest->grf_features) & override_features;
9016  source->grf_features |= features;
9017  dest->grf_features |= features;
9018 
9019  for (Price p = PR_BEGIN; p < PR_END; p++) {
9020  /* Already a price defined -> nothing to do */
9021  if (!HasBit(features, _price_base_specs[p].grf_feature) || dest->price_base_multipliers[p] != INVALID_PRICE_MODIFIER) continue;
9022  DEBUG(grf, 3, "Price base multiplier %d from '%s' propagated to '%s'", p, source->filename, dest->filename);
9023  dest->price_base_multipliers[p] = source->price_base_multipliers[p];
9024  }
9025  }
9026 
9027  /* The 'master grf' now have the correct multipliers. Assign them to the 'addon grfs' to make everything consistent. */
9028  for (int i = 0; i < num_grfs; i++) {
9029  if (grf_overrides[i] < 0) continue;
9030  GRFFile *source = _grf_files[i];
9031  GRFFile *dest = _grf_files[grf_overrides[i]];
9032 
9033  uint32 features = (source->grf_features | dest->grf_features) & override_features;
9034  source->grf_features |= features;
9035  dest->grf_features |= features;
9036 
9037  for (Price p = PR_BEGIN; p < PR_END; p++) {
9038  if (!HasBit(features, _price_base_specs[p].grf_feature)) continue;
9039  if (source->price_base_multipliers[p] != dest->price_base_multipliers[p]) {
9040  DEBUG(grf, 3, "Price base multiplier %d from '%s' propagated to '%s'", p, dest->filename, source->filename);
9041  }
9042  source->price_base_multipliers[p] = dest->price_base_multipliers[p];
9043  }
9044  }
9045 
9046  /* Apply fallback prices for grf version < 8 */
9047  const GRFFile * const *end = _grf_files.End();
9048  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
9049  if ((*file)->grf_version >= 8) continue;
9050  PriceMultipliers &price_base_multipliers = (*file)->price_base_multipliers;
9051  for (Price p = PR_BEGIN; p < PR_END; p++) {
9052  Price fallback_price = _price_base_specs[p].fallback_price;
9053  if (fallback_price != INVALID_PRICE && price_base_multipliers[p] == INVALID_PRICE_MODIFIER) {
9054  /* No price multiplier has been set.
9055  * So copy the multiplier from the fallback price, maybe a multiplier was set there. */
9056  price_base_multipliers[p] = price_base_multipliers[fallback_price];
9057  }
9058  }
9059  }
9060 
9061  /* Decide local/global scope of price base multipliers */
9062  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
9063  PriceMultipliers &price_base_multipliers = (*file)->price_base_multipliers;
9064  for (Price p = PR_BEGIN; p < PR_END; p++) {
9065  if (price_base_multipliers[p] == INVALID_PRICE_MODIFIER) {
9066  /* No multiplier was set; set it to a neutral value */
9067  price_base_multipliers[p] = 0;
9068  } else {
9069  if (!HasBit((*file)->grf_features, _price_base_specs[p].grf_feature)) {
9070  /* The grf does not define any objects of the feature,
9071  * so it must be a difficulty setting. Apply it globally */
9072  DEBUG(grf, 3, "'%s' sets global price base multiplier %d", (*file)->filename, p);
9073  SetPriceBaseMultiplier(p, price_base_multipliers[p]);
9074  price_base_multipliers[p] = 0;
9075  } else {
9076  DEBUG(grf, 3, "'%s' sets local price base multiplier %d", (*file)->filename, p);
9077  }
9078  }
9079  }
9080  }
9081 }
9082 
9083 extern void InitGRFTownGeneratorNames();
9084 
9086 static void AfterLoadGRFs()
9087 {
9088  for (StringIDMapping *it = _string_to_grf_mapping.Begin(); it != _string_to_grf_mapping.End(); it++) {
9089  *it->target = MapGRFStringID(it->grfid, it->source);
9090  }
9091  _string_to_grf_mapping.Clear();
9092 
9093  /* Free the action 6 override sprites. */
9094  for (GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.begin(); it != _grf_line_to_action6_sprite_override.end(); it++) {
9095  free((*it).second);
9096  }
9097  _grf_line_to_action6_sprite_override.clear();
9098 
9099  /* Polish cargoes */
9101 
9102  /* Pre-calculate all refit masks after loading GRF files. */
9104 
9105  /* Polish engines */
9107 
9108  /* Set the actually used Canal properties */
9109  FinaliseCanals();
9110 
9111  /* Add all new houses to the house array. */
9113 
9114  /* Add all new industries to the industry array. */
9116 
9117  /* Add all new objects to the object array. */
9119 
9121 
9122  /* Sort the list of industry types. */
9124 
9125  /* Create dynamic list of industry legends for smallmap_gui.cpp */
9127 
9128  /* Build the routemap legend, based on the available cargos */
9130 
9131  /* Add all new airports to the airports array. */
9133  BindAirportSpecs();
9134 
9135  /* Update the townname generators list */
9137 
9138  /* Run all queued vehicle list order changes */
9140 
9141  /* Load old shore sprites in new position, if they were replaced by ActionA */
9142  ActivateOldShore();
9143 
9144  /* Set up custom rail types */
9145  InitRailTypes();
9146 
9147  Engine *e;
9148  FOR_ALL_ENGINES_OF_TYPE(e, VEH_ROAD) {
9149  if (_gted[e->index].rv_max_speed != 0) {
9150  /* Set RV maximum speed from the mph/0.8 unit value */
9151  e->u.road.max_speed = _gted[e->index].rv_max_speed * 4;
9152  }
9153  }
9154 
9155  FOR_ALL_ENGINES_OF_TYPE(e, VEH_TRAIN) {
9156  RailType railtype = GetRailTypeByLabel(_gted[e->index].railtypelabel);
9157  if (railtype == INVALID_RAILTYPE) {
9158  /* Rail type is not available, so disable this engine */
9159  e->info.climates = 0;
9160  } else {
9161  e->u.rail.railtype = railtype;
9162  }
9163  }
9164 
9166 
9168 
9169  /* Deallocate temporary loading data */
9170  free(_gted);
9171  _grm_sprites.clear();
9172 }
9173 
9180 void LoadNewGRF(uint load_index, uint file_index, uint num_baseset)
9181 {
9182  /* In case of networking we need to "sync" the start values
9183  * so all NewGRFs are loaded equally. For this we use the
9184  * start date of the game and we set the counters, etc. to
9185  * 0 so they're the same too. */
9186  Date date = _date;
9187  Year year = _cur_year;
9188  DateFract date_fract = _date_fract;
9189  uint16 tick_counter = _tick_counter;
9190  byte display_opt = _display_opt;
9191 
9192  if (_networking) {
9194  _date = ConvertYMDToDate(_cur_year, 0, 1);
9195  _date_fract = 0;
9196  _tick_counter = 0;
9197  _display_opt = 0;
9198  }
9199 
9201 
9202  ResetNewGRFData();
9203 
9204  /*
9205  * Reset the status of all files, so we can 'retry' to load them.
9206  * This is needed when one for example rearranges the NewGRFs in-game
9207  * and a previously disabled NewGRF becomes useable. If it would not
9208  * be reset, the NewGRF would remain disabled even though it should
9209  * have been enabled.
9210  */
9211  for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
9212  if (c->status != GCS_NOT_FOUND) c->status = GCS_UNKNOWN;
9213  }
9214 
9215  _cur.spriteid = load_index;
9216 
9217  /* Load newgrf sprites
9218  * in each loading stage, (try to) open each file specified in the config
9219  * and load information from it. */
9220  for (GrfLoadingStage stage = GLS_LABELSCAN; stage <= GLS_ACTIVATION; stage++) {
9221  /* Set activated grfs back to will-be-activated between reservation- and activation-stage.
9222  * This ensures that action7/9 conditions 0x06 - 0x0A work correctly. */
9223  for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
9224  if (c->status == GCS_ACTIVATED) c->status = GCS_INITIALISED;
9225  }
9226 
9227  if (stage == GLS_RESERVE) {
9228  static const uint32 overrides[][2] = {
9229  { 0x44442202, 0x44440111 }, // UKRS addons modifies UKRS
9230  { 0x6D620402, 0x6D620401 }, // DBSetXL ECS extension modifies DBSetXL
9231  { 0x4D656f20, 0x4D656F17 }, // LV4cut modifies LV4
9232  };
9233  for (size_t i = 0; i < lengthof(overrides); i++) {
9234  SetNewGRFOverride(BSWAP32(overrides[i][0]), BSWAP32(overrides[i][1]));
9235  }
9236  }
9237 
9238  uint slot = file_index;
9239  uint num_non_static = 0;
9240 
9241  _cur.stage = stage;
9242  for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
9243  if (c->status == GCS_DISABLED || c->status == GCS_NOT_FOUND) continue;
9244  if (stage > GLS_INIT && HasBit(c->flags, GCF_INIT_ONLY)) continue;
9245 
9246  Subdirectory subdir = slot < file_index + num_baseset ? BASESET_DIR : NEWGRF_DIR;
9247  if (!FioCheckFileExists(c->filename, subdir)) {
9248  DEBUG(grf, 0, "NewGRF file is missing '%s'; disabling", c->filename);
9249  c->status = GCS_NOT_FOUND;
9250  continue;
9251  }
9252 
9253  if (stage == GLS_LABELSCAN) InitNewGRFFile(c);
9254 
9255  if (!HasBit(c->flags, GCF_STATIC) && !HasBit(c->flags, GCF_SYSTEM)) {
9256  if (num_non_static == NETWORK_MAX_GRF_COUNT) {
9257  DEBUG(grf, 0, "'%s' is not loaded as the maximum number of non-static GRFs has been reached", c->filename);
9258  c->status = GCS_DISABLED;
9259  c->error = new GRFError(STR_NEWGRF_ERROR_MSG_FATAL, STR_NEWGRF_ERROR_TOO_MANY_NEWGRFS_LOADED);
9260  continue;
9261  }
9262  num_non_static++;
9263  }
9264  LoadNewGRFFile(c, slot++, stage, subdir);
9265  if (stage == GLS_RESERVE) {
9266  SetBit(c->flags, GCF_RESERVED);
9267  } else if (stage == GLS_ACTIVATION) {
9268  ClrBit(c->flags, GCF_RESERVED);
9269  assert(GetFileByGRFID(c->ident.grfid) == _cur.grffile);
9272  DEBUG(sprite, 2, "LoadNewGRF: Currently %i sprites are loaded", _cur.spriteid);
9273  } else if (stage == GLS_INIT && HasBit(c->flags, GCF_INIT_ONLY)) {
9274  /* We're not going to activate this, so free whatever data we allocated */
9276  }
9277  }
9278  }
9279 
9280  /* Pseudo sprite processing is finished; free temporary stuff */
9281  _cur.ClearDataForNextFile();
9282 
9283  /* Call any functions that should be run after GRFs have been loaded. */
9284  AfterLoadGRFs();
9285 
9286  /* Now revert back to the original situation */
9287  _cur_year = year;
9288  _date = date;
9289  _date_fract = date_fract;
9290  _tick_counter = tick_counter;
9291  _display_opt = display_opt;
9292 }