OpenTTD
newgrf.cpp
Go to the documentation of this file.
1 /* $Id: newgrf.cpp 27769 2017-03-05 14:45:13Z frosch $ */
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  /* FALL THROUGH */
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 }
3676 
3685 static ChangeInfoResult AirportChangeInfo(uint airport, int numinfo, int prop, ByteReader *buf)
3686 {
3688 
3689  if (airport + numinfo > NUM_AIRPORTS_PER_GRF) {
3690  grfmsg(1, "AirportChangeInfo: Too many airports, trying id (%u), max (%u). Ignoring.", airport + numinfo, NUM_AIRPORTS_PER_GRF);
3691  return CIR_INVALID_ID;
3692  }
3693 
3694  /* Allocate industry specs if they haven't been allocated already. */
3695  if (_cur.grffile->airportspec == NULL) {
3696  _cur.grffile->airportspec = CallocT<AirportSpec*>(NUM_AIRPORTS_PER_GRF);
3697  }
3698 
3699  for (int i = 0; i < numinfo; i++) {
3700  AirportSpec *as = _cur.grffile->airportspec[airport + i];
3701 
3702  if (as == NULL && prop != 0x08 && prop != 0x09) {
3703  grfmsg(2, "AirportChangeInfo: Attempt to modify undefined airport %u, ignoring", airport + i);
3704  return CIR_INVALID_ID;
3705  }
3706 
3707  switch (prop) {
3708  case 0x08: { // Modify original airport
3709  byte subs_id = buf->ReadByte();
3710 
3711  if (subs_id == 0xFF) {
3712  /* Instead of defining a new airport, an airport id
3713  * of 0xFF disables the old airport with the current id. */
3714  AirportSpec::GetWithoutOverride(airport + i)->enabled = false;
3715  continue;
3716  } else if (subs_id >= NEW_AIRPORT_OFFSET) {
3717  /* The substitute id must be one of the original airports. */
3718  grfmsg(2, "AirportChangeInfo: Attempt to use new airport %u as substitute airport for %u. Ignoring.", subs_id, airport + i);
3719  continue;
3720  }
3721 
3722  AirportSpec **spec = &_cur.grffile->airportspec[airport + i];
3723  /* Allocate space for this airport.
3724  * Only need to do it once. If ever it is called again, it should not
3725  * do anything */
3726  if (*spec == NULL) {
3727  *spec = MallocT<AirportSpec>(1);
3728  as = *spec;
3729 
3730  memcpy(as, AirportSpec::GetWithoutOverride(subs_id), sizeof(*as));
3731  as->enabled = true;
3732  as->grf_prop.local_id = airport + i;
3733  as->grf_prop.subst_id = subs_id;
3734  as->grf_prop.grffile = _cur.grffile;
3735  /* override the default airport */
3736  _airport_mngr.Add(airport + i, _cur.grffile->grfid, subs_id);
3737  /* Create a copy of the original tiletable so it can be freed later. */
3738  DuplicateTileTable(as);
3739  }
3740  break;
3741  }
3742 
3743  case 0x0A: { // Set airport layout
3744  as->num_table = buf->ReadByte(); // Number of layaouts
3745  as->rotation = MallocT<Direction>(as->num_table);
3746  uint32 defsize = buf->ReadDWord(); // Total size of the definition
3747  AirportTileTable **tile_table = CallocT<AirportTileTable*>(as->num_table); // Table with tiles to compose the airport
3748  AirportTileTable *att = CallocT<AirportTileTable>(defsize); // Temporary array to read the tile layouts from the GRF
3749  int size;
3750  const AirportTileTable *copy_from;
3751  try {
3752  for (byte j = 0; j < as->num_table; j++) {
3753  as->rotation[j] = (Direction)buf->ReadByte();
3754  for (int k = 0;; k++) {
3755  att[k].ti.x = buf->ReadByte(); // Offsets from northermost tile
3756  att[k].ti.y = buf->ReadByte();
3757 
3758  if (att[k].ti.x == 0 && att[k].ti.y == 0x80) {
3759  /* Not the same terminator. The one we are using is rather
3760  * x = -80, y = 0 . So, adjust it. */
3761  att[k].ti.x = -0x80;
3762  att[k].ti.y = 0;
3763  att[k].gfx = 0;
3764 
3765  size = k + 1;
3766  copy_from = att;
3767  break;
3768  }
3769 
3770  att[k].gfx = buf->ReadByte();
3771 
3772  if (att[k].gfx == 0xFE) {
3773  /* Use a new tile from this GRF */
3774  int local_tile_id = buf->ReadWord();
3775 
3776  /* Read the ID from the _airporttile_mngr. */
3777  uint16 tempid = _airporttile_mngr.GetID(local_tile_id, _cur.grffile->grfid);
3778 
3779  if (tempid == INVALID_AIRPORTTILE) {
3780  grfmsg(2, "AirportChangeInfo: Attempt to use airport tile %u with airport id %u, not yet defined. Ignoring.", local_tile_id, airport + i);
3781  } else {
3782  /* Declared as been valid, can be used */
3783  att[k].gfx = tempid;
3784  size = k + 1;
3785  copy_from = att;
3786  }
3787  } else if (att[k].gfx == 0xFF) {
3788  att[k].ti.x = (int8)GB(att[k].ti.x, 0, 8);
3789  att[k].ti.y = (int8)GB(att[k].ti.y, 0, 8);
3790  }
3791 
3792  if (as->rotation[j] == DIR_E || as->rotation[j] == DIR_W) {
3793  as->size_x = max<byte>(as->size_x, att[k].ti.y + 1);
3794  as->size_y = max<byte>(as->size_y, att[k].ti.x + 1);
3795  } else {
3796  as->size_x = max<byte>(as->size_x, att[k].ti.x + 1);
3797  as->size_y = max<byte>(as->size_y, att[k].ti.y + 1);
3798  }
3799  }
3800  tile_table[j] = CallocT<AirportTileTable>(size);
3801  memcpy(tile_table[j], copy_from, sizeof(*copy_from) * size);
3802  }
3803  /* Install final layout construction in the airport spec */
3804  as->table = tile_table;
3805  free(att);
3806  } catch (...) {
3807  for (int i = 0; i < as->num_table; i++) {
3808  free(tile_table[i]);
3809  }
3810  free(tile_table);
3811  free(att);
3812  throw;
3813  }
3814  break;
3815  }
3816 
3817  case 0x0C:
3818  as->min_year = buf->ReadWord();
3819  as->max_year = buf->ReadWord();
3820  if (as->max_year == 0xFFFF) as->max_year = MAX_YEAR;
3821  break;
3822 
3823  case 0x0D:
3824  as->ttd_airport_type = (TTDPAirportType)buf->ReadByte();
3825  break;
3826 
3827  case 0x0E:
3828  as->catchment = Clamp(buf->ReadByte(), 1, MAX_CATCHMENT);
3829  break;
3830 
3831  case 0x0F:
3832  as->noise_level = buf->ReadByte();
3833  break;
3834 
3835  case 0x10:
3836  AddStringForMapping(buf->ReadWord(), &as->name);
3837  break;
3838 
3839  case 0x11: // Maintenance cost factor
3840  as->maintenance_cost = buf->ReadWord();
3841  break;
3842 
3843  default:
3844  ret = CIR_UNKNOWN;
3845  break;
3846  }
3847  }
3848 
3849  return ret;
3850 }
3851 
3859 {
3861 
3862  switch (prop) {
3863  case 0x0B:
3864  case 0x0C:
3865  case 0x0D:
3866  case 0x12:
3867  case 0x14:
3868  case 0x16:
3869  case 0x17:
3870  buf->ReadByte();
3871  break;
3872 
3873  case 0x09:
3874  case 0x0A:
3875  case 0x10:
3876  case 0x11:
3877  case 0x13:
3878  case 0x15:
3879  buf->ReadWord();
3880  break;
3881 
3882  case 0x08:
3883  case 0x0E:
3884  case 0x0F:
3885  buf->ReadDWord();
3886  break;
3887 
3888  default:
3889  ret = CIR_UNKNOWN;
3890  break;
3891  }
3892 
3893  return ret;
3894 }
3895 
3904 static ChangeInfoResult ObjectChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
3905 {
3907 
3908  if (id + numinfo > NUM_OBJECTS_PER_GRF) {
3909  grfmsg(1, "ObjectChangeInfo: Too many objects loaded (%u), max (%u). Ignoring.", id + numinfo, NUM_OBJECTS_PER_GRF);
3910  return CIR_INVALID_ID;
3911  }
3912 
3913  /* Allocate object specs if they haven't been allocated already. */
3914  if (_cur.grffile->objectspec == NULL) {
3915  _cur.grffile->objectspec = CallocT<ObjectSpec*>(NUM_OBJECTS_PER_GRF);
3916  }
3917 
3918  for (int i = 0; i < numinfo; i++) {
3919  ObjectSpec *spec = _cur.grffile->objectspec[id + i];
3920 
3921  if (prop != 0x08 && spec == NULL) {
3922  /* If the object property 08 is not yet set, ignore this property */
3923  ChangeInfoResult cir = IgnoreObjectProperty(prop, buf);
3924  if (cir > ret) ret = cir;
3925  continue;
3926  }
3927 
3928  switch (prop) {
3929  case 0x08: { // Class ID
3930  ObjectSpec **ospec = &_cur.grffile->objectspec[id + i];
3931 
3932  /* Allocate space for this object. */
3933  if (*ospec == NULL) {
3934  *ospec = CallocT<ObjectSpec>(1);
3935  (*ospec)->views = 1; // Default for NewGRFs that don't set it.
3936  }
3937 
3938  /* Swap classid because we read it in BE. */
3939  uint32 classid = buf->ReadDWord();
3940  (*ospec)->cls_id = ObjectClass::Allocate(BSWAP32(classid));
3941  (*ospec)->enabled = true;
3942  break;
3943  }
3944 
3945  case 0x09: { // Class name
3946  ObjectClass *objclass = ObjectClass::Get(spec->cls_id);
3947  AddStringForMapping(buf->ReadWord(), &objclass->name);
3948  break;
3949  }
3950 
3951  case 0x0A: // Object name
3952  AddStringForMapping(buf->ReadWord(), &spec->name);
3953  break;
3954 
3955  case 0x0B: // Climate mask
3956  spec->climate = buf->ReadByte();
3957  break;
3958 
3959  case 0x0C: // Size
3960  spec->size = buf->ReadByte();
3961  break;
3962 
3963  case 0x0D: // Build cost multipler
3964  spec->build_cost_multiplier = buf->ReadByte();
3966  break;
3967 
3968  case 0x0E: // Introduction date
3969  spec->introduction_date = buf->ReadDWord();
3970  break;
3971 
3972  case 0x0F: // End of life
3973  spec->end_of_life_date = buf->ReadDWord();
3974  break;
3975 
3976  case 0x10: // Flags
3977  spec->flags = (ObjectFlags)buf->ReadWord();
3978  _loaded_newgrf_features.has_2CC |= (spec->flags & OBJECT_FLAG_2CC_COLOUR) != 0;
3979  break;
3980 
3981  case 0x11: // Animation info
3982  spec->animation.frames = buf->ReadByte();
3983  spec->animation.status = buf->ReadByte();
3984  break;
3985 
3986  case 0x12: // Animation speed
3987  spec->animation.speed = buf->ReadByte();
3988  break;
3989 
3990  case 0x13: // Animation triggers
3991  spec->animation.triggers = buf->ReadWord();
3992  break;
3993 
3994  case 0x14: // Removal cost multiplier
3995  spec->clear_cost_multiplier = buf->ReadByte();
3996  break;
3997 
3998  case 0x15: // Callback mask
3999  spec->callback_mask = buf->ReadWord();
4000  break;
4001 
4002  case 0x16: // Building height
4003  spec->height = buf->ReadByte();
4004  break;
4005 
4006  case 0x17: // Views
4007  spec->views = buf->ReadByte();
4008  if (spec->views != 1 && spec->views != 2 && spec->views != 4) {
4009  grfmsg(2, "ObjectChangeInfo: Invalid number of views (%u) for object id %u. Ignoring.", spec->views, id + i);
4010  spec->views = 1;
4011  }
4012  break;
4013 
4014  case 0x18: // Amount placed on 256^2 map on map creation
4015  spec->generate_amount = buf->ReadByte();
4016  break;
4017 
4018  default:
4019  ret = CIR_UNKNOWN;
4020  break;
4021  }
4022  }
4023 
4024  return ret;
4025 }
4026 
4035 static ChangeInfoResult RailTypeChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
4036 {
4038 
4039  extern RailtypeInfo _railtypes[RAILTYPE_END];
4040 
4041  if (id + numinfo > RAILTYPE_END) {
4042  grfmsg(1, "RailTypeChangeInfo: Rail type %u is invalid, max %u, ignoring", id + numinfo, RAILTYPE_END);
4043  return CIR_INVALID_ID;
4044  }
4045 
4046  for (int i = 0; i < numinfo; i++) {
4047  RailType rt = _cur.grffile->railtype_map[id + i];
4048  if (rt == INVALID_RAILTYPE) return CIR_INVALID_ID;
4049 
4050  RailtypeInfo *rti = &_railtypes[rt];
4051 
4052  switch (prop) {
4053  case 0x08: // Label of rail type
4054  /* Skipped here as this is loaded during reservation stage. */
4055  buf->ReadDWord();
4056  break;
4057 
4058  case 0x09: { // Toolbar caption of railtype (sets name as well for backwards compatibility for grf ver < 8)
4059  uint16 str = buf->ReadWord();
4061  if (_cur.grffile->grf_version < 8) {
4062  AddStringForMapping(str, &rti->strings.name);
4063  }
4064  break;
4065  }
4066 
4067  case 0x0A: // Menu text of railtype
4068  AddStringForMapping(buf->ReadWord(), &rti->strings.menu_text);
4069  break;
4070 
4071  case 0x0B: // Build window caption
4072  AddStringForMapping(buf->ReadWord(), &rti->strings.build_caption);
4073  break;
4074 
4075  case 0x0C: // Autoreplace text
4076  AddStringForMapping(buf->ReadWord(), &rti->strings.replace_text);
4077  break;
4078 
4079  case 0x0D: // New locomotive text
4080  AddStringForMapping(buf->ReadWord(), &rti->strings.new_loco);
4081  break;
4082 
4083  case 0x0E: // Compatible railtype list
4084  case 0x0F: // Powered railtype list
4085  case 0x18: // Railtype list required for date introduction
4086  case 0x19: // Introduced railtype list
4087  {
4088  /* Rail type compatibility bits are added to the existing bits
4089  * to allow multiple GRFs to modify compatibility with the
4090  * default rail types. */
4091  int n = buf->ReadByte();
4092  for (int j = 0; j != n; j++) {
4093  RailTypeLabel label = buf->ReadDWord();
4094  RailType rt = GetRailTypeByLabel(BSWAP32(label), false);
4095  if (rt != INVALID_RAILTYPE) {
4096  switch (prop) {
4097  case 0x0F: SetBit(rti->powered_railtypes, rt); // Powered implies compatible.
4098  case 0x0E: SetBit(rti->compatible_railtypes, rt); break;
4099  case 0x18: SetBit(rti->introduction_required_railtypes, rt); break;
4100  case 0x19: SetBit(rti->introduces_railtypes, rt); break;
4101  }
4102  }
4103  }
4104  break;
4105  }
4106 
4107  case 0x10: // Rail Type flags
4108  rti->flags = (RailTypeFlags)buf->ReadByte();
4109  break;
4110 
4111  case 0x11: // Curve speed advantage
4112  rti->curve_speed = buf->ReadByte();
4113  break;
4114 
4115  case 0x12: // Station graphic
4116  rti->fallback_railtype = Clamp(buf->ReadByte(), 0, 2);
4117  break;
4118 
4119  case 0x13: // Construction cost factor
4120  rti->cost_multiplier = buf->ReadWord();
4121  break;
4122 
4123  case 0x14: // Speed limit
4124  rti->max_speed = buf->ReadWord();
4125  break;
4126 
4127  case 0x15: // Acceleration model
4128  rti->acceleration_type = Clamp(buf->ReadByte(), 0, 2);
4129  break;
4130 
4131  case 0x16: // Map colour
4132  rti->map_colour = buf->ReadByte();
4133  break;
4134 
4135  case 0x17: // Introduction date
4136  rti->introduction_date = buf->ReadDWord();
4137  break;
4138 
4139  case 0x1A: // Sort order
4140  rti->sorting_order = buf->ReadByte();
4141  break;
4142 
4143  case 0x1B: // Name of railtype (overridden by prop 09 for grf ver < 8)
4144  AddStringForMapping(buf->ReadWord(), &rti->strings.name);
4145  break;
4146 
4147  case 0x1C: // Maintenance cost factor
4148  rti->maintenance_multiplier = buf->ReadWord();
4149  break;
4150 
4151  case 0x1D: // Alternate rail type label list
4152  /* Skipped here as this is loaded during reservation stage. */
4153  for (int j = buf->ReadByte(); j != 0; j--) buf->ReadDWord();
4154  break;
4155 
4156  default:
4157  ret = CIR_UNKNOWN;
4158  break;
4159  }
4160  }
4161 
4162  return ret;
4163 }
4164 
4165 static ChangeInfoResult RailTypeReserveInfo(uint id, int numinfo, int prop, ByteReader *buf)
4166 {
4168 
4169  extern RailtypeInfo _railtypes[RAILTYPE_END];
4170 
4171  if (id + numinfo > RAILTYPE_END) {
4172  grfmsg(1, "RailTypeReserveInfo: Rail type %u is invalid, max %u, ignoring", id + numinfo, RAILTYPE_END);
4173  return CIR_INVALID_ID;
4174  }
4175 
4176  for (int i = 0; i < numinfo; i++) {
4177  switch (prop) {
4178  case 0x08: // Label of rail type
4179  {
4180  RailTypeLabel rtl = buf->ReadDWord();
4181  rtl = BSWAP32(rtl);
4182 
4183  RailType rt = GetRailTypeByLabel(rtl, false);
4184  if (rt == INVALID_RAILTYPE) {
4185  /* Set up new rail type */
4186  rt = AllocateRailType(rtl);
4187  }
4188 
4189  _cur.grffile->railtype_map[id + i] = rt;
4190  break;
4191  }
4192 
4193  case 0x09: // Toolbar caption of railtype
4194  case 0x0A: // Menu text
4195  case 0x0B: // Build window caption
4196  case 0x0C: // Autoreplace text
4197  case 0x0D: // New loco
4198  case 0x13: // Construction cost
4199  case 0x14: // Speed limit
4200  case 0x1B: // Name of railtype
4201  case 0x1C: // Maintenance cost factor
4202  buf->ReadWord();
4203  break;
4204 
4205  case 0x1D: // Alternate rail type label list
4206  if (_cur.grffile->railtype_map[id + i] != INVALID_RAILTYPE) {
4207  int n = buf->ReadByte();
4208  for (int j = 0; j != n; j++) {
4209  *_railtypes[_cur.grffile->railtype_map[id + i]].alternate_labels.Append() = BSWAP32(buf->ReadDWord());
4210  }
4211  break;
4212  }
4213  grfmsg(1, "RailTypeReserveInfo: Ignoring property 1D for rail type %u because no label was set", id + i);
4214  /* FALL THROUGH */
4215 
4216  case 0x0E: // Compatible railtype list
4217  case 0x0F: // Powered railtype list
4218  case 0x18: // Railtype list required for date introduction
4219  case 0x19: // Introduced railtype list
4220  for (int j = buf->ReadByte(); j != 0; j--) buf->ReadDWord();
4221  break;
4222 
4223  case 0x10: // Rail Type flags
4224  case 0x11: // Curve speed advantage
4225  case 0x12: // Station graphic
4226  case 0x15: // Acceleration model
4227  case 0x16: // Map colour
4228  case 0x1A: // Sort order
4229  buf->ReadByte();
4230  break;
4231 
4232  case 0x17: // Introduction date
4233  buf->ReadDWord();
4234  break;
4235 
4236  default:
4237  ret = CIR_UNKNOWN;
4238  break;
4239  }
4240  }
4241 
4242  return ret;
4243 }
4244 
4245 static ChangeInfoResult AirportTilesChangeInfo(uint airtid, int numinfo, int prop, ByteReader *buf)
4246 {
4248 
4249  if (airtid + numinfo > NUM_AIRPORTTILES_PER_GRF) {
4250  grfmsg(1, "AirportTileChangeInfo: Too many airport tiles loaded (%u), max (%u). Ignoring.", airtid + numinfo, NUM_AIRPORTTILES_PER_GRF);
4251  return CIR_INVALID_ID;
4252  }
4253 
4254  /* Allocate airport tile specs if they haven't been allocated already. */
4255  if (_cur.grffile->airtspec == NULL) {
4256  _cur.grffile->airtspec = CallocT<AirportTileSpec*>(NUM_AIRPORTTILES_PER_GRF);
4257  }
4258 
4259  for (int i = 0; i < numinfo; i++) {
4260  AirportTileSpec *tsp = _cur.grffile->airtspec[airtid + i];
4261 
4262  if (prop != 0x08 && tsp == NULL) {
4263  grfmsg(2, "AirportTileChangeInfo: Attempt to modify undefined airport tile %u. Ignoring.", airtid + i);
4264  return CIR_INVALID_ID;
4265  }
4266 
4267  switch (prop) {
4268  case 0x08: { // Substitute airport tile type
4269  AirportTileSpec **tilespec = &_cur.grffile->airtspec[airtid + i];
4270  byte subs_id = buf->ReadByte();
4271 
4272  if (subs_id >= NEW_AIRPORTTILE_OFFSET) {
4273  /* The substitute id must be one of the original airport tiles. */
4274  grfmsg(2, "AirportTileChangeInfo: Attempt to use new airport tile %u as substitute airport tile for %u. Ignoring.", subs_id, airtid + i);
4275  continue;
4276  }
4277 
4278  /* Allocate space for this airport tile. */
4279  if (*tilespec == NULL) {
4280  *tilespec = CallocT<AirportTileSpec>(1);
4281  tsp = *tilespec;
4282 
4283  memcpy(tsp, AirportTileSpec::Get(subs_id), sizeof(AirportTileSpec));
4284  tsp->enabled = true;
4285 
4286  tsp->animation.status = ANIM_STATUS_NO_ANIMATION;
4287 
4288  tsp->grf_prop.local_id = airtid + i;
4289  tsp->grf_prop.subst_id = subs_id;
4290  tsp->grf_prop.grffile = _cur.grffile;
4291  _airporttile_mngr.AddEntityID(airtid + i, _cur.grffile->grfid, subs_id); // pre-reserve the tile slot
4292  }
4293  break;
4294  }
4295 
4296  case 0x09: { // Airport tile override
4297  byte override = buf->ReadByte();
4298 
4299  /* The airport tile being overridden must be an original airport tile. */
4300  if (override >= NEW_AIRPORTTILE_OFFSET) {
4301  grfmsg(2, "AirportTileChangeInfo: Attempt to override new airport tile %u with airport tile id %u. Ignoring.", override, airtid + i);
4302  continue;
4303  }
4304 
4305  _airporttile_mngr.Add(airtid + i, _cur.grffile->grfid, override);
4306  break;
4307  }
4308 
4309  case 0x0E: // Callback mask
4310  tsp->callback_mask = buf->ReadByte();
4311  break;
4312 
4313  case 0x0F: // Animation information
4314  tsp->animation.frames = buf->ReadByte();
4315  tsp->animation.status = buf->ReadByte();
4316  break;
4317 
4318  case 0x10: // Animation speed
4319  tsp->animation.speed = buf->ReadByte();
4320  break;
4321 
4322  case 0x11: // Animation triggers
4323  tsp->animation.triggers = buf->ReadByte();
4324  break;
4325 
4326  default:
4327  ret = CIR_UNKNOWN;
4328  break;
4329  }
4330  }
4331 
4332  return ret;
4333 }
4334 
4335 static bool HandleChangeInfoResult(const char *caller, ChangeInfoResult cir, uint8 feature, uint8 property)
4336 {
4337  switch (cir) {
4338  default: NOT_REACHED();
4339 
4340  case CIR_DISABLED:
4341  /* Error has already been printed; just stop parsing */
4342  return true;
4343 
4344  case CIR_SUCCESS:
4345  return false;
4346 
4347  case CIR_UNHANDLED:
4348  grfmsg(1, "%s: Ignoring property 0x%02X of feature 0x%02X (not implemented)", caller, property, feature);
4349  return false;
4350 
4351  case CIR_UNKNOWN:
4352  grfmsg(0, "%s: Unknown property 0x%02X of feature 0x%02X, disabling", caller, property, feature);
4353  /* FALL THROUGH */
4354 
4355  case CIR_INVALID_ID: {
4356  /* No debug message for an invalid ID, as it has already been output */
4357  GRFError *error = DisableGrf(cir == CIR_INVALID_ID ? STR_NEWGRF_ERROR_INVALID_ID : STR_NEWGRF_ERROR_UNKNOWN_PROPERTY);
4358  if (cir != CIR_INVALID_ID) error->param_value[1] = property;
4359  return true;
4360  }
4361  }
4362 }
4363 
4364 /* Action 0x00 */
4365 static void FeatureChangeInfo(ByteReader *buf)
4366 {
4367  /* <00> <feature> <num-props> <num-info> <id> (<property <new-info>)...
4368  *
4369  * B feature
4370  * B num-props how many properties to change per vehicle/station
4371  * B num-info how many vehicles/stations to change
4372  * E id ID of first vehicle/station to change, if num-info is
4373  * greater than one, this one and the following
4374  * vehicles/stations will be changed
4375  * B property what property to change, depends on the feature
4376  * V new-info new bytes of info (variable size; depends on properties) */
4377 
4378  static const VCI_Handler handler[] = {
4379  /* GSF_TRAINS */ RailVehicleChangeInfo,
4380  /* GSF_ROADVEHICLES */ RoadVehicleChangeInfo,
4381  /* GSF_SHIPS */ ShipVehicleChangeInfo,
4382  /* GSF_AIRCRAFT */ AircraftVehicleChangeInfo,
4383  /* GSF_STATIONS */ StationChangeInfo,
4384  /* GSF_CANALS */ CanalChangeInfo,
4385  /* GSF_BRIDGES */ BridgeChangeInfo,
4386  /* GSF_HOUSES */ TownHouseChangeInfo,
4387  /* GSF_GLOBALVAR */ GlobalVarChangeInfo,
4388  /* GSF_INDUSTRYTILES */ IndustrytilesChangeInfo,
4389  /* GSF_INDUSTRIES */ IndustriesChangeInfo,
4390  /* GSF_CARGOES */ NULL, // Cargo is handled during reservation
4391  /* GSF_SOUNDFX */ SoundEffectChangeInfo,
4392  /* GSF_AIRPORTS */ AirportChangeInfo,
4393  /* GSF_SIGNALS */ NULL,
4394  /* GSF_OBJECTS */ ObjectChangeInfo,
4395  /* GSF_RAILTYPES */ RailTypeChangeInfo,
4396  /* GSF_AIRPORTTILES */ AirportTilesChangeInfo,
4397  };
4398 
4399  uint8 feature = buf->ReadByte();
4400  uint8 numprops = buf->ReadByte();
4401  uint numinfo = buf->ReadByte();
4402  uint engine = buf->ReadExtendedByte();
4403 
4404  grfmsg(6, "FeatureChangeInfo: feature %d, %d properties, to apply to %d+%d",
4405  feature, numprops, engine, numinfo);
4406 
4407  if (feature >= lengthof(handler) || handler[feature] == NULL) {
4408  if (feature != GSF_CARGOES) grfmsg(1, "FeatureChangeInfo: Unsupported feature %d, skipping", feature);
4409  return;
4410  }
4411 
4412  /* Mark the feature as used by the grf */
4413  SetBit(_cur.grffile->grf_features, feature);
4414 
4415  while (numprops-- && buf->HasData()) {
4416  uint8 prop = buf->ReadByte();
4417 
4418  ChangeInfoResult cir = handler[feature](engine, numinfo, prop, buf);
4419  if (HandleChangeInfoResult("FeatureChangeInfo", cir, feature, prop)) return;
4420  }
4421 }
4422 
4423 /* Action 0x00 (GLS_SAFETYSCAN) */
4424 static void SafeChangeInfo(ByteReader *buf)
4425 {
4426  uint8 feature = buf->ReadByte();
4427  uint8 numprops = buf->ReadByte();
4428  uint numinfo = buf->ReadByte();
4429  buf->ReadExtendedByte(); // id
4430 
4431  if (feature == GSF_BRIDGES && numprops == 1) {
4432  uint8 prop = buf->ReadByte();
4433  /* Bridge property 0x0D is redefinition of sprite layout tables, which
4434  * is considered safe. */
4435  if (prop == 0x0D) return;
4436  } else if (feature == GSF_GLOBALVAR && numprops == 1) {
4437  uint8 prop = buf->ReadByte();
4438  /* Engine ID Mappings are safe, if the source is static */
4439  if (prop == 0x11) {
4440  bool is_safe = true;
4441  for (uint i = 0; i < numinfo; i++) {
4442  uint32 s = buf->ReadDWord();
4443  buf->ReadDWord(); // dest
4444  const GRFConfig *grfconfig = GetGRFConfig(s);
4445  if (grfconfig != NULL && !HasBit(grfconfig->flags, GCF_STATIC)) {
4446  is_safe = false;
4447  break;
4448  }
4449  }
4450  if (is_safe) return;
4451  }
4452  }
4453 
4454  SetBit(_cur.grfconfig->flags, GCF_UNSAFE);
4455 
4456  /* Skip remainder of GRF */
4457  _cur.skip_sprites = -1;
4458 }
4459 
4460 /* Action 0x00 (GLS_RESERVE) */
4461 static void ReserveChangeInfo(ByteReader *buf)
4462 {
4463  uint8 feature = buf->ReadByte();
4464 
4465  if (feature != GSF_CARGOES && feature != GSF_GLOBALVAR && feature != GSF_RAILTYPES) return;
4466 
4467  uint8 numprops = buf->ReadByte();
4468  uint8 numinfo = buf->ReadByte();
4469  uint8 index = buf->ReadExtendedByte();
4470 
4471  while (numprops-- && buf->HasData()) {
4472  uint8 prop = buf->ReadByte();
4474 
4475  switch (feature) {
4476  default: NOT_REACHED();
4477  case GSF_CARGOES:
4478  cir = CargoChangeInfo(index, numinfo, prop, buf);
4479  break;
4480 
4481  case GSF_GLOBALVAR:
4482  cir = GlobalVarReserveInfo(index, numinfo, prop, buf);
4483  break;
4484 
4485  case GSF_RAILTYPES:
4486  cir = RailTypeReserveInfo(index, numinfo, prop, buf);
4487  break;
4488  }
4489 
4490  if (HandleChangeInfoResult("ReserveChangeInfo", cir, feature, prop)) return;
4491  }
4492 }
4493 
4494 /* Action 0x01 */
4495 static void NewSpriteSet(ByteReader *buf)
4496 {
4497  /* Basic format: <01> <feature> <num-sets> <num-ent>
4498  * Extended format: <01> <feature> 00 <first-set> <num-sets> <num-ent>
4499  *
4500  * B feature feature to define sprites for
4501  * 0, 1, 2, 3: veh-type, 4: train stations
4502  * E first-set first sprite set to define
4503  * B num-sets number of sprite sets (extended byte in extended format)
4504  * E num-ent how many entries per sprite set
4505  * For vehicles, this is the number of different
4506  * vehicle directions in each sprite set
4507  * Set num-dirs=8, unless your sprites are symmetric.
4508  * In that case, use num-dirs=4.
4509  */
4510 
4511  uint8 feature = buf->ReadByte();
4512  uint16 num_sets = buf->ReadByte();
4513  uint16 first_set = 0;
4514 
4515  if (num_sets == 0 && buf->HasData(3)) {
4516  /* Extended Action1 format.
4517  * Some GRFs define zero sets of zero sprites, though there is actually no use in that. Ignore them. */
4518  first_set = buf->ReadExtendedByte();
4519  num_sets = buf->ReadExtendedByte();
4520  }
4521  uint16 num_ents = buf->ReadExtendedByte();
4522 
4523  _cur.AddSpriteSets(feature, _cur.spriteid, first_set, num_sets, num_ents);
4524 
4525  grfmsg(7, "New sprite set at %d of type %d, consisting of %d sets with %d views each (total %d)",
4526  _cur.spriteid, feature, num_sets, num_ents, num_sets * num_ents
4527  );
4528 
4529  for (int i = 0; i < num_sets * num_ents; i++) {
4530  _cur.nfo_line++;
4531  LoadNextSprite(_cur.spriteid++, _cur.file_index, _cur.nfo_line, _cur.grf_container_ver);
4532  }
4533 }
4534 
4535 /* Action 0x01 (SKIP) */
4536 static void SkipAct1(ByteReader *buf)
4537 {
4538  buf->ReadByte();
4539  uint16 num_sets = buf->ReadByte();
4540 
4541  if (num_sets == 0 && buf->HasData(3)) {
4542  /* Extended Action1 format.
4543  * Some GRFs define zero sets of zero sprites, though there is actually no use in that. Ignore them. */
4544  buf->ReadExtendedByte(); // first_set
4545  num_sets = buf->ReadExtendedByte();
4546  }
4547  uint16 num_ents = buf->ReadExtendedByte();
4548 
4549  _cur.skip_sprites = num_sets * num_ents;
4550 
4551  grfmsg(3, "SkipAct1: Skipping %d sprites", _cur.skip_sprites);
4552 }
4553 
4554 /* Helper function to either create a callback or link to a previously
4555  * defined spritegroup. */
4556 static const SpriteGroup *GetGroupFromGroupID(byte setid, byte type, uint16 groupid)
4557 {
4558  if (HasBit(groupid, 15)) {
4560  return new CallbackResultSpriteGroup(groupid, _cur.grffile->grf_version >= 8);
4561  }
4562 
4563  if (groupid > MAX_SPRITEGROUP || _cur.spritegroups[groupid] == NULL) {
4564  grfmsg(1, "GetGroupFromGroupID(0x%02X:0x%02X): Groupid 0x%04X does not exist, leaving empty", setid, type, groupid);
4565  return NULL;
4566  }
4567 
4568  return _cur.spritegroups[groupid];
4569 }
4570 
4579 static const SpriteGroup *CreateGroupFromGroupID(byte feature, byte setid, byte type, uint16 spriteid)
4580 {
4581  if (HasBit(spriteid, 15)) {
4583  return new CallbackResultSpriteGroup(spriteid, _cur.grffile->grf_version >= 8);
4584  }
4585 
4586  if (!_cur.IsValidSpriteSet(feature, spriteid)) {
4587  grfmsg(1, "CreateGroupFromGroupID(0x%02X:0x%02X): Sprite set %u invalid", setid, type, spriteid);
4588  return NULL;
4589  }
4590 
4591  SpriteID spriteset_start = _cur.GetSprite(feature, spriteid);
4592  uint num_sprites = _cur.GetNumEnts(feature, spriteid);
4593 
4594  /* Ensure that the sprites are loeded */
4595  assert(spriteset_start + num_sprites <= _cur.spriteid);
4596 
4598  return new ResultSpriteGroup(spriteset_start, num_sprites);
4599 }
4600 
4601 /* Action 0x02 */
4602 static void NewSpriteGroup(ByteReader *buf)
4603 {
4604  /* <02> <feature> <set-id> <type/num-entries> <feature-specific-data...>
4605  *
4606  * B feature see action 1
4607  * B set-id ID of this particular definition
4608  * B type/num-entries
4609  * if 80 or greater, this is a randomized or variational
4610  * list definition, see below
4611  * otherwise it specifies a number of entries, the exact
4612  * meaning depends on the feature
4613  * V feature-specific-data (huge mess, don't even look it up --pasky) */
4614  SpriteGroup *act_group = NULL;
4615 
4616  uint8 feature = buf->ReadByte();
4617  uint8 setid = buf->ReadByte();
4618  uint8 type = buf->ReadByte();
4619 
4620  /* Sprite Groups are created here but they are allocated from a pool, so
4621  * we do not need to delete anything if there is an exception from the
4622  * ByteReader. */
4623 
4624  switch (type) {
4625  /* Deterministic Sprite Group */
4626  case 0x81: // Self scope, byte
4627  case 0x82: // Parent scope, byte
4628  case 0x85: // Self scope, word
4629  case 0x86: // Parent scope, word
4630  case 0x89: // Self scope, dword
4631  case 0x8A: // Parent scope, dword
4632  {
4633  byte varadjust;
4634  byte varsize;
4635 
4638  act_group = group;
4639  group->var_scope = HasBit(type, 1) ? VSG_SCOPE_PARENT : VSG_SCOPE_SELF;
4640 
4641  switch (GB(type, 2, 2)) {
4642  default: NOT_REACHED();
4643  case 0: group->size = DSG_SIZE_BYTE; varsize = 1; break;
4644  case 1: group->size = DSG_SIZE_WORD; varsize = 2; break;
4645  case 2: group->size = DSG_SIZE_DWORD; varsize = 4; break;
4646  }
4647 
4649  adjusts.Clear();
4650 
4651  /* Loop through the var adjusts. Unfortunately we don't know how many we have
4652  * from the outset, so we shall have to keep reallocing. */
4653  do {
4654  DeterministicSpriteGroupAdjust *adjust = adjusts.Append();
4655 
4656  /* The first var adjust doesn't have an operation specified, so we set it to add. */
4657  adjust->operation = adjusts.Length() == 1 ? DSGA_OP_ADD : (DeterministicSpriteGroupAdjustOperation)buf->ReadByte();
4658  adjust->variable = buf->ReadByte();
4659  if (adjust->variable == 0x7E) {
4660  /* Link subroutine group */
4661  adjust->subroutine = GetGroupFromGroupID(setid, type, buf->ReadByte());
4662  } else {
4663  adjust->parameter = IsInsideMM(adjust->variable, 0x60, 0x80) ? buf->ReadByte() : 0;
4664  }
4665 
4666  varadjust = buf->ReadByte();
4667  adjust->shift_num = GB(varadjust, 0, 5);
4668  adjust->type = (DeterministicSpriteGroupAdjustType)GB(varadjust, 6, 2);
4669  adjust->and_mask = buf->ReadVarSize(varsize);
4670 
4671  if (adjust->type != DSGA_TYPE_NONE) {
4672  adjust->add_val = buf->ReadVarSize(varsize);
4673  adjust->divmod_val = buf->ReadVarSize(varsize);
4674  } else {
4675  adjust->add_val = 0;
4676  adjust->divmod_val = 0;
4677  }
4678 
4679  /* Continue reading var adjusts while bit 5 is set. */
4680  } while (HasBit(varadjust, 5));
4681 
4682  group->num_adjusts = adjusts.Length();
4683  group->adjusts = MallocT<DeterministicSpriteGroupAdjust>(group->num_adjusts);
4684  MemCpyT(group->adjusts, adjusts.Begin(), group->num_adjusts);
4685 
4686  group->num_ranges = buf->ReadByte();
4687  if (group->num_ranges > 0) group->ranges = CallocT<DeterministicSpriteGroupRange>(group->num_ranges);
4688 
4689  for (uint i = 0; i < group->num_ranges; i++) {
4690  group->ranges[i].group = GetGroupFromGroupID(setid, type, buf->ReadWord());
4691  group->ranges[i].low = buf->ReadVarSize(varsize);
4692  group->ranges[i].high = buf->ReadVarSize(varsize);
4693  }
4694 
4695  group->default_group = GetGroupFromGroupID(setid, type, buf->ReadWord());
4696  break;
4697  }
4698 
4699  /* Randomized Sprite Group */
4700  case 0x80: // Self scope
4701  case 0x83: // Parent scope
4702  case 0x84: // Relative scope
4703  {
4706  act_group = group;
4707  group->var_scope = HasBit(type, 1) ? VSG_SCOPE_PARENT : VSG_SCOPE_SELF;
4708 
4709  if (HasBit(type, 2)) {
4710  if (feature <= GSF_AIRCRAFT) group->var_scope = VSG_SCOPE_RELATIVE;
4711  group->count = buf->ReadByte();
4712  }
4713 
4714  uint8 triggers = buf->ReadByte();
4715  group->triggers = GB(triggers, 0, 7);
4716  group->cmp_mode = HasBit(triggers, 7) ? RSG_CMP_ALL : RSG_CMP_ANY;
4717  group->lowest_randbit = buf->ReadByte();
4718  group->num_groups = buf->ReadByte();
4719  group->groups = CallocT<const SpriteGroup*>(group->num_groups);
4720 
4721  for (uint i = 0; i < group->num_groups; i++) {
4722  group->groups[i] = GetGroupFromGroupID(setid, type, buf->ReadWord());
4723  }
4724 
4725  break;
4726  }
4727 
4728  /* Neither a variable or randomized sprite group... must be a real group */
4729  default:
4730  {
4731  switch (feature) {
4732  case GSF_TRAINS:
4733  case GSF_ROADVEHICLES:
4734  case GSF_SHIPS:
4735  case GSF_AIRCRAFT:
4736  case GSF_STATIONS:
4737  case GSF_CANALS:
4738  case GSF_CARGOES:
4739  case GSF_AIRPORTS:
4740  case GSF_RAILTYPES:
4741  {
4742  byte num_loaded = type;
4743  byte num_loading = buf->ReadByte();
4744 
4745  if (!_cur.HasValidSpriteSets(feature)) {
4746  grfmsg(0, "NewSpriteGroup: No sprite set to work on! Skipping");
4747  return;
4748  }
4749 
4751  RealSpriteGroup *group = new RealSpriteGroup();
4752  act_group = group;
4753 
4754  group->num_loaded = num_loaded;
4755  group->num_loading = num_loading;
4756  if (num_loaded > 0) group->loaded = CallocT<const SpriteGroup*>(num_loaded);
4757  if (num_loading > 0) group->loading = CallocT<const SpriteGroup*>(num_loading);
4758 
4759  grfmsg(6, "NewSpriteGroup: New SpriteGroup 0x%02X, %u loaded, %u loading",
4760  setid, num_loaded, num_loading);
4761 
4762  for (uint i = 0; i < num_loaded; i++) {
4763  uint16 spriteid = buf->ReadWord();
4764  group->loaded[i] = CreateGroupFromGroupID(feature, setid, type, spriteid);
4765  grfmsg(8, "NewSpriteGroup: + rg->loaded[%i] = subset %u", i, spriteid);
4766  }
4767 
4768  for (uint i = 0; i < num_loading; i++) {
4769  uint16 spriteid = buf->ReadWord();
4770  group->loading[i] = CreateGroupFromGroupID(feature, setid, type, spriteid);
4771  grfmsg(8, "NewSpriteGroup: + rg->loading[%i] = subset %u", i, spriteid);
4772  }
4773 
4774  break;
4775  }
4776 
4777  case GSF_HOUSES:
4778  case GSF_AIRPORTTILES:
4779  case GSF_OBJECTS:
4780  case GSF_INDUSTRYTILES: {
4781  byte num_building_sprites = max((uint8)1, type);
4782 
4785  act_group = group;
4786 
4787  /* On error, bail out immediately. Temporary GRF data was already freed */
4788  if (ReadSpriteLayout(buf, num_building_sprites, true, feature, false, type == 0, &group->dts)) return;
4789  break;
4790  }
4791 
4792  case GSF_INDUSTRIES: {
4793  if (type > 1) {
4794  grfmsg(1, "NewSpriteGroup: Unsupported industry production version %d, skipping", type);
4795  break;
4796  }
4797 
4800  act_group = group;
4801  group->version = type;
4802  if (type == 0) {
4803  for (uint i = 0; i < 3; i++) {
4804  group->subtract_input[i] = (int16)buf->ReadWord(); // signed
4805  }
4806  for (uint i = 0; i < 2; i++) {
4807  group->add_output[i] = buf->ReadWord(); // unsigned
4808  }
4809  group->again = buf->ReadByte();
4810  } else {
4811  for (uint i = 0; i < 3; i++) {
4812  group->subtract_input[i] = buf->ReadByte();
4813  }
4814  for (uint i = 0; i < 2; i++) {
4815  group->add_output[i] = buf->ReadByte();
4816  }
4817  group->again = buf->ReadByte();
4818  }
4819  break;
4820  }
4821 
4822  /* Loading of Tile Layout and Production Callback groups would happen here */
4823  default: grfmsg(1, "NewSpriteGroup: Unsupported feature %d, skipping", feature);
4824  }
4825  }
4826  }
4827 
4828  _cur.spritegroups[setid] = act_group;
4829 }
4830 
4831 static CargoID TranslateCargo(uint8 feature, uint8 ctype)
4832 {
4833  if (feature == GSF_OBJECTS) {
4834  switch (ctype) {
4835  case 0: return 0;
4836  case 0xFF: return CT_PURCHASE_OBJECT;
4837  default:
4838  grfmsg(1, "TranslateCargo: Invalid cargo bitnum %d for objects, skipping.", ctype);
4839  return CT_INVALID;
4840  }
4841  }
4842  /* Special cargo types for purchase list and stations */
4843  if (feature == GSF_STATIONS && ctype == 0xFE) return CT_DEFAULT_NA;
4844  if (ctype == 0xFF) return CT_PURCHASE;
4845 
4846  if (_cur.grffile->cargo_list.Length() == 0) {
4847  /* No cargo table, so use bitnum values */
4848  if (ctype >= 32) {
4849  grfmsg(1, "TranslateCargo: Cargo bitnum %d out of range (max 31), skipping.", ctype);
4850  return CT_INVALID;
4851  }
4852 
4853  const CargoSpec *cs;
4854  FOR_ALL_CARGOSPECS(cs) {
4855  if (cs->bitnum == ctype) {
4856  grfmsg(6, "TranslateCargo: Cargo bitnum %d mapped to cargo type %d.", ctype, cs->Index());
4857  return cs->Index();
4858  }
4859  }
4860 
4861  grfmsg(5, "TranslateCargo: Cargo bitnum %d not available in this climate, skipping.", ctype);
4862  return CT_INVALID;
4863  }
4864 
4865  /* Check if the cargo type is out of bounds of the cargo translation table */
4866  if (ctype >= _cur.grffile->cargo_list.Length()) {
4867  grfmsg(1, "TranslateCargo: Cargo type %d out of range (max %d), skipping.", ctype, _cur.grffile->cargo_list.Length() - 1);
4868  return CT_INVALID;
4869  }
4870 
4871  /* Look up the cargo label from the translation table */
4872  CargoLabel cl = _cur.grffile->cargo_list[ctype];
4873  if (cl == 0) {
4874  grfmsg(5, "TranslateCargo: Cargo type %d not available in this climate, skipping.", ctype);
4875  return CT_INVALID;
4876  }
4877 
4878  ctype = GetCargoIDByLabel(cl);
4879  if (ctype == CT_INVALID) {
4880  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));
4881  return CT_INVALID;
4882  }
4883 
4884  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);
4885  return ctype;
4886 }
4887 
4888 
4889 static bool IsValidGroupID(uint16 groupid, const char *function)
4890 {
4891  if (groupid > MAX_SPRITEGROUP || _cur.spritegroups[groupid] == NULL) {
4892  grfmsg(1, "%s: Spritegroup 0x%04X out of range or empty, skipping.", function, groupid);
4893  return false;
4894  }
4895 
4896  return true;
4897 }
4898 
4899 static void VehicleMapSpriteGroup(ByteReader *buf, byte feature, uint8 idcount)
4900 {
4901  static EngineID *last_engines;
4902  static uint last_engines_count;
4903  bool wagover = false;
4904 
4905  /* Test for 'wagon override' flag */
4906  if (HasBit(idcount, 7)) {
4907  wagover = true;
4908  /* Strip off the flag */
4909  idcount = GB(idcount, 0, 7);
4910 
4911  if (last_engines_count == 0) {
4912  grfmsg(0, "VehicleMapSpriteGroup: WagonOverride: No engine to do override with");
4913  return;
4914  }
4915 
4916  grfmsg(6, "VehicleMapSpriteGroup: WagonOverride: %u engines, %u wagons",
4917  last_engines_count, idcount);
4918  } else {
4919  if (last_engines_count != idcount) {
4920  last_engines = ReallocT(last_engines, idcount);
4921  last_engines_count = idcount;
4922  }
4923  }
4924 
4925  EngineID *engines = AllocaM(EngineID, idcount);
4926  for (uint i = 0; i < idcount; i++) {
4927  Engine *e = GetNewEngine(_cur.grffile, (VehicleType)feature, buf->ReadExtendedByte());
4928  if (e == NULL) {
4929  /* No engine could be allocated?!? Deal with it. Okay,
4930  * this might look bad. Also make sure this NewGRF
4931  * gets disabled, as a half loaded one is bad. */
4932  HandleChangeInfoResult("VehicleMapSpriteGroup", CIR_INVALID_ID, 0, 0);
4933  return;
4934  }
4935 
4936  engines[i] = e->index;
4937  if (!wagover) last_engines[i] = engines[i];
4938  }
4939 
4940  uint8 cidcount = buf->ReadByte();
4941  for (uint c = 0; c < cidcount; c++) {
4942  uint8 ctype = buf->ReadByte();
4943  uint16 groupid = buf->ReadWord();
4944  if (!IsValidGroupID(groupid, "VehicleMapSpriteGroup")) continue;
4945 
4946  grfmsg(8, "VehicleMapSpriteGroup: * [%d] Cargo type 0x%X, group id 0x%02X", c, ctype, groupid);
4947 
4948  ctype = TranslateCargo(feature, ctype);
4949  if (ctype == CT_INVALID) continue;
4950 
4951  for (uint i = 0; i < idcount; i++) {
4952  EngineID engine = engines[i];
4953 
4954  grfmsg(7, "VehicleMapSpriteGroup: [%d] Engine %d...", i, engine);
4955 
4956  if (wagover) {
4957  SetWagonOverrideSprites(engine, ctype, _cur.spritegroups[groupid], last_engines, last_engines_count);
4958  } else {
4959  SetCustomEngineSprites(engine, ctype, _cur.spritegroups[groupid]);
4960  }
4961  }
4962  }
4963 
4964  uint16 groupid = buf->ReadWord();
4965  if (!IsValidGroupID(groupid, "VehicleMapSpriteGroup")) return;
4966 
4967  grfmsg(8, "-- Default group id 0x%04X", groupid);
4968 
4969  for (uint i = 0; i < idcount; i++) {
4970  EngineID engine = engines[i];
4971 
4972  if (wagover) {
4973  SetWagonOverrideSprites(engine, CT_DEFAULT, _cur.spritegroups[groupid], last_engines, last_engines_count);
4974  } else {
4975  SetCustomEngineSprites(engine, CT_DEFAULT, _cur.spritegroups[groupid]);
4976  SetEngineGRF(engine, _cur.grffile);
4977  }
4978  }
4979 }
4980 
4981 
4982 static void CanalMapSpriteGroup(ByteReader *buf, uint8 idcount)
4983 {
4984  CanalFeature *cfs = AllocaM(CanalFeature, idcount);
4985  for (uint i = 0; i < idcount; i++) {
4986  cfs[i] = (CanalFeature)buf->ReadByte();
4987  }
4988 
4989  uint8 cidcount = buf->ReadByte();
4990  buf->Skip(cidcount * 3);
4991 
4992  uint16 groupid = buf->ReadWord();
4993  if (!IsValidGroupID(groupid, "CanalMapSpriteGroup")) return;
4994 
4995  for (uint i = 0; i < idcount; i++) {
4996  CanalFeature cf = cfs[i];
4997 
4998  if (cf >= CF_END) {
4999  grfmsg(1, "CanalMapSpriteGroup: Canal subset %d out of range, skipping", cf);
5000  continue;
5001  }
5002 
5003  _water_feature[cf].grffile = _cur.grffile;
5004  _water_feature[cf].group = _cur.spritegroups[groupid];
5005  }
5006 }
5007 
5008 
5009 static void StationMapSpriteGroup(ByteReader *buf, uint8 idcount)
5010 {
5011  uint8 *stations = AllocaM(uint8, idcount);
5012  for (uint i = 0; i < idcount; i++) {
5013  stations[i] = buf->ReadByte();
5014  }
5015 
5016  uint8 cidcount = buf->ReadByte();
5017  for (uint c = 0; c < cidcount; c++) {
5018  uint8 ctype = buf->ReadByte();
5019  uint16 groupid = buf->ReadWord();
5020  if (!IsValidGroupID(groupid, "StationMapSpriteGroup")) continue;
5021 
5022  ctype = TranslateCargo(GSF_STATIONS, ctype);
5023  if (ctype == CT_INVALID) continue;
5024 
5025  for (uint i = 0; i < idcount; i++) {
5026  StationSpec *statspec = _cur.grffile->stations == NULL ? NULL : _cur.grffile->stations[stations[i]];
5027 
5028  if (statspec == NULL) {
5029  grfmsg(1, "StationMapSpriteGroup: Station with ID 0x%02X does not exist, skipping", stations[i]);
5030  continue;
5031  }
5032 
5033  statspec->grf_prop.spritegroup[ctype] = _cur.spritegroups[groupid];
5034  }
5035  }
5036 
5037  uint16 groupid = buf->ReadWord();
5038  if (!IsValidGroupID(groupid, "StationMapSpriteGroup")) return;
5039 
5040  for (uint i = 0; i < idcount; i++) {
5041  StationSpec *statspec = _cur.grffile->stations == NULL ? NULL : _cur.grffile->stations[stations[i]];
5042 
5043  if (statspec == NULL) {
5044  grfmsg(1, "StationMapSpriteGroup: Station with ID 0x%02X does not exist, skipping", stations[i]);
5045  continue;
5046  }
5047 
5048  if (statspec->grf_prop.grffile != NULL) {
5049  grfmsg(1, "StationMapSpriteGroup: Station with ID 0x%02X mapped multiple times, skipping", stations[i]);
5050  continue;
5051  }
5052 
5053  statspec->grf_prop.spritegroup[CT_DEFAULT] = _cur.spritegroups[groupid];
5054  statspec->grf_prop.grffile = _cur.grffile;
5055  statspec->grf_prop.local_id = stations[i];
5056  StationClass::Assign(statspec);
5057  }
5058 }
5059 
5060 
5061 static void TownHouseMapSpriteGroup(ByteReader *buf, uint8 idcount)
5062 {
5063  uint8 *houses = AllocaM(uint8, idcount);
5064  for (uint i = 0; i < idcount; i++) {
5065  houses[i] = buf->ReadByte();
5066  }
5067 
5068  /* Skip the cargo type section, we only care about the default group */
5069  uint8 cidcount = buf->ReadByte();
5070  buf->Skip(cidcount * 3);
5071 
5072  uint16 groupid = buf->ReadWord();
5073  if (!IsValidGroupID(groupid, "TownHouseMapSpriteGroup")) return;
5074 
5075  if (_cur.grffile->housespec == NULL) {
5076  grfmsg(1, "TownHouseMapSpriteGroup: No houses defined, skipping");
5077  return;
5078  }
5079 
5080  for (uint i = 0; i < idcount; i++) {
5081  HouseSpec *hs = _cur.grffile->housespec[houses[i]];
5082 
5083  if (hs == NULL) {
5084  grfmsg(1, "TownHouseMapSpriteGroup: House %d undefined, skipping.", houses[i]);
5085  continue;
5086  }
5087 
5088  hs->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
5089  }
5090 }
5091 
5092 static void IndustryMapSpriteGroup(ByteReader *buf, uint8 idcount)
5093 {
5094  uint8 *industries = AllocaM(uint8, idcount);
5095  for (uint i = 0; i < idcount; i++) {
5096  industries[i] = buf->ReadByte();
5097  }
5098 
5099  /* Skip the cargo type section, we only care about the default group */
5100  uint8 cidcount = buf->ReadByte();
5101  buf->Skip(cidcount * 3);
5102 
5103  uint16 groupid = buf->ReadWord();
5104  if (!IsValidGroupID(groupid, "IndustryMapSpriteGroup")) return;
5105 
5106  if (_cur.grffile->industryspec == NULL) {
5107  grfmsg(1, "IndustryMapSpriteGroup: No industries defined, skipping");
5108  return;
5109  }
5110 
5111  for (uint i = 0; i < idcount; i++) {
5112  IndustrySpec *indsp = _cur.grffile->industryspec[industries[i]];
5113 
5114  if (indsp == NULL) {
5115  grfmsg(1, "IndustryMapSpriteGroup: Industry %d undefined, skipping", industries[i]);
5116  continue;
5117  }
5118 
5119  indsp->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
5120  }
5121 }
5122 
5123 static void IndustrytileMapSpriteGroup(ByteReader *buf, uint8 idcount)
5124 {
5125  uint8 *indtiles = AllocaM(uint8, idcount);
5126  for (uint i = 0; i < idcount; i++) {
5127  indtiles[i] = buf->ReadByte();
5128  }
5129 
5130  /* Skip the cargo type section, we only care about the default group */
5131  uint8 cidcount = buf->ReadByte();
5132  buf->Skip(cidcount * 3);
5133 
5134  uint16 groupid = buf->ReadWord();
5135  if (!IsValidGroupID(groupid, "IndustrytileMapSpriteGroup")) return;
5136 
5137  if (_cur.grffile->indtspec == NULL) {
5138  grfmsg(1, "IndustrytileMapSpriteGroup: No industry tiles defined, skipping");
5139  return;
5140  }
5141 
5142  for (uint i = 0; i < idcount; i++) {
5143  IndustryTileSpec *indtsp = _cur.grffile->indtspec[indtiles[i]];
5144 
5145  if (indtsp == NULL) {
5146  grfmsg(1, "IndustrytileMapSpriteGroup: Industry tile %d undefined, skipping", indtiles[i]);
5147  continue;
5148  }
5149 
5150  indtsp->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
5151  }
5152 }
5153 
5154 static void CargoMapSpriteGroup(ByteReader *buf, uint8 idcount)
5155 {
5156  CargoID *cargoes = AllocaM(CargoID, idcount);
5157  for (uint i = 0; i < idcount; i++) {
5158  cargoes[i] = buf->ReadByte();
5159  }
5160 
5161  /* Skip the cargo type section, we only care about the default group */
5162  uint8 cidcount = buf->ReadByte();
5163  buf->Skip(cidcount * 3);
5164 
5165  uint16 groupid = buf->ReadWord();
5166  if (!IsValidGroupID(groupid, "CargoMapSpriteGroup")) return;
5167 
5168  for (uint i = 0; i < idcount; i++) {
5169  CargoID cid = cargoes[i];
5170 
5171  if (cid >= NUM_CARGO) {
5172  grfmsg(1, "CargoMapSpriteGroup: Cargo ID %d out of range, skipping", cid);
5173  continue;
5174  }
5175 
5176  CargoSpec *cs = CargoSpec::Get(cid);
5177  cs->grffile = _cur.grffile;
5178  cs->group = _cur.spritegroups[groupid];
5179  }
5180 }
5181 
5182 static void ObjectMapSpriteGroup(ByteReader *buf, uint8 idcount)
5183 {
5184  if (_cur.grffile->objectspec == NULL) {
5185  grfmsg(1, "ObjectMapSpriteGroup: No object tiles defined, skipping");
5186  return;
5187  }
5188 
5189  uint8 *objects = AllocaM(uint8, idcount);
5190  for (uint i = 0; i < idcount; i++) {
5191  objects[i] = buf->ReadByte();
5192  }
5193 
5194  uint8 cidcount = buf->ReadByte();
5195  for (uint c = 0; c < cidcount; c++) {
5196  uint8 ctype = buf->ReadByte();
5197  uint16 groupid = buf->ReadWord();
5198  if (!IsValidGroupID(groupid, "ObjectMapSpriteGroup")) continue;
5199 
5200  ctype = TranslateCargo(GSF_OBJECTS, ctype);
5201  if (ctype == CT_INVALID) continue;
5202 
5203  for (uint i = 0; i < idcount; i++) {
5204  ObjectSpec *spec = _cur.grffile->objectspec[objects[i]];
5205 
5206  if (spec == NULL) {
5207  grfmsg(1, "ObjectMapSpriteGroup: Object with ID 0x%02X undefined, skipping", objects[i]);
5208  continue;
5209  }
5210 
5211  spec->grf_prop.spritegroup[ctype] = _cur.spritegroups[groupid];
5212  }
5213  }
5214 
5215  uint16 groupid = buf->ReadWord();
5216  if (!IsValidGroupID(groupid, "ObjectMapSpriteGroup")) return;
5217 
5218  for (uint i = 0; i < idcount; i++) {
5219  ObjectSpec *spec = _cur.grffile->objectspec[objects[i]];
5220 
5221  if (spec == NULL) {
5222  grfmsg(1, "ObjectMapSpriteGroup: Object with ID 0x%02X undefined, skipping", objects[i]);
5223  continue;
5224  }
5225 
5226  if (spec->grf_prop.grffile != NULL) {
5227  grfmsg(1, "ObjectMapSpriteGroup: Object with ID 0x%02X mapped multiple times, skipping", objects[i]);
5228  continue;
5229  }
5230 
5231  spec->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
5232  spec->grf_prop.grffile = _cur.grffile;
5233  spec->grf_prop.local_id = objects[i];
5234  }
5235 }
5236 
5237 static void RailTypeMapSpriteGroup(ByteReader *buf, uint8 idcount)
5238 {
5239  uint8 *railtypes = AllocaM(uint8, idcount);
5240  for (uint i = 0; i < idcount; i++) {
5241  railtypes[i] = _cur.grffile->railtype_map[buf->ReadByte()];
5242  }
5243 
5244  uint8 cidcount = buf->ReadByte();
5245  for (uint c = 0; c < cidcount; c++) {
5246  uint8 ctype = buf->ReadByte();
5247  uint16 groupid = buf->ReadWord();
5248  if (!IsValidGroupID(groupid, "RailTypeMapSpriteGroup")) continue;
5249 
5250  if (ctype >= RTSG_END) continue;
5251 
5252  extern RailtypeInfo _railtypes[RAILTYPE_END];
5253  for (uint i = 0; i < idcount; i++) {
5254  if (railtypes[i] != INVALID_RAILTYPE) {
5255  RailtypeInfo *rti = &_railtypes[railtypes[i]];
5256 
5257  rti->grffile[ctype] = _cur.grffile;
5258  rti->group[ctype] = _cur.spritegroups[groupid];
5259  }
5260  }
5261  }
5262 
5263  /* Railtypes do not use the default group. */
5264  buf->ReadWord();
5265 }
5266 
5267 static void AirportMapSpriteGroup(ByteReader *buf, uint8 idcount)
5268 {
5269  uint8 *airports = AllocaM(uint8, idcount);
5270  for (uint i = 0; i < idcount; i++) {
5271  airports[i] = buf->ReadByte();
5272  }
5273 
5274  /* Skip the cargo type section, we only care about the default group */
5275  uint8 cidcount = buf->ReadByte();
5276  buf->Skip(cidcount * 3);
5277 
5278  uint16 groupid = buf->ReadWord();
5279  if (!IsValidGroupID(groupid, "AirportMapSpriteGroup")) return;
5280 
5281  if (_cur.grffile->airportspec == NULL) {
5282  grfmsg(1, "AirportMapSpriteGroup: No airports defined, skipping");
5283  return;
5284  }
5285 
5286  for (uint i = 0; i < idcount; i++) {
5287  AirportSpec *as = _cur.grffile->airportspec[airports[i]];
5288 
5289  if (as == NULL) {
5290  grfmsg(1, "AirportMapSpriteGroup: Airport %d undefined, skipping", airports[i]);
5291  continue;
5292  }
5293 
5294  as->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
5295  }
5296 }
5297 
5298 static void AirportTileMapSpriteGroup(ByteReader *buf, uint8 idcount)
5299 {
5300  uint8 *airptiles = AllocaM(uint8, idcount);
5301  for (uint i = 0; i < idcount; i++) {
5302  airptiles[i] = buf->ReadByte();
5303  }
5304 
5305  /* Skip the cargo type section, we only care about the default group */
5306  uint8 cidcount = buf->ReadByte();
5307  buf->Skip(cidcount * 3);
5308 
5309  uint16 groupid = buf->ReadWord();
5310  if (!IsValidGroupID(groupid, "AirportTileMapSpriteGroup")) return;
5311 
5312  if (_cur.grffile->airtspec == NULL) {
5313  grfmsg(1, "AirportTileMapSpriteGroup: No airport tiles defined, skipping");
5314  return;
5315  }
5316 
5317  for (uint i = 0; i < idcount; i++) {
5318  AirportTileSpec *airtsp = _cur.grffile->airtspec[airptiles[i]];
5319 
5320  if (airtsp == NULL) {
5321  grfmsg(1, "AirportTileMapSpriteGroup: Airport tile %d undefined, skipping", airptiles[i]);
5322  continue;
5323  }
5324 
5325  airtsp->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
5326  }
5327 }
5328 
5329 
5330 /* Action 0x03 */
5331 static void FeatureMapSpriteGroup(ByteReader *buf)
5332 {
5333  /* <03> <feature> <n-id> <ids>... <num-cid> [<cargo-type> <cid>]... <def-cid>
5334  * id-list := [<id>] [id-list]
5335  * cargo-list := <cargo-type> <cid> [cargo-list]
5336  *
5337  * B feature see action 0
5338  * B n-id bits 0-6: how many IDs this definition applies to
5339  * bit 7: if set, this is a wagon override definition (see below)
5340  * B ids the IDs for which this definition applies
5341  * B num-cid number of cargo IDs (sprite group IDs) in this definition
5342  * can be zero, in that case the def-cid is used always
5343  * B cargo-type type of this cargo type (e.g. mail=2, wood=7, see below)
5344  * W cid cargo ID (sprite group ID) for this type of cargo
5345  * W def-cid default cargo ID (sprite group ID) */
5346 
5347  uint8 feature = buf->ReadByte();
5348  uint8 idcount = buf->ReadByte();
5349 
5350  /* If idcount is zero, this is a feature callback */
5351  if (idcount == 0) {
5352  /* Skip number of cargo ids? */
5353  buf->ReadByte();
5354  uint16 groupid = buf->ReadWord();
5355  if (!IsValidGroupID(groupid, "FeatureMapSpriteGroup")) return;
5356 
5357  grfmsg(6, "FeatureMapSpriteGroup: Adding generic feature callback for feature %d", feature);
5358 
5359  AddGenericCallback(feature, _cur.grffile, _cur.spritegroups[groupid]);
5360  return;
5361  }
5362 
5363  /* Mark the feature as used by the grf (generic callbacks do not count) */
5364  SetBit(_cur.grffile->grf_features, feature);
5365 
5366  grfmsg(6, "FeatureMapSpriteGroup: Feature %d, %d ids", feature, idcount);
5367 
5368  switch (feature) {
5369  case GSF_TRAINS:
5370  case GSF_ROADVEHICLES:
5371  case GSF_SHIPS:
5372  case GSF_AIRCRAFT:
5373  VehicleMapSpriteGroup(buf, feature, idcount);
5374  return;
5375 
5376  case GSF_CANALS:
5377  CanalMapSpriteGroup(buf, idcount);
5378  return;
5379 
5380  case GSF_STATIONS:
5381  StationMapSpriteGroup(buf, idcount);
5382  return;
5383 
5384  case GSF_HOUSES:
5385  TownHouseMapSpriteGroup(buf, idcount);
5386  return;
5387 
5388  case GSF_INDUSTRIES:
5389  IndustryMapSpriteGroup(buf, idcount);
5390  return;
5391 
5392  case GSF_INDUSTRYTILES:
5393  IndustrytileMapSpriteGroup(buf, idcount);
5394  return;
5395 
5396  case GSF_CARGOES:
5397  CargoMapSpriteGroup(buf, idcount);
5398  return;
5399 
5400  case GSF_AIRPORTS:
5401  AirportMapSpriteGroup(buf, idcount);
5402  return;
5403 
5404  case GSF_OBJECTS:
5405  ObjectMapSpriteGroup(buf, idcount);
5406  break;
5407 
5408  case GSF_RAILTYPES:
5409  RailTypeMapSpriteGroup(buf, idcount);
5410  break;
5411 
5412  case GSF_AIRPORTTILES:
5413  AirportTileMapSpriteGroup(buf, idcount);
5414  return;
5415 
5416  default:
5417  grfmsg(1, "FeatureMapSpriteGroup: Unsupported feature %d, skipping", feature);
5418  return;
5419  }
5420 }
5421 
5422 /* Action 0x04 */
5423 static void FeatureNewName(ByteReader *buf)
5424 {
5425  /* <04> <veh-type> <language-id> <num-veh> <offset> <data...>
5426  *
5427  * B veh-type see action 0 (as 00..07, + 0A
5428  * But IF veh-type = 48, then generic text
5429  * B language-id If bit 6 is set, This is the extended language scheme,
5430  * with up to 64 language.
5431  * Otherwise, it is a mapping where set bits have meaning
5432  * 0 = american, 1 = english, 2 = german, 3 = french, 4 = spanish
5433  * Bit 7 set means this is a generic text, not a vehicle one (or else)
5434  * B num-veh number of vehicles which are getting a new name
5435  * B/W offset number of the first vehicle that gets a new name
5436  * Byte : ID of vehicle to change
5437  * Word : ID of string to change/add
5438  * S data new texts, each of them zero-terminated, after
5439  * which the next name begins. */
5440 
5441  bool new_scheme = _cur.grffile->grf_version >= 7;
5442 
5443  uint8 feature = buf->ReadByte();
5444  uint8 lang = buf->ReadByte();
5445  uint8 num = buf->ReadByte();
5446  bool generic = HasBit(lang, 7);
5447  uint16 id;
5448  if (generic) {
5449  id = buf->ReadWord();
5450  } else if (feature <= GSF_AIRCRAFT) {
5451  id = buf->ReadExtendedByte();
5452  } else {
5453  id = buf->ReadByte();
5454  }
5455 
5456  ClrBit(lang, 7);
5457 
5458  uint16 endid = id + num;
5459 
5460  grfmsg(6, "FeatureNewName: About to rename engines %d..%d (feature %d) in language 0x%02X",
5461  id, endid, feature, lang);
5462 
5463  for (; id < endid && buf->HasData(); id++) {
5464  const char *name = buf->ReadString();
5465  grfmsg(8, "FeatureNewName: 0x%04X <- %s", id, name);
5466 
5467  switch (feature) {
5468  case GSF_TRAINS:
5469  case GSF_ROADVEHICLES:
5470  case GSF_SHIPS:
5471  case GSF_AIRCRAFT:
5472  if (!generic) {
5473  Engine *e = GetNewEngine(_cur.grffile, (VehicleType)feature, id, HasBit(_cur.grfconfig->flags, GCF_STATIC));
5474  if (e == NULL) break;
5475  StringID string = AddGRFString(_cur.grffile->grfid, e->index, lang, new_scheme, false, name, e->info.string_id);
5476  e->info.string_id = string;
5477  } else {
5478  AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, true, name, STR_UNDEFINED);
5479  }
5480  break;
5481 
5482  default:
5483  if (IsInsideMM(id, 0xD000, 0xD400) || IsInsideMM(id, 0xD800, 0xE000)) {
5484  AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, true, name, STR_UNDEFINED);
5485  break;
5486  }
5487 
5488  switch (GB(id, 8, 8)) {
5489  case 0xC4: // Station class name
5490  if (_cur.grffile->stations == NULL || _cur.grffile->stations[GB(id, 0, 8)] == NULL) {
5491  grfmsg(1, "FeatureNewName: Attempt to name undefined station 0x%X, ignoring", GB(id, 0, 8));
5492  } else {
5493  StationClassID cls_id = _cur.grffile->stations[GB(id, 0, 8)]->cls_id;
5494  StationClass::Get(cls_id)->name = AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
5495  }
5496  break;
5497 
5498  case 0xC5: // Station name
5499  if (_cur.grffile->stations == NULL || _cur.grffile->stations[GB(id, 0, 8)] == NULL) {
5500  grfmsg(1, "FeatureNewName: Attempt to name undefined station 0x%X, ignoring", GB(id, 0, 8));
5501  } else {
5502  _cur.grffile->stations[GB(id, 0, 8)]->name = AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
5503  }
5504  break;
5505 
5506  case 0xC7: // Airporttile name
5507  if (_cur.grffile->airtspec == NULL || _cur.grffile->airtspec[GB(id, 0, 8)] == NULL) {
5508  grfmsg(1, "FeatureNewName: Attempt to name undefined airport tile 0x%X, ignoring", GB(id, 0, 8));
5509  } else {
5510  _cur.grffile->airtspec[GB(id, 0, 8)]->name = AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
5511  }
5512  break;
5513 
5514  case 0xC9: // House name
5515  if (_cur.grffile->housespec == NULL || _cur.grffile->housespec[GB(id, 0, 8)] == NULL) {
5516  grfmsg(1, "FeatureNewName: Attempt to name undefined house 0x%X, ignoring.", GB(id, 0, 8));
5517  } else {
5518  _cur.grffile->housespec[GB(id, 0, 8)]->building_name = AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
5519  }
5520  break;
5521 
5522  default:
5523  grfmsg(7, "FeatureNewName: Unsupported ID (0x%04X)", id);
5524  break;
5525  }
5526  break;
5527  }
5528  }
5529 }
5530 
5539 static uint16 SanitizeSpriteOffset(uint16& num, uint16 offset, int max_sprites, const char *name)
5540 {
5541 
5542  if (offset >= max_sprites) {
5543  grfmsg(1, "GraphicsNew: %s sprite offset must be less than %i, skipping", name, max_sprites);
5544  uint orig_num = num;
5545  num = 0;
5546  return orig_num;
5547  }
5548 
5549  if (offset + num > max_sprites) {
5550  grfmsg(4, "GraphicsNew: %s sprite overflow, truncating...", name);
5551  uint orig_num = num;
5552  num = max(max_sprites - offset, 0);
5553  return orig_num - num;
5554  }
5555 
5556  return 0;
5557 }
5558 
5559 
5565 };
5567 struct Action5Type {
5570  uint16 min_sprites;
5571  uint16 max_sprites;
5572  const char *name;
5573 };
5574 
5576 static const Action5Type _action5_types[] = {
5577  /* Note: min_sprites should not be changed. Therefore these constants are directly here and not in sprites.h */
5578  /* 0x00 */ { A5BLOCK_INVALID, 0, 0, 0, "Type 0x00" },
5579  /* 0x01 */ { A5BLOCK_INVALID, 0, 0, 0, "Type 0x01" },
5580  /* 0x02 */ { A5BLOCK_INVALID, 0, 0, 0, "Type 0x02" },
5581  /* 0x03 */ { A5BLOCK_INVALID, 0, 0, 0, "Type 0x03" },
5582  /* 0x04 */ { A5BLOCK_ALLOW_OFFSET, SPR_SIGNALS_BASE, 1, PRESIGNAL_SEMAPHORE_AND_PBS_SPRITE_COUNT, "Signal graphics" },
5583  /* 0x05 */ { A5BLOCK_ALLOW_OFFSET, SPR_ELRAIL_BASE, 1, ELRAIL_SPRITE_COUNT, "Rail catenary graphics" },
5584  /* 0x06 */ { A5BLOCK_ALLOW_OFFSET, SPR_SLOPES_BASE, 1, NORMAL_AND_HALFTILE_FOUNDATION_SPRITE_COUNT, "Foundation graphics" },
5585  /* 0x07 */ { A5BLOCK_INVALID, 0, 75, 0, "TTDP GUI graphics" }, // Not used by OTTD.
5586  /* 0x08 */ { A5BLOCK_ALLOW_OFFSET, SPR_CANALS_BASE, 1, CANALS_SPRITE_COUNT, "Canal graphics" },
5587  /* 0x09 */ { A5BLOCK_ALLOW_OFFSET, SPR_ONEWAY_BASE, 1, ONEWAY_SPRITE_COUNT, "One way road graphics" },
5588  /* 0x0A */ { A5BLOCK_ALLOW_OFFSET, SPR_2CCMAP_BASE, 1, TWOCCMAP_SPRITE_COUNT, "2CC colour maps" },
5589  /* 0x0B */ { A5BLOCK_ALLOW_OFFSET, SPR_TRAMWAY_BASE, 1, TRAMWAY_SPRITE_COUNT, "Tramway graphics" },
5590  /* 0x0C */ { A5BLOCK_INVALID, 0, 133, 0, "Snowy temperate tree" }, // Not yet used by OTTD.
5591  /* 0x0D */ { A5BLOCK_FIXED, SPR_SHORE_BASE, 16, SPR_SHORE_SPRITE_COUNT, "Shore graphics" },
5592  /* 0x0E */ { A5BLOCK_INVALID, 0, 0, 0, "New Signals graphics" }, // Not yet used by OTTD.
5593  /* 0x0F */ { A5BLOCK_ALLOW_OFFSET, SPR_TRACKS_FOR_SLOPES_BASE, 1, TRACKS_FOR_SLOPES_SPRITE_COUNT, "Sloped rail track" },
5594  /* 0x10 */ { A5BLOCK_ALLOW_OFFSET, SPR_AIRPORTX_BASE, 1, AIRPORTX_SPRITE_COUNT, "Airport graphics" },
5595  /* 0x11 */ { A5BLOCK_ALLOW_OFFSET, SPR_ROADSTOP_BASE, 1, ROADSTOP_SPRITE_COUNT, "Road stop graphics" },
5596  /* 0x12 */ { A5BLOCK_ALLOW_OFFSET, SPR_AQUEDUCT_BASE, 1, AQUEDUCT_SPRITE_COUNT, "Aqueduct graphics" },
5597  /* 0x13 */ { A5BLOCK_ALLOW_OFFSET, SPR_AUTORAIL_BASE, 1, AUTORAIL_SPRITE_COUNT, "Autorail graphics" },
5598  /* 0x14 */ { A5BLOCK_ALLOW_OFFSET, SPR_FLAGS_BASE, 1, FLAGS_SPRITE_COUNT, "Flag graphics" },
5599  /* 0x15 */ { A5BLOCK_ALLOW_OFFSET, SPR_OPENTTD_BASE, 1, OPENTTD_SPRITE_COUNT, "OpenTTD GUI graphics" },
5600  /* 0x16 */ { A5BLOCK_ALLOW_OFFSET, SPR_AIRPORT_PREVIEW_BASE, 1, SPR_AIRPORT_PREVIEW_COUNT, "Airport preview graphics" },
5601  /* 0x17 */ { A5BLOCK_ALLOW_OFFSET, SPR_RAILTYPE_TUNNEL_BASE, 1, RAILTYPE_TUNNEL_BASE_COUNT, "Railtype tunnel base" },
5602  /* 0x18 */ { A5BLOCK_ALLOW_OFFSET, SPR_PALETTE_BASE, 1, PALETTE_SPRITE_COUNT, "Palette" },
5603 };
5604 
5605 /* Action 0x05 */
5606 static void GraphicsNew(ByteReader *buf)
5607 {
5608  /* <05> <graphics-type> <num-sprites> <other data...>
5609  *
5610  * B graphics-type What set of graphics the sprites define.
5611  * E num-sprites How many sprites are in this set?
5612  * V other data Graphics type specific data. Currently unused. */
5613  /* TODO */
5614 
5615  uint8 type = buf->ReadByte();
5616  uint16 num = buf->ReadExtendedByte();
5617  uint16 offset = HasBit(type, 7) ? buf->ReadExtendedByte() : 0;
5618  ClrBit(type, 7); // Clear the high bit as that only indicates whether there is an offset.
5619 
5620  if ((type == 0x0D) && (num == 10) && HasBit(_cur.grfconfig->flags, GCF_SYSTEM)) {
5621  /* Special not-TTDP-compatible case used in openttd.grf
5622  * Missing shore sprites and initialisation of SPR_SHORE_BASE */
5623  grfmsg(2, "GraphicsNew: Loading 10 missing shore sprites from extra grf.");
5624  LoadNextSprite(SPR_SHORE_BASE + 0, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_STEEP_S
5625  LoadNextSprite(SPR_SHORE_BASE + 5, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_STEEP_W
5626  LoadNextSprite(SPR_SHORE_BASE + 7, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_WSE
5627  LoadNextSprite(SPR_SHORE_BASE + 10, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_STEEP_N
5628  LoadNextSprite(SPR_SHORE_BASE + 11, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_NWS
5629  LoadNextSprite(SPR_SHORE_BASE + 13, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_ENW
5630  LoadNextSprite(SPR_SHORE_BASE + 14, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_SEN
5631  LoadNextSprite(SPR_SHORE_BASE + 15, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_STEEP_E
5632  LoadNextSprite(SPR_SHORE_BASE + 16, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_EW
5633  LoadNextSprite(SPR_SHORE_BASE + 17, _cur.file_index, _cur.nfo_line++, _cur.grf_container_ver); // SLOPE_NS
5634  if (_loaded_newgrf_features.shore == SHORE_REPLACE_NONE) _loaded_newgrf_features.shore = SHORE_REPLACE_ONLY_NEW;
5635  return;
5636  }
5637 
5638  /* Supported type? */
5639  if ((type >= lengthof(_action5_types)) || (_action5_types[type].block_type == A5BLOCK_INVALID)) {
5640  grfmsg(2, "GraphicsNew: Custom graphics (type 0x%02X) sprite block of length %u (unimplemented, ignoring)", type, num);
5641  _cur.skip_sprites = num;
5642  return;
5643  }
5644 
5645  const Action5Type *action5_type = &_action5_types[type];
5646 
5647  /* Contrary to TTDP we allow always to specify too few sprites as we allow always an offset,
5648  * except for the long version of the shore type:
5649  * Ignore offset if not allowed */
5650  if ((action5_type->block_type != A5BLOCK_ALLOW_OFFSET) && (offset != 0)) {
5651  grfmsg(1, "GraphicsNew: %s (type 0x%02X) do not allow an <offset> field. Ignoring offset.", action5_type->name, type);
5652  offset = 0;
5653  }
5654 
5655  /* Ignore action5 if too few sprites are specified. (for TTDP compatibility)
5656  * This does not make sense, if <offset> is allowed */
5657  if ((action5_type->block_type == A5BLOCK_FIXED) && (num < action5_type->min_sprites)) {
5658  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);
5659  _cur.skip_sprites = num;
5660  return;
5661  }
5662 
5663  /* Load at most max_sprites sprites. Skip remaining sprites. (for compatibility with TTDP and future extentions) */
5664  uint16 skip_num = SanitizeSpriteOffset(num, offset, action5_type->max_sprites, action5_type->name);
5665  SpriteID replace = action5_type->sprite_base + offset;
5666 
5667  /* Load <num> sprites starting from <replace>, then skip <skip_num> sprites. */
5668  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);
5669 
5670  for (; num > 0; num--) {
5671  _cur.nfo_line++;
5672  LoadNextSprite(replace == 0 ? _cur.spriteid++ : replace++, _cur.file_index, _cur.nfo_line, _cur.grf_container_ver);
5673  }
5674 
5675  if (type == 0x0D) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_5;
5676 
5677  _cur.skip_sprites = skip_num;
5678 }
5679 
5680 /* Action 0x05 (SKIP) */
5681 static void SkipAct5(ByteReader *buf)
5682 {
5683  /* Ignore type byte */
5684  buf->ReadByte();
5685 
5686  /* Skip the sprites of this action */
5687  _cur.skip_sprites = buf->ReadExtendedByte();
5688 
5689  grfmsg(3, "SkipAct5: Skipping %d sprites", _cur.skip_sprites);
5690 }
5691 
5703 bool GetGlobalVariable(byte param, uint32 *value, const GRFFile *grffile)
5704 {
5705  switch (param) {
5706  case 0x00: // current date
5707  *value = max(_date - DAYS_TILL_ORIGINAL_BASE_YEAR, 0);
5708  return true;
5709 
5710  case 0x01: // current year
5712  return true;
5713 
5714  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)
5715  YearMonthDay ymd;
5716  ConvertDateToYMD(_date, &ymd);
5717  Date start_of_year = ConvertYMDToDate(ymd.year, 0, 1);
5718  *value = ymd.month | (ymd.day - 1) << 8 | (IsLeapYear(ymd.year) ? 1 << 15 : 0) | (_date - start_of_year) << 16;
5719  return true;
5720  }
5721 
5722  case 0x03: // current climate, 0=temp, 1=arctic, 2=trop, 3=toyland
5724  return true;
5725 
5726  case 0x06: // road traffic side, bit 4 clear=left, set=right
5727  *value = _settings_game.vehicle.road_side << 4;
5728  return true;
5729 
5730  case 0x09: // date fraction
5731  *value = _date_fract * 885;
5732  return true;
5733 
5734  case 0x0A: // animation counter
5735  *value = _tick_counter;
5736  return true;
5737 
5738  case 0x0B: { // TTDPatch version
5739  uint major = 2;
5740  uint minor = 6;
5741  uint revision = 1; // special case: 2.0.1 is 2.0.10
5742  uint build = 1382;
5743  *value = (major << 24) | (minor << 20) | (revision << 16) | build;
5744  return true;
5745  }
5746 
5747  case 0x0D: // TTD Version, 00=DOS, 01=Windows
5748  *value = _cur.grfconfig->palette & GRFP_USE_MASK;
5749  return true;
5750 
5751  case 0x0E: // Y-offset for train sprites
5752  *value = _cur.grffile->traininfo_vehicle_pitch;
5753  return true;
5754 
5755  case 0x0F: // Rail track type cost factors
5756  *value = 0;
5757  SB(*value, 0, 8, GetRailTypeInfo(RAILTYPE_RAIL)->cost_multiplier); // normal rail
5759  /* skip elrail multiplier - disabled */
5760  SB(*value, 8, 8, GetRailTypeInfo(RAILTYPE_MONO)->cost_multiplier); // monorail
5761  } else {
5762  SB(*value, 8, 8, GetRailTypeInfo(RAILTYPE_ELECTRIC)->cost_multiplier); // electified railway
5763  /* Skip monorail multiplier - no space in result */
5764  }
5765  SB(*value, 16, 8, GetRailTypeInfo(RAILTYPE_MAGLEV)->cost_multiplier); // maglev
5766  return true;
5767 
5768  case 0x11: // current rail tool type
5769  *value = 0; // constant fake value to avoid desync
5770  return true;
5771 
5772  case 0x12: // Game mode
5773  *value = _game_mode;
5774  return true;
5775 
5776  /* case 0x13: // Tile refresh offset to left not implemented */
5777  /* case 0x14: // Tile refresh offset to right not implemented */
5778  /* case 0x15: // Tile refresh offset upwards not implemented */
5779  /* case 0x16: // Tile refresh offset downwards not implemented */
5780  /* case 0x17: // temperate snow line not implemented */
5781 
5782  case 0x1A: // Always -1
5783  *value = UINT_MAX;
5784  return true;
5785 
5786  case 0x1B: // Display options
5787  *value = 0x3F; // constant fake value to avoid desync
5788  return true;
5789 
5790  case 0x1D: // TTD Platform, 00=TTDPatch, 01=OpenTTD
5791  *value = 1;
5792  return true;
5793 
5794  case 0x1E: // Miscellaneous GRF features
5795  *value = _misc_grf_features;
5796 
5797  /* Add the local flags */
5798  assert(!HasBit(*value, GMB_TRAIN_WIDTH_32_PIXELS));
5799  if (_cur.grffile->traininfo_vehicle_width == VEHICLEINFO_FULL_VEHICLE_WIDTH) SetBit(*value, GMB_TRAIN_WIDTH_32_PIXELS);
5800  return true;
5801 
5802  /* case 0x1F: // locale dependent settings not implemented to avoid desync */
5803 
5804  case 0x20: { // snow line height
5805  byte snowline = GetSnowLine();
5807  *value = Clamp(snowline * (grffile->grf_version >= 8 ? 1 : TILE_HEIGHT), 0, 0xFE);
5808  } else {
5809  /* No snow */
5810  *value = 0xFF;
5811  }
5812  return true;
5813  }
5814 
5815  case 0x21: // OpenTTD version
5816  *value = _openttd_newgrf_version;
5817  return true;
5818 
5819  case 0x22: // difficulty level
5820  *value = SP_CUSTOM;
5821  return true;
5822 
5823  case 0x23: // long format date
5824  *value = _date;
5825  return true;
5826 
5827  case 0x24: // long format year
5828  *value = _cur_year;
5829  return true;
5830 
5831  default: return false;
5832  }
5833 }
5834 
5835 static uint32 GetParamVal(byte param, uint32 *cond_val)
5836 {
5837  /* First handle variable common with VarAction2 */
5838  uint32 value;
5839  if (GetGlobalVariable(param - 0x80, &value, _cur.grffile)) return value;
5840 
5841  /* Non-common variable */
5842  switch (param) {
5843  case 0x84: { // GRF loading stage
5844  uint32 res = 0;
5845 
5846  if (_cur.stage > GLS_INIT) SetBit(res, 0);
5847  if (_cur.stage == GLS_RESERVE) SetBit(res, 8);
5848  if (_cur.stage == GLS_ACTIVATION) SetBit(res, 9);
5849  return res;
5850  }
5851 
5852  case 0x85: // TTDPatch flags, only for bit tests
5853  if (cond_val == NULL) {
5854  /* Supported in Action 0x07 and 0x09, not 0x0D */
5855  return 0;
5856  } else {
5857  uint32 param_val = _ttdpatch_flags[*cond_val / 0x20];
5858  *cond_val %= 0x20;
5859  return param_val;
5860  }
5861 
5862  case 0x88: // GRF ID check
5863  return 0;
5864 
5865  /* case 0x99: Global ID offset not implemented */
5866 
5867  default:
5868  /* GRF Parameter */
5869  if (param < 0x80) return _cur.grffile->GetParam(param);
5870 
5871  /* In-game variable. */
5872  grfmsg(1, "Unsupported in-game variable 0x%02X", param);
5873  return UINT_MAX;
5874  }
5875 }
5876 
5877 /* Action 0x06 */
5878 static void CfgApply(ByteReader *buf)
5879 {
5880  /* <06> <param-num> <param-size> <offset> ... <FF>
5881  *
5882  * B param-num Number of parameter to substitute (First = "zero")
5883  * Ignored if that parameter was not specified in newgrf.cfg
5884  * B param-size How many bytes to replace. If larger than 4, the
5885  * bytes of the following parameter are used. In that
5886  * case, nothing is applied unless *all* parameters
5887  * were specified.
5888  * B offset Offset into data from beginning of next sprite
5889  * to place where parameter is to be stored. */
5890 
5891  /* Preload the next sprite */
5892  size_t pos = FioGetPos();
5893  uint32 num = _cur.grf_container_ver >= 2 ? FioReadDword() : FioReadWord();
5894  uint8 type = FioReadByte();
5895  byte *preload_sprite = NULL;
5896 
5897  /* Check if the sprite is a pseudo sprite. We can't operate on real sprites. */
5898  if (type == 0xFF) {
5899  preload_sprite = MallocT<byte>(num);
5900  FioReadBlock(preload_sprite, num);
5901  }
5902 
5903  /* Reset the file position to the start of the next sprite */
5904  FioSeekTo(pos, SEEK_SET);
5905 
5906  if (type != 0xFF) {
5907  grfmsg(2, "CfgApply: Ignoring (next sprite is real, unsupported)");
5908  free(preload_sprite);
5909  return;
5910  }
5911 
5912  GRFLocation location(_cur.grfconfig->ident.grfid, _cur.nfo_line + 1);
5913  GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.find(location);
5914  if (it != _grf_line_to_action6_sprite_override.end()) {
5915  free(preload_sprite);
5916  preload_sprite = _grf_line_to_action6_sprite_override[location];
5917  } else {
5918  _grf_line_to_action6_sprite_override[location] = preload_sprite;
5919  }
5920 
5921  /* Now perform the Action 0x06 on our data. */
5922 
5923  for (;;) {
5924  uint i;
5925  uint param_num;
5926  uint param_size;
5927  uint offset;
5928  bool add_value;
5929 
5930  /* Read the parameter to apply. 0xFF indicates no more data to change. */
5931  param_num = buf->ReadByte();
5932  if (param_num == 0xFF) break;
5933 
5934  /* Get the size of the parameter to use. If the size covers multiple
5935  * double words, sequential parameter values are used. */
5936  param_size = buf->ReadByte();
5937 
5938  /* Bit 7 of param_size indicates we should add to the original value
5939  * instead of replacing it. */
5940  add_value = HasBit(param_size, 7);
5941  param_size = GB(param_size, 0, 7);
5942 
5943  /* Where to apply the data to within the pseudo sprite data. */
5944  offset = buf->ReadExtendedByte();
5945 
5946  /* If the parameter is a GRF parameter (not an internal variable) check
5947  * if it (and all further sequential parameters) has been defined. */
5948  if (param_num < 0x80 && (param_num + (param_size - 1) / 4) >= _cur.grffile->param_end) {
5949  grfmsg(2, "CfgApply: Ignoring (param %d not set)", (param_num + (param_size - 1) / 4));
5950  break;
5951  }
5952 
5953  grfmsg(8, "CfgApply: Applying %u bytes from parameter 0x%02X at offset 0x%04X", param_size, param_num, offset);
5954 
5955  bool carry = false;
5956  for (i = 0; i < param_size && offset + i < num; i++) {
5957  uint32 value = GetParamVal(param_num + i / 4, NULL);
5958  /* Reset carry flag for each iteration of the variable (only really
5959  * matters if param_size is greater than 4) */
5960  if (i % 4 == 0) carry = false;
5961 
5962  if (add_value) {
5963  uint new_value = preload_sprite[offset + i] + GB(value, (i % 4) * 8, 8) + (carry ? 1 : 0);
5964  preload_sprite[offset + i] = GB(new_value, 0, 8);
5965  /* Check if the addition overflowed */
5966  carry = new_value >= 256;
5967  } else {
5968  preload_sprite[offset + i] = GB(value, (i % 4) * 8, 8);
5969  }
5970  }
5971  }
5972 }
5973 
5984 {
5985  GRFError *error = DisableGrf(STR_NEWGRF_ERROR_STATIC_GRF_CAUSES_DESYNC, c);
5986  error->data = stredup(_cur.grfconfig->GetName());
5987 }
5988 
5989 /* Action 0x07
5990  * Action 0x09 */
5991 static void SkipIf(ByteReader *buf)
5992 {
5993  /* <07/09> <param-num> <param-size> <condition-type> <value> <num-sprites>
5994  *
5995  * B param-num
5996  * B param-size
5997  * B condition-type
5998  * V value
5999  * B num-sprites */
6000  /* TODO: More params. More condition types. */
6001  uint32 cond_val = 0;
6002  uint32 mask = 0;
6003  bool result;
6004 
6005  uint8 param = buf->ReadByte();
6006  uint8 paramsize = buf->ReadByte();
6007  uint8 condtype = buf->ReadByte();
6008 
6009  if (condtype < 2) {
6010  /* Always 1 for bit tests, the given value should be ignored. */
6011  paramsize = 1;
6012  }
6013 
6014  switch (paramsize) {
6015  case 8: cond_val = buf->ReadDWord(); mask = buf->ReadDWord(); break;
6016  case 4: cond_val = buf->ReadDWord(); mask = 0xFFFFFFFF; break;
6017  case 2: cond_val = buf->ReadWord(); mask = 0x0000FFFF; break;
6018  case 1: cond_val = buf->ReadByte(); mask = 0x000000FF; break;
6019  default: break;
6020  }
6021 
6022  if (param < 0x80 && _cur.grffile->param_end <= param) {
6023  grfmsg(7, "SkipIf: Param %d undefined, skipping test", param);
6024  return;
6025  }
6026 
6027  uint32 param_val = GetParamVal(param, &cond_val);
6028 
6029  grfmsg(7, "SkipIf: Test condtype %d, param 0x%08X, condval 0x%08X", condtype, param_val, cond_val);
6030 
6031  /*
6032  * Parameter (variable in specs) 0x88 can only have GRF ID checking
6033  * conditions, except conditions 0x0B, 0x0C (cargo availability) and
6034  * 0x0D, 0x0E (Rail type availability) as those ignore the parameter.
6035  * So, when the condition type is one of those, the specific variable
6036  * 0x88 code is skipped, so the "general" code for the cargo
6037  * availability conditions kicks in.
6038  */
6039  if (param == 0x88 && (condtype < 0x0B || condtype > 0x0E)) {
6040  /* GRF ID checks */
6041 
6042  GRFConfig *c = GetGRFConfig(cond_val, mask);
6043 
6044  if (c != NULL && HasBit(c->flags, GCF_STATIC) && !HasBit(_cur.grfconfig->flags, GCF_STATIC) && _networking) {
6046  c = NULL;
6047  }
6048 
6049  if (condtype != 10 && c == NULL) {
6050  grfmsg(7, "SkipIf: GRFID 0x%08X unknown, skipping test", BSWAP32(cond_val));
6051  return;
6052  }
6053 
6054  switch (condtype) {
6055  /* Tests 0x06 to 0x0A are only for param 0x88, GRFID checks */
6056  case 0x06: // Is GRFID active?
6057  result = c->status == GCS_ACTIVATED;
6058  break;
6059 
6060  case 0x07: // Is GRFID non-active?
6061  result = c->status != GCS_ACTIVATED;
6062  break;
6063 
6064  case 0x08: // GRFID is not but will be active?
6065  result = c->status == GCS_INITIALISED;
6066  break;
6067 
6068  case 0x09: // GRFID is or will be active?
6069  result = c->status == GCS_ACTIVATED || c->status == GCS_INITIALISED;
6070  break;
6071 
6072  case 0x0A: // GRFID is not nor will be active
6073  /* This is the only condtype that doesn't get ignored if the GRFID is not found */
6074  result = c == NULL || c->status == GCS_DISABLED || c->status == GCS_NOT_FOUND;
6075  break;
6076 
6077  default: grfmsg(1, "SkipIf: Unsupported GRF condition type %02X. Ignoring", condtype); return;
6078  }
6079  } else {
6080  /* Parameter or variable tests */
6081  switch (condtype) {
6082  case 0x00: result = !!(param_val & (1 << cond_val));
6083  break;
6084  case 0x01: result = !(param_val & (1 << cond_val));
6085  break;
6086  case 0x02: result = (param_val & mask) == cond_val;
6087  break;
6088  case 0x03: result = (param_val & mask) != cond_val;
6089  break;
6090  case 0x04: result = (param_val & mask) < cond_val;
6091  break;
6092  case 0x05: result = (param_val & mask) > cond_val;
6093  break;
6094  case 0x0B: result = GetCargoIDByLabel(BSWAP32(cond_val)) == CT_INVALID;
6095  break;
6096  case 0x0C: result = GetCargoIDByLabel(BSWAP32(cond_val)) != CT_INVALID;
6097  break;
6098  case 0x0D: result = GetRailTypeByLabel(BSWAP32(cond_val)) == INVALID_RAILTYPE;
6099  break;
6100  case 0x0E: result = GetRailTypeByLabel(BSWAP32(cond_val)) != INVALID_RAILTYPE;
6101  break;
6102 
6103  default: grfmsg(1, "SkipIf: Unsupported condition type %02X. Ignoring", condtype); return;
6104  }
6105  }
6106 
6107  if (!result) {
6108  grfmsg(2, "SkipIf: Not skipping sprites, test was false");
6109  return;
6110  }
6111 
6112  uint8 numsprites = buf->ReadByte();
6113 
6114  /* numsprites can be a GOTO label if it has been defined in the GRF
6115  * file. The jump will always be the first matching label that follows
6116  * the current nfo_line. If no matching label is found, the first matching
6117  * label in the file is used. */
6118  GRFLabel *choice = NULL;
6119  for (GRFLabel *label = _cur.grffile->label; label != NULL; label = label->next) {
6120  if (label->label != numsprites) continue;
6121 
6122  /* Remember a goto before the current line */
6123  if (choice == NULL) choice = label;
6124  /* If we find a label here, this is definitely good */
6125  if (label->nfo_line > _cur.nfo_line) {
6126  choice = label;
6127  break;
6128  }
6129  }
6130 
6131  if (choice != NULL) {
6132  grfmsg(2, "SkipIf: Jumping to label 0x%0X at line %d, test was true", choice->label, choice->nfo_line);
6133  FioSeekTo(choice->pos, SEEK_SET);
6134  _cur.nfo_line = choice->nfo_line;
6135  return;
6136  }
6137 
6138  grfmsg(2, "SkipIf: Skipping %d sprites, test was true", numsprites);
6139  _cur.skip_sprites = numsprites;
6140  if (_cur.skip_sprites == 0) {
6141  /* Zero means there are no sprites to skip, so
6142  * we use -1 to indicate that all further
6143  * sprites should be skipped. */
6144  _cur.skip_sprites = -1;
6145 
6146  /* If an action 8 hasn't been encountered yet, disable the grf. */
6147  if (_cur.grfconfig->status != (_cur.stage < GLS_RESERVE ? GCS_INITIALISED : GCS_ACTIVATED)) {
6148  DisableGrf();
6149  }
6150  }
6151 }
6152 
6153 
6154 /* Action 0x08 (GLS_FILESCAN) */
6155 static void ScanInfo(ByteReader *buf)
6156 {
6157  uint8 grf_version = buf->ReadByte();
6158  uint32 grfid = buf->ReadDWord();
6159  const char *name = buf->ReadString();
6160 
6161  _cur.grfconfig->ident.grfid = grfid;
6162 
6163  if (grf_version < 2 || grf_version > 8) {
6165  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);
6166  }
6167 
6168  /* GRF IDs starting with 0xFF are reserved for internal TTDPatch use */
6169  if (GB(grfid, 0, 8) == 0xFF) SetBit(_cur.grfconfig->flags, GCF_SYSTEM);
6170 
6171  AddGRFTextToList(&_cur.grfconfig->name->text, 0x7F, grfid, false, name);
6172 
6173  if (buf->HasData()) {
6174  const char *info = buf->ReadString();
6175  AddGRFTextToList(&_cur.grfconfig->info->text, 0x7F, grfid, true, info);
6176  }
6177 
6178  /* GLS_INFOSCAN only looks for the action 8, so we can skip the rest of the file */
6179  _cur.skip_sprites = -1;
6180 }
6181 
6182 /* Action 0x08 */
6183 static void GRFInfo(ByteReader *buf)
6184 {
6185  /* <08> <version> <grf-id> <name> <info>
6186  *
6187  * B version newgrf version, currently 06
6188  * 4*B grf-id globally unique ID of this .grf file
6189  * S name name of this .grf set
6190  * S info string describing the set, and e.g. author and copyright */
6191 
6192  uint8 version = buf->ReadByte();
6193  uint32 grfid = buf->ReadDWord();
6194  const char *name = buf->ReadString();
6195 
6196  if (_cur.stage < GLS_RESERVE && _cur.grfconfig->status != GCS_UNKNOWN) {
6197  DisableGrf(STR_NEWGRF_ERROR_MULTIPLE_ACTION_8);
6198  return;
6199  }
6200 
6201  if (_cur.grffile->grfid != grfid) {
6202  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));
6203  _cur.grffile->grfid = grfid;
6204  }
6205 
6206  _cur.grffile->grf_version = version;
6207  _cur.grfconfig->status = _cur.stage < GLS_RESERVE ? GCS_INITIALISED : GCS_ACTIVATED;
6208 
6209  /* Do swap the GRFID for displaying purposes since people expect that */
6210  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);
6211 }
6212 
6213 /* Action 0x0A */
6214 static void SpriteReplace(ByteReader *buf)
6215 {
6216  /* <0A> <num-sets> <set1> [<set2> ...]
6217  * <set>: <num-sprites> <first-sprite>
6218  *
6219  * B num-sets How many sets of sprites to replace.
6220  * Each set:
6221  * B num-sprites How many sprites are in this set
6222  * W first-sprite First sprite number to replace */
6223 
6224  uint8 num_sets = buf->ReadByte();
6225 
6226  for (uint i = 0; i < num_sets; i++) {
6227  uint8 num_sprites = buf->ReadByte();
6228  uint16 first_sprite = buf->ReadWord();
6229 
6230  grfmsg(2, "SpriteReplace: [Set %d] Changing %d sprites, beginning with %d",
6231  i, num_sprites, first_sprite
6232  );
6233 
6234  for (uint j = 0; j < num_sprites; j++) {
6235  int load_index = first_sprite + j;
6236  _cur.nfo_line++;
6237  LoadNextSprite(load_index, _cur.file_index, _cur.nfo_line, _cur.grf_container_ver); // XXX
6238 
6239  /* Shore sprites now located at different addresses.
6240  * So detect when the old ones get replaced. */
6241  if (IsInsideMM(load_index, SPR_ORIGINALSHORE_START, SPR_ORIGINALSHORE_END + 1)) {
6242  if (_loaded_newgrf_features.shore != SHORE_REPLACE_ACTION_5) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_A;
6243  }
6244  }
6245  }
6246 }
6247 
6248 /* Action 0x0A (SKIP) */
6249 static void SkipActA(ByteReader *buf)
6250 {
6251  uint8 num_sets = buf->ReadByte();
6252 
6253  for (uint i = 0; i < num_sets; i++) {
6254  /* Skip the sprites this replaces */
6255  _cur.skip_sprites += buf->ReadByte();
6256  /* But ignore where they go */
6257  buf->ReadWord();
6258  }
6259 
6260  grfmsg(3, "SkipActA: Skipping %d sprites", _cur.skip_sprites);
6261 }
6262 
6263 /* Action 0x0B */
6264 static void GRFLoadError(ByteReader *buf)
6265 {
6266  /* <0B> <severity> <language-id> <message-id> [<message...> 00] [<data...>] 00 [<parnum>]
6267  *
6268  * B severity 00: notice, contine loading grf file
6269  * 01: warning, continue loading grf file
6270  * 02: error, but continue loading grf file, and attempt
6271  * loading grf again when loading or starting next game
6272  * 03: error, abort loading and prevent loading again in
6273  * the future (only when restarting the patch)
6274  * B language-id see action 4, use 1F for built-in error messages
6275  * B message-id message to show, see below
6276  * S message for custom messages (message-id FF), text of the message
6277  * not present for built-in messages.
6278  * V data additional data for built-in (or custom) messages
6279  * B parnum parameter numbers to be shown in the message (maximum of 2) */
6280 
6281  static const StringID msgstr[] = {
6282  STR_NEWGRF_ERROR_VERSION_NUMBER,
6283  STR_NEWGRF_ERROR_DOS_OR_WINDOWS,
6284  STR_NEWGRF_ERROR_UNSET_SWITCH,
6285  STR_NEWGRF_ERROR_INVALID_PARAMETER,
6286  STR_NEWGRF_ERROR_LOAD_BEFORE,
6287  STR_NEWGRF_ERROR_LOAD_AFTER,
6288  STR_NEWGRF_ERROR_OTTD_VERSION_NUMBER,
6289  };
6290 
6291  static const StringID sevstr[] = {
6292  STR_NEWGRF_ERROR_MSG_INFO,
6293  STR_NEWGRF_ERROR_MSG_WARNING,
6294  STR_NEWGRF_ERROR_MSG_ERROR,
6295  STR_NEWGRF_ERROR_MSG_FATAL
6296  };
6297 
6298  byte severity = buf->ReadByte();
6299  byte lang = buf->ReadByte();
6300  byte message_id = buf->ReadByte();
6301 
6302  /* Skip the error if it isn't valid for the current language. */
6303  if (!CheckGrfLangID(lang, _cur.grffile->grf_version)) return;
6304 
6305  /* Skip the error until the activation stage unless bit 7 of the severity
6306  * is set. */
6307  if (!HasBit(severity, 7) && _cur.stage == GLS_INIT) {
6308  grfmsg(7, "GRFLoadError: Skipping non-fatal GRFLoadError in stage %d", _cur.stage);
6309  return;
6310  }
6311  ClrBit(severity, 7);
6312 
6313  if (severity >= lengthof(sevstr)) {
6314  grfmsg(7, "GRFLoadError: Invalid severity id %d. Setting to 2 (non-fatal error).", severity);
6315  severity = 2;
6316  } else if (severity == 3) {
6317  /* This is a fatal error, so make sure the GRF is deactivated and no
6318  * more of it gets loaded. */
6319  DisableGrf();
6320 
6321  /* Make sure we show fatal errors, instead of silly infos from before */
6322  delete _cur.grfconfig->error;
6323  _cur.grfconfig->error = NULL;
6324  }
6325 
6326  if (message_id >= lengthof(msgstr) && message_id != 0xFF) {
6327  grfmsg(7, "GRFLoadError: Invalid message id.");
6328  return;
6329  }
6330 
6331  if (buf->Remaining() <= 1) {
6332  grfmsg(7, "GRFLoadError: No message data supplied.");
6333  return;
6334  }
6335 
6336  /* For now we can only show one message per newgrf file. */
6337  if (_cur.grfconfig->error != NULL) return;
6338 
6339  GRFError *error = new GRFError(sevstr[severity]);
6340 
6341  if (message_id == 0xFF) {
6342  /* This is a custom error message. */
6343  if (buf->HasData()) {
6344  const char *message = buf->ReadString();
6345 
6346  error->custom_message = TranslateTTDPatchCodes(_cur.grffile->grfid, lang, true, message, NULL, SCC_RAW_STRING_POINTER);
6347  } else {
6348  grfmsg(7, "GRFLoadError: No custom message supplied.");
6349  error->custom_message = stredup("");
6350  }
6351  } else {
6352  error->message = msgstr[message_id];
6353  }
6354 
6355  if (buf->HasData()) {
6356  const char *data = buf->ReadString();
6357 
6358  error->data = TranslateTTDPatchCodes(_cur.grffile->grfid, lang, true, data);
6359  } else {
6360  grfmsg(7, "GRFLoadError: No message data supplied.");
6361  error->data = stredup("");
6362  }
6363 
6364  /* Only two parameter numbers can be used in the string. */
6365  for (uint i = 0; i < lengthof(error->param_value) && buf->HasData(); i++) {
6366  uint param_number = buf->ReadByte();
6367  error->param_value[i] = _cur.grffile->GetParam(param_number);
6368  }
6369 
6370  _cur.grfconfig->error = error;
6371 }
6372 
6373 /* Action 0x0C */
6374 static void GRFComment(ByteReader *buf)
6375 {
6376  /* <0C> [<ignored...>]
6377  *
6378  * V ignored Anything following the 0C is ignored */
6379 
6380  if (!buf->HasData()) return;
6381 
6382  const char *text = buf->ReadString();
6383  grfmsg(2, "GRFComment: %s", text);
6384 }
6385 
6386 /* Action 0x0D (GLS_SAFETYSCAN) */
6387 static void SafeParamSet(ByteReader *buf)
6388 {
6389  uint8 target = buf->ReadByte();
6390 
6391  /* Writing GRF parameters and some bits of 'misc GRF features' are safe. */
6392  if (target < 0x80 || target == 0x9E) return;
6393 
6394  /* GRM could be unsafe, but as here it can only happen after other GRFs
6395  * are loaded, it should be okay. If the GRF tried to use the slots it
6396  * reserved, it would be marked unsafe anyway. GRM for (e.g. bridge)
6397  * sprites is considered safe. */
6398 
6399  SetBit(_cur.grfconfig->flags, GCF_UNSAFE);
6400 
6401  /* Skip remainder of GRF */
6402  _cur.skip_sprites = -1;
6403 }
6404 
6405 
6406 static uint32 GetPatchVariable(uint8 param)
6407 {
6408  switch (param) {
6409  /* start year - 1920 */
6411 
6412  /* freight trains weight factor */
6413  case 0x0E: return _settings_game.vehicle.freight_trains;
6414 
6415  /* empty wagon speed increase */
6416  case 0x0F: return 0;
6417 
6418  /* plane speed factor; our patch option is reversed from TTDPatch's,
6419  * the following is good for 1x, 2x and 4x (most common?) and...
6420  * well not really for 3x. */
6421  case 0x10:
6423  default:
6424  case 4: return 1;
6425  case 3: return 2;
6426  case 2: return 2;
6427  case 1: return 4;
6428  }
6429 
6430 
6431  /* 2CC colourmap base sprite */
6432  case 0x11: return SPR_2CCMAP_BASE;
6433 
6434  /* map size: format = -MABXYSS
6435  * M : the type of map
6436  * bit 0 : set : squared map. Bit 1 is now not relevant
6437  * clear : rectangle map. Bit 1 will indicate the bigger edge of the map
6438  * bit 1 : set : Y is the bigger edge. Bit 0 is clear
6439  * clear : X is the bigger edge.
6440  * A : minimum edge(log2) of the map
6441  * B : maximum edge(log2) of the map
6442  * XY : edges(log2) of each side of the map.
6443  * SS : combination of both X and Y, thus giving the size(log2) of the map
6444  */
6445  case 0x13: {
6446  byte map_bits = 0;
6447  byte log_X = MapLogX() - 6; // substraction is required to make the minimal size (64) zero based
6448  byte log_Y = MapLogY() - 6;
6449  byte max_edge = max(log_X, log_Y);
6450 
6451  if (log_X == log_Y) { // we have a squared map, since both edges are identical
6452  SetBit(map_bits, 0);
6453  } else {
6454  if (max_edge == log_Y) SetBit(map_bits, 1); // edge Y been the biggest, mark it
6455  }
6456 
6457  return (map_bits << 24) | (min(log_X, log_Y) << 20) | (max_edge << 16) |
6458  (log_X << 12) | (log_Y << 8) | (log_X + log_Y);
6459  }
6460 
6461  /* The maximum height of the map. */
6462  case 0x14:
6464 
6465  /* Extra foundations base sprite */
6466  case 0x15:
6467  return SPR_SLOPES_BASE;
6468 
6469  /* Shore base sprite */
6470  case 0x16:
6471  return SPR_SHORE_BASE;
6472 
6473  default:
6474  grfmsg(2, "ParamSet: Unknown Patch variable 0x%02X.", param);
6475  return 0;
6476  }
6477 }
6478 
6479 
6480 static uint32 PerformGRM(uint32 *grm, uint16 num_ids, uint16 count, uint8 op, uint8 target, const char *type)
6481 {
6482  uint start = 0;
6483  uint size = 0;
6484 
6485  if (op == 6) {
6486  /* Return GRFID of set that reserved ID */
6487  return grm[_cur.grffile->GetParam(target)];
6488  }
6489 
6490  /* With an operation of 2 or 3, we want to reserve a specific block of IDs */
6491  if (op == 2 || op == 3) start = _cur.grffile->GetParam(target);
6492 
6493  for (uint i = start; i < num_ids; i++) {
6494  if (grm[i] == 0) {
6495  size++;
6496  } else {
6497  if (op == 2 || op == 3) break;
6498  start = i + 1;
6499  size = 0;
6500  }
6501 
6502  if (size == count) break;
6503  }
6504 
6505  if (size == count) {
6506  /* Got the slot... */
6507  if (op == 0 || op == 3) {
6508  grfmsg(2, "ParamSet: GRM: Reserving %d %s at %d", count, type, start);
6509  for (uint i = 0; i < count; i++) grm[start + i] = _cur.grffile->grfid;
6510  }
6511  return start;
6512  }
6513 
6514  /* Unable to allocate */
6515  if (op != 4 && op != 5) {
6516  /* Deactivate GRF */
6517  grfmsg(0, "ParamSet: GRM: Unable to allocate %d %s, deactivating", count, type);
6518  DisableGrf(STR_NEWGRF_ERROR_GRM_FAILED);
6519  return UINT_MAX;
6520  }
6521 
6522  grfmsg(1, "ParamSet: GRM: Unable to allocate %d %s", count, type);
6523  return UINT_MAX;
6524 }
6525 
6526 
6528 static void ParamSet(ByteReader *buf)
6529 {
6530  /* <0D> <target> <operation> <source1> <source2> [<data>]
6531  *
6532  * B target parameter number where result is stored
6533  * B operation operation to perform, see below
6534  * B source1 first source operand
6535  * B source2 second source operand
6536  * D data data to use in the calculation, not necessary
6537  * if both source1 and source2 refer to actual parameters
6538  *
6539  * Operations
6540  * 00 Set parameter equal to source1
6541  * 01 Addition, source1 + source2
6542  * 02 Subtraction, source1 - source2
6543  * 03 Unsigned multiplication, source1 * source2 (both unsigned)
6544  * 04 Signed multiplication, source1 * source2 (both signed)
6545  * 05 Unsigned bit shift, source1 by source2 (source2 taken to be a
6546  * signed quantity; left shift if positive and right shift if
6547  * negative, source1 is unsigned)
6548  * 06 Signed bit shift, source1 by source2
6549  * (source2 like in 05, and source1 as well)
6550  */
6551 
6552  uint8 target = buf->ReadByte();
6553  uint8 oper = buf->ReadByte();
6554  uint32 src1 = buf->ReadByte();
6555  uint32 src2 = buf->ReadByte();
6556 
6557  uint32 data = 0;
6558  if (buf->Remaining() >= 4) data = buf->ReadDWord();
6559 
6560  /* You can add 80 to the operation to make it apply only if the target
6561  * is not defined yet. In this respect, a parameter is taken to be
6562  * defined if any of the following applies:
6563  * - it has been set to any value in the newgrf(w).cfg parameter list
6564  * - it OR A PARAMETER WITH HIGHER NUMBER has been set to any value by
6565  * an earlier action D */
6566  if (HasBit(oper, 7)) {
6567  if (target < 0x80 && target < _cur.grffile->param_end) {
6568  grfmsg(7, "ParamSet: Param %u already defined, skipping", target);
6569  return;
6570  }
6571 
6572  oper = GB(oper, 0, 7);
6573  }
6574 
6575  if (src2 == 0xFE) {
6576  if (GB(data, 0, 8) == 0xFF) {
6577  if (data == 0x0000FFFF) {
6578  /* Patch variables */
6579  src1 = GetPatchVariable(src1);
6580  } else {
6581  /* GRF Resource Management */
6582  uint8 op = src1;
6583  uint8 feature = GB(data, 8, 8);
6584  uint16 count = GB(data, 16, 16);
6585 
6586  if (_cur.stage == GLS_RESERVE) {
6587  if (feature == 0x08) {
6588  /* General sprites */
6589  if (op == 0) {
6590  /* Check if the allocated sprites will fit below the original sprite limit */
6591  if (_cur.spriteid + count >= 16384) {
6592  grfmsg(0, "ParamSet: GRM: Unable to allocate %d sprites; try changing NewGRF order", count);
6593  DisableGrf(STR_NEWGRF_ERROR_GRM_FAILED);
6594  return;
6595  }
6596 
6597  /* Reserve space at the current sprite ID */
6598  grfmsg(4, "ParamSet: GRM: Allocated %d sprites at %d", count, _cur.spriteid);
6599  _grm_sprites[GRFLocation(_cur.grffile->grfid, _cur.nfo_line)] = _cur.spriteid;
6600  _cur.spriteid += count;
6601  }
6602  }
6603  /* Ignore GRM result during reservation */
6604  src1 = 0;
6605  } else if (_cur.stage == GLS_ACTIVATION) {
6606  switch (feature) {
6607  case 0x00: // Trains
6608  case 0x01: // Road Vehicles
6609  case 0x02: // Ships
6610  case 0x03: // Aircraft
6612  src1 = PerformGRM(&_grm_engines[_engine_offsets[feature]], _engine_counts[feature], count, op, target, "vehicles");
6613  if (_cur.skip_sprites == -1) return;
6614  } else {
6615  /* GRM does not apply for dynamic engine allocation. */
6616  switch (op) {
6617  case 2:
6618  case 3:
6619  src1 = _cur.grffile->GetParam(target);
6620  break;
6621 
6622  default:
6623  src1 = 0;
6624  break;
6625  }
6626  }
6627  break;
6628 
6629  case 0x08: // General sprites
6630  switch (op) {
6631  case 0:
6632  /* Return space reserved during reservation stage */
6633  src1 = _grm_sprites[GRFLocation(_cur.grffile->grfid, _cur.nfo_line)];
6634  grfmsg(4, "ParamSet: GRM: Using pre-allocated sprites at %d", src1);
6635  break;
6636 
6637  case 1:
6638  src1 = _cur.spriteid;
6639  break;
6640 
6641  default:
6642  grfmsg(1, "ParamSet: GRM: Unsupported operation %d for general sprites", op);
6643  return;
6644  }
6645  break;
6646 
6647  case 0x0B: // Cargo
6648  /* There are two ranges: one for cargo IDs and one for cargo bitmasks */
6649  src1 = PerformGRM(_grm_cargoes, NUM_CARGO * 2, count, op, target, "cargoes");
6650  if (_cur.skip_sprites == -1) return;
6651  break;
6652 
6653  default: grfmsg(1, "ParamSet: GRM: Unsupported feature 0x%X", feature); return;
6654  }
6655  } else {
6656  /* Ignore GRM during initialization */
6657  src1 = 0;
6658  }
6659  }
6660  } else {
6661  /* Read another GRF File's parameter */
6662  const GRFFile *file = GetFileByGRFID(data);
6663  GRFConfig *c = GetGRFConfig(data);
6664  if (c != NULL && HasBit(c->flags, GCF_STATIC) && !HasBit(_cur.grfconfig->flags, GCF_STATIC) && _networking) {
6665  /* Disable the read GRF if it is a static NewGRF. */
6667  src1 = 0;
6668  } else if (file == NULL || c == NULL || c->status == GCS_DISABLED) {
6669  src1 = 0;
6670  } else if (src1 == 0xFE) {
6671  src1 = c->version;
6672  } else {
6673  src1 = file->GetParam(src1);
6674  }
6675  }
6676  } else {
6677  /* The source1 and source2 operands refer to the grf parameter number
6678  * like in action 6 and 7. In addition, they can refer to the special
6679  * variables available in action 7, or they can be FF to use the value
6680  * of <data>. If referring to parameters that are undefined, a value
6681  * of 0 is used instead. */
6682  src1 = (src1 == 0xFF) ? data : GetParamVal(src1, NULL);
6683  src2 = (src2 == 0xFF) ? data : GetParamVal(src2, NULL);
6684  }
6685 
6686  /* TODO: You can access the parameters of another GRF file by using
6687  * source2=FE, source1=the other GRF's parameter number and data=GRF
6688  * ID. This is only valid with operation 00 (set). If the GRF ID
6689  * cannot be found, a value of 0 is used for the parameter value
6690  * instead. */
6691 
6692  uint32 res;
6693  switch (oper) {
6694  case 0x00:
6695  res = src1;
6696  break;
6697 
6698  case 0x01:
6699  res = src1 + src2;
6700  break;
6701 
6702  case 0x02:
6703  res = src1 - src2;
6704  break;
6705 
6706  case 0x03:
6707  res = src1 * src2;
6708  break;
6709 
6710  case 0x04:
6711  res = (int32)src1 * (int32)src2;
6712  break;
6713 
6714  case 0x05:
6715  if ((int32)src2 < 0) {
6716  res = src1 >> -(int32)src2;
6717  } else {
6718  res = src1 << (src2 & 0x1F); // Same behaviour as in EvalAdjustT, mask 'value' to 5 bits, which should behave the same on all architectures.
6719  }
6720  break;
6721 
6722  case 0x06:
6723  if ((int32)src2 < 0) {
6724  res = (int32)src1 >> -(int32)src2;
6725  } else {
6726  res = (int32)src1 << (src2 & 0x1F); // Same behaviour as in EvalAdjustT, mask 'value' to 5 bits, which should behave the same on all architectures.
6727  }
6728  break;
6729 
6730  case 0x07: // Bitwise AND
6731  res = src1 & src2;
6732  break;
6733 
6734  case 0x08: // Bitwise OR
6735  res = src1 | src2;
6736  break;
6737 
6738  case 0x09: // Unsigned division
6739  if (src2 == 0) {
6740  res = src1;
6741  } else {
6742  res = src1 / src2;
6743  }
6744  break;
6745 
6746  case 0x0A: // Signed divison
6747  if (src2 == 0) {
6748  res = src1;
6749  } else {
6750  res = (int32)src1 / (int32)src2;
6751  }
6752  break;
6753 
6754  case 0x0B: // Unsigned modulo
6755  if (src2 == 0) {
6756  res = src1;
6757  } else {
6758  res = src1 % src2;
6759  }
6760  break;
6761 
6762  case 0x0C: // Signed modulo
6763  if (src2 == 0) {
6764  res = src1;
6765  } else {
6766  res = (int32)src1 % (int32)src2;
6767  }
6768  break;
6769 
6770  default: grfmsg(0, "ParamSet: Unknown operation %d, skipping", oper); return;
6771  }
6772 
6773  switch (target) {
6774  case 0x8E: // Y-Offset for train sprites
6775  _cur.grffile->traininfo_vehicle_pitch = res;
6776  break;
6777 
6778  case 0x8F: { // Rail track type cost factors
6779  extern RailtypeInfo _railtypes[RAILTYPE_END];
6780  _railtypes[RAILTYPE_RAIL].cost_multiplier = GB(res, 0, 8);
6782  _railtypes[RAILTYPE_ELECTRIC].cost_multiplier = GB(res, 0, 8);
6783  _railtypes[RAILTYPE_MONO].cost_multiplier = GB(res, 8, 8);
6784  } else {
6785  _railtypes[RAILTYPE_ELECTRIC].cost_multiplier = GB(res, 8, 8);
6786  _railtypes[RAILTYPE_MONO].cost_multiplier = GB(res, 16, 8);
6787  }
6788  _railtypes[RAILTYPE_MAGLEV].cost_multiplier = GB(res, 16, 8);
6789  break;
6790  }
6791 
6792  /* @todo implement */
6793  case 0x93: // Tile refresh offset to left
6794  case 0x94: // Tile refresh offset to right
6795  case 0x95: // Tile refresh offset upwards
6796  case 0x96: // Tile refresh offset downwards
6797  case 0x97: // Snow line height
6798  case 0x99: // Global ID offset
6799  grfmsg(7, "ParamSet: Skipping unimplemented target 0x%02X", target);
6800  break;
6801 
6802  case 0x9E: // Miscellaneous GRF features
6803  /* Set train list engine width */
6804  _cur.grffile->traininfo_vehicle_width = HasBit(res, GMB_TRAIN_WIDTH_32_PIXELS) ? VEHICLEINFO_FULL_VEHICLE_WIDTH : TRAININFO_DEFAULT_VEHICLE_WIDTH;
6805  /* Remove the local flags from the global flags */
6807 
6808  /* Only copy safe bits for static grfs */
6809  if (HasBit(_cur.grfconfig->flags, GCF_STATIC)) {
6810  uint32 safe_bits = 0;
6811  SetBit(safe_bits, GMB_SECOND_ROCKY_TILE_SET);
6812 
6813  _misc_grf_features = (_misc_grf_features & ~safe_bits) | (res & safe_bits);
6814  } else {
6815  _misc_grf_features = res;
6816  }
6817  break;
6818 
6819  case 0x9F: // locale-dependent settings
6820  grfmsg(7, "ParamSet: Skipping unimplemented target 0x%02X", target);
6821  break;
6822 
6823  default:
6824  if (target < 0x80) {
6825  _cur.grffile->param[target] = res;
6826  /* param is zeroed by default */
6827  if (target + 1U > _cur.grffile->param_end) _cur.grffile->param_end = target + 1;
6828  } else {
6829  grfmsg(7, "ParamSet: Skipping unknown target 0x%02X", target);
6830  }
6831  break;
6832  }
6833 }
6834 
6835 /* Action 0x0E (GLS_SAFETYSCAN) */
6836 static void SafeGRFInhibit(ByteReader *buf)
6837 {
6838  /* <0E> <num> <grfids...>
6839  *
6840  * B num Number of GRFIDs that follow
6841  * D grfids GRFIDs of the files to deactivate */
6842 
6843  uint8 num = buf->ReadByte();
6844 
6845  for (uint i = 0; i < num; i++) {
6846  uint32 grfid = buf->ReadDWord();
6847 
6848  /* GRF is unsafe it if tries to deactivate other GRFs */
6849  if (grfid != _cur.grfconfig->ident.grfid) {
6850  SetBit(_cur.grfconfig->flags, GCF_UNSAFE);
6851 
6852  /* Skip remainder of GRF */
6853  _cur.skip_sprites = -1;
6854 
6855  return;
6856  }
6857  }
6858 }
6859 
6860 /* Action 0x0E */
6861 static void GRFInhibit(ByteReader *buf)
6862 {
6863  /* <0E> <num> <grfids...>
6864  *
6865  * B num Number of GRFIDs that follow
6866  * D grfids GRFIDs of the files to deactivate */
6867 
6868  uint8 num = buf->ReadByte();
6869 
6870  for (uint i = 0; i < num; i++) {
6871  uint32 grfid = buf->ReadDWord();
6872  GRFConfig *file = GetGRFConfig(grfid);
6873 
6874  /* Unset activation flag */
6875  if (file != NULL && file != _cur.grfconfig) {
6876  grfmsg(2, "GRFInhibit: Deactivating file '%s'", file->filename);
6877  GRFError *error = DisableGrf(STR_NEWGRF_ERROR_FORCEFULLY_DISABLED, file);
6878  error->data = stredup(_cur.grfconfig->GetName());
6879  }
6880  }
6881 }
6882 
6884 static void FeatureTownName(ByteReader *buf)
6885 {
6886  /* <0F> <id> <style-name> <num-parts> <parts>
6887  *
6888  * B id ID of this definition in bottom 7 bits (final definition if bit 7 set)
6889  * V style-name Name of the style (only for final definition)
6890  * B num-parts Number of parts in this definition
6891  * V parts The parts */
6892 
6893  uint32 grfid = _cur.grffile->grfid;
6894 
6895  GRFTownName *townname = AddGRFTownName(grfid);
6896 
6897  byte id = buf->ReadByte();
6898  grfmsg(6, "FeatureTownName: definition 0x%02X", id & 0x7F);
6899 
6900  if (HasBit(id, 7)) {
6901  /* Final definition */
6902  ClrBit(id, 7);
6903  bool new_scheme = _cur.grffile->grf_version >= 7;
6904 
6905  byte lang = buf->ReadByte();
6906 
6907  byte nb_gen = townname->nb_gen;
6908  do {
6909  ClrBit(lang, 7);
6910 
6911  const char *name = buf->ReadString();
6912 
6913  char *lang_name = TranslateTTDPatchCodes(grfid, lang, false, name);
6914  grfmsg(6, "FeatureTownName: lang 0x%X -> '%s'", lang, lang_name);
6915  free(lang_name);
6916 
6917  townname->name[nb_gen] = AddGRFString(grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
6918 
6919  lang = buf->ReadByte();
6920  } while (lang != 0);
6921  townname->id[nb_gen] = id;
6922  townname->nb_gen++;
6923  }
6924 
6925  byte nb = buf->ReadByte();
6926  grfmsg(6, "FeatureTownName: %u parts", nb);
6927 
6928  townname->nbparts[id] = nb;
6929  townname->partlist[id] = CallocT<NamePartList>(nb);
6930 
6931  for (int i = 0; i < nb; i++) {
6932  byte nbtext = buf->ReadByte();
6933  townname->partlist[id][i].bitstart = buf->ReadByte();
6934  townname->partlist[id][i].bitcount = buf->ReadByte();
6935  townname->partlist[id][i].maxprob = 0;
6936  townname->partlist[id][i].partcount = nbtext;
6937  townname->partlist[id][i].parts = CallocT<NamePart>(nbtext);
6938  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);
6939 
6940  for (int j = 0; j < nbtext; j++) {
6941  byte prob = buf->ReadByte();
6942 
6943  if (HasBit(prob, 7)) {
6944  byte ref_id = buf->ReadByte();
6945 
6946  if (townname->nbparts[ref_id] == 0) {
6947  grfmsg(0, "FeatureTownName: definition 0x%02X doesn't exist, deactivating", ref_id);
6948  DelGRFTownName(grfid);
6949  DisableGrf(STR_NEWGRF_ERROR_INVALID_ID);
6950  return;
6951  }
6952 
6953  grfmsg(6, "FeatureTownName: part %d, text %d, uses intermediate definition 0x%02X (with probability %d)", i, j, ref_id, prob & 0x7F);
6954  townname->partlist[id][i].parts[j].data.id = ref_id;
6955  } else {
6956  const char *text = buf->ReadString();
6957  townname->partlist[id][i].parts[j].data.text = TranslateTTDPatchCodes(grfid, 0, false, text);
6958  grfmsg(6, "FeatureTownName: part %d, text %d, '%s' (with probability %d)", i, j, townname->partlist[id][i].parts[j].data.text, prob);
6959  }
6960  townname->partlist[id][i].parts[j].prob = prob;
6961  townname->partlist[id][i].maxprob += GB(prob, 0, 7);
6962  }
6963  grfmsg(6, "FeatureTownName: part %d, total probability %d", i, townname->partlist[id][i].maxprob);
6964  }
6965 }
6966 
6968 static void DefineGotoLabel(ByteReader *buf)
6969 {
6970  /* <10> <label> [<comment>]
6971  *
6972  * B label The label to define
6973  * V comment Optional comment - ignored */
6974 
6975  byte nfo_label = buf->ReadByte();
6976 
6977  GRFLabel *label = MallocT<GRFLabel>(1);
6978  label->label = nfo_label;
6979  label->nfo_line = _cur.nfo_line;
6980  label->pos = FioGetPos();
6981  label->next = NULL;
6982 
6983  /* Set up a linked list of goto targets which we will search in an Action 0x7/0x9 */
6984  if (_cur.grffile->label == NULL) {
6985  _cur.grffile->label = label;
6986  } else {
6987  /* Attach the label to the end of the list */
6988  GRFLabel *l;
6989  for (l = _cur.grffile->label; l->next != NULL; l = l->next) {}
6990  l->next = label;
6991  }
6992 
6993  grfmsg(2, "DefineGotoLabel: GOTO target with label 0x%02X", label->label);
6994 }
6995 
7000 static void ImportGRFSound(SoundEntry *sound)
7001 {
7002  const GRFFile *file;
7003  uint32 grfid = FioReadDword();
7004  SoundID sound_id = FioReadWord();
7005 
7006  file = GetFileByGRFID(grfid);
7007  if (file == NULL || file->sound_offset == 0) {
7008  grfmsg(1, "ImportGRFSound: Source file not available");
7009  return;
7010  }
7011 
7012  if (sound_id >= file->num_sounds) {
7013  grfmsg(1, "ImportGRFSound: Sound effect %d is invalid", sound_id);
7014  return;
7015  }
7016 
7017  grfmsg(2, "ImportGRFSound: Copying sound %d (%d) from file %X", sound_id, file->sound_offset + sound_id, grfid);
7018 
7019  *sound = *GetSound(file->sound_offset + sound_id);
7020 
7021  /* Reset volume and priority, which TTDPatch doesn't copy */
7022  sound->volume = 128;
7023  sound->priority = 0;
7024 }
7025 
7031 static void LoadGRFSound(size_t offs, SoundEntry *sound)
7032 {
7033  /* Set default volume and priority */
7034  sound->volume = 0x80;
7035  sound->priority = 0;
7036 
7037  if (offs != SIZE_MAX) {
7038  /* Sound is present in the NewGRF. */
7039  sound->file_slot = _cur.file_index;
7040  sound->file_offset = offs;
7041  sound->grf_container_ver = _cur.grf_container_ver;
7042  }
7043 }
7044 
7045 /* Action 0x11 */
7046 static void GRFSound(ByteReader *buf)
7047 {
7048  /* <11> <num>
7049  *
7050  * W num Number of sound files that follow */
7051 
7052  uint16 num = buf->ReadWord();
7053  if (num == 0) return;
7054 
7055  SoundEntry *sound;
7056  if (_cur.grffile->sound_offset == 0) {
7057  _cur.grffile->sound_offset = GetNumSounds();
7058  _cur.grffile->num_sounds = num;
7059  sound = AllocateSound(num);
7060  } else {
7061  sound = GetSound(_cur.grffile->sound_offset);
7062  }
7063 
7064  for (int i = 0; i < num; i++) {
7065  _cur.nfo_line++;
7066 
7067  /* Check whether the index is in range. This might happen if multiple action 11 are present.
7068  * While this is invalid, we do not check for this. But we should prevent it from causing bigger trouble */
7069  bool invalid = i >= _cur.grffile->num_sounds;
7070 
7071  size_t offs = FioGetPos();
7072 
7073  uint32 len = _cur.grf_container_ver >= 2 ? FioReadDword() : FioReadWord();
7074  byte type = FioReadByte();
7075 
7076  if (_cur.grf_container_ver >= 2 && type == 0xFD) {
7077  /* Reference to sprite section. */
7078  if (invalid) {
7079  grfmsg(1, "GRFSound: Sound index out of range (multiple Action 11?)");
7080  FioSkipBytes(len);
7081  } else if (len != 4) {
7082  grfmsg(1, "GRFSound: Invalid sprite section import");
7083  FioSkipBytes(len);
7084  } else {
7085  uint32 id = FioReadDword();
7086  if (_cur.stage == GLS_INIT) LoadGRFSound(GetGRFSpriteOffset(id), sound + i);
7087  }
7088  continue;
7089  }
7090 
7091  if (type != 0xFF) {
7092  grfmsg(1, "GRFSound: Unexpected RealSprite found, skipping");
7093  FioSkipBytes(7);
7094  SkipSpriteData(type, len - 8);
7095  continue;
7096  }
7097 
7098  if (invalid) {
7099  grfmsg(1, "GRFSound: Sound index out of range (multiple Action 11?)");
7100  FioSkipBytes(len);
7101  }
7102 
7103  byte action = FioReadByte();
7104  switch (action) {
7105  case 0xFF:
7106  /* Allocate sound only in init stage. */
7107  if (_cur.stage == GLS_INIT) {
7108  if (_cur.grf_container_ver >= 2) {
7109  grfmsg(1, "GRFSound: Inline sounds are not supported for container version >= 2");
7110  } else {
7111  LoadGRFSound(offs, sound + i);
7112  }
7113  }
7114  FioSkipBytes(len - 1); // already read <action>
7115  break;
7116 
7117  case 0xFE:
7118  if (_cur.stage == GLS_ACTIVATION) {
7119  /* XXX 'Action 0xFE' isn't really specified. It is only mentioned for
7120  * importing sounds, so this is probably all wrong... */
7121  if (FioReadByte() != 0) grfmsg(1, "GRFSound: Import type mismatch");
7122  ImportGRFSound(sound + i);
7123  } else {
7124  FioSkipBytes(len - 1); // already read <action>
7125  }
7126  break;
7127 
7128  default:
7129  grfmsg(1, "GRFSound: Unexpected Action %x found, skipping", action);
7130  FioSkipBytes(len - 1); // already read <action>
7131  break;
7132  }
7133  }
7134 }
7135 
7136 /* Action 0x11 (SKIP) */
7137 static void SkipAct11(ByteReader *buf)
7138 {
7139  /* <11> <num>
7140  *
7141  * W num Number of sound files that follow */
7142 
7143  _cur.skip_sprites = buf->ReadWord();
7144 
7145  grfmsg(3, "SkipAct11: Skipping %d sprites", _cur.skip_sprites);
7146 }
7147 
7149 static void LoadFontGlyph(ByteReader *buf)
7150 {
7151  /* <12> <num_def> <font_size> <num_char> <base_char>
7152  *
7153  * B num_def Number of definitions
7154  * B font_size Size of font (0 = normal, 1 = small, 2 = large, 3 = mono)
7155  * B num_char Number of consecutive glyphs
7156  * W base_char First character index */
7157 
7158  uint8 num_def = buf->ReadByte();
7159 
7160  for (uint i = 0; i < num_def; i++) {
7161  FontSize size = (FontSize)buf->ReadByte();
7162  uint8 num_char = buf->ReadByte();
7163  uint16 base_char = buf->ReadWord();
7164 
7165  if (size >= FS_END) {
7166  grfmsg(1, "LoadFontGlyph: Size %u is not supported, ignoring", size);
7167  }
7168 
7169  grfmsg(7, "LoadFontGlyph: Loading %u glyph(s) at 0x%04X for size %u", num_char, base_char, size);
7170 
7171  for (uint c = 0; c < num_char; c++) {
7172  if (size < FS_END) SetUnicodeGlyph(size, base_char + c, _cur.spriteid);
7173  _cur.nfo_line++;
7174  LoadNextSprite(_cur.spriteid++, _cur.file_index, _cur.nfo_line, _cur.grf_container_ver);
7175  }
7176  }
7177 }
7178 
7180 static void SkipAct12(ByteReader *buf)
7181 {
7182  /* <12> <num_def> <font_size> <num_char> <base_char>
7183  *
7184  * B num_def Number of definitions
7185  * B font_size Size of font (0 = normal, 1 = small, 2 = large)
7186  * B num_char Number of consecutive glyphs
7187  * W base_char First character index */
7188 
7189  uint8 num_def = buf->ReadByte();
7190 
7191  for (uint i = 0; i < num_def; i++) {
7192  /* Ignore 'size' byte */
7193  buf->ReadByte();
7194 
7195  /* Sum up number of characters */
7196  _cur.skip_sprites += buf->ReadByte();
7197 
7198  /* Ignore 'base_char' word */
7199  buf->ReadWord();
7200  }
7201 
7202  grfmsg(3, "SkipAct12: Skipping %d sprites", _cur.skip_sprites);
7203 }
7204 
7207 {
7208  /* <13> <grfid> <num-ent> <offset> <text...>
7209  *
7210  * 4*B grfid The GRFID of the file whose texts are to be translated
7211  * B num-ent Number of strings
7212  * W offset First text ID
7213  * S text... Zero-terminated strings */
7214 
7215  uint32 grfid = buf->ReadDWord();
7216  const GRFConfig *c = GetGRFConfig(grfid);
7217  if (c == NULL || (c->status != GCS_INITIALISED && c->status != GCS_ACTIVATED)) {
7218  grfmsg(7, "TranslateGRFStrings: GRFID 0x%08x unknown, skipping action 13", BSWAP32(grfid));
7219  return;
7220  }
7221 
7222  if (c->status == GCS_INITIALISED) {
7223  /* If the file is not active but will be activated later, give an error
7224  * and disable this file. */
7225  GRFError *error = DisableGrf(STR_NEWGRF_ERROR_LOAD_AFTER);
7226 
7227  char tmp[256];
7228  GetString(tmp, STR_NEWGRF_ERROR_AFTER_TRANSLATED_FILE, lastof(tmp));
7229  error->data = stredup(tmp);
7230 
7231  return;
7232  }
7233 
7234  /* Since no language id is supplied for with version 7 and lower NewGRFs, this string has
7235  * to be added as a generic string, thus the language id of 0x7F. For this to work
7236  * new_scheme has to be true as well, which will also be implicitly the case for version 8
7237  * and higher. A language id of 0x7F will be overridden by a non-generic id, so this will
7238  * not change anything if a string has been provided specifically for this language. */
7239  byte language = _cur.grffile->grf_version >= 8 ? buf->ReadByte() : 0x7F;
7240  byte num_strings = buf->ReadByte();
7241  uint16 first_id = buf->ReadWord();
7242 
7243  if (!((first_id >= 0xD000 && first_id + num_strings <= 0xD400) || (first_id >= 0xD800 && first_id + num_strings <= 0xE000))) {
7244  grfmsg(7, "TranslateGRFStrings: Attempting to set out-of-range string IDs in action 13 (first: 0x%4X, number: 0x%2X)", first_id, num_strings);
7245  return;
7246  }
7247 
7248  for (uint i = 0; i < num_strings && buf->HasData(); i++) {
7249  const char *string = buf->ReadString();
7250 
7251  if (StrEmpty(string)) {
7252  grfmsg(7, "TranslateGRFString: Ignoring empty string.");
7253  continue;
7254  }
7255 
7256  AddGRFString(grfid, first_id + i, language, true, true, string, STR_UNDEFINED);
7257  }
7258 }
7259 
7261 static bool ChangeGRFName(byte langid, const char *str)
7262 {
7263  AddGRFTextToList(&_cur.grfconfig->name->text, langid, _cur.grfconfig->ident.grfid, false, str);
7264  return true;
7265 }
7266 
7268 static bool ChangeGRFDescription(byte langid, const char *str)
7269 {
7270  AddGRFTextToList(&_cur.grfconfig->info->text, langid, _cur.grfconfig->ident.grfid, true, str);
7271  return true;
7272 }
7273 
7275 static bool ChangeGRFURL(byte langid, const char *str)
7276 {
7277  AddGRFTextToList(&_cur.grfconfig->url->text, langid, _cur.grfconfig->ident.grfid, false, str);
7278  return true;
7279 }
7280 
7282 static bool ChangeGRFNumUsedParams(size_t len, ByteReader *buf)
7283 {
7284  if (len != 1) {
7285  grfmsg(2, "StaticGRFInfo: expected only 1 byte for 'INFO'->'NPAR' but got " PRINTF_SIZE ", ignoring this field", len);
7286  buf->Skip(len);
7287  } else {
7288  _cur.grfconfig->num_valid_params = min(buf->ReadByte(), lengthof(_cur.grfconfig->param));
7289  }
7290  return true;
7291 }
7292 
7294 static bool ChangeGRFPalette(size_t len, ByteReader *buf)
7295 {
7296  if (len != 1) {
7297  grfmsg(2, "StaticGRFInfo: expected only 1 byte for 'INFO'->'PALS' but got " PRINTF_SIZE ", ignoring this field", len);
7298  buf->Skip(len);
7299  } else {
7300  char data = buf->ReadByte();
7301  GRFPalette pal = GRFP_GRF_UNSET;
7302  switch (data) {
7303  case '*':
7304  case 'A': pal = GRFP_GRF_ANY; break;
7305  case 'W': pal = GRFP_GRF_WINDOWS; break;
7306  case 'D': pal = GRFP_GRF_DOS; break;
7307  default:
7308  grfmsg(2, "StaticGRFInfo: unexpected value '%02x' for 'INFO'->'PALS', ignoring this field", data);
7309  break;
7310  }
7311  if (pal != GRFP_GRF_UNSET) {
7312  _cur.grfconfig->palette &= ~GRFP_GRF_MASK;
7313  _cur.grfconfig->palette |= pal;
7314  }
7315  }
7316  return true;
7317 }
7318 
7320 static bool ChangeGRFBlitter(size_t len, ByteReader *buf)
7321 {
7322  if (len != 1) {
7323  grfmsg(2, "StaticGRFInfo: expected only 1 byte for 'INFO'->'BLTR' but got " PRINTF_SIZE ", ignoring this field", len);
7324  buf->Skip(len);
7325  } else {
7326  char data = buf->ReadByte();
7327  GRFPalette pal = GRFP_BLT_UNSET;
7328  switch (data) {
7329  case '8': pal = GRFP_BLT_UNSET; break;
7330  case '3': pal = GRFP_BLT_32BPP; break;
7331  default:
7332  grfmsg(2, "StaticGRFInfo: unexpected value '%02x' for 'INFO'->'BLTR', ignoring this field", data);
7333  return true;
7334  }
7335  _cur.grfconfig->palette &= ~GRFP_BLT_MASK;
7336  _cur.grfconfig->palette |= pal;
7337  }
7338  return true;
7339 }
7340 
7342 static bool ChangeGRFVersion(size_t len, ByteReader *buf)
7343 {
7344  if (len != 4) {
7345  grfmsg(2, "StaticGRFInfo: expected 4 bytes for 'INFO'->'VRSN' but got " PRINTF_SIZE ", ignoring this field", len);
7346  buf->Skip(len);
7347  } else {
7348  /* Set min_loadable_version as well (default to minimal compatibility) */
7349  _cur.grfconfig->version = _cur.grfconfig->min_loadable_version = buf->ReadDWord();
7350  }
7351  return true;
7352 }
7353 
7355 static bool ChangeGRFMinVersion(size_t len, ByteReader *buf)
7356 {
7357  if (len != 4) {
7358  grfmsg(2, "StaticGRFInfo: expected 4 bytes for 'INFO'->'MINV' but got " PRINTF_SIZE ", ignoring this field", len);
7359  buf->Skip(len);
7360  } else {
7361  _cur.grfconfig->min_loadable_version = buf->ReadDWord();
7362  if (_cur.grfconfig->version == 0) {
7363  grfmsg(2, "StaticGRFInfo: 'MINV' defined before 'VRSN' or 'VRSN' set to 0, ignoring this field");
7364  _cur.grfconfig->min_loadable_version = 0;
7365  }
7366  if (_cur.grfconfig->version < _cur.grfconfig->min_loadable_version) {
7367  grfmsg(2, "StaticGRFInfo: 'MINV' defined as %d, limiting it to 'VRSN'", _cur.grfconfig->min_loadable_version);
7369  }
7370  }
7371  return true;
7372 }
7373 
7375 
7377 static bool ChangeGRFParamName(byte langid, const char *str)
7378 {
7379  AddGRFTextToList(&_cur_parameter->name, langid, _cur.grfconfig->ident.grfid, false, str);
7380  return true;
7381 }
7382 
7384 static bool ChangeGRFParamDescription(byte langid, const char *str)
7385 {
7386  AddGRFTextToList(&_cur_parameter->desc, langid, _cur.grfconfig->ident.grfid, true, str);
7387  return true;
7388 }
7389 
7391 static bool ChangeGRFParamType(size_t len, ByteReader *buf)
7392 {
7393  if (len != 1) {
7394  grfmsg(2, "StaticGRFInfo: expected 1 byte for 'INFO'->'PARA'->'TYPE' but got " PRINTF_SIZE ", ignoring this field", len);
7395  buf->Skip(len);
7396  } else {
7397  GRFParameterType type = (GRFParameterType)buf->ReadByte();
7398  if (type < PTYPE_END) {
7399  _cur_parameter->type = type;
7400  } else {
7401  grfmsg(3, "StaticGRFInfo: unknown parameter type %d, ignoring this field", type);
7402  }
7403  }
7404  return true;
7405 }
7406 
7408 static bool ChangeGRFParamLimits(size_t len, ByteReader *buf)
7409 {
7410  if (_cur_parameter->type != PTYPE_UINT_ENUM) {
7411  grfmsg(2, "StaticGRFInfo: 'INFO'->'PARA'->'LIMI' is only valid for parameters with type uint/enum, ignoring this field");
7412  buf->Skip(len);
7413  } else if (len != 8) {
7414  grfmsg(2, "StaticGRFInfo: expected 8 bytes for 'INFO'->'PARA'->'LIMI' but got " PRINTF_SIZE ", ignoring this field", len);
7415  buf->Skip(len);
7416  } else {
7417  _cur_parameter->min_value = buf->ReadDWord();
7418  _cur_parameter->max_value = buf->ReadDWord();
7419  }
7420  return true;
7421 }
7422 
7424 static bool ChangeGRFParamMask(size_t len, ByteReader *buf)
7425 {
7426  if (len < 1 || len > 3) {
7427  grfmsg(2, "StaticGRFInfo: expected 1 to 3 bytes for 'INFO'->'PARA'->'MASK' but got " PRINTF_SIZE ", ignoring this field", len);
7428  buf->Skip(len);
7429  } else {
7430  byte param_nr = buf->ReadByte();
7431  if (param_nr >= lengthof(_cur.grfconfig->param)) {
7432  grfmsg(2, "StaticGRFInfo: invalid parameter number in 'INFO'->'PARA'->'MASK', param %d, ignoring this field", param_nr);
7433  buf->Skip(len - 1);
7434  } else {
7435  _cur_parameter->param_nr = param_nr;
7436  if (len >= 2) _cur_parameter->first_bit = min(buf->ReadByte(), 31);
7437  if (len >= 3) _cur_parameter->num_bit = min(buf->ReadByte(), 32 - _cur_parameter->first_bit);
7438  }
7439  }
7440 
7441  return true;
7442 }
7443 
7445 static bool ChangeGRFParamDefault(size_t len, ByteReader *buf)
7446 {
7447  if (len != 4) {
7448  grfmsg(2, "StaticGRFInfo: expected 4 bytes for 'INFO'->'PARA'->'DEFA' but got " PRINTF_SIZE ", ignoring this field", len);
7449  buf->Skip(len);
7450  } else {
7451  _cur_parameter->def_value = buf->ReadDWord();
7452  }
7453  _cur.grfconfig->has_param_defaults = true;
7454  return true;
7455 }
7456 
7457 typedef bool (*DataHandler)(size_t, ByteReader *);
7458 typedef bool (*TextHandler)(byte, const char *str);
7459 typedef bool (*BranchHandler)(ByteReader *);
7460 
7471  id(0),
7472  type(0)
7473  {}
7474 
7480  AllowedSubtags(uint32 id, DataHandler handler) :
7481  id(id),
7482  type('B')
7483  {
7484  this->handler.data = handler;
7485  }
7486 
7492  AllowedSubtags(uint32 id, TextHandler handler) :
7493  id(id),
7494  type('T')
7495  {
7496  this->handler.text = handler;
7497  }
7498 
7504  AllowedSubtags(uint32 id, BranchHandler handler) :
7505  id(id),
7506  type('C')
7507  {
7508  this->handler.call_handler = true;
7509  this->handler.u.branch = handler;
7510  }
7511 
7518  id(id),
7519  type('C')
7520  {
7521  this->handler.call_handler = false;
7522  this->handler.u.subtags = subtags;
7523  }
7524 
7525  uint32 id;
7526  byte type;
7527  union {
7530  struct {
7531  union {
7534  } u;
7536  };
7537  } handler;
7538 };
7539 
7540 static bool SkipUnknownInfo(ByteReader *buf, byte type);
7541 static bool HandleNodes(ByteReader *buf, AllowedSubtags *tags);
7542 
7550 {
7551  byte type = buf->ReadByte();
7552  while (type != 0) {
7553  uint32 id = buf->ReadDWord();
7554  if (type != 'T' || id > _cur_parameter->max_value) {
7555  grfmsg(2, "StaticGRFInfo: all child nodes of 'INFO'->'PARA'->param_num->'VALU' should have type 't' and the value/bit number as id");
7556  if (!SkipUnknownInfo(buf, type)) return false;
7557  type = buf->ReadByte();
7558  continue;
7559  }
7560 
7561  byte langid = buf->ReadByte();
7562  const char *name_string = buf->ReadString();
7563 
7564  SmallPair<uint32, GRFText *> *val_name = _cur_parameter->value_names.Find(id);
7565  if (val_name != _cur_parameter->value_names.End()) {
7566  AddGRFTextToList(&val_name->second, langid, _cur.grfconfig->ident.grfid, false, name_string);
7567  } else {
7568  GRFText *list = NULL;
7569  AddGRFTextToList(&list, langid, _cur.grfconfig->ident.grfid, false, name_string);
7570  _cur_parameter->value_names.Insert(id, list);
7571  }
7572 
7573  type = buf->ReadByte();
7574  }
7575  return true;
7576 }
7577 
7587  AllowedSubtags()
7588 };
7589 
7597 {
7598  byte type = buf->ReadByte();
7599  while (type != 0) {
7600  uint32 id = buf->ReadDWord();
7601  if (type != 'C' || id >= _cur.grfconfig->num_valid_params) {
7602  grfmsg(2, "StaticGRFInfo: all child nodes of 'INFO'->'PARA' should have type 'C' and their parameter number as id");
7603  if (!SkipUnknownInfo(buf, type)) return false;
7604  type = buf->ReadByte();
7605  continue;
7606  }
7607 
7608  if (id >= _cur.grfconfig->param_info.Length()) {
7609  uint num_to_add = id - _cur.grfconfig->param_info.Length() + 1;
7610  GRFParameterInfo **newdata = _cur.grfconfig->param_info.Append(num_to_add);
7611  MemSetT<GRFParameterInfo *>(newdata, 0, num_to_add);
7612  }
7613  if (_cur.grfconfig->param_info[id] == NULL) {
7614  _cur.grfconfig->param_info[id] = new GRFParameterInfo(id);
7615  }
7616  _cur_parameter = _cur.grfconfig->param_info[id];
7617  /* Read all parameter-data and process each node. */
7618  if (!HandleNodes(buf, _tags_parameters)) return false;
7619  type = buf->ReadByte();
7620  }
7621  return true;
7622 }
7623 
7626  AllowedSubtags('NAME', ChangeGRFName),
7628  AllowedSubtags('URL_', ChangeGRFURL),
7635  AllowedSubtags()
7636 };
7637 
7640  AllowedSubtags('INFO', _tags_info),
7641  AllowedSubtags()
7642 };
7643 
7644 
7651 static bool SkipUnknownInfo(ByteReader *buf, byte type)
7652 {
7653  /* type and id are already read */
7654  switch (type) {
7655  case 'C': {
7656  byte new_type = buf->ReadByte();
7657  while (new_type != 0) {
7658  buf->ReadDWord(); // skip the id
7659  if (!SkipUnknownInfo(buf, new_type)) return false;
7660  new_type = buf->ReadByte();
7661  }
7662  break;
7663  }
7664 
7665  case 'T':
7666  buf->ReadByte(); // lang
7667  buf->ReadString(); // actual text
7668  break;
7669 
7670  case 'B': {
7671  uint16 size = buf->ReadWord();
7672  buf->Skip(size);
7673  break;
7674  }
7675 
7676  default:
7677  return false;
7678  }
7679 
7680  return true;
7681 }
7682 
7691 static bool HandleNode(byte type, uint32 id, ByteReader *buf, AllowedSubtags subtags[])
7692 {
7693  uint i = 0;
7694  AllowedSubtags *tag;
7695  while ((tag = &subtags[i++])->type != 0) {
7696  if (tag->id != BSWAP32(id) || tag->type != type) continue;
7697  switch (type) {
7698  default: NOT_REACHED();
7699 
7700  case 'T': {
7701  byte langid = buf->ReadByte();
7702  return tag->handler.text(langid, buf->ReadString());
7703  }
7704 
7705  case 'B': {
7706  size_t len = buf->ReadWord();
7707  if (buf->Remaining() < len) return false;
7708  return tag->handler.data(len, buf);
7709  }
7710 
7711  case 'C': {
7712  if (tag->handler.call_handler) {
7713  return tag->handler.u.branch(buf);
7714  }
7715  return HandleNodes(buf, tag->handler.u.subtags);
7716  }
7717  }
7718  }
7719  grfmsg(2, "StaticGRFInfo: unknown type/id combination found, type=%c, id=%x", type, id);
7720  return SkipUnknownInfo(buf, type);
7721 }
7722 
7729 static bool HandleNodes(ByteReader *buf, AllowedSubtags subtags[])
7730 {
7731  byte type = buf->ReadByte();
7732  while (type != 0) {
7733  uint32 id = buf->ReadDWord();
7734  if (!HandleNode(type, id, buf, subtags)) return false;
7735  type = buf->ReadByte();
7736  }
7737  return true;
7738 }
7739 
7744 static void StaticGRFInfo(ByteReader *buf)
7745 {
7746  /* <14> <type> <id> <text/data...> */
7747  HandleNodes(buf, _tags_root);
7748 }
7749 
7755 static void GRFUnsafe(ByteReader *buf)
7756 {
7757  SetBit(_cur.grfconfig->flags, GCF_UNSAFE);
7758 
7759  /* Skip remainder of GRF */
7760  _cur.skip_sprites = -1;
7761 }
7762 
7763 
7766 {
7767  _ttdpatch_flags[0] = ((_settings_game.station.never_expire_airports ? 1 : 0) << 0x0C) // keepsmallairport
7768  | (1 << 0x0D) // newairports
7769  | (1 << 0x0E) // largestations
7770  | ((_settings_game.construction.max_bridge_length > 16 ? 1 : 0) << 0x0F) // longbridges
7771  | (0 << 0x10) // loadtime
7772  | (1 << 0x12) // presignals
7773  | (1 << 0x13) // extpresignals
7774  | ((_settings_game.vehicle.never_expire_vehicles ? 1 : 0) << 0x16) // enginespersist
7775  | (1 << 0x1B) // multihead
7776  | (1 << 0x1D) // lowmemory
7777  | (1 << 0x1E); // generalfixes
7778 
7779  _ttdpatch_flags[1] = ((_settings_game.economy.station_noise_level ? 1 : 0) << 0x07) // moreairports - based on units of noise
7780  | (1 << 0x08) // mammothtrains
7781  | (1 << 0x09) // trainrefit
7782  | (0 << 0x0B) // subsidiaries
7783  | ((_settings_game.order.gradual_loading ? 1 : 0) << 0x0C) // gradualloading
7784  | (1 << 0x12) // unifiedmaglevmode - set bit 0 mode. Not revelant to OTTD
7785  | (1 << 0x13) // unifiedmaglevmode - set bit 1 mode
7786  | (1 << 0x14) // bridgespeedlimits
7787  | (1 << 0x16) // eternalgame
7788  | (1 << 0x17) // newtrains
7789  | (1 << 0x18) // newrvs
7790  | (1 << 0x19) // newships
7791  | (1 << 0x1A) // newplanes
7792  | ((_settings_game.construction.train_signal_side == 1 ? 1 : 0) << 0x1B) // signalsontrafficside
7793  | ((_settings_game.vehicle.disable_elrails ? 0 : 1) << 0x1C); // electrifiedrailway
7794 
7795  _ttdpatch_flags[2] = (1 << 0x01) // loadallgraphics - obsolote
7796  | (1 << 0x03) // semaphores
7797  | (1 << 0x0A) // newobjects
7798  | (0 << 0x0B) // enhancedgui
7799  | (0 << 0x0C) // newagerating
7800  | ((_settings_game.construction.build_on_slopes ? 1 : 0) << 0x0D) // buildonslopes
7801  | (1 << 0x0E) // fullloadany
7802  | (1 << 0x0F) // planespeed
7803  | (0 << 0x10) // moreindustriesperclimate - obsolete
7804  | (0 << 0x11) // moretoylandfeatures
7805  | (1 << 0x12) // newstations
7806  | (1 << 0x13) // tracktypecostdiff
7807  | (1 << 0x14) // manualconvert
7808  | ((_settings_game.construction.build_on_slopes ? 1 : 0) << 0x15) // buildoncoasts
7809  | (1 << 0x16) // canals
7810  | (1 << 0x17) // newstartyear
7811  | ((_settings_game.vehicle.freight_trains > 1 ? 1 : 0) << 0x18) // freighttrains
7812  | (1 << 0x19) // newhouses
7813  | (1 << 0x1A) // newbridges
7814  | (1 << 0x1B) // newtownnames
7815  | (1 << 0x1C) // moreanimation
7816  | ((_settings_game.vehicle.wagon_speed_limits ? 1 : 0) << 0x1D) // wagonspeedlimits
7817  | (1 << 0x1E) // newshistory
7818  | (0 << 0x1F); // custombridgeheads
7819 
7820  _ttdpatch_flags[3] = (0 << 0x00) // newcargodistribution
7821  | (1 << 0x01) // windowsnap
7822  | ((_settings_game.economy.allow_town_roads || _generating_world ? 0 : 1) << 0x02) // townbuildnoroad
7823  | (1 << 0x03) // pathbasedsignalling
7824  | (0 << 0x04) // aichoosechance
7825  | (1 << 0x05) // resolutionwidth
7826  | (1 << 0x06) // resolutionheight
7827  | (1 << 0x07) // newindustries
7828  | ((_settings_game.order.improved_load ? 1 : 0) << 0x08) // fifoloading
7829  | (0 << 0x09) // townroadbranchprob
7830  | (0 << 0x0A) // tempsnowline
7831  | (1 << 0x0B) // newcargo
7832  | (1 << 0x0C) // enhancemultiplayer
7833  | (1 << 0x0D) // onewayroads
7834  | (1 << 0x0E) // irregularstations
7835  | (1 << 0x0F) // statistics
7836  | (1 << 0x10) // newsounds
7837  | (1 << 0x11) // autoreplace
7838  | (1 << 0x12) // autoslope
7839  | (0 << 0x13) // followvehicle
7840  | (1 << 0x14) // trams
7841  | (0 << 0x15) // enhancetunnels
7842  | (1 << 0x16) // shortrvs
7843  | (1 << 0x17) // articulatedrvs
7844  | ((_settings_game.vehicle.dynamic_engines ? 1 : 0) << 0x18) // dynamic engines
7845  | (1 << 0x1E) // variablerunningcosts
7846  | (1 << 0x1F); // any switch is on
7847 }
7848 
7850 static void ResetCustomStations()
7851 {
7852  const GRFFile * const *end = _grf_files.End();
7853  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
7854  StationSpec **&stations = (*file)->stations;
7855  if (stations == NULL) continue;
7856  for (uint i = 0; i < NUM_STATIONS_PER_GRF; i++) {
7857  if (stations[i] == NULL) continue;
7858  StationSpec *statspec = stations[i];
7859 
7860  delete[] statspec->renderdata;
7861 
7862  /* Release platforms and layouts */
7863  if (!statspec->copied_layouts) {
7864  for (uint l = 0; l < statspec->lengths; l++) {
7865  for (uint p = 0; p < statspec->platforms[l]; p++) {
7866  free(statspec->layouts[l][p]);
7867  }
7868  free(statspec->layouts[l]);
7869  }
7870  free(statspec->layouts);
7871  free(statspec->platforms);
7872  }
7873 
7874  /* Release this station */
7875  free(statspec);
7876  }
7877 
7878  /* Free and reset the station data */
7879  free(stations);
7880  stations = NULL;
7881  }
7882 }
7883 
7885 static void ResetCustomHouses()
7886 {
7887  const GRFFile * const *end = _grf_files.End();
7888  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
7889  HouseSpec **&housespec = (*file)->housespec;
7890  if (housespec == NULL) continue;
7891  for (uint i = 0; i < NUM_HOUSES_PER_GRF; i++) {
7892  free(housespec[i]);
7893  }
7894 
7895  free(housespec);
7896  housespec = NULL;
7897  }
7898 }
7899 
7901 static void ResetCustomAirports()
7902 {
7903  const GRFFile * const *end = _grf_files.End();
7904  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
7905  AirportSpec **aslist = (*file)->airportspec;
7906  if (aslist != NULL) {
7907  for (uint i = 0; i < NUM_AIRPORTS_PER_GRF; i++) {
7908  AirportSpec *as = aslist[i];
7909 
7910  if (as != NULL) {
7911  /* We need to remove the tiles layouts */
7912  for (int j = 0; j < as->num_table; j++) {
7913  /* remove the individual layouts */
7914  free(as->table[j]);
7915  }
7916  free(as->table);
7917  free(as->depot_table);
7918 
7919  free(as);
7920  }
7921  }
7922  free(aslist);
7923  (*file)->airportspec = NULL;
7924  }
7925 
7926  AirportTileSpec **&airporttilespec = (*file)->airtspec;
7927  if (airporttilespec != NULL) {
7928  for (uint i = 0; i < NUM_AIRPORTTILES_PER_GRF; i++) {
7929  free(airporttilespec[i]);
7930  }
7931  free(airporttilespec);
7932  airporttilespec = NULL;
7933  }
7934  }
7935 }
7936 
7939 {
7940  const GRFFile * const *end = _grf_files.End();
7941  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
7942  IndustrySpec **&industryspec = (*file)->industryspec;
7943  IndustryTileSpec **&indtspec = (*file)->indtspec;
7944 
7945  /* We are verifiying both tiles and industries specs loaded from the grf file
7946  * First, let's deal with industryspec */
7947  if (industryspec != NULL) {
7948  for (uint i = 0; i < NUM_INDUSTRYTYPES_PER_GRF; i++) {
7949  IndustrySpec *ind = industryspec[i];
7950  if (ind == NULL) continue;
7951 
7952  /* We need to remove the sounds array */
7953  if (HasBit(ind->cleanup_flag, CLEAN_RANDOMSOUNDS)) {
7954  free(ind->random_sounds);
7955  }
7956 
7957  /* We need to remove the tiles layouts */
7959 
7960  free(ind);
7961  }
7962 
7963  free(industryspec);
7964  industryspec = NULL;
7965  }
7966 
7967  if (indtspec == NULL) continue;
7968  for (uint i = 0; i < NUM_INDUSTRYTILES_PER_GRF; i++) {
7969  free(indtspec[i]);
7970  }
7971 
7972  free(indtspec);
7973  indtspec = NULL;
7974  }
7975 }
7976 
7978 static void ResetCustomObjects()
7979 {
7980  const GRFFile * const *end = _grf_files.End();
7981  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
7982  ObjectSpec **&objectspec = (*file)->objectspec;
7983  if (objectspec == NULL) continue;
7984  for (uint i = 0; i < NUM_OBJECTS_PER_GRF; i++) {
7985  free(objectspec[i]);
7986  }
7987 
7988  free(objectspec);
7989  objectspec = NULL;
7990  }
7991 }
7992 
7994 static void ResetNewGRF()
7995 {
7996  const GRFFile * const *end = _grf_files.End();
7997  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
7998  delete *file;
7999  }
8000 
8001  _grf_files.Clear();
8002  _cur.grffile = NULL;
8003 }
8004 
8006 static void ResetNewGRFErrors()
8007 {
8008  for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
8009  if (!HasBit(c->flags, GCF_COPY) && c->error != NULL) {
8010  delete c->error;
8011  c->error = NULL;
8012  }
8013  }
8014 }
8015 
8021 {
8022  CleanUpStrings();
8023  CleanUpGRFTownNames();
8024 
8025  /* Copy/reset original engine info data */
8026  SetupEngines();
8027 
8028  /* Copy/reset original bridge info data */
8029  ResetBridges();
8030 
8031  /* Reset rail type information */
8032  ResetRailTypes();
8033 
8034  /* Allocate temporary refit/cargo class data */
8035  _gted = CallocT<GRFTempEngineData>(Engine::GetPoolSize());
8036 
8037  /* Fill rail type label temporary data for default trains */
8038  Engine *e;
8039  FOR_ALL_ENGINES_OF_TYPE(e, VEH_TRAIN) {
8040  _gted[e->index].railtypelabel = GetRailTypeInfo(e->u.rail.railtype)->label;
8041  }
8042 
8043  /* Reset GRM reservations */
8044  memset(&_grm_engines, 0, sizeof(_grm_engines));
8045  memset(&_grm_cargoes, 0, sizeof(_grm_cargoes));
8046 
8047  /* Reset generic feature callback lists */
8049 
8050  /* Reset price base data */
8052 
8053  /* Reset the curencies array */
8054  ResetCurrencies();
8055 
8056  /* Reset the house array */
8058  ResetHouses();
8059 
8060  /* Reset the industries structures*/
8062  ResetIndustries();
8063 
8064  /* Reset the objects. */
8065  ObjectClass::Reset();
8067  ResetObjects();
8068 
8069  /* Reset station classes */
8070  StationClass::Reset();
8072 
8073  /* Reset airport-related structures */
8074  AirportClass::Reset();
8078 
8079  /* Reset canal sprite groups and flags */
8080  memset(_water_feature, 0, sizeof(_water_feature));
8081 
8082  /* Reset the snowline table. */
8083  ClearSnowLine();
8084 
8085  /* Reset NewGRF files */
8086  ResetNewGRF();
8087 
8088  /* Reset NewGRF errors. */
8090 
8091  /* Set up the default cargo types */
8093 
8094  /* Reset misc GRF features and train list display variables */
8095  _misc_grf_features = 0;
8096 
8097  _loaded_newgrf_features.has_2CC = false;
8098  _loaded_newgrf_features.used_liveries = 1 << LS_DEFAULT;
8099  _loaded_newgrf_features.has_newhouses = false;
8100  _loaded_newgrf_features.has_newindustries = false;
8101  _loaded_newgrf_features.shore = SHORE_REPLACE_NONE;
8102 
8103  /* Clear all GRF overrides */
8104  _grf_id_overrides.clear();
8105 
8106  InitializeSoundPool();
8107  _spritegroup_pool.CleanPool();
8108 }
8109 
8114 {
8115  /* Reset override managers */
8116  _engine_mngr.ResetToDefaultMapping();
8117  _house_mngr.ResetMapping();
8118  _industry_mngr.ResetMapping();
8119  _industile_mngr.ResetMapping();
8120  _airport_mngr.ResetMapping();
8121  _airporttile_mngr.ResetMapping();
8122 }
8123 
8129 {
8130  memset(_cur.grffile->cargo_map, 0xFF, sizeof(_cur.grffile->cargo_map));
8131 
8132  for (CargoID c = 0; c < NUM_CARGO; c++) {
8133  const CargoSpec *cs = CargoSpec::Get(c);
8134  if (!cs->IsValid()) continue;
8135 
8136  if (_cur.grffile->cargo_list.Length() == 0) {
8137  /* Default translation table, so just a straight mapping to bitnum */
8138  _cur.grffile->cargo_map[c] = cs->bitnum;
8139  } else {
8140  /* Check the translation table for this cargo's label */
8141  int index = _cur.grffile->cargo_list.FindIndex(cs->label);
8142  if (index >= 0) _cur.grffile->cargo_map[c] = index;
8143  }
8144  }
8145 }
8146 
8151 static void InitNewGRFFile(const GRFConfig *config)
8152 {
8153  GRFFile *newfile = GetFileByFilename(config->filename);
8154  if (newfile != NULL) {
8155  /* We already loaded it once. */
8156  _cur.grffile = newfile;
8157  return;
8158  }
8159 
8160  newfile = new GRFFile(config);
8161  *_grf_files.Append() = _cur.grffile = newfile;
8162 }
8163 
8169 {
8170  this->filename = stredup(config->filename);
8171  this->grfid = config->ident.grfid;
8172 
8173  /* Initialise local settings to defaults */
8174  this->traininfo_vehicle_pitch = 0;
8175  this->traininfo_vehicle_width = TRAININFO_DEFAULT_VEHICLE_WIDTH;
8176 
8177  /* Mark price_base_multipliers as 'not set' */
8178  for (Price i = PR_BEGIN; i < PR_END; i++) {
8179  this->price_base_multipliers[i] = INVALID_PRICE_MODIFIER;
8180  }
8181 
8182  /* Initialise rail type map with default rail types */
8183  memset(this->railtype_map, INVALID_RAILTYPE, sizeof(this->railtype_map));
8184  this->railtype_map[0] = RAILTYPE_RAIL;
8185  this->railtype_map[1] = RAILTYPE_ELECTRIC;
8186  this->railtype_map[2] = RAILTYPE_MONO;
8187  this->railtype_map[3] = RAILTYPE_MAGLEV;
8188 
8189  /* Copy the initial parameter list
8190  * 'Uninitialised' parameters are zeroed as that is their default value when dynamically creating them. */
8191  assert_compile(lengthof(this->param) == lengthof(config->param) && lengthof(this->param) == 0x80);
8192 
8193  assert(config->num_params <= lengthof(config->param));
8194  this->param_end = config->num_params;
8195  if (this->param_end > 0) {
8196  MemCpyT(this->param, config->param, this->param_end);
8197  }
8198 }
8199 
8200 GRFFile::~GRFFile()
8201 {
8202  free(this->filename);
8203  delete[] this->language_map;
8204 }
8205 
8206 
8212  'PASS', 'COAL', 'MAIL', 'LVST', 'GOOD', 'GRAI', 'WHEA', 'MAIZ', 'WOOD',
8213  'IORE', 'STEL', 'VALU', 'GOLD', 'DIAM', 'PAPR', 'FOOD', 'FRUT', 'CORE',
8214  'WATR', 'SUGR', 'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL',
8215  'PLST', 'FZDR',
8216  0 };
8217 
8218 static const CargoLabel _default_refitmasks_road[] = {
8219  0 };
8220 
8221 static const CargoLabel _default_refitmasks_ships[] = {
8222  'COAL', 'MAIL', 'LVST', 'GOOD', 'GRAI', 'WHEA', 'MAIZ', 'WOOD', 'IORE',
8223  'STEL', 'VALU', 'GOLD', 'DIAM', 'PAPR', 'FOOD', 'FRUT', 'CORE', 'WATR',
8224  'RUBR', 'SUGR', 'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL',
8225  'PLST', 'FZDR',
8226  0 };
8227 
8228 static const CargoLabel _default_refitmasks_aircraft[] = {
8229  'PASS', 'MAIL', 'GOOD', 'VALU', 'GOLD', 'DIAM', 'FOOD', 'FRUT', 'SUGR',
8230  'TOYS', 'BATT', 'SWET', 'TOFF', 'COLA', 'CTCD', 'BUBL', 'PLST', 'FZDR',
8231  0 };
8232 
8233 static const CargoLabel * const _default_refitmasks[] = {
8235  _default_refitmasks_road,
8236  _default_refitmasks_ships,
8237  _default_refitmasks_aircraft,
8238 };
8239 
8240 
8244 static void CalculateRefitMasks()
8245 {
8246  Engine *e;
8247 
8248  FOR_ALL_ENGINES(e) {
8249  EngineID engine = e->index;
8250  EngineInfo *ei = &e->info;
8251  bool only_defaultcargo;
8252 
8253  /* Did the newgrf specify any refitting? If not, use defaults. */
8254  if (_gted[engine].refittability != GRFTempEngineData::UNSET) {
8255  uint32 mask = 0;
8256  uint32 not_mask = 0;
8257  uint32 xor_mask = ei->refit_mask;
8258 
8259  /* If the original masks set by the grf are zero, the vehicle shall only carry the default cargo.
8260  * Note: After applying the translations, the vehicle may end up carrying no defined cargo. It becomes unavailable in that case. */
8261  only_defaultcargo = _gted[engine].refittability == GRFTempEngineData::EMPTY;
8262 
8263  if (_gted[engine].cargo_allowed != 0) {
8264  /* Build up the list of cargo types from the set cargo classes. */
8265  const CargoSpec *cs;
8266  FOR_ALL_CARGOSPECS(cs) {
8267  if (_gted[engine].cargo_allowed & cs->classes) SetBit(mask, cs->Index());
8268  if (_gted[engine].cargo_disallowed & cs->classes) SetBit(not_mask, cs->Index());
8269  }
8270  }
8271 
8272  ei->refit_mask = ((mask & ~not_mask) ^ xor_mask) & _cargo_mask;
8273 
8274  /* Apply explicit refit includes/excludes. */
8275  ei->refit_mask |= _gted[engine].ctt_include_mask;
8276  ei->refit_mask &= ~_gted[engine].ctt_exclude_mask;
8277  } else {
8278  uint32 xor_mask = 0;
8279 
8280  /* Don't apply default refit mask to wagons nor engines with no capacity */
8281  if (e->type != VEH_TRAIN || (e->u.rail.capacity != 0 && e->u.rail.railveh_type != RAILVEH_WAGON)) {
8282  const CargoLabel *cl = _default_refitmasks[e->type];
8283  for (uint i = 0;; i++) {
8284  if (cl[i] == 0) break;
8285 
8286  CargoID cargo = GetCargoIDByLabel(cl[i]);
8287  if (cargo == CT_INVALID) continue;
8288 
8289  SetBit(xor_mask, cargo);
8290  }
8291  }
8292 
8293  ei->refit_mask = xor_mask & _cargo_mask;
8294 
8295  /* If the mask is zero, the vehicle shall only carry the default cargo */
8296  only_defaultcargo = (ei->refit_mask == 0);
8297  }
8298 
8299  /* Clear invalid cargoslots (from default vehicles or pre-NewCargo GRFs) */
8300  if (!HasBit(_cargo_mask, ei->cargo_type)) ei->cargo_type = CT_INVALID;
8301 
8302  /* Ensure that the vehicle is either not refittable, or that the default cargo is one of the refittable cargoes.
8303  * Note: Vehicles refittable to no cargo are handle differently to vehicle refittable to a single cargo. The latter might have subtypes. */
8304  if (!only_defaultcargo && (e->type != VEH_SHIP || e->u.ship.old_refittable) && ei->cargo_type != CT_INVALID && !HasBit(ei->refit_mask, ei->cargo_type)) {
8305  ei->cargo_type = CT_INVALID;
8306  }
8307 
8308  /* Check if this engine's cargo type is valid. If not, set to the first refittable
8309  * cargo type. Finally disable the vehicle, if there is still no cargo. */
8310  if (ei->cargo_type == CT_INVALID && ei->refit_mask != 0) {
8311  /* Figure out which CTT to use for the default cargo, if it is 'first refittable'. */
8312  const uint8 *cargo_map_for_first_refittable = NULL;
8313  {
8314  const GRFFile *file = _gted[engine].defaultcargo_grf;
8315  if (file == NULL) file = e->GetGRF();
8316  if (file != NULL && file->grf_version >= 8 && file->cargo_list.Length() != 0) {
8317  cargo_map_for_first_refittable = file->cargo_map;
8318  }
8319  }
8320 
8321  if (cargo_map_for_first_refittable != NULL) {
8322  /* Use first refittable cargo from cargo translation table */
8323  byte best_local_slot = 0xFF;
8324  CargoID cargo_type;
8325  FOR_EACH_SET_CARGO_ID(cargo_type, ei->refit_mask) {
8326  byte local_slot = cargo_map_for_first_refittable[cargo_type];
8327  if (local_slot < best_local_slot) {
8328  best_local_slot = local_slot;
8329  ei->cargo_type = cargo_type;
8330  }
8331  }
8332  }
8333 
8334  if (ei->cargo_type == CT_INVALID) {
8335  /* Use first refittable cargo slot */
8336  ei->cargo_type = (CargoID)FindFirstBit(ei->refit_mask);
8337  }
8338  }
8339  if (ei->cargo_type == CT_INVALID) ei->climates = 0;
8340 
8341  /* Clear refit_mask for not refittable ships */
8342  if (e->type == VEH_SHIP && !e->u.ship.old_refittable) {
8343  ei->refit_mask = 0;
8344  }
8345  }
8346 }
8347 
8349 static void FinaliseCanals()
8350 {
8351  for (uint i = 0; i < CF_END; i++) {
8352  if (_water_feature[i].grffile != NULL) {
8355  }
8356  }
8357 }
8358 
8360 static void FinaliseEngineArray()
8361 {
8362  Engine *e;
8363 
8364  FOR_ALL_ENGINES(e) {
8365  if (e->GetGRF() == NULL) {
8366  const EngineIDMapping &eid = _engine_mngr[e->index];
8367  if (eid.grfid != INVALID_GRFID || eid.internal_id != eid.substitute_id) {
8368  e->info.string_id = STR_NEWGRF_INVALID_ENGINE;
8369  }
8370  }
8371 
8372  /* When the train does not set property 27 (misc flags), but it
8373  * is overridden by a NewGRF graphically we want to disable the
8374  * flipping possibility. */
8375  if (e->type == VEH_TRAIN && !_gted[e->index].prop27_set && e->GetGRF() != NULL && is_custom_sprite(e->u.rail.image_index)) {
8376  ClrBit(e->info.misc_flags, EF_RAIL_FLIPS);
8377  }
8378 
8379  /* Skip wagons, there livery is defined via the engine */
8380  if (e->type != VEH_TRAIN || e->u.rail.railveh_type != RAILVEH_WAGON) {
8382  SetBit(_loaded_newgrf_features.used_liveries, ls);
8383  /* Note: For ships and roadvehicles we assume that they cannot be refitted between passenger and freight */
8384 
8385  if (e->type == VEH_TRAIN) {
8386  SetBit(_loaded_newgrf_features.used_liveries, LS_FREIGHT_WAGON);
8387  switch (ls) {
8388  case LS_STEAM:
8389  case LS_DIESEL:
8390  case LS_ELECTRIC:
8391  case LS_MONORAIL:
8392  case LS_MAGLEV:
8393  SetBit(_loaded_newgrf_features.used_liveries, LS_PASSENGER_WAGON_STEAM + ls - LS_STEAM);
8394  break;
8395 
8396  case LS_DMU:
8397  case LS_EMU:
8398  SetBit(_loaded_newgrf_features.used_liveries, LS_PASSENGER_WAGON_DIESEL + ls - LS_DMU);
8399  break;
8400 
8401  default: NOT_REACHED();
8402  }
8403  }
8404  }
8405  }
8406 }
8407 
8409 static void FinaliseCargoArray()
8410 {
8411  for (CargoID c = 0; c < NUM_CARGO; c++) {
8412  CargoSpec *cs = CargoSpec::Get(c);
8413  if (!cs->IsValid()) {
8414  cs->name = cs->name_single = cs->units_volume = STR_NEWGRF_INVALID_CARGO;
8415  cs->quantifier = STR_NEWGRF_INVALID_CARGO_QUANTITY;
8416  cs->abbrev = STR_NEWGRF_INVALID_CARGO_ABBREV;
8417  }
8418  }
8419 }
8420 
8432 static bool IsHouseSpecValid(HouseSpec *hs, const HouseSpec *next1, const HouseSpec *next2, const HouseSpec *next3, const char *filename)
8433 {
8434  if (((hs->building_flags & BUILDING_HAS_2_TILES) != 0 &&
8435  (next1 == NULL || !next1->enabled || (next1->building_flags & BUILDING_HAS_1_TILE) != 0)) ||
8436  ((hs->building_flags & BUILDING_HAS_4_TILES) != 0 &&
8437  (next2 == NULL || !next2->enabled || (next2->building_flags & BUILDING_HAS_1_TILE) != 0 ||
8438  next3 == NULL || !next3->enabled || (next3->building_flags & BUILDING_HAS_1_TILE) != 0))) {
8439  hs->enabled = false;
8440  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);
8441  return false;
8442  }
8443 
8444  /* Some places sum population by only counting north tiles. Other places use all tiles causing desyncs.
8445  * As the newgrf specs define population to be zero for non-north tiles, we just disable the offending house.
8446  * If you want to allow non-zero populations somewhen, make sure to sum the population of all tiles in all places. */
8447  if (((hs->building_flags & BUILDING_HAS_2_TILES) != 0 && next1->population != 0) ||
8448  ((hs->building_flags & BUILDING_HAS_4_TILES) != 0 && (next2->population != 0 || next3->population != 0))) {
8449  hs->enabled = false;
8450  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);
8451  return false;
8452  }
8453 
8454  /* Substitute type is also used for override, and having an override with a different size causes crashes.
8455  * This check should only be done for NewGRF houses because grf_prop.subst_id is not set for original houses.*/
8456  if (filename != NULL && (hs->building_flags & BUILDING_HAS_1_TILE) != (HouseSpec::Get(hs->grf_prop.subst_id)->building_flags & BUILDING_HAS_1_TILE)) {
8457  hs->enabled = false;
8458  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);
8459  return false;
8460  }
8461 
8462  /* Make sure that additional parts of multitile houses are not available. */
8463  if ((hs->building_flags & BUILDING_HAS_1_TILE) == 0 && (hs->building_availability & HZ_ZONALL) != 0 && (hs->building_availability & HZ_CLIMALL) != 0) {
8464  hs->enabled = false;
8465  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);
8466  return false;
8467  }
8468 
8469  return true;
8470 }
8471 
8478 static void EnsureEarlyHouse(HouseZones bitmask)
8479 {
8480  Year min_year = MAX_YEAR;
8481 
8482  for (int i = 0; i < NUM_HOUSES; i++) {
8483  HouseSpec *hs = HouseSpec::Get(i);
8484  if (hs == NULL || !hs->enabled) continue;
8485  if ((hs->building_availability & bitmask) != bitmask) continue;
8486  if (hs->min_year < min_year) min_year = hs->min_year;
8487  }
8488 
8489  if (min_year == 0) return;
8490 
8491  for (int i = 0; i < NUM_HOUSES; i++) {
8492  HouseSpec *hs = HouseSpec::Get(i);
8493  if (hs == NULL || !hs->enabled) continue;
8494  if ((hs->building_availability & bitmask) != bitmask) continue;
8495  if (hs->min_year == min_year) hs->min_year = 0;
8496  }
8497 }
8498 
8505 static void FinaliseHouseArray()
8506 {
8507  /* If there are no houses with start dates before 1930, then all houses
8508  * with start dates of 1930 have them reset to 0. This is in order to be
8509  * compatible with TTDPatch, where if no houses have start dates before
8510  * 1930 and the date is before 1930, the game pretends that this is 1930.
8511  * If there have been any houses defined with start dates before 1930 then
8512  * the dates are left alone.
8513  * On the other hand, why 1930? Just 'fix' the houses with the lowest
8514  * minimum introduction date to 0.
8515  */
8516  const GRFFile * const *end = _grf_files.End();
8517  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
8518  HouseSpec **&housespec = (*file)->housespec;
8519  if (housespec == NULL) continue;
8520 
8521  for (int i = 0; i < NUM_HOUSES_PER_GRF; i++) {
8522  HouseSpec *hs = housespec[i];
8523 
8524  if (hs == NULL) continue;
8525 
8526  const HouseSpec *next1 = (i + 1 < NUM_HOUSES_PER_GRF ? housespec[i + 1] : NULL);
8527  const HouseSpec *next2 = (i + 2 < NUM_HOUSES_PER_GRF ? housespec[i + 2] : NULL);
8528  const HouseSpec *next3 = (i + 3 < NUM_HOUSES_PER_GRF ? housespec[i + 3] : NULL);
8529 
8530  if (!IsHouseSpecValid(hs, next1, next2, next3, (*file)->filename)) continue;
8531 
8532  _house_mngr.SetEntitySpec(hs);
8533  }
8534  }
8535 
8536  for (int i = 0; i < NUM_HOUSES; i++) {
8537  HouseSpec *hs = HouseSpec::Get(i);
8538  const HouseSpec *next1 = (i + 1 < NUM_HOUSES ? HouseSpec::Get(i + 1) : NULL);
8539  const HouseSpec *next2 = (i + 2 < NUM_HOUSES ? HouseSpec::Get(i + 2) : NULL);
8540  const HouseSpec *next3 = (i + 3 < NUM_HOUSES ? HouseSpec::Get(i + 3) : NULL);
8541 
8542  /* We need to check all houses again to we are sure that multitile houses
8543  * did get consecutive IDs and none of the parts are missing. */
8544  if (!IsHouseSpecValid(hs, next1, next2, next3, NULL)) {
8545  /* GetHouseNorthPart checks 3 houses that are directly before
8546  * it in the house pool. If any of those houses have multi-tile
8547  * flags set it assumes it's part of a multitile house. Since
8548  * we can have invalid houses in the pool marked as disabled, we
8549  * don't want to have them influencing valid tiles. As such set
8550  * building_flags to zero here to make sure any house following
8551  * this one in the pool is properly handled as 1x1 house. */
8552  hs->building_flags = TILE_NO_FLAG;
8553  }
8554  }
8555 
8556  HouseZones climate_mask = (HouseZones)(1 << (_settings_game.game_creation.landscape + 12));
8557  EnsureEarlyHouse(HZ_ZON1 | climate_mask);
8558  EnsureEarlyHouse(HZ_ZON2 | climate_mask);
8559  EnsureEarlyHouse(HZ_ZON3 | climate_mask);
8560  EnsureEarlyHouse(HZ_ZON4 | climate_mask);
8561  EnsureEarlyHouse(HZ_ZON5 | climate_mask);
8562 
8563  if (_settings_game.game_creation.landscape == LT_ARCTIC) {
8569  }
8570 }
8571 
8578 {
8579  const GRFFile * const *end = _grf_files.End();
8580  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
8581  IndustrySpec **&industryspec = (*file)->industryspec;
8582  IndustryTileSpec **&indtspec = (*file)->indtspec;
8583  if (industryspec != NULL) {
8584  for (int i = 0; i < NUM_INDUSTRYTYPES_PER_GRF; i++) {
8585  IndustrySpec *indsp = industryspec[i];
8586 
8587  if (indsp != NULL && indsp->enabled) {
8588  StringID strid;
8589  /* process the conversion of text at the end, so to be sure everything will be fine
8590  * and available. Check if it does not return undefind marker, which is a very good sign of a
8591  * substitute industry who has not changed the string been examined, thus using it as such */
8592  strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->name);
8593  if (strid != STR_UNDEFINED) indsp->name = strid;
8594 
8595  strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->closure_text);
8596  if (strid != STR_UNDEFINED) indsp->closure_text = strid;
8597 
8598  strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->production_up_text);
8599  if (strid != STR_UNDEFINED) indsp->production_up_text = strid;
8600 
8601  strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->production_down_text);
8602  if (strid != STR_UNDEFINED) indsp->production_down_text = strid;
8603 
8604  strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->new_industry_text);
8605  if (strid != STR_UNDEFINED) indsp->new_industry_text = strid;
8606 
8607  if (indsp->station_name != STR_NULL) {
8608  /* STR_NULL (0) can be set by grf. It has a meaning regarding assignation of the
8609  * station's name. Don't want to lose the value, therefore, do not process. */
8610  strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->station_name);
8611  if (strid != STR_UNDEFINED) indsp->station_name = strid;
8612  }
8613 
8614  _industry_mngr.SetEntitySpec(indsp);
8615  _loaded_newgrf_features.has_newindustries = true;
8616  }
8617  }
8618  }
8619 
8620  if (indtspec != NULL) {
8621  for (int i = 0; i < NUM_INDUSTRYTILES_PER_GRF; i++) {
8622  IndustryTileSpec *indtsp = indtspec[i];
8623  if (indtsp != NULL) {
8624  _industile_mngr.SetEntitySpec(indtsp);
8625  }
8626  }
8627  }
8628  }
8629 
8630  for (uint j = 0; j < NUM_INDUSTRYTYPES; j++) {
8631  IndustrySpec *indsp = &_industry_specs[j];
8632  if (indsp->enabled && indsp->grf_prop.grffile != NULL) {
8633  for (uint i = 0; i < 3; i++) {
8634  indsp->conflicting[i] = MapNewGRFIndustryType(indsp->conflicting[i], indsp->grf_prop.grffile->grfid);
8635  }
8636  }
8637  if (!indsp->enabled) {
8638  indsp->name = STR_NEWGRF_INVALID_INDUSTRYTYPE;
8639  }
8640  }
8641 }
8642 
8649 {
8650  const GRFFile * const *end = _grf_files.End();
8651  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
8652  ObjectSpec **&objectspec = (*file)->objectspec;
8653  if (objectspec != NULL) {
8654  for (int i = 0; i < NUM_OBJECTS_PER_GRF; i++) {
8655  if (objectspec[i] != NULL && objectspec[i]->grf_prop.grffile != NULL && objectspec[i]->enabled) {
8656  _object_mngr.SetEntitySpec(objectspec[i]);
8657  }
8658  }
8659  }
8660  }
8661 }
8662 
8669 {
8670  const GRFFile * const *end = _grf_files.End();
8671  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
8672  AirportSpec **&airportspec = (*file)->airportspec;
8673  if (airportspec != NULL) {
8674  for (int i = 0; i < NUM_AIRPORTS_PER_GRF; i++) {
8675  if (airportspec[i] != NULL && airportspec[i]->enabled) {
8676  _airport_mngr.SetEntitySpec(airportspec[i]);
8677  }
8678  }
8679  }
8680 
8681  AirportTileSpec **&airporttilespec = (*file)->airtspec;
8682  if (airporttilespec != NULL) {
8683  for (uint i = 0; i < NUM_AIRPORTTILES_PER_GRF; i++) {
8684  if (airporttilespec[i] != NULL && airporttilespec[i]->enabled) {
8685  _airporttile_mngr.SetEntitySpec(airporttilespec[i]);
8686  }
8687  }
8688  }
8689  }
8690 }
8691 
8692 /* Here we perform initial decoding of some special sprites (as are they
8693  * described at http://www.ttdpatch.net/src/newgrf.txt, but this is only a very
8694  * partial implementation yet).
8695  * XXX: We consider GRF files trusted. It would be trivial to exploit OTTD by
8696  * a crafted invalid GRF file. We should tell that to the user somehow, or
8697  * better make this more robust in the future. */
8698 static void DecodeSpecialSprite(byte *buf, uint num, GrfLoadingStage stage)
8699 {
8700  /* XXX: There is a difference between staged loading in TTDPatch and
8701  * here. In TTDPatch, for some reason actions 1 and 2 are carried out
8702  * during stage 1, whilst action 3 is carried out during stage 2 (to
8703  * "resolve" cargo IDs... wtf). This is a little problem, because cargo
8704  * IDs are valid only within a given set (action 1) block, and may be
8705  * overwritten after action 3 associates them. But overwriting happens
8706  * in an earlier stage than associating, so... We just process actions
8707  * 1 and 2 in stage 2 now, let's hope that won't get us into problems.
8708  * --pasky
8709  * We need a pre-stage to set up GOTO labels of Action 0x10 because the grf
8710  * is not in memory and scanning the file every time would be too expensive.
8711  * In other stages we skip action 0x10 since it's already dealt with. */
8712  static const SpecialSpriteHandler handlers[][GLS_END] = {
8713  /* 0x00 */ { NULL, SafeChangeInfo, NULL, NULL, ReserveChangeInfo, FeatureChangeInfo, },
8714  /* 0x01 */ { SkipAct1, SkipAct1, SkipAct1, SkipAct1, SkipAct1, NewSpriteSet, },
8715  /* 0x02 */ { NULL, NULL, NULL, NULL, NULL, NewSpriteGroup, },
8716  /* 0x03 */ { NULL, GRFUnsafe, NULL, NULL, NULL, FeatureMapSpriteGroup, },
8717  /* 0x04 */ { NULL, NULL, NULL, NULL, NULL, FeatureNewName, },
8718  /* 0x05 */ { SkipAct5, SkipAct5, SkipAct5, SkipAct5, SkipAct5, GraphicsNew, },
8719  /* 0x06 */ { NULL, NULL, NULL, CfgApply, CfgApply, CfgApply, },
8720  /* 0x07 */ { NULL, NULL, NULL, NULL, SkipIf, SkipIf, },
8721  /* 0x08 */ { ScanInfo, NULL, NULL, GRFInfo, GRFInfo, GRFInfo, },
8722  /* 0x09 */ { NULL, NULL, NULL, SkipIf, SkipIf, SkipIf, },
8723  /* 0x0A */ { SkipActA, SkipActA, SkipActA, SkipActA, SkipActA, SpriteReplace, },
8724  /* 0x0B */ { NULL, NULL, NULL, GRFLoadError, GRFLoadError, GRFLoadError, },
8725  /* 0x0C */ { NULL, NULL, NULL, GRFComment, NULL, GRFComment, },
8726  /* 0x0D */ { NULL, SafeParamSet, NULL, ParamSet, ParamSet, ParamSet, },
8727  /* 0x0E */ { NULL, SafeGRFInhibit, NULL, GRFInhibit, GRFInhibit, GRFInhibit, },
8728  /* 0x0F */ { NULL, GRFUnsafe, NULL, FeatureTownName, NULL, NULL, },
8729  /* 0x10 */ { NULL, NULL, DefineGotoLabel, NULL, NULL, NULL, },
8730  /* 0x11 */ { SkipAct11,GRFUnsafe, SkipAct11, GRFSound, SkipAct11, GRFSound, },
8732  /* 0x13 */ { NULL, NULL, NULL, NULL, NULL, TranslateGRFStrings, },
8733  /* 0x14 */ { StaticGRFInfo, NULL, NULL, NULL, NULL, NULL, },
8734  };
8735 
8736  GRFLocation location(_cur.grfconfig->ident.grfid, _cur.nfo_line);
8737 
8738  GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.find(location);
8739  if (it == _grf_line_to_action6_sprite_override.end()) {
8740  /* No preloaded sprite to work with; read the
8741  * pseudo sprite content. */
8742  FioReadBlock(buf, num);
8743  } else {
8744  /* Use the preloaded sprite data. */
8745  buf = _grf_line_to_action6_sprite_override[location];
8746  grfmsg(7, "DecodeSpecialSprite: Using preloaded pseudo sprite data");
8747 
8748  /* Skip the real (original) content of this action. */
8749  FioSeekTo(num, SEEK_CUR);
8750  }
8751 
8752  ByteReader br(buf, buf + num);
8753  ByteReader *bufp = &br;
8754 
8755  try {
8756  byte action = bufp->ReadByte();
8757 
8758  if (action == 0xFF) {
8759  grfmsg(2, "DecodeSpecialSprite: Unexpected data block, skipping");
8760  } else if (action == 0xFE) {
8761  grfmsg(2, "DecodeSpecialSprite: Unexpected import block, skipping");
8762  } else if (action >= lengthof(handlers)) {
8763  grfmsg(7, "DecodeSpecialSprite: Skipping unknown action 0x%02X", action);
8764  } else if (handlers[action][stage] == NULL) {
8765  grfmsg(7, "DecodeSpecialSprite: Skipping action 0x%02X in stage %d", action, stage);
8766  } else {
8767  grfmsg(7, "DecodeSpecialSprite: Handling action 0x%02X in stage %d", action, stage);
8768  handlers[action][stage](bufp);
8769  }
8770  } catch (...) {
8771  grfmsg(1, "DecodeSpecialSprite: Tried to read past end of pseudo-sprite data");
8772  DisableGrf(STR_NEWGRF_ERROR_READ_BOUNDS);
8773  }
8774 }
8775 
8776 
8778 extern const byte _grf_cont_v2_sig[8] = {'G', 'R', 'F', 0x82, 0x0D, 0x0A, 0x1A, 0x0A};
8779 
8785 {
8786  size_t pos = FioGetPos();
8787 
8788  if (FioReadWord() == 0) {
8789  /* Check for GRF container version 2, which is identified by the bytes
8790  * '47 52 46 82 0D 0A 1A 0A' at the start of the file. */
8791  for (uint i = 0; i < lengthof(_grf_cont_v2_sig); i++) {
8792  if (FioReadByte() != _grf_cont_v2_sig[i]) return 0; // Invalid format
8793  }
8794 
8795  return 2;
8796  }
8797 
8798  /* Container version 1 has no header, rewind to start. */
8799  FioSeekTo(pos, SEEK_SET);
8800  return 1;
8801 }
8802 
8810 void LoadNewGRFFile(GRFConfig *config, uint file_index, GrfLoadingStage stage, Subdirectory subdir)
8811 {
8812  const char *filename = config->filename;
8813 
8814  /* A .grf file is activated only if it was active when the game was
8815  * started. If a game is loaded, only its active .grfs will be
8816  * reactivated, unless "loadallgraphics on" is used. A .grf file is
8817  * considered active if its action 8 has been processed, i.e. its
8818  * action 8 hasn't been skipped using an action 7.
8819  *
8820  * During activation, only actions 0, 1, 2, 3, 4, 5, 7, 8, 9, 0A and 0B are
8821  * carried out. All others are ignored, because they only need to be
8822  * processed once at initialization. */
8823  if (stage != GLS_FILESCAN && stage != GLS_SAFETYSCAN && stage != GLS_LABELSCAN) {
8824  _cur.grffile = GetFileByFilename(filename);
8825  if (_cur.grffile == NULL) usererror("File '%s' lost in cache.\n", filename);
8826  if (stage == GLS_RESERVE && config->status != GCS_INITIALISED) return;
8827  if (stage == GLS_ACTIVATION && !HasBit(config->flags, GCF_RESERVED)) return;
8828  }
8829 
8830  if (file_index >= MAX_FILE_SLOTS) {
8831  DEBUG(grf, 0, "'%s' is not loaded as the maximum number of file slots has been reached", filename);
8832  config->status = GCS_DISABLED;
8833  config->error = new GRFError(STR_NEWGRF_ERROR_MSG_FATAL, STR_NEWGRF_ERROR_TOO_MANY_NEWGRFS_LOADED);
8834  return;
8835  }
8836 
8837  FioOpenFile(file_index, filename, subdir);
8838  _cur.file_index = file_index; // XXX
8839  _palette_remap_grf[_cur.file_index] = (config->palette & GRFP_USE_MASK);
8840 
8841  _cur.grfconfig = config;
8842 
8843  DEBUG(grf, 2, "LoadNewGRFFile: Reading NewGRF-file '%s'", filename);
8844 
8846  if (_cur.grf_container_ver == 0) {
8847  DEBUG(grf, 7, "LoadNewGRFFile: Custom .grf has invalid format");
8848  return;
8849  }
8850 
8851  if (stage == GLS_INIT || stage == GLS_ACTIVATION) {
8852  /* We need the sprite offsets in the init stage for NewGRF sounds
8853  * and in the activation stage for real sprites. */
8855  } else {
8856  /* Skip sprite section offset if present. */
8857  if (_cur.grf_container_ver >= 2) FioReadDword();
8858  }
8859 
8860  if (_cur.grf_container_ver >= 2) {
8861  /* Read compression value. */
8862  byte compression = FioReadByte();
8863  if (compression != 0) {
8864  DEBUG(grf, 7, "LoadNewGRFFile: Unsupported compression format");
8865  return;
8866  }
8867  }
8868 
8869  /* Skip the first sprite; we don't care about how many sprites this
8870  * does contain; newest TTDPatches and George's longvehicles don't
8871  * neither, apparently. */
8872  uint32 num = _cur.grf_container_ver >= 2 ? FioReadDword() : FioReadWord();
8873  if (num == 4 && FioReadByte() == 0xFF) {
8874  FioReadDword();
8875  } else {
8876  DEBUG(grf, 7, "LoadNewGRFFile: Custom .grf has invalid format");
8877  return;
8878  }
8879 
8880  _cur.ClearDataForNextFile();
8881 
8883 
8884  while ((num = (_cur.grf_container_ver >= 2 ? FioReadDword() : FioReadWord())) != 0) {
8885  byte type = FioReadByte();
8886  _cur.nfo_line++;
8887 
8888  if (type == 0xFF) {
8889  if (_cur.skip_sprites == 0) {
8890  DecodeSpecialSprite(buf.Allocate(num), num, stage);
8891 
8892  /* Stop all processing if we are to skip the remaining sprites */
8893  if (_cur.skip_sprites == -1) break;
8894 
8895  continue;
8896  } else {
8897  FioSkipBytes(num);
8898  }
8899  } else {
8900  if (_cur.skip_sprites == 0) {
8901  grfmsg(0, "LoadNewGRFFile: Unexpected sprite, disabling");
8902  DisableGrf(STR_NEWGRF_ERROR_UNEXPECTED_SPRITE);
8903  break;
8904  }
8905 
8906  if (_cur.grf_container_ver >= 2 && type == 0xFD) {
8907  /* Reference to data section. Container version >= 2 only. */
8908  FioSkipBytes(num);
8909  } else {
8910  FioSkipBytes(7);
8911  SkipSpriteData(type, num - 8);
8912  }
8913  }
8914 
8915  if (_cur.skip_sprites > 0) _cur.skip_sprites--;
8916  }
8917 }
8918 
8926 static void ActivateOldShore()
8927 {
8928  /* Use default graphics, if no shore sprites were loaded.
8929  * Should not happen, as the base set's extra grf should include some. */
8930  if (_loaded_newgrf_features.shore == SHORE_REPLACE_NONE) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_A;
8931 
8932  if (_loaded_newgrf_features.shore != SHORE_REPLACE_ACTION_5) {
8933  DupSprite(SPR_ORIGINALSHORE_START + 1, SPR_SHORE_BASE + 1); // SLOPE_W
8934  DupSprite(SPR_ORIGINALSHORE_START + 2, SPR_SHORE_BASE + 2); // SLOPE_S
8935  DupSprite(SPR_ORIGINALSHORE_START + 6, SPR_SHORE_BASE + 3); // SLOPE_SW
8936  DupSprite(SPR_ORIGINALSHORE_START + 0, SPR_SHORE_BASE + 4); // SLOPE_E
8937  DupSprite(SPR_ORIGINALSHORE_START + 4, SPR_SHORE_BASE + 6); // SLOPE_SE
8938  DupSprite(SPR_ORIGINALSHORE_START + 3, SPR_SHORE_BASE + 8); // SLOPE_N
8939  DupSprite(SPR_ORIGINALSHORE_START + 7, SPR_SHORE_BASE + 9); // SLOPE_NW
8940  DupSprite(SPR_ORIGINALSHORE_START + 5, SPR_SHORE_BASE + 12); // SLOPE_NE
8941  }
8942 
8943  if (_loaded_newgrf_features.shore == SHORE_REPLACE_ACTION_A) {
8944  DupSprite(SPR_FLAT_GRASS_TILE + 16, SPR_SHORE_BASE + 0); // SLOPE_STEEP_S
8945  DupSprite(SPR_FLAT_GRASS_TILE + 17, SPR_SHORE_BASE + 5); // SLOPE_STEEP_W
8946  DupSprite(SPR_FLAT_GRASS_TILE + 7, SPR_SHORE_BASE + 7); // SLOPE_WSE
8947  DupSprite(SPR_FLAT_GRASS_TILE + 15, SPR_SHORE_BASE + 10); // SLOPE_STEEP_N
8948  DupSprite(SPR_FLAT_GRASS_TILE + 11, SPR_SHORE_BASE + 11); // SLOPE_NWS
8949  DupSprite(SPR_FLAT_GRASS_TILE + 13, SPR_SHORE_BASE + 13); // SLOPE_ENW
8950  DupSprite(SPR_FLAT_GRASS_TILE + 14, SPR_SHORE_BASE + 14); // SLOPE_SEN
8951  DupSprite(SPR_FLAT_GRASS_TILE + 18, SPR_SHORE_BASE + 15); // SLOPE_STEEP_E
8952 
8953  /* XXX - SLOPE_EW, SLOPE_NS are currently not used.
8954  * If they would be used somewhen, then these grass tiles will most like not look as needed */
8955  DupSprite(SPR_FLAT_GRASS_TILE + 5, SPR_SHORE_BASE + 16); // SLOPE_EW
8956  DupSprite(SPR_FLAT_GRASS_TILE + 10, SPR_SHORE_BASE + 17); // SLOPE_NS
8957  }
8958 }
8959 
8964 {
8965  extern const PriceBaseSpec _price_base_specs[];
8967  static const uint32 override_features = (1 << GSF_TRAINS) | (1 << GSF_ROADVEHICLES) | (1 << GSF_SHIPS) | (1 << GSF_AIRCRAFT);
8968 
8969  /* Evaluate grf overrides */
8970  int num_grfs = _grf_files.Length();
8971  int *grf_overrides = AllocaM(int, num_grfs);
8972  for (int i = 0; i < num_grfs; i++) {
8973  grf_overrides[i] = -1;
8974 
8975  GRFFile *source = _grf_files[i];
8976  uint32 override = _grf_id_overrides[source->grfid];
8977  if (override == 0) continue;
8978 
8979  GRFFile *dest = GetFileByGRFID(override);
8980  if (dest == NULL) continue;
8981 
8982  grf_overrides[i] = _grf_files.FindIndex(dest);
8983  assert(grf_overrides[i] >= 0);
8984  }
8985 
8986  /* Override features and price base multipliers of earlier loaded grfs */
8987  for (int i = 0; i < num_grfs; i++) {
8988  if (grf_overrides[i] < 0 || grf_overrides[i] >= i) continue;
8989  GRFFile *source = _grf_files[i];
8990  GRFFile *dest = _grf_files[grf_overrides[i]];
8991 
8992  uint32 features = (source->grf_features | dest->grf_features) & override_features;
8993  source->grf_features |= features;
8994  dest->grf_features |= features;
8995 
8996  for (Price p = PR_BEGIN; p < PR_END; p++) {
8997  /* No price defined -> nothing to do */
8998  if (!HasBit(features, _price_base_specs[p].grf_feature) || source->price_base_multipliers[p] == INVALID_PRICE_MODIFIER) continue;
8999  DEBUG(grf, 3, "'%s' overrides price base multiplier %d of '%s'", source->filename, p, dest->filename);
9000  dest->price_base_multipliers[p] = source->price_base_multipliers[p];
9001  }
9002  }
9003 
9004  /* Propagate features and price base multipliers of afterwards loaded grfs, if none is present yet */
9005  for (int i = num_grfs - 1; i >= 0; i--) {
9006  if (grf_overrides[i] < 0 || grf_overrides[i] <= i) continue;
9007  GRFFile *source = _grf_files[i];
9008  GRFFile *dest = _grf_files[grf_overrides[i]];
9009 
9010  uint32 features = (source->grf_features | dest->grf_features) & override_features;
9011  source->grf_features |= features;
9012  dest->grf_features |= features;
9013 
9014  for (Price p = PR_BEGIN; p < PR_END; p++) {
9015  /* Already a price defined -> nothing to do */
9016  if (!HasBit(features, _price_base_specs[p].grf_feature) || dest->price_base_multipliers[p] != INVALID_PRICE_MODIFIER) continue;
9017  DEBUG(grf, 3, "Price base multiplier %d from '%s' propagated to '%s'", p, source->filename, dest->filename);
9018  dest->price_base_multipliers[p] = source->price_base_multipliers[p];
9019  }
9020  }
9021 
9022  /* The 'master grf' now have the correct multipliers. Assign them to the 'addon grfs' to make everything consistent. */
9023  for (int i = 0; i < num_grfs; i++) {
9024  if (grf_overrides[i] < 0) continue;
9025  GRFFile *source = _grf_files[i];
9026  GRFFile *dest = _grf_files[grf_overrides[i]];
9027 
9028  uint32 features = (source->grf_features | dest->grf_features) & override_features;
9029  source->grf_features |= features;
9030  dest->grf_features |= features;
9031 
9032  for (Price p = PR_BEGIN; p < PR_END; p++) {
9033  if (!HasBit(features, _price_base_specs[p].grf_feature)) continue;
9034  if (source->price_base_multipliers[p] != dest->price_base_multipliers[p]) {
9035  DEBUG(grf, 3, "Price base multiplier %d from '%s' propagated to '%s'", p, dest->filename, source->filename);
9036  }
9037  source->price_base_multipliers[p] = dest->price_base_multipliers[p];
9038  }
9039  }
9040 
9041  /* Apply fallback prices for grf version < 8 */
9042  const GRFFile * const *end = _grf_files.End();
9043  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
9044  if ((*file)->grf_version >= 8) continue;
9045  PriceMultipliers &price_base_multipliers = (*file)->price_base_multipliers;
9046  for (Price p = PR_BEGIN; p < PR_END; p++) {
9047  Price fallback_price = _price_base_specs[p].fallback_price;
9048  if (fallback_price != INVALID_PRICE && price_base_multipliers[p] == INVALID_PRICE_MODIFIER) {
9049  /* No price multiplier has been set.
9050  * So copy the multiplier from the fallback price, maybe a multiplier was set there. */
9051  price_base_multipliers[p] = price_base_multipliers[fallback_price];
9052  }
9053  }
9054  }
9055 
9056  /* Decide local/global scope of price base multipliers */
9057  for (GRFFile **file = _grf_files.Begin(); file != end; file++) {
9058  PriceMultipliers &price_base_multipliers = (*file)->price_base_multipliers;
9059  for (Price p = PR_BEGIN; p < PR_END; p++) {
9060  if (price_base_multipliers[p] == INVALID_PRICE_MODIFIER) {
9061  /* No multiplier was set; set it to a neutral value */
9062  price_base_multipliers[p] = 0;
9063  } else {
9064  if (!HasBit((*file)->grf_features, _price_base_specs[p].grf_feature)) {
9065  /* The grf does not define any objects of the feature,
9066  * so it must be a difficulty setting. Apply it globally */
9067  DEBUG(grf, 3, "'%s' sets global price base multiplier %d", (*file)->filename, p);
9068  SetPriceBaseMultiplier(p, price_base_multipliers[p]);
9069  price_base_multipliers[p] = 0;
9070  } else {
9071  DEBUG(grf, 3, "'%s' sets local price base multiplier %d", (*file)->filename, p);
9072  }
9073  }
9074  }
9075  }
9076 }
9077 
9078 extern void InitGRFTownGeneratorNames();
9079 
9081 static void AfterLoadGRFs()
9082 {
9083  for (StringIDMapping *it = _string_to_grf_mapping.Begin(); it != _string_to_grf_mapping.End(); it++) {
9084  *it->target = MapGRFStringID(it->grfid, it->source);
9085  }
9086  _string_to_grf_mapping.Clear();
9087 
9088  /* Free the action 6 override sprites. */
9089  for (GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.begin(); it != _grf_line_to_action6_sprite_override.end(); it++) {
9090  free((*it).second);
9091  }
9092  _grf_line_to_action6_sprite_override.clear();
9093 
9094  /* Polish cargoes */
9096 
9097  /* Pre-calculate all refit masks after loading GRF files. */
9099 
9100  /* Polish engines */
9102 
9103  /* Set the actually used Canal properties */
9104  FinaliseCanals();
9105 
9106  /* Add all new houses to the house array. */
9108 
9109  /* Add all new industries to the industry array. */
9111 
9112  /* Add all new objects to the object array. */
9114 
9116 
9117  /* Sort the list of industry types. */
9119 
9120  /* Create dynamic list of industry legends for smallmap_gui.cpp */
9122 
9123  /* Build the routemap legend, based on the available cargos */
9125 
9126  /* Add all new airports to the airports array. */
9128  BindAirportSpecs();
9129 
9130  /* Update the townname generators list */
9132 
9133  /* Run all queued vehicle list order changes */
9135 
9136  /* Load old shore sprites in new position, if they were replaced by ActionA */
9137  ActivateOldShore();
9138 
9139  /* Set up custom rail types */
9140  InitRailTypes();
9141 
9142  Engine *e;
9143  FOR_ALL_ENGINES_OF_TYPE(e, VEH_ROAD) {
9144  if (_gted[e->index].rv_max_speed != 0) {
9145  /* Set RV maximum speed from the mph/0.8 unit value */
9146  e->u.road.max_speed = _gted[e->index].rv_max_speed * 4;
9147  }
9148  }
9149 
9150  FOR_ALL_ENGINES_OF_TYPE(e, VEH_TRAIN) {
9151  RailType railtype = GetRailTypeByLabel(_gted[e->index].railtypelabel);
9152  if (railtype == INVALID_RAILTYPE) {
9153  /* Rail type is not available, so disable this engine */
9154  e->info.climates = 0;
9155  } else {
9156  e->u.rail.railtype = railtype;
9157  }
9158  }
9159 
9161 
9163 
9164  /* Deallocate temporary loading data */
9165  free(_gted);
9166  _grm_sprites.clear();
9167 }
9168 
9175 void LoadNewGRF(uint load_index, uint file_index, uint num_baseset)
9176 {
9177  /* In case of networking we need to "sync" the start values
9178  * so all NewGRFs are loaded equally. For this we use the
9179  * start date of the game and we set the counters, etc. to
9180  * 0 so they're the same too. */
9181  Date date = _date;
9182  Year year = _cur_year;
9183  DateFract date_fract = _date_fract;
9184  uint16 tick_counter = _tick_counter;
9185  byte display_opt = _display_opt;
9186 
9187  if (_networking) {
9189  _date = ConvertYMDToDate(_cur_year, 0, 1);
9190  _date_fract = 0;
9191  _tick_counter = 0;
9192  _display_opt = 0;
9193  }
9194 
9196 
9197  ResetNewGRFData();
9198 
9199  /*
9200  * Reset the status of all files, so we can 'retry' to load them.
9201  * This is needed when one for example rearranges the NewGRFs in-game
9202  * and a previously disabled NewGRF becomes useable. If it would not
9203  * be reset, the NewGRF would remain disabled even though it should
9204  * have been enabled.
9205  */
9206  for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
9207  if (c->status != GCS_NOT_FOUND) c->status = GCS_UNKNOWN;
9208  }
9209 
9210  _cur.spriteid = load_index;
9211 
9212  /* Load newgrf sprites
9213  * in each loading stage, (try to) open each file specified in the config
9214  * and load information from it. */
9215  for (GrfLoadingStage stage = GLS_LABELSCAN; stage <= GLS_ACTIVATION; stage++) {
9216  /* Set activated grfs back to will-be-activated between reservation- and activation-stage.
9217  * This ensures that action7/9 conditions 0x06 - 0x0A work correctly. */
9218  for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
9219  if (c->status == GCS_ACTIVATED) c->status = GCS_INITIALISED;
9220  }
9221 
9222  if (stage == GLS_RESERVE) {
9223  static const uint32 overrides[][2] = {
9224  { 0x44442202, 0x44440111 }, // UKRS addons modifies UKRS
9225  { 0x6D620402, 0x6D620401 }, // DBSetXL ECS extension modifies DBSetXL
9226  { 0x4D656f20, 0x4D656F17 }, // LV4cut modifies LV4
9227  };
9228  for (size_t i = 0; i < lengthof(overrides); i++) {
9229  SetNewGRFOverride(BSWAP32(overrides[i][0]), BSWAP32(overrides[i][1]));
9230  }
9231  }
9232 
9233  uint slot = file_index;
9234  uint num_non_static = 0;
9235 
9236  _cur.stage = stage;
9237  for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
9238  if (c->status == GCS_DISABLED || c->status == GCS_NOT_FOUND) continue;
9239  if (stage > GLS_INIT && HasBit(c->flags, GCF_INIT_ONLY)) continue;
9240 
9241  Subdirectory subdir = slot < file_index + num_baseset ? BASESET_DIR : NEWGRF_DIR;
9242  if (!FioCheckFileExists(c->filename, subdir)) {
9243  DEBUG(grf, 0, "NewGRF file is missing '%s'; disabling", c->filename);
9244  c->status = GCS_NOT_FOUND;
9245  continue;
9246  }
9247 
9248  if (stage == GLS_LABELSCAN) InitNewGRFFile(c);
9249 
9250  if (!HasBit(c->flags, GCF_STATIC) && !HasBit(c->flags, GCF_SYSTEM)) {
9251  if (num_non_static == NETWORK_MAX_GRF_COUNT) {
9252  DEBUG(grf, 0, "'%s' is not loaded as the maximum number of non-static GRFs has been reached", c->filename);
9253  c->status = GCS_DISABLED;
9254  c->error = new GRFError(STR_NEWGRF_ERROR_MSG_FATAL, STR_NEWGRF_ERROR_TOO_MANY_NEWGRFS_LOADED);
9255  continue;
9256  }
9257  num_non_static++;
9258  }
9259  LoadNewGRFFile(c, slot++, stage, subdir);
9260  if (stage == GLS_RESERVE) {
9261  SetBit(c->flags, GCF_RESERVED);
9262  } else if (stage == GLS_ACTIVATION) {
9263  ClrBit(c->flags, GCF_RESERVED);
9264  assert(GetFileByGRFID(c->ident.grfid) == _cur.grffile);
9267  DEBUG(sprite, 2, "LoadNewGRF: Currently %i sprites are loaded", _cur.spriteid);
9268  } else if (stage == GLS_INIT && HasBit(c->flags, GCF_INIT_ONLY)) {
9269  /* We're not going to activate this, so free whatever data we allocated */
9271  }
9272  }
9273  }
9274 
9275  /* Pseudo sprite processing is finished; free temporary stuff */
9276  _cur.ClearDataForNextFile();
9277 
9278  /* Call any functions that should be run after GRFs have been loaded. */
9279  AfterLoadGRFs();
9280 
9281  /* Now revert back to the original situation */
9282  _cur_year = year;
9283  _date = date;
9284  _date_fract = date_fract;
9285  _tick_counter = tick_counter;
9286  _display_opt = display_opt;
9287 }