OpenTTD Source: src/newgrf.cpp Source File

OpenTTD Source 14.1

newgrf.cpp
Go to the documentation of this file.
1 /*
2 * This file is part of OpenTTD.
3 * 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.
4 * 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.
5 * 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/>.
6 */
7
10 #include "stdafx.h"
11
12 #include "core/container_func.hpp"
13 #include "debug.h"
14 #include "fileio_func.h"
15 #include "engine_func.h"
16 #include "engine_base.h"
17 #include "bridge.h"
18 #include "town.h"
19 #include "newgrf_engine.h"
20 #include "newgrf_text.h"
21 #include "fontcache.h"
22 #include "currency.h"
23 #include "landscape.h"
24 #include "newgrf_cargo.h"
25 #include "newgrf_house.h"
26 #include "newgrf_sound.h"
27 #include "newgrf_station.h"
28 #include "industrytype.h"
29 #include "industry_map.h"
30 #include "newgrf_canal.h"
31 #include "newgrf_townname.h"
32 #include "newgrf_industries.h"
33 #include "newgrf_airporttiles.h"
34 #include "newgrf_airport.h"
35 #include "newgrf_object.h"
36 #include "rev.h"
37 #include "fios.h"
38 #include "strings_func.h"
39 #include "timer/timer_game_tick.h"
40 #include "timer/timer_game_calendar.h"
41 #include "string_func.h"
42 #include "network/core/config.h"
43 #include "smallmap_gui.h"
44 #include "genworld.h"
45 #include "error.h"
46 #include "error_func.h"
47 #include "vehicle_func.h"
48 #include "language.h"
49 #include "vehicle_base.h"
50 #include "road.h"
51 #include "newgrf_roadstop.h"
52
53 #include "table/strings.h"
54 #include "table/build_industry.h"
55
56 #include "safeguards.h"
57
58 /* TTDPatch extended GRF format codec
59 * (c) Petr Baudis 2004 (GPL'd)
60 * Changes by Florian octo Forster are (c) by the OpenTTD development team.
61 *
62 * Contains portions of documentation by TTDPatch team.
63 * Thanks especially to Josef Drexler for the documentation as well as a lot
64 * of help at #tycoon. Also thanks to Michael Blunck for his GRF files which
65 * served as subject to the initial testing of this codec. */
66
68 static std::vector<GRFFile *> _grf_files;
69
70 const std::vector<GRFFile *> &GetAllGRFFiles()
71 {
72 return _grf_files;
73 }
74
76 byte _misc_grf_features = 0;
77
79 static uint32_t _ttdpatch_flags[8];
80
82 GRFLoadedFeatures _loaded_newgrf_features;
83
84 static const uint MAX_SPRITEGROUP = UINT8_MAX;
85
87 struct GrfProcessingState {
88 private:
90 struct SpriteSet {
91 SpriteID sprite;
92 uint num_sprites;
93 };
94
96 std::map<uint, SpriteSet> spritesets[GSF_END];
97
98 public:
99 /* Global state */
100 GrfLoadingStage stage;
101 SpriteID spriteid;
102
103 /* Local state in the file */
104 SpriteFile *file;
105 GRFFile *grffile;
106 GRFConfig *grfconfig;
107 uint32_t nfo_line;
108
109 /* Kind of return values when processing certain actions */
110 int skip_sprites;
111
112 /* Currently referenceable spritegroups */
113 const SpriteGroup *spritegroups[MAX_SPRITEGROUP + 1];
114
116 void ClearDataForNextFile()
117 {
118 this->nfo_line = 0;
119 this->skip_sprites = 0;
120
121 for (uint i = 0; i < GSF_END; i++) {
122 this->spritesets[i].clear();
123 }
124
125 memset(this->spritegroups, 0, sizeof(this->spritegroups));
126 }
127
136 void AddSpriteSets(byte feature, SpriteID first_sprite, uint first_set, uint numsets, uint numents)
137 {
138 assert(feature < GSF_END);
139 for (uint i = 0; i < numsets; i++) {
140 SpriteSet &set = this->spritesets[feature][first_set + i];
141 set.sprite = first_sprite + i * numents;
142 set.num_sprites = numents;
143 }
144 }
145
152 bool HasValidSpriteSets(byte feature) const
153 {
154 assert(feature < GSF_END);
155 return !this->spritesets[feature].empty();
156 }
157
165 bool IsValidSpriteSet(byte feature, uint set) const
166 {
167 assert(feature < GSF_END);
168 return this->spritesets[feature].find(set) != this->spritesets[feature].end();
169 }
170
177 SpriteID GetSprite(byte feature, uint set) const
178 {
179 assert(IsValidSpriteSet(feature, set));
180 return this->spritesets[feature].find(set)->second.sprite;
181 }
182
189 uint GetNumEnts(byte feature, uint set) const
190 {
191 assert(IsValidSpriteSet(feature, set));
192 return this->spritesets[feature].find(set)->second.num_sprites;
193 }
194 };
195
196 static GrfProcessingState _cur;
197
198
205 template <VehicleType T>
206 static inline bool IsValidNewGRFImageIndex(uint8_t image_index)
207 {
208 return image_index == 0xFD || IsValidImageIndex<T>(image_index);
209 }
210
211 class OTTDByteReaderSignal { };
212
214 class ByteReader {
215 protected:
216 byte *data;
217 byte *end;
218
219 public:
220 ByteReader(byte *data, byte *end) : data(data), end(end) { }
221
222 inline byte *ReadBytes(size_t size)
223 {
224 if (data + size >= end) {
225 /* Put data at the end, as would happen if every byte had been individually read. */
226 data = end;
227 throw OTTDByteReaderSignal();
228 }
229
230 byte *ret = data;
231 data += size;
232 return ret;
233 }
234
235 inline byte ReadByte()
236 {
237 if (data < end) return *(data)++;
238 throw OTTDByteReaderSignal();
239 }
240
241 uint16_t ReadWord()
242 {
243 uint16_t val = ReadByte();
244 return val | (ReadByte() << 8);
245 }
246
247 uint16_t ReadExtendedByte()
248 {
249 uint16_t val = ReadByte();
250 return val == 0xFF ? ReadWord() : val;
251 }
252
253 uint32_t ReadDWord()
254 {
255 uint32_t val = ReadWord();
256 return val | (ReadWord() << 16);
257 }
258
259 uint32_t ReadVarSize(byte size)
260 {
261 switch (size) {
262 case 1: return ReadByte();
263 case 2: return ReadWord();
264 case 4: return ReadDWord();
265 default:
266 NOT_REACHED();
267 return 0;
268 }
269 }
270
271 const char *ReadString()
272 {
273 char *string = reinterpret_cast<char *>(data);
274 size_t string_length = ttd_strnlen(string, Remaining());
275
276 if (string_length == Remaining()) {
277 /* String was not NUL terminated, so make sure it is now. */
278 string[string_length - 1] = '\0';
279 GrfMsg(7, "String was not terminated with a zero byte.");
280 } else {
281 /* Increase the string length to include the NUL byte. */
282 string_length++;
283 }
284 Skip(string_length);
285
286 return string;
287 }
288
289 inline size_t Remaining() const
290 {
291 return end - data;
292 }
293
294 inline bool HasData(size_t count = 1) const
295 {
296 return data + count <= end;
297 }
298
299 inline byte *Data()
300 {
301 return data;
302 }
303
304 inline void Skip(size_t len)
305 {
306 data += len;
307 /* It is valid to move the buffer to exactly the end of the data,
308 * as there may not be any more data read. */
309 if (data > end) throw OTTDByteReaderSignal();
310 }
311 };
312
313 typedef void (*SpecialSpriteHandler)(ByteReader *buf);
314
316 static const uint NUM_STATIONS_PER_GRF = UINT16_MAX - 1;
317
319 struct GRFTempEngineData {
321 enum Refittability {
322 UNSET = 0,
323 EMPTY,
324 NONEMPTY,
325 };
326
327 uint16_t cargo_allowed;
328 uint16_t cargo_disallowed;
329 RailTypeLabel railtypelabel;
330 uint8_t roadtramtype;
331 const GRFFile *defaultcargo_grf;
332 Refittability refittability;
333 uint8_t rv_max_speed;
334 CargoTypes ctt_include_mask;
335 CargoTypes ctt_exclude_mask;
336
341 void UpdateRefittability(bool non_empty)
342 {
343 if (non_empty) {
344 this->refittability = NONEMPTY;
345 } else if (this->refittability == UNSET) {
346 this->refittability = EMPTY;
347 }
348 }
349 };
350
351 static std::vector<GRFTempEngineData> _gted;
352
357 static uint32_t _grm_engines[256];
358
360 static uint32_t _grm_cargoes[NUM_CARGO * 2];
361
362 struct GRFLocation {
363 uint32_t grfid;
364 uint32_t nfoline;
365
366 GRFLocation(uint32_t grfid, uint32_t nfoline) : grfid(grfid), nfoline(nfoline) { }
367
368 bool operator<(const GRFLocation &other) const
369 {
370 return this->grfid < other.grfid || (this->grfid == other.grfid && this->nfoline < other.nfoline);
371 }
372
373 bool operator == (const GRFLocation &other) const
374 {
375 return this->grfid == other.grfid && this->nfoline == other.nfoline;
376 }
377 };
378
379 static std::map<GRFLocation, SpriteID> _grm_sprites;
380 typedef std::map<GRFLocation, std::vector<byte>> GRFLineToSpriteOverride;
381 static GRFLineToSpriteOverride _grf_line_to_action6_sprite_override;
382
393 void GrfMsgI(int severity, const std::string &msg)
394 {
395 Debug(grf, severity, "[{}:{}] {}", _cur.grfconfig->filename, _cur.nfo_line, msg);
396 }
397
403 static GRFFile *GetFileByGRFID(uint32_t grfid)
404 {
405 for (GRFFile * const file : _grf_files) {
406 if (file->grfid == grfid) return file;
407 }
408 return nullptr;
409 }
410
416 static GRFFile *GetFileByFilename(const std::string &filename)
417 {
418 for (GRFFile * const file : _grf_files) {
419 if (file->filename == filename) return file;
420 }
421 return nullptr;
422 }
423
425 static void ClearTemporaryNewGRFData(GRFFile *gf)
426 {
427 gf->labels.clear();
428 }
429
436 static GRFError *DisableGrf(StringID message = STR_NULL, GRFConfig *config = nullptr)
437 {
438 GRFFile *file;
439 if (config != nullptr) {
440 file = GetFileByGRFID(config->ident.grfid);
441 } else {
442 config = _cur.grfconfig;
443 file = _cur.grffile;
444 }
445
446 config->status = GCS_DISABLED;
447 if (file != nullptr) ClearTemporaryNewGRFData(file);
448 if (config == _cur.grfconfig) _cur.skip_sprites = -1;
449
450 if (message == STR_NULL) return nullptr;
451
452 config->error = {STR_NEWGRF_ERROR_MSG_FATAL, message};
453 if (config == _cur.grfconfig) config->error->param_value[0] = _cur.nfo_line;
454 return &config->error.value();
455 }
456
460 struct StringIDMapping {
461 uint32_t grfid;
462 StringID source;
463 StringID *target;
464 };
465 typedef std::vector<StringIDMapping> StringIDMappingVector;
466 static StringIDMappingVector _string_to_grf_mapping;
467
473 static void AddStringForMapping(StringID source, StringID *target)
474 {
475 *target = STR_UNDEFINED;
476 _string_to_grf_mapping.push_back({_cur.grffile->grfid, source, target});
477 }
478
486 static StringID TTDPStringIDToOTTDStringIDMapping(StringID str)
487 {
488 /* StringID table for TextIDs 0x4E->0x6D */
489 static const StringID units_volume[] = {
490 STR_ITEMS, STR_PASSENGERS, STR_TONS, STR_BAGS,
491 STR_LITERS, STR_ITEMS, STR_CRATES, STR_TONS,
492 STR_TONS, STR_TONS, STR_TONS, STR_BAGS,
493 STR_TONS, STR_TONS, STR_TONS, STR_BAGS,
494 STR_TONS, STR_TONS, STR_BAGS, STR_LITERS,
495 STR_TONS, STR_LITERS, STR_TONS, STR_ITEMS,
496 STR_BAGS, STR_LITERS, STR_TONS, STR_ITEMS,
497 STR_TONS, STR_ITEMS, STR_LITERS, STR_ITEMS
498 };
499
500 /* A string straight from a NewGRF; this was already translated by MapGRFStringID(). */
501 assert(!IsInsideMM(str, 0xD000, 0xD7FF));
502
503 #define TEXTID_TO_STRINGID(begin, end, stringid, stringend) \
504 static_assert(stringend - stringid == end - begin); \
505 if (str >= begin && str <= end) return str + (stringid - begin)
506
507 /* We have some changes in our cargo strings, resulting in some missing. */
508 TEXTID_TO_STRINGID(0x000E, 0x002D, STR_CARGO_PLURAL_NOTHING, STR_CARGO_PLURAL_FIZZY_DRINKS);
509 TEXTID_TO_STRINGID(0x002E, 0x004D, STR_CARGO_SINGULAR_NOTHING, STR_CARGO_SINGULAR_FIZZY_DRINK);
510 if (str >= 0x004E && str <= 0x006D) return units_volume[str - 0x004E];
511 TEXTID_TO_STRINGID(0x006E, 0x008D, STR_QUANTITY_NOTHING, STR_QUANTITY_FIZZY_DRINKS);
512 TEXTID_TO_STRINGID(0x008E, 0x00AD, STR_ABBREV_NOTHING, STR_ABBREV_FIZZY_DRINKS);
513 TEXTID_TO_STRINGID(0x00D1, 0x00E0, STR_COLOUR_DARK_BLUE, STR_COLOUR_WHITE);
514
515 /* Map building names according to our lang file changes. There are several
516 * ranges of house ids, all of which need to be remapped to allow newgrfs
517 * to use original house names. */
518 TEXTID_TO_STRINGID(0x200F, 0x201F, STR_TOWN_BUILDING_NAME_TALL_OFFICE_BLOCK_1, STR_TOWN_BUILDING_NAME_OLD_HOUSES_1);
519 TEXTID_TO_STRINGID(0x2036, 0x2041, STR_TOWN_BUILDING_NAME_COTTAGES_1, STR_TOWN_BUILDING_NAME_SHOPPING_MALL_1);
520 TEXTID_TO_STRINGID(0x2059, 0x205C, STR_TOWN_BUILDING_NAME_IGLOO_1, STR_TOWN_BUILDING_NAME_PIGGY_BANK_1);
521
522 /* Same thing for industries */
523 TEXTID_TO_STRINGID(0x4802, 0x4826, STR_INDUSTRY_NAME_COAL_MINE, STR_INDUSTRY_NAME_SUGAR_MINE);
524 TEXTID_TO_STRINGID(0x482D, 0x482E, STR_NEWS_INDUSTRY_CONSTRUCTION, STR_NEWS_INDUSTRY_PLANTED);
525 TEXTID_TO_STRINGID(0x4832, 0x4834, STR_NEWS_INDUSTRY_CLOSURE_GENERAL, STR_NEWS_INDUSTRY_CLOSURE_LACK_OF_TREES);
526 TEXTID_TO_STRINGID(0x4835, 0x4838, STR_NEWS_INDUSTRY_PRODUCTION_INCREASE_GENERAL, STR_NEWS_INDUSTRY_PRODUCTION_INCREASE_FARM);
527 TEXTID_TO_STRINGID(0x4839, 0x483A, STR_NEWS_INDUSTRY_PRODUCTION_DECREASE_GENERAL, STR_NEWS_INDUSTRY_PRODUCTION_DECREASE_FARM);
528
529 switch (str) {
530 case 0x4830: return STR_ERROR_CAN_T_CONSTRUCT_THIS_INDUSTRY;
531 case 0x4831: return STR_ERROR_FOREST_CAN_ONLY_BE_PLANTED;
532 case 0x483B: return STR_ERROR_CAN_ONLY_BE_POSITIONED;
533 }
534 #undef TEXTID_TO_STRINGID
535
536 if (str == STR_NULL) return STR_EMPTY;
537
538 Debug(grf, 0, "Unknown StringID 0x{:04X} remapped to STR_EMPTY. Please open a Feature Request if you need it", str);
539
540 return STR_EMPTY;
541 }
542
550 StringID MapGRFStringID(uint32_t grfid, StringID str)
551 {
552 if (IsInsideMM(str, 0xD800, 0x10000)) {
553 /* General text provided by NewGRF.
554 * In the specs this is called the 0xDCxx range (misc persistent texts),
555 * but we meanwhile extended the range to 0xD800-0xFFFF.
556 * Note: We are not involved in the "persistent" business, since we do not store
557 * any NewGRF strings in savegames. */
558 return GetGRFStringID(grfid, str);
559 } else if (IsInsideMM(str, 0xD000, 0xD800)) {
560 /* Callback text provided by NewGRF.
561 * In the specs this is called the 0xD0xx range (misc graphics texts).
562 * These texts can be returned by various callbacks.
563 *
564 * Due to how TTDP implements the GRF-local- to global-textid translation
565 * texts included via 0x80 or 0x81 control codes have to add 0x400 to the textid.
566 * We do not care about that difference and just mask out the 0x400 bit.
567 */
568 str &= ~0x400;
569 return GetGRFStringID(grfid, str);
570 } else {
571 /* The NewGRF wants to include/reference an original TTD string.
572 * Try our best to find an equivalent one. */
573 return TTDPStringIDToOTTDStringIDMapping(str);
574 }
575 }
576
577 static std::map<uint32_t, uint32_t> _grf_id_overrides;
578
584 static void SetNewGRFOverride(uint32_t source_grfid, uint32_t target_grfid)
585 {
586 _grf_id_overrides[source_grfid] = target_grfid;
587 GrfMsg(5, "SetNewGRFOverride: Added override of 0x{:X} to 0x{:X}", BSWAP32(source_grfid), BSWAP32(target_grfid));
588 }
589
598 static Engine *GetNewEngine(const GRFFile *file, VehicleType type, uint16_t internal_id, bool static_access = false)
599 {
600 /* Hack for add-on GRFs that need to modify another GRF's engines. This lets
601 * them use the same engine slots. */
602 uint32_t scope_grfid = INVALID_GRFID; // If not using dynamic_engines, all newgrfs share their ID range
603 if (_settings_game.vehicle.dynamic_engines) {
604 /* If dynamic_engies is enabled, there can be multiple independent ID ranges. */
605 scope_grfid = file->grfid;
606 uint32_t override = _grf_id_overrides[file->grfid];
607 if (override != 0) {
608 scope_grfid = override;
609 const GRFFile *grf_match = GetFileByGRFID(override);
610 if (grf_match == nullptr) {
611 GrfMsg(5, "Tried mapping from GRFID {:x} to {:x} but target is not loaded", BSWAP32(file->grfid), BSWAP32(override));
612 } else {
613 GrfMsg(5, "Mapping from GRFID {:x} to {:x}", BSWAP32(file->grfid), BSWAP32(override));
614 }
615 }
616
617 /* Check if the engine is registered in the override manager */
618 EngineID engine = _engine_mngr.GetID(type, internal_id, scope_grfid);
619 if (engine != INVALID_ENGINE) {
620 Engine *e = Engine::Get(engine);
621 if (e->grf_prop.grffile == nullptr) e->grf_prop.grffile = file;
622 return e;
623 }
624 }
625
626 /* Check if there is an unreserved slot */
627 EngineID engine = _engine_mngr.GetID(type, internal_id, INVALID_GRFID);
628 if (engine != INVALID_ENGINE) {
629 Engine *e = Engine::Get(engine);
630
631 if (e->grf_prop.grffile == nullptr) {
632 e->grf_prop.grffile = file;
633 GrfMsg(5, "Replaced engine at index {} for GRFID {:x}, type {}, index {}", e->index, BSWAP32(file->grfid), type, internal_id);
634 }
635
636 /* Reserve the engine slot */
637 if (!static_access) {
638 EngineIDMapping *eid = _engine_mngr.data() + engine;
639 eid->grfid = scope_grfid; // Note: this is INVALID_GRFID if dynamic_engines is disabled, so no reservation
640 }
641
642 return e;
643 }
644
645 if (static_access) return nullptr;
646
647 if (!Engine::CanAllocateItem()) {
648 GrfMsg(0, "Can't allocate any more engines");
649 return nullptr;
650 }
651
652 size_t engine_pool_size = Engine::GetPoolSize();
653
654 /* ... it's not, so create a new one based off an existing engine */
655 Engine *e = new Engine(type, internal_id);
656 e->grf_prop.grffile = file;
657
658 /* Reserve the engine slot */
659 assert(_engine_mngr.size() == e->index);
660 _engine_mngr.push_back({
661 scope_grfid, // Note: this is INVALID_GRFID if dynamic_engines is disabled, so no reservation
662 internal_id,
663 type,
664 std::min<uint8_t>(internal_id, _engine_counts[type]) // substitute_id == _engine_counts[subtype] means "no substitute"
665 });
666
667 if (engine_pool_size != Engine::GetPoolSize()) {
668 /* Resize temporary engine data ... */
669 _gted.resize(Engine::GetPoolSize());
670 }
671 if (type == VEH_TRAIN) {
672 _gted[e->index].railtypelabel = GetRailTypeInfo(e->u.rail.railtype)->label;
673 }
674
675 GrfMsg(5, "Created new engine at index {} for GRFID {:x}, type {}, index {}", e->index, BSWAP32(file->grfid), type, internal_id);
676
677 return e;
678 }
679
690 EngineID GetNewEngineID(const GRFFile *file, VehicleType type, uint16_t internal_id)
691 {
692 uint32_t scope_grfid = INVALID_GRFID; // If not using dynamic_engines, all newgrfs share their ID range
693 if (_settings_game.vehicle.dynamic_engines) {
694 scope_grfid = file->grfid;
695 uint32_t override = _grf_id_overrides[file->grfid];
696 if (override != 0) scope_grfid = override;
697 }
698
699 return _engine_mngr.GetID(type, internal_id, scope_grfid);
700 }
701
706 static void MapSpriteMappingRecolour(PalSpriteID *grf_sprite)
707 {
708 if (HasBit(grf_sprite->pal, 14)) {
709 ClrBit(grf_sprite->pal, 14);
710 SetBit(grf_sprite->sprite, SPRITE_MODIFIER_OPAQUE);
711 }
712
713 if (HasBit(grf_sprite->sprite, 14)) {
714 ClrBit(grf_sprite->sprite, 14);
715 SetBit(grf_sprite->sprite, PALETTE_MODIFIER_TRANSPARENT);
716 }
717
718 if (HasBit(grf_sprite->sprite, 15)) {
719 ClrBit(grf_sprite->sprite, 15);
720 SetBit(grf_sprite->sprite, PALETTE_MODIFIER_COLOUR);
721 }
722 }
723
737 static TileLayoutFlags ReadSpriteLayoutSprite(ByteReader *buf, bool read_flags, bool invert_action1_flag, bool use_cur_spritesets, int feature, PalSpriteID *grf_sprite, uint16_t *max_sprite_offset = nullptr, uint16_t *max_palette_offset = nullptr)
738 {
739 grf_sprite->sprite = buf->ReadWord();
740 grf_sprite->pal = buf->ReadWord();
741 TileLayoutFlags flags = read_flags ? (TileLayoutFlags)buf->ReadWord() : TLF_NOTHING;
742
743 MapSpriteMappingRecolour(grf_sprite);
744
745 bool custom_sprite = HasBit(grf_sprite->pal, 15) != invert_action1_flag;
746 ClrBit(grf_sprite->pal, 15);
747 if (custom_sprite) {
748 /* Use sprite from Action 1 */
749 uint index = GB(grf_sprite->sprite, 0, 14);
750 if (use_cur_spritesets && (!_cur.IsValidSpriteSet(feature, index) || _cur.GetNumEnts(feature, index) == 0)) {
751 GrfMsg(1, "ReadSpriteLayoutSprite: Spritelayout uses undefined custom spriteset {}", index);
752 grf_sprite->sprite = SPR_IMG_QUERY;
753 grf_sprite->pal = PAL_NONE;
754 } else {
755 SpriteID sprite = use_cur_spritesets ? _cur.GetSprite(feature, index) : index;
756 if (max_sprite_offset != nullptr) *max_sprite_offset = use_cur_spritesets ? _cur.GetNumEnts(feature, index) : UINT16_MAX;
757 SB(grf_sprite->sprite, 0, SPRITE_WIDTH, sprite);
758 SetBit(grf_sprite->sprite, SPRITE_MODIFIER_CUSTOM_SPRITE);
759 }
760 } else if ((flags & TLF_SPRITE_VAR10) && !(flags & TLF_SPRITE_REG_FLAGS)) {
761 GrfMsg(1, "ReadSpriteLayoutSprite: Spritelayout specifies var10 value for non-action-1 sprite");
762 DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
763 return flags;
764 }
765
766 if (flags & TLF_CUSTOM_PALETTE) {
767 /* Use palette from Action 1 */
768 uint index = GB(grf_sprite->pal, 0, 14);
769 if (use_cur_spritesets && (!_cur.IsValidSpriteSet(feature, index) || _cur.GetNumEnts(feature, index) == 0)) {
770 GrfMsg(1, "ReadSpriteLayoutSprite: Spritelayout uses undefined custom spriteset {} for 'palette'", index);
771 grf_sprite->pal = PAL_NONE;
772 } else {
773 SpriteID sprite = use_cur_spritesets ? _cur.GetSprite(feature, index) : index;
774 if (max_palette_offset != nullptr) *max_palette_offset = use_cur_spritesets ? _cur.GetNumEnts(feature, index) : UINT16_MAX;
775 SB(grf_sprite->pal, 0, SPRITE_WIDTH, sprite);
776 SetBit(grf_sprite->pal, SPRITE_MODIFIER_CUSTOM_SPRITE);
777 }
778 } else if ((flags & TLF_PALETTE_VAR10) && !(flags & TLF_PALETTE_REG_FLAGS)) {
779 GrfMsg(1, "ReadSpriteLayoutRegisters: Spritelayout specifies var10 value for non-action-1 palette");
780 DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
781 return flags;
782 }
783
784 return flags;
785 }
786
795 static void ReadSpriteLayoutRegisters(ByteReader *buf, TileLayoutFlags flags, bool is_parent, NewGRFSpriteLayout *dts, uint index)
796 {
797 if (!(flags & TLF_DRAWING_FLAGS)) return;
798
799 if (dts->registers == nullptr) dts->AllocateRegisters();
800 TileLayoutRegisters &regs = const_cast<TileLayoutRegisters&>(dts->registers[index]);
801 regs.flags = flags & TLF_DRAWING_FLAGS;
802
803 if (flags & TLF_DODRAW) regs.dodraw = buf->ReadByte();
804 if (flags & TLF_SPRITE) regs.sprite = buf->ReadByte();
805 if (flags & TLF_PALETTE) regs.palette = buf->ReadByte();
806
807 if (is_parent) {
808 if (flags & TLF_BB_XY_OFFSET) {
809 regs.delta.parent[0] = buf->ReadByte();
810 regs.delta.parent[1] = buf->ReadByte();
811 }
812 if (flags & TLF_BB_Z_OFFSET) regs.delta.parent[2] = buf->ReadByte();
813 } else {
814 if (flags & TLF_CHILD_X_OFFSET) regs.delta.child[0] = buf->ReadByte();
815 if (flags & TLF_CHILD_Y_OFFSET) regs.delta.child[1] = buf->ReadByte();
816 }
817
818 if (flags & TLF_SPRITE_VAR10) {
819 regs.sprite_var10 = buf->ReadByte();
820 if (regs.sprite_var10 > TLR_MAX_VAR10) {
821 GrfMsg(1, "ReadSpriteLayoutRegisters: Spritelayout specifies var10 ({}) exceeding the maximal allowed value {}", regs.sprite_var10, TLR_MAX_VAR10);
822 DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
823 return;
824 }
825 }
826
827 if (flags & TLF_PALETTE_VAR10) {
828 regs.palette_var10 = buf->ReadByte();
829 if (regs.palette_var10 > TLR_MAX_VAR10) {
830 GrfMsg(1, "ReadSpriteLayoutRegisters: Spritelayout specifies var10 ({}) exceeding the maximal allowed value {}", regs.palette_var10, TLR_MAX_VAR10);
831 DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
832 return;
833 }
834 }
835 }
836
848 static bool ReadSpriteLayout(ByteReader *buf, uint num_building_sprites, bool use_cur_spritesets, byte feature, bool allow_var10, bool no_z_position, NewGRFSpriteLayout *dts)
849 {
850 bool has_flags = HasBit(num_building_sprites, 6);
851 ClrBit(num_building_sprites, 6);
852 TileLayoutFlags valid_flags = TLF_KNOWN_FLAGS;
853 if (!allow_var10) valid_flags &= ~TLF_VAR10_FLAGS;
854 dts->Allocate(num_building_sprites); // allocate before reading groundsprite flags
855
856 std::vector<uint16_t> max_sprite_offset(num_building_sprites + 1, 0);
857 std::vector<uint16_t> max_palette_offset(num_building_sprites + 1, 0);
858
859 /* Groundsprite */
860 TileLayoutFlags flags = ReadSpriteLayoutSprite(buf, has_flags, false, use_cur_spritesets, feature, &dts->ground, max_sprite_offset.data(), max_palette_offset.data());
861 if (_cur.skip_sprites < 0) return true;
862
863 if (flags & ~(valid_flags & ~TLF_NON_GROUND_FLAGS)) {
864 GrfMsg(1, "ReadSpriteLayout: Spritelayout uses invalid flag 0x{:X} for ground sprite", flags & ~(valid_flags & ~TLF_NON_GROUND_FLAGS));
865 DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
866 return true;
867 }
868
869 ReadSpriteLayoutRegisters(buf, flags, false, dts, 0);
870 if (_cur.skip_sprites < 0) return true;
871
872 for (uint i = 0; i < num_building_sprites; i++) {
873 DrawTileSeqStruct *seq = const_cast<DrawTileSeqStruct*>(&dts->seq[i]);
874
875 flags = ReadSpriteLayoutSprite(buf, has_flags, false, use_cur_spritesets, feature, &seq->image, max_sprite_offset.data() + i + 1, max_palette_offset.data() + i + 1);
876 if (_cur.skip_sprites < 0) return true;
877
878 if (flags & ~valid_flags) {
879 GrfMsg(1, "ReadSpriteLayout: Spritelayout uses unknown flag 0x{:X}", flags & ~valid_flags);
880 DisableGrf(STR_NEWGRF_ERROR_INVALID_SPRITE_LAYOUT);
881 return true;
882 }
883
884 seq->delta_x = buf->ReadByte();
885 seq->delta_y = buf->ReadByte();
886
887 if (!no_z_position) seq->delta_z = buf->ReadByte();
888
889 if (seq->IsParentSprite()) {
890 seq->size_x = buf->ReadByte();
891 seq->size_y = buf->ReadByte();
892 seq->size_z = buf->ReadByte();
893 }
894
895 ReadSpriteLayoutRegisters(buf, flags, seq->IsParentSprite(), dts, i + 1);
896 if (_cur.skip_sprites < 0) return true;
897 }
898
899 /* Check if the number of sprites per spriteset is consistent */
900 bool is_consistent = true;
901 dts->consistent_max_offset = 0;
902 for (uint i = 0; i < num_building_sprites + 1; i++) {
903 if (max_sprite_offset[i] > 0) {
904 if (dts->consistent_max_offset == 0) {
905 dts->consistent_max_offset = max_sprite_offset[i];
906 } else if (dts->consistent_max_offset != max_sprite_offset[i]) {
907 is_consistent = false;
908 break;
909 }
910 }
911 if (max_palette_offset[i] > 0) {
912 if (dts->consistent_max_offset == 0) {
913 dts->consistent_max_offset = max_palette_offset[i];
914 } else if (dts->consistent_max_offset != max_palette_offset[i]) {
915 is_consistent = false;
916 break;
917 }
918 }
919 }
920
921 /* When the Action1 sets are unknown, everything should be 0 (no spriteset usage) or UINT16_MAX (some spriteset usage) */
922 assert(use_cur_spritesets || (is_consistent && (dts->consistent_max_offset == 0 || dts->consistent_max_offset == UINT16_MAX)));
923
924 if (!is_consistent || dts->registers != nullptr) {
925 dts->consistent_max_offset = 0;
926 if (dts->registers == nullptr) dts->AllocateRegisters();
927
928 for (uint i = 0; i < num_building_sprites + 1; i++) {
929 TileLayoutRegisters &regs = const_cast<TileLayoutRegisters&>(dts->registers[i]);
930 regs.max_sprite_offset = max_sprite_offset[i];
931 regs.max_palette_offset = max_palette_offset[i];
932 }
933 }
934
935 return false;
936 }
937
941 static CargoTypes TranslateRefitMask(uint32_t refit_mask)
942 {
943 CargoTypes result = 0;
944 for (uint8_t bit : SetBitIterator(refit_mask)) {
945 CargoID cargo = GetCargoTranslation(bit, _cur.grffile, true);
946 if (IsValidCargoID(cargo)) SetBit(result, cargo);
947 }
948 return result;
949 }
950
958 static void ConvertTTDBasePrice(uint32_t base_pointer, const char *error_location, Price *index)
959 {
960 /* Special value for 'none' */
961 if (base_pointer == 0) {
962 *index = INVALID_PRICE;
963 return;
964 }
965
966 static const uint32_t start = 0x4B34;
967 static const uint32_t size = 6;
968
969 if (base_pointer < start || (base_pointer - start) % size != 0 || (base_pointer - start) / size >= PR_END) {
970 GrfMsg(1, "{}: Unsupported running cost base 0x{:04X}, ignoring", error_location, base_pointer);
971 return;
972 }
973
974 *index = (Price)((base_pointer - start) / size);
975 }
976
978 enum ChangeInfoResult {
979 CIR_SUCCESS,
980 CIR_DISABLED,
981 CIR_UNHANDLED,
982 CIR_UNKNOWN,
983 CIR_INVALID_ID,
984 };
985
986 typedef ChangeInfoResult (*VCI_Handler)(uint engine, int numinfo, int prop, ByteReader *buf);
987
995 static ChangeInfoResult CommonVehicleChangeInfo(EngineInfo *ei, int prop, ByteReader *buf)
996 {
997 switch (prop) {
998 case 0x00: // Introduction date
999 ei->base_intro = buf->ReadWord() + CalendarTime::DAYS_TILL_ORIGINAL_BASE_YEAR;
1000 break;
1001
1002 case 0x02: // Decay speed
1003 ei->decay_speed = buf->ReadByte();
1004 break;
1005
1006 case 0x03: // Vehicle life
1007 ei->lifelength = buf->ReadByte();
1008 break;
1009
1010 case 0x04: // Model life
1011 ei->base_life = buf->ReadByte();
1012 break;
1013
1014 case 0x06: // Climates available
1015 ei->climates = buf->ReadByte();
1016 break;
1017
1018 case PROP_VEHICLE_LOAD_AMOUNT: // 0x07 Loading speed
1019 /* Amount of cargo loaded during a vehicle's "loading tick" */
1020 ei->load_amount = buf->ReadByte();
1021 break;
1022
1023 default:
1024 return CIR_UNKNOWN;
1025 }
1026
1027 return CIR_SUCCESS;
1028 }
1029
1038 static ChangeInfoResult RailVehicleChangeInfo(uint engine, int numinfo, int prop, ByteReader *buf)
1039 {
1040 ChangeInfoResult ret = CIR_SUCCESS;
1041
1042 for (int i = 0; i < numinfo; i++) {
1043 Engine *e = GetNewEngine(_cur.grffile, VEH_TRAIN, engine + i);
1044 if (e == nullptr) return CIR_INVALID_ID; // No engine could be allocated, so neither can any next vehicles
1045
1046 EngineInfo *ei = &e->info;
1047 RailVehicleInfo *rvi = &e->u.rail;
1048
1049 switch (prop) {
1050 case 0x05: { // Track type
1051 uint8_t tracktype = buf->ReadByte();
1052
1053 if (tracktype < _cur.grffile->railtype_list.size()) {
1054 _gted[e->index].railtypelabel = _cur.grffile->railtype_list[tracktype];
1055 break;
1056 }
1057
1058 switch (tracktype) {
1059 case 0: _gted[e->index].railtypelabel = rvi->engclass >= 2 ? RAILTYPE_LABEL_ELECTRIC : RAILTYPE_LABEL_RAIL; break;
1060 case 1: _gted[e->index].railtypelabel = RAILTYPE_LABEL_MONO; break;
1061 case 2: _gted[e->index].railtypelabel = RAILTYPE_LABEL_MAGLEV; break;
1062 default:
1063 GrfMsg(1, "RailVehicleChangeInfo: Invalid track type {} specified, ignoring", tracktype);
1064 break;
1065 }
1066 break;
1067 }
1068
1069 case 0x08: // AI passenger service
1070 /* Tells the AI that this engine is designed for
1071 * passenger services and shouldn't be used for freight. */
1072 rvi->ai_passenger_only = buf->ReadByte();
1073 break;
1074
1075 case PROP_TRAIN_SPEED: { // 0x09 Speed (1 unit is 1 km-ish/h)
1076 uint16_t speed = buf->ReadWord();
1077 if (speed == 0xFFFF) speed = 0;
1078
1079 rvi->max_speed = speed;
1080 break;
1081 }
1082
1083 case PROP_TRAIN_POWER: // 0x0B Power
1084 rvi->power = buf->ReadWord();
1085
1086 /* Set engine / wagon state based on power */
1087 if (rvi->power != 0) {
1088 if (rvi->railveh_type == RAILVEH_WAGON) {
1089 rvi->railveh_type = RAILVEH_SINGLEHEAD;
1090 }
1091 } else {
1092 rvi->railveh_type = RAILVEH_WAGON;
1093 }
1094 break;
1095
1096 case PROP_TRAIN_RUNNING_COST_FACTOR: // 0x0D Running cost factor
1097 rvi->running_cost = buf->ReadByte();
1098 break;
1099
1100 case 0x0E: // Running cost base
1101 ConvertTTDBasePrice(buf->ReadDWord(), "RailVehicleChangeInfo", &rvi->running_cost_class);
1102 break;
1103
1104 case 0x12: { // Sprite ID
1105 uint8_t spriteid = buf->ReadByte();
1106 uint8_t orig_spriteid = spriteid;
1107
1108 /* TTD sprite IDs point to a location in a 16bit array, but we use it
1109 * as an array index, so we need it to be half the original value. */
1110 if (spriteid < 0xFD) spriteid >>= 1;
1111
1112 if (IsValidNewGRFImageIndex<VEH_TRAIN>(spriteid)) {
1113 rvi->image_index = spriteid;
1114 } else {
1115 GrfMsg(1, "RailVehicleChangeInfo: Invalid Sprite {} specified, ignoring", orig_spriteid);
1116 rvi->image_index = 0;
1117 }
1118 break;
1119 }
1120
1121 case 0x13: { // Dual-headed
1122 uint8_t dual = buf->ReadByte();
1123
1124 if (dual != 0) {
1125 rvi->railveh_type = RAILVEH_MULTIHEAD;
1126 } else {
1127 rvi->railveh_type = rvi->power == 0 ?
1128 RAILVEH_WAGON : RAILVEH_SINGLEHEAD;
1129 }
1130 break;
1131 }
1132
1133 case PROP_TRAIN_CARGO_CAPACITY: // 0x14 Cargo capacity
1134 rvi->capacity = buf->ReadByte();
1135 break;
1136
1137 case 0x15: { // Cargo type
1138 _gted[e->index].defaultcargo_grf = _cur.grffile;
1139 uint8_t ctype = buf->ReadByte();
1140
1141 if (ctype == 0xFF) {
1142 /* 0xFF is specified as 'use first refittable' */
1143 ei->cargo_type = INVALID_CARGO;
1144 } else if (_cur.grffile->grf_version >= 8) {
1145 /* Use translated cargo. Might result in INVALID_CARGO (first refittable), if cargo is not defined. */
1146 ei->cargo_type = GetCargoTranslation(ctype, _cur.grffile);
1147 } else if (ctype < NUM_CARGO) {
1148 /* Use untranslated cargo. */
1149 ei->cargo_type = ctype;
1150 } else {
1151 ei->cargo_type = INVALID_CARGO;
1152 GrfMsg(2, "RailVehicleChangeInfo: Invalid cargo type {}, using first refittable", ctype);
1153 }
1154 ei->cargo_label = CT_INVALID;
1155 break;
1156 }
1157
1158 case PROP_TRAIN_WEIGHT: // 0x16 Weight
1159 SB(rvi->weight, 0, 8, buf->ReadByte());
1160 break;
1161
1162 case PROP_TRAIN_COST_FACTOR: // 0x17 Cost factor
1163 rvi->cost_factor = buf->ReadByte();
1164 break;
1165
1166 case 0x18: // AI rank
1167 GrfMsg(2, "RailVehicleChangeInfo: Property 0x18 'AI rank' not used by NoAI, ignored.");
1168 buf->ReadByte();
1169 break;
1170
1171 case 0x19: { // Engine traction type
1172 /* What do the individual numbers mean?
1173 * 0x00 .. 0x07: Steam
1174 * 0x08 .. 0x27: Diesel
1175 * 0x28 .. 0x31: Electric
1176 * 0x32 .. 0x37: Monorail
1177 * 0x38 .. 0x41: Maglev
1178 */
1179 uint8_t traction = buf->ReadByte();
1180 EngineClass engclass;
1181
1182 if (traction <= 0x07) {
1183 engclass = EC_STEAM;
1184 } else if (traction <= 0x27) {
1185 engclass = EC_DIESEL;
1186 } else if (traction <= 0x31) {
1187 engclass = EC_ELECTRIC;
1188 } else if (traction <= 0x37) {
1189 engclass = EC_MONORAIL;
1190 } else if (traction <= 0x41) {
1191 engclass = EC_MAGLEV;
1192 } else {
1193 break;
1194 }
1195
1196 if (_cur.grffile->railtype_list.empty()) {
1197 /* Use traction type to select between normal and electrified
1198 * rail only when no translation list is in place. */
1199 if (_gted[e->index].railtypelabel == RAILTYPE_LABEL_RAIL && engclass >= EC_ELECTRIC) _gted[e->index].railtypelabel = RAILTYPE_LABEL_ELECTRIC;
1200 if (_gted[e->index].railtypelabel == RAILTYPE_LABEL_ELECTRIC && engclass < EC_ELECTRIC) _gted[e->index].railtypelabel = RAILTYPE_LABEL_RAIL;
1201 }
1202
1203 rvi->engclass = engclass;
1204 break;
1205 }
1206
1207 case 0x1A: // Alter purchase list sort order
1208 AlterVehicleListOrder(e->index, buf->ReadExtendedByte());
1209 break;
1210
1211 case 0x1B: // Powered wagons power bonus
1212 rvi->pow_wag_power = buf->ReadWord();
1213 break;
1214
1215 case 0x1C: // Refit cost
1216 ei->refit_cost = buf->ReadByte();
1217 break;
1218
1219 case 0x1D: { // Refit cargo
1220 uint32_t mask = buf->ReadDWord();
1221 _gted[e->index].UpdateRefittability(mask != 0);
1222 ei->refit_mask = TranslateRefitMask(mask);
1223 _gted[e->index].defaultcargo_grf = _cur.grffile;
1224 break;
1225 }
1226
1227 case 0x1E: // Callback
1228 SB(ei->callback_mask, 0, 8, buf->ReadByte());
1229 break;
1230
1231 case PROP_TRAIN_TRACTIVE_EFFORT: // 0x1F Tractive effort coefficient
1232 rvi->tractive_effort = buf->ReadByte();
1233 break;
1234
1235 case 0x20: // Air drag
1236 rvi->air_drag = buf->ReadByte();
1237 break;
1238
1239 case PROP_TRAIN_SHORTEN_FACTOR: // 0x21 Shorter vehicle
1240 rvi->shorten_factor = buf->ReadByte();
1241 break;
1242
1243 case 0x22: // Visual effect
1244 rvi->visual_effect = buf->ReadByte();
1245 /* Avoid accidentally setting visual_effect to the default value
1246 * Since bit 6 (disable effects) is set anyways, we can safely erase some bits. */
1247 if (rvi->visual_effect == VE_DEFAULT) {
1248 assert(HasBit(rvi->visual_effect, VE_DISABLE_EFFECT));
1249 SB(rvi->visual_effect, VE_TYPE_START, VE_TYPE_COUNT, 0);
1250 }
1251 break;
1252
1253 case 0x23: // Powered wagons weight bonus
1254 rvi->pow_wag_weight = buf->ReadByte();
1255 break;
1256
1257 case 0x24: { // High byte of vehicle weight
1258 byte weight = buf->ReadByte();
1259
1260 if (weight > 4) {
1261 GrfMsg(2, "RailVehicleChangeInfo: Nonsensical weight of {} tons, ignoring", weight << 8);
1262 } else {
1263 SB(rvi->weight, 8, 8, weight);
1264 }
1265 break;
1266 }
1267
1268 case PROP_TRAIN_USER_DATA: // 0x25 User-defined bit mask to set when checking veh. var. 42
1269 rvi->user_def_data = buf->ReadByte();
1270 break;
1271
1272 case 0x26: // Retire vehicle early
1273 ei->retire_early = buf->ReadByte();
1274 break;
1275
1276 case 0x27: // Miscellaneous flags
1277 ei->misc_flags = buf->ReadByte();
1278 _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
1279 break;
1280
1281 case 0x28: // Cargo classes allowed
1282 _gted[e->index].cargo_allowed = buf->ReadWord();
1283 _gted[e->index].UpdateRefittability(_gted[e->index].cargo_allowed != 0);
1284 _gted[e->index].defaultcargo_grf = _cur.grffile;
1285 break;
1286
1287 case 0x29: // Cargo classes disallowed
1288 _gted[e->index].cargo_disallowed = buf->ReadWord();
1289 _gted[e->index].UpdateRefittability(false);
1290 break;
1291
1292 case 0x2A: // Long format introduction date (days since year 0)
1293 ei->base_intro = buf->ReadDWord();
1294 break;
1295
1296 case PROP_TRAIN_CARGO_AGE_PERIOD: // 0x2B Cargo aging period
1297 ei->cargo_age_period = buf->ReadWord();
1298 break;
1299
1300 case 0x2C: // CTT refit include list
1301 case 0x2D: { // CTT refit exclude list
1302 uint8_t count = buf->ReadByte();
1303 _gted[e->index].UpdateRefittability(prop == 0x2C && count != 0);
1304 if (prop == 0x2C) _gted[e->index].defaultcargo_grf = _cur.grffile;
1305 CargoTypes &ctt = prop == 0x2C ? _gted[e->index].ctt_include_mask : _gted[e->index].ctt_exclude_mask;
1306 ctt = 0;
1307 while (count--) {
1308 CargoID ctype = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
1309 if (IsValidCargoID(ctype)) SetBit(ctt, ctype);
1310 }
1311 break;
1312 }
1313
1314 case PROP_TRAIN_CURVE_SPEED_MOD: // 0x2E Curve speed modifier
1315 rvi->curve_speed_mod = buf->ReadWord();
1316 break;
1317
1318 case 0x2F: // Engine variant
1319 ei->variant_id = buf->ReadWord();
1320 break;
1321
1322 case 0x30: // Extra miscellaneous flags
1323 ei->extra_flags = static_cast<ExtraEngineFlags>(buf->ReadDWord());
1324 break;
1325
1326 case 0x31: // Callback additional mask
1327 SB(ei->callback_mask, 8, 8, buf->ReadByte());
1328 break;
1329
1330 default:
1331 ret = CommonVehicleChangeInfo(ei, prop, buf);
1332 break;
1333 }
1334 }
1335
1336 return ret;
1337 }
1338
1347 static ChangeInfoResult RoadVehicleChangeInfo(uint engine, int numinfo, int prop, ByteReader *buf)
1348 {
1349 ChangeInfoResult ret = CIR_SUCCESS;
1350
1351 for (int i = 0; i < numinfo; i++) {
1352 Engine *e = GetNewEngine(_cur.grffile, VEH_ROAD, engine + i);
1353 if (e == nullptr) return CIR_INVALID_ID; // No engine could be allocated, so neither can any next vehicles
1354
1355 EngineInfo *ei = &e->info;
1356 RoadVehicleInfo *rvi = &e->u.road;
1357
1358 switch (prop) {
1359 case 0x05: // Road/tram type
1360 /* RoadTypeLabel is looked up later after the engine's road/tram
1361 * flag is set, however 0 means the value has not been set. */
1362 _gted[e->index].roadtramtype = buf->ReadByte() + 1;
1363 break;
1364
1365 case 0x08: // Speed (1 unit is 0.5 kmh)
1366 rvi->max_speed = buf->ReadByte();
1367 break;
1368
1369 case PROP_ROADVEH_RUNNING_COST_FACTOR: // 0x09 Running cost factor
1370 rvi->running_cost = buf->ReadByte();
1371 break;
1372
1373 case 0x0A: // Running cost base
1374 ConvertTTDBasePrice(buf->ReadDWord(), "RoadVehicleChangeInfo", &rvi->running_cost_class);
1375 break;
1376
1377 case 0x0E: { // Sprite ID
1378 uint8_t spriteid = buf->ReadByte();
1379 uint8_t orig_spriteid = spriteid;
1380
1381 /* cars have different custom id in the GRF file */
1382 if (spriteid == 0xFF) spriteid = 0xFD;
1383
1384 if (spriteid < 0xFD) spriteid >>= 1;
1385
1386 if (IsValidNewGRFImageIndex<VEH_ROAD>(spriteid)) {
1387 rvi->image_index = spriteid;
1388 } else {
1389 GrfMsg(1, "RoadVehicleChangeInfo: Invalid Sprite {} specified, ignoring", orig_spriteid);
1390 rvi->image_index = 0;
1391 }
1392 break;
1393 }
1394
1395 case PROP_ROADVEH_CARGO_CAPACITY: // 0x0F Cargo capacity
1396 rvi->capacity = buf->ReadByte();
1397 break;
1398
1399 case 0x10: { // Cargo type
1400 _gted[e->index].defaultcargo_grf = _cur.grffile;
1401 uint8_t ctype = buf->ReadByte();
1402
1403 if (ctype == 0xFF) {
1404 /* 0xFF is specified as 'use first refittable' */
1405 ei->cargo_type = INVALID_CARGO;
1406 } else if (_cur.grffile->grf_version >= 8) {
1407 /* Use translated cargo. Might result in INVALID_CARGO (first refittable), if cargo is not defined. */
1408 ei->cargo_type = GetCargoTranslation(ctype, _cur.grffile);
1409 } else if (ctype < NUM_CARGO) {
1410 /* Use untranslated cargo. */
1411 ei->cargo_type = ctype;
1412 } else {
1413 ei->cargo_type = INVALID_CARGO;
1414 GrfMsg(2, "RailVehicleChangeInfo: Invalid cargo type {}, using first refittable", ctype);
1415 }
1416 ei->cargo_label = CT_INVALID;
1417 break;
1418 }
1419
1420 case PROP_ROADVEH_COST_FACTOR: // 0x11 Cost factor
1421 rvi->cost_factor = buf->ReadByte();
1422 break;
1423
1424 case 0x12: // SFX
1425 rvi->sfx = GetNewGRFSoundID(_cur.grffile, buf->ReadByte());
1426 break;
1427
1428 case PROP_ROADVEH_POWER: // Power in units of 10 HP.
1429 rvi->power = buf->ReadByte();
1430 break;
1431
1432 case PROP_ROADVEH_WEIGHT: // Weight in units of 1/4 tons.
1433 rvi->weight = buf->ReadByte();
1434 break;
1435
1436 case PROP_ROADVEH_SPEED: // Speed in mph/0.8
1437 _gted[e->index].rv_max_speed = buf->ReadByte();
1438 break;
1439
1440 case 0x16: { // Cargoes available for refitting
1441 uint32_t mask = buf->ReadDWord();
1442 _gted[e->index].UpdateRefittability(mask != 0);
1443 ei->refit_mask = TranslateRefitMask(mask);
1444 _gted[e->index].defaultcargo_grf = _cur.grffile;
1445 break;
1446 }
1447
1448 case 0x17: // Callback mask
1449 SB(ei->callback_mask, 0, 8, buf->ReadByte());
1450 break;
1451
1452 case PROP_ROADVEH_TRACTIVE_EFFORT: // Tractive effort coefficient in 1/256.
1453 rvi->tractive_effort = buf->ReadByte();
1454 break;
1455
1456 case 0x19: // Air drag
1457 rvi->air_drag = buf->ReadByte();
1458 break;
1459
1460 case 0x1A: // Refit cost
1461 ei->refit_cost = buf->ReadByte();
1462 break;
1463
1464 case 0x1B: // Retire vehicle early
1465 ei->retire_early = buf->ReadByte();
1466 break;
1467
1468 case 0x1C: // Miscellaneous flags
1469 ei->misc_flags = buf->ReadByte();
1470 _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
1471 break;
1472
1473 case 0x1D: // Cargo classes allowed
1474 _gted[e->index].cargo_allowed = buf->ReadWord();
1475 _gted[e->index].UpdateRefittability(_gted[e->index].cargo_allowed != 0);
1476 _gted[e->index].defaultcargo_grf = _cur.grffile;
1477 break;
1478
1479 case 0x1E: // Cargo classes disallowed
1480 _gted[e->index].cargo_disallowed = buf->ReadWord();
1481 _gted[e->index].UpdateRefittability(false);
1482 break;
1483
1484 case 0x1F: // Long format introduction date (days since year 0)
1485 ei->base_intro = buf->ReadDWord();
1486 break;
1487
1488 case 0x20: // Alter purchase list sort order
1489 AlterVehicleListOrder(e->index, buf->ReadExtendedByte());
1490 break;
1491
1492 case 0x21: // Visual effect
1493 rvi->visual_effect = buf->ReadByte();
1494 /* Avoid accidentally setting visual_effect to the default value
1495 * Since bit 6 (disable effects) is set anyways, we can safely erase some bits. */
1496 if (rvi->visual_effect == VE_DEFAULT) {
1497 assert(HasBit(rvi->visual_effect, VE_DISABLE_EFFECT));
1498 SB(rvi->visual_effect, VE_TYPE_START, VE_TYPE_COUNT, 0);
1499 }
1500 break;
1501
1502 case PROP_ROADVEH_CARGO_AGE_PERIOD: // 0x22 Cargo aging period
1503 ei->cargo_age_period = buf->ReadWord();
1504 break;
1505
1506 case PROP_ROADVEH_SHORTEN_FACTOR: // 0x23 Shorter vehicle
1507 rvi->shorten_factor = buf->ReadByte();
1508 break;
1509
1510 case 0x24: // CTT refit include list
1511 case 0x25: { // CTT refit exclude list
1512 uint8_t count = buf->ReadByte();
1513 _gted[e->index].UpdateRefittability(prop == 0x24 && count != 0);
1514 if (prop == 0x24) _gted[e->index].defaultcargo_grf = _cur.grffile;
1515 CargoTypes &ctt = prop == 0x24 ? _gted[e->index].ctt_include_mask : _gted[e->index].ctt_exclude_mask;
1516 ctt = 0;
1517 while (count--) {
1518 CargoID ctype = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
1519 if (IsValidCargoID(ctype)) SetBit(ctt, ctype);
1520 }
1521 break;
1522 }
1523
1524 case 0x26: // Engine variant
1525 ei->variant_id = buf->ReadWord();
1526 break;
1527
1528 case 0x27: // Extra miscellaneous flags
1529 ei->extra_flags = static_cast<ExtraEngineFlags>(buf->ReadDWord());
1530 break;
1531
1532 case 0x28: // Callback additional mask
1533 SB(ei->callback_mask, 8, 8, buf->ReadByte());
1534 break;
1535
1536 default:
1537 ret = CommonVehicleChangeInfo(ei, prop, buf);
1538 break;
1539 }
1540 }
1541
1542 return ret;
1543 }
1544
1553 static ChangeInfoResult ShipVehicleChangeInfo(uint engine, int numinfo, int prop, ByteReader *buf)
1554 {
1555 ChangeInfoResult ret = CIR_SUCCESS;
1556
1557 for (int i = 0; i < numinfo; i++) {
1558 Engine *e = GetNewEngine(_cur.grffile, VEH_SHIP, engine + i);
1559 if (e == nullptr) return CIR_INVALID_ID; // No engine could be allocated, so neither can any next vehicles
1560
1561 EngineInfo *ei = &e->info;
1562 ShipVehicleInfo *svi = &e->u.ship;
1563
1564 switch (prop) {
1565 case 0x08: { // Sprite ID
1566 uint8_t spriteid = buf->ReadByte();
1567 uint8_t orig_spriteid = spriteid;
1568
1569 /* ships have different custom id in the GRF file */
1570 if (spriteid == 0xFF) spriteid = 0xFD;
1571
1572 if (spriteid < 0xFD) spriteid >>= 1;
1573
1574 if (IsValidNewGRFImageIndex<VEH_SHIP>(spriteid)) {
1575 svi->image_index = spriteid;
1576 } else {
1577 GrfMsg(1, "ShipVehicleChangeInfo: Invalid Sprite {} specified, ignoring", orig_spriteid);
1578 svi->image_index = 0;
1579 }
1580 break;
1581 }
1582
1583 case 0x09: // Refittable
1584 svi->old_refittable = (buf->ReadByte() != 0);
1585 break;
1586
1587 case PROP_SHIP_COST_FACTOR: // 0x0A Cost factor
1588 svi->cost_factor = buf->ReadByte();
1589 break;
1590
1591 case PROP_SHIP_SPEED: // 0x0B Speed (1 unit is 0.5 km-ish/h). Use 0x23 to achieve higher speeds.
1592 svi->max_speed = buf->ReadByte();
1593 break;
1594
1595 case 0x0C: { // Cargo type
1596 _gted[e->index].defaultcargo_grf = _cur.grffile;
1597 uint8_t ctype = buf->ReadByte();
1598
1599 if (ctype == 0xFF) {
1600 /* 0xFF is specified as 'use first refittable' */
1601 ei->cargo_type = INVALID_CARGO;
1602 } else if (_cur.grffile->grf_version >= 8) {
1603 /* Use translated cargo. Might result in INVALID_CARGO (first refittable), if cargo is not defined. */
1604 ei->cargo_type = GetCargoTranslation(ctype, _cur.grffile);
1605 } else if (ctype < NUM_CARGO) {
1606 /* Use untranslated cargo. */
1607 ei->cargo_type = ctype;
1608 } else {
1609 ei->cargo_type = INVALID_CARGO;
1610 GrfMsg(2, "ShipVehicleChangeInfo: Invalid cargo type {}, using first refittable", ctype);
1611 }
1612 ei->cargo_label = CT_INVALID;
1613 break;
1614 }
1615
1616 case PROP_SHIP_CARGO_CAPACITY: // 0x0D Cargo capacity
1617 svi->capacity = buf->ReadWord();
1618 break;
1619
1620 case PROP_SHIP_RUNNING_COST_FACTOR: // 0x0F Running cost factor
1621 svi->running_cost = buf->ReadByte();
1622 break;
1623
1624 case 0x10: // SFX
1625 svi->sfx = GetNewGRFSoundID(_cur.grffile, buf->ReadByte());
1626 break;
1627
1628 case 0x11: { // Cargoes available for refitting
1629 uint32_t mask = buf->ReadDWord();
1630 _gted[e->index].UpdateRefittability(mask != 0);
1631 ei->refit_mask = TranslateRefitMask(mask);
1632 _gted[e->index].defaultcargo_grf = _cur.grffile;
1633 break;
1634 }
1635
1636 case 0x12: // Callback mask
1637 SB(ei->callback_mask, 0, 8, buf->ReadByte());
1638 break;
1639
1640 case 0x13: // Refit cost
1641 ei->refit_cost = buf->ReadByte();
1642 break;
1643
1644 case 0x14: // Ocean speed fraction
1645 svi->ocean_speed_frac = buf->ReadByte();
1646 break;
1647
1648 case 0x15: // Canal speed fraction
1649 svi->canal_speed_frac = buf->ReadByte();
1650 break;
1651
1652 case 0x16: // Retire vehicle early
1653 ei->retire_early = buf->ReadByte();
1654 break;
1655
1656 case 0x17: // Miscellaneous flags
1657 ei->misc_flags = buf->ReadByte();
1658 _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
1659 break;
1660
1661 case 0x18: // Cargo classes allowed
1662 _gted[e->index].cargo_allowed = buf->ReadWord();
1663 _gted[e->index].UpdateRefittability(_gted[e->index].cargo_allowed != 0);
1664 _gted[e->index].defaultcargo_grf = _cur.grffile;
1665 break;
1666
1667 case 0x19: // Cargo classes disallowed
1668 _gted[e->index].cargo_disallowed = buf->ReadWord();
1669 _gted[e->index].UpdateRefittability(false);
1670 break;
1671
1672 case 0x1A: // Long format introduction date (days since year 0)
1673 ei->base_intro = buf->ReadDWord();
1674 break;
1675
1676 case 0x1B: // Alter purchase list sort order
1677 AlterVehicleListOrder(e->index, buf->ReadExtendedByte());
1678 break;
1679
1680 case 0x1C: // Visual effect
1681 svi->visual_effect = buf->ReadByte();
1682 /* Avoid accidentally setting visual_effect to the default value
1683 * Since bit 6 (disable effects) is set anyways, we can safely erase some bits. */
1684 if (svi->visual_effect == VE_DEFAULT) {
1685 assert(HasBit(svi->visual_effect, VE_DISABLE_EFFECT));
1686 SB(svi->visual_effect, VE_TYPE_START, VE_TYPE_COUNT, 0);
1687 }
1688 break;
1689
1690 case PROP_SHIP_CARGO_AGE_PERIOD: // 0x1D Cargo aging period
1691 ei->cargo_age_period = buf->ReadWord();
1692 break;
1693
1694 case 0x1E: // CTT refit include list
1695 case 0x1F: { // CTT refit exclude list
1696 uint8_t count = buf->ReadByte();
1697 _gted[e->index].UpdateRefittability(prop == 0x1E && count != 0);
1698 if (prop == 0x1E) _gted[e->index].defaultcargo_grf = _cur.grffile;
1699 CargoTypes &ctt = prop == 0x1E ? _gted[e->index].ctt_include_mask : _gted[e->index].ctt_exclude_mask;
1700 ctt = 0;
1701 while (count--) {
1702 CargoID ctype = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
1703 if (IsValidCargoID(ctype)) SetBit(ctt, ctype);
1704 }
1705 break;
1706 }
1707
1708 case 0x20: // Engine variant
1709 ei->variant_id = buf->ReadWord();
1710 break;
1711
1712 case 0x21: // Extra miscellaneous flags
1713 ei->extra_flags = static_cast<ExtraEngineFlags>(buf->ReadDWord());
1714 break;
1715
1716 case 0x22: // Callback additional mask
1717 SB(ei->callback_mask, 8, 8, buf->ReadByte());
1718 break;
1719
1720 case 0x23: // Speed (1 unit is 0.5 km-ish/h)
1721 svi->max_speed = buf->ReadWord();
1722 break;
1723
1724 case 0x24: // Acceleration (1 unit is 0.5 km-ish/h per tick)
1725 svi->acceleration = std::max<uint8_t>(1, buf->ReadByte());
1726 break;
1727
1728 default:
1729 ret = CommonVehicleChangeInfo(ei, prop, buf);
1730 break;
1731 }
1732 }
1733
1734 return ret;
1735 }
1736
1745 static ChangeInfoResult AircraftVehicleChangeInfo(uint engine, int numinfo, int prop, ByteReader *buf)
1746 {
1747 ChangeInfoResult ret = CIR_SUCCESS;
1748
1749 for (int i = 0; i < numinfo; i++) {
1750 Engine *e = GetNewEngine(_cur.grffile, VEH_AIRCRAFT, engine + i);
1751 if (e == nullptr) return CIR_INVALID_ID; // No engine could be allocated, so neither can any next vehicles
1752
1753 EngineInfo *ei = &e->info;
1754 AircraftVehicleInfo *avi = &e->u.air;
1755
1756 switch (prop) {
1757 case 0x08: { // Sprite ID
1758 uint8_t spriteid = buf->ReadByte();
1759 uint8_t orig_spriteid = spriteid;
1760
1761 /* aircraft have different custom id in the GRF file */
1762 if (spriteid == 0xFF) spriteid = 0xFD;
1763
1764 if (spriteid < 0xFD) spriteid >>= 1;
1765
1766 if (IsValidNewGRFImageIndex<VEH_AIRCRAFT>(spriteid)) {
1767 avi->image_index = spriteid;
1768 } else {
1769 GrfMsg(1, "AircraftVehicleChangeInfo: Invalid Sprite {} specified, ignoring", orig_spriteid);
1770 avi->image_index = 0;
1771 }
1772 break;
1773 }
1774
1775 case 0x09: // Helicopter
1776 if (buf->ReadByte() == 0) {
1777 avi->subtype = AIR_HELI;
1778 } else {
1779 SB(avi->subtype, 0, 1, 1); // AIR_CTOL
1780 }
1781 break;
1782
1783 case 0x0A: // Large
1784 SB(avi->subtype, 1, 1, (buf->ReadByte() != 0 ? 1 : 0)); // AIR_FAST
1785 break;
1786
1787 case PROP_AIRCRAFT_COST_FACTOR: // 0x0B Cost factor
1788 avi->cost_factor = buf->ReadByte();
1789 break;
1790
1791 case PROP_AIRCRAFT_SPEED: // 0x0C Speed (1 unit is 8 mph, we translate to 1 unit is 1 km-ish/h)
1792 avi->max_speed = (buf->ReadByte() * 128) / 10;
1793 break;
1794
1795 case 0x0D: // Acceleration
1796 avi->acceleration = buf->ReadByte();
1797 break;
1798
1799 case PROP_AIRCRAFT_RUNNING_COST_FACTOR: // 0x0E Running cost factor
1800 avi->running_cost = buf->ReadByte();
1801 break;
1802
1803 case PROP_AIRCRAFT_PASSENGER_CAPACITY: // 0x0F Passenger capacity
1804 avi->passenger_capacity = buf->ReadWord();
1805 break;
1806
1807 case PROP_AIRCRAFT_MAIL_CAPACITY: // 0x11 Mail capacity
1808 avi->mail_capacity = buf->ReadByte();
1809 break;
1810
1811 case 0x12: // SFX
1812 avi->sfx = GetNewGRFSoundID(_cur.grffile, buf->ReadByte());
1813 break;
1814
1815 case 0x13: { // Cargoes available for refitting
1816 uint32_t mask = buf->ReadDWord();
1817 _gted[e->index].UpdateRefittability(mask != 0);
1818 ei->refit_mask = TranslateRefitMask(mask);
1819 _gted[e->index].defaultcargo_grf = _cur.grffile;
1820 break;
1821 }
1822
1823 case 0x14: // Callback mask
1824 SB(ei->callback_mask, 0, 8, buf->ReadByte());
1825 break;
1826
1827 case 0x15: // Refit cost
1828 ei->refit_cost = buf->ReadByte();
1829 break;
1830
1831 case 0x16: // Retire vehicle early
1832 ei->retire_early = buf->ReadByte();
1833 break;
1834
1835 case 0x17: // Miscellaneous flags
1836 ei->misc_flags = buf->ReadByte();
1837 _loaded_newgrf_features.has_2CC |= HasBit(ei->misc_flags, EF_USES_2CC);
1838 break;
1839
1840 case 0x18: // Cargo classes allowed
1841 _gted[e->index].cargo_allowed = buf->ReadWord();
1842 _gted[e->index].UpdateRefittability(_gted[e->index].cargo_allowed != 0);
1843 _gted[e->index].defaultcargo_grf = _cur.grffile;
1844 break;
1845
1846 case 0x19: // Cargo classes disallowed
1847 _gted[e->index].cargo_disallowed = buf->ReadWord();
1848 _gted[e->index].UpdateRefittability(false);
1849 break;
1850
1851 case 0x1A: // Long format introduction date (days since year 0)
1852 ei->base_intro = buf->ReadDWord();
1853 break;
1854
1855 case 0x1B: // Alter purchase list sort order
1856 AlterVehicleListOrder(e->index, buf->ReadExtendedByte());
1857 break;
1858
1859 case PROP_AIRCRAFT_CARGO_AGE_PERIOD: // 0x1C Cargo aging period
1860 ei->cargo_age_period = buf->ReadWord();
1861 break;
1862
1863 case 0x1D: // CTT refit include list
1864 case 0x1E: { // CTT refit exclude list
1865 uint8_t count = buf->ReadByte();
1866 _gted[e->index].UpdateRefittability(prop == 0x1D && count != 0);
1867 if (prop == 0x1D) _gted[e->index].defaultcargo_grf = _cur.grffile;
1868 CargoTypes &ctt = prop == 0x1D ? _gted[e->index].ctt_include_mask : _gted[e->index].ctt_exclude_mask;
1869 ctt = 0;
1870 while (count--) {
1871 CargoID ctype = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
1872 if (IsValidCargoID(ctype)) SetBit(ctt, ctype);
1873 }
1874 break;
1875 }
1876
1877 case PROP_AIRCRAFT_RANGE: // 0x1F Max aircraft range
1878 avi->max_range = buf->ReadWord();
1879 break;
1880
1881 case 0x20: // Engine variant
1882 ei->variant_id = buf->ReadWord();
1883 break;
1884
1885 case 0x21: // Extra miscellaneous flags
1886 ei->extra_flags = static_cast<ExtraEngineFlags>(buf->ReadDWord());
1887 break;
1888
1889 case 0x22: // Callback additional mask
1890 SB(ei->callback_mask, 8, 8, buf->ReadByte());
1891 break;
1892
1893 default:
1894 ret = CommonVehicleChangeInfo(ei, prop, buf);
1895 break;
1896 }
1897 }
1898
1899 return ret;
1900 }
1901
1910 static ChangeInfoResult StationChangeInfo(uint stid, int numinfo, int prop, ByteReader *buf)
1911 {
1912 ChangeInfoResult ret = CIR_SUCCESS;
1913
1914 if (stid + numinfo > NUM_STATIONS_PER_GRF) {
1915 GrfMsg(1, "StationChangeInfo: Station {} is invalid, max {}, ignoring", stid + numinfo, NUM_STATIONS_PER_GRF);
1916 return CIR_INVALID_ID;
1917 }
1918
1919 /* Allocate station specs if necessary */
1920 if (_cur.grffile->stations.size() < stid + numinfo) _cur.grffile->stations.resize(stid + numinfo);
1921
1922 for (int i = 0; i < numinfo; i++) {
1923 StationSpec *statspec = _cur.grffile->stations[stid + i].get();
1924
1925 /* Check that the station we are modifying is defined. */
1926 if (statspec == nullptr && prop != 0x08) {
1927 GrfMsg(2, "StationChangeInfo: Attempt to modify undefined station {}, ignoring", stid + i);
1928 return CIR_INVALID_ID;
1929 }
1930
1931 switch (prop) {
1932 case 0x08: { // Class ID
1933 /* Property 0x08 is special; it is where the station is allocated */
1934 if (statspec == nullptr) {
1935 _cur.grffile->stations[stid + i] = std::make_unique<StationSpec>();
1936 statspec = _cur.grffile->stations[stid + i].get();
1937 }
1938
1939 /* Swap classid because we read it in BE meaning WAYP or DFLT */
1940 uint32_t classid = buf->ReadDWord();
1941 statspec->cls_id = StationClass::Allocate(BSWAP32(classid));
1942 break;
1943 }
1944
1945 case 0x09: { // Define sprite layout
1946 uint16_t tiles = buf->ReadExtendedByte();
1947 statspec->renderdata.clear(); // delete earlier loaded stuff
1948 statspec->renderdata.reserve(tiles);
1949
1950 for (uint t = 0; t < tiles; t++) {
1951 NewGRFSpriteLayout *dts = &statspec->renderdata.emplace_back();
1952 dts->consistent_max_offset = UINT16_MAX; // Spritesets are unknown, so no limit.
1953
1954 if (buf->HasData(4) && *(uint32_t*)buf->Data() == 0) {
1955 buf->Skip(4);
1956 extern const DrawTileSprites _station_display_datas_rail[8];
1957 dts->Clone(&_station_display_datas_rail[t % 8]);
1958 continue;
1959 }
1960
1961 ReadSpriteLayoutSprite(buf, false, false, false, GSF_STATIONS, &dts->ground);
1962 /* On error, bail out immediately. Temporary GRF data was already freed */
1963 if (_cur.skip_sprites < 0) return CIR_DISABLED;
1964
1965 static std::vector<DrawTileSeqStruct> tmp_layout;
1966 tmp_layout.clear();
1967 for (;;) {
1968 /* no relative bounding box support */
1969 DrawTileSeqStruct &dtss = tmp_layout.emplace_back();
1970 MemSetT(&dtss, 0);
1971
1972 dtss.delta_x = buf->ReadByte();
1973 if (dtss.IsTerminator()) break;
1974 dtss.delta_y = buf->ReadByte();
1975 dtss.delta_z = buf->ReadByte();
1976 dtss.size_x = buf->ReadByte();
1977 dtss.size_y = buf->ReadByte();
1978 dtss.size_z = buf->ReadByte();
1979
1980 ReadSpriteLayoutSprite(buf, false, true, false, GSF_STATIONS, &dtss.image);
1981 /* On error, bail out immediately. Temporary GRF data was already freed */
1982 if (_cur.skip_sprites < 0) return CIR_DISABLED;
1983 }
1984 dts->Clone(tmp_layout.data());
1985 }
1986
1987 /* Number of layouts must be even, alternating X and Y */
1988 if (statspec->renderdata.size() & 1) {
1989 GrfMsg(1, "StationChangeInfo: Station {} defines an odd number of sprite layouts, dropping the last item", stid + i);
1990 statspec->renderdata.pop_back();
1991 }
1992 break;
1993 }
1994
1995 case 0x0A: { // Copy sprite layout
1996 uint16_t srcid = buf->ReadExtendedByte();
1997 const StationSpec *srcstatspec = srcid >= _cur.grffile->stations.size() ? nullptr : _cur.grffile->stations[srcid].get();
1998
1999 if (srcstatspec == nullptr) {
2000 GrfMsg(1, "StationChangeInfo: Station {} is not defined, cannot copy sprite layout to {}.", srcid, stid + i);
2001 continue;
2002 }
2003
2004 statspec->renderdata.clear(); // delete earlier loaded stuff
2005 statspec->renderdata.reserve(srcstatspec->renderdata.size());
2006
2007 for (const auto &it : srcstatspec->renderdata) {
2008 NewGRFSpriteLayout *dts = &statspec->renderdata.emplace_back();
2009 dts->Clone(&it);
2010 }
2011 break;
2012 }
2013
2014 case 0x0B: // Callback mask
2015 statspec->callback_mask = buf->ReadByte();
2016 break;
2017
2018 case 0x0C: // Disallowed number of platforms
2019 statspec->disallowed_platforms = buf->ReadByte();
2020 break;
2021
2022 case 0x0D: // Disallowed platform lengths
2023 statspec->disallowed_lengths = buf->ReadByte();
2024 break;
2025
2026 case 0x0E: // Define custom layout
2027 while (buf->HasData()) {
2028 byte length = buf->ReadByte();
2029 byte number = buf->ReadByte();
2030
2031 if (length == 0 || number == 0) break;
2032
2033 if (statspec->layouts.size() < length) statspec->layouts.resize(length);
2034 if (statspec->layouts[length - 1].size() < number) statspec->layouts[length - 1].resize(number);
2035
2036 const byte *layout = buf->ReadBytes(length * number);
2037 statspec->layouts[length - 1][number - 1].assign(layout, layout + length * number);
2038
2039 /* Validate tile values are only the permitted 00, 02, 04 and 06. */
2040 for (auto &tile : statspec->layouts[length - 1][number - 1]) {
2041 if ((tile & 6) != tile) {
2042 GrfMsg(1, "StationChangeInfo: Invalid tile {} in layout {}x{}", tile, length, number);
2043 tile &= 6;
2044 }
2045 }
2046 }
2047 break;
2048
2049 case 0x0F: { // Copy custom layout
2050 uint16_t srcid = buf->ReadExtendedByte();
2051 const StationSpec *srcstatspec = srcid >= _cur.grffile->stations.size() ? nullptr : _cur.grffile->stations[srcid].get();
2052
2053 if (srcstatspec == nullptr) {
2054 GrfMsg(1, "StationChangeInfo: Station {} is not defined, cannot copy tile layout to {}.", srcid, stid + i);
2055 continue;
2056 }
2057
2058 statspec->layouts = srcstatspec->layouts;
2059 break;
2060 }
2061
2062 case 0x10: // Little/lots cargo threshold
2063 statspec->cargo_threshold = buf->ReadWord();
2064 break;
2065
2066 case 0x11: // Pylon placement
2067 statspec->pylons = buf->ReadByte();
2068 break;
2069
2070 case 0x12: // Cargo types for random triggers
2071 if (_cur.grffile->grf_version >= 7) {
2072 statspec->cargo_triggers = TranslateRefitMask(buf->ReadDWord());
2073 } else {
2074 statspec->cargo_triggers = (CargoTypes)buf->ReadDWord();
2075 }
2076 break;
2077
2078 case 0x13: // General flags
2079 statspec->flags = buf->ReadByte();
2080 break;
2081
2082 case 0x14: // Overhead wire placement
2083 statspec->wires = buf->ReadByte();
2084 break;
2085
2086 case 0x15: // Blocked tiles
2087 statspec->blocked = buf->ReadByte();
2088 break;
2089
2090 case 0x16: // Animation info
2091 statspec->animation.frames = buf->ReadByte();
2092 statspec->animation.status = buf->ReadByte();
2093 break;
2094
2095 case 0x17: // Animation speed
2096 statspec->animation.speed = buf->ReadByte();
2097 break;
2098
2099 case 0x18: // Animation triggers
2100 statspec->animation.triggers = buf->ReadWord();
2101 break;
2102
2103 /* 0x19 road routing (not implemented) */
2104
2105 case 0x1A: { // Advanced sprite layout
2106 uint16_t tiles = buf->ReadExtendedByte();
2107 statspec->renderdata.clear(); // delete earlier loaded stuff
2108 statspec->renderdata.reserve(tiles);
2109
2110 for (uint t = 0; t < tiles; t++) {
2111 NewGRFSpriteLayout *dts = &statspec->renderdata.emplace_back();
2112 uint num_building_sprites = buf->ReadByte();
2113 /* On error, bail out immediately. Temporary GRF data was already freed */
2114 if (ReadSpriteLayout(buf, num_building_sprites, false, GSF_STATIONS, true, false, dts)) return CIR_DISABLED;
2115 }
2116
2117 /* Number of layouts must be even, alternating X and Y */
2118 if (statspec->renderdata.size() & 1) {
2119 GrfMsg(1, "StationChangeInfo: Station {} defines an odd number of sprite layouts, dropping the last item", stid + i);
2120 statspec->renderdata.pop_back();
2121 }
2122 break;
2123 }
2124
2125 case 0x1B: // Minimum bridge height (not implemented)
2126 buf->ReadWord();
2127 buf->ReadWord();
2128 buf->ReadWord();
2129 buf->ReadWord();
2130 break;
2131
2132 case 0x1C: // Station Name
2133 AddStringForMapping(buf->ReadWord(), &statspec->name);
2134 break;
2135
2136 case 0x1D: // Station Class name
2137 AddStringForMapping(buf->ReadWord(), &StationClass::Get(statspec->cls_id)->name);
2138 break;
2139
2140 default:
2141 ret = CIR_UNKNOWN;
2142 break;
2143 }
2144 }
2145
2146 return ret;
2147 }
2148
2157 static ChangeInfoResult CanalChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
2158 {
2159 ChangeInfoResult ret = CIR_SUCCESS;
2160
2161 if (id + numinfo > CF_END) {
2162 GrfMsg(1, "CanalChangeInfo: Canal feature 0x{:02X} is invalid, max {}, ignoring", id + numinfo, CF_END);
2163 return CIR_INVALID_ID;
2164 }
2165
2166 for (int i = 0; i < numinfo; i++) {
2167 CanalProperties *cp = &_cur.grffile->canal_local_properties[id + i];
2168
2169 switch (prop) {
2170 case 0x08:
2171 cp->callback_mask = buf->ReadByte();
2172 break;
2173
2174 case 0x09:
2175 cp->flags = buf->ReadByte();
2176 break;
2177
2178 default:
2179 ret = CIR_UNKNOWN;
2180 break;
2181 }
2182 }
2183
2184 return ret;
2185 }
2186
2195 static ChangeInfoResult BridgeChangeInfo(uint brid, int numinfo, int prop, ByteReader *buf)
2196 {
2197 ChangeInfoResult ret = CIR_SUCCESS;
2198
2199 if (brid + numinfo > MAX_BRIDGES) {
2200 GrfMsg(1, "BridgeChangeInfo: Bridge {} is invalid, max {}, ignoring", brid + numinfo, MAX_BRIDGES);
2201 return CIR_INVALID_ID;
2202 }
2203
2204 for (int i = 0; i < numinfo; i++) {
2205 BridgeSpec *bridge = &_bridge[brid + i];
2206
2207 switch (prop) {
2208 case 0x08: { // Year of availability
2209 /* We treat '0' as always available */
2210 byte year = buf->ReadByte();
2211 bridge->avail_year = (year > 0 ? CalendarTime::ORIGINAL_BASE_YEAR + year : 0);
2212 break;
2213 }
2214
2215 case 0x09: // Minimum length
2216 bridge->min_length = buf->ReadByte();
2217 break;
2218
2219 case 0x0A: // Maximum length
2220 bridge->max_length = buf->ReadByte();
2221 if (bridge->max_length > 16) bridge->max_length = UINT16_MAX;
2222 break;
2223
2224 case 0x0B: // Cost factor
2225 bridge->price = buf->ReadByte();
2226 break;
2227
2228 case 0x0C: // Maximum speed
2229 bridge->speed = buf->ReadWord();
2230 if (bridge->speed == 0) bridge->speed = UINT16_MAX;
2231 break;
2232
2233 case 0x0D: { // Bridge sprite tables
2234 byte tableid = buf->ReadByte();
2235 byte numtables = buf->ReadByte();
2236
2237 if (bridge->sprite_table == nullptr) {
2238 /* Allocate memory for sprite table pointers and zero out */
2239 bridge->sprite_table = CallocT<PalSpriteID*>(7);
2240 }
2241
2242 for (; numtables-- != 0; tableid++) {
2243 if (tableid >= 7) { // skip invalid data
2244 GrfMsg(1, "BridgeChangeInfo: Table {} >= 7, skipping", tableid);
2245 for (byte sprite = 0; sprite < 32; sprite++) buf->ReadDWord();
2246 continue;
2247 }
2248
2249 if (bridge->sprite_table[tableid] == nullptr) {
2250 bridge->sprite_table[tableid] = MallocT<PalSpriteID>(32);
2251 }
2252
2253 for (byte sprite = 0; sprite < 32; sprite++) {
2254 SpriteID image = buf->ReadWord();
2255 PaletteID pal = buf->ReadWord();
2256
2257 bridge->sprite_table[tableid][sprite].sprite = image;
2258 bridge->sprite_table[tableid][sprite].pal = pal;
2259
2260 MapSpriteMappingRecolour(&bridge->sprite_table[tableid][sprite]);
2261 }
2262 }
2263 break;
2264 }
2265
2266 case 0x0E: // Flags; bit 0 - disable far pillars
2267 bridge->flags = buf->ReadByte();
2268 break;
2269
2270 case 0x0F: // Long format year of availability (year since year 0)
2271 bridge->avail_year = Clamp(TimerGameCalendar::Year(buf->ReadDWord()), CalendarTime::MIN_YEAR, CalendarTime::MAX_YEAR);
2272 break;
2273
2274 case 0x10: { // purchase string
2275 StringID newone = GetGRFStringID(_cur.grffile->grfid, buf->ReadWord());
2276 if (newone != STR_UNDEFINED) bridge->material = newone;
2277 break;
2278 }
2279
2280 case 0x11: // description of bridge with rails or roads
2281 case 0x12: {
2282 StringID newone = GetGRFStringID(_cur.grffile->grfid, buf->ReadWord());
2283 if (newone != STR_UNDEFINED) bridge->transport_name[prop - 0x11] = newone;
2284 break;
2285 }
2286
2287 case 0x13: // 16 bits cost multiplier
2288 bridge->price = buf->ReadWord();
2289 break;
2290
2291 default:
2292 ret = CIR_UNKNOWN;
2293 break;
2294 }
2295 }
2296
2297 return ret;
2298 }
2299
2306 static ChangeInfoResult IgnoreTownHouseProperty(int prop, ByteReader *buf)
2307 {
2308 ChangeInfoResult ret = CIR_SUCCESS;
2309
2310 switch (prop) {
2311 case 0x09:
2312 case 0x0B:
2313 case 0x0C:
2314 case 0x0D:
2315 case 0x0E:
2316 case 0x0F:
2317 case 0x11:
2318 case 0x14:
2319 case 0x15:
2320 case 0x16:
2321 case 0x18:
2322 case 0x19:
2323 case 0x1A:
2324 case 0x1B:
2325 case 0x1C:
2326 case 0x1D:
2327 case 0x1F:
2328 buf->ReadByte();
2329 break;
2330
2331 case 0x0A:
2332 case 0x10:
2333 case 0x12:
2334 case 0x13:
2335 case 0x21:
2336 case 0x22:
2337 buf->ReadWord();
2338 break;
2339
2340 case 0x1E:
2341 buf->ReadDWord();
2342 break;
2343
2344 case 0x17:
2345 for (uint j = 0; j < 4; j++) buf->ReadByte();
2346 break;
2347
2348 case 0x20: {
2349 byte count = buf->ReadByte();
2350 for (byte j = 0; j < count; j++) buf->ReadByte();
2351 break;
2352 }
2353
2354 case 0x23:
2355 buf->Skip(buf->ReadByte() * 2);
2356 break;
2357
2358 default:
2359 ret = CIR_UNKNOWN;
2360 break;
2361 }
2362 return ret;
2363 }
2364
2373 static ChangeInfoResult TownHouseChangeInfo(uint hid, int numinfo, int prop, ByteReader *buf)
2374 {
2375 ChangeInfoResult ret = CIR_SUCCESS;
2376
2377 if (hid + numinfo > NUM_HOUSES_PER_GRF) {
2378 GrfMsg(1, "TownHouseChangeInfo: Too many houses loaded ({}), max ({}). Ignoring.", hid + numinfo, NUM_HOUSES_PER_GRF);
2379 return CIR_INVALID_ID;
2380 }
2381
2382 /* Allocate house specs if they haven't been allocated already. */
2383 if (_cur.grffile->housespec.size() < hid + numinfo) _cur.grffile->housespec.resize(hid + numinfo);
2384
2385 for (int i = 0; i < numinfo; i++) {
2386 HouseSpec *housespec = _cur.grffile->housespec[hid + i].get();
2387
2388 if (prop != 0x08 && housespec == nullptr) {
2389 /* If the house property 08 is not yet set, ignore this property */
2390 ChangeInfoResult cir = IgnoreTownHouseProperty(prop, buf);
2391 if (cir > ret) ret = cir;
2392 continue;
2393 }
2394
2395 switch (prop) {
2396 case 0x08: { // Substitute building type, and definition of a new house
2397 byte subs_id = buf->ReadByte();
2398 if (subs_id == 0xFF) {
2399 /* Instead of defining a new house, a substitute house id
2400 * of 0xFF disables the old house with the current id. */
2401 if (hid + i < NEW_HOUSE_OFFSET) HouseSpec::Get(hid + i)->enabled = false;
2402 continue;
2403 } else if (subs_id >= NEW_HOUSE_OFFSET) {
2404 /* The substitute id must be one of the original houses. */
2405 GrfMsg(2, "TownHouseChangeInfo: Attempt to use new house {} as substitute house for {}. Ignoring.", subs_id, hid + i);
2406 continue;
2407 }
2408
2409 /* Allocate space for this house. */
2410 if (housespec == nullptr) {
2411 /* Only the first property 08 setting copies properties; if you later change it, properties will stay. */
2412 _cur.grffile->housespec[hid + i] = std::make_unique<HouseSpec>(*HouseSpec::Get(subs_id));
2413 housespec = _cur.grffile->housespec[hid + i].get();
2414
2415 housespec->enabled = true;
2416 housespec->grf_prop.local_id = hid + i;
2417 housespec->grf_prop.subst_id = subs_id;
2418 housespec->grf_prop.grffile = _cur.grffile;
2419 /* Set default colours for randomization, used if not overridden. */
2420 housespec->random_colour[0] = COLOUR_RED;
2421 housespec->random_colour[1] = COLOUR_BLUE;
2422 housespec->random_colour[2] = COLOUR_ORANGE;
2423 housespec->random_colour[3] = COLOUR_GREEN;
2424
2425 /* House flags 40 and 80 are exceptions; these flags are never set automatically. */
2426 housespec->building_flags &= ~(BUILDING_IS_CHURCH | BUILDING_IS_STADIUM);
2427
2428 /* Make sure that the third cargo type is valid in this
2429 * climate. This can cause problems when copying the properties
2430 * of a house that accepts food, where the new house is valid
2431 * in the temperate climate. */
2432 CargoID cid = housespec->accepts_cargo[2];
2433 if (!IsValidCargoID(cid)) cid = GetCargoIDByLabel(housespec->accepts_cargo_label[2]);
2434 if (!IsValidCargoID(cid)) {
2435 housespec->cargo_acceptance[2] = 0;
2436 }
2437 }
2438 break;
2439 }
2440
2441 case 0x09: // Building flags
2442 housespec->building_flags = (BuildingFlags)buf->ReadByte();
2443 break;
2444
2445 case 0x0A: { // Availability years
2446 uint16_t years = buf->ReadWord();
2447 housespec->min_year = GB(years, 0, 8) > 150 ? CalendarTime::MAX_YEAR : CalendarTime::ORIGINAL_BASE_YEAR + GB(years, 0, 8);
2448 housespec->max_year = GB(years, 8, 8) > 150 ? CalendarTime::MAX_YEAR : CalendarTime::ORIGINAL_BASE_YEAR + GB(years, 8, 8);
2449 break;
2450 }
2451
2452 case 0x0B: // Population
2453 housespec->population = buf->ReadByte();
2454 break;
2455
2456 case 0x0C: // Mail generation multiplier
2457 housespec->mail_generation = buf->ReadByte();
2458 break;
2459
2460 case 0x0D: // Passenger acceptance
2461 case 0x0E: // Mail acceptance
2462 housespec->cargo_acceptance[prop - 0x0D] = buf->ReadByte();
2463 break;
2464
2465 case 0x0F: { // Goods/candy, food/fizzy drinks acceptance
2466 int8_t goods = buf->ReadByte();
2467
2468 /* If value of goods is negative, it means in fact food or, if in toyland, fizzy_drink acceptance.
2469 * Else, we have "standard" 3rd cargo type, goods or candy, for toyland once more */
2470 CargoID cid = (goods >= 0) ? ((_settings_game.game_creation.landscape == LT_TOYLAND) ? GetCargoIDByLabel(CT_CANDY) : GetCargoIDByLabel(CT_GOODS)) :
2471 ((_settings_game.game_creation.landscape == LT_TOYLAND) ? GetCargoIDByLabel(CT_FIZZY_DRINKS) : GetCargoIDByLabel(CT_FOOD));
2472
2473 /* Make sure the cargo type is valid in this climate. */
2474 if (!IsValidCargoID(cid)) goods = 0;
2475
2476 housespec->accepts_cargo[2] = cid;
2477 housespec->accepts_cargo_label[2] = CT_INVALID;
2478 housespec->cargo_acceptance[2] = abs(goods); // but we do need positive value here
2479 break;
2480 }
2481
2482 case 0x10: // Local authority rating decrease on removal
2483 housespec->remove_rating_decrease = buf->ReadWord();
2484 break;
2485
2486 case 0x11: // Removal cost multiplier
2487 housespec->removal_cost = buf->ReadByte();
2488 break;
2489
2490 case 0x12: // Building name ID
2491 AddStringForMapping(buf->ReadWord(), &housespec->building_name);
2492 break;
2493
2494 case 0x13: // Building availability mask
2495 housespec->building_availability = (HouseZones)buf->ReadWord();
2496 break;
2497
2498 case 0x14: // House callback mask
2499 housespec->callback_mask |= buf->ReadByte();
2500 break;
2501
2502 case 0x15: { // House override byte
2503 byte override = buf->ReadByte();
2504
2505 /* The house being overridden must be an original house. */
2506 if (override >= NEW_HOUSE_OFFSET) {
2507 GrfMsg(2, "TownHouseChangeInfo: Attempt to override new house {} with house id {}. Ignoring.", override, hid + i);
2508 continue;
2509 }
2510
2511 _house_mngr.Add(hid + i, _cur.grffile->grfid, override);
2512 break;
2513 }
2514
2515 case 0x16: // Periodic refresh multiplier
2516 housespec->processing_time = std::min<byte>(buf->ReadByte(), 63u);
2517 break;
2518
2519 case 0x17: // Four random colours to use
2520 for (uint j = 0; j < 4; j++) housespec->random_colour[j] = static_cast<Colours>(GB(buf->ReadByte(), 0, 4));
2521 break;
2522
2523 case 0x18: // Relative probability of appearing
2524 housespec->probability = buf->ReadByte();
2525 break;
2526
2527 case 0x19: // Extra flags
2528 housespec->extra_flags = (HouseExtraFlags)buf->ReadByte();
2529 break;
2530
2531 case 0x1A: // Animation frames
2532 housespec->animation.frames = buf->ReadByte();
2533 housespec->animation.status = GB(housespec->animation.frames, 7, 1);
2534 SB(housespec->animation.frames, 7, 1, 0);
2535 break;
2536
2537 case 0x1B: // Animation speed
2538 housespec->animation.speed = Clamp(buf->ReadByte(), 2, 16);
2539 break;
2540
2541 case 0x1C: // Class of the building type
2542 housespec->class_id = AllocateHouseClassID(buf->ReadByte(), _cur.grffile->grfid);
2543 break;
2544
2545 case 0x1D: // Callback mask part 2
2546 housespec->callback_mask |= (buf->ReadByte() << 8);
2547 break;
2548
2549 case 0x1E: { // Accepted cargo types
2550 uint32_t cargotypes = buf->ReadDWord();
2551
2552 /* Check if the cargo types should not be changed */
2553 if (cargotypes == 0xFFFFFFFF) break;
2554
2555 for (uint j = 0; j < 3; j++) {
2556 /* Get the cargo number from the 'list' */
2557 uint8_t cargo_part = GB(cargotypes, 8 * j, 8);
2558 CargoID cargo = GetCargoTranslation(cargo_part, _cur.grffile);
2559
2560 if (!IsValidCargoID(cargo)) {
2561 /* Disable acceptance of invalid cargo type */
2562 housespec->cargo_acceptance[j] = 0;
2563 } else {
2564 housespec->accepts_cargo[j] = cargo;
2565 }
2566 housespec->accepts_cargo_label[j] = CT_INVALID;
2567 }
2568 break;
2569 }
2570
2571 case 0x1F: // Minimum life span
2572 housespec->minimum_life = buf->ReadByte();
2573 break;
2574
2575 case 0x20: { // Cargo acceptance watch list
2576 byte count = buf->ReadByte();
2577 for (byte j = 0; j < count; j++) {
2578 CargoID cargo = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
2579 if (IsValidCargoID(cargo)) SetBit(housespec->watched_cargoes, cargo);
2580 }
2581 break;
2582 }
2583
2584 case 0x21: // long introduction year
2585 housespec->min_year = buf->ReadWord();
2586 break;
2587
2588 case 0x22: // long maximum year
2589 housespec->max_year = buf->ReadWord();
2590 break;
2591
2592 case 0x23: { // variable length cargo types accepted
2593 uint count = buf->ReadByte();
2594 if (count > lengthof(housespec->accepts_cargo)) {
2595 GRFError *error = DisableGrf(STR_NEWGRF_ERROR_LIST_PROPERTY_TOO_LONG);
2596 error->param_value[1] = prop;
2597 return CIR_DISABLED;
2598 }
2599 /* Always write the full accepts_cargo array, and check each index for being inside the
2600 * provided data. This ensures all values are properly initialized, and also avoids
2601 * any risks of array overrun. */
2602 for (uint i = 0; i < lengthof(housespec->accepts_cargo); i++) {
2603 if (i < count) {
2604 housespec->accepts_cargo[i] = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
2605 housespec->cargo_acceptance[i] = buf->ReadByte();
2606 } else {
2607 housespec->accepts_cargo[i] = INVALID_CARGO;
2608 housespec->cargo_acceptance[i] = 0;
2609 }
2610 housespec->accepts_cargo_label[i] = CT_INVALID;
2611 }
2612 break;
2613 }
2614
2615 default:
2616 ret = CIR_UNKNOWN;
2617 break;
2618 }
2619 }
2620
2621 return ret;
2622 }
2623
2630 /* static */ const LanguageMap *LanguageMap::GetLanguageMap(uint32_t grfid, uint8_t language_id)
2631 {
2632 /* LanguageID "MAX_LANG", i.e. 7F is any. This language can't have a gender/case mapping, but has to be handled gracefully. */
2633 const GRFFile *grffile = GetFileByGRFID(grfid);
2634 return (grffile != nullptr && grffile->language_map != nullptr && language_id < MAX_LANG) ? &grffile->language_map[language_id] : nullptr;
2635 }
2636
2646 template <typename T>
2647 static ChangeInfoResult LoadTranslationTable(uint gvid, int numinfo, ByteReader *buf, std::vector<T> &translation_table, const char *name)
2648 {
2649 if (gvid != 0) {
2650 GrfMsg(1, "LoadTranslationTable: {} translation table must start at zero", name);
2651 return CIR_INVALID_ID;
2652 }
2653
2654 translation_table.clear();
2655 for (int i = 0; i < numinfo; i++) {
2656 translation_table.push_back(T(BSWAP32(buf->ReadDWord())));
2657 }
2658
2659 return CIR_SUCCESS;
2660 }
2661
2668 static std::string ReadDWordAsString(ByteReader *reader)
2669 {
2670 std::string output;
2671 for (int i = 0; i < 4; i++) output.push_back(reader->ReadByte());
2672 return StrMakeValid(output);
2673 }
2674
2683 static ChangeInfoResult GlobalVarChangeInfo(uint gvid, int numinfo, int prop, ByteReader *buf)
2684 {
2685 /* Properties which are handled as a whole */
2686 switch (prop) {
2687 case 0x09: // Cargo Translation Table; loading during both reservation and activation stage (in case it is selected depending on defined cargos)
2688 return LoadTranslationTable(gvid, numinfo, buf, _cur.grffile->cargo_list, "Cargo");
2689
2690 case 0x12: // Rail type translation table; loading during both reservation and activation stage (in case it is selected depending on defined railtypes)
2691 return LoadTranslationTable(gvid, numinfo, buf, _cur.grffile->railtype_list, "Rail type");
2692
2693 case 0x16: // Road type translation table; loading during both reservation and activation stage (in case it is selected depending on defined railtypes)
2694 return LoadTranslationTable(gvid, numinfo, buf, _cur.grffile->roadtype_list, "Road type");
2695
2696 case 0x17: // Tram type translation table; loading during both reservation and activation stage (in case it is selected depending on defined railtypes)
2697 return LoadTranslationTable(gvid, numinfo, buf, _cur.grffile->tramtype_list, "Tram type");
2698
2699 default:
2700 break;
2701 }
2702
2703 /* Properties which are handled per item */
2704 ChangeInfoResult ret = CIR_SUCCESS;
2705 for (int i = 0; i < numinfo; i++) {
2706 switch (prop) {
2707 case 0x08: { // Cost base factor
2708 int factor = buf->ReadByte();
2709 uint price = gvid + i;
2710
2711 if (price < PR_END) {
2712 _cur.grffile->price_base_multipliers[price] = std::min<int>(factor - 8, MAX_PRICE_MODIFIER);
2713 } else {
2714 GrfMsg(1, "GlobalVarChangeInfo: Price {} out of range, ignoring", price);
2715 }
2716 break;
2717 }
2718
2719 case 0x0A: { // Currency display names
2720 uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
2721 StringID newone = GetGRFStringID(_cur.grffile->grfid, buf->ReadWord());
2722
2723 if ((newone != STR_UNDEFINED) && (curidx < CURRENCY_END)) {
2724 _currency_specs[curidx].name = newone;
2725 _currency_specs[curidx].code.clear();
2726 }
2727 break;
2728 }
2729
2730 case 0x0B: { // Currency multipliers
2731 uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
2732 uint32_t rate = buf->ReadDWord();
2733
2734 if (curidx < CURRENCY_END) {
2735 /* TTDPatch uses a multiple of 1000 for its conversion calculations,
2736 * which OTTD does not. For this reason, divide grf value by 1000,
2737 * to be compatible */
2738 _currency_specs[curidx].rate = rate / 1000;
2739 } else {
2740 GrfMsg(1, "GlobalVarChangeInfo: Currency multipliers {} out of range, ignoring", curidx);
2741 }
2742 break;
2743 }
2744
2745 case 0x0C: { // Currency options
2746 uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
2747 uint16_t options = buf->ReadWord();
2748
2749 if (curidx < CURRENCY_END) {
2750 _currency_specs[curidx].separator.clear();
2751 _currency_specs[curidx].separator.push_back(GB(options, 0, 8));
2752 /* By specifying only one bit, we prevent errors,
2753 * since newgrf specs said that only 0 and 1 can be set for symbol_pos */
2754 _currency_specs[curidx].symbol_pos = GB(options, 8, 1);
2755 } else {
2756 GrfMsg(1, "GlobalVarChangeInfo: Currency option {} out of range, ignoring", curidx);
2757 }
2758 break;
2759 }
2760
2761 case 0x0D: { // Currency prefix symbol
2762 uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
2763 std::string prefix = ReadDWordAsString(buf);
2764
2765 if (curidx < CURRENCY_END) {
2766 _currency_specs[curidx].prefix = prefix;
2767 } else {
2768 GrfMsg(1, "GlobalVarChangeInfo: Currency symbol {} out of range, ignoring", curidx);
2769 }
2770 break;
2771 }
2772
2773 case 0x0E: { // Currency suffix symbol
2774 uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
2775 std::string suffix = ReadDWordAsString(buf);
2776
2777 if (curidx < CURRENCY_END) {
2778 _currency_specs[curidx].suffix = suffix;
2779 } else {
2780 GrfMsg(1, "GlobalVarChangeInfo: Currency symbol {} out of range, ignoring", curidx);
2781 }
2782 break;
2783 }
2784
2785 case 0x0F: { // Euro introduction dates
2786 uint curidx = GetNewgrfCurrencyIdConverted(gvid + i);
2787 TimerGameCalendar::Year year_euro = buf->ReadWord();
2788
2789 if (curidx < CURRENCY_END) {
2790 _currency_specs[curidx].to_euro = year_euro;
2791 } else {
2792 GrfMsg(1, "GlobalVarChangeInfo: Euro intro date {} out of range, ignoring", curidx);
2793 }
2794 break;
2795 }
2796
2797 case 0x10: // Snow line height table
2798 if (numinfo > 1 || IsSnowLineSet()) {
2799 GrfMsg(1, "GlobalVarChangeInfo: The snowline can only be set once ({})", numinfo);
2800 } else if (buf->Remaining() < SNOW_LINE_MONTHS * SNOW_LINE_DAYS) {
2801 GrfMsg(1, "GlobalVarChangeInfo: Not enough entries set in the snowline table ({})", buf->Remaining());
2802 } else {
2803 byte table[SNOW_LINE_MONTHS][SNOW_LINE_DAYS];
2804
2805 for (uint i = 0; i < SNOW_LINE_MONTHS; i++) {
2806 for (uint j = 0; j < SNOW_LINE_DAYS; j++) {
2807 table[i][j] = buf->ReadByte();
2808 if (_cur.grffile->grf_version >= 8) {
2809 if (table[i][j] != 0xFF) table[i][j] = table[i][j] * (1 + _settings_game.construction.map_height_limit) / 256;
2810 } else {
2811 if (table[i][j] >= 128) {
2812 /* no snow */
2813 table[i][j] = 0xFF;
2814 } else {
2815 table[i][j] = table[i][j] * (1 + _settings_game.construction.map_height_limit) / 128;
2816 }
2817 }
2818 }
2819 }
2820 SetSnowLine(table);
2821 }
2822 break;
2823
2824 case 0x11: // GRF match for engine allocation
2825 /* This is loaded during the reservation stage, so just skip it here. */
2826 /* Each entry is 8 bytes. */
2827 buf->Skip(8);
2828 break;
2829
2830 case 0x13: // Gender translation table
2831 case 0x14: // Case translation table
2832 case 0x15: { // Plural form translation
2833 uint curidx = gvid + i; // The current index, i.e. language.
2834 const LanguageMetadata *lang = curidx < MAX_LANG ? GetLanguage(curidx) : nullptr;
2835 if (lang == nullptr) {
2836 GrfMsg(1, "GlobalVarChangeInfo: Language {} is not known, ignoring", curidx);
2837 /* Skip over the data. */
2838 if (prop == 0x15) {
2839 buf->ReadByte();
2840 } else {
2841 while (buf->ReadByte() != 0) {
2842 buf->ReadString();
2843 }
2844 }
2845 break;
2846 }
2847
2848 if (_cur.grffile->language_map == nullptr) _cur.grffile->language_map = new LanguageMap[MAX_LANG];
2849
2850 if (prop == 0x15) {
2851 uint plural_form = buf->ReadByte();
2852 if (plural_form >= LANGUAGE_MAX_PLURAL) {
2853 GrfMsg(1, "GlobalVarChanceInfo: Plural form {} is out of range, ignoring", plural_form);
2854 } else {
2855 _cur.grffile->language_map[curidx].plural_form = plural_form;
2856 }
2857 break;
2858 }
2859
2860 byte newgrf_id = buf->ReadByte(); // The NewGRF (custom) identifier.
2861 while (newgrf_id != 0) {
2862 const char *name = buf->ReadString(); // The name for the OpenTTD identifier.
2863
2864 /* We'll just ignore the UTF8 identifier character. This is (fairly)
2865 * safe as OpenTTD's strings gender/cases are usually in ASCII which
2866 * is just a subset of UTF8, or they need the bigger UTF8 characters
2867 * such as Cyrillic. Thus we will simply assume they're all UTF8. */
2868 char32_t c;
2869 size_t len = Utf8Decode(&c, name);
2870 if (c == NFO_UTF8_IDENTIFIER) name += len;
2871
2872 LanguageMap::Mapping map;
2873 map.newgrf_id = newgrf_id;
2874 if (prop == 0x13) {
2875 map.openttd_id = lang->GetGenderIndex(name);
2876 if (map.openttd_id >= MAX_NUM_GENDERS) {
2877 GrfMsg(1, "GlobalVarChangeInfo: Gender name {} is not known, ignoring", name);
2878 } else {
2879 _cur.grffile->language_map[curidx].gender_map.push_back(map);
2880 }
2881 } else {
2882 map.openttd_id = lang->GetCaseIndex(name);
2883 if (map.openttd_id >= MAX_NUM_CASES) {
2884 GrfMsg(1, "GlobalVarChangeInfo: Case name {} is not known, ignoring", name);
2885 } else {
2886 _cur.grffile->language_map[curidx].case_map.push_back(map);
2887 }
2888 }
2889 newgrf_id = buf->ReadByte();
2890 }
2891 break;
2892 }
2893
2894 default:
2895 ret = CIR_UNKNOWN;
2896 break;
2897 }
2898 }
2899
2900 return ret;
2901 }
2902
2903 static ChangeInfoResult GlobalVarReserveInfo(uint gvid, int numinfo, int prop, ByteReader *buf)
2904 {
2905 /* Properties which are handled as a whole */
2906 switch (prop) {
2907 case 0x09: // Cargo Translation Table; loading during both reservation and activation stage (in case it is selected depending on defined cargos)
2908 return LoadTranslationTable(gvid, numinfo, buf, _cur.grffile->cargo_list, "Cargo");
2909
2910 case 0x12: // Rail type translation table; loading during both reservation and activation stage (in case it is selected depending on defined railtypes)
2911 return LoadTranslationTable(gvid, numinfo, buf, _cur.grffile->railtype_list, "Rail type");
2912
2913 case 0x16: // Road type translation table; loading during both reservation and activation stage (in case it is selected depending on defined roadtypes)
2914 return LoadTranslationTable(gvid, numinfo, buf, _cur.grffile->roadtype_list, "Road type");
2915
2916 case 0x17: // Tram type translation table; loading during both reservation and activation stage (in case it is selected depending on defined tramtypes)
2917 return LoadTranslationTable(gvid, numinfo, buf, _cur.grffile->tramtype_list, "Tram type");
2918
2919 default:
2920 break;
2921 }
2922
2923 /* Properties which are handled per item */
2924 ChangeInfoResult ret = CIR_SUCCESS;
2925 for (int i = 0; i < numinfo; i++) {
2926 switch (prop) {
2927 case 0x08: // Cost base factor
2928 case 0x15: // Plural form translation
2929 buf->ReadByte();
2930 break;
2931
2932 case 0x0A: // Currency display names
2933 case 0x0C: // Currency options
2934 case 0x0F: // Euro introduction dates
2935 buf->ReadWord();
2936 break;
2937
2938 case 0x0B: // Currency multipliers
2939 case 0x0D: // Currency prefix symbol
2940 case 0x0E: // Currency suffix symbol
2941 buf->ReadDWord();
2942 break;
2943
2944 case 0x10: // Snow line height table
2945 buf->Skip(SNOW_LINE_MONTHS * SNOW_LINE_DAYS);
2946 break;
2947
2948 case 0x11: { // GRF match for engine allocation
2949 uint32_t s = buf->ReadDWord();
2950 uint32_t t = buf->ReadDWord();
2951 SetNewGRFOverride(s, t);
2952 break;
2953 }
2954
2955 case 0x13: // Gender translation table
2956 case 0x14: // Case translation table
2957 while (buf->ReadByte() != 0) {
2958 buf->ReadString();
2959 }
2960 break;
2961
2962 default:
2963 ret = CIR_UNKNOWN;
2964 break;
2965 }
2966 }
2967
2968 return ret;
2969 }
2970
2971
2980 static ChangeInfoResult CargoChangeInfo(uint cid, int numinfo, int prop, ByteReader *buf)
2981 {
2982 ChangeInfoResult ret = CIR_SUCCESS;
2983
2984 if (cid + numinfo > NUM_CARGO) {
2985 GrfMsg(2, "CargoChangeInfo: Cargo type {} out of range (max {})", cid + numinfo, NUM_CARGO - 1);
2986 return CIR_INVALID_ID;
2987 }
2988
2989 for (int i = 0; i < numinfo; i++) {
2990 CargoSpec *cs = CargoSpec::Get(cid + i);
2991
2992 switch (prop) {
2993 case 0x08: // Bit number of cargo
2994 cs->bitnum = buf->ReadByte();
2995 if (cs->IsValid()) {
2996 cs->grffile = _cur.grffile;
2997 SetBit(_cargo_mask, cid + i);
2998 } else {
2999 ClrBit(_cargo_mask, cid + i);
3000 }
3001 BuildCargoLabelMap();
3002 break;
3003
3004 case 0x09: // String ID for cargo type name
3005 AddStringForMapping(buf->ReadWord(), &cs->name);
3006 break;
3007
3008 case 0x0A: // String for 1 unit of cargo
3009 AddStringForMapping(buf->ReadWord(), &cs->name_single);
3010 break;
3011
3012 case 0x0B: // String for singular quantity of cargo (e.g. 1 tonne of coal)
3013 case 0x1B: // String for cargo units
3014 /* String for units of cargo. This is different in OpenTTD
3015 * (e.g. tonnes) to TTDPatch (e.g. {COMMA} tonne of coal).
3016 * Property 1B is used to set OpenTTD's behaviour. */
3017 AddStringForMapping(buf->ReadWord(), &cs->units_volume);
3018 break;
3019
3020 case 0x0C: // String for plural quantity of cargo (e.g. 10 tonnes of coal)
3021 case 0x1C: // String for any amount of cargo
3022 /* Strings for an amount of cargo. This is different in OpenTTD
3023 * (e.g. {WEIGHT} of coal) to TTDPatch (e.g. {COMMA} tonnes of coal).
3024 * Property 1C is used to set OpenTTD's behaviour. */
3025 AddStringForMapping(buf->ReadWord(), &cs->quantifier);
3026 break;
3027
3028 case 0x0D: // String for two letter cargo abbreviation
3029 AddStringForMapping(buf->ReadWord(), &cs->abbrev);
3030 break;
3031
3032 case 0x0E: // Sprite ID for cargo icon
3033 cs->sprite = buf->ReadWord();
3034 break;
3035
3036 case 0x0F: // Weight of one unit of cargo
3037 cs->weight = buf->ReadByte();
3038 break;
3039
3040 case 0x10: // Used for payment calculation
3041 cs->transit_periods[0] = buf->ReadByte();
3042 break;
3043
3044 case 0x11: // Used for payment calculation
3045 cs->transit_periods[1] = buf->ReadByte();
3046 break;
3047
3048 case 0x12: // Base cargo price
3049 cs->initial_payment = buf->ReadDWord();
3050 break;
3051
3052 case 0x13: // Colour for station rating bars
3053 cs->rating_colour = buf->ReadByte();
3054 break;
3055
3056 case 0x14: // Colour for cargo graph
3057 cs->legend_colour = buf->ReadByte();
3058 break;
3059
3060 case 0x15: // Freight status
3061 cs->is_freight = (buf->ReadByte() != 0);
3062 break;
3063
3064 case 0x16: // Cargo classes
3065 cs->classes = buf->ReadWord();
3066 break;
3067
3068 case 0x17: // Cargo label
3069 cs->label = CargoLabel{BSWAP32(buf->ReadDWord())};
3070 BuildCargoLabelMap();
3071 break;
3072
3073 case 0x18: { // Town growth substitute type
3074 uint8_t substitute_type = buf->ReadByte();
3075
3076 switch (substitute_type) {
3077 case 0x00: cs->town_acceptance_effect = TAE_PASSENGERS; break;
3078 case 0x02: cs->town_acceptance_effect = TAE_MAIL; break;
3079 case 0x05: cs->town_acceptance_effect = TAE_GOODS; break;
3080 case 0x09: cs->town_acceptance_effect = TAE_WATER; break;
3081 case 0x0B: cs->town_acceptance_effect = TAE_FOOD; break;
3082 default:
3083 GrfMsg(1, "CargoChangeInfo: Unknown town growth substitute value {}, setting to none.", substitute_type);
3084 [[fallthrough]];
3085 case 0xFF: cs->town_acceptance_effect = TAE_NONE; break;
3086 }
3087 break;
3088 }
3089
3090 case 0x19: // Town growth coefficient
3091 buf->ReadWord();
3092 break;
3093
3094 case 0x1A: // Bitmask of callbacks to use
3095 cs->callback_mask = buf->ReadByte();
3096 break;
3097
3098 case 0x1D: // Vehicle capacity muliplier
3099 cs->multiplier = std::max<uint16_t>(1u, buf->ReadWord());
3100 break;
3101
3102 case 0x1E: { // Town production substitute type
3103 uint8_t substitute_type = buf->ReadByte();
3104
3105 switch (substitute_type) {
3106 case 0x00: cs->town_production_effect = TPE_PASSENGERS; break;
3107 case 0x02: cs->town_production_effect = TPE_MAIL; break;
3108 default:
3109 GrfMsg(1, "CargoChangeInfo: Unknown town production substitute value {}, setting to none.", substitute_type);
3110 [[fallthrough]];
3111 case 0xFF: cs->town_production_effect = TPE_NONE; break;
3112 }
3113 break;
3114 }
3115
3116 case 0x1F: // Town production multiplier
3117 cs->town_production_multiplier = std::max<uint16_t>(1U, buf->ReadWord());
3118 break;
3119
3120 default:
3121 ret = CIR_UNKNOWN;
3122 break;
3123 }
3124 }
3125
3126 return ret;
3127 }
3128
3129
3138 static ChangeInfoResult SoundEffectChangeInfo(uint sid, int numinfo, int prop, ByteReader *buf)
3139 {
3140 ChangeInfoResult ret = CIR_SUCCESS;
3141
3142 if (_cur.grffile->sound_offset == 0) {
3143 GrfMsg(1, "SoundEffectChangeInfo: No effects defined, skipping");
3144 return CIR_INVALID_ID;
3145 }
3146
3147 if (sid + numinfo - ORIGINAL_SAMPLE_COUNT > _cur.grffile->num_sounds) {
3148 GrfMsg(1, "SoundEffectChangeInfo: Attempting to change undefined sound effect ({}), max ({}). Ignoring.", sid + numinfo, ORIGINAL_SAMPLE_COUNT + _cur.grffile->num_sounds);
3149 return CIR_INVALID_ID;
3150 }
3151
3152 for (int i = 0; i < numinfo; i++) {
3153 SoundEntry *sound = GetSound(sid + i + _cur.grffile->sound_offset - ORIGINAL_SAMPLE_COUNT);
3154
3155 switch (prop) {
3156 case 0x08: // Relative volume
3157 sound->volume = buf->ReadByte();
3158 break;
3159
3160 case 0x09: // Priority
3161 sound->priority = buf->ReadByte();
3162 break;
3163
3164 case 0x0A: { // Override old sound
3165 SoundID orig_sound = buf->ReadByte();
3166
3167 if (orig_sound >= ORIGINAL_SAMPLE_COUNT) {
3168 GrfMsg(1, "SoundEffectChangeInfo: Original sound {} not defined (max {})", orig_sound, ORIGINAL_SAMPLE_COUNT);
3169 } else {
3170 SoundEntry *old_sound = GetSound(orig_sound);
3171
3172 /* Literally copy the data of the new sound over the original */
3173 *old_sound = *sound;
3174 }
3175 break;
3176 }
3177
3178 default:
3179 ret = CIR_UNKNOWN;
3180 break;
3181 }
3182 }
3183
3184 return ret;
3185 }
3186
3193 static ChangeInfoResult IgnoreIndustryTileProperty(int prop, ByteReader *buf)
3194 {
3195 ChangeInfoResult ret = CIR_SUCCESS;
3196
3197 switch (prop) {
3198 case 0x09:
3199 case 0x0D:
3200 case 0x0E:
3201 case 0x10:
3202 case 0x11:
3203 case 0x12:
3204 buf->ReadByte();
3205 break;
3206
3207 case 0x0A:
3208 case 0x0B:
3209 case 0x0C:
3210 case 0x0F:
3211 buf->ReadWord();
3212 break;
3213
3214 case 0x13:
3215 buf->Skip(buf->ReadByte() * 2);
3216 break;
3217
3218 default:
3219 ret = CIR_UNKNOWN;
3220 break;
3221 }
3222 return ret;
3223 }
3224
3233 static ChangeInfoResult IndustrytilesChangeInfo(uint indtid, int numinfo, int prop, ByteReader *buf)
3234 {
3235 ChangeInfoResult ret = CIR_SUCCESS;
3236
3237 if (indtid + numinfo > NUM_INDUSTRYTILES_PER_GRF) {
3238 GrfMsg(1, "IndustryTilesChangeInfo: Too many industry tiles loaded ({}), max ({}). Ignoring.", indtid + numinfo, NUM_INDUSTRYTILES_PER_GRF);
3239 return CIR_INVALID_ID;
3240 }
3241
3242 /* Allocate industry tile specs if they haven't been allocated already. */
3243 if (_cur.grffile->indtspec.size() < indtid + numinfo) _cur.grffile->indtspec.resize(indtid + numinfo);
3244
3245 for (int i = 0; i < numinfo; i++) {
3246 IndustryTileSpec *tsp = _cur.grffile->indtspec[indtid + i].get();
3247
3248 if (prop != 0x08 && tsp == nullptr) {
3249 ChangeInfoResult cir = IgnoreIndustryTileProperty(prop, buf);
3250 if (cir > ret) ret = cir;
3251 continue;
3252 }
3253
3254 switch (prop) {
3255 case 0x08: { // Substitute industry tile type
3256 byte subs_id = buf->ReadByte();
3257 if (subs_id >= NEW_INDUSTRYTILEOFFSET) {
3258 /* The substitute id must be one of the original industry tile. */
3259 GrfMsg(2, "IndustryTilesChangeInfo: Attempt to use new industry tile {} as substitute industry tile for {}. Ignoring.", subs_id, indtid + i);
3260 continue;
3261 }
3262
3263 /* Allocate space for this industry. */
3264 if (tsp == nullptr) {
3265 _cur.grffile->indtspec[indtid + i] = std::make_unique<IndustryTileSpec>(_industry_tile_specs[subs_id]);
3266 tsp = _cur.grffile->indtspec[indtid + i].get();
3267
3268 tsp->enabled = true;
3269
3270 /* A copied tile should not have the animation infos copied too.
3271 * The anim_state should be left untouched, though
3272 * It is up to the author to animate them */
3273 tsp->anim_production = INDUSTRYTILE_NOANIM;
3274 tsp->anim_next = INDUSTRYTILE_NOANIM;
3275
3276 tsp->grf_prop.local_id = indtid + i;
3277 tsp->grf_prop.subst_id = subs_id;
3278 tsp->grf_prop.grffile = _cur.grffile;
3279 _industile_mngr.AddEntityID(indtid + i, _cur.grffile->grfid, subs_id); // pre-reserve the tile slot
3280 }
3281 break;
3282 }
3283
3284 case 0x09: { // Industry tile override
3285 byte ovrid = buf->ReadByte();
3286
3287 /* The industry being overridden must be an original industry. */
3288 if (ovrid >= NEW_INDUSTRYTILEOFFSET) {
3289 GrfMsg(2, "IndustryTilesChangeInfo: Attempt to override new industry tile {} with industry tile id {}. Ignoring.", ovrid, indtid + i);
3290 continue;
3291 }
3292
3293 _industile_mngr.Add(indtid + i, _cur.grffile->grfid, ovrid);
3294 break;
3295 }
3296
3297 case 0x0A: // Tile acceptance
3298 case 0x0B:
3299 case 0x0C: {
3300 uint16_t acctp = buf->ReadWord();
3301 tsp->accepts_cargo[prop - 0x0A] = GetCargoTranslation(GB(acctp, 0, 8), _cur.grffile);
3302 tsp->acceptance[prop - 0x0A] = Clamp(GB(acctp, 8, 8), 0, 16);
3303 tsp->accepts_cargo_label[prop - 0x0A] = CT_INVALID;
3304 break;
3305 }
3306
3307 case 0x0D: // Land shape flags
3308 tsp->slopes_refused = (Slope)buf->ReadByte();
3309 break;
3310
3311 case 0x0E: // Callback mask
3312 tsp->callback_mask = buf->ReadByte();
3313 break;
3314
3315 case 0x0F: // Animation information
3316 tsp->animation.frames = buf->ReadByte();
3317 tsp->animation.status = buf->ReadByte();
3318 break;
3319
3320 case 0x10: // Animation speed
3321 tsp->animation.speed = buf->ReadByte();
3322 break;
3323
3324 case 0x11: // Triggers for callback 25
3325 tsp->animation.triggers = buf->ReadByte();
3326 break;
3327
3328 case 0x12: // Special flags
3329 tsp->special_flags = (IndustryTileSpecialFlags)buf->ReadByte();
3330 break;
3331
3332 case 0x13: { // variable length cargo acceptance
3333 byte num_cargoes = buf->ReadByte();
3334 if (num_cargoes > std::size(tsp->acceptance)) {
3335 GRFError *error = DisableGrf(STR_NEWGRF_ERROR_LIST_PROPERTY_TOO_LONG);
3336 error->param_value[1] = prop;
3337 return CIR_DISABLED;
3338 }
3339 for (uint i = 0; i < std::size(tsp->acceptance); i++) {
3340 if (i < num_cargoes) {
3341 tsp->accepts_cargo[i] = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
3342 /* Tile acceptance can be negative to counteract the INDTILE_SPECIAL_ACCEPTS_ALL_CARGO flag */
3343 tsp->acceptance[i] = (int8_t)buf->ReadByte();
3344 } else {
3345 tsp->accepts_cargo[i] = INVALID_CARGO;
3346 tsp->acceptance[i] = 0;
3347 }
3348 tsp->accepts_cargo_label[i] = CT_INVALID;
3349 }
3350 break;
3351 }
3352
3353 default:
3354 ret = CIR_UNKNOWN;
3355 break;
3356 }
3357 }
3358
3359 return ret;
3360 }
3361
3368 static ChangeInfoResult IgnoreIndustryProperty(int prop, ByteReader *buf)
3369 {
3370 ChangeInfoResult ret = CIR_SUCCESS;
3371
3372 switch (prop) {
3373 case 0x09:
3374 case 0x0B:
3375 case 0x0F:
3376 case 0x12:
3377 case 0x13:
3378 case 0x14:
3379 case 0x17:
3380 case 0x18:
3381 case 0x19:
3382 case 0x21:
3383 case 0x22:
3384 buf->ReadByte();
3385 break;
3386
3387 case 0x0C:
3388 case 0x0D:
3389 case 0x0E:
3390 case 0x10:
3391 case 0x1B:
3392 case 0x1F:
3393 case 0x24:
3394 buf->ReadWord();
3395 break;
3396
3397 case 0x11:
3398 case 0x1A:
3399 case 0x1C:
3400 case 0x1D:
3401 case 0x1E:
3402 case 0x20:
3403 case 0x23:
3404 buf->ReadDWord();
3405 break;
3406
3407 case 0x0A: {
3408 byte num_table = buf->ReadByte();
3409 for (byte j = 0; j < num_table; j++) {
3410 for (uint k = 0;; k++) {
3411 byte x = buf->ReadByte();
3412 if (x == 0xFE && k == 0) {
3413 buf->ReadByte();
3414 buf->ReadByte();
3415 break;
3416 }
3417
3418 byte y = buf->ReadByte();
3419 if (x == 0 && y == 0x80) break;
3420
3421 byte gfx = buf->ReadByte();
3422 if (gfx == 0xFE) buf->ReadWord();
3423 }
3424 }
3425 break;
3426 }
3427
3428 case 0x16:
3429 for (byte j = 0; j < 3; j++) buf->ReadByte();
3430 break;
3431
3432 case 0x15:
3433 case 0x25:
3434 case 0x26:
3435 case 0x27:
3436 buf->Skip(buf->ReadByte());
3437 break;
3438
3439 case 0x28: {
3440 int num_inputs = buf->ReadByte();
3441 int num_outputs = buf->ReadByte();
3442 buf->Skip(num_inputs * num_outputs * 2);
3443 break;
3444 }
3445
3446 default:
3447 ret = CIR_UNKNOWN;
3448 break;
3449 }
3450 return ret;
3451 }
3452
3458 static bool ValidateIndustryLayout(const IndustryTileLayout &layout)
3459 {
3460 const size_t size = layout.size();
3461 if (size == 0) return false;
3462
3463 for (size_t i = 0; i < size - 1; i++) {
3464 for (size_t j = i + 1; j < size; j++) {
3465 if (layout[i].ti.x == layout[j].ti.x &&
3466 layout[i].ti.y == layout[j].ti.y) {
3467 return false;
3468 }
3469 }
3470 }
3471
3472 bool have_regular_tile = false;
3473 for (const auto &tilelayout : layout) {
3474 if (tilelayout.gfx != GFX_WATERTILE_SPECIALCHECK) {
3475 have_regular_tile = true;
3476 break;
3477 }
3478 }
3479
3480 return have_regular_tile;
3481 }
3482
3491 static ChangeInfoResult IndustriesChangeInfo(uint indid, int numinfo, int prop, ByteReader *buf)
3492 {
3493 ChangeInfoResult ret = CIR_SUCCESS;
3494
3495 if (indid + numinfo > NUM_INDUSTRYTYPES_PER_GRF) {
3496 GrfMsg(1, "IndustriesChangeInfo: Too many industries loaded ({}), max ({}). Ignoring.", indid + numinfo, NUM_INDUSTRYTYPES_PER_GRF);
3497 return CIR_INVALID_ID;
3498 }
3499
3500 /* Allocate industry specs if they haven't been allocated already. */
3501 if (_cur.grffile->industryspec.size() < indid + numinfo) _cur.grffile->industryspec.resize(indid + numinfo);
3502
3503 for (int i = 0; i < numinfo; i++) {
3504 IndustrySpec *indsp = _cur.grffile->industryspec[indid + i].get();
3505
3506 if (prop != 0x08 && indsp == nullptr) {
3507 ChangeInfoResult cir = IgnoreIndustryProperty(prop, buf);
3508 if (cir > ret) ret = cir;
3509 continue;
3510 }
3511
3512 switch (prop) {
3513 case 0x08: { // Substitute industry type
3514 byte subs_id = buf->ReadByte();
3515 if (subs_id == 0xFF) {
3516 /* Instead of defining a new industry, a substitute industry id
3517 * of 0xFF disables the old industry with the current id. */
3518 _industry_specs[indid + i].enabled = false;
3519 continue;
3520 } else if (subs_id >= NEW_INDUSTRYOFFSET) {
3521 /* The substitute id must be one of the original industry. */
3522 GrfMsg(2, "_industry_specs: Attempt to use new industry {} as substitute industry for {}. Ignoring.", subs_id, indid + i);
3523 continue;
3524 }
3525
3526 /* Allocate space for this industry.
3527 * Only need to do it once. If ever it is called again, it should not
3528 * do anything */
3529 if (indsp == nullptr) {
3530 _cur.grffile->industryspec[indid + i] = std::make_unique<IndustrySpec>(_origin_industry_specs[subs_id]);
3531 indsp = _cur.grffile->industryspec[indid + i].get();
3532
3533 indsp->enabled = true;
3534 indsp->grf_prop.local_id = indid + i;
3535 indsp->grf_prop.subst_id = subs_id;
3536 indsp->grf_prop.grffile = _cur.grffile;
3537 /* If the grf industry needs to check its surrounding upon creation, it should
3538 * rely on callbacks, not on the original placement functions */
3539 indsp->check_proc = CHECK_NOTHING;
3540 }
3541 break;
3542 }
3543
3544 case 0x09: { // Industry type override
3545 byte ovrid = buf->ReadByte();
3546
3547 /* The industry being overridden must be an original industry. */
3548 if (ovrid >= NEW_INDUSTRYOFFSET) {
3549 GrfMsg(2, "IndustriesChangeInfo: Attempt to override new industry {} with industry id {}. Ignoring.", ovrid, indid + i);
3550 continue;
3551 }
3552 indsp->grf_prop.override = ovrid;
3553 _industry_mngr.Add(indid + i, _cur.grffile->grfid, ovrid);
3554 break;
3555 }
3556
3557 case 0x0A: { // Set industry layout(s)
3558 byte new_num_layouts = buf->ReadByte();
3559 uint32_t definition_size = buf->ReadDWord();
3560 uint32_t bytes_read = 0;
3561 std::vector<IndustryTileLayout> new_layouts;
3562 IndustryTileLayout layout;
3563
3564 for (byte j = 0; j < new_num_layouts; j++) {
3565 layout.clear();
3566
3567 for (uint k = 0;; k++) {
3568 if (bytes_read >= definition_size) {
3569 GrfMsg(3, "IndustriesChangeInfo: Incorrect size for industry tile layout definition for industry {}.", indid);
3570 /* Avoid warning twice */
3571 definition_size = UINT32_MAX;
3572 }
3573
3574 layout.push_back(IndustryTileLayoutTile{});
3575 IndustryTileLayoutTile &it = layout.back();
3576
3577 it.ti.x = buf->ReadByte(); // Offsets from northermost tile
3578 ++bytes_read;
3579
3580 if (it.ti.x == 0xFE && k == 0) {
3581 /* This means we have to borrow the layout from an old industry */
3582 IndustryType type = buf->ReadByte();
3583 byte laynbr = buf->ReadByte();
3584 bytes_read += 2;
3585
3586 if (type >= lengthof(_origin_industry_specs)) {
3587 GrfMsg(1, "IndustriesChangeInfo: Invalid original industry number for layout import, industry {}", indid);
3588 DisableGrf(STR_NEWGRF_ERROR_INVALID_ID);
3589 return CIR_DISABLED;
3590 }
3591 if (laynbr >= _origin_industry_specs[type].layouts.size()) {
3592 GrfMsg(1, "IndustriesChangeInfo: Invalid original industry layout index for layout import, industry {}", indid);
3593 DisableGrf(STR_NEWGRF_ERROR_INVALID_ID);
3594 return CIR_DISABLED;
3595 }
3596 layout = _origin_industry_specs[type].layouts[laynbr];
3597 break;
3598 }
3599
3600 it.ti.y = buf->ReadByte(); // Or table definition finalisation
3601 ++bytes_read;
3602
3603 if (it.ti.x == 0 && it.ti.y == 0x80) {
3604 /* Terminator, remove and finish up */
3605 layout.pop_back();
3606 break;
3607 }
3608
3609 it.gfx = buf->ReadByte();
3610 ++bytes_read;
3611
3612 if (it.gfx == 0xFE) {
3613 /* Use a new tile from this GRF */
3614 int local_tile_id = buf->ReadWord();
3615 bytes_read += 2;
3616
3617 /* Read the ID from the _industile_mngr. */
3618 int tempid = _industile_mngr.GetID(local_tile_id, _cur.grffile->grfid);
3619
3620 if (tempid == INVALID_INDUSTRYTILE) {
3621 GrfMsg(2, "IndustriesChangeInfo: Attempt to use industry tile {} with industry id {}, not yet defined. Ignoring.", local_tile_id, indid);
3622 } else {
3623 /* Declared as been valid, can be used */
3624 it.gfx = tempid;
3625 }
3626 } else if (it.gfx == GFX_WATERTILE_SPECIALCHECK) {
3627 it.ti.x = (int8_t)GB(it.ti.x, 0, 8);
3628 it.ti.y = (int8_t)GB(it.ti.y, 0, 8);
3629
3630 /* When there were only 256x256 maps, TileIndex was a uint16_t and
3631 * it.ti was just a TileIndexDiff that was added to it.
3632 * As such negative "x" values were shifted into the "y" position.
3633 * x = -1, y = 1 -> x = 255, y = 0
3634 * Since GRF version 8 the position is interpreted as pair of independent int8.
3635 * For GRF version < 8 we need to emulate the old shifting behaviour.
3636 */
3637 if (_cur.grffile->grf_version < 8 && it.ti.x < 0) it.ti.y += 1;
3638 }
3639 }
3640
3641 if (!ValidateIndustryLayout(layout)) {
3642 /* The industry layout was not valid, so skip this one. */
3643 GrfMsg(1, "IndustriesChangeInfo: Invalid industry layout for industry id {}. Ignoring", indid);
3644 new_num_layouts--;
3645 j--;
3646 } else {
3647 new_layouts.push_back(layout);
3648 }
3649 }
3650
3651 /* Install final layout construction in the industry spec */
3652 indsp->layouts = new_layouts;
3653 break;
3654 }
3655
3656 case 0x0B: // Industry production flags
3657 indsp->life_type = (IndustryLifeType)buf->ReadByte();
3658 break;
3659
3660 case 0x0C: // Industry closure message
3661 AddStringForMapping(buf->ReadWord(), &indsp->closure_text);
3662 break;
3663
3664 case 0x0D: // Production increase message
3665 AddStringForMapping(buf->ReadWord(), &indsp->production_up_text);
3666 break;
3667
3668 case 0x0E: // Production decrease message
3669 AddStringForMapping(buf->ReadWord(), &indsp->production_down_text);
3670 break;
3671
3672 case 0x0F: // Fund cost multiplier
3673 indsp->cost_multiplier = buf->ReadByte();
3674 break;
3675
3676 case 0x10: // Production cargo types
3677 for (byte j = 0; j < 2; j++) {
3678 indsp->produced_cargo[j] = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
3679 indsp->produced_cargo_label[j] = CT_INVALID;
3680 }
3681 break;
3682
3683 case 0x11: // Acceptance cargo types
3684 for (byte j = 0; j < 3; j++) {
3685 indsp->accepts_cargo[j] = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
3686 indsp->accepts_cargo_label[j] = CT_INVALID;
3687 }
3688 buf->ReadByte(); // Unnused, eat it up
3689 break;
3690
3691 case 0x12: // Production multipliers
3692 case 0x13:
3693 indsp->production_rate[prop - 0x12] = buf->ReadByte();
3694 break;
3695
3696 case 0x14: // Minimal amount of cargo distributed
3697 indsp->minimal_cargo = buf->ReadByte();
3698 break;
3699
3700 case 0x15: { // Random sound effects
3701 indsp->number_of_sounds = buf->ReadByte();
3702 uint8_t *sounds = MallocT<uint8_t>(indsp->number_of_sounds);
3703
3704 try {
3705 for (uint8_t j = 0; j < indsp->number_of_sounds; j++) {
3706 sounds[j] = buf->ReadByte();
3707 }
3708 } catch (...) {
3709 free(sounds);
3710 throw;
3711 }
3712
3713 if (HasBit(indsp->cleanup_flag, CLEAN_RANDOMSOUNDS)) {
3714 free(indsp->random_sounds);
3715 }
3716 indsp->random_sounds = sounds;
3717 SetBit(indsp->cleanup_flag, CLEAN_RANDOMSOUNDS);
3718 break;
3719 }
3720
3721 case 0x16: // Conflicting industry types
3722 for (byte j = 0; j < 3; j++) indsp->conflicting[j] = buf->ReadByte();
3723 break;
3724
3725 case 0x17: // Probability in random game
3726 indsp->appear_creation[_settings_game.game_creation.landscape] = buf->ReadByte();
3727 break;
3728
3729 case 0x18: // Probability during gameplay
3730 indsp->appear_ingame[_settings_game.game_creation.landscape] = buf->ReadByte();
3731 break;
3732
3733 case 0x19: // Map colour
3734 indsp->map_colour = buf->ReadByte();
3735 break;
3736
3737 case 0x1A: // Special industry flags to define special behavior
3738 indsp->behaviour = (IndustryBehaviour)buf->ReadDWord();
3739 break;
3740
3741 case 0x1B: // New industry text ID
3742 AddStringForMapping(buf->ReadWord(), &indsp->new_industry_text);
3743 break;
3744
3745 case 0x1C: // Input cargo multipliers for the three input cargo types
3746 case 0x1D:
3747 case 0x1E: {
3748 uint32_t multiples = buf->ReadDWord();
3749 indsp->input_cargo_multiplier[prop - 0x1C][0] = GB(multiples, 0, 16);
3750 indsp->input_cargo_multiplier[prop - 0x1C][1] = GB(multiples, 16, 16);
3751 break;
3752 }
3753
3754 case 0x1F: // Industry name
3755 AddStringForMapping(buf->ReadWord(), &indsp->name);
3756 break;
3757
3758 case 0x20: // Prospecting success chance
3759 indsp->prospecting_chance = buf->ReadDWord();
3760 break;
3761
3762 case 0x21: // Callback mask
3763 case 0x22: { // Callback additional mask
3764 byte aflag = buf->ReadByte();
3765 SB(indsp->callback_mask, (prop - 0x21) * 8, 8, aflag);
3766 break;
3767 }
3768
3769 case 0x23: // removal cost multiplier
3770 indsp->removal_cost_multiplier = buf->ReadDWord();
3771 break;
3772
3773 case 0x24: { // name for nearby station
3774 uint16_t str = buf->ReadWord();
3775 if (str == 0) {
3776 indsp->station_name = STR_NULL;
3777 } else {
3778 AddStringForMapping(str, &indsp->station_name);
3779 }
3780 break;
3781 }
3782
3783 case 0x25: { // variable length produced cargoes
3784 byte num_cargoes = buf->ReadByte();
3785 if (num_cargoes > lengthof(indsp->produced_cargo)) {
3786 GRFError *error = DisableGrf(STR_NEWGRF_ERROR_LIST_PROPERTY_TOO_LONG);
3787 error->param_value[1] = prop;
3788 return CIR_DISABLED;
3789 }
3790 for (uint i = 0; i < lengthof(indsp->produced_cargo); i++) {
3791 if (i < num_cargoes) {
3792 CargoID cargo = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
3793 indsp->produced_cargo[i] = cargo;
3794 } else {
3795 indsp->produced_cargo[i] = INVALID_CARGO;
3796 }
3797 indsp->produced_cargo_label[i] = CT_INVALID;
3798 }
3799 break;
3800 }
3801
3802 case 0x26: { // variable length accepted cargoes
3803 byte num_cargoes = buf->ReadByte();
3804 if (num_cargoes > lengthof(indsp->accepts_cargo)) {
3805 GRFError *error = DisableGrf(STR_NEWGRF_ERROR_LIST_PROPERTY_TOO_LONG);
3806 error->param_value[1] = prop;
3807 return CIR_DISABLED;
3808 }
3809 for (uint i = 0; i < lengthof(indsp->accepts_cargo); i++) {
3810 if (i < num_cargoes) {
3811 CargoID cargo = GetCargoTranslation(buf->ReadByte(), _cur.grffile);
3812 indsp->accepts_cargo[i] = cargo;
3813 } else {
3814 indsp->accepts_cargo[i] = INVALID_CARGO;
3815 }
3816 indsp->accepts_cargo_label[i] = CT_INVALID;
3817 }
3818 break;
3819 }
3820
3821 case 0x27: { // variable length production rates
3822 byte num_cargoes = buf->ReadByte();
3823 if (num_cargoes > lengthof(indsp->production_rate)) {
3824 GRFError *error = DisableGrf(STR_NEWGRF_ERROR_LIST_PROPERTY_TOO_LONG);
3825 error->param_value[1] = prop;
3826 return CIR_DISABLED;
3827 }
3828 for (uint i = 0; i < lengthof(indsp->production_rate); i++) {
3829 if (i < num_cargoes) {
3830 indsp->production_rate[i] = buf->ReadByte();
3831 } else {
3832 indsp->production_rate[i] = 0;
3833 }
3834 }
3835 break;
3836 }
3837
3838 case 0x28: { // variable size input/output production multiplier table
3839 byte num_inputs = buf->ReadByte();
3840 byte num_outputs = buf->ReadByte();
3841 if (num_inputs > lengthof(indsp->accepts_cargo) || num_outputs > lengthof(indsp->produced_cargo)) {
3842 GRFError *error = DisableGrf(STR_NEWGRF_ERROR_LIST_PROPERTY_TOO_LONG);
3843 error->param_value[1] = prop;
3844 return CIR_DISABLED;
3845 }
3846 for (uint i = 0; i < lengthof(indsp->accepts_cargo); i++) {
3847 for (uint j = 0; j < lengthof(indsp->produced_cargo); j++) {
3848 uint16_t mult = 0;
3849 if (i < num_inputs && j < num_outputs) mult = buf->ReadWord();
3850 indsp->input_cargo_multiplier[i][j] = mult;
3851 }
3852 }
3853 break;
3854 }
3855
3856 default:
3857 ret = CIR_UNKNOWN;
3858 break;
3859 }
3860 }
3861
3862 return ret;
3863 }
3864
3870 static void DuplicateTileTable(AirportSpec *as)
3871 {
3872 AirportTileTable **table_list = MallocT<AirportTileTable*>(as->num_table);
3873 for (int i = 0; i < as->num_table; i++) {
3874 uint num_tiles = 1;
3875 const AirportTileTable *it = as->table[0];
3876 do {
3877 num_tiles++;
3878 } while ((++it)->ti.x != -0x80);
3879 table_list[i] = MallocT<AirportTileTable>(num_tiles);
3880 MemCpyT(table_list[i], as->table[i], num_tiles);
3881 }
3882 as->table = table_list;
3883 HangarTileTable *depot_table = MallocT<HangarTileTable>(as->nof_depots);
3884 MemCpyT(depot_table, as->depot_table, as->nof_depots);
3885 as->depot_table = depot_table;
3886 Direction *rotation = MallocT<Direction>(as->num_table);
3887 MemCpyT(rotation, as->rotation, as->num_table);
3888 as->rotation = rotation;
3889 }
3890
3899 static ChangeInfoResult AirportChangeInfo(uint airport, int numinfo, int prop, ByteReader *buf)
3900 {
3901 ChangeInfoResult ret = CIR_SUCCESS;
3902
3903 if (airport + numinfo > NUM_AIRPORTS_PER_GRF) {
3904 GrfMsg(1, "AirportChangeInfo: Too many airports, trying id ({}), max ({}). Ignoring.", airport + numinfo, NUM_AIRPORTS_PER_GRF);
3905 return CIR_INVALID_ID;
3906 }
3907
3908 /* Allocate industry specs if they haven't been allocated already. */
3909 if (_cur.grffile->airportspec.size() < airport + numinfo) _cur.grffile->airportspec.resize(airport + numinfo);
3910
3911 for (int i = 0; i < numinfo; i++) {
3912 AirportSpec *as = _cur.grffile->airportspec[airport + i].get();
3913
3914 if (as == nullptr && prop != 0x08 && prop != 0x09) {
3915 GrfMsg(2, "AirportChangeInfo: Attempt to modify undefined airport {}, ignoring", airport + i);
3916 return CIR_INVALID_ID;
3917 }
3918
3919 switch (prop) {
3920 case 0x08: { // Modify original airport
3921 byte subs_id = buf->ReadByte();
3922 if (subs_id == 0xFF) {
3923 /* Instead of defining a new airport, an airport id
3924 * of 0xFF disables the old airport with the current id. */
3925 AirportSpec::GetWithoutOverride(airport + i)->enabled = false;
3926 continue;
3927 } else if (subs_id >= NEW_AIRPORT_OFFSET) {
3928 /* The substitute id must be one of the original airports. */
3929 GrfMsg(2, "AirportChangeInfo: Attempt to use new airport {} as substitute airport for {}. Ignoring.", subs_id, airport + i);
3930 continue;
3931 }
3932
3933 /* Allocate space for this airport.
3934 * Only need to do it once. If ever it is called again, it should not
3935 * do anything */
3936 if (as == nullptr) {
3937 _cur.grffile->airportspec[airport + i] = std::make_unique<AirportSpec>(*AirportSpec::GetWithoutOverride(subs_id));
3938 as = _cur.grffile->airportspec[airport + i].get();
3939
3940 as->enabled = true;
3941 as->grf_prop.local_id = airport + i;
3942 as->grf_prop.subst_id = subs_id;
3943 as->grf_prop.grffile = _cur.grffile;
3944 /* override the default airport */
3945 _airport_mngr.Add(airport + i, _cur.grffile->grfid, subs_id);
3946 /* Create a copy of the original tiletable so it can be freed later. */
3947 DuplicateTileTable(as);
3948 }
3949 break;
3950 }
3951
3952 case 0x0A: { // Set airport layout
3953 byte old_num_table = as->num_table;
3954 free(as->rotation);
3955 as->num_table = buf->ReadByte(); // Number of layaouts
3956 as->rotation = MallocT<Direction>(as->num_table);
3957 uint32_t defsize = buf->ReadDWord(); // Total size of the definition
3958 AirportTileTable **tile_table = CallocT<AirportTileTable*>(as->num_table); // Table with tiles to compose the airport
3959 AirportTileTable *att = CallocT<AirportTileTable>(defsize); // Temporary array to read the tile layouts from the GRF
3960 int size;
3961 const AirportTileTable *copy_from;
3962 try {
3963 for (byte j = 0; j < as->num_table; j++) {
3964 const_cast<Direction&>(as->rotation[j]) = (Direction)buf->ReadByte();
3965 for (int k = 0;; k++) {
3966 att[k].ti.x = buf->ReadByte(); // Offsets from northermost tile
3967 att[k].ti.y = buf->ReadByte();
3968
3969 if (att[k].ti.x == 0 && att[k].ti.y == 0x80) {
3970 /* Not the same terminator. The one we are using is rather
3971 * x = -80, y = 0 . So, adjust it. */
3972 att[k].ti.x = -0x80;
3973 att[k].ti.y = 0;
3974 att[k].gfx = 0;
3975
3976 size = k + 1;
3977 copy_from = att;
3978 break;
3979 }
3980
3981 att[k].gfx = buf->ReadByte();
3982
3983 if (att[k].gfx == 0xFE) {
3984 /* Use a new tile from this GRF */
3985 int local_tile_id = buf->ReadWord();
3986
3987 /* Read the ID from the _airporttile_mngr. */
3988 uint16_t tempid = _airporttile_mngr.GetID(local_tile_id, _cur.grffile->grfid);
3989
3990 if (tempid == INVALID_AIRPORTTILE) {
3991 GrfMsg(2, "AirportChangeInfo: Attempt to use airport tile {} with airport id {}, not yet defined. Ignoring.", local_tile_id, airport + i);
3992 } else {
3993 /* Declared as been valid, can be used */
3994 att[k].gfx = tempid;
3995 }
3996 } else if (att[k].gfx == 0xFF) {
3997 att[k].ti.x = (int8_t)GB(att[k].ti.x, 0, 8);
3998 att[k].ti.y = (int8_t)GB(att[k].ti.y, 0, 8);
3999 }
4000
4001 if (as->rotation[j] == DIR_E || as->rotation[j] == DIR_W) {
4002 as->size_x = std::max<byte>(as->size_x, att[k].ti.y + 1);
4003 as->size_y = std::max<byte>(as->size_y, att[k].ti.x + 1);
4004 } else {
4005 as->size_x = std::max<byte>(as->size_x, att[k].ti.x + 1);
4006 as->size_y = std::max<byte>(as->size_y, att[k].ti.y + 1);
4007 }
4008 }
4009 tile_table[j] = CallocT<AirportTileTable>(size);
4010 memcpy(tile_table[j], copy_from, sizeof(*copy_from) * size);
4011 }
4012 /* Free old layouts in the airport spec */
4013 for (int j = 0; j < old_num_table; j++) {
4014 /* remove the individual layouts */
4015 free(as->table[j]);
4016 }
4017 free(as->table);
4018 /* Install final layout construction in the airport spec */
4019 as->table = tile_table;
4020 free(att);
4021 } catch (...) {
4022 for (int i = 0; i < as->num_table; i++) {
4023 free(tile_table[i]);
4024 }
4025 free(tile_table);
4026 free(att);
4027 throw;
4028 }
4029 break;
4030 }
4031
4032 case 0x0C:
4033 as->min_year = buf->ReadWord();
4034 as->max_year = buf->ReadWord();
4035 if (as->max_year == 0xFFFF) as->max_year = CalendarTime::MAX_YEAR;
4036 break;
4037
4038 case 0x0D:
4039 as->ttd_airport_type = (TTDPAirportType)buf->ReadByte();
4040 break;
4041
4042 case 0x0E:
4043 as->catchment = Clamp(buf->ReadByte(), 1, MAX_CATCHMENT);
4044 break;
4045
4046 case 0x0F:
4047 as->noise_level = buf->ReadByte();
4048 break;
4049
4050 case 0x10:
4051 AddStringForMapping(buf->ReadWord(), &as->name);
4052 break;
4053
4054 case 0x11: // Maintenance cost factor
4055 as->maintenance_cost = buf->ReadWord();
4056 break;
4057
4058 default:
4059 ret = CIR_UNKNOWN;
4060 break;
4061 }
4062 }
4063
4064 return ret;
4065 }
4066
4073 static ChangeInfoResult IgnoreObjectProperty(uint prop, ByteReader *buf)
4074 {
4075 ChangeInfoResult ret = CIR_SUCCESS;
4076
4077 switch (prop) {
4078 case 0x0B:
4079 case 0x0C:
4080 case 0x0D:
4081 case 0x12:
4082 case 0x14:
4083 case 0x16:
4084 case 0x17:
4085 case 0x18:
4086 buf->ReadByte();
4087 break;
4088
4089 case 0x09:
4090 case 0x0A:
4091 case 0x10:
4092 case 0x11:
4093 case 0x13:
4094 case 0x15:
4095 buf->ReadWord();
4096 break;
4097
4098 case 0x08:
4099 case 0x0E:
4100 case 0x0F:
4101 buf->ReadDWord();
4102 break;
4103
4104 default:
4105 ret = CIR_UNKNOWN;
4106 break;
4107 }
4108
4109 return ret;
4110 }
4111
4120 static ChangeInfoResult ObjectChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
4121 {
4122 ChangeInfoResult ret = CIR_SUCCESS;
4123
4124 if (id + numinfo > NUM_OBJECTS_PER_GRF) {
4125 GrfMsg(1, "ObjectChangeInfo: Too many objects loaded ({}), max ({}). Ignoring.", id + numinfo, NUM_OBJECTS_PER_GRF);
4126 return CIR_INVALID_ID;
4127 }
4128
4129 /* Allocate object specs if they haven't been allocated already. */
4130 if (_cur.grffile->objectspec.size() < id + numinfo) _cur.grffile->objectspec.resize(id + numinfo);
4131
4132 for (int i = 0; i < numinfo; i++) {
4133 ObjectSpec *spec = _cur.grffile->objectspec[id + i].get();
4134
4135 if (prop != 0x08 && spec == nullptr) {
4136 /* If the object property 08 is not yet set, ignore this property */
4137 ChangeInfoResult cir = IgnoreObjectProperty(prop, buf);
4138 if (cir > ret) ret = cir;
4139 continue;
4140 }
4141
4142 switch (prop) {
4143 case 0x08: { // Class ID
4144 /* Allocate space for this object. */
4145 if (spec == nullptr) {
4146 _cur.grffile->objectspec[id + i] = std::make_unique<ObjectSpec>();
4147 spec = _cur.grffile->objectspec[id + i].get();
4148 spec->views = 1; // Default for NewGRFs that don't set it.
4149 spec->size = OBJECT_SIZE_1X1; // Default for NewGRFs that manage to not set it (1x1)
4150 }
4151
4152 /* Swap classid because we read it in BE. */
4153 uint32_t classid = buf->ReadDWord();
4154 spec->cls_id = ObjectClass::Allocate(BSWAP32(classid));
4155 break;
4156 }
4157
4158 case 0x09: { // Class name
4159 ObjectClass *objclass = ObjectClass::Get(spec->cls_id);
4160 AddStringForMapping(buf->ReadWord(), &objclass->name);
4161 break;
4162 }
4163
4164 case 0x0A: // Object name
4165 AddStringForMapping(buf->ReadWord(), &spec->name);
4166 break;
4167
4168 case 0x0B: // Climate mask
4169 spec->climate = buf->ReadByte();
4170 break;
4171
4172 case 0x0C: // Size
4173 spec->size = buf->ReadByte();
4174 if (GB(spec->size, 0, 4) == 0 || GB(spec->size, 4, 4) == 0) {
4175 GrfMsg(0, "ObjectChangeInfo: Invalid object size requested (0x{:X}) for object id {}. Ignoring.", spec->size, id + i);
4176 spec->size = OBJECT_SIZE_1X1;
4177 }
4178 break;
4179
4180 case 0x0D: // Build cost multipler
4181 spec->build_cost_multiplier = buf->ReadByte();
4182 spec->clear_cost_multiplier = spec->build_cost_multiplier;
4183 break;
4184
4185 case 0x0E: // Introduction date
4186 spec->introduction_date = buf->ReadDWord();
4187 break;
4188
4189 case 0x0F: // End of life
4190 spec->end_of_life_date = buf->ReadDWord();
4191 break;
4192
4193 case 0x10: // Flags
4194 spec->flags = (ObjectFlags)buf->ReadWord();
4195 _loaded_newgrf_features.has_2CC |= (spec->flags & OBJECT_FLAG_2CC_COLOUR) != 0;
4196 break;
4197
4198 case 0x11: // Animation info
4199 spec->animation.frames = buf->ReadByte();
4200 spec->animation.status = buf->ReadByte();
4201 break;
4202
4203 case 0x12: // Animation speed
4204 spec->animation.speed = buf->ReadByte();
4205 break;
4206
4207 case 0x13: // Animation triggers
4208 spec->animation.triggers = buf->ReadWord();
4209 break;
4210
4211 case 0x14: // Removal cost multiplier
4212 spec->clear_cost_multiplier = buf->ReadByte();
4213 break;
4214
4215 case 0x15: // Callback mask
4216 spec->callback_mask = buf->ReadWord();
4217 break;
4218
4219 case 0x16: // Building height
4220 spec->height = buf->ReadByte();
4221 break;
4222
4223 case 0x17: // Views
4224 spec->views = buf->ReadByte();
4225 if (spec->views != 1 && spec->views != 2 && spec->views != 4) {
4226 GrfMsg(2, "ObjectChangeInfo: Invalid number of views ({}) for object id {}. Ignoring.", spec->views, id + i);
4227 spec->views = 1;
4228 }
4229 break;
4230
4231 case 0x18: // Amount placed on 256^2 map on map creation
4232 spec->generate_amount = buf->ReadByte();
4233 break;
4234
4235 default:
4236 ret = CIR_UNKNOWN;
4237 break;
4238 }
4239 }
4240
4241 return ret;
4242 }
4243
4252 static ChangeInfoResult RailTypeChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
4253 {
4254 ChangeInfoResult ret = CIR_SUCCESS;
4255
4256 extern RailTypeInfo _railtypes[RAILTYPE_END];
4257
4258 if (id + numinfo > RAILTYPE_END) {
4259 GrfMsg(1, "RailTypeChangeInfo: Rail type {} is invalid, max {}, ignoring", id + numinfo, RAILTYPE_END);
4260 return CIR_INVALID_ID;
4261 }
4262
4263 for (int i = 0; i < numinfo; i++) {
4264 RailType rt = _cur.grffile->railtype_map[id + i];
4265 if (rt == INVALID_RAILTYPE) return CIR_INVALID_ID;
4266
4267 RailTypeInfo *rti = &_railtypes[rt];
4268
4269 switch (prop) {
4270 case 0x08: // Label of rail type
4271 /* Skipped here as this is loaded during reservation stage. */
4272 buf->ReadDWord();
4273 break;
4274
4275 case 0x09: { // Toolbar caption of railtype (sets name as well for backwards compatibility for grf ver < 8)
4276 uint16_t str = buf->ReadWord();
4277 AddStringForMapping(str, &rti->strings.toolbar_caption);
4278 if (_cur.grffile->grf_version < 8) {
4279 AddStringForMapping(str, &rti->strings.name);
4280 }
4281 break;
4282 }
4283
4284 case 0x0A: // Menu text of railtype
4285 AddStringForMapping(buf->ReadWord(), &rti->strings.menu_text);
4286 break;
4287
4288 case 0x0B: // Build window caption
4289 AddStringForMapping(buf->ReadWord(), &rti->strings.build_caption);
4290 break;
4291
4292 case 0x0C: // Autoreplace text
4293 AddStringForMapping(buf->ReadWord(), &rti->strings.replace_text);
4294 break;
4295
4296 case 0x0D: // New locomotive text
4297 AddStringForMapping(buf->ReadWord(), &rti->strings.new_loco);
4298 break;
4299
4300 case 0x0E: // Compatible railtype list
4301 case 0x0F: // Powered railtype list
4302 case 0x18: // Railtype list required for date introduction
4303 case 0x19: // Introduced railtype list
4304 {
4305 /* Rail type compatibility bits are added to the existing bits
4306 * to allow multiple GRFs to modify compatibility with the
4307 * default rail types. */
4308 int n = buf->ReadByte();
4309 for (int j = 0; j != n; j++) {
4310 RailTypeLabel label = buf->ReadDWord();
4311 RailType resolved_rt = GetRailTypeByLabel(BSWAP32(label), false);
4312 if (resolved_rt != INVALID_RAILTYPE) {
4313 switch (prop) {
4314 case 0x0F: SetBit(rti->powered_railtypes, resolved_rt); [[fallthrough]]; // Powered implies compatible.
4315 case 0x0E: SetBit(rti->compatible_railtypes, resolved_rt); break;
4316 case 0x18: SetBit(rti->introduction_required_railtypes, resolved_rt); break;
4317 case 0x19: SetBit(rti->introduces_railtypes, resolved_rt); break;
4318 }
4319 }
4320 }
4321 break;
4322 }
4323
4324 case 0x10: // Rail Type flags
4325 rti->flags = (RailTypeFlags)buf->ReadByte();
4326 break;
4327
4328 case 0x11: // Curve speed advantage
4329 rti->curve_speed = buf->ReadByte();
4330 break;
4331
4332 case 0x12: // Station graphic
4333 rti->fallback_railtype = Clamp(buf->ReadByte(), 0, 2);
4334 break;
4335
4336 case 0x13: // Construction cost factor
4337 rti->cost_multiplier = buf->ReadWord();
4338 break;
4339
4340 case 0x14: // Speed limit
4341 rti->max_speed = buf->ReadWord();
4342 break;
4343
4344 case 0x15: // Acceleration model
4345 rti->acceleration_type = Clamp(buf->ReadByte(), 0, 2);
4346 break;
4347
4348 case 0x16: // Map colour
4349 rti->map_colour = buf->ReadByte();
4350 break;
4351
4352 case 0x17: // Introduction date
4353 rti->introduction_date = buf->ReadDWord();
4354 break;
4355
4356 case 0x1A: // Sort order
4357 rti->sorting_order = buf->ReadByte();
4358 break;
4359
4360 case 0x1B: // Name of railtype (overridden by prop 09 for grf ver < 8)
4361 AddStringForMapping(buf->ReadWord(), &rti->strings.name);
4362 break;
4363
4364 case 0x1C: // Maintenance cost factor
4365 rti->maintenance_multiplier = buf->ReadWord();
4366 break;
4367
4368 case 0x1D: // Alternate rail type label list
4369 /* Skipped here as this is loaded during reservation stage. */
4370 for (int j = buf->ReadByte(); j != 0; j--) buf->ReadDWord();
4371 break;
4372
4373 default:
4374 ret = CIR_UNKNOWN;
4375 break;
4376 }
4377 }
4378
4379 return ret;
4380 }
4381
4382 static ChangeInfoResult RailTypeReserveInfo(uint id, int numinfo, int prop, ByteReader *buf)
4383 {
4384 ChangeInfoResult ret = CIR_SUCCESS;
4385
4386 extern RailTypeInfo _railtypes[RAILTYPE_END];
4387
4388 if (id + numinfo > RAILTYPE_END) {
4389 GrfMsg(1, "RailTypeReserveInfo: Rail type {} is invalid, max {}, ignoring", id + numinfo, RAILTYPE_END);
4390 return CIR_INVALID_ID;
4391 }
4392
4393 for (int i = 0; i < numinfo; i++) {
4394 switch (prop) {
4395 case 0x08: // Label of rail type
4396 {
4397 RailTypeLabel rtl = buf->ReadDWord();
4398 rtl = BSWAP32(rtl);
4399
4400 RailType rt = GetRailTypeByLabel(rtl, false);
4401 if (rt == INVALID_RAILTYPE) {
4402 /* Set up new rail type */
4403 rt = AllocateRailType(rtl);
4404 }
4405
4406 _cur.grffile->railtype_map[id + i] = rt;
4407 break;
4408 }
4409
4410 case 0x09: // Toolbar caption of railtype
4411 case 0x0A: // Menu text
4412 case 0x0B: // Build window caption
4413 case 0x0C: // Autoreplace text
4414 case 0x0D: // New loco
4415 case 0x13: // Construction cost
4416 case 0x14: // Speed limit
4417 case 0x1B: // Name of railtype
4418 case 0x1C: // Maintenance cost factor
4419 buf->ReadWord();
4420 break;
4421
4422 case 0x1D: // Alternate rail type label list
4423 if (_cur.grffile->railtype_map[id + i] != INVALID_RAILTYPE) {
4424 int n = buf->ReadByte();
4425 for (int j = 0; j != n; j++) {
4426 _railtypes[_cur.grffile->railtype_map[id + i]].alternate_labels.push_back(BSWAP32(buf->ReadDWord()));
4427 }
4428 break;
4429 }
4430 GrfMsg(1, "RailTypeReserveInfo: Ignoring property 1D for rail type {} because no label was set", id + i);
4431 [[fallthrough]];
4432
4433 case 0x0E: // Compatible railtype list
4434 case 0x0F: // Powered railtype list
4435 case 0x18: // Railtype list required for date introduction
4436 case 0x19: // Introduced railtype list
4437 for (int j = buf->ReadByte(); j != 0; j--) buf->ReadDWord();
4438 break;
4439
4440 case 0x10: // Rail Type flags
4441 case 0x11: // Curve speed advantage
4442 case 0x12: // Station graphic
4443 case 0x15: // Acceleration model
4444 case 0x16: // Map colour
4445 case 0x1A: // Sort order
4446 buf->ReadByte();
4447 break;
4448
4449 case 0x17: // Introduction date
4450 buf->ReadDWord();
4451 break;
4452
4453 default:
4454 ret = CIR_UNKNOWN;
4455 break;
4456 }
4457 }
4458
4459 return ret;
4460 }
4461
4470 static ChangeInfoResult RoadTypeChangeInfo(uint id, int numinfo, int prop, ByteReader *buf, RoadTramType rtt)
4471 {
4472 ChangeInfoResult ret = CIR_SUCCESS;
4473
4474 extern RoadTypeInfo _roadtypes[ROADTYPE_END];
4475 RoadType *type_map = (rtt == RTT_TRAM) ? _cur.grffile->tramtype_map : _cur.grffile->roadtype_map;
4476
4477 if (id + numinfo > ROADTYPE_END) {
4478 GrfMsg(1, "RoadTypeChangeInfo: Road type {} is invalid, max {}, ignoring", id + numinfo, ROADTYPE_END);
4479 return CIR_INVALID_ID;
4480 }
4481
4482 for (int i = 0; i < numinfo; i++) {
4483 RoadType rt = type_map[id + i];
4484 if (rt == INVALID_ROADTYPE) return CIR_INVALID_ID;
4485
4486 RoadTypeInfo *rti = &_roadtypes[rt];
4487
4488 switch (prop) {
4489 case 0x08: // Label of road type
4490 /* Skipped here as this is loaded during reservation stage. */
4491 buf->ReadDWord();
4492 break;
4493
4494 case 0x09: { // Toolbar caption of roadtype (sets name as well for backwards compatibility for grf ver < 8)
4495 uint16_t str = buf->ReadWord();
4496 AddStringForMapping(str, &rti->strings.toolbar_caption);
4497 break;
4498 }
4499
4500 case 0x0A: // Menu text of roadtype
4501 AddStringForMapping(buf->ReadWord(), &rti->strings.menu_text);
4502 break;
4503
4504 case 0x0B: // Build window caption
4505 AddStringForMapping(buf->ReadWord(), &rti->strings.build_caption);
4506 break;
4507
4508 case 0x0C: // Autoreplace text
4509 AddStringForMapping(buf->ReadWord(), &rti->strings.replace_text);
4510 break;
4511
4512 case 0x0D: // New engine text
4513 AddStringForMapping(buf->ReadWord(), &rti->strings.new_engine);
4514 break;
4515
4516 case 0x0F: // Powered roadtype list
4517 case 0x18: // Roadtype list required for date introduction
4518 case 0x19: { // Introduced roadtype list
4519 /* Road type compatibility bits are added to the existing bits
4520 * to allow multiple GRFs to modify compatibility with the
4521 * default road types. */
4522 int n = buf->ReadByte();
4523 for (int j = 0; j != n; j++) {
4524 RoadTypeLabel label = buf->ReadDWord();
4525 RoadType resolved_rt = GetRoadTypeByLabel(BSWAP32(label), false);
4526 if (resolved_rt != INVALID_ROADTYPE) {
4527 switch (prop) {
4528 case 0x0F:
4529 if (GetRoadTramType(resolved_rt) == rtt) {
4530 SetBit(rti->powered_roadtypes, resolved_rt);
4531 } else {
4532 GrfMsg(1, "RoadTypeChangeInfo: Powered road type list: Road type {} road/tram type does not match road type {}, ignoring", resolved_rt, rt);
4533 }
4534 break;
4535 case 0x18: SetBit(rti->introduction_required_roadtypes, resolved_rt); break;
4536 case 0x19: SetBit(rti->introduces_roadtypes, resolved_rt); break;
4537 }
4538 }
4539 }
4540 break;
4541 }
4542
4543 case 0x10: // Road Type flags
4544 rti->flags = (RoadTypeFlags)buf->ReadByte();
4545 break;
4546
4547 case 0x13: // Construction cost factor
4548 rti->cost_multiplier = buf->ReadWord();
4549 break;
4550
4551 case 0x14: // Speed limit
4552 rti->max_speed = buf->ReadWord();
4553 break;
4554
4555 case 0x16: // Map colour
4556 rti->map_colour = buf->ReadByte();
4557 break;
4558
4559 case 0x17: // Introduction date
4560 rti->introduction_date = buf->ReadDWord();
4561 break;
4562
4563 case 0x1A: // Sort order
4564 rti->sorting_order = buf->ReadByte();
4565 break;
4566
4567 case 0x1B: // Name of roadtype
4568 AddStringForMapping(buf->ReadWord(), &rti->strings.name);
4569 break;
4570
4571 case 0x1C: // Maintenance cost factor
4572 rti->maintenance_multiplier = buf->ReadWord();
4573 break;
4574
4575 case 0x1D: // Alternate road type label list
4576 /* Skipped here as this is loaded during reservation stage. */
4577 for (int j = buf->ReadByte(); j != 0; j--) buf->ReadDWord();
4578 break;
4579
4580 default:
4581 ret = CIR_UNKNOWN;
4582 break;
4583 }
4584 }
4585
4586 return ret;
4587 }
4588
4589 static ChangeInfoResult RoadTypeChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
4590 {
4591 return RoadTypeChangeInfo(id, numinfo, prop, buf, RTT_ROAD);
4592 }
4593
4594 static ChangeInfoResult TramTypeChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
4595 {
4596 return RoadTypeChangeInfo(id, numinfo, prop, buf, RTT_TRAM);
4597 }
4598
4599
4600 static ChangeInfoResult RoadTypeReserveInfo(uint id, int numinfo, int prop, ByteReader *buf, RoadTramType rtt)
4601 {
4602 ChangeInfoResult ret = CIR_SUCCESS;
4603
4604 extern RoadTypeInfo _roadtypes[ROADTYPE_END];
4605 RoadType *type_map = (rtt == RTT_TRAM) ? _cur.grffile->tramtype_map : _cur.grffile->roadtype_map;
4606
4607 if (id + numinfo > ROADTYPE_END) {
4608 GrfMsg(1, "RoadTypeReserveInfo: Road type {} is invalid, max {}, ignoring", id + numinfo, ROADTYPE_END);
4609 return CIR_INVALID_ID;
4610 }
4611
4612 for (int i = 0; i < numinfo; i++) {
4613 switch (prop) {
4614 case 0x08: { // Label of road type
4615 RoadTypeLabel rtl = buf->ReadDWord();
4616 rtl = BSWAP32(rtl);
4617
4618 RoadType rt = GetRoadTypeByLabel(rtl, false);
4619 if (rt == INVALID_ROADTYPE) {
4620 /* Set up new road type */
4621 rt = AllocateRoadType(rtl, rtt);
4622 } else if (GetRoadTramType(rt) != rtt) {
4623 GrfMsg(1, "RoadTypeReserveInfo: Road type {} is invalid type (road/tram), ignoring", id + numinfo);
4624 return CIR_INVALID_ID;
4625 }
4626
4627 type_map[id + i] = rt;
4628 break;
4629 }
4630 case 0x09: // Toolbar caption of roadtype
4631 case 0x0A: // Menu text
4632 case 0x0B: // Build window caption
4633 case 0x0C: // Autoreplace text
4634 case 0x0D: // New loco
4635 case 0x13: // Construction cost
4636 case 0x14: // Speed limit
4637 case 0x1B: // Name of roadtype
4638 case 0x1C: // Maintenance cost factor
4639 buf->ReadWord();
4640 break;
4641
4642 case 0x1D: // Alternate road type label list
4643 if (type_map[id + i] != INVALID_ROADTYPE) {
4644 int n = buf->ReadByte();
4645 for (int j = 0; j != n; j++) {
4646 _roadtypes[type_map[id + i]].alternate_labels.push_back(BSWAP32(buf->ReadDWord()));
4647 }
4648 break;
4649 }
4650 GrfMsg(1, "RoadTypeReserveInfo: Ignoring property 1D for road type {} because no label was set", id + i);
4651 /* FALL THROUGH */
4652
4653 case 0x0F: // Powered roadtype list
4654 case 0x18: // Roadtype list required for date introduction
4655 case 0x19: // Introduced roadtype list
4656 for (int j = buf->ReadByte(); j != 0; j--) buf->ReadDWord();
4657 break;
4658
4659 case 0x10: // Road Type flags
4660 case 0x16: // Map colour
4661 case 0x1A: // Sort order
4662 buf->ReadByte();
4663 break;
4664
4665 case 0x17: // Introduction date
4666 buf->ReadDWord();
4667 break;
4668
4669 default:
4670 ret = CIR_UNKNOWN;
4671 break;
4672 }
4673 }
4674
4675 return ret;
4676 }
4677
4678 static ChangeInfoResult RoadTypeReserveInfo(uint id, int numinfo, int prop, ByteReader *buf)
4679 {
4680 return RoadTypeReserveInfo(id, numinfo, prop, buf, RTT_ROAD);
4681 }
4682
4683 static ChangeInfoResult TramTypeReserveInfo(uint id, int numinfo, int prop, ByteReader *buf)
4684 {
4685 return RoadTypeReserveInfo(id, numinfo, prop, buf, RTT_TRAM);
4686 }
4687
4688 static ChangeInfoResult AirportTilesChangeInfo(uint airtid, int numinfo, int prop, ByteReader *buf)
4689 {
4690 ChangeInfoResult ret = CIR_SUCCESS;
4691
4692 if (airtid + numinfo > NUM_AIRPORTTILES_PER_GRF) {
4693 GrfMsg(1, "AirportTileChangeInfo: Too many airport tiles loaded ({}), max ({}). Ignoring.", airtid + numinfo, NUM_AIRPORTTILES_PER_GRF);
4694 return CIR_INVALID_ID;
4695 }
4696
4697 /* Allocate airport tile specs if they haven't been allocated already. */
4698 if (_cur.grffile->airtspec.size() < airtid + numinfo) _cur.grffile->airtspec.resize(airtid + numinfo);
4699
4700 for (int i = 0; i < numinfo; i++) {
4701 AirportTileSpec *tsp = _cur.grffile->airtspec[airtid + i].get();
4702
4703 if (prop != 0x08 && tsp == nullptr) {
4704 GrfMsg(2, "AirportTileChangeInfo: Attempt to modify undefined airport tile {}. Ignoring.", airtid + i);
4705 return CIR_INVALID_ID;
4706 }
4707
4708 switch (prop) {
4709 case 0x08: { // Substitute airport tile type
4710 byte subs_id = buf->ReadByte();
4711 if (subs_id >= NEW_AIRPORTTILE_OFFSET) {
4712 /* The substitute id must be one of the original airport tiles. */
4713 GrfMsg(2, "AirportTileChangeInfo: Attempt to use new airport tile {} as substitute airport tile for {}. Ignoring.", subs_id, airtid + i);
4714 continue;
4715 }
4716
4717 /* Allocate space for this airport tile. */
4718 if (tsp == nullptr) {
4719 _cur.grffile->airtspec[airtid + i] = std::make_unique<AirportTileSpec>(*AirportTileSpec::Get(subs_id));
4720 tsp = _cur.grffile->airtspec[airtid + i].get();
4721
4722 tsp->enabled = true;
4723
4724 tsp->animation.status = ANIM_STATUS_NO_ANIMATION;
4725
4726 tsp->grf_prop.local_id = airtid + i;
4727 tsp->grf_prop.subst_id = subs_id;
4728 tsp->grf_prop.grffile = _cur.grffile;
4729 _airporttile_mngr.AddEntityID(airtid + i, _cur.grffile->grfid, subs_id); // pre-reserve the tile slot
4730 }
4731 break;
4732 }
4733
4734 case 0x09: { // Airport tile override
4735 byte override = buf->ReadByte();
4736
4737 /* The airport tile being overridden must be an original airport tile. */
4738 if (override >= NEW_AIRPORTTILE_OFFSET) {
4739 GrfMsg(2, "AirportTileChangeInfo: Attempt to override new airport tile {} with airport tile id {}. Ignoring.", override, airtid + i);
4740 continue;
4741 }
4742
4743 _airporttile_mngr.Add(airtid + i, _cur.grffile->grfid, override);
4744 break;
4745 }
4746
4747 case 0x0E: // Callback mask
4748 tsp->callback_mask = buf->ReadByte();
4749 break;
4750
4751 case 0x0F: // Animation information
4752 tsp->animation.frames = buf->ReadByte();
4753 tsp->animation.status = buf->ReadByte();
4754 break;
4755
4756 case 0x10: // Animation speed
4757 tsp->animation.speed = buf->ReadByte();
4758 break;
4759
4760 case 0x11: // Animation triggers
4761 tsp->animation.triggers = buf->ReadByte();
4762 break;
4763
4764 default:
4765 ret = CIR_UNKNOWN;
4766 break;
4767 }
4768 }
4769
4770 return ret;
4771 }
4772
4779 static ChangeInfoResult IgnoreRoadStopProperty(uint prop, ByteReader *buf)
4780 {
4781 ChangeInfoResult ret = CIR_SUCCESS;
4782
4783 switch (prop) {
4784 case 0x09:
4785 case 0x0C:
4786 case 0x0F:
4787 case 0x11:
4788 buf->ReadByte();
4789 break;
4790
4791 case 0x0A:
4792 case 0x0B:
4793 case 0x0E:
4794 case 0x10:
4795 case 0x15:
4796 buf->ReadWord();
4797 break;
4798
4799 case 0x08:
4800 case 0x0D:
4801 case 0x12:
4802 buf->ReadDWord();
4803 break;
4804
4805 default:
4806 ret = CIR_UNKNOWN;
4807 break;
4808 }
4809
4810 return ret;
4811 }
4812
4813 static ChangeInfoResult RoadStopChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
4814 {
4815 ChangeInfoResult ret = CIR_SUCCESS;
4816
4817 if (id + numinfo > NUM_ROADSTOPS_PER_GRF) {
4818 GrfMsg(1, "RoadStopChangeInfo: RoadStop {} is invalid, max {}, ignoring", id + numinfo, NUM_ROADSTOPS_PER_GRF);
4819 return CIR_INVALID_ID;
4820 }
4821
4822 if (_cur.grffile->roadstops.size() < id + numinfo) _cur.grffile->roadstops.resize(id + numinfo);
4823
4824 for (int i = 0; i < numinfo; i++) {
4825 RoadStopSpec *rs = _cur.grffile->roadstops[id + i].get();
4826
4827 if (rs == nullptr && prop != 0x08) {
4828 GrfMsg(1, "RoadStopChangeInfo: Attempt to modify undefined road stop {}, ignoring", id + i);
4829 ChangeInfoResult cir = IgnoreRoadStopProperty(prop, buf);
4830 if (cir > ret) ret = cir;
4831 continue;
4832 }
4833
4834 switch (prop) {
4835 case 0x08: { // Road Stop Class ID
4836 if (rs == nullptr) {
4837 _cur.grffile->roadstops[id + i] = std::make_unique<RoadStopSpec>();
4838 rs = _cur.grffile->roadstops[id + i].get();
4839 }
4840
4841 uint32_t classid = buf->ReadDWord();
4842 rs->cls_id = RoadStopClass::Allocate(BSWAP32(classid));
4843 rs->spec_id = id + i;
4844 break;
4845 }
4846
4847 case 0x09: // Road stop type
4848 rs->stop_type = (RoadStopAvailabilityType)buf->ReadByte();
4849 break;
4850
4851 case 0x0A: // Road Stop Name
4852 AddStringForMapping(buf->ReadWord(), &rs->name);
4853 break;
4854
4855 case 0x0B: // Road Stop Class name
4856 AddStringForMapping(buf->ReadWord(), &RoadStopClass::Get(rs->cls_id)->name);
4857 break;
4858
4859 case 0x0C: // The draw mode
4860 rs->draw_mode = (RoadStopDrawMode)buf->ReadByte();
4861 break;
4862
4863 case 0x0D: // Cargo types for random triggers
4864 rs->cargo_triggers = TranslateRefitMask(buf->ReadDWord());
4865 break;
4866
4867 case 0x0E: // Animation info
4868 rs->animation.frames = buf->ReadByte();
4869 rs->animation.status = buf->ReadByte();
4870 break;
4871
4872 case 0x0F: // Animation speed
4873 rs->animation.speed = buf->ReadByte();
4874 break;
4875
4876 case 0x10: // Animation triggers
4877 rs->animation.triggers = buf->ReadWord();
4878 break;
4879
4880 case 0x11: // Callback mask
4881 rs->callback_mask = buf->ReadByte();
4882 break;
4883
4884 case 0x12: // General flags
4885 rs->flags = (uint8_t)buf->ReadDWord(); // Future-proofing, size this as 4 bytes, but we only need one byte's worth of flags at present
4886 break;
4887
4888 case 0x15: // Cost multipliers
4889 rs->build_cost_multiplier = buf->ReadByte();
4890 rs->clear_cost_multiplier = buf->ReadByte();
4891 break;
4892
4893 default:
4894 ret = CIR_UNKNOWN;
4895 break;
4896 }
4897 }
4898
4899 return ret;
4900 }
4901
4902 static bool HandleChangeInfoResult(const char *caller, ChangeInfoResult cir, uint8_t feature, uint8_t property)
4903 {
4904 switch (cir) {
4905 default: NOT_REACHED();
4906
4907 case CIR_DISABLED:
4908 /* Error has already been printed; just stop parsing */
4909 return true;
4910
4911 case CIR_SUCCESS:
4912 return false;
4913
4914 case CIR_UNHANDLED:
4915 GrfMsg(1, "{}: Ignoring property 0x{:02X} of feature 0x{:02X} (not implemented)", caller, property, feature);
4916 return false;
4917
4918 case CIR_UNKNOWN:
4919 GrfMsg(0, "{}: Unknown property 0x{:02X} of feature 0x{:02X}, disabling", caller, property, feature);
4920 [[fallthrough]];
4921
4922 case CIR_INVALID_ID: {
4923 /* No debug message for an invalid ID, as it has already been output */
4924 GRFError *error = DisableGrf(cir == CIR_INVALID_ID ? STR_NEWGRF_ERROR_INVALID_ID : STR_NEWGRF_ERROR_UNKNOWN_PROPERTY);
4925 if (cir != CIR_INVALID_ID) error->param_value[1] = property;
4926 return true;
4927 }
4928 }
4929 }
4930
4931 /* Action 0x00 */
4932 static void FeatureChangeInfo(ByteReader *buf)
4933 {
4934 /* <00> <feature> <num-props> <num-info> <id> (<property <new-info>)...
4935 *
4936 * B feature
4937 * B num-props how many properties to change per vehicle/station
4938 * B num-info how many vehicles/stations to change
4939 * E id ID of first vehicle/station to change, if num-info is
4940 * greater than one, this one and the following
4941 * vehicles/stations will be changed
4942 * B property what property to change, depends on the feature
4943 * V new-info new bytes of info (variable size; depends on properties) */
4944
4945 static const VCI_Handler handler[] = {
4946 /* GSF_TRAINS */ RailVehicleChangeInfo,
4947 /* GSF_ROADVEHICLES */ RoadVehicleChangeInfo,
4948 /* GSF_SHIPS */ ShipVehicleChangeInfo,
4949 /* GSF_AIRCRAFT */ AircraftVehicleChangeInfo,
4950 /* GSF_STATIONS */ StationChangeInfo,
4951 /* GSF_CANALS */ CanalChangeInfo,
4952 /* GSF_BRIDGES */ BridgeChangeInfo,
4953 /* GSF_HOUSES */ TownHouseChangeInfo,
4954 /* GSF_GLOBALVAR */ GlobalVarChangeInfo,
4955 /* GSF_INDUSTRYTILES */ IndustrytilesChangeInfo,
4956 /* GSF_INDUSTRIES */ IndustriesChangeInfo,
4957 /* GSF_CARGOES */ nullptr, // Cargo is handled during reservation
4958 /* GSF_SOUNDFX */ SoundEffectChangeInfo,
4959 /* GSF_AIRPORTS */ AirportChangeInfo,
4960 /* GSF_SIGNALS */ nullptr,
4961 /* GSF_OBJECTS */ ObjectChangeInfo,
4962 /* GSF_RAILTYPES */ RailTypeChangeInfo,
4963 /* GSF_AIRPORTTILES */ AirportTilesChangeInfo,
4964 /* GSF_ROADTYPES */ RoadTypeChangeInfo,
4965 /* GSF_TRAMTYPES */ TramTypeChangeInfo,
4966 /* GSF_ROADSTOPS */ RoadStopChangeInfo,
4967 };
4968 static_assert(GSF_END == lengthof(handler));
4969
4970 uint8_t feature = buf->ReadByte();
4971 uint8_t numprops = buf->ReadByte();
4972 uint numinfo = buf->ReadByte();
4973 uint engine = buf->ReadExtendedByte();
4974
4975 if (feature >= GSF_END) {
4976 GrfMsg(1, "FeatureChangeInfo: Unsupported feature 0x{:02X}, skipping", feature);
4977 return;
4978 }
4979
4980 GrfMsg(6, "FeatureChangeInfo: Feature 0x{:02X}, {} properties, to apply to {}+{}",
4981 feature, numprops, engine, numinfo);
4982
4983 if (handler[feature] == nullptr) {
4984 if (feature != GSF_CARGOES) GrfMsg(1, "FeatureChangeInfo: Unsupported feature 0x{:02X}, skipping", feature);
4985 return;
4986 }
4987
4988 /* Mark the feature as used by the grf */
4989 SetBit(_cur.grffile->grf_features, feature);
4990
4991 while (numprops-- && buf->HasData()) {
4992 uint8_t prop = buf->ReadByte();
4993
4994 ChangeInfoResult cir = handler[feature](engine, numinfo, prop, buf);
4995 if (HandleChangeInfoResult("FeatureChangeInfo", cir, feature, prop)) return;
4996 }
4997 }
4998
4999 /* Action 0x00 (GLS_SAFETYSCAN) */
5000 static void SafeChangeInfo(ByteReader *buf)
5001 {
5002 uint8_t feature = buf->ReadByte();
5003 uint8_t numprops = buf->ReadByte();
5004 uint numinfo = buf->ReadByte();
5005 buf->ReadExtendedByte(); // id
5006
5007 if (feature == GSF_BRIDGES && numprops == 1) {
5008 uint8_t prop = buf->ReadByte();
5009 /* Bridge property 0x0D is redefinition of sprite layout tables, which
5010 * is considered safe. */
5011 if (prop == 0x0D) return;
5012 } else if (feature == GSF_GLOBALVAR && numprops == 1) {
5013 uint8_t prop = buf->ReadByte();
5014 /* Engine ID Mappings are safe, if the source is static */
5015 if (prop == 0x11) {
5016 bool is_safe = true;
5017 for (uint i = 0; i < numinfo; i++) {
5018 uint32_t s = buf->ReadDWord();
5019 buf->ReadDWord(); // dest
5020 const GRFConfig *grfconfig = GetGRFConfig(s);
5021 if (grfconfig != nullptr && !HasBit(grfconfig->flags, GCF_STATIC)) {
5022 is_safe = false;
5023 break;
5024 }
5025 }
5026 if (is_safe) return;
5027 }
5028 }
5029
5030 SetBit(_cur.grfconfig->flags, GCF_UNSAFE);
5031
5032 /* Skip remainder of GRF */
5033 _cur.skip_sprites = -1;
5034 }
5035
5036 /* Action 0x00 (GLS_RESERVE) */
5037 static void ReserveChangeInfo(ByteReader *buf)
5038 {
5039 uint8_t feature = buf->ReadByte();
5040
5041 if (feature != GSF_CARGOES && feature != GSF_GLOBALVAR && feature != GSF_RAILTYPES && feature != GSF_ROADTYPES && feature != GSF_TRAMTYPES) return;
5042
5043 uint8_t numprops = buf->ReadByte();
5044 uint8_t numinfo = buf->ReadByte();
5045 uint8_t index = buf->ReadExtendedByte();
5046
5047 while (numprops-- && buf->HasData()) {
5048 uint8_t prop = buf->ReadByte();
5049 ChangeInfoResult cir = CIR_SUCCESS;
5050
5051 switch (feature) {
5052 default: NOT_REACHED();
5053 case GSF_CARGOES:
5054 cir = CargoChangeInfo(index, numinfo, prop, buf);
5055 break;
5056
5057 case GSF_GLOBALVAR:
5058 cir = GlobalVarReserveInfo(index, numinfo, prop, buf);
5059 break;
5060
5061 case GSF_RAILTYPES:
5062 cir = RailTypeReserveInfo(index, numinfo, prop, buf);
5063 break;
5064
5065 case GSF_ROADTYPES:
5066 cir = RoadTypeReserveInfo(index, numinfo, prop, buf);
5067 break;
5068
5069 case GSF_TRAMTYPES:
5070 cir = TramTypeReserveInfo(index, numinfo, prop, buf);
5071 break;
5072 }
5073
5074 if (HandleChangeInfoResult("ReserveChangeInfo", cir, feature, prop)) return;
5075 }
5076 }
5077
5078 /* Action 0x01 */
5079 static void NewSpriteSet(ByteReader *buf)
5080 {
5081 /* Basic format: <01> <feature> <num-sets> <num-ent>
5082 * Extended format: <01> <feature> 00 <first-set> <num-sets> <num-ent>
5083 *
5084 * B feature feature to define sprites for
5085 * 0, 1, 2, 3: veh-type, 4: train stations
5086 * E first-set first sprite set to define
5087 * B num-sets number of sprite sets (extended byte in extended format)
5088 * E num-ent how many entries per sprite set
5089 * For vehicles, this is the number of different
5090 * vehicle directions in each sprite set
5091 * Set num-dirs=8, unless your sprites are symmetric.
5092 * In that case, use num-dirs=4.
5093 */
5094
5095 uint8_t feature = buf->ReadByte();
5096 uint16_t num_sets = buf->ReadByte();
5097 uint16_t first_set = 0;
5098
5099 if (num_sets == 0 && buf->HasData(3)) {
5100 /* Extended Action1 format.
5101 * Some GRFs define zero sets of zero sprites, though there is actually no use in that. Ignore them. */
5102 first_set = buf->ReadExtendedByte();
5103 num_sets = buf->ReadExtendedByte();
5104 }
5105 uint16_t num_ents = buf->ReadExtendedByte();
5106
5107 if (feature >= GSF_END) {
5108 _cur.skip_sprites = num_sets * num_ents;
5109 GrfMsg(1, "NewSpriteSet: Unsupported feature 0x{:02X}, skipping {} sprites", feature, _cur.skip_sprites);
5110 return;
5111 }
5112
5113 _cur.AddSpriteSets(feature, _cur.spriteid, first_set, num_sets, num_ents);
5114
5115 GrfMsg(7, "New sprite set at {} of feature 0x{:02X}, consisting of {} sets with {} views each (total {})",
5116 _cur.spriteid, feature, num_sets, num_ents, num_sets * num_ents
5117 );
5118
5119 for (int i = 0; i < num_sets * num_ents; i++) {
5120 _cur.nfo_line++;
5121 LoadNextSprite(_cur.spriteid++, *_cur.file, _cur.nfo_line);
5122 }
5123 }
5124
5125 /* Action 0x01 (SKIP) */
5126 static void SkipAct1(ByteReader *buf)
5127 {
5128 buf->ReadByte();
5129 uint16_t num_sets = buf->ReadByte();
5130
5131 if (num_sets == 0 && buf->HasData(3)) {
5132 /* Extended Action1 format.
5133 * Some GRFs define zero sets of zero sprites, though there is actually no use in that. Ignore them. */
5134 buf->ReadExtendedByte(); // first_set
5135 num_sets = buf->ReadExtendedByte();
5136 }
5137 uint16_t num_ents = buf->ReadExtendedByte();
5138
5139 _cur.skip_sprites = num_sets * num_ents;
5140
5141 GrfMsg(3, "SkipAct1: Skipping {} sprites", _cur.skip_sprites);
5142 }
5143
5144 /* Helper function to either create a callback or link to a previously
5145 * defined spritegroup. */
5146 static const SpriteGroup *GetGroupFromGroupID(byte setid, byte type, uint16_t groupid)
5147 {
5148 if (HasBit(groupid, 15)) {
5149 assert(CallbackResultSpriteGroup::CanAllocateItem());
5150 return new CallbackResultSpriteGroup(groupid, _cur.grffile->grf_version >= 8);
5151 }
5152
5153 if (groupid > MAX_SPRITEGROUP || _cur.spritegroups[groupid] == nullptr) {
5154 GrfMsg(1, "GetGroupFromGroupID(0x{:02X}:0x{:02X}): Groupid 0x{:04X} does not exist, leaving empty", setid, type, groupid);
5155 return nullptr;
5156 }
5157
5158 return _cur.spritegroups[groupid];
5159 }
5160
5169 static const SpriteGroup *CreateGroupFromGroupID(byte feature, byte setid, byte type, uint16_t spriteid)
5170 {
5171 if (HasBit(spriteid, 15)) {
5172 assert(CallbackResultSpriteGroup::CanAllocateItem());
5173 return new CallbackResultSpriteGroup(spriteid, _cur.grffile->grf_version >= 8);
5174 }
5175
5176 if (!_cur.IsValidSpriteSet(feature, spriteid)) {
5177 GrfMsg(1, "CreateGroupFromGroupID(0x{:02X}:0x{:02X}): Sprite set {} invalid", setid, type, spriteid);
5178 return nullptr;
5179 }
5180
5181 SpriteID spriteset_start = _cur.GetSprite(feature, spriteid);
5182 uint num_sprites = _cur.GetNumEnts(feature, spriteid);
5183
5184 /* Ensure that the sprites are loeded */
5185 assert(spriteset_start + num_sprites <= _cur.spriteid);
5186
5187 assert(ResultSpriteGroup::CanAllocateItem());
5188 return new ResultSpriteGroup(spriteset_start, num_sprites);
5189 }
5190
5191 /* Action 0x02 */
5192 static void NewSpriteGroup(ByteReader *buf)
5193 {
5194 /* <02> <feature> <set-id> <type/num-entries> <feature-specific-data...>
5195 *
5196 * B feature see action 1
5197 * B set-id ID of this particular definition
5198 * B type/num-entries
5199 * if 80 or greater, this is a randomized or variational
5200 * list definition, see below
5201 * otherwise it specifies a number of entries, the exact
5202 * meaning depends on the feature
5203 * V feature-specific-data (huge mess, don't even look it up --pasky) */
5204 const SpriteGroup *act_group = nullptr;
5205
5206 uint8_t feature = buf->ReadByte();
5207 if (feature >= GSF_END) {
5208 GrfMsg(1, "NewSpriteGroup: Unsupported feature 0x{:02X}, skipping", feature);
5209 return;
5210 }
5211
5212 uint8_t setid = buf->ReadByte();
5213 uint8_t type = buf->ReadByte();
5214
5215 /* Sprite Groups are created here but they are allocated from a pool, so
5216 * we do not need to delete anything if there is an exception from the
5217 * ByteReader. */
5218
5219 switch (type) {
5220 /* Deterministic Sprite Group */
5221 case 0x81: // Self scope, byte
5222 case 0x82: // Parent scope, byte
5223 case 0x85: // Self scope, word
5224 case 0x86: // Parent scope, word
5225 case 0x89: // Self scope, dword
5226 case 0x8A: // Parent scope, dword
5227 {
5228 byte varadjust;
5229 byte varsize;
5230
5231 assert(DeterministicSpriteGroup::CanAllocateItem());
5232 DeterministicSpriteGroup *group = new DeterministicSpriteGroup();
5233 group->nfo_line = _cur.nfo_line;
5234 act_group = group;
5235 group->var_scope = HasBit(type, 1) ? VSG_SCOPE_PARENT : VSG_SCOPE_SELF;
5236
5237 switch (GB(type, 2, 2)) {
5238 default: NOT_REACHED();
5239 case 0: group->size = DSG_SIZE_BYTE; varsize = 1; break;
5240 case 1: group->size = DSG_SIZE_WORD; varsize = 2; break;
5241 case 2: group->size = DSG_SIZE_DWORD; varsize = 4; break;
5242 }
5243
5244 /* Loop through the var adjusts. Unfortunately we don't know how many we have
5245 * from the outset, so we shall have to keep reallocing. */
5246 do {
5247 DeterministicSpriteGroupAdjust &adjust = group->adjusts.emplace_back();
5248
5249 /* The first var adjust doesn't have an operation specified, so we set it to add. */
5250 adjust.operation = group->adjusts.size() == 1 ? DSGA_OP_ADD : (DeterministicSpriteGroupAdjustOperation)buf->ReadByte();
5251 adjust.variable = buf->ReadByte();
5252 if (adjust.variable == 0x7E) {
5253 /* Link subroutine group */
5254 adjust.subroutine = GetGroupFromGroupID(setid, type, buf->ReadByte());
5255 } else {
5256 adjust.parameter = IsInsideMM(adjust.variable, 0x60, 0x80) ? buf->ReadByte() : 0;
5257 }
5258
5259 varadjust = buf->ReadByte();
5260 adjust.shift_num = GB(varadjust, 0, 5);
5261 adjust.type = (DeterministicSpriteGroupAdjustType)GB(varadjust, 6, 2);
5262 adjust.and_mask = buf->ReadVarSize(varsize);
5263
5264 if (adjust.type != DSGA_TYPE_NONE) {
5265 adjust.add_val = buf->ReadVarSize(varsize);
5266 adjust.divmod_val = buf->ReadVarSize(varsize);
5267 } else {
5268 adjust.add_val = 0;
5269 adjust.divmod_val = 0;
5270 }
5271
5272 /* Continue reading var adjusts while bit 5 is set. */
5273 } while (HasBit(varadjust, 5));
5274
5275 std::vector<DeterministicSpriteGroupRange> ranges;
5276 ranges.resize(buf->ReadByte());
5277 for (uint i = 0; i < ranges.size(); i++) {
5278 ranges[i].group = GetGroupFromGroupID(setid, type, buf->ReadWord());
5279 ranges[i].low = buf->ReadVarSize(varsize);
5280 ranges[i].high = buf->ReadVarSize(varsize);
5281 }
5282
5283 group->default_group = GetGroupFromGroupID(setid, type, buf->ReadWord());
5284 group->error_group = ranges.empty() ? group->default_group : ranges[0].group;
5285 /* nvar == 0 is a special case -- we turn our value into a callback result */
5286 group->calculated_result = ranges.empty();
5287
5288 /* Sort ranges ascending. When ranges overlap, this may required clamping or splitting them */
5289 std::vector<uint32_t> bounds;
5290 for (uint i = 0; i < ranges.size(); i++) {
5291 bounds.push_back(ranges[i].low);
5292 if (ranges[i].high != UINT32_MAX) bounds.push_back(ranges[i].high + 1);
5293 }
5294 std::sort(bounds.begin(), bounds.end());
5295 bounds.erase(std::unique(bounds.begin(), bounds.end()), bounds.end());
5296
5297 std::vector<const SpriteGroup *> target;
5298 for (uint j = 0; j < bounds.size(); ++j) {
5299 uint32_t v = bounds[j];
5300 const SpriteGroup *t = group->default_group;
5301 for (uint i = 0; i < ranges.size(); i++) {
5302 if (ranges[i].low <= v && v <= ranges[i].high) {
5303 t = ranges[i].group;
5304 break;
5305 }
5306 }
5307 target.push_back(t);
5308 }
5309 assert(target.size() == bounds.size());
5310
5311 for (uint j = 0; j < bounds.size(); ) {
5312 if (target[j] != group->default_group) {
5313 DeterministicSpriteGroupRange &r = group->ranges.emplace_back();
5314 r.group = target[j];
5315 r.low = bounds[j];
5316 while (j < bounds.size() && target[j] == r.group) {
5317 j++;
5318 }
5319 r.high = j < bounds.size() ? bounds[j] - 1 : UINT32_MAX;
5320 } else {
5321 j++;
5322 }
5323 }
5324
5325 break;
5326 }
5327
5328 /* Randomized Sprite Group */
5329 case 0x80: // Self scope
5330 case 0x83: // Parent scope
5331 case 0x84: // Relative scope
5332 {
5333 assert(RandomizedSpriteGroup::CanAllocateItem());
5334 RandomizedSpriteGroup *group = new RandomizedSpriteGroup();
5335 group->nfo_line = _cur.nfo_line;
5336 act_group = group;
5337 group->var_scope = HasBit(type, 1) ? VSG_SCOPE_PARENT : VSG_SCOPE_SELF;
5338
5339 if (HasBit(type, 2)) {
5340 if (feature <= GSF_AIRCRAFT) group->var_scope = VSG_SCOPE_RELATIVE;
5341 group->count = buf->ReadByte();
5342 }
5343
5344 uint8_t triggers = buf->ReadByte();
5345 group->triggers = GB(triggers, 0, 7);
5346 group->cmp_mode = HasBit(triggers, 7) ? RSG_CMP_ALL : RSG_CMP_ANY;
5347 group->lowest_randbit = buf->ReadByte();
5348
5349 byte num_groups = buf->ReadByte();
5350 if (!HasExactlyOneBit(num_groups)) {
5351 GrfMsg(1, "NewSpriteGroup: Random Action 2 nrand should be power of 2");
5352 }
5353
5354 for (uint i = 0; i < num_groups; i++) {
5355 group->groups.push_back(GetGroupFromGroupID(setid, type, buf->ReadWord()));
5356 }
5357
5358 break;
5359 }
5360
5361 /* Neither a variable or randomized sprite group... must be a real group */
5362 default:
5363 {
5364 switch (feature) {
5365 case GSF_TRAINS:
5366 case GSF_ROADVEHICLES:
5367 case GSF_SHIPS:
5368 case GSF_AIRCRAFT:
5369 case GSF_STATIONS:
5370 case GSF_CANALS:
5371 case GSF_CARGOES:
5372 case GSF_AIRPORTS:
5373 case GSF_RAILTYPES:
5374 case GSF_ROADTYPES:
5375 case GSF_TRAMTYPES:
5376 {
5377 byte num_loaded = type;
5378 byte num_loading = buf->ReadByte();
5379
5380 if (!_cur.HasValidSpriteSets(feature)) {
5381 GrfMsg(0, "NewSpriteGroup: No sprite set to work on! Skipping");
5382 return;
5383 }
5384
5385 GrfMsg(6, "NewSpriteGroup: New SpriteGroup 0x{:02X}, {} loaded, {} loading",
5386 setid, num_loaded, num_loading);
5387
5388 if (num_loaded + num_loading == 0) {
5389 GrfMsg(1, "NewSpriteGroup: no result, skipping invalid RealSpriteGroup");
5390 break;
5391 }
5392
5393 if (num_loaded + num_loading == 1) {
5394 /* Avoid creating 'Real' sprite group if only one option. */
5395 uint16_t spriteid = buf->ReadWord();
5396 act_group = CreateGroupFromGroupID(feature, setid, type, spriteid);
5397 GrfMsg(8, "NewSpriteGroup: one result, skipping RealSpriteGroup = subset {}", spriteid);
5398 break;
5399 }
5400
5401 std::vector<uint16_t> loaded;
5402 std::vector<uint16_t> loading;
5403
5404 for (uint i = 0; i < num_loaded; i++) {
5405 loaded.push_back(buf->ReadWord());
5406 GrfMsg(8, "NewSpriteGroup: + rg->loaded[{}] = subset {}", i, loaded[i]);
5407 }
5408
5409 for (uint i = 0; i < num_loading; i++) {
5410 loading.push_back(buf->ReadWord());
5411 GrfMsg(8, "NewSpriteGroup: + rg->loading[{}] = subset {}", i, loading[i]);
5412 }
5413
5414 if (std::adjacent_find(loaded.begin(), loaded.end(), std::not_equal_to<>()) == loaded.end() &&
5415 std::adjacent_find(loading.begin(), loading.end(), std::not_equal_to<>()) == loading.end() &&
5416 loaded[0] == loading[0])
5417 {
5418 /* Both lists only contain the same value, so don't create 'Real' sprite group */
5419 act_group = CreateGroupFromGroupID(feature, setid, type, loaded[0]);
5420 GrfMsg(8, "NewSpriteGroup: same result, skipping RealSpriteGroup = subset {}", loaded[0]);
5421 break;
5422 }
5423
5424 assert(RealSpriteGroup::CanAllocateItem());
5425 RealSpriteGroup *group = new RealSpriteGroup();
5426 group->nfo_line = _cur.nfo_line;
5427 act_group = group;
5428
5429 for (uint16_t spriteid : loaded) {
5430 const SpriteGroup *t = CreateGroupFromGroupID(feature, setid, type, spriteid);
5431 group->loaded.push_back(t);
5432 }
5433
5434 for (uint16_t spriteid : loading) {
5435 const SpriteGroup *t = CreateGroupFromGroupID(feature, setid, type, spriteid);
5436 group->loading.push_back(t);
5437 }
5438
5439 break;
5440 }
5441
5442 case GSF_HOUSES:
5443 case GSF_AIRPORTTILES:
5444 case GSF_OBJECTS:
5445 case GSF_INDUSTRYTILES:
5446 case GSF_ROADSTOPS: {
5447 byte num_building_sprites = std::max((uint8_t)1, type);
5448
5449 assert(TileLayoutSpriteGroup::CanAllocateItem());
5450 TileLayoutSpriteGroup *group = new TileLayoutSpriteGroup();
5451 group->nfo_line = _cur.nfo_line;
5452 act_group = group;
5453
5454 /* On error, bail out immediately. Temporary GRF data was already freed */
5455 if (ReadSpriteLayout(buf, num_building_sprites, true, feature, false, type == 0, &group->dts)) return;
5456 break;
5457 }
5458
5459 case GSF_INDUSTRIES: {
5460 if (type > 2) {
5461 GrfMsg(1, "NewSpriteGroup: Unsupported industry production version {}, skipping", type);
5462 break;
5463 }
5464
5465 assert(IndustryProductionSpriteGroup::CanAllocateItem());
5466 IndustryProductionSpriteGroup *group = new IndustryProductionSpriteGroup();
5467 group->nfo_line = _cur.nfo_line;
5468 act_group = group;
5469 group->version = type;
5470 if (type == 0) {
5471 group->num_input = 3;
5472 for (uint i = 0; i < 3; i++) {
5473 group->subtract_input[i] = (int16_t)buf->ReadWord(); // signed
5474 }
5475 group->num_output = 2;
5476 for (uint i = 0; i < 2; i++) {
5477 group->add_output[i] = buf->ReadWord(); // unsigned
5478 }
5479 group->again = buf->ReadByte();
5480 } else if (type == 1) {
5481 group->num_input = 3;
5482 for (uint i = 0; i < 3; i++) {
5483 group->subtract_input[i] = buf->ReadByte();
5484 }
5485 group->num_output = 2;
5486 for (uint i = 0; i < 2; i++) {
5487 group->add_output[i] = buf->ReadByte();
5488 }
5489 group->again = buf->ReadByte();
5490 } else if (type == 2) {
5491 group->num_input = buf->ReadByte();
5492 if (group->num_input > lengthof(group->subtract_input)) {
5493 GRFError *error = DisableGrf(STR_NEWGRF_ERROR_INDPROD_CALLBACK);
5494 error->data = "too many inputs (max 16)";
5495 return;
5496 }
5497 for (uint i = 0; i < group->num_input; i++) {
5498 byte rawcargo = buf->ReadByte();
5499 CargoID cargo = GetCargoTranslation(rawcargo, _cur.grffile);
5500 if (!IsValidCargoID(cargo)) {
5501 /* The mapped cargo is invalid. This is permitted at this point,
5502 * as long as the result is not used. Mark it invalid so this
5503 * can be tested later. */
5504 group->version = 0xFF;
5505 } else if (std::find(group->cargo_input, group->cargo_input + i, cargo) != group->cargo_input + i) {
5506 GRFError *error = DisableGrf(STR_NEWGRF_ERROR_INDPROD_CALLBACK);
5507 error->data = "duplicate input cargo";
5508 return;
5509 }
5510 group->cargo_input[i] = cargo;
5511 group->subtract_input[i] = buf->ReadByte();
5512 }
5513 group->num_output = buf->ReadByte();
5514 if (group->num_output > lengthof(group->add_output)) {
5515 GRFError *error = DisableGrf(STR_NEWGRF_ERROR_INDPROD_CALLBACK);
5516 error->data = "too many outputs (max 16)";
5517 return;
5518 }
5519 for (uint i = 0; i < group->num_output; i++) {
5520 byte rawcargo = buf->ReadByte();
5521 CargoID cargo = GetCargoTranslation(rawcargo, _cur.grffile);
5522 if (!IsValidCargoID(cargo)) {
5523 /* Mark this result as invalid to use */
5524 group->version = 0xFF;
5525 } else if (std::find(group->cargo_output, group->cargo_output + i, cargo) != group->cargo_output + i) {
5526 GRFError *error = DisableGrf(STR_NEWGRF_ERROR_INDPROD_CALLBACK);
5527 error->data = "duplicate output cargo";
5528 return;
5529 }
5530 group->cargo_output[i] = cargo;
5531 group->add_output[i] = buf->ReadByte();
5532 }
5533 group->again = buf->ReadByte();
5534 } else {
5535 NOT_REACHED();
5536 }
5537 break;
5538 }
5539
5540 /* Loading of Tile Layout and Production Callback groups would happen here */
5541 default: GrfMsg(1, "NewSpriteGroup: Unsupported feature 0x{:02X}, skipping", feature);
5542 }
5543 }
5544 }
5545
5546 _cur.spritegroups[setid] = act_group;
5547 }
5548
5549 static CargoID TranslateCargo(uint8_t feature, uint8_t ctype)
5550 {
5551 /* Special cargo types for purchase list and stations */
5552 if ((feature == GSF_STATIONS || feature == GSF_ROADSTOPS) && ctype == 0xFE) return SpriteGroupCargo::SG_DEFAULT_NA;
5553 if (ctype == 0xFF) return SpriteGroupCargo::SG_PURCHASE;
5554
5555 if (_cur.grffile->cargo_list.empty()) {
5556 /* No cargo table, so use bitnum values */
5557 if (ctype >= 32) {
5558 GrfMsg(1, "TranslateCargo: Cargo bitnum {} out of range (max 31), skipping.", ctype);
5559 return INVALID_CARGO;
5560 }
5561
5562 for (const CargoSpec *cs : CargoSpec::Iterate()) {
5563 if (cs->bitnum == ctype) {
5564 GrfMsg(6, "TranslateCargo: Cargo bitnum {} mapped to cargo type {}.", ctype, cs->Index());
5565 return cs->Index();
5566 }
5567 }
5568
5569 GrfMsg(5, "TranslateCargo: Cargo bitnum {} not available in this climate, skipping.", ctype);
5570 return INVALID_CARGO;
5571 }
5572
5573 /* Check if the cargo type is out of bounds of the cargo translation table */
5574 if (ctype >= _cur.grffile->cargo_list.size()) {
5575 GrfMsg(1, "TranslateCargo: Cargo type {} out of range (max {}), skipping.", ctype, (unsigned int)_cur.grffile->cargo_list.size() - 1);
5576 return INVALID_CARGO;
5577 }
5578
5579 /* Look up the cargo label from the translation table */
5580 CargoLabel cl = _cur.grffile->cargo_list[ctype];
5581 if (cl == CT_INVALID) {
5582 GrfMsg(5, "TranslateCargo: Cargo type {} not available in this climate, skipping.", ctype);
5583 return INVALID_CARGO;
5584 }
5585
5586 CargoID cid = GetCargoIDByLabel(cl);
5587 if (!IsValidCargoID(cid)) {
5588 GrfMsg(5, "TranslateCargo: Cargo '{:c}{:c}{:c}{:c}' unsupported, skipping.", GB(cl.base(), 24, 8), GB(cl.base(), 16, 8), GB(cl.base(), 8, 8), GB(cl.base(), 0, 8));
5589 return INVALID_CARGO;
5590 }
5591
5592 GrfMsg(6, "TranslateCargo: Cargo '{:c}{:c}{:c}{:c}' mapped to cargo type {}.", GB(cl.base(), 24, 8), GB(cl.base(), 16, 8), GB(cl.base(), 8, 8), GB(cl.base(), 0, 8), cid);
5593 return cid;
5594 }
5595
5596
5597 static bool IsValidGroupID(uint16_t groupid, const char *function)
5598 {
5599 if (groupid > MAX_SPRITEGROUP || _cur.spritegroups[groupid] == nullptr) {
5600 GrfMsg(1, "{}: Spritegroup 0x{:04X} out of range or empty, skipping.", function, groupid);
5601 return false;
5602 }
5603
5604 return true;
5605 }
5606
5607 static void VehicleMapSpriteGroup(ByteReader *buf, byte feature, uint8_t idcount)
5608 {
5609 static EngineID *last_engines;
5610 static uint last_engines_count;
5611 bool wagover = false;
5612
5613 /* Test for 'wagon override' flag */
5614 if (HasBit(idcount, 7)) {
5615 wagover = true;
5616 /* Strip off the flag */
5617 idcount = GB(idcount, 0, 7);
5618
5619 if (last_engines_count == 0) {
5620 GrfMsg(0, "VehicleMapSpriteGroup: WagonOverride: No engine to do override with");
5621 return;
5622 }
5623
5624 GrfMsg(6, "VehicleMapSpriteGroup: WagonOverride: {} engines, {} wagons",
5625 last_engines_count, idcount);
5626 } else {
5627 if (last_engines_count != idcount) {
5628 last_engines = ReallocT(last_engines, idcount);
5629 last_engines_count = idcount;
5630 }
5631 }
5632
5633 std::vector<EngineID> engines;
5634 for (uint i = 0; i < idcount; i++) {
5635 Engine *e = GetNewEngine(_cur.grffile, (VehicleType)feature, buf->ReadExtendedByte());
5636 if (e == nullptr) {
5637 /* No engine could be allocated?!? Deal with it. Okay,
5638 * this might look bad. Also make sure this NewGRF
5639 * gets disabled, as a half loaded one is bad. */
5640 HandleChangeInfoResult("VehicleMapSpriteGroup", CIR_INVALID_ID, 0, 0);
5641 return;
5642 }
5643
5644 engines.push_back(e->index);
5645 if (!wagover) last_engines[i] = engines[i];
5646 }
5647
5648 uint8_t cidcount = buf->ReadByte();
5649 for (uint c = 0; c < cidcount; c++) {
5650 uint8_t ctype = buf->ReadByte();
5651 uint16_t groupid = buf->ReadWord();
5652 if (!IsValidGroupID(groupid, "VehicleMapSpriteGroup")) continue;
5653
5654 GrfMsg(8, "VehicleMapSpriteGroup: * [{}] Cargo type 0x{:X}, group id 0x{:02X}", c, ctype, groupid);
5655
5656 CargoID cid = TranslateCargo(feature, ctype);
5657 if (!IsValidCargoID(cid)) continue;
5658
5659 for (uint i = 0; i < idcount; i++) {
5660 EngineID engine = engines[i];
5661
5662 GrfMsg(7, "VehicleMapSpriteGroup: [{}] Engine {}...", i, engine);
5663
5664 if (wagover) {
5665 SetWagonOverrideSprites(engine, cid, _cur.spritegroups[groupid], last_engines, last_engines_count);
5666 } else {
5667 SetCustomEngineSprites(engine, cid, _cur.spritegroups[groupid]);
5668 }
5669 }
5670 }
5671
5672 uint16_t groupid = buf->ReadWord();
5673 if (!IsValidGroupID(groupid, "VehicleMapSpriteGroup")) return;
5674
5675 GrfMsg(8, "-- Default group id 0x{:04X}", groupid);
5676
5677 for (uint i = 0; i < idcount; i++) {
5678 EngineID engine = engines[i];
5679
5680 if (wagover) {
5681 SetWagonOverrideSprites(engine, SpriteGroupCargo::SG_DEFAULT, _cur.spritegroups[groupid], last_engines, last_engines_count);
5682 } else {
5683 SetCustomEngineSprites(engine, SpriteGroupCargo::SG_DEFAULT, _cur.spritegroups[groupid]);
5684 SetEngineGRF(engine, _cur.grffile);
5685 }
5686 }
5687 }
5688
5689
5690 static void CanalMapSpriteGroup(ByteReader *buf, uint8_t idcount)
5691 {
5692 std::vector<uint16_t> cfs;
5693 cfs.reserve(idcount);
5694 for (uint i = 0; i < idcount; i++) {
5695 cfs.push_back(buf->ReadExtendedByte());
5696 }
5697
5698 uint8_t cidcount = buf->ReadByte();
5699 buf->Skip(cidcount * 3);
5700
5701 uint16_t groupid = buf->ReadWord();
5702 if (!IsValidGroupID(groupid, "CanalMapSpriteGroup")) return;
5703
5704 for (auto &cf : cfs) {
5705 if (cf >= CF_END) {
5706 GrfMsg(1, "CanalMapSpriteGroup: Canal subset {} out of range, skipping", cf);
5707 continue;
5708 }
5709
5710 _water_feature[cf].grffile = _cur.grffile;
5711 _water_feature[cf].group = _cur.spritegroups[groupid];
5712 }
5713 }
5714
5715
5716 static void StationMapSpriteGroup(ByteReader *buf, uint8_t idcount)
5717 {
5718 if (_cur.grffile->stations.empty()) {
5719 GrfMsg(1, "StationMapSpriteGroup: No stations defined, skipping");
5720 return;
5721 }
5722
5723 std::vector<uint16_t> stations;
5724 stations.reserve(idcount);
5725 for (uint i = 0; i < idcount; i++) {
5726 stations.push_back(buf->ReadExtendedByte());
5727 }
5728
5729 uint8_t cidcount = buf->ReadByte();
5730 for (uint c = 0; c < cidcount; c++) {
5731 uint8_t ctype = buf->ReadByte();
5732 uint16_t groupid = buf->ReadWord();
5733 if (!IsValidGroupID(groupid, "StationMapSpriteGroup")) continue;
5734
5735 ctype = TranslateCargo(GSF_STATIONS, ctype);
5736 if (!IsValidCargoID(ctype)) continue;
5737
5738 for (auto &station : stations) {
5739 StationSpec *statspec = station >= _cur.grffile->stations.size() ? nullptr : _cur.grffile->stations[station].get();
5740
5741 if (statspec == nullptr) {
5742 GrfMsg(1, "StationMapSpriteGroup: Station {} undefined, skipping", station);
5743 continue;
5744 }
5745
5746 statspec->grf_prop.spritegroup[ctype] = _cur.spritegroups[groupid];
5747 }
5748 }
5749
5750 uint16_t groupid = buf->ReadWord();
5751 if (!IsValidGroupID(groupid, "StationMapSpriteGroup")) return;
5752
5753 for (auto &station : stations) {
5754 StationSpec *statspec = station >= _cur.grffile->stations.size() ? nullptr : _cur.grffile->stations[station].get();
5755
5756 if (statspec == nullptr) {
5757 GrfMsg(1, "StationMapSpriteGroup: Station {} undefined, skipping", station);
5758 continue;
5759 }
5760
5761 if (statspec->grf_prop.grffile != nullptr) {
5762 GrfMsg(1, "StationMapSpriteGroup: Station {} mapped multiple times, skipping", station);
5763 continue;
5764 }
5765
5766 statspec->grf_prop.spritegroup[SpriteGroupCargo::SG_DEFAULT] = _cur.spritegroups[groupid];
5767 statspec->grf_prop.grffile = _cur.grffile;
5768 statspec->grf_prop.local_id = station;
5769 StationClass::Assign(statspec);
5770 }
5771 }
5772
5773
5774 static void TownHouseMapSpriteGroup(ByteReader *buf, uint8_t idcount)
5775 {
5776 if (_cur.grffile->housespec.empty()) {
5777 GrfMsg(1, "TownHouseMapSpriteGroup: No houses defined, skipping");
5778 return;
5779 }
5780
5781 std::vector<uint16_t> houses;
5782 houses.reserve(idcount);
5783 for (uint i = 0; i < idcount; i++) {
5784 houses.push_back(buf->ReadExtendedByte());
5785 }
5786
5787 /* Skip the cargo type section, we only care about the default group */
5788 uint8_t cidcount = buf->ReadByte();
5789 buf->Skip(cidcount * 3);
5790
5791 uint16_t groupid = buf->ReadWord();
5792 if (!IsValidGroupID(groupid, "TownHouseMapSpriteGroup")) return;
5793
5794 for (auto &house : houses) {
5795 HouseSpec *hs = house >= _cur.grffile->housespec.size() ? nullptr : _cur.grffile->housespec[house].get();
5796
5797 if (hs == nullptr) {
5798 GrfMsg(1, "TownHouseMapSpriteGroup: House {} undefined, skipping.", house);
5799 continue;
5800 }
5801
5802 hs->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
5803 }
5804 }
5805
5806 static void IndustryMapSpriteGroup(ByteReader *buf, uint8_t idcount)
5807 {
5808 if (_cur.grffile->industryspec.empty()) {
5809 GrfMsg(1, "IndustryMapSpriteGroup: No industries defined, skipping");
5810 return;
5811 }
5812
5813 std::vector<uint16_t> industries;
5814 industries.reserve(idcount);
5815 for (uint i = 0; i < idcount; i++) {
5816 industries.push_back(buf->ReadExtendedByte());
5817 }
5818
5819 /* Skip the cargo type section, we only care about the default group */
5820 uint8_t cidcount = buf->ReadByte();
5821 buf->Skip(cidcount * 3);
5822
5823 uint16_t groupid = buf->ReadWord();
5824 if (!IsValidGroupID(groupid, "IndustryMapSpriteGroup")) return;
5825
5826 for (auto &industry : industries) {
5827 IndustrySpec *indsp = industry >= _cur.grffile->industryspec.size() ? nullptr : _cur.grffile->industryspec[industry].get();
5828
5829 if (indsp == nullptr) {
5830 GrfMsg(1, "IndustryMapSpriteGroup: Industry {} undefined, skipping", industry);
5831 continue;
5832 }
5833
5834 indsp->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
5835 }
5836 }
5837
5838 static void IndustrytileMapSpriteGroup(ByteReader *buf, uint8_t idcount)
5839 {
5840 if (_cur.grffile->indtspec.empty()) {
5841 GrfMsg(1, "IndustrytileMapSpriteGroup: No industry tiles defined, skipping");
5842 return;
5843 }
5844
5845 std::vector<uint16_t> indtiles;
5846 indtiles.reserve(idcount);
5847 for (uint i = 0; i < idcount; i++) {
5848 indtiles.push_back(buf->ReadExtendedByte());
5849 }
5850
5851 /* Skip the cargo type section, we only care about the default group */
5852 uint8_t cidcount = buf->ReadByte();
5853 buf->Skip(cidcount * 3);
5854
5855 uint16_t groupid = buf->ReadWord();
5856 if (!IsValidGroupID(groupid, "IndustrytileMapSpriteGroup")) return;
5857
5858 for (auto &indtile : indtiles) {
5859 IndustryTileSpec *indtsp = indtile >= _cur.grffile->indtspec.size() ? nullptr : _cur.grffile->indtspec[indtile].get();
5860
5861 if (indtsp == nullptr) {
5862 GrfMsg(1, "IndustrytileMapSpriteGroup: Industry tile {} undefined, skipping", indtile);
5863 continue;
5864 }
5865
5866 indtsp->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
5867 }
5868 }
5869
5870 static void CargoMapSpriteGroup(ByteReader *buf, uint8_t idcount)
5871 {
5872 std::vector<uint16_t> cargoes;
5873 cargoes.reserve(idcount);
5874 for (uint i = 0; i < idcount; i++) {
5875 cargoes.push_back(buf->ReadExtendedByte());
5876 }
5877
5878 /* Skip the cargo type section, we only care about the default group */
5879 uint8_t cidcount = buf->ReadByte();
5880 buf->Skip(cidcount * 3);
5881
5882 uint16_t groupid = buf->ReadWord();
5883 if (!IsValidGroupID(groupid, "CargoMapSpriteGroup")) return;
5884
5885 for (auto &cid : cargoes) {
5886 if (cid >= NUM_CARGO) {
5887 GrfMsg(1, "CargoMapSpriteGroup: Cargo ID {} out of range, skipping", cid);
5888 continue;
5889 }
5890
5891 CargoSpec *cs = CargoSpec::Get(cid);
5892 cs->grffile = _cur.grffile;
5893 cs->group = _cur.spritegroups[groupid];
5894 }
5895 }
5896
5897 static void ObjectMapSpriteGroup(ByteReader *buf, uint8_t idcount)
5898 {
5899 if (_cur.grffile->objectspec.empty()) {
5900 GrfMsg(1, "ObjectMapSpriteGroup: No object tiles defined, skipping");
5901 return;
5902 }
5903
5904 std::vector<uint16_t> objects;
5905 objects.reserve(idcount);
5906 for (uint i = 0; i < idcount; i++) {
5907 objects.push_back(buf->ReadExtendedByte());
5908 }
5909
5910 uint8_t cidcount = buf->ReadByte();
5911 for (uint c = 0; c < cidcount; c++) {
5912 uint8_t ctype = buf->ReadByte();
5913 uint16_t groupid = buf->ReadWord();
5914 if (!IsValidGroupID(groupid, "ObjectMapSpriteGroup")) continue;
5915
5916 /* The only valid option here is purchase list sprite groups. */
5917 if (ctype != 0xFF) {
5918 GrfMsg(1, "ObjectMapSpriteGroup: Invalid cargo bitnum {} for objects, skipping.", ctype);
5919 continue;
5920 }
5921
5922 for (auto &object : objects) {
5923 ObjectSpec *spec = object >= _cur.grffile->objectspec.size() ? nullptr : _cur.grffile->objectspec[object].get();
5924
5925 if (spec == nullptr) {
5926 GrfMsg(1, "ObjectMapSpriteGroup: Object {} undefined, skipping", object);
5927 continue;
5928 }
5929
5930 spec->grf_prop.spritegroup[OBJECT_SPRITE_GROUP_PURCHASE] = _cur.spritegroups[groupid];
5931 }
5932 }
5933
5934 uint16_t groupid = buf->ReadWord();
5935 if (!IsValidGroupID(groupid, "ObjectMapSpriteGroup")) return;
5936
5937 for (auto &object : objects) {
5938 ObjectSpec *spec = object >= _cur.grffile->objectspec.size() ? nullptr : _cur.grffile->objectspec[object].get();
5939
5940 if (spec == nullptr) {
5941 GrfMsg(1, "ObjectMapSpriteGroup: Object {} undefined, skipping", object);
5942 continue;
5943 }
5944
5945 if (spec->grf_prop.grffile != nullptr) {
5946 GrfMsg(1, "ObjectMapSpriteGroup: Object {} mapped multiple times, skipping", object);
5947 continue;
5948 }
5949
5950 spec->grf_prop.spritegroup[OBJECT_SPRITE_GROUP_DEFAULT] = _cur.spritegroups[groupid];
5951 spec->grf_prop.grffile = _cur.grffile;
5952 spec->grf_prop.local_id = object;
5953 }
5954 }
5955
5956 static void RailTypeMapSpriteGroup(ByteReader *buf, uint8_t idcount)
5957 {
5958 std::vector<uint8_t> railtypes;
5959 railtypes.reserve(idcount);
5960 for (uint i = 0; i < idcount; i++) {
5961 uint16_t id = buf->ReadExtendedByte();
5962 railtypes.push_back(id < RAILTYPE_END ? _cur.grffile->railtype_map[id] : INVALID_RAILTYPE);
5963 }
5964
5965 uint8_t cidcount = buf->ReadByte();
5966 for (uint c = 0; c < cidcount; c++) {
5967 uint8_t ctype = buf->ReadByte();
5968 uint16_t groupid = buf->ReadWord();
5969 if (!IsValidGroupID(groupid, "RailTypeMapSpriteGroup")) continue;
5970
5971 if (ctype >= RTSG_END) continue;
5972
5973 extern RailTypeInfo _railtypes[RAILTYPE_END];
5974 for (auto &railtype : railtypes) {
5975 if (railtype != INVALID_RAILTYPE) {
5976 RailTypeInfo *rti = &_railtypes[railtype];
5977
5978 rti->grffile[ctype] = _cur.grffile;
5979 rti->group[ctype] = _cur.spritegroups[groupid];
5980 }
5981 }
5982 }
5983
5984 /* Railtypes do not use the default group. */
5985 buf->ReadWord();
5986 }
5987
5988 static void RoadTypeMapSpriteGroup(ByteReader *buf, uint8_t idcount, RoadTramType rtt)
5989 {
5990 RoadType *type_map = (rtt == RTT_TRAM) ? _cur.grffile->tramtype_map : _cur.grffile->roadtype_map;
5991
5992 std::vector<uint8_t> roadtypes;
5993 roadtypes.reserve(idcount);
5994 for (uint i = 0; i < idcount; i++) {
5995 uint16_t id = buf->ReadExtendedByte();
5996 roadtypes.push_back(id < ROADTYPE_END ? type_map[id] : INVALID_ROADTYPE);
5997 }
5998
5999 uint8_t cidcount = buf->ReadByte();
6000 for (uint c = 0; c < cidcount; c++) {
6001 uint8_t ctype = buf->ReadByte();
6002 uint16_t groupid = buf->ReadWord();
6003 if (!IsValidGroupID(groupid, "RoadTypeMapSpriteGroup")) continue;
6004
6005 if (ctype >= ROTSG_END) continue;
6006
6007 extern RoadTypeInfo _roadtypes[ROADTYPE_END];
6008 for (auto &roadtype : roadtypes) {
6009 if (roadtype != INVALID_ROADTYPE) {
6010 RoadTypeInfo *rti = &_roadtypes[roadtype];
6011
6012 rti->grffile[ctype] = _cur.grffile;
6013 rti->group[ctype] = _cur.spritegroups[groupid];
6014 }
6015 }
6016 }
6017
6018 /* Roadtypes do not use the default group. */
6019 buf->ReadWord();
6020 }
6021
6022 static void AirportMapSpriteGroup(ByteReader *buf, uint8_t idcount)
6023 {
6024 if (_cur.grffile->airportspec.empty()) {
6025 GrfMsg(1, "AirportMapSpriteGroup: No airports defined, skipping");
6026 return;
6027 }
6028
6029 std::vector<uint16_t> airports;
6030 airports.reserve(idcount);
6031 for (uint i = 0; i < idcount; i++) {
6032 airports.push_back(buf->ReadExtendedByte());
6033 }
6034
6035 /* Skip the cargo type section, we only care about the default group */
6036 uint8_t cidcount = buf->ReadByte();
6037 buf->Skip(cidcount * 3);
6038
6039 uint16_t groupid = buf->ReadWord();
6040 if (!IsValidGroupID(groupid, "AirportMapSpriteGroup")) return;
6041
6042 for (auto &airport : airports) {
6043 AirportSpec *as = airport >= _cur.grffile->airportspec.size() ? nullptr : _cur.grffile->airportspec[airport].get();
6044
6045 if (as == nullptr) {
6046 GrfMsg(1, "AirportMapSpriteGroup: Airport {} undefined, skipping", airport);
6047 continue;
6048 }
6049
6050 as->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
6051 }
6052 }
6053
6054 static void AirportTileMapSpriteGroup(ByteReader *buf, uint8_t idcount)
6055 {
6056 if (_cur.grffile->airtspec.empty()) {
6057 GrfMsg(1, "AirportTileMapSpriteGroup: No airport tiles defined, skipping");
6058 return;
6059 }
6060
6061 std::vector<uint16_t> airptiles;
6062 airptiles.reserve(idcount);
6063 for (uint i = 0; i < idcount; i++) {
6064 airptiles.push_back(buf->ReadExtendedByte());
6065 }
6066
6067 /* Skip the cargo type section, we only care about the default group */
6068 uint8_t cidcount = buf->ReadByte();
6069 buf->Skip(cidcount * 3);
6070
6071 uint16_t groupid = buf->ReadWord();
6072 if (!IsValidGroupID(groupid, "AirportTileMapSpriteGroup")) return;
6073
6074 for (auto &airptile : airptiles) {
6075 AirportTileSpec *airtsp = airptile >= _cur.grffile->airtspec.size() ? nullptr : _cur.grffile->airtspec[airptile].get();
6076
6077 if (airtsp == nullptr) {
6078 GrfMsg(1, "AirportTileMapSpriteGroup: Airport tile {} undefined, skipping", airptile);
6079 continue;
6080 }
6081
6082 airtsp->grf_prop.spritegroup[0] = _cur.spritegroups[groupid];
6083 }
6084 }
6085
6086 static void RoadStopMapSpriteGroup(ByteReader *buf, uint8_t idcount)
6087 {
6088 if (_cur.grffile->roadstops.empty()) {
6089 GrfMsg(1, "RoadStopMapSpriteGroup: No roadstops defined, skipping");
6090 return;
6091 }
6092
6093 std::vector<uint16_t> roadstops;
6094 roadstops.reserve(idcount);
6095 for (uint i = 0; i < idcount; i++) {
6096 roadstops.push_back(buf->ReadExtendedByte());
6097 }
6098
6099 uint8_t cidcount = buf->ReadByte();
6100 for (uint c = 0; c < cidcount; c++) {
6101 uint8_t ctype = buf->ReadByte();
6102 uint16_t groupid = buf->ReadWord();
6103 if (!IsValidGroupID(groupid, "RoadStopMapSpriteGroup")) continue;
6104
6105 ctype = TranslateCargo(GSF_ROADSTOPS, ctype);
6106 if (!IsValidCargoID(ctype)) continue;
6107
6108 for (auto &roadstop : roadstops) {
6109 RoadStopSpec *roadstopspec = roadstop >= _cur.grffile->roadstops.size() ? nullptr : _cur.grffile->roadstops[roadstop].get();
6110
6111 if (roadstopspec == nullptr) {
6112 GrfMsg(1, "RoadStopMapSpriteGroup: Road stop {} undefined, skipping", roadstop);
6113 continue;
6114 }
6115
6116 roadstopspec->grf_prop.spritegroup[ctype] = _cur.spritegroups[groupid];
6117 }
6118 }
6119
6120 uint16_t groupid = buf->ReadWord();
6121 if (!IsValidGroupID(groupid, "RoadStopMapSpriteGroup")) return;
6122
6123 for (auto &roadstop : roadstops) {
6124 RoadStopSpec *roadstopspec = roadstop >= _cur.grffile->roadstops.size() ? nullptr : _cur.grffile->roadstops[roadstop].get();
6125
6126 if (roadstopspec == nullptr) {
6127 GrfMsg(1, "RoadStopMapSpriteGroup: Road stop {} undefined, skipping.", roadstop);
6128 continue;
6129 }
6130
6131 if (roadstopspec->grf_prop.grffile != nullptr) {
6132 GrfMsg(1, "RoadStopMapSpriteGroup: Road stop {} mapped multiple times, skipping", roadstop);
6133 continue;
6134 }
6135
6136 roadstopspec->grf_prop.spritegroup[SpriteGroupCargo::SG_DEFAULT] = _cur.spritegroups[groupid];
6137 roadstopspec->grf_prop.grffile = _cur.grffile;
6138 roadstopspec->grf_prop.local_id = roadstop;
6139 RoadStopClass::Assign(roadstopspec);
6140 }
6141 }
6142
6143 /* Action 0x03 */
6144 static void FeatureMapSpriteGroup(ByteReader *buf)
6145 {
6146 /* <03> <feature> <n-id> <ids>... <num-cid> [<cargo-type> <cid>]... <def-cid>
6147 * id-list := [<id>] [id-list]
6148 * cargo-list := <cargo-type> <cid> [cargo-list]
6149 *
6150 * B feature see action 0
6151 * B n-id bits 0-6: how many IDs this definition applies to
6152 * bit 7: if set, this is a wagon override definition (see below)
6153 * E ids the IDs for which this definition applies
6154 * B num-cid number of cargo IDs (sprite group IDs) in this definition
6155 * can be zero, in that case the def-cid is used always
6156 * B cargo-type type of this cargo type (e.g. mail=2, wood=7, see below)
6157 * W cid cargo ID (sprite group ID) for this type of cargo
6158 * W def-cid default cargo ID (sprite group ID) */
6159
6160 uint8_t feature = buf->ReadByte();
6161 uint8_t idcount = buf->ReadByte();
6162
6163 if (feature >= GSF_END) {
6164 GrfMsg(1, "FeatureMapSpriteGroup: Unsupported feature 0x{:02X}, skipping", feature);
6165 return;
6166 }
6167
6168 /* If idcount is zero, this is a feature callback */
6169 if (idcount == 0) {
6170 /* Skip number of cargo ids? */
6171 buf->ReadByte();
6172 uint16_t groupid = buf->ReadWord();
6173 if (!IsValidGroupID(groupid, "FeatureMapSpriteGroup")) return;
6174
6175 GrfMsg(6, "FeatureMapSpriteGroup: Adding generic feature callback for feature 0x{:02X}", feature);
6176
6177 AddGenericCallback(feature, _cur.grffile, _cur.spritegroups[groupid]);
6178 return;
6179 }
6180
6181 /* Mark the feature as used by the grf (generic callbacks do not count) */
6182 SetBit(_cur.grffile->grf_features, feature);
6183
6184 GrfMsg(6, "FeatureMapSpriteGroup: Feature 0x{:02X}, {} ids", feature, idcount);
6185
6186 switch (feature) {
6187 case GSF_TRAINS:
6188 case GSF_ROADVEHICLES:
6189 case GSF_SHIPS:
6190 case GSF_AIRCRAFT:
6191 VehicleMapSpriteGroup(buf, feature, idcount);
6192 return;
6193
6194 case GSF_CANALS:
6195 CanalMapSpriteGroup(buf, idcount);
6196 return;
6197
6198 case GSF_STATIONS:
6199 StationMapSpriteGroup(buf, idcount);
6200 return;
6201
6202 case GSF_HOUSES:
6203 TownHouseMapSpriteGroup(buf, idcount);
6204 return;
6205
6206 case GSF_INDUSTRIES:
6207 IndustryMapSpriteGroup(buf, idcount);
6208 return;
6209
6210 case GSF_INDUSTRYTILES:
6211 IndustrytileMapSpriteGroup(buf, idcount);
6212 return;
6213
6214 case GSF_CARGOES:
6215 CargoMapSpriteGroup(buf, idcount);
6216 return;
6217
6218 case GSF_AIRPORTS:
6219 AirportMapSpriteGroup(buf, idcount);
6220 return;
6221
6222 case GSF_OBJECTS:
6223 ObjectMapSpriteGroup(buf, idcount);
6224 break;
6225
6226 case GSF_RAILTYPES:
6227 RailTypeMapSpriteGroup(buf, idcount);
6228 break;
6229
6230 case GSF_ROADTYPES:
6231 RoadTypeMapSpriteGroup(buf, idcount, RTT_ROAD);
6232 break;
6233
6234 case GSF_TRAMTYPES:
6235 RoadTypeMapSpriteGroup(buf, idcount, RTT_TRAM);
6236 break;
6237
6238 case GSF_AIRPORTTILES:
6239 AirportTileMapSpriteGroup(buf, idcount);
6240 return;
6241
6242 case GSF_ROADSTOPS:
6243 RoadStopMapSpriteGroup(buf, idcount);
6244 return;
6245
6246 default:
6247 GrfMsg(1, "FeatureMapSpriteGroup: Unsupported feature 0x{:02X}, skipping", feature);
6248 return;
6249 }
6250 }
6251
6252 /* Action 0x04 */
6253 static void FeatureNewName(ByteReader *buf)
6254 {
6255 /* <04> <veh-type> <language-id> <num-veh> <offset> <data...>
6256 *
6257 * B veh-type see action 0 (as 00..07, + 0A
6258 * But IF veh-type = 48, then generic text
6259 * B language-id If bit 6 is set, This is the extended language scheme,
6260 * with up to 64 language.
6261 * Otherwise, it is a mapping where set bits have meaning
6262 * 0 = american, 1 = english, 2 = german, 3 = french, 4 = spanish
6263 * Bit 7 set means this is a generic text, not a vehicle one (or else)
6264 * B num-veh number of vehicles which are getting a new name
6265 * B/W offset number of the first vehicle that gets a new name
6266 * Byte : ID of vehicle to change
6267 * Word : ID of string to change/add
6268 * S data new texts, each of them zero-terminated, after
6269 * which the next name begins. */
6270
6271 bool new_scheme = _cur.grffile->grf_version >= 7;
6272
6273 uint8_t feature = buf->ReadByte();
6274 if (feature >= GSF_END && feature != 0x48) {
6275 GrfMsg(1, "FeatureNewName: Unsupported feature 0x{:02X}, skipping", feature);
6276 return;
6277 }
6278
6279 uint8_t lang = buf->ReadByte();
6280 uint8_t num = buf->ReadByte();
6281 bool generic = HasBit(lang, 7);
6282 uint16_t id;
6283 if (generic) {
6284 id = buf->ReadWord();
6285 } else if (feature <= GSF_AIRCRAFT) {
6286 id = buf->ReadExtendedByte();
6287 } else {
6288 id = buf->ReadByte();
6289 }
6290
6291 ClrBit(lang, 7);
6292
6293 uint16_t endid = id + num;
6294
6295 GrfMsg(6, "FeatureNewName: About to rename engines {}..{} (feature 0x{:02X}) in language 0x{:02X}",
6296 id, endid, feature, lang);
6297
6298 for (; id < endid && buf->HasData(); id++) {
6299 const char *name = buf->ReadString();
6300 GrfMsg(8, "FeatureNewName: 0x{:04X} <- {}", id, name);
6301
6302 switch (feature) {
6303 case GSF_TRAINS:
6304 case GSF_ROADVEHICLES:
6305 case GSF_SHIPS:
6306 case GSF_AIRCRAFT:
6307 if (!generic) {
6308 Engine *e = GetNewEngine(_cur.grffile, (VehicleType)feature, id, HasBit(_cur.grfconfig->flags, GCF_STATIC));
6309 if (e == nullptr) break;
6310 StringID string = AddGRFString(_cur.grffile->grfid, e->index, lang, new_scheme, false, name, e->info.string_id);
6311 e->info.string_id = string;
6312 } else {
6313 AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, true, name, STR_UNDEFINED);
6314 }
6315 break;
6316
6317 default:
6318 if (IsInsideMM(id, 0xD000, 0xD400) || IsInsideMM(id, 0xD800, 0x10000)) {
6319 AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, true, name, STR_UNDEFINED);
6320 break;
6321 }
6322
6323 switch (GB(id, 8, 8)) {
6324 case 0xC4: // Station class name
6325 if (GB(id, 0, 8) >= _cur.grffile->stations.size() || _cur.grffile->stations[GB(id, 0, 8)] == nullptr) {
6326 GrfMsg(1, "FeatureNewName: Attempt to name undefined station 0x{:X}, ignoring", GB(id, 0, 8));
6327 } else {
6328 StationClassID cls_id = _cur.grffile->stations[GB(id, 0, 8)]->cls_id;
6329 StationClass::Get(cls_id)->name = AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
6330 }
6331 break;
6332
6333 case 0xC5: // Station name
6334 if (GB(id, 0, 8) >= _cur.grffile->stations.size() || _cur.grffile->stations[GB(id, 0, 8)] == nullptr) {
6335 GrfMsg(1, "FeatureNewName: Attempt to name undefined station 0x{:X}, ignoring", GB(id, 0, 8));
6336 } else {
6337 _cur.grffile->stations[GB(id, 0, 8)]->name = AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
6338 }
6339 break;
6340
6341 case 0xC7: // Airporttile name
6342 if (GB(id, 0, 8) >= _cur.grffile->airtspec.size() || _cur.grffile->airtspec[GB(id, 0, 8)] == nullptr) {
6343 GrfMsg(1, "FeatureNewName: Attempt to name undefined airport tile 0x{:X}, ignoring", GB(id, 0, 8));
6344 } else {
6345 _cur.grffile->airtspec[GB(id, 0, 8)]->name = AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
6346 }
6347 break;
6348
6349 case 0xC9: // House name
6350 if (GB(id, 0, 8) >= _cur.grffile->housespec.size() || _cur.grffile->housespec[GB(id, 0, 8)] == nullptr) {
6351 GrfMsg(1, "FeatureNewName: Attempt to name undefined house 0x{:X}, ignoring.", GB(id, 0, 8));
6352 } else {
6353 _cur.grffile->housespec[GB(id, 0, 8)]->building_name = AddGRFString(_cur.grffile->grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
6354 }
6355 break;
6356
6357 default:
6358 GrfMsg(7, "FeatureNewName: Unsupported ID (0x{:04X})", id);
6359 break;
6360 }
6361 break;
6362 }
6363 }
6364 }
6365
6374 static uint16_t SanitizeSpriteOffset(uint16_t &num, uint16_t offset, int max_sprites, const char *name)
6375 {
6376
6377 if (offset >= max_sprites) {
6378 GrfMsg(1, "GraphicsNew: {} sprite offset must be less than {}, skipping", name, max_sprites);
6379 uint orig_num = num;
6380 num = 0;
6381 return orig_num;
6382 }
6383
6384 if (offset + num > max_sprites) {
6385 GrfMsg(4, "GraphicsNew: {} sprite overflow, truncating...", name);
6386 uint orig_num = num;
6387 num = std::max(max_sprites - offset, 0);
6388 return orig_num - num;
6389 }
6390
6391 return 0;
6392 }
6393
6394
6396 enum Action5BlockType {
6397 A5BLOCK_FIXED,
6398 A5BLOCK_ALLOW_OFFSET,
6399 A5BLOCK_INVALID,
6400 };
6402 struct Action5Type {
6403 Action5BlockType block_type;
6404 SpriteID sprite_base;
6405 uint16_t min_sprites;
6406 uint16_t max_sprites;
6407 const char *name;
6408 };
6409
6411 static const Action5Type _action5_types[] = {
6412 /* Note: min_sprites should not be changed. Therefore these constants are directly here and not in sprites.h */
6413 /* 0x00 */ { A5BLOCK_INVALID, 0, 0, 0, "Type 0x00" },
6414 /* 0x01 */ { A5BLOCK_INVALID, 0, 0, 0, "Type 0x01" },
6415 /* 0x02 */ { A5BLOCK_INVALID, 0, 0, 0, "Type 0x02" },
6416 /* 0x03 */ { A5BLOCK_INVALID, 0, 0, 0, "Type 0x03" },
6417 /* 0x04 */ { A5BLOCK_ALLOW_OFFSET, SPR_SIGNALS_BASE, 1, PRESIGNAL_SEMAPHORE_AND_PBS_SPRITE_COUNT, "Signal graphics" },
6418 /* 0x05 */ { A5BLOCK_ALLOW_OFFSET, SPR_ELRAIL_BASE, 1, ELRAIL_SPRITE_COUNT, "Rail catenary graphics" },
6419 /* 0x06 */ { A5BLOCK_ALLOW_OFFSET, SPR_SLOPES_BASE, 1, NORMAL_AND_HALFTILE_FOUNDATION_SPRITE_COUNT, "Foundation graphics" },
6420 /* 0x07 */ { A5BLOCK_INVALID, 0, 75, 0, "TTDP GUI graphics" }, // Not used by OTTD.
6421 /* 0x08 */ { A5BLOCK_ALLOW_OFFSET, SPR_CANALS_BASE, 1, CANALS_SPRITE_COUNT, "Canal graphics" },
6422 /* 0x09 */ { A5BLOCK_ALLOW_OFFSET, SPR_ONEWAY_BASE, 1, ONEWAY_SPRITE_COUNT, "One way road graphics" },
6423 /* 0x0A */ { A5BLOCK_ALLOW_OFFSET, SPR_2CCMAP_BASE, 1, TWOCCMAP_SPRITE_COUNT, "2CC colour maps" },
6424 /* 0x0B */ { A5BLOCK_ALLOW_OFFSET, SPR_TRAMWAY_BASE, 1, TRAMWAY_SPRITE_COUNT, "Tramway graphics" },
6425 /* 0x0C */ { A5BLOCK_INVALID, 0, 133, 0, "Snowy temperate tree" }, // Not yet used by OTTD.
6426 /* 0x0D */ { A5BLOCK_FIXED, SPR_SHORE_BASE, 16, SPR_SHORE_SPRITE_COUNT, "Shore graphics" },
6427 /* 0x0E */ { A5BLOCK_INVALID, 0, 0, 0, "New Signals graphics" }, // Not yet used by OTTD.
6428 /* 0x0F */ { A5BLOCK_ALLOW_OFFSET, SPR_TRACKS_FOR_SLOPES_BASE, 1, TRACKS_FOR_SLOPES_SPRITE_COUNT, "Sloped rail track" },
6429 /* 0x10 */ { A5BLOCK_ALLOW_OFFSET, SPR_AIRPORTX_BASE, 1, AIRPORTX_SPRITE_COUNT, "Airport graphics" },
6430 /* 0x11 */ { A5BLOCK_ALLOW_OFFSET, SPR_ROADSTOP_BASE, 1, ROADSTOP_SPRITE_COUNT, "Road stop graphics" },
6431 /* 0x12 */ { A5BLOCK_ALLOW_OFFSET, SPR_AQUEDUCT_BASE, 1, AQUEDUCT_SPRITE_COUNT, "Aqueduct graphics" },
6432 /* 0x13 */ { A5BLOCK_ALLOW_OFFSET, SPR_AUTORAIL_BASE, 1, AUTORAIL_SPRITE_COUNT, "Autorail graphics" },
6433 /* 0x14 */ { A5BLOCK_INVALID, 0, 1, 0, "Flag graphics" }, // deprecated, no longer used.
6434 /* 0x15 */ { A5BLOCK_ALLOW_OFFSET, SPR_OPENTTD_BASE, 1, OPENTTD_SPRITE_COUNT, "OpenTTD GUI graphics" },
6435 /* 0x16 */ { A5BLOCK_ALLOW_OFFSET, SPR_AIRPORT_PREVIEW_BASE, 1, SPR_AIRPORT_PREVIEW_COUNT, "Airport preview graphics" },
6436 /* 0x17 */ { A5BLOCK_ALLOW_OFFSET, SPR_RAILTYPE_TUNNEL_BASE, 1, RAILTYPE_TUNNEL_BASE_COUNT, "Railtype tunnel base" },
6437 /* 0x18 */ { A5BLOCK_ALLOW_OFFSET, SPR_PALETTE_BASE, 1, PALETTE_SPRITE_COUNT, "Palette" },
6438 };
6439
6440 /* Action 0x05 */
6441 static void GraphicsNew(ByteReader *buf)
6442 {
6443 /* <05> <graphics-type> <num-sprites> <other data...>
6444 *
6445 * B graphics-type What set of graphics the sprites define.
6446 * E num-sprites How many sprites are in this set?
6447 * V other data Graphics type specific data. Currently unused. */
6448
6449 uint8_t type = buf->ReadByte();
6450 uint16_t num = buf->ReadExtendedByte();
6451 uint16_t offset = HasBit(type, 7) ? buf->ReadExtendedByte() : 0;
6452 ClrBit(type, 7); // Clear the high bit as that only indicates whether there is an offset.
6453
6454 if ((type == 0x0D) && (num == 10) && HasBit(_cur.grfconfig->flags, GCF_SYSTEM)) {
6455 /* Special not-TTDP-compatible case used in openttd.grf
6456 * Missing shore sprites and initialisation of SPR_SHORE_BASE */
6457 GrfMsg(2, "GraphicsNew: Loading 10 missing shore sprites from extra grf.");
6458 LoadNextSprite(SPR_SHORE_BASE + 0, *_cur.file, _cur.nfo_line++); // SLOPE_STEEP_S
6459 LoadNextSprite(SPR_SHORE_BASE + 5, *_cur.file, _cur.nfo_line++); // SLOPE_STEEP_W
6460 LoadNextSprite(SPR_SHORE_BASE + 7, *_cur.file, _cur.nfo_line++); // SLOPE_WSE
6461 LoadNextSprite(SPR_SHORE_BASE + 10, *_cur.file, _cur.nfo_line++); // SLOPE_STEEP_N
6462 LoadNextSprite(SPR_SHORE_BASE + 11, *_cur.file, _cur.nfo_line++); // SLOPE_NWS
6463 LoadNextSprite(SPR_SHORE_BASE + 13, *_cur.file, _cur.nfo_line++); // SLOPE_ENW
6464 LoadNextSprite(SPR_SHORE_BASE + 14, *_cur.file, _cur.nfo_line++); // SLOPE_SEN
6465 LoadNextSprite(SPR_SHORE_BASE + 15, *_cur.file, _cur.nfo_line++); // SLOPE_STEEP_E
6466 LoadNextSprite(SPR_SHORE_BASE + 16, *_cur.file, _cur.nfo_line++); // SLOPE_EW
6467 LoadNextSprite(SPR_SHORE_BASE + 17, *_cur.file, _cur.nfo_line++); // SLOPE_NS
6468 if (_loaded_newgrf_features.shore == SHORE_REPLACE_NONE) _loaded_newgrf_features.shore = SHORE_REPLACE_ONLY_NEW;
6469 return;
6470 }
6471
6472 /* Supported type? */
6473 if ((type >= lengthof(_action5_types)) || (_action5_types[type].block_type == A5BLOCK_INVALID)) {
6474 GrfMsg(2, "GraphicsNew: Custom graphics (type 0x{:02X}) sprite block of length {} (unimplemented, ignoring)", type, num);
6475 _cur.skip_sprites = num;
6476 return;
6477 }
6478
6479 const Action5Type *action5_type = &_action5_types[type];
6480
6481 /* Contrary to TTDP we allow always to specify too few sprites as we allow always an offset,
6482 * except for the long version of the shore type:
6483 * Ignore offset if not allowed */
6484 if ((action5_type->block_type != A5BLOCK_ALLOW_OFFSET) && (offset != 0)) {
6485 GrfMsg(1, "GraphicsNew: {} (type 0x{:02X}) do not allow an <offset> field. Ignoring offset.", action5_type->name, type);
6486 offset = 0;
6487 }
6488
6489 /* Ignore action5 if too few sprites are specified. (for TTDP compatibility)
6490 * This does not make sense, if <offset> is allowed */
6491 if ((action5_type->block_type == A5BLOCK_FIXED) && (num < action5_type->min_sprites)) {
6492 GrfMsg(1, "GraphicsNew: {} (type 0x{:02X}) count must be at least {}. Only {} were specified. Skipping.", action5_type->name, type, action5_type->min_sprites, num);
6493 _cur.skip_sprites = num;
6494 return;
6495 }
6496
6497 /* Load at most max_sprites sprites. Skip remaining sprites. (for compatibility with TTDP and future extensions) */
6498 uint16_t skip_num = SanitizeSpriteOffset(num, offset, action5_type->max_sprites, action5_type->name);
6499 SpriteID replace = action5_type->sprite_base + offset;
6500
6501 /* Load <num> sprites starting from <replace>, then skip <skip_num> sprites. */
6502 GrfMsg(2, "GraphicsNew: Replacing sprites {} to {} of {} (type 0x{:02X}) at SpriteID 0x{:04X}", offset, offset + num - 1, action5_type->name, type, replace);
6503
6504 if (type == 0x0D) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_5;
6505
6506 if (type == 0x0B) {
6507 static const SpriteID depot_with_track_offset = SPR_TRAMWAY_DEPOT_WITH_TRACK - SPR_TRAMWAY_BASE;
6508 static const SpriteID depot_no_track_offset = SPR_TRAMWAY_DEPOT_NO_TRACK - SPR_TRAMWAY_BASE;
6509 if (offset <= depot_with_track_offset && offset + num > depot_with_track_offset) _loaded_newgrf_features.tram = TRAMWAY_REPLACE_DEPOT_WITH_TRACK;
6510 if (offset <= depot_no_track_offset && offset + num > depot_no_track_offset) _loaded_newgrf_features.tram = TRAMWAY_REPLACE_DEPOT_NO_TRACK;
6511 }
6512
6513 /* If the baseset or grf only provides sprites for flat tiles (pre #10282), duplicate those for use on slopes. */
6514 bool dup_oneway_sprites = ((type == 0x09) && (offset + num <= SPR_ONEWAY_SLOPE_N_OFFSET));
6515
6516 for (; num > 0; num--) {
6517 _cur.nfo_line++;
6518 int load_index = (replace == 0 ? _cur.spriteid++ : replace++);
6519 LoadNextSprite(load_index, *_cur.file, _cur.nfo_line);
6520 if (dup_oneway_sprites) {
6521 DupSprite(load_index, load_index + SPR_ONEWAY_SLOPE_N_OFFSET);
6522 DupSprite(load_index, load_index + SPR_ONEWAY_SLOPE_S_OFFSET);
6523 }
6524 }
6525
6526 _cur.skip_sprites = skip_num;
6527 }
6528
6529 /* Action 0x05 (SKIP) */
6530 static void SkipAct5(ByteReader *buf)
6531 {
6532 /* Ignore type byte */
6533 buf->ReadByte();
6534
6535 /* Skip the sprites of this action */
6536 _cur.skip_sprites = buf->ReadExtendedByte();
6537
6538 GrfMsg(3, "SkipAct5: Skipping {} sprites", _cur.skip_sprites);
6539 }
6540
6552 bool GetGlobalVariable(byte param, uint32_t *value, const GRFFile *grffile)
6553 {
6554 switch (param) {
6555 case 0x00: // current date
6556 *value = std::max(TimerGameCalendar::date - CalendarTime::DAYS_TILL_ORIGINAL_BASE_YEAR, TimerGameCalendar::Date(0)).base();
6557 return true;
6558
6559 case 0x01: // current year
6560 *value = (Clamp(TimerGameCalendar::year, CalendarTime::ORIGINAL_BASE_YEAR, CalendarTime::ORIGINAL_MAX_YEAR) - CalendarTime::ORIGINAL_BASE_YEAR).base();
6561 return true;
6562
6563 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)
6564 TimerGameCalendar::YearMonthDay ymd = TimerGameCalendar::ConvertDateToYMD(TimerGameCalendar::date);
6565 TimerGameCalendar::Date start_of_year = TimerGameCalendar::ConvertYMDToDate(ymd.year, 0, 1);
6566 *value = ymd.month | (ymd.day - 1) << 8 | (TimerGameCalendar::IsLeapYear(ymd.year) ? 1 << 15 : 0) | (TimerGameCalendar::date - start_of_year).base() << 16;
6567 return true;
6568 }
6569
6570 case 0x03: // current climate, 0=temp, 1=arctic, 2=trop, 3=toyland
6571 *value = _settings_game.game_creation.landscape;
6572 return true;
6573
6574 case 0x06: // road traffic side, bit 4 clear=left, set=right
6575 *value = _settings_game.vehicle.road_side << 4;
6576 return true;
6577
6578 case 0x09: // date fraction
6579 *value = TimerGameCalendar::date_fract * 885;
6580 return true;
6581
6582 case 0x0A: // animation counter
6583 *value = GB(TimerGameTick::counter, 0, 16);
6584 return true;
6585
6586 case 0x0B: { // TTDPatch version
6587 uint major = 2;
6588 uint minor = 6;
6589 uint revision = 1; // special case: 2.0.1 is 2.0.10
6590 uint build = 1382;
6591 *value = (major << 24) | (minor << 20) | (revision << 16) | build;
6592 return true;
6593 }
6594
6595 case 0x0D: // TTD Version, 00=DOS, 01=Windows
6596 *value = _cur.grfconfig->palette & GRFP_USE_MASK;
6597 return true;
6598
6599 case 0x0E: // Y-offset for train sprites
6600 *value = _cur.grffile->traininfo_vehicle_pitch;
6601 return true;
6602
6603 case 0x0F: // Rail track type cost factors
6604 *value = 0;
6605 SB(*value, 0, 8, GetRailTypeInfo(RAILTYPE_RAIL)->cost_multiplier); // normal rail
6606 if (_settings_game.vehicle.disable_elrails) {
6607 /* skip elrail multiplier - disabled */
6608 SB(*value, 8, 8, GetRailTypeInfo(RAILTYPE_MONO)->cost_multiplier); // monorail
6609 } else {
6610 SB(*value, 8, 8, GetRailTypeInfo(RAILTYPE_ELECTRIC)->cost_multiplier); // electified railway
6611 /* Skip monorail multiplier - no space in result */
6612 }
6613 SB(*value, 16, 8, GetRailTypeInfo(RAILTYPE_MAGLEV)->cost_multiplier); // maglev
6614 return true;
6615
6616 case 0x11: // current rail tool type
6617 *value = 0; // constant fake value to avoid desync
6618 return true;
6619
6620 case 0x12: // Game mode
6621 *value = _game_mode;
6622 return true;
6623
6624 /* case 0x13: // Tile refresh offset to left not implemented */
6625 /* case 0x14: // Tile refresh offset to right not implemented */
6626 /* case 0x15: // Tile refresh offset upwards not implemented */
6627 /* case 0x16: // Tile refresh offset downwards not implemented */
6628 /* case 0x17: // temperate snow line not implemented */
6629
6630 case 0x1A: // Always -1
6631 *value = UINT_MAX;
6632 return true;
6633
6634 case 0x1B: // Display options
6635 *value = 0x3F; // constant fake value to avoid desync
6636 return true;
6637
6638 case 0x1D: // TTD Platform, 00=TTDPatch, 01=OpenTTD
6639 *value = 1;
6640 return true;
6641
6642 case 0x1E: // Miscellaneous GRF features
6643 *value = _misc_grf_features;
6644
6645 /* Add the local flags */
6646 assert(!HasBit(*value, GMB_TRAIN_WIDTH_32_PIXELS));
6647 if (_cur.grffile->traininfo_vehicle_width == VEHICLEINFO_FULL_VEHICLE_WIDTH) SetBit(*value, GMB_TRAIN_WIDTH_32_PIXELS);
6648 return true;
6649
6650 /* case 0x1F: // locale dependent settings not implemented to avoid desync */
6651
6652 case 0x20: { // snow line height
6653 byte snowline = GetSnowLine();
6654 if (_settings_game.game_creation.landscape == LT_ARCTIC && snowline <= _settings_game.construction.map_height_limit) {
6655 *value = Clamp(snowline * (grffile->grf_version >= 8 ? 1 : TILE_HEIGHT), 0, 0xFE);
6656 } else {
6657 /* No snow */
6658 *value = 0xFF;
6659 }
6660 return true;
6661 }
6662
6663 case 0x21: // OpenTTD version
6664 *value = _openttd_newgrf_version;
6665 return true;
6666
6667 case 0x22: // difficulty level
6668 *value = SP_CUSTOM;
6669 return true;
6670
6671 case 0x23: // long format date
6672 *value = TimerGameCalendar::date.base();
6673 return true;
6674
6675 case 0x24: // long format year
6676 *value = TimerGameCalendar::year.base();
6677 return true;
6678
6679 default: return false;
6680 }
6681 }
6682
6683 static uint32_t GetParamVal(byte param, uint32_t *cond_val)
6684 {
6685 /* First handle variable common with VarAction2 */
6686 uint32_t value;
6687 if (GetGlobalVariable(param - 0x80, &value, _cur.grffile)) return value;
6688
6689
6690 /* Non-common variable */
6691 switch (param) {
6692 case 0x84: { // GRF loading stage
6693 uint32_t res = 0;
6694
6695 if (_cur.stage > GLS_INIT) SetBit(res, 0);
6696 if (_cur.stage == GLS_RESERVE) SetBit(res, 8);
6697 if (_cur.stage == GLS_ACTIVATION) SetBit(res, 9);
6698 return res;
6699 }
6700
6701 case 0x85: // TTDPatch flags, only for bit tests
6702 if (cond_val == nullptr) {
6703 /* Supported in Action 0x07 and 0x09, not 0x0D */
6704 return 0;
6705 } else {
6706 uint32_t index = *cond_val / 0x20;
6707 uint32_t param_val = index < lengthof(_ttdpatch_flags) ? _ttdpatch_flags[index] : 0;
6708 *cond_val %= 0x20;
6709 return param_val;
6710 }
6711
6712 case 0x88: // GRF ID check
6713 return 0;
6714
6715 /* case 0x99: Global ID offset not implemented */
6716
6717 default:
6718 /* GRF Parameter */
6719 if (param < 0x80) return _cur.grffile->GetParam(param);
6720
6721 /* In-game variable. */
6722 GrfMsg(1, "Unsupported in-game variable 0x{:02X}", param);
6723 return UINT_MAX;
6724 }
6725 }
6726
6727 /* Action 0x06 */
6728 static void CfgApply(ByteReader *buf)
6729 {
6730 /* <06> <param-num> <param-size> <offset> ... <FF>
6731 *
6732 * B param-num Number of parameter to substitute (First = "zero")
6733 * Ignored if that parameter was not specified in newgrf.cfg
6734 * B param-size How many bytes to replace. If larger than 4, the
6735 * bytes of the following parameter are used. In that
6736 * case, nothing is applied unless *all* parameters
6737 * were specified.
6738 * B offset Offset into data from beginning of next sprite
6739 * to place where parameter is to be stored. */
6740
6741 /* Preload the next sprite */
6742 SpriteFile &file = *_cur.file;
6743 size_t pos = file.GetPos();
6744 uint32_t num = file.GetContainerVersion() >= 2 ? file.ReadDword() : file.ReadWord();
6745 uint8_t type = file.ReadByte();
6746
6747 /* Check if the sprite is a pseudo sprite. We can't operate on real sprites. */
6748 if (type != 0xFF) {
6749 GrfMsg(2, "CfgApply: Ignoring (next sprite is real, unsupported)");
6750
6751 /* Reset the file position to the start of the next sprite */
6752 file.SeekTo(pos, SEEK_SET);
6753 return;
6754 }
6755
6756 /* Get (or create) the override for the next sprite. */
6757 GRFLocation location(_cur.grfconfig->ident.grfid, _cur.nfo_line + 1);
6758 std::vector<byte> &preload_sprite = _grf_line_to_action6_sprite_override[location];
6759
6760 /* Load new sprite data if it hasn't already been loaded. */
6761 if (preload_sprite.empty()) {
6762 preload_sprite.resize(num);
6763 file.ReadBlock(preload_sprite.data(), num);
6764 }
6765
6766 /* Reset the file position to the start of the next sprite */
6767 file.SeekTo(pos, SEEK_SET);
6768
6769 /* Now perform the Action 0x06 on our data. */
6770 for (;;) {
6771 uint i;
6772 uint param_num;
6773 uint param_size;
6774 uint offset;
6775 bool add_value;
6776
6777 /* Read the parameter to apply. 0xFF indicates no more data to change. */
6778 param_num = buf->ReadByte();
6779 if (param_num == 0xFF) break;
6780
6781 /* Get the size of the parameter to use. If the size covers multiple
6782 * double words, sequential parameter values are used. */
6783 param_size = buf->ReadByte();
6784
6785 /* Bit 7 of param_size indicates we should add to the original value
6786 * instead of replacing it. */
6787 add_value = HasBit(param_size, 7);
6788 param_size = GB(param_size, 0, 7);
6789
6790 /* Where to apply the data to within the pseudo sprite data. */
6791 offset = buf->ReadExtendedByte();
6792
6793 /* If the parameter is a GRF parameter (not an internal variable) check
6794 * if it (and all further sequential parameters) has been defined. */
6795 if (param_num < 0x80 && (param_num + (param_size - 1) / 4) >= _cur.grffile->param_end) {
6796 GrfMsg(2, "CfgApply: Ignoring (param {} not set)", (param_num + (param_size - 1) / 4));
6797 break;
6798 }
6799
6800 GrfMsg(8, "CfgApply: Applying {} bytes from parameter 0x{:02X} at offset 0x{:04X}", param_size, param_num, offset);
6801
6802 bool carry = false;
6803 for (i = 0; i < param_size && offset + i < num; i++) {
6804 uint32_t value = GetParamVal(param_num + i / 4, nullptr);
6805 /* Reset carry flag for each iteration of the variable (only really
6806 * matters if param_size is greater than 4) */
6807 if (i % 4 == 0) carry = false;
6808
6809 if (add_value) {
6810 uint new_value = preload_sprite[offset + i] + GB(value, (i % 4) * 8, 8) + (carry ? 1 : 0);
6811 preload_sprite[offset + i] = GB(new_value, 0, 8);
6812 /* Check if the addition overflowed */
6813 carry = new_value >= 256;
6814 } else {
6815 preload_sprite[offset + i] = GB(value, (i % 4) * 8, 8);
6816 }
6817 }
6818 }
6819 }
6820
6830 static void DisableStaticNewGRFInfluencingNonStaticNewGRFs(GRFConfig *c)
6831 {
6832 GRFError *error = DisableGrf(STR_NEWGRF_ERROR_STATIC_GRF_CAUSES_DESYNC, c);
6833 error->data = _cur.grfconfig->GetName();
6834 }
6835
6836 /* Action 0x07
6837 * Action 0x09 */
6838 static void SkipIf(ByteReader *buf)
6839 {
6840 /* <07/09> <param-num> <param-size> <condition-type> <value> <num-sprites>
6841 *
6842 * B param-num
6843 * B param-size
6844 * B condition-type
6845 * V value
6846 * B num-sprites */
6847 uint32_t cond_val = 0;
6848 uint32_t mask = 0;
6849 bool result;
6850
6851 uint8_t param = buf->ReadByte();
6852 uint8_t paramsize = buf->ReadByte();
6853 uint8_t condtype = buf->ReadByte();
6854
6855 if (condtype < 2) {
6856 /* Always 1 for bit tests, the given value should be ignored. */
6857 paramsize = 1;
6858 }
6859
6860 switch (paramsize) {
6861 case 8: cond_val = buf->ReadDWord(); mask = buf->ReadDWord(); break;
6862 case 4: cond_val = buf->ReadDWord(); mask = 0xFFFFFFFF; break;
6863 case 2: cond_val = buf->ReadWord(); mask = 0x0000FFFF; break;
6864 case 1: cond_val = buf->ReadByte(); mask = 0x000000FF; break;
6865 default: break;
6866 }
6867
6868 if (param < 0x80 && _cur.grffile->param_end <= param) {
6869 GrfMsg(7, "SkipIf: Param {} undefined, skipping test", param);
6870 return;
6871 }
6872
6873 GrfMsg(7, "SkipIf: Test condtype {}, param 0x{:02X}, condval 0x{:08X}", condtype, param, cond_val);
6874
6875 /* condtypes that do not use 'param' are always valid.
6876 * condtypes that use 'param' are either not valid for param 0x88, or they are only valid for param 0x88.
6877 */
6878 if (condtype >= 0x0B) {
6879 /* Tests that ignore 'param' */
6880 switch (condtype) {
6881 case 0x0B: result = !IsValidCargoID(GetCargoIDByLabel(CargoLabel(BSWAP32(cond_val))));
6882 break;
6883 case 0x0C: result = IsValidCargoID(GetCargoIDByLabel(CargoLabel(BSWAP32(cond_val))));
6884 break;
6885 case 0x0D: result = GetRailTypeByLabel(BSWAP32(cond_val)) == INVALID_RAILTYPE;
6886 break;
6887 case 0x0E: result = GetRailTypeByLabel(BSWAP32(cond_val)) != INVALID_RAILTYPE;
6888 break;
6889 case 0x0F: {
6890 RoadType rt = GetRoadTypeByLabel(BSWAP32(cond_val));
6891 result = rt == INVALID_ROADTYPE || !RoadTypeIsRoad(rt);
6892 break;
6893 }
6894 case 0x10: {
6895 RoadType rt = GetRoadTypeByLabel(BSWAP32(cond_val));
6896 result = rt != INVALID_ROADTYPE && RoadTypeIsRoad(rt);
6897 break;
6898 }
6899 case 0x11: {
6900 RoadType rt = GetRoadTypeByLabel(BSWAP32(cond_val));
6901 result = rt == INVALID_ROADTYPE || !RoadTypeIsTram(rt);
6902 break;
6903 }
6904 case 0x12: {
6905 RoadType rt = GetRoadTypeByLabel(BSWAP32(cond_val));
6906 result = rt != INVALID_ROADTYPE && RoadTypeIsTram(rt);
6907 break;
6908 }
6909 default: GrfMsg(1, "SkipIf: Unsupported condition type {:02X}. Ignoring", condtype); return;
6910 }
6911 } else if (param == 0x88) {
6912 /* GRF ID checks */
6913
6914 GRFConfig *c = GetGRFConfig(cond_val, mask);
6915
6916 if (c != nullptr && HasBit(c->flags, GCF_STATIC) && !HasBit(_cur.grfconfig->flags, GCF_STATIC) && _networking) {
6917 DisableStaticNewGRFInfluencingNonStaticNewGRFs(c);
6918 c = nullptr;
6919 }
6920
6921 if (condtype != 10 && c == nullptr) {
6922 GrfMsg(7, "SkipIf: GRFID 0x{:08X} unknown, skipping test", BSWAP32(cond_val));
6923 return;
6924 }
6925
6926 switch (condtype) {
6927 /* Tests 0x06 to 0x0A are only for param 0x88, GRFID checks */
6928 case 0x06: // Is GRFID active?
6929 result = c->status == GCS_ACTIVATED;
6930 break;
6931
6932 case 0x07: // Is GRFID non-active?
6933 result = c->status != GCS_ACTIVATED;
6934 break;
6935
6936 case 0x08: // GRFID is not but will be active?
6937 result = c->status == GCS_INITIALISED;
6938 break;
6939
6940 case 0x09: // GRFID is or will be active?
6941 result = c->status == GCS_ACTIVATED || c->status == GCS_INITIALISED;
6942 break;
6943
6944 case 0x0A: // GRFID is not nor will be active
6945 /* This is the only condtype that doesn't get ignored if the GRFID is not found */
6946 result = c == nullptr || c->status == GCS_DISABLED || c->status == GCS_NOT_FOUND;
6947 break;
6948
6949 default: GrfMsg(1, "SkipIf: Unsupported GRF condition type {:02X}. Ignoring", condtype); return;
6950 }
6951 } else {
6952 /* Tests that use 'param' and are not GRF ID checks. */
6953 uint32_t param_val = GetParamVal(param, &cond_val); // cond_val is modified for param == 0x85
6954 switch (condtype) {
6955 case 0x00: result = !!(param_val & (1 << cond_val));
6956 break;
6957 case 0x01: result = !(param_val & (1 << cond_val));
6958 break;
6959 case 0x02: result = (param_val & mask) == cond_val;
6960 break;
6961 case 0x03: result = (param_val & mask) != cond_val;
6962 break;
6963 case 0x04: result = (param_val & mask) < cond_val;
6964 break;
6965 case 0x05: result = (param_val & mask) > cond_val;
6966 break;
6967 default: GrfMsg(1, "SkipIf: Unsupported condition type {:02X}. Ignoring", condtype); return;
6968 }
6969 }
6970
6971 if (!result) {
6972 GrfMsg(2, "SkipIf: Not skipping sprites, test was false");
6973 return;
6974 }
6975
6976 uint8_t numsprites = buf->ReadByte();
6977
6978 /* numsprites can be a GOTO label if it has been defined in the GRF
6979 * file. The jump will always be the first matching label that follows
6980 * the current nfo_line. If no matching label is found, the first matching
6981 * label in the file is used. */
6982 const GRFLabel *choice = nullptr;
6983 for (const auto &label : _cur.grffile->labels) {
6984 if (label.label != numsprites) continue;
6985
6986 /* Remember a goto before the current line */
6987 if (choice == nullptr) choice = &label;
6988 /* If we find a label here, this is definitely good */
6989 if (label.nfo_line > _cur.nfo_line) {
6990 choice = &label;
6991 break;
6992 }
6993 }
6994
6995 if (choice != nullptr) {
6996 GrfMsg(2, "SkipIf: Jumping to label 0x{:X} at line {}, test was true", choice->label, choice->nfo_line);
6997 _cur.file->SeekTo(choice->pos, SEEK_SET);
6998 _cur.nfo_line = choice->nfo_line;
6999 return;
7000 }
7001
7002 GrfMsg(2, "SkipIf: Skipping {} sprites, test was true", numsprites);
7003 _cur.skip_sprites = numsprites;
7004 if (_cur.skip_sprites == 0) {
7005 /* Zero means there are no sprites to skip, so
7006 * we use -1 to indicate that all further
7007 * sprites should be skipped. */
7008 _cur.skip_sprites = -1;
7009
7010 /* If an action 8 hasn't been encountered yet, disable the grf. */
7011 if (_cur.grfconfig->status != (_cur.stage < GLS_RESERVE ? GCS_INITIALISED : GCS_ACTIVATED)) {
7012 DisableGrf();
7013 }
7014 }
7015 }
7016
7017
7018 /* Action 0x08 (GLS_FILESCAN) */
7019 static void ScanInfo(ByteReader *buf)
7020 {
7021 uint8_t grf_version = buf->ReadByte();
7022 uint32_t grfid = buf->ReadDWord();
7023 const char *name = buf->ReadString();
7024
7025 _cur.grfconfig->ident.grfid = grfid;
7026
7027 if (grf_version < 2 || grf_version > 8) {
7028 SetBit(_cur.grfconfig->flags, GCF_INVALID);
7029 Debug(grf, 0, "{}: NewGRF \"{}\" (GRFID {:08X}) uses GRF version {}, which is incompatible with this version of OpenTTD.", _cur.grfconfig->filename, name, BSWAP32(grfid), grf_version);
7030 }
7031
7032 /* GRF IDs starting with 0xFF are reserved for internal TTDPatch use */
7033 if (GB(grfid, 0, 8) == 0xFF) SetBit(_cur.grfconfig->flags, GCF_SYSTEM);
7034
7035 AddGRFTextToList(_cur.grfconfig->name, 0x7F, grfid, false, name);
7036
7037 if (buf->HasData()) {
7038 const char *info = buf->ReadString();
7039 AddGRFTextToList(_cur.grfconfig->info, 0x7F, grfid, true, info);
7040 }
7041
7042 /* GLS_INFOSCAN only looks for the action 8, so we can skip the rest of the file */
7043 _cur.skip_sprites = -1;
7044 }
7045
7046 /* Action 0x08 */
7047 static void GRFInfo(ByteReader *buf)
7048 {
7049 /* <08> <version> <grf-id> <name> <info>
7050 *
7051 * B version newgrf version, currently 06
7052 * 4*B grf-id globally unique ID of this .grf file
7053 * S name name of this .grf set
7054 * S info string describing the set, and e.g. author and copyright */
7055
7056 uint8_t version = buf->ReadByte();
7057 uint32_t grfid = buf->ReadDWord();
7058 const char *name = buf->ReadString();
7059
7060 if (_cur.stage < GLS_RESERVE && _cur.grfconfig->status != GCS_UNKNOWN) {
7061 DisableGrf(STR_NEWGRF_ERROR_MULTIPLE_ACTION_8);
7062 return;
7063 }
7064
7065 if (_cur.grffile->grfid != grfid) {
7066 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));
7067 _cur.grffile->grfid = grfid;
7068 }
7069
7070 _cur.grffile->grf_version = version;
7071 _cur.grfconfig->status = _cur.stage < GLS_RESERVE ? GCS_INITIALISED : GCS_ACTIVATED;
7072
7073 /* Do swap the GRFID for displaying purposes since people expect that */
7074 Debug(grf, 1, "GRFInfo: Loaded GRFv{} set {:08X} - {} (palette: {}, version: {})", version, BSWAP32(grfid), name, (_cur.grfconfig->palette & GRFP_USE_MASK) ? "Windows" : "DOS", _cur.grfconfig->version);
7075 }
7076
7077 /* Action 0x0A */
7078 static void SpriteReplace(ByteReader *buf)
7079 {
7080 /* <0A> <num-sets> <set1> [<set2> ...]
7081 * <set>: <num-sprites> <first-sprite>
7082 *
7083 * B num-sets How many sets of sprites to replace.
7084 * Each set:
7085 * B num-sprites How many sprites are in this set
7086 * W first-sprite First sprite number to replace */
7087
7088 uint8_t num_sets = buf->ReadByte();
7089
7090 for (uint i = 0; i < num_sets; i++) {
7091 uint8_t num_sprites = buf->ReadByte();
7092 uint16_t first_sprite = buf->ReadWord();
7093
7094 GrfMsg(2, "SpriteReplace: [Set {}] Changing {} sprites, beginning with {}",
7095 i, num_sprites, first_sprite
7096 );
7097
7098 for (uint j = 0; j < num_sprites; j++) {
7099 int load_index = first_sprite + j;
7100 _cur.nfo_line++;
7101 LoadNextSprite(load_index, *_cur.file, _cur.nfo_line); // XXX
7102
7103 /* Shore sprites now located at different addresses.
7104 * So detect when the old ones get replaced. */
7105 if (IsInsideMM(load_index, SPR_ORIGINALSHORE_START, SPR_ORIGINALSHORE_END + 1)) {
7106 if (_loaded_newgrf_features.shore != SHORE_REPLACE_ACTION_5) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_A;
7107 }
7108 }
7109 }
7110 }
7111
7112 /* Action 0x0A (SKIP) */
7113 static void SkipActA(ByteReader *buf)
7114 {
7115 uint8_t num_sets = buf->ReadByte();
7116
7117 for (uint i = 0; i < num_sets; i++) {
7118 /* Skip the sprites this replaces */
7119 _cur.skip_sprites += buf->ReadByte();
7120 /* But ignore where they go */
7121 buf->ReadWord();
7122 }
7123
7124 GrfMsg(3, "SkipActA: Skipping {} sprites", _cur.skip_sprites);
7125 }
7126
7127 /* Action 0x0B */
7128 static void GRFLoadError(ByteReader *buf)
7129 {
7130 /* <0B> <severity> <language-id> <message-id> [<message...> 00] [<data...>] 00 [<parnum>]
7131 *
7132 * B severity 00: notice, continue loading grf file
7133 * 01: warning, continue loading grf file
7134 * 02: error, but continue loading grf file, and attempt
7135 * loading grf again when loading or starting next game
7136 * 03: error, abort loading and prevent loading again in
7137 * the future (only when restarting the patch)
7138 * B language-id see action 4, use 1F for built-in error messages
7139 * B message-id message to show, see below
7140 * S message for custom messages (message-id FF), text of the message
7141 * not present for built-in messages.
7142 * V data additional data for built-in (or custom) messages
7143 * B parnum parameter numbers to be shown in the message (maximum of 2) */
7144
7145 static const StringID msgstr[] = {
7146 STR_NEWGRF_ERROR_VERSION_NUMBER,
7147 STR_NEWGRF_ERROR_DOS_OR_WINDOWS,
7148 STR_NEWGRF_ERROR_UNSET_SWITCH,
7149 STR_NEWGRF_ERROR_INVALID_PARAMETER,
7150 STR_NEWGRF_ERROR_LOAD_BEFORE,
7151 STR_NEWGRF_ERROR_LOAD_AFTER,
7152 STR_NEWGRF_ERROR_OTTD_VERSION_NUMBER,
7153 };
7154
7155 static const StringID sevstr[] = {
7156 STR_NEWGRF_ERROR_MSG_INFO,
7157 STR_NEWGRF_ERROR_MSG_WARNING,
7158 STR_NEWGRF_ERROR_MSG_ERROR,
7159 STR_NEWGRF_ERROR_MSG_FATAL
7160 };
7161
7162 byte severity = buf->ReadByte();
7163 byte lang = buf->ReadByte();
7164 byte message_id = buf->ReadByte();
7165
7166 /* Skip the error if it isn't valid for the current language. */
7167 if (!CheckGrfLangID(lang, _cur.grffile->grf_version)) return;
7168
7169 /* Skip the error until the activation stage unless bit 7 of the severity
7170 * is set. */
7171 if (!HasBit(severity, 7) && _cur.stage == GLS_INIT) {
7172 GrfMsg(7, "GRFLoadError: Skipping non-fatal GRFLoadError in stage {}", _cur.stage);
7173 return;
7174 }
7175 ClrBit(severity, 7);
7176
7177 if (severity >= lengthof(sevstr)) {
7178 GrfMsg(7, "GRFLoadError: Invalid severity id {}. Setting to 2 (non-fatal error).", severity);
7179 severity = 2;
7180 } else if (severity == 3) {
7181 /* This is a fatal error, so make sure the GRF is deactivated and no
7182 * more of it gets loaded. */
7183 DisableGrf();
7184
7185 /* Make sure we show fatal errors, instead of silly infos from before */
7186 _cur.grfconfig->error.reset();
7187 }
7188
7189 if (message_id >= lengthof(msgstr) && message_id != 0xFF) {
7190 GrfMsg(7, "GRFLoadError: Invalid message id.");
7191 return;
7192 }
7193
7194 if (buf->Remaining() <= 1) {
7195 GrfMsg(7, "GRFLoadError: No message data supplied.");
7196 return;
7197 }
7198
7199 /* For now we can only show one message per newgrf file. */
7200 if (_cur.grfconfig->error.has_value()) return;
7201
7202 _cur.grfconfig->error = {sevstr[severity]};
7203 GRFError *error = &_cur.grfconfig->error.value();
7204
7205 if (message_id == 0xFF) {
7206 /* This is a custom error message. */
7207 if (buf->HasData()) {
7208 const char *message = buf->ReadString();
7209
7210 error->custom_message = TranslateTTDPatchCodes(_cur.grffile->grfid, lang, true, message, SCC_RAW_STRING_POINTER);
7211 } else {
7212 GrfMsg(7, "GRFLoadError: No custom message supplied.");
7213 error->custom_message.clear();
7214 }
7215 } else {
7216 error->message = msgstr[message_id];
7217 }
7218
7219 if (buf->HasData()) {
7220 const char *data = buf->ReadString();
7221
7222 error->data = TranslateTTDPatchCodes(_cur.grffile->grfid, lang, true, data);
7223 } else {
7224 GrfMsg(7, "GRFLoadError: No message data supplied.");
7225 error->data.clear();
7226 }
7227
7228 /* Only two parameter numbers can be used in the string. */
7229 for (uint i = 0; i < error->param_value.size() && buf->HasData(); i++) {
7230 uint param_number = buf->ReadByte();
7231 error->param_value[i] = _cur.grffile->GetParam(param_number);
7232 }
7233 }
7234
7235 /* Action 0x0C */
7236 static void GRFComment(ByteReader *buf)
7237 {
7238 /* <0C> [<ignored...>]
7239 *
7240 * V ignored Anything following the 0C is ignored */
7241
7242 if (!buf->HasData()) return;
7243
7244 const char *text = buf->ReadString();
7245 GrfMsg(2, "GRFComment: {}", text);
7246 }
7247
7248 /* Action 0x0D (GLS_SAFETYSCAN) */
7249 static void SafeParamSet(ByteReader *buf)
7250 {
7251 uint8_t target = buf->ReadByte();
7252
7253 /* Writing GRF parameters and some bits of 'misc GRF features' are safe. */
7254 if (target < 0x80 || target == 0x9E) return;
7255
7256 /* GRM could be unsafe, but as here it can only happen after other GRFs
7257 * are loaded, it should be okay. If the GRF tried to use the slots it
7258 * reserved, it would be marked unsafe anyway. GRM for (e.g. bridge)
7259 * sprites is considered safe. */
7260
7261 SetBit(_cur.grfconfig->flags, GCF_UNSAFE);
7262
7263 /* Skip remainder of GRF */
7264 _cur.skip_sprites = -1;
7265 }
7266
7267
7268 static uint32_t GetPatchVariable(uint8_t param)
7269 {
7270 switch (param) {
7271 /* start year - 1920 */
7272 case 0x0B: return (std::max(_settings_game.game_creation.starting_year, CalendarTime::ORIGINAL_BASE_YEAR) - CalendarTime::ORIGINAL_BASE_YEAR).base();
7273
7274 /* freight trains weight factor */
7275 case 0x0E: return _settings_game.vehicle.freight_trains;
7276
7277 /* empty wagon speed increase */
7278 case 0x0F: return 0;
7279
7280 /* plane speed factor; our patch option is reversed from TTDPatch's,
7281 * the following is good for 1x, 2x and 4x (most common?) and...
7282 * well not really for 3x. */
7283 case 0x10:
7284 switch (_settings_game.vehicle.plane_speed) {
7285 default:
7286 case 4: return 1;
7287 case 3: return 2;
7288 case 2: return 2;
7289 case 1: return 4;
7290 }
7291
7292
7293 /* 2CC colourmap base sprite */
7294 case 0x11: return SPR_2CCMAP_BASE;
7295
7296 /* map size: format = -MABXYSS
7297 * M : the type of map
7298 * bit 0 : set : squared map. Bit 1 is now not relevant
7299 * clear : rectangle map. Bit 1 will indicate the bigger edge of the map
7300 * bit 1 : set : Y is the bigger edge. Bit 0 is clear
7301 * clear : X is the bigger edge.
7302 * A : minimum edge(log2) of the map
7303 * B : maximum edge(log2) of the map
7304 * XY : edges(log2) of each side of the map.
7305 * SS : combination of both X and Y, thus giving the size(log2) of the map
7306 */
7307 case 0x13: {
7308 byte map_bits = 0;
7309 byte log_X = Map::LogX() - 6; // subtraction is required to make the minimal size (64) zero based
7310 byte log_Y = Map::LogY() - 6;
7311 byte max_edge = std::max(log_X, log_Y);
7312
7313 if (log_X == log_Y) { // we have a squared map, since both edges are identical
7314 SetBit(map_bits, 0);
7315 } else {
7316 if (max_edge == log_Y) SetBit(map_bits, 1); // edge Y been the biggest, mark it
7317 }
7318
7319 return (map_bits << 24) | (std::min(log_X, log_Y) << 20) | (max_edge << 16) |
7320 (log_X << 12) | (log_Y << 8) | (log_X + log_Y);
7321 }
7322
7323 /* The maximum height of the map. */
7324 case 0x14:
7325 return _settings_game.construction.map_height_limit;
7326
7327 /* Extra foundations base sprite */
7328 case 0x15:
7329 return SPR_SLOPES_BASE;
7330
7331 /* Shore base sprite */
7332 case 0x16:
7333 return SPR_SHORE_BASE;
7334
7335 /* Game map seed */
7336 case 0x17:
7337 return _settings_game.game_creation.generation_seed;
7338
7339 default:
7340 GrfMsg(2, "ParamSet: Unknown Patch variable 0x{:02X}.", param);
7341 return 0;
7342 }
7343 }
7344
7345
7346 static uint32_t PerformGRM(uint32_t *grm, uint16_t num_ids, uint16_t count, uint8_t op, uint8_t target, const char *type)
7347 {
7348 uint start = 0;
7349 uint size = 0;
7350
7351 if (op == 6) {
7352 /* Return GRFID of set that reserved ID */
7353 return grm[_cur.grffile->GetParam(target)];
7354 }
7355
7356 /* With an operation of 2 or 3, we want to reserve a specific block of IDs */
7357 if (op == 2 || op == 3) start = _cur.grffile->GetParam(target);
7358
7359 for (uint i = start; i < num_ids; i++) {
7360 if (grm[i] == 0) {
7361 size++;
7362 } else {
7363 if (op == 2 || op == 3) break;
7364 start = i + 1;
7365 size = 0;
7366 }
7367
7368 if (size == count) break;
7369 }
7370
7371 if (size == count) {
7372 /* Got the slot... */
7373 if (op == 0 || op == 3) {
7374 GrfMsg(2, "ParamSet: GRM: Reserving {} {} at {}", count, type, start);
7375 for (uint i = 0; i < count; i++) grm[start + i] = _cur.grffile->grfid;
7376 }
7377 return start;
7378 }
7379
7380 /* Unable to allocate */
7381 if (op != 4 && op != 5) {
7382 /* Deactivate GRF */
7383 GrfMsg(0, "ParamSet: GRM: Unable to allocate {} {}, deactivating", count, type);
7384 DisableGrf(STR_NEWGRF_ERROR_GRM_FAILED);
7385 return UINT_MAX;
7386 }
7387
7388 GrfMsg(1, "ParamSet: GRM: Unable to allocate {} {}", count, type);
7389 return UINT_MAX;
7390 }
7391
7392
7394 static void ParamSet(ByteReader *buf)
7395 {
7396 /* <0D> <target> <operation> <source1> <source2> [<data>]
7397 *
7398 * B target parameter number where result is stored
7399 * B operation operation to perform, see below
7400 * B source1 first source operand
7401 * B source2 second source operand
7402 * D data data to use in the calculation, not necessary
7403 * if both source1 and source2 refer to actual parameters
7404 *
7405 * Operations
7406 * 00 Set parameter equal to source1
7407 * 01 Addition, source1 + source2
7408 * 02 Subtraction, source1 - source2
7409 * 03 Unsigned multiplication, source1 * source2 (both unsigned)
7410 * 04 Signed multiplication, source1 * source2 (both signed)
7411 * 05 Unsigned bit shift, source1 by source2 (source2 taken to be a
7412 * signed quantity; left shift if positive and right shift if
7413 * negative, source1 is unsigned)
7414 * 06 Signed bit shift, source1 by source2
7415 * (source2 like in 05, and source1 as well)
7416 */
7417
7418 uint8_t target = buf->ReadByte();
7419 uint8_t oper = buf->ReadByte();
7420 uint32_t src1 = buf->ReadByte();
7421 uint32_t src2 = buf->ReadByte();
7422
7423 uint32_t data = 0;
7424 if (buf->Remaining() >= 4) data = buf->ReadDWord();
7425
7426 /* You can add 80 to the operation to make it apply only if the target
7427 * is not defined yet. In this respect, a parameter is taken to be
7428 * defined if any of the following applies:
7429 * - it has been set to any value in the newgrf(w).cfg parameter list
7430 * - it OR A PARAMETER WITH HIGHER NUMBER has been set to any value by
7431 * an earlier action D */
7432 if (HasBit(oper, 7)) {
7433 if (target < 0x80 && target < _cur.grffile->param_end) {
7434 GrfMsg(7, "ParamSet: Param {} already defined, skipping", target);
7435 return;
7436 }
7437
7438 oper = GB(oper, 0, 7);
7439 }
7440
7441 if (src2 == 0xFE) {
7442 if (GB(data, 0, 8) == 0xFF) {
7443 if (data == 0x0000FFFF) {
7444 /* Patch variables */
7445 src1 = GetPatchVariable(src1);
7446 } else {
7447 /* GRF Resource Management */
7448 uint8_t op = src1;
7449 uint8_t feature = GB(data, 8, 8);
7450 uint16_t count = GB(data, 16, 16);
7451
7452 if (_cur.stage == GLS_RESERVE) {
7453 if (feature == 0x08) {
7454 /* General sprites */
7455 if (op == 0) {
7456 /* Check if the allocated sprites will fit below the original sprite limit */
7457 if (_cur.spriteid + count >= 16384) {
7458 GrfMsg(0, "ParamSet: GRM: Unable to allocate {} sprites; try changing NewGRF order", count);
7459 DisableGrf(STR_NEWGRF_ERROR_GRM_FAILED);
7460 return;
7461 }
7462
7463 /* Reserve space at the current sprite ID */
7464 GrfMsg(4, "ParamSet: GRM: Allocated {} sprites at {}", count, _cur.spriteid);
7465 _grm_sprites[GRFLocation(_cur.grffile->grfid, _cur.nfo_line)] = _cur.spriteid;
7466 _cur.spriteid += count;
7467 }
7468 }
7469 /* Ignore GRM result during reservation */
7470 src1 = 0;
7471 } else if (_cur.stage == GLS_ACTIVATION) {
7472 switch (feature) {
7473 case 0x00: // Trains
7474 case 0x01: // Road Vehicles
7475 case 0x02: // Ships
7476 case 0x03: // Aircraft
7477 if (!_settings_game.vehicle.dynamic_engines) {
7478 src1 = PerformGRM(&_grm_engines[_engine_offsets[feature]], _engine_counts[feature], count, op, target, "vehicles");
7479 if (_cur.skip_sprites == -1) return;
7480 } else {
7481 /* GRM does not apply for dynamic engine allocation. */
7482 switch (op) {
7483 case 2:
7484 case 3:
7485 src1 = _cur.grffile->GetParam(target);
7486 break;
7487
7488 default:
7489 src1 = 0;
7490 break;
7491 }
7492 }
7493 break;
7494
7495 case 0x08: // General sprites
7496 switch (op) {
7497 case 0:
7498 /* Return space reserved during reservation stage */
7499 src1 = _grm_sprites[GRFLocation(_cur.grffile->grfid, _cur.nfo_line)];
7500 GrfMsg(4, "ParamSet: GRM: Using pre-allocated sprites at {}", src1);
7501 break;
7502
7503 case 1:
7504 src1 = _cur.spriteid;
7505 break;
7506
7507 default:
7508 GrfMsg(1, "ParamSet: GRM: Unsupported operation {} for general sprites", op);
7509 return;
7510 }
7511 break;
7512
7513 case 0x0B: // Cargo
7514 /* There are two ranges: one for cargo IDs and one for cargo bitmasks */
7515 src1 = PerformGRM(_grm_cargoes, NUM_CARGO * 2, count, op, target, "cargoes");
7516 if (_cur.skip_sprites == -1) return;
7517 break;
7518
7519 default: GrfMsg(1, "ParamSet: GRM: Unsupported feature 0x{:X}", feature); return;
7520 }
7521 } else {
7522 /* Ignore GRM during initialization */
7523 src1 = 0;
7524 }
7525 }
7526 } else {
7527 /* Read another GRF File's parameter */
7528 const GRFFile *file = GetFileByGRFID(data);
7529 GRFConfig *c = GetGRFConfig(data);
7530 if (c != nullptr && HasBit(c->flags, GCF_STATIC) && !HasBit(_cur.grfconfig->flags, GCF_STATIC) && _networking) {
7531 /* Disable the read GRF if it is a static NewGRF. */
7532 DisableStaticNewGRFInfluencingNonStaticNewGRFs(c);
7533 src1 = 0;
7534 } else if (file == nullptr || c == nullptr || c->status == GCS_DISABLED) {
7535 src1 = 0;
7536 } else if (src1 == 0xFE) {
7537 src1 = c->version;
7538 } else {
7539 src1 = file->GetParam(src1);
7540 }
7541 }
7542 } else {
7543 /* The source1 and source2 operands refer to the grf parameter number
7544 * like in action 6 and 7. In addition, they can refer to the special
7545 * variables available in action 7, or they can be FF to use the value
7546 * of <data>. If referring to parameters that are undefined, a value
7547 * of 0 is used instead. */
7548 src1 = (src1 == 0xFF) ? data : GetParamVal(src1, nullptr);
7549 src2 = (src2 == 0xFF) ? data : GetParamVal(src2, nullptr);
7550 }
7551
7552 uint32_t res;
7553 switch (oper) {
7554 case 0x00:
7555 res = src1;
7556 break;
7557
7558 case 0x01:
7559 res = src1 + src2;
7560 break;
7561
7562 case 0x02:
7563 res = src1 - src2;
7564 break;
7565
7566 case 0x03:
7567 res = src1 * src2;
7568 break;
7569
7570 case 0x04:
7571 res = (int32_t)src1 * (int32_t)src2;
7572 break;
7573
7574 case 0x05:
7575 if ((int32_t)src2 < 0) {
7576 res = src1 >> -(int32_t)src2;
7577 } else {
7578 res = src1 << (src2 & 0x1F); // Same behaviour as in EvalAdjustT, mask 'value' to 5 bits, which should behave the same on all architectures.
7579 }
7580 break;
7581
7582 case 0x06:
7583 if ((int32_t)src2 < 0) {
7584 res = (int32_t)src1 >> -(int32_t)src2;
7585 } else {
7586 res = (int32_t)src1 << (src2 & 0x1F); // Same behaviour as in EvalAdjustT, mask 'value' to 5 bits, which should behave the same on all architectures.
7587 }
7588 break;
7589
7590 case 0x07: // Bitwise AND
7591 res = src1 & src2;
7592 break;
7593
7594 case 0x08: // Bitwise OR
7595 res = src1 | src2;
7596 break;
7597
7598 case 0x09: // Unsigned division
7599 if (src2 == 0) {
7600 res = src1;
7601 } else {
7602 res = src1 / src2;
7603 }
7604 break;
7605
7606 case 0x0A: // Signed division
7607 if (src2 == 0) {
7608 res = src1;
7609 } else {
7610 res = (int32_t)src1 / (int32_t)src2;
7611 }
7612 break;
7613
7614 case 0x0B: // Unsigned modulo
7615 if (src2 == 0) {
7616 res = src1;
7617 } else {
7618 res = src1 % src2;
7619 }
7620 break;
7621
7622 case 0x0C: // Signed modulo
7623 if (src2 == 0) {
7624 res = src1;
7625 } else {
7626 res = (int32_t)src1 % (int32_t)src2;
7627 }
7628 break;
7629
7630 default: GrfMsg(0, "ParamSet: Unknown operation {}, skipping", oper); return;
7631 }
7632
7633 switch (target) {
7634 case 0x8E: // Y-Offset for train sprites
7635 _cur.grffile->traininfo_vehicle_pitch = res;
7636 break;
7637
7638 case 0x8F: { // Rail track type cost factors
7639 extern RailTypeInfo _railtypes[RAILTYPE_END];
7640 _railtypes[RAILTYPE_RAIL].cost_multiplier = GB(res, 0, 8);
7641 if (_settings_game.vehicle.disable_elrails) {
7642 _railtypes[RAILTYPE_ELECTRIC].cost_multiplier = GB(res, 0, 8);
7643 _railtypes[RAILTYPE_MONO].cost_multiplier = GB(res, 8, 8);
7644 } else {
7645 _railtypes[RAILTYPE_ELECTRIC].cost_multiplier = GB(res, 8, 8);
7646 _railtypes[RAILTYPE_MONO].cost_multiplier = GB(res, 16, 8);
7647 }
7648 _railtypes[RAILTYPE_MAGLEV].cost_multiplier = GB(res, 16, 8);
7649 break;
7650 }
7651
7652 /* not implemented */
7653 case 0x93: // Tile refresh offset to left -- Intended to allow support for larger sprites, not necessary for OTTD
7654 case 0x94: // Tile refresh offset to right
7655 case 0x95: // Tile refresh offset upwards
7656 case 0x96: // Tile refresh offset downwards
7657 case 0x97: // Snow line height -- Better supported by feature 8 property 10h (snow line table) TODO: implement by filling the entire snow line table with the given value
7658 case 0x99: // Global ID offset -- Not necessary since IDs are remapped automatically
7659 GrfMsg(7, "ParamSet: Skipping unimplemented target 0x{:02X}", target);
7660 break;
7661
7662 case 0x9E: // Miscellaneous GRF features
7663 /* Set train list engine width */
7664 _cur.grffile->traininfo_vehicle_width = HasBit(res, GMB_TRAIN_WIDTH_32_PIXELS) ? VEHICLEINFO_FULL_VEHICLE_WIDTH : TRAININFO_DEFAULT_VEHICLE_WIDTH;
7665 /* Remove the local flags from the global flags */
7666 ClrBit(res, GMB_TRAIN_WIDTH_32_PIXELS);
7667
7668 /* Only copy safe bits for static grfs */
7669 if (HasBit(_cur.grfconfig->flags, GCF_STATIC)) {
7670 uint32_t safe_bits = 0;
7671 SetBit(safe_bits, GMB_SECOND_ROCKY_TILE_SET);
7672
7673 _misc_grf_features = (_misc_grf_features & ~safe_bits) | (res & safe_bits);
7674 } else {
7675 _misc_grf_features = res;
7676 }
7677 break;
7678
7679 case 0x9F: // locale-dependent settings
7680 GrfMsg(7, "ParamSet: Skipping unimplemented target 0x{:02X}", target);
7681 break;
7682
7683 default:
7684 if (target < 0x80) {
7685 _cur.grffile->param[target] = res;
7686 /* param is zeroed by default */
7687 if (target + 1U > _cur.grffile->param_end) _cur.grffile->param_end = target + 1;
7688 } else {
7689 GrfMsg(7, "ParamSet: Skipping unknown target 0x{:02X}", target);
7690 }
7691 break;
7692 }
7693 }
7694
7695 /* Action 0x0E (GLS_SAFETYSCAN) */
7696 static void SafeGRFInhibit(ByteReader *buf)
7697 {
7698 /* <0E> <num> <grfids...>
7699 *
7700 * B num Number of GRFIDs that follow
7701 * D grfids GRFIDs of the files to deactivate */
7702
7703 uint8_t num = buf->ReadByte();
7704
7705 for (uint i = 0; i < num; i++) {
7706 uint32_t grfid = buf->ReadDWord();
7707
7708 /* GRF is unsafe it if tries to deactivate other GRFs */
7709 if (grfid != _cur.grfconfig->ident.grfid) {
7710 SetBit(_cur.grfconfig->flags, GCF_UNSAFE);
7711
7712 /* Skip remainder of GRF */
7713 _cur.skip_sprites = -1;
7714
7715 return;
7716 }
7717 }
7718 }
7719
7720 /* Action 0x0E */
7721 static void GRFInhibit(ByteReader *buf)
7722 {
7723 /* <0E> <num> <grfids...>
7724 *
7725 * B num Number of GRFIDs that follow
7726 * D grfids GRFIDs of the files to deactivate */
7727
7728 uint8_t num = buf->ReadByte();
7729
7730 for (uint i = 0; i < num; i++) {
7731 uint32_t grfid = buf->ReadDWord();
7732 GRFConfig *file = GetGRFConfig(grfid);
7733
7734 /* Unset activation flag */
7735 if (file != nullptr && file != _cur.grfconfig) {
7736 GrfMsg(2, "GRFInhibit: Deactivating file '{}'", file->filename);
7737 GRFError *error = DisableGrf(STR_NEWGRF_ERROR_FORCEFULLY_DISABLED, file);
7738 error->data = _cur.grfconfig->GetName();
7739 }
7740 }
7741 }
7742
7744 static void FeatureTownName(ByteReader *buf)
7745 {
7746 /* <0F> <id> <style-name> <num-parts> <parts>
7747 *
7748 * B id ID of this definition in bottom 7 bits (final definition if bit 7 set)
7749 * V style-name Name of the style (only for final definition)
7750 * B num-parts Number of parts in this definition
7751 * V parts The parts */
7752
7753 uint32_t grfid = _cur.grffile->grfid;
7754
7755 GRFTownName *townname = AddGRFTownName(grfid);
7756
7757 byte id = buf->ReadByte();
7758 GrfMsg(6, "FeatureTownName: definition 0x{:02X}", id & 0x7F);
7759
7760 if (HasBit(id, 7)) {
7761 /* Final definition */
7762 ClrBit(id, 7);
7763 bool new_scheme = _cur.grffile->grf_version >= 7;
7764
7765 byte lang = buf->ReadByte();
7766 StringID style = STR_UNDEFINED;
7767
7768 do {
7769 ClrBit(lang, 7);
7770
7771 const char *name = buf->ReadString();
7772
7773 std::string lang_name = TranslateTTDPatchCodes(grfid, lang, false, name);
7774 GrfMsg(6, "FeatureTownName: lang 0x{:X} -> '{}'", lang, lang_name);
7775
7776 style = AddGRFString(grfid, id, lang, new_scheme, false, name, STR_UNDEFINED);
7777
7778 lang = buf->ReadByte();
7779 } while (lang != 0);
7780 townname->styles.emplace_back(style, id);
7781 }
7782
7783 uint8_t parts = buf->ReadByte();
7784 GrfMsg(6, "FeatureTownName: {} parts", parts);
7785
7786 townname->partlists[id].reserve(parts);
7787 for (uint partnum = 0; partnum < parts; partnum++) {
7788 NamePartList &partlist = townname->partlists[id].emplace_back();
7789 uint8_t texts = buf->ReadByte();
7790 partlist.bitstart = buf->ReadByte();
7791 partlist.bitcount = buf->ReadByte();
7792 partlist.maxprob = 0;
7793 GrfMsg(6, "FeatureTownName: part {} contains {} texts and will use GB(seed, {}, {})", partnum, texts, partlist.bitstart, partlist.bitcount);
7794
7795 partlist.parts.reserve(texts);
7796 for (uint textnum = 0; textnum < texts; textnum++) {
7797 NamePart &part = partlist.parts.emplace_back();
7798 part.prob = buf->ReadByte();
7799
7800 if (HasBit(part.prob, 7)) {
7801 byte ref_id = buf->ReadByte();
7802 if (ref_id >= GRFTownName::MAX_LISTS || townname->partlists[ref_id].empty()) {
7803 GrfMsg(0, "FeatureTownName: definition 0x{:02X} doesn't exist, deactivating", ref_id);
7804 DelGRFTownName(grfid);
7805 DisableGrf(STR_NEWGRF_ERROR_INVALID_ID);
7806 return;
7807 }
7808 part.id = ref_id;
7809 GrfMsg(6, "FeatureTownName: part {}, text {}, uses intermediate definition 0x{:02X} (with probability {})", partnum, textnum, ref_id, part.prob & 0x7F);
7810 } else {
7811 const char *text = buf->ReadString();
7812 part.text = TranslateTTDPatchCodes(grfid, 0, false, text);
7813 GrfMsg(6, "FeatureTownName: part {}, text {}, '{}' (with probability {})", partnum, textnum, part.text, part.prob);
7814 }
7815 partlist.maxprob += GB(part.prob, 0, 7);
7816 }
7817 GrfMsg(6, "FeatureTownName: part {}, total probability {}", partnum, partlist.maxprob);
7818 }
7819 }
7820
7822 static void DefineGotoLabel(ByteReader *buf)
7823 {
7824 /* <10> <label> [<comment>]
7825 *
7826 * B label The label to define
7827 * V comment Optional comment - ignored */
7828
7829 byte nfo_label = buf->ReadByte();
7830
7831 _cur.grffile->labels.emplace_back(nfo_label, _cur.nfo_line, _cur.file->GetPos());
7832
7833 GrfMsg(2, "DefineGotoLabel: GOTO target with label 0x{:02X}", nfo_label);
7834 }
7835
7840 static void ImportGRFSound(SoundEntry *sound)
7841 {
7842 const GRFFile *file;
7843 uint32_t grfid = _cur.file->ReadDword();
7844 SoundID sound_id = _cur.file->ReadWord();
7845
7846 file = GetFileByGRFID(grfid);
7847 if (file == nullptr || file->sound_offset == 0) {
7848 GrfMsg(1, "ImportGRFSound: Source file not available");
7849 return;
7850 }
7851
7852 if (sound_id >= file->num_sounds) {
7853 GrfMsg(1, "ImportGRFSound: Sound effect {} is invalid", sound_id);
7854 return;
7855 }
7856
7857 GrfMsg(2, "ImportGRFSound: Copying sound {} ({}) from file {:x}", sound_id, file->sound_offset + sound_id, grfid);
7858
7859 *sound = *GetSound(file->sound_offset + sound_id);
7860
7861 /* Reset volume and priority, which TTDPatch doesn't copy */
7862 sound->volume = 128;
7863 sound->priority = 0;
7864 }
7865
7871 static void LoadGRFSound(size_t offs, SoundEntry *sound)
7872 {
7873 /* Set default volume and priority */
7874 sound->volume = 0x80;
7875 sound->priority = 0;
7876
7877 if (offs != SIZE_MAX) {
7878 /* Sound is present in the NewGRF. */
7879 sound->file = _cur.file;
7880 sound->file_offset = offs;
7881 sound->grf_container_ver = _cur.file->GetContainerVersion();
7882 }
7883 }
7884
7885 /* Action 0x11 */
7886 static void GRFSound(ByteReader *buf)
7887 {
7888 /* <11> <num>
7889 *
7890 * W num Number of sound files that follow */
7891
7892 uint16_t num = buf->ReadWord();
7893 if (num == 0) return;
7894
7895 SoundEntry *sound;
7896 if (_cur.grffile->sound_offset == 0) {
7897 _cur.grffile->sound_offset = GetNumSounds();
7898 _cur.grffile->num_sounds = num;
7899 sound = AllocateSound(num);
7900 } else {
7901 sound = GetSound(_cur.grffile->sound_offset);
7902 }
7903
7904 SpriteFile &file = *_cur.file;
7905 byte grf_container_version = file.GetContainerVersion();
7906 for (int i = 0; i < num; i++) {
7907 _cur.nfo_line++;
7908
7909 /* Check whether the index is in range. This might happen if multiple action 11 are present.
7910 * While this is invalid, we do not check for this. But we should prevent it from causing bigger trouble */
7911 bool invalid = i >= _cur.grffile->num_sounds;
7912
7913 size_t offs = file.GetPos();
7914
7915 uint32_t len = grf_container_version >= 2 ? file.ReadDword() : file.ReadWord();
7916 byte type = file.ReadByte();
7917
7918 if (grf_container_version >= 2 && type == 0xFD) {
7919 /* Reference to sprite section. */
7920 if (invalid) {
7921 GrfMsg(1, "GRFSound: Sound index out of range (multiple Action 11?)");
7922 file.SkipBytes(len);
7923 } else if (len != 4) {
7924 GrfMsg(1, "GRFSound: Invalid sprite section import");
7925 file.SkipBytes(len);
7926 } else {
7927 uint32_t id = file.ReadDword();
7928 if (_cur.stage == GLS_INIT) LoadGRFSound(GetGRFSpriteOffset(id), sound + i);
7929 }
7930 continue;
7931 }
7932
7933 if (type != 0xFF) {
7934 GrfMsg(1, "GRFSound: Unexpected RealSprite found, skipping");
7935 file.SkipBytes(7);
7936 SkipSpriteData(*_cur.file, type, len - 8);
7937 continue;
7938 }
7939
7940 if (invalid) {
7941 GrfMsg(1, "GRFSound: Sound index out of range (multiple Action 11?)");
7942 file.SkipBytes(len);
7943 }
7944
7945 byte action = file.ReadByte();
7946 switch (action) {
7947 case 0xFF:
7948 /* Allocate sound only in init stage. */
7949 if (_cur.stage == GLS_INIT) {
7950 if (grf_container_version >= 2) {
7951 GrfMsg(1, "GRFSound: Inline sounds are not supported for container version >= 2");
7952 } else {
7953 LoadGRFSound(offs, sound + i);
7954 }
7955 }
7956 file.SkipBytes(len - 1); // already read <action>
7957 break;
7958
7959 case 0xFE:
7960 if (_cur.stage == GLS_ACTIVATION) {
7961 /* XXX 'Action 0xFE' isn't really specified. It is only mentioned for
7962 * importing sounds, so this is probably all wrong... */
7963 if (file.ReadByte() != 0) GrfMsg(1, "GRFSound: Import type mismatch");
7964 ImportGRFSound(sound + i);
7965 } else {
7966 file.SkipBytes(len - 1); // already read <action>
7967 }
7968 break;
7969
7970 default:
7971 GrfMsg(1, "GRFSound: Unexpected Action {:x} found, skipping", action);
7972 file.SkipBytes(len - 1); // already read <action>
7973 break;
7974 }
7975 }
7976 }
7977
7978 /* Action 0x11 (SKIP) */
7979 static void SkipAct11(ByteReader *buf)
7980 {
7981 /* <11> <num>
7982 *
7983 * W num Number of sound files that follow */
7984
7985 _cur.skip_sprites = buf->ReadWord();
7986
7987 GrfMsg(3, "SkipAct11: Skipping {} sprites", _cur.skip_sprites);
7988 }
7989
7991 static void LoadFontGlyph(ByteReader *buf)
7992 {
7993 /* <12> <num_def> <font_size> <num_char> <base_char>
7994 *
7995 * B num_def Number of definitions
7996 * B font_size Size of font (0 = normal, 1 = small, 2 = large, 3 = mono)
7997 * B num_char Number of consecutive glyphs
7998 * W base_char First character index */
7999
8000 uint8_t num_def = buf->ReadByte();
8001
8002 for (uint i = 0; i < num_def; i++) {
8003 FontSize size = (FontSize)buf->ReadByte();
8004 uint8_t num_char = buf->ReadByte();
8005 uint16_t base_char = buf->ReadWord();
8006
8007 if (size >= FS_END) {
8008 GrfMsg(1, "LoadFontGlyph: Size {} is not supported, ignoring", size);
8009 }
8010
8011 GrfMsg(7, "LoadFontGlyph: Loading {} glyph(s) at 0x{:04X} for size {}", num_char, base_char, size);
8012
8013 for (uint c = 0; c < num_char; c++) {
8014 if (size < FS_END) SetUnicodeGlyph(size, base_char + c, _cur.spriteid);
8015 _cur.nfo_line++;
8016 LoadNextSprite(_cur.spriteid++, *_cur.file, _cur.nfo_line);
8017 }
8018 }
8019 }
8020
8022 static void SkipAct12(ByteReader *buf)
8023 {
8024 /* <12> <num_def> <font_size> <num_char> <base_char>
8025 *
8026 * B num_def Number of definitions
8027 * B font_size Size of font (0 = normal, 1 = small, 2 = large)
8028 * B num_char Number of consecutive glyphs
8029 * W base_char First character index */
8030
8031 uint8_t num_def = buf->ReadByte();
8032
8033 for (uint i = 0; i < num_def; i++) {
8034 /* Ignore 'size' byte */
8035 buf->ReadByte();
8036
8037 /* Sum up number of characters */
8038 _cur.skip_sprites += buf->ReadByte();
8039
8040 /* Ignore 'base_char' word */
8041 buf->ReadWord();
8042 }
8043
8044 GrfMsg(3, "SkipAct12: Skipping {} sprites", _cur.skip_sprites);
8045 }
8046
8048 static void TranslateGRFStrings(ByteReader *buf)
8049 {
8050 /* <13> <grfid> <num-ent> <offset> <text...>
8051 *
8052 * 4*B grfid The GRFID of the file whose texts are to be translated
8053 * B num-ent Number of strings
8054 * W offset First text ID
8055 * S text... Zero-terminated strings */
8056
8057 uint32_t grfid = buf->ReadDWord();
8058 const GRFConfig *c = GetGRFConfig(grfid);
8059 if (c == nullptr || (c->status != GCS_INITIALISED && c->status != GCS_ACTIVATED)) {
8060 GrfMsg(7, "TranslateGRFStrings: GRFID 0x{:08X} unknown, skipping action 13", BSWAP32(grfid));
8061 return;
8062 }
8063
8064 if (c->status == GCS_INITIALISED) {
8065 /* If the file is not active but will be activated later, give an error
8066 * and disable this file. */
8067 GRFError *error = DisableGrf(STR_NEWGRF_ERROR_LOAD_AFTER);
8068
8069 error->data = GetString(STR_NEWGRF_ERROR_AFTER_TRANSLATED_FILE);
8070
8071 return;
8072 }
8073
8074 /* Since no language id is supplied for with version 7 and lower NewGRFs, this string has
8075 * to be added as a generic string, thus the language id of 0x7F. For this to work
8076 * new_scheme has to be true as well, which will also be implicitly the case for version 8
8077 * and higher. A language id of 0x7F will be overridden by a non-generic id, so this will
8078 * not change anything if a string has been provided specifically for this language. */
8079 byte language = _cur.grffile->grf_version >= 8 ? buf->ReadByte() : 0x7F;
8080 byte num_strings = buf->ReadByte();
8081 uint16_t first_id = buf->ReadWord();
8082
8083 if (!((first_id >= 0xD000 && first_id + num_strings <= 0xD400) || (first_id >= 0xD800 && first_id + num_strings <= 0xE000))) {
8084 GrfMsg(7, "TranslateGRFStrings: Attempting to set out-of-range string IDs in action 13 (first: 0x{:04X}, number: 0x{:02X})", first_id, num_strings);
8085 return;
8086 }
8087
8088 for (uint i = 0; i < num_strings && buf->HasData(); i++) {
8089 const char *string = buf->ReadString();
8090
8091 if (StrEmpty(string)) {
8092 GrfMsg(7, "TranslateGRFString: Ignoring empty string.");
8093 continue;
8094 }
8095
8096 AddGRFString(grfid, first_id + i, language, true, true, string, STR_UNDEFINED);
8097 }
8098 }
8099
8101 static bool ChangeGRFName(byte langid, const char *str)
8102 {
8103 AddGRFTextToList(_cur.grfconfig->name, langid, _cur.grfconfig->ident.grfid, false, str);
8104 return true;
8105 }
8106
8108 static bool ChangeGRFDescription(byte langid, const char *str)
8109 {
8110 AddGRFTextToList(_cur.grfconfig->info, langid, _cur.grfconfig->ident.grfid, true, str);
8111 return true;
8112 }
8113
8115 static bool ChangeGRFURL(byte langid, const char *str)
8116 {
8117 AddGRFTextToList(_cur.grfconfig->url, langid, _cur.grfconfig->ident.grfid, false, str);
8118 return true;
8119 }
8120
8122 static bool ChangeGRFNumUsedParams(size_t len, ByteReader *buf)
8123 {
8124 if (len != 1) {
8125 GrfMsg(2, "StaticGRFInfo: expected only 1 byte for 'INFO'->'NPAR' but got {}, ignoring this field", len);
8126 buf->Skip(len);
8127 } else {
8128 _cur.grfconfig->num_valid_params = std::min(buf->ReadByte(), ClampTo<uint8_t>(_cur.grfconfig->param.size()));
8129 }
8130 return true;
8131 }
8132
8134 static bool ChangeGRFPalette(size_t len, ByteReader *buf)
8135 {
8136 if (len != 1) {
8137 GrfMsg(2, "StaticGRFInfo: expected only 1 byte for 'INFO'->'PALS' but got {}, ignoring this field", len);
8138 buf->Skip(len);
8139 } else {
8140 char data = buf->ReadByte();
8141 GRFPalette pal = GRFP_GRF_UNSET;
8142 switch (data) {
8143 case '*':
8144 case 'A': pal = GRFP_GRF_ANY; break;
8145 case 'W': pal = GRFP_GRF_WINDOWS; break;
8146 case 'D': pal = GRFP_GRF_DOS; break;
8147 default:
8148 GrfMsg(2, "StaticGRFInfo: unexpected value '{:02X}' for 'INFO'->'PALS', ignoring this field", data);
8149 break;
8150 }
8151 if (pal != GRFP_GRF_UNSET) {
8152 _cur.grfconfig->palette &= ~GRFP_GRF_MASK;
8153 _cur.grfconfig->palette |= pal;
8154 }
8155 }
8156 return true;
8157 }
8158
8160 static bool ChangeGRFBlitter(size_t len, ByteReader *buf)
8161 {
8162 if (len != 1) {
8163 GrfMsg(2, "StaticGRFInfo: expected only 1 byte for 'INFO'->'BLTR' but got {}, ignoring this field", len);
8164 buf->Skip(len);
8165 } else {
8166 char data = buf->ReadByte();
8167 GRFPalette pal = GRFP_BLT_UNSET;
8168 switch (data) {
8169 case '8': pal = GRFP_BLT_UNSET; break;
8170 case '3': pal = GRFP_BLT_32BPP; break;
8171 default:
8172 GrfMsg(2, "StaticGRFInfo: unexpected value '{:02X}' for 'INFO'->'BLTR', ignoring this field", data);
8173 return true;
8174 }
8175 _cur.grfconfig->palette &= ~GRFP_BLT_MASK;
8176 _cur.grfconfig->palette |= pal;
8177 }
8178 return true;
8179 }
8180
8182 static bool ChangeGRFVersion(size_t len, ByteReader *buf)
8183 {
8184 if (len != 4) {
8185 GrfMsg(2, "StaticGRFInfo: expected 4 bytes for 'INFO'->'VRSN' but got {}, ignoring this field", len);
8186 buf->Skip(len);
8187 } else {
8188 /* Set min_loadable_version as well (default to minimal compatibility) */
8189 _cur.grfconfig->version = _cur.grfconfig->min_loadable_version = buf->ReadDWord();
8190 }
8191 return true;
8192 }
8193
8195 static bool ChangeGRFMinVersion(size_t len, ByteReader *buf)
8196 {
8197 if (len != 4) {
8198 GrfMsg(2, "StaticGRFInfo: expected 4 bytes for 'INFO'->'MINV' but got {}, ignoring this field", len);
8199 buf->Skip(len);
8200 } else {
8201 _cur.grfconfig->min_loadable_version = buf->ReadDWord();
8202 if (_cur.grfconfig->version == 0) {
8203 GrfMsg(2, "StaticGRFInfo: 'MINV' defined before 'VRSN' or 'VRSN' set to 0, ignoring this field");
8204 _cur.grfconfig->min_loadable_version = 0;
8205 }
8206 if (_cur.grfconfig->version < _cur.grfconfig->min_loadable_version) {
8207 GrfMsg(2, "StaticGRFInfo: 'MINV' defined as {}, limiting it to 'VRSN'", _cur.grfconfig->min_loadable_version);
8208 _cur.grfconfig->min_loadable_version = _cur.grfconfig->version;
8209 }
8210 }
8211 return true;
8212 }
8213
8214 static GRFParameterInfo *_cur_parameter;
8215
8217 static bool ChangeGRFParamName(byte langid, const char *str)
8218 {
8219 AddGRFTextToList(_cur_parameter->name, langid, _cur.grfconfig->ident.grfid, false, str);
8220 return true;
8221 }
8222
8224 static bool ChangeGRFParamDescription(byte langid, const char *str)
8225 {
8226 AddGRFTextToList(_cur_parameter->desc, langid, _cur.grfconfig->ident.grfid, true, str);
8227 return true;
8228 }
8229
8231 static bool ChangeGRFParamType(size_t len, ByteReader *buf)
8232 {
8233 if (len != 1) {
8234 GrfMsg(2, "StaticGRFInfo: expected 1 byte for 'INFO'->'PARA'->'TYPE' but got {}, ignoring this field", len);
8235 buf->Skip(len);
8236 } else {
8237 GRFParameterType type = (GRFParameterType)buf->ReadByte();
8238 if (type < PTYPE_END) {
8239 _cur_parameter->type = type;
8240 } else {
8241 GrfMsg(3, "StaticGRFInfo: unknown parameter type {}, ignoring this field", type);
8242 }
8243 }
8244 return true;
8245 }
8246
8248 static bool ChangeGRFParamLimits(size_t len, ByteReader *buf)
8249 {
8250 if (_cur_parameter->type != PTYPE_UINT_ENUM) {
8251 GrfMsg(2, "StaticGRFInfo: 'INFO'->'PARA'->'LIMI' is only valid for parameters with type uint/enum, ignoring this field");
8252 buf->Skip(len);
8253 } else if (len != 8) {
8254 GrfMsg(2, "StaticGRFInfo: expected 8 bytes for 'INFO'->'PARA'->'LIMI' but got {}, ignoring this field", len);
8255 buf->Skip(len);
8256 } else {
8257 uint32_t min_value = buf->ReadDWord();
8258 uint32_t max_value = buf->ReadDWord();
8259 if (min_value <= max_value) {
8260 _cur_parameter->min_value = min_value;
8261 _cur_parameter->max_value = max_value;
8262 } else {
8263 GrfMsg(2, "StaticGRFInfo: 'INFO'->'PARA'->'LIMI' values are incoherent, ignoring this field");
8264 }
8265 }
8266 return true;
8267 }
8268
8270 static bool ChangeGRFParamMask(size_t len, ByteReader *buf)
8271 {
8272 if (len < 1 || len > 3) {
8273 GrfMsg(2, "StaticGRFInfo: expected 1 to 3 bytes for 'INFO'->'PARA'->'MASK' but got {}, ignoring this field", len);
8274 buf->Skip(len);
8275 } else {
8276 byte param_nr = buf->ReadByte();
8277 if (param_nr >= _cur.grfconfig->param.size()) {
8278 GrfMsg(2, "StaticGRFInfo: invalid parameter number in 'INFO'->'PARA'->'MASK', param {}, ignoring this field", param_nr);
8279 buf->Skip(len - 1);
8280 } else {
8281 _cur_parameter->param_nr = param_nr;
8282 if (len >= 2) _cur_parameter->first_bit = std::min<byte>(buf->ReadByte(), 31);
8283 if (len >= 3) _cur_parameter->num_bit = std::min<byte>(buf->ReadByte(), 32 - _cur_parameter->first_bit);
8284 }
8285 }
8286
8287 return true;
8288 }
8289
8291 static bool ChangeGRFParamDefault(size_t len, ByteReader *buf)
8292 {
8293 if (len != 4) {
8294 GrfMsg(2, "StaticGRFInfo: expected 4 bytes for 'INFO'->'PARA'->'DEFA' but got {}, ignoring this field", len);
8295 buf->Skip(len);
8296 } else {
8297 _cur_parameter->def_value = buf->ReadDWord();
8298 }
8299 _cur.grfconfig->has_param_defaults = true;
8300 return true;
8301 }
8302
8303 typedef bool (*DataHandler)(size_t, ByteReader *);
8304 typedef bool (*TextHandler)(byte, const char *str);
8305 typedef bool (*BranchHandler)(ByteReader *);
8306
8314 struct AllowedSubtags {
8316 AllowedSubtags() :
8317 id(0),
8318 type(0)
8319 {}
8320
8326 AllowedSubtags(uint32_t id, DataHandler handler) :
8327 id(id),
8328 type('B')
8329 {
8330 this->handler.data = handler;
8331 }
8332
8338 AllowedSubtags(uint32_t id, TextHandler handler) :
8339 id(id),
8340 type('T')
8341 {
8342 this->handler.text = handler;
8343 }
8344
8350 AllowedSubtags(uint32_t id, BranchHandler handler) :
8351 id(id),
8352 type('C')
8353 {
8354 this->handler.call_handler = true;
8355 this->handler.u.branch = handler;
8356 }
8357
8363 AllowedSubtags(uint32_t id, AllowedSubtags *subtags) :
8364 id(id),
8365 type('C')
8366 {
8367 this->handler.call_handler = false;
8368 this->handler.u.subtags = subtags;
8369 }
8370
8371 uint32_t id;
8372 byte type;
8373 union {
8374 DataHandler data;
8375 TextHandler text;
8376 struct {
8377 union {
8378 BranchHandler branch;
8379 AllowedSubtags *subtags;
8380 } u;
8381 bool call_handler;
8382 };
8383 } handler;
8384 };
8385
8386 static bool SkipUnknownInfo(ByteReader *buf, byte type);
8387 static bool HandleNodes(ByteReader *buf, AllowedSubtags *tags);
8388
8395 static bool ChangeGRFParamValueNames(ByteReader *buf)
8396 {
8397 byte type = buf->ReadByte();
8398 while (type != 0) {
8399 uint32_t id = buf->ReadDWord();
8400 if (type != 'T' || id > _cur_parameter->max_value) {
8401 GrfMsg(2, "StaticGRFInfo: all child nodes of 'INFO'->'PARA'->param_num->'VALU' should have type 't' and the value/bit number as id");
8402 if (!SkipUnknownInfo(buf, type)) return false;
8403 type = buf->ReadByte();
8404 continue;
8405 }
8406
8407 byte langid = buf->ReadByte();
8408 const char *name_string = buf->ReadString();
8409
8410 auto val_name = _cur_parameter->value_names.find(id);
8411 if (val_name != _cur_parameter->value_names.end()) {
8412 AddGRFTextToList(val_name->second, langid, _cur.grfconfig->ident.grfid, false, name_string);
8413 } else {
8414 GRFTextList list;
8415 AddGRFTextToList(list, langid, _cur.grfconfig->ident.grfid, false, name_string);
8416 _cur_parameter->value_names[id] = list;
8417 }
8418
8419 type = buf->ReadByte();
8420 }
8421 return true;
8422 }
8423
8425 AllowedSubtags _tags_parameters[] = {
8426 AllowedSubtags('NAME', ChangeGRFParamName),
8427 AllowedSubtags('DESC', ChangeGRFParamDescription),
8428 AllowedSubtags('TYPE', ChangeGRFParamType),
8429 AllowedSubtags('LIMI', ChangeGRFParamLimits),
8430 AllowedSubtags('MASK', ChangeGRFParamMask),
8431 AllowedSubtags('VALU', ChangeGRFParamValueNames),
8432 AllowedSubtags('DFLT', ChangeGRFParamDefault),
8433 AllowedSubtags()
8434 };
8435
8442 static bool HandleParameterInfo(ByteReader *buf)
8443 {
8444 byte type = buf->ReadByte();
8445 while (type != 0) {
8446 uint32_t id = buf->ReadDWord();
8447 if (type != 'C' || id >= _cur.grfconfig->num_valid_params) {
8448 GrfMsg(2, "StaticGRFInfo: all child nodes of 'INFO'->'PARA' should have type 'C' and their parameter number as id");
8449 if (!SkipUnknownInfo(buf, type)) return false;
8450 type = buf->ReadByte();
8451 continue;
8452 }
8453
8454 if (id >= _cur.grfconfig->param_info.size()) {
8455 _cur.grfconfig->param_info.resize(id + 1);
8456 }
8457 if (!_cur.grfconfig->param_info[id].has_value()) {
8458 _cur.grfconfig->param_info[id] = GRFParameterInfo(id);
8459 }
8460 _cur_parameter = &_cur.grfconfig->param_info[id].value();
8461 /* Read all parameter-data and process each node. */
8462 if (!HandleNodes(buf, _tags_parameters)) return false;
8463 type = buf->ReadByte();
8464 }
8465 return true;
8466 }
8467
8469 AllowedSubtags _tags_info[] = {
8470 AllowedSubtags('NAME', ChangeGRFName),
8471 AllowedSubtags('DESC', ChangeGRFDescription),
8472 AllowedSubtags('URL_', ChangeGRFURL),
8473 AllowedSubtags('NPAR', ChangeGRFNumUsedParams),
8474 AllowedSubtags('PALS', ChangeGRFPalette),
8475 AllowedSubtags('BLTR', ChangeGRFBlitter),
8476 AllowedSubtags('VRSN', ChangeGRFVersion),
8477 AllowedSubtags('MINV', ChangeGRFMinVersion),
8478 AllowedSubtags('PARA', HandleParameterInfo),
8479 AllowedSubtags()
8480 };
8481
8483 AllowedSubtags _tags_root[] = {
8484 AllowedSubtags('INFO', _tags_info),
8485 AllowedSubtags()
8486 };
8487
8488
8495 static bool SkipUnknownInfo(ByteReader *buf, byte type)
8496 {
8497 /* type and id are already read */
8498 switch (type) {
8499 case 'C': {
8500 byte new_type = buf->ReadByte();
8501 while (new_type != 0) {
8502 buf->ReadDWord(); // skip the id
8503 if (!SkipUnknownInfo(buf, new_type)) return false;
8504 new_type = buf->ReadByte();
8505 }
8506 break;
8507 }
8508
8509 case 'T':
8510 buf->ReadByte(); // lang
8511 buf->ReadString(); // actual text
8512 break;
8513
8514 case 'B': {
8515 uint16_t size = buf->ReadWord();
8516 buf->Skip(size);
8517 break;
8518 }
8519
8520 default:
8521 return false;
8522 }
8523
8524 return true;
8525 }
8526
8535 static bool HandleNode(byte type, uint32_t id, ByteReader *buf, AllowedSubtags subtags[])
8536 {
8537 uint i = 0;
8538 AllowedSubtags *tag;
8539 while ((tag = &subtags[i++])->type != 0) {
8540 if (tag->id != BSWAP32(id) || tag->type != type) continue;
8541 switch (type) {
8542 default: NOT_REACHED();
8543
8544 case 'T': {
8545 byte langid = buf->ReadByte();
8546 return tag->handler.text(langid, buf->ReadString());
8547 }
8548
8549 case 'B': {
8550 size_t len = buf->ReadWord();
8551 if (buf->Remaining() < len) return false;
8552 return tag->handler.data(len, buf);
8553 }
8554
8555 case 'C': {
8556 if (tag->handler.call_handler) {
8557 return tag->handler.u.branch(buf);
8558 }
8559 return HandleNodes(buf, tag->handler.u.subtags);
8560 }
8561 }
8562 }
8563 GrfMsg(2, "StaticGRFInfo: unknown type/id combination found, type={:c}, id={:x}", type, id);
8564 return SkipUnknownInfo(buf, type);
8565 }
8566
8573 static bool HandleNodes(ByteReader *buf, AllowedSubtags subtags[])
8574 {
8575 byte type = buf->ReadByte();
8576 while (type != 0) {
8577 uint32_t id = buf->ReadDWord();
8578 if (!HandleNode(type, id, buf, subtags)) return false;
8579 type = buf->ReadByte();
8580 }
8581 return true;
8582 }
8583
8588 static void StaticGRFInfo(ByteReader *buf)
8589 {
8590 /* <14> <type> <id> <text/data...> */
8591 HandleNodes(buf, _tags_root);
8592 }
8593
8598 static void GRFUnsafe(ByteReader *)
8599 {
8600 SetBit(_cur.grfconfig->flags, GCF_UNSAFE);
8601
8602 /* Skip remainder of GRF */
8603 _cur.skip_sprites = -1;
8604 }
8605
8606
8608 static void InitializeGRFSpecial()
8609 {
8610 _ttdpatch_flags[0] = ((_settings_game.station.never_expire_airports ? 1U : 0U) << 0x0C) // keepsmallairport
8611 | (1U << 0x0D) // newairports
8612 | (1U << 0x0E) // largestations
8613 | ((_settings_game.construction.max_bridge_length > 16 ? 1U : 0U) << 0x0F) // longbridges
8614 | (0U << 0x10) // loadtime
8615 | (1U << 0x12) // presignals
8616 | (1U << 0x13) // extpresignals
8617 | ((_settings_game.vehicle.never_expire_vehicles ? 1U : 0U) << 0x16) // enginespersist
8618 | (1U << 0x1B) // multihead
8619 | (1U << 0x1D) // lowmemory
8620 | (1U << 0x1E); // generalfixes
8621
8622 _ttdpatch_flags[1] = ((_settings_game.economy.station_noise_level ? 1U : 0U) << 0x07) // moreairports - based on units of noise
8623 | (1U << 0x08) // mammothtrains
8624 | (1U << 0x09) // trainrefit
8625 | (0U << 0x0B) // subsidiaries
8626 | ((_settings_game.order.gradual_loading ? 1U : 0U) << 0x0C) // gradualloading
8627 | (1U << 0x12) // unifiedmaglevmode - set bit 0 mode. Not revelant to OTTD
8628 | (1U << 0x13) // unifiedmaglevmode - set bit 1 mode
8629 | (1U << 0x14) // bridgespeedlimits
8630 | (1U << 0x16) // eternalgame
8631 | (1U << 0x17) // newtrains
8632 | (1U << 0x18) // newrvs
8633 | (1U << 0x19) // newships
8634 | (1U << 0x1A) // newplanes
8635 | ((_settings_game.construction.train_signal_side == 1 ? 1U : 0U) << 0x1B) // signalsontrafficside
8636 | ((_settings_game.vehicle.disable_elrails ? 0U : 1U) << 0x1C); // electrifiedrailway
8637
8638 _ttdpatch_flags[2] = (1U << 0x01) // loadallgraphics - obsolote
8639 | (1U << 0x03) // semaphores
8640 | (1U << 0x0A) // newobjects
8641 | (0U << 0x0B) // enhancedgui
8642 | (0U << 0x0C) // newagerating
8643 | ((_settings_game.construction.build_on_slopes ? 1U : 0U) << 0x0D) // buildonslopes
8644 | (1U << 0x0E) // fullloadany
8645 | (1U << 0x0F) // planespeed
8646 | (0U << 0x10) // moreindustriesperclimate - obsolete
8647 | (0U << 0x11) // moretoylandfeatures
8648 | (1U << 0x12) // newstations
8649 | (1U << 0x13) // tracktypecostdiff
8650 | (1U << 0x14) // manualconvert
8651 | ((_settings_game.construction.build_on_slopes ? 1U : 0U) << 0x15) // buildoncoasts
8652 | (1U << 0x16) // canals
8653 | (1U << 0x17) // newstartyear
8654 | ((_settings_game.vehicle.freight_trains > 1 ? 1U : 0U) << 0x18) // freighttrains
8655 | (1U << 0x19) // newhouses
8656 | (1U << 0x1A) // newbridges
8657 | (1U << 0x1B) // newtownnames
8658 | (1U << 0x1C) // moreanimation
8659 | ((_settings_game.vehicle.wagon_speed_limits ? 1U : 0U) << 0x1D) // wagonspeedlimits
8660 | (1U << 0x1E) // newshistory
8661 | (0U << 0x1F); // custombridgeheads
8662
8663 _ttdpatch_flags[3] = (0U << 0x00) // newcargodistribution
8664 | (1U << 0x01) // windowsnap
8665 | ((_settings_game.economy.allow_town_roads || _generating_world ? 0U : 1U) << 0x02) // townbuildnoroad
8666 | (1U << 0x03) // pathbasedsignalling
8667 | (0U << 0x04) // aichoosechance
8668 | (1U << 0x05) // resolutionwidth
8669 | (1U << 0x06) // resolutionheight
8670 | (1U << 0x07) // newindustries
8671 | ((_settings_game.order.improved_load ? 1U : 0U) << 0x08) // fifoloading
8672 | (0U << 0x09) // townroadbranchprob
8673 | (0U << 0x0A) // tempsnowline
8674 | (1U << 0x0B) // newcargo
8675 | (1U << 0x0C) // enhancemultiplayer
8676 | (1U << 0x0D) // onewayroads
8677 | (1U << 0x0E) // irregularstations
8678 | (1U << 0x0F) // statistics
8679 | (1U << 0x10) // newsounds
8680 | (1U << 0x11) // autoreplace
8681 | (1U << 0x12) // autoslope
8682 | (0U << 0x13) // followvehicle
8683 | (1U << 0x14) // trams
8684 | (0U << 0x15) // enhancetunnels
8685 | (1U << 0x16) // shortrvs
8686 | (1U << 0x17) // articulatedrvs
8687 | ((_settings_game.vehicle.dynamic_engines ? 1U : 0U) << 0x18) // dynamic engines
8688 | (1U << 0x1E) // variablerunningcosts
8689 | (1U << 0x1F); // any switch is on
8690
8691 _ttdpatch_flags[4] = (1U << 0x00) // larger persistent storage
8692 | ((_settings_game.economy.inflation ? 1U : 0U) << 0x01) // inflation is on
8693 | (1U << 0x02); // extended string range
8694 }
8695
8697 static void ResetCustomStations()
8698 {
8699 for (GRFFile * const file : _grf_files) {
8700 file->stations.clear();
8701 }
8702 }
8703
8705 static void ResetCustomHouses()
8706 {
8707 for (GRFFile * const file : _grf_files) {
8708 file->housespec.clear();
8709 }
8710 }
8711
8713 static void ResetCustomAirports()
8714 {
8715 for (GRFFile * const file : _grf_files) {
8716 for (auto &as : file->airportspec) {
8717 if (as != nullptr) {
8718 /* We need to remove the tiles layouts */
8719 for (int j = 0; j < as->num_table; j++) {
8720 /* remove the individual layouts */
8721 free(as->table[j]);
8722 }
8723 free(as->table);
8724 free(as->depot_table);
8725 free(as->rotation);
8726 }
8727 }
8728 file->airportspec.clear();
8729 file->airtspec.clear();
8730 }
8731 }
8732
8734 static void ResetCustomIndustries()
8735 {
8736 for (GRFFile * const file : _grf_files) {
8737 file->industryspec.clear();
8738 file->indtspec.clear();
8739 }
8740 }
8741
8743 static void ResetCustomObjects()
8744 {
8745 for (GRFFile * const file : _grf_files) {
8746 file->objectspec.clear();
8747 }
8748 }
8749
8750 static void ResetCustomRoadStops()
8751 {
8752 for (auto file : _grf_files) {
8753 file->roadstops.clear();
8754 }
8755 }
8756
8758 static void ResetNewGRF()
8759 {
8760 for (GRFFile * const file : _grf_files) {
8761 delete file;
8762 }
8763
8764 _grf_files.clear();
8765 _cur.grffile = nullptr;
8766 }
8767
8769 static void ResetNewGRFErrors()
8770 {
8771 for (GRFConfig *c = _grfconfig; c != nullptr; c = c->next) {
8772 c->error.reset();
8773 }
8774 }
8775
8779 void ResetNewGRFData()
8780 {
8781 CleanUpStrings();
8782 CleanUpGRFTownNames();
8783
8784 /* Copy/reset original engine info data */
8785 SetupEngines();
8786
8787 /* Copy/reset original bridge info data */
8788 ResetBridges();
8789
8790 /* Reset rail type information */
8791 ResetRailTypes();
8792
8793 /* Copy/reset original road type info data */
8794 ResetRoadTypes();
8795
8796 /* Allocate temporary refit/cargo class data */
8797 _gted.resize(Engine::GetPoolSize());
8798
8799 /* Fill rail type label temporary data for default trains */
8800 for (const Engine *e : Engine::IterateType(VEH_TRAIN)) {
8801 _gted[e->index].railtypelabel = GetRailTypeInfo(e->u.rail.railtype)->label;
8802 }
8803
8804 /* Reset GRM reservations */
8805 memset(&_grm_engines, 0, sizeof(_grm_engines));
8806 memset(&_grm_cargoes, 0, sizeof(_grm_cargoes));
8807
8808 /* Reset generic feature callback lists */
8809 ResetGenericCallbacks();
8810
8811 /* Reset price base data */
8812 ResetPriceBaseMultipliers();
8813
8814 /* Reset the curencies array */
8815 ResetCurrencies();
8816
8817 /* Reset the house array */
8818 ResetCustomHouses();
8819 ResetHouses();
8820
8821 /* Reset the industries structures*/
8822 ResetCustomIndustries();
8823 ResetIndustries();
8824
8825 /* Reset the objects. */
8826 ObjectClass::Reset();
8827 ResetCustomObjects();
8828 ResetObjects();
8829
8830 /* Reset station classes */
8831 StationClass::Reset();
8832 ResetCustomStations();
8833
8834 /* Reset airport-related structures */
8835 AirportClass::Reset();
8836 ResetCustomAirports();
8837 AirportSpec::ResetAirports();
8838 AirportTileSpec::ResetAirportTiles();
8839
8840 /* Reset road stop classes */
8841 RoadStopClass::Reset();
8842 ResetCustomRoadStops();
8843
8844 /* Reset canal sprite groups and flags */
8845 memset(_water_feature, 0, sizeof(_water_feature));
8846
8847 /* Reset the snowline table. */
8848 ClearSnowLine();
8849
8850 /* Reset NewGRF files */
8851 ResetNewGRF();
8852
8853 /* Reset NewGRF errors. */
8854 ResetNewGRFErrors();
8855
8856 /* Set up the default cargo types */
8857 SetupCargoForClimate(_settings_game.game_creation.landscape);
8858
8859 /* Reset misc GRF features and train list display variables */
8860 _misc_grf_features = 0;
8861
8862 _loaded_newgrf_features.has_2CC = false;
8863 _loaded_newgrf_features.used_liveries = 1 << LS_DEFAULT;
8864 _loaded_newgrf_features.shore = SHORE_REPLACE_NONE;
8865 _loaded_newgrf_features.tram = TRAMWAY_REPLACE_DEPOT_NONE;
8866
8867 /* Clear all GRF overrides */
8868 _grf_id_overrides.clear();
8869
8870 InitializeSoundPool();
8871 _spritegroup_pool.CleanPool();
8872 }
8873
8877 void ResetPersistentNewGRFData()
8878 {
8879 /* Reset override managers */
8880 _engine_mngr.ResetToDefaultMapping();
8881 _house_mngr.ResetMapping();
8882 _industry_mngr.ResetMapping();
8883 _industile_mngr.ResetMapping();
8884 _airport_mngr.ResetMapping();
8885 _airporttile_mngr.ResetMapping();
8886 }
8887
8892 static void BuildCargoTranslationMap()
8893 {
8894 _cur.grffile->cargo_map.fill(UINT8_MAX);
8895
8896 for (const CargoSpec *cs : CargoSpec::Iterate()) {
8897 if (!cs->IsValid()) continue;
8898
8899 if (_cur.grffile->cargo_list.empty()) {
8900 /* Default translation table, so just a straight mapping to bitnum */
8901 _cur.grffile->cargo_map[cs->Index()] = cs->bitnum;
8902 } else {
8903 /* Check the translation table for this cargo's label */
8904 int idx = find_index(_cur.grffile->cargo_list, {cs->label});
8905 if (idx >= 0) _cur.grffile->cargo_map[cs->Index()] = idx;
8906 }
8907 }
8908 }
8909
8914 static void InitNewGRFFile(const GRFConfig *config)
8915 {
8916 GRFFile *newfile = GetFileByFilename(config->filename);
8917 if (newfile != nullptr) {
8918 /* We already loaded it once. */
8919 _cur.grffile = newfile;
8920 return;
8921 }
8922
8923 newfile = new GRFFile(config);
8924 _grf_files.push_back(_cur.grffile = newfile);
8925 }
8926
8931 GRFFile::GRFFile(const GRFConfig *config)
8932 {
8933 this->filename = config->filename;
8934 this->grfid = config->ident.grfid;
8935
8936 /* Initialise local settings to defaults */
8937 this->traininfo_vehicle_pitch = 0;
8938 this->traininfo_vehicle_width = TRAININFO_DEFAULT_VEHICLE_WIDTH;
8939
8940 /* Mark price_base_multipliers as 'not set' */
8941 for (Price i = PR_BEGIN; i < PR_END; i++) {
8942 this->price_base_multipliers[i] = INVALID_PRICE_MODIFIER;
8943 }
8944
8945 /* Initialise rail type map with default rail types */
8946 std::fill(std::begin(this->railtype_map), std::end(this->railtype_map), INVALID_RAILTYPE);
8947 this->railtype_map[0] = RAILTYPE_RAIL;
8948 this->railtype_map[1] = RAILTYPE_ELECTRIC;
8949 this->railtype_map[2] = RAILTYPE_MONO;
8950 this->railtype_map[3] = RAILTYPE_MAGLEV;
8951
8952 /* Initialise road type map with default road types */
8953 std::fill(std::begin(this->roadtype_map), std::end(this->roadtype_map), INVALID_ROADTYPE);
8954 this->roadtype_map[0] = ROADTYPE_ROAD;
8955
8956 /* Initialise tram type map with default tram types */
8957 std::fill(std::begin(this->tramtype_map), std::end(this->tramtype_map), INVALID_ROADTYPE);
8958 this->tramtype_map[0] = ROADTYPE_TRAM;
8959
8960 /* Copy the initial parameter list
8961 * 'Uninitialised' parameters are zeroed as that is their default value when dynamically creating them. */
8962 this->param = config->param;
8963 this->param_end = config->num_params;
8964 }
8965
8966 GRFFile::~GRFFile()
8967 {
8968 delete[] this->language_map;
8969 }
8970
8976 static CargoLabel GetActiveCargoLabel(const std::initializer_list<CargoLabel> &labels)
8977 {
8978 for (const CargoLabel &label : labels) {
8979 CargoID cid = GetCargoIDByLabel(label);
8980 if (cid != INVALID_CARGO) return label;
8981 }
8982 return CT_INVALID;
8983 }
8984
8990 static CargoLabel GetActiveCargoLabel(const std::variant<CargoLabel, MixedCargoType> &label)
8991 {
8992 if (std::holds_alternative<CargoLabel>(label)) return std::get<CargoLabel>(label);
8993 if (std::holds_alternative<MixedCargoType>(label)) {
8994 switch (std::get<MixedCargoType>(label)) {
8995 case MCT_LIVESTOCK_FRUIT: return GetActiveCargoLabel({CT_LIVESTOCK, CT_FRUIT});
8996 case MCT_GRAIN_WHEAT_MAIZE: return GetActiveCargoLabel({CT_GRAIN, CT_WHEAT, CT_MAIZE});
8997 case MCT_VALUABLES_GOLD_DIAMONDS: return GetActiveCargoLabel({CT_VALUABLES, CT_GOLD, CT_DIAMONDS});
8998 default: NOT_REACHED();
8999 }
9000 }
9001 NOT_REACHED();
9002 }
9003
9007 static void CalculateRefitMasks()
9008 {
9009 CargoTypes original_known_cargoes = 0;
9010 for (CargoID cid = 0; cid != NUM_CARGO; ++cid) {
9011 if (IsDefaultCargo(cid)) SetBit(original_known_cargoes, cid);
9012 }
9013
9014 for (Engine *e : Engine::Iterate()) {
9015 EngineID engine = e->index;
9016 EngineInfo *ei = &e->info;
9017 bool only_defaultcargo;
9018
9019 /* Apply default cargo translation map if cargo type hasn't been set, either explicitly or by aircraft cargo handling. */
9020 if (!IsValidCargoID(e->info.cargo_type)) {
9021 e->info.cargo_type = GetCargoIDByLabel(GetActiveCargoLabel(e->info.cargo_label));
9022 }
9023
9024 /* If the NewGRF did not set any cargo properties, we apply default values. */
9025 if (_gted[engine].defaultcargo_grf == nullptr) {
9026 /* If the vehicle has any capacity, apply the default refit masks */
9027 if (e->type != VEH_TRAIN || e->u.rail.capacity != 0) {
9028 static constexpr byte T = 1 << LT_TEMPERATE;
9029 static constexpr byte A = 1 << LT_ARCTIC;
9030 static constexpr byte S = 1 << LT_TROPIC;
9031 static constexpr byte Y = 1 << LT_TOYLAND;
9032 static const struct DefaultRefitMasks {
9033 byte climate;
9034 CargoLabel cargo_label;
9035 CargoTypes cargo_allowed;
9036 CargoTypes cargo_disallowed;
9037 } _default_refit_masks[] = {
9038 {T | A | S | Y, CT_PASSENGERS, CC_PASSENGERS, 0},
9039 {T | A | S , CT_MAIL, CC_MAIL, 0},
9040 {T | A | S , CT_VALUABLES, CC_ARMOURED, CC_LIQUID},
9041 { Y, CT_MAIL, CC_MAIL | CC_ARMOURED, CC_LIQUID},
9042 {T | A , CT_COAL, CC_BULK, 0},
9043 { S , CT_COPPER_ORE, CC_BULK, 0},
9044 { Y, CT_SUGAR, CC_BULK, 0},
9045 {T | A | S , CT_OIL, CC_LIQUID, 0},
9046 { Y, CT_COLA, CC_LIQUID, 0},
9047 {T , CT_GOODS, CC_PIECE_GOODS | CC_EXPRESS, CC_LIQUID | CC_PASSENGERS},
9048 { A | S , CT_GOODS, CC_PIECE_GOODS | CC_EXPRESS, CC_LIQUID | CC_PASSENGERS | CC_REFRIGERATED},
9049 { A | S , CT_FOOD, CC_REFRIGERATED, 0},
9050 { Y, CT_CANDY, CC_PIECE_GOODS | CC_EXPRESS, CC_LIQUID | CC_PASSENGERS},
9051 };
9052
9053 if (e->type == VEH_AIRCRAFT) {
9054 /* Aircraft default to "light" cargoes */
9055 _gted[engine].cargo_allowed = CC_PASSENGERS | CC_MAIL | CC_ARMOURED | CC_EXPRESS;
9056 _gted[engine].cargo_disallowed = CC_LIQUID;
9057 } else if (e->type == VEH_SHIP) {
9058 CargoLabel label = GetActiveCargoLabel(ei->cargo_label);
9059 switch (label.base()) {
9060 case CT_PASSENGERS.base():
9061 /* Ferries */
9062 _gted[engine].cargo_allowed = CC_PASSENGERS;
9063 _gted[engine].cargo_disallowed = 0;
9064 break;
9065 case CT_OIL.base():
9066 /* Tankers */
9067 _gted[engine].cargo_allowed = CC_LIQUID;
9068 _gted[engine].cargo_disallowed = 0;
9069 break;
9070 default:
9071 /* Cargo ships */
9072 if (_settings_game.game_creation.landscape == LT_TOYLAND) {
9073 /* No tanker in toyland :( */
9074 _gted[engine].cargo_allowed = CC_MAIL | CC_ARMOURED | CC_EXPRESS | CC_BULK | CC_PIECE_GOODS | CC_LIQUID;
9075 _gted[engine].cargo_disallowed = CC_PASSENGERS;
9076 } else {
9077 _gted[engine].cargo_allowed = CC_MAIL | CC_ARMOURED | CC_EXPRESS | CC_BULK | CC_PIECE_GOODS;
9078 _gted[engine].cargo_disallowed = CC_LIQUID | CC_PASSENGERS;
9079 }
9080 break;
9081 }
9082 e->u.ship.old_refittable = true;
9083 } else if (e->type == VEH_TRAIN && e->u.rail.railveh_type != RAILVEH_WAGON) {
9084 /* Train engines default to all cargoes, so you can build single-cargo consists with fast engines.
9085 * Trains loading multiple cargoes may start stations accepting unwanted cargoes. */
9086 _gted[engine].cargo_allowed = CC_PASSENGERS | CC_MAIL | CC_ARMOURED | CC_EXPRESS | CC_BULK | CC_PIECE_GOODS | CC_LIQUID;
9087 _gted[engine].cargo_disallowed = 0;
9088 } else {
9089 /* Train wagons and road vehicles are classified by their default cargo type */
9090 CargoLabel label = GetActiveCargoLabel(ei->cargo_label);
9091 for (const auto &drm : _default_refit_masks) {
9092 if (!HasBit(drm.climate, _settings_game.game_creation.landscape)) continue;
9093 if (drm.cargo_label != label) continue;
9094
9095 _gted[engine].cargo_allowed = drm.cargo_allowed;
9096 _gted[engine].cargo_disallowed = drm.cargo_disallowed;
9097 break;
9098 }
9099
9100 /* All original cargoes have specialised vehicles, so exclude them */
9101 _gted[engine].ctt_exclude_mask = original_known_cargoes;
9102 }
9103 }
9104 _gted[engine].UpdateRefittability(_gted[engine].cargo_allowed != 0);
9105
9106 if (IsValidCargoID(ei->cargo_type)) ClrBit(_gted[engine].ctt_exclude_mask, ei->cargo_type);
9107 }
9108
9109 /* Compute refittability */
9110 {
9111 CargoTypes mask = 0;
9112 CargoTypes not_mask = 0;
9113 CargoTypes xor_mask = ei->refit_mask;
9114
9115 /* If the original masks set by the grf are zero, the vehicle shall only carry the default cargo.
9116 * Note: After applying the translations, the vehicle may end up carrying no defined cargo. It becomes unavailable in that case. */
9117 only_defaultcargo = _gted[engine].refittability != GRFTempEngineData::NONEMPTY;
9118
9119 if (_gted[engine].cargo_allowed != 0) {
9120 /* Build up the list of cargo types from the set cargo classes. */
9121 for (const CargoSpec *cs : CargoSpec::Iterate()) {
9122 if (_gted[engine].cargo_allowed & cs->classes) SetBit(mask, cs->Index());
9123 if (_gted[engine].cargo_disallowed & cs->classes) SetBit(not_mask, cs->Index());
9124 }
9125 }
9126
9127 ei->refit_mask = ((mask & ~not_mask) ^ xor_mask) & _cargo_mask;
9128
9129 /* Apply explicit refit includes/excludes. */
9130 ei->refit_mask |= _gted[engine].ctt_include_mask;
9131 ei->refit_mask &= ~_gted[engine].ctt_exclude_mask;
9132 }
9133
9134 /* Clear invalid cargoslots (from default vehicles or pre-NewCargo GRFs) */
9135 if (IsValidCargoID(ei->cargo_type) && !HasBit(_cargo_mask, ei->cargo_type)) ei->cargo_type = INVALID_CARGO;
9136
9137 /* Ensure that the vehicle is either not refittable, or that the default cargo is one of the refittable cargoes.
9138 * Note: Vehicles refittable to no cargo are handle differently to vehicle refittable to a single cargo. The latter might have subtypes. */
9139 if (!only_defaultcargo && (e->type != VEH_SHIP || e->u.ship.old_refittable) && IsValidCargoID(ei->cargo_type) && !HasBit(ei->refit_mask, ei->cargo_type)) {
9140 ei->cargo_type = INVALID_CARGO;
9141 }
9142
9143 /* Check if this engine's cargo type is valid. If not, set to the first refittable
9144 * cargo type. Finally disable the vehicle, if there is still no cargo. */
9145 if (!IsValidCargoID(ei->cargo_type) && ei->refit_mask != 0) {
9146 /* Figure out which CTT to use for the default cargo, if it is 'first refittable'. */
9147 const GRFFile *file = _gted[engine].defaultcargo_grf;
9148 if (file == nullptr) file = e->GetGRF();
9149 if (file != nullptr && file->grf_version >= 8 && !file->cargo_list.empty()) {
9150 /* Use first refittable cargo from cargo translation table */
9151 byte best_local_slot = UINT8_MAX;
9152 for (CargoID cargo_type : SetCargoBitIterator(ei->refit_mask)) {
9153 byte local_slot = file->cargo_map[cargo_type];
9154 if (local_slot < best_local_slot) {
9155 best_local_slot = local_slot;
9156 ei->cargo_type = cargo_type;
9157 }
9158 }
9159 }
9160
9161 if (!IsValidCargoID(ei->cargo_type)) {
9162 /* Use first refittable cargo slot */
9163 ei->cargo_type = (CargoID)FindFirstBit(ei->refit_mask);
9164 }
9165 }
9166 if (!IsValidCargoID(ei->cargo_type) && e->type == VEH_TRAIN && e->u.rail.railveh_type != RAILVEH_WAGON && e->u.rail.capacity == 0) {
9167 /* For train engines which do not carry cargo it does not matter if their cargo type is invalid.
9168 * Fallback to the first available instead, if the cargo type has not been changed (as indicated by
9169 * cargo_label not being CT_INVALID). */
9170 if (GetActiveCargoLabel(ei->cargo_label) != CT_INVALID) {
9171 ei->cargo_type = static_cast<CargoID>(FindFirstBit(_standard_cargo_mask));
9172 }
9173 }
9174 if (!IsValidCargoID(ei->cargo_type)) ei->climates = 0;
9175
9176 /* Clear refit_mask for not refittable ships */
9177 if (e->type == VEH_SHIP && !e->u.ship.old_refittable) {
9178 ei->refit_mask = 0;
9179 }
9180 }
9181 }
9182
9184 static void FinaliseCanals()
9185 {
9186 for (uint i = 0; i < CF_END; i++) {
9187 if (_water_feature[i].grffile != nullptr) {
9188 _water_feature[i].callback_mask = _water_feature[i].grffile->canal_local_properties[i].callback_mask;
9189 _water_feature[i].flags = _water_feature[i].grffile->canal_local_properties[i].flags;
9190 }
9191 }
9192 }
9193
9195 static void FinaliseEngineArray()
9196 {
9197 for (Engine *e : Engine::Iterate()) {
9198 if (e->GetGRF() == nullptr) {
9199 const EngineIDMapping &eid = _engine_mngr[e->index];
9200 if (eid.grfid != INVALID_GRFID || eid.internal_id != eid.substitute_id) {
9201 e->info.string_id = STR_NEWGRF_INVALID_ENGINE;
9202 }
9203 }
9204
9205 /* Do final mapping on variant engine ID. */
9206 if (e->info.variant_id != INVALID_ENGINE) {
9207 e->info.variant_id = GetNewEngineID(e->grf_prop.grffile, e->type, e->info.variant_id);
9208 }
9209
9210 if (!HasBit(e->info.climates, _settings_game.game_creation.landscape)) continue;
9211
9212 /* Skip wagons, there livery is defined via the engine */
9213 if (e->type != VEH_TRAIN || e->u.rail.railveh_type != RAILVEH_WAGON) {
9214 LiveryScheme ls = GetEngineLiveryScheme(e->index, INVALID_ENGINE, nullptr);
9215 SetBit(_loaded_newgrf_features.used_liveries, ls);
9216 /* Note: For ships and roadvehicles we assume that they cannot be refitted between passenger and freight */
9217
9218 if (e->type == VEH_TRAIN) {
9219 SetBit(_loaded_newgrf_features.used_liveries, LS_FREIGHT_WAGON);
9220 switch (ls) {
9221 case LS_STEAM:
9222 case LS_DIESEL:
9223 case LS_ELECTRIC:
9224 case LS_MONORAIL:
9225 case LS_MAGLEV:
9226 SetBit(_loaded_newgrf_features.used_liveries, LS_PASSENGER_WAGON_STEAM + ls - LS_STEAM);
9227 break;
9228
9229 case LS_DMU:
9230 case LS_EMU:
9231 SetBit(_loaded_newgrf_features.used_liveries, LS_PASSENGER_WAGON_DIESEL + ls - LS_DMU);
9232 break;
9233
9234 default: NOT_REACHED();
9235 }
9236 }
9237 }
9238 }
9239
9240 /* Check engine variants don't point back on themselves (either directly or via a loop) then set appropriate flags
9241 * on variant engine. This is performed separately as all variant engines need to have been resolved. */
9242 for (Engine *e : Engine::Iterate()) {
9243 EngineID parent = e->info.variant_id;
9244 while (parent != INVALID_ENGINE) {
9245 parent = Engine::Get(parent)->info.variant_id;
9246 if (parent != e->index) continue;
9247
9248 /* Engine looped back on itself, so clear the variant. */
9249 e->info.variant_id = INVALID_ENGINE;
9250
9251 GrfMsg(1, "FinaliseEngineArray: Variant of engine {:x} in '{}' loops back on itself", _engine_mngr[e->index].internal_id, e->GetGRF()->filename);
9252 break;
9253 }
9254
9255 if (e->info.variant_id != INVALID_ENGINE) {
9256 Engine::Get(e->info.variant_id)->display_flags |= EngineDisplayFlags::HasVariants | EngineDisplayFlags::IsFolded;
9257 }
9258 }
9259 }
9260
9262 void FinaliseCargoArray()
9263 {
9264 for (CargoSpec &cs : CargoSpec::array) {
9265 if (cs.town_production_effect == INVALID_TPE) {
9266 /* Set default town production effect by cargo label. */
9267 switch (cs.label.base()) {
9268 case CT_PASSENGERS.base(): cs.town_production_effect = TPE_PASSENGERS; break;
9269 case CT_MAIL.base(): cs.town_production_effect = TPE_MAIL; break;
9270 default: cs.town_production_effect = TPE_NONE; break;
9271 }
9272 }
9273 if (!cs.IsValid()) {
9274 cs.name = cs.name_single = cs.units_volume = STR_NEWGRF_INVALID_CARGO;
9275 cs.quantifier = STR_NEWGRF_INVALID_CARGO_QUANTITY;
9276 cs.abbrev = STR_NEWGRF_INVALID_CARGO_ABBREV;
9277 }
9278 }
9279 }
9280
9292 static bool IsHouseSpecValid(HouseSpec *hs, const HouseSpec *next1, const HouseSpec *next2, const HouseSpec *next3, const std::string &filename)
9293 {
9294 if (((hs->building_flags & BUILDING_HAS_2_TILES) != 0 &&
9295 (next1 == nullptr || !next1->enabled || (next1->building_flags & BUILDING_HAS_1_TILE) != 0)) ||
9296 ((hs->building_flags & BUILDING_HAS_4_TILES) != 0 &&
9297 (next2 == nullptr || !next2->enabled || (next2->building_flags & BUILDING_HAS_1_TILE) != 0 ||
9298 next3 == nullptr || !next3->enabled || (next3->building_flags & BUILDING_HAS_1_TILE) != 0))) {
9299 hs->enabled = false;
9300 if (!filename.empty()) Debug(grf, 1, "FinaliseHouseArray: {} defines house {} as multitile, but no suitable tiles follow. Disabling house.", filename, hs->grf_prop.local_id);
9301 return false;
9302 }
9303
9304 /* Some places sum population by only counting north tiles. Other places use all tiles causing desyncs.
9305 * As the newgrf specs define population to be zero for non-north tiles, we just disable the offending house.
9306 * If you want to allow non-zero populations somewhen, make sure to sum the population of all tiles in all places. */
9307 if (((hs->building_flags & BUILDING_HAS_2_TILES) != 0 && next1->population != 0) ||
9308 ((hs->building_flags & BUILDING_HAS_4_TILES) != 0 && (next2->population != 0 || next3->population != 0))) {
9309 hs->enabled = false;
9310 if (!filename.empty()) Debug(grf, 1, "FinaliseHouseArray: {} defines multitile house {} with non-zero population on additional tiles. Disabling house.", filename, hs->grf_prop.local_id);
9311 return false;
9312 }
9313
9314 /* Substitute type is also used for override, and having an override with a different size causes crashes.
9315 * This check should only be done for NewGRF houses because grf_prop.subst_id is not set for original houses.*/
9316 if (!filename.empty() && (hs->building_flags & BUILDING_HAS_1_TILE) != (HouseSpec::Get(hs->grf_prop.subst_id)->building_flags & BUILDING_HAS_1_TILE)) {
9317 hs->enabled = false;
9318 Debug(grf, 1, "FinaliseHouseArray: {} defines house {} with different house size then it's substitute type. Disabling house.", filename, hs->grf_prop.local_id);
9319 return false;
9320 }
9321
9322 /* Make sure that additional parts of multitile houses are not available. */
9323 if ((hs->building_flags & BUILDING_HAS_1_TILE) == 0 && (hs->building_availability & HZ_ZONALL) != 0 && (hs->building_availability & HZ_CLIMALL) != 0) {
9324 hs->enabled = false;
9325 if (!filename.empty()) Debug(grf, 1, "FinaliseHouseArray: {} defines house {} without a size but marked it as available. Disabling house.", filename, hs->grf_prop.local_id);
9326 return false;
9327 }
9328
9329 return true;
9330 }
9331
9338 static void EnsureEarlyHouse(HouseZones bitmask)
9339 {
9340 TimerGameCalendar::Year min_year = CalendarTime::MAX_YEAR;
9341
9342 for (int i = 0; i < NUM_HOUSES; i++) {
9343 HouseSpec *hs = HouseSpec::Get(i);
9344 if (hs == nullptr || !hs->enabled) continue;
9345 if ((hs->building_availability & bitmask) != bitmask) continue;
9346 if (hs->min_year < min_year) min_year = hs->min_year;
9347 }
9348
9349 if (min_year == 0) return;
9350
9351 for (int i = 0; i < NUM_HOUSES; i++) {
9352 HouseSpec *hs = HouseSpec::Get(i);
9353 if (hs == nullptr || !hs->enabled) continue;
9354 if ((hs->building_availability & bitmask) != bitmask) continue;
9355 if (hs->min_year == min_year) hs->min_year = 0;
9356 }
9357 }
9358
9365 static void FinaliseHouseArray()
9366 {
9367 /* If there are no houses with start dates before 1930, then all houses
9368 * with start dates of 1930 have them reset to 0. This is in order to be
9369 * compatible with TTDPatch, where if no houses have start dates before
9370 * 1930 and the date is before 1930, the game pretends that this is 1930.
9371 * If there have been any houses defined with start dates before 1930 then
9372 * the dates are left alone.
9373 * On the other hand, why 1930? Just 'fix' the houses with the lowest
9374 * minimum introduction date to 0.
9375 */
9376 for (GRFFile * const file : _grf_files) {
9377 if (file->housespec.empty()) continue;
9378
9379 size_t num_houses = file->housespec.size();
9380 for (size_t i = 0; i < num_houses; i++) {
9381 HouseSpec *hs = file->housespec[i].get();
9382
9383 if (hs == nullptr) continue;
9384
9385 const HouseSpec *next1 = (i + 1 < num_houses ? file->housespec[i + 1].get() : nullptr);
9386 const HouseSpec *next2 = (i + 2 < num_houses ? file->housespec[i + 2].get() : nullptr);
9387 const HouseSpec *next3 = (i + 3 < num_houses ? file->housespec[i + 3].get() : nullptr);
9388
9389 if (!IsHouseSpecValid(hs, next1, next2, next3, file->filename)) continue;
9390
9391 _house_mngr.SetEntitySpec(hs);
9392 }
9393 }
9394
9395 for (size_t i = 0; i < NUM_HOUSES; i++) {
9396 HouseSpec *hs = HouseSpec::Get(i);
9397 const HouseSpec *next1 = (i + 1 < NUM_HOUSES ? HouseSpec::Get(i + 1) : nullptr);
9398 const HouseSpec *next2 = (i + 2 < NUM_HOUSES ? HouseSpec::Get(i + 2) : nullptr);
9399 const HouseSpec *next3 = (i + 3 < NUM_HOUSES ? HouseSpec::Get(i + 3) : nullptr);
9400
9401 /* We need to check all houses again to we are sure that multitile houses
9402 * did get consecutive IDs and none of the parts are missing. */
9403 if (!IsHouseSpecValid(hs, next1, next2, next3, std::string{})) {
9404 /* GetHouseNorthPart checks 3 houses that are directly before
9405 * it in the house pool. If any of those houses have multi-tile
9406 * flags set it assumes it's part of a multitile house. Since
9407 * we can have invalid houses in the pool marked as disabled, we
9408 * don't want to have them influencing valid tiles. As such set
9409 * building_flags to zero here to make sure any house following
9410 * this one in the pool is properly handled as 1x1 house. */
9411 hs->building_flags = TILE_NO_FLAG;
9412 }
9413
9414 /* Apply default cargo translation map for unset cargo slots */
9415 for (uint i = 0; i < lengthof(hs->accepts_cargo); ++i) {
9416 if (!IsValidCargoID(hs->accepts_cargo[i])) hs->accepts_cargo[i] = GetCargoIDByLabel(hs->accepts_cargo_label[i]);
9417 /* Disable acceptance if cargo type is invalid. */
9418 if (!IsValidCargoID(hs->accepts_cargo[i])) hs->cargo_acceptance[i] = 0;
9419 }
9420 }
9421
9422 HouseZones climate_mask = (HouseZones)(1 << (_settings_game.game_creation.landscape + 12));
9423 EnsureEarlyHouse(HZ_ZON1 | climate_mask);
9424 EnsureEarlyHouse(HZ_ZON2 | climate_mask);
9425 EnsureEarlyHouse(HZ_ZON3 | climate_mask);
9426 EnsureEarlyHouse(HZ_ZON4 | climate_mask);
9427 EnsureEarlyHouse(HZ_ZON5 | climate_mask);
9428
9429 if (_settings_game.game_creation.landscape == LT_ARCTIC) {
9430 EnsureEarlyHouse(HZ_ZON1 | HZ_SUBARTC_ABOVE);
9431 EnsureEarlyHouse(HZ_ZON2 | HZ_SUBARTC_ABOVE);
9432 EnsureEarlyHouse(HZ_ZON3 | HZ_SUBARTC_ABOVE);
9433 EnsureEarlyHouse(HZ_ZON4 | HZ_SUBARTC_ABOVE);
9434 EnsureEarlyHouse(HZ_ZON5 | HZ_SUBARTC_ABOVE);
9435 }
9436 }
9437
9443 static void FinaliseIndustriesArray()
9444 {
9445 for (GRFFile * const file : _grf_files) {
9446 for (const auto &indsp : file->industryspec) {
9447 if (indsp == nullptr || !indsp->enabled) continue;
9448
9449 StringID strid;
9450 /* process the conversion of text at the end, so to be sure everything will be fine
9451 * and available. Check if it does not return undefind marker, which is a very good sign of a
9452 * substitute industry who has not changed the string been examined, thus using it as such */
9453 strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->name);
9454 if (strid != STR_UNDEFINED) indsp->name = strid;
9455
9456 strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->closure_text);
9457 if (strid != STR_UNDEFINED) indsp->closure_text = strid;
9458
9459 strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->production_up_text);
9460 if (strid != STR_UNDEFINED) indsp->production_up_text = strid;
9461
9462 strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->production_down_text);
9463 if (strid != STR_UNDEFINED) indsp->production_down_text = strid;
9464
9465 strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->new_industry_text);
9466 if (strid != STR_UNDEFINED) indsp->new_industry_text = strid;
9467
9468 if (indsp->station_name != STR_NULL) {
9469 /* STR_NULL (0) can be set by grf. It has a meaning regarding assignation of the
9470 * station's name. Don't want to lose the value, therefore, do not process. */
9471 strid = GetGRFStringID(indsp->grf_prop.grffile->grfid, indsp->station_name);
9472 if (strid != STR_UNDEFINED) indsp->station_name = strid;
9473 }
9474
9475 _industry_mngr.SetEntitySpec(indsp.get());
9476 }
9477
9478 for (const auto &indtsp : file->indtspec) {
9479 if (indtsp != nullptr) {
9480 _industile_mngr.SetEntitySpec(indtsp.get());
9481 }
9482 }
9483 }
9484
9485 for (auto &indsp : _industry_specs) {
9486 if (indsp.enabled && indsp.grf_prop.grffile != nullptr) {
9487 for (auto &conflicting : indsp.conflicting) {
9488 conflicting = MapNewGRFIndustryType(conflicting, indsp.grf_prop.grffile->grfid);
9489 }
9490 }
9491 if (!indsp.enabled) {
9492 indsp.name = STR_NEWGRF_INVALID_INDUSTRYTYPE;
9493 }
9494
9495 /* Apply default cargo translation map for unset cargo slots */
9496 for (uint i = 0; i < lengthof(indsp.produced_cargo); ++i) {
9497 if (!IsValidCargoID(indsp.produced_cargo[i])) indsp.produced_cargo[i] = GetCargoIDByLabel(GetActiveCargoLabel(indsp.produced_cargo_label[i]));
9498 }
9499 for (uint i = 0; i < lengthof(indsp.accepts_cargo); ++i) {
9500 if (!IsValidCargoID(indsp.accepts_cargo[i])) indsp.accepts_cargo[i] = GetCargoIDByLabel(GetActiveCargoLabel(indsp.accepts_cargo_label[i]));
9501 }
9502 }
9503
9504 for (auto &indtsp : _industry_tile_specs) {
9505 /* Apply default cargo translation map for unset cargo slots */
9506 for (size_t i = 0; i < indtsp.accepts_cargo.size(); ++i) {
9507 if (!IsValidCargoID(indtsp.accepts_cargo[i])) indtsp.accepts_cargo[i] = GetCargoIDByLabel(GetActiveCargoLabel(indtsp.accepts_cargo_label[i]));
9508 }
9509 }
9510 }
9511
9517 static void FinaliseObjectsArray()
9518 {
9519 for (GRFFile * const file : _grf_files) {
9520 for (auto &objectspec : file->objectspec) {
9521 if (objectspec != nullptr && objectspec->grf_prop.grffile != nullptr && objectspec->IsEnabled()) {
9522 _object_mngr.SetEntitySpec(objectspec.get());
9523 }
9524 }
9525 }
9526
9527 ObjectSpec::BindToClasses();
9528 }
9529
9535 static void FinaliseAirportsArray()
9536 {
9537 for (GRFFile * const file : _grf_files) {
9538 for (auto &as : file->airportspec) {
9539 if (as != nullptr && as->enabled) {
9540 _airport_mngr.SetEntitySpec(as.get());
9541 }
9542 }
9543
9544 for (auto &ats : file->airtspec) {
9545 if (ats != nullptr && ats->enabled) {
9546 _airporttile_mngr.SetEntitySpec(ats.get());
9547 }
9548 }
9549 }
9550 }
9551
9552 /* Here we perform initial decoding of some special sprites (as are they
9553 * described at http://www.ttdpatch.net/src/newgrf.txt, but this is only a very
9554 * partial implementation yet).
9555 * XXX: We consider GRF files trusted. It would be trivial to exploit OTTD by
9556 * a crafted invalid GRF file. We should tell that to the user somehow, or
9557 * better make this more robust in the future. */
9558 static void DecodeSpecialSprite(byte *buf, uint num, GrfLoadingStage stage)
9559 {
9560 /* XXX: There is a difference between staged loading in TTDPatch and
9561 * here. In TTDPatch, for some reason actions 1 and 2 are carried out
9562 * during stage 1, whilst action 3 is carried out during stage 2 (to
9563 * "resolve" cargo IDs... wtf). This is a little problem, because cargo
9564 * IDs are valid only within a given set (action 1) block, and may be
9565 * overwritten after action 3 associates them. But overwriting happens
9566 * in an earlier stage than associating, so... We just process actions
9567 * 1 and 2 in stage 2 now, let's hope that won't get us into problems.
9568 * --pasky
9569 * We need a pre-stage to set up GOTO labels of Action 0x10 because the grf
9570 * is not in memory and scanning the file every time would be too expensive.
9571 * In other stages we skip action 0x10 since it's already dealt with. */
9572 static const SpecialSpriteHandler handlers[][GLS_END] = {
9573 /* 0x00 */ { nullptr, SafeChangeInfo, nullptr, nullptr, ReserveChangeInfo, FeatureChangeInfo, },
9574 /* 0x01 */ { SkipAct1, SkipAct1, SkipAct1, SkipAct1, SkipAct1, NewSpriteSet, },
9575 /* 0x02 */ { nullptr, nullptr, nullptr, nullptr, nullptr, NewSpriteGroup, },
9576 /* 0x03 */ { nullptr, GRFUnsafe, nullptr, nullptr, nullptr, FeatureMapSpriteGroup, },
9577 /* 0x04 */ { nullptr, nullptr, nullptr, nullptr, nullptr, FeatureNewName, },
9578 /* 0x05 */ { SkipAct5, SkipAct5, SkipAct5, SkipAct5, SkipAct5, GraphicsNew, },
9579 /* 0x06 */ { nullptr, nullptr, nullptr, CfgApply, CfgApply, CfgApply, },
9580 /* 0x07 */ { nullptr, nullptr, nullptr, nullptr, SkipIf, SkipIf, },
9581 /* 0x08 */ { ScanInfo, nullptr, nullptr, GRFInfo, GRFInfo, GRFInfo, },
9582 /* 0x09 */ { nullptr, nullptr, nullptr, SkipIf, SkipIf, SkipIf, },
9583 /* 0x0A */ { SkipActA, SkipActA, SkipActA, SkipActA, SkipActA, SpriteReplace, },
9584 /* 0x0B */ { nullptr, nullptr, nullptr, GRFLoadError, GRFLoadError, GRFLoadError, },
9585 /* 0x0C */ { nullptr, nullptr, nullptr, GRFComment, nullptr, GRFComment, },
9586 /* 0x0D */ { nullptr, SafeParamSet, nullptr, ParamSet, ParamSet, ParamSet, },
9587 /* 0x0E */ { nullptr, SafeGRFInhibit, nullptr, GRFInhibit, GRFInhibit, GRFInhibit, },
9588 /* 0x0F */ { nullptr, GRFUnsafe, nullptr, FeatureTownName, nullptr, nullptr, },
9589 /* 0x10 */ { nullptr, nullptr, DefineGotoLabel, nullptr, nullptr, nullptr, },
9590 /* 0x11 */ { SkipAct11, GRFUnsafe, SkipAct11, GRFSound, SkipAct11, GRFSound, },
9591 /* 0x12 */ { SkipAct12, SkipAct12, SkipAct12, SkipAct12, SkipAct12, LoadFontGlyph, },
9592 /* 0x13 */ { nullptr, nullptr, nullptr, nullptr, nullptr, TranslateGRFStrings, },
9593 /* 0x14 */ { StaticGRFInfo, nullptr, nullptr, nullptr, nullptr, nullptr, },
9594 };
9595
9596 GRFLocation location(_cur.grfconfig->ident.grfid, _cur.nfo_line);
9597
9598 GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.find(location);
9599 if (it == _grf_line_to_action6_sprite_override.end()) {
9600 /* No preloaded sprite to work with; read the
9601 * pseudo sprite content. */
9602 _cur.file->ReadBlock(buf, num);
9603 } else {
9604 /* Use the preloaded sprite data. */
9605 buf = _grf_line_to_action6_sprite_override[location].data();
9606 GrfMsg(7, "DecodeSpecialSprite: Using preloaded pseudo sprite data");
9607
9608 /* Skip the real (original) content of this action. */
9609 _cur.file->SeekTo(num, SEEK_CUR);
9610 }
9611
9612 ByteReader br(buf, buf + num);
9613 ByteReader *bufp = &br;
9614
9615 try {
9616 byte action = bufp->ReadByte();
9617
9618 if (action == 0xFF) {
9619 GrfMsg(2, "DecodeSpecialSprite: Unexpected data block, skipping");
9620 } else if (action == 0xFE) {
9621 GrfMsg(2, "DecodeSpecialSprite: Unexpected import block, skipping");
9622 } else if (action >= lengthof(handlers)) {
9623 GrfMsg(7, "DecodeSpecialSprite: Skipping unknown action 0x{:02X}", action);
9624 } else if (handlers[action][stage] == nullptr) {
9625 GrfMsg(7, "DecodeSpecialSprite: Skipping action 0x{:02X} in stage {}", action, stage);
9626 } else {
9627 GrfMsg(7, "DecodeSpecialSprite: Handling action 0x{:02X} in stage {}", action, stage);
9628 handlers[action][stage](bufp);
9629 }
9630 } catch (...) {
9631 GrfMsg(1, "DecodeSpecialSprite: Tried to read past end of pseudo-sprite data");
9632 DisableGrf(STR_NEWGRF_ERROR_READ_BOUNDS);
9633 }
9634 }
9635
9642 static void LoadNewGRFFileFromFile(GRFConfig *config, GrfLoadingStage stage, SpriteFile &file)
9643 {
9644 _cur.file = &file;
9645 _cur.grfconfig = config;
9646
9647 Debug(grf, 2, "LoadNewGRFFile: Reading NewGRF-file '{}'", config->filename);
9648
9649 byte grf_container_version = file.GetContainerVersion();
9650 if (grf_container_version == 0) {
9651 Debug(grf, 7, "LoadNewGRFFile: Custom .grf has invalid format");
9652 return;
9653 }
9654
9655 if (stage == GLS_INIT || stage == GLS_ACTIVATION) {
9656 /* We need the sprite offsets in the init stage for NewGRF sounds
9657 * and in the activation stage for real sprites. */
9658 ReadGRFSpriteOffsets(file);
9659 } else {
9660 /* Skip sprite section offset if present. */
9661 if (grf_container_version >= 2) file.ReadDword();
9662 }
9663
9664 if (grf_container_version >= 2) {
9665 /* Read compression value. */
9666 byte compression = file.ReadByte();
9667 if (compression != 0) {
9668 Debug(grf, 7, "LoadNewGRFFile: Unsupported compression format");
9669 return;
9670 }
9671 }
9672
9673 /* Skip the first sprite; we don't care about how many sprites this
9674 * does contain; newest TTDPatches and George's longvehicles don't
9675 * neither, apparently. */
9676 uint32_t num = grf_container_version >= 2 ? file.ReadDword() : file.ReadWord();
9677 if (num == 4 && file.ReadByte() == 0xFF) {
9678 file.ReadDword();
9679 } else {
9680 Debug(grf, 7, "LoadNewGRFFile: Custom .grf has invalid format");
9681 return;
9682 }
9683
9684 _cur.ClearDataForNextFile();
9685
9686 ReusableBuffer<byte> buf;
9687
9688 while ((num = (grf_container_version >= 2 ? file.ReadDword() : file.ReadWord())) != 0) {
9689 byte type = file.ReadByte();
9690 _cur.nfo_line++;
9691
9692 if (type == 0xFF) {
9693 if (_cur.skip_sprites == 0) {
9694 DecodeSpecialSprite(buf.Allocate(num), num, stage);
9695
9696 /* Stop all processing if we are to skip the remaining sprites */
9697 if (_cur.skip_sprites == -1) break;
9698
9699 continue;
9700 } else {
9701 file.SkipBytes(num);
9702 }
9703 } else {
9704 if (_cur.skip_sprites == 0) {
9705 GrfMsg(0, "LoadNewGRFFile: Unexpected sprite, disabling");
9706 DisableGrf(STR_NEWGRF_ERROR_UNEXPECTED_SPRITE);
9707 break;
9708 }
9709
9710 if (grf_container_version >= 2 && type == 0xFD) {
9711 /* Reference to data section. Container version >= 2 only. */
9712 file.SkipBytes(num);
9713 } else {
9714 file.SkipBytes(7);
9715 SkipSpriteData(file, type, num - 8);
9716 }
9717 }
9718
9719 if (_cur.skip_sprites > 0) _cur.skip_sprites--;
9720 }
9721 }
9722
9731 void LoadNewGRFFile(GRFConfig *config, GrfLoadingStage stage, Subdirectory subdir, bool temporary)
9732 {
9733 const std::string &filename = config->filename;
9734
9735 /* A .grf file is activated only if it was active when the game was
9736 * started. If a game is loaded, only its active .grfs will be
9737 * reactivated, unless "loadallgraphics on" is used. A .grf file is
9738 * considered active if its action 8 has been processed, i.e. its
9739 * action 8 hasn't been skipped using an action 7.
9740 *
9741 * During activation, only actions 0, 1, 2, 3, 4, 5, 7, 8, 9, 0A and 0B are
9742 * carried out. All others are ignored, because they only need to be
9743 * processed once at initialization. */
9744 if (stage != GLS_FILESCAN && stage != GLS_SAFETYSCAN && stage != GLS_LABELSCAN) {
9745 _cur.grffile = GetFileByFilename(filename);
9746 if (_cur.grffile == nullptr) UserError("File '{}' lost in cache.\n", filename);
9747 if (stage == GLS_RESERVE && config->status != GCS_INITIALISED) return;
9748 if (stage == GLS_ACTIVATION && !HasBit(config->flags, GCF_RESERVED)) return;
9749 }
9750
9751 bool needs_palette_remap = config->palette & GRFP_USE_MASK;
9752 if (temporary) {
9753 SpriteFile temporarySpriteFile(filename, subdir, needs_palette_remap);
9754 LoadNewGRFFileFromFile(config, stage, temporarySpriteFile);
9755 } else {
9756 LoadNewGRFFileFromFile(config, stage, OpenCachedSpriteFile(filename, subdir, needs_palette_remap));
9757 }
9758 }
9759
9767 static void ActivateOldShore()
9768 {
9769 /* Use default graphics, if no shore sprites were loaded.
9770 * Should not happen, as the base set's extra grf should include some. */
9771 if (_loaded_newgrf_features.shore == SHORE_REPLACE_NONE) _loaded_newgrf_features.shore = SHORE_REPLACE_ACTION_A;
9772
9773 if (_loaded_newgrf_features.shore != SHORE_REPLACE_ACTION_5) {
9774 DupSprite(SPR_ORIGINALSHORE_START + 1, SPR_SHORE_BASE + 1); // SLOPE_W
9775 DupSprite(SPR_ORIGINALSHORE_START + 2, SPR_SHORE_BASE + 2); // SLOPE_S
9776 DupSprite(SPR_ORIGINALSHORE_START + 6, SPR_SHORE_BASE + 3); // SLOPE_SW
9777 DupSprite(SPR_ORIGINALSHORE_START + 0, SPR_SHORE_BASE + 4); // SLOPE_E
9778 DupSprite(SPR_ORIGINALSHORE_START + 4, SPR_SHORE_BASE + 6); // SLOPE_SE
9779 DupSprite(SPR_ORIGINALSHORE_START + 3, SPR_SHORE_BASE + 8); // SLOPE_N
9780 DupSprite(SPR_ORIGINALSHORE_START + 7, SPR_SHORE_BASE + 9); // SLOPE_NW
9781 DupSprite(SPR_ORIGINALSHORE_START + 5, SPR_SHORE_BASE + 12); // SLOPE_NE
9782 }
9783
9784 if (_loaded_newgrf_features.shore == SHORE_REPLACE_ACTION_A) {
9785 DupSprite(SPR_FLAT_GRASS_TILE + 16, SPR_SHORE_BASE + 0); // SLOPE_STEEP_S
9786 DupSprite(SPR_FLAT_GRASS_TILE + 17, SPR_SHORE_BASE + 5); // SLOPE_STEEP_W
9787 DupSprite(SPR_FLAT_GRASS_TILE + 7, SPR_SHORE_BASE + 7); // SLOPE_WSE
9788 DupSprite(SPR_FLAT_GRASS_TILE + 15, SPR_SHORE_BASE + 10); // SLOPE_STEEP_N
9789 DupSprite(SPR_FLAT_GRASS_TILE + 11, SPR_SHORE_BASE + 11); // SLOPE_NWS
9790 DupSprite(SPR_FLAT_GRASS_TILE + 13, SPR_SHORE_BASE + 13); // SLOPE_ENW
9791 DupSprite(SPR_FLAT_GRASS_TILE + 14, SPR_SHORE_BASE + 14); // SLOPE_SEN
9792 DupSprite(SPR_FLAT_GRASS_TILE + 18, SPR_SHORE_BASE + 15); // SLOPE_STEEP_E
9793
9794 /* XXX - SLOPE_EW, SLOPE_NS are currently not used.
9795 * If they would be used somewhen, then these grass tiles will most like not look as needed */
9796 DupSprite(SPR_FLAT_GRASS_TILE + 5, SPR_SHORE_BASE + 16); // SLOPE_EW
9797 DupSprite(SPR_FLAT_GRASS_TILE + 10, SPR_SHORE_BASE + 17); // SLOPE_NS
9798 }
9799 }
9800
9804 static void ActivateOldTramDepot()
9805 {
9806 if (_loaded_newgrf_features.tram == TRAMWAY_REPLACE_DEPOT_WITH_TRACK) {
9807 DupSprite(SPR_ROAD_DEPOT + 0, SPR_TRAMWAY_DEPOT_NO_TRACK + 0); // use road depot graphics for "no tracks"
9808 DupSprite(SPR_TRAMWAY_DEPOT_WITH_TRACK + 1, SPR_TRAMWAY_DEPOT_NO_TRACK + 1);
9809 DupSprite(SPR_ROAD_DEPOT + 2, SPR_TRAMWAY_DEPOT_NO_TRACK + 2); // use road depot graphics for "no tracks"
9810 DupSprite(SPR_TRAMWAY_DEPOT_WITH_TRACK + 3, SPR_TRAMWAY_DEPOT_NO_TRACK + 3);
9811 DupSprite(SPR_TRAMWAY_DEPOT_WITH_TRACK + 4, SPR_TRAMWAY_DEPOT_NO_TRACK + 4);
9812 DupSprite(SPR_TRAMWAY_DEPOT_WITH_TRACK + 5, SPR_TRAMWAY_DEPOT_NO_TRACK + 5);
9813 }
9814 }
9815
9819 static void FinalisePriceBaseMultipliers()
9820 {
9821 extern const PriceBaseSpec _price_base_specs[];
9823 static const uint32_t override_features = (1 << GSF_TRAINS) | (1 << GSF_ROADVEHICLES) | (1 << GSF_SHIPS) | (1 << GSF_AIRCRAFT);
9824
9825 /* Evaluate grf overrides */
9826 int num_grfs = (uint)_grf_files.size();
9827 std::vector<int> grf_overrides(num_grfs, -1);
9828 for (int i = 0; i < num_grfs; i++) {
9829 GRFFile *source = _grf_files[i];
9830 uint32_t override = _grf_id_overrides[source->grfid];
9831 if (override == 0) continue;
9832
9833 GRFFile *dest = GetFileByGRFID(override);
9834 if (dest == nullptr) continue;
9835
9836 grf_overrides[i] = find_index(_grf_files, dest);
9837 assert(grf_overrides[i] >= 0);
9838 }
9839
9840 /* Override features and price base multipliers of earlier loaded grfs */
9841 for (int i = 0; i < num_grfs; i++) {
9842 if (grf_overrides[i] < 0 || grf_overrides[i] >= i) continue;
9843 GRFFile *source = _grf_files[i];
9844 GRFFile *dest = _grf_files[grf_overrides[i]];
9845
9846 uint32_t features = (source->grf_features | dest->grf_features) & override_features;
9847 source->grf_features |= features;
9848 dest->grf_features |= features;
9849
9850 for (Price p = PR_BEGIN; p < PR_END; p++) {
9851 /* No price defined -> nothing to do */
9852 if (!HasBit(features, _price_base_specs[p].grf_feature) || source->price_base_multipliers[p] == INVALID_PRICE_MODIFIER) continue;
9853 Debug(grf, 3, "'{}' overrides price base multiplier {} of '{}'", source->filename, p, dest->filename);
9854 dest->price_base_multipliers[p] = source->price_base_multipliers[p];
9855 }
9856 }
9857
9858 /* Propagate features and price base multipliers of afterwards loaded grfs, if none is present yet */
9859 for (int i = num_grfs - 1; i >= 0; i--) {
9860 if (grf_overrides[i] < 0 || grf_overrides[i] <= i) continue;
9861 GRFFile *source = _grf_files[i];
9862 GRFFile *dest = _grf_files[grf_overrides[i]];
9863
9864 uint32_t features = (source->grf_features | dest->grf_features) & override_features;
9865 source->grf_features |= features;
9866 dest->grf_features |= features;
9867
9868 for (Price p = PR_BEGIN; p < PR_END; p++) {
9869 /* Already a price defined -> nothing to do */
9870 if (!HasBit(features, _price_base_specs[p].grf_feature) || dest->price_base_multipliers[p] != INVALID_PRICE_MODIFIER) continue;
9871 Debug(grf, 3, "Price base multiplier {} from '{}' propagated to '{}'", p, source->filename, dest->filename);
9872 dest->price_base_multipliers[p] = source->price_base_multipliers[p];
9873 }
9874 }
9875
9876 /* The 'master grf' now have the correct multipliers. Assign them to the 'addon grfs' to make everything consistent. */
9877 for (int i = 0; i < num_grfs; i++) {
9878 if (grf_overrides[i] < 0) continue;
9879 GRFFile *source = _grf_files[i];
9880 GRFFile *dest = _grf_files[grf_overrides[i]];
9881
9882 uint32_t features = (source->grf_features | dest->grf_features) & override_features;
9883 source->grf_features |= features;
9884 dest->grf_features |= features;
9885
9886 for (Price p = PR_BEGIN; p < PR_END; p++) {
9887 if (!HasBit(features, _price_base_specs[p].grf_feature)) continue;
9888 if (source->price_base_multipliers[p] != dest->price_base_multipliers[p]) {
9889 Debug(grf, 3, "Price base multiplier {} from '{}' propagated to '{}'", p, dest->filename, source->filename);
9890 }
9891 source->price_base_multipliers[p] = dest->price_base_multipliers[p];
9892 }
9893 }
9894
9895 /* Apply fallback prices for grf version < 8 */
9896 for (GRFFile * const file : _grf_files) {
9897 if (file->grf_version >= 8) continue;
9898 PriceMultipliers &price_base_multipliers = file->price_base_multipliers;
9899 for (Price p = PR_BEGIN; p < PR_END; p++) {
9900 Price fallback_price = _price_base_specs[p].fallback_price;
9901 if (fallback_price != INVALID_PRICE && price_base_multipliers[p] == INVALID_PRICE_MODIFIER) {
9902 /* No price multiplier has been set.
9903 * So copy the multiplier from the fallback price, maybe a multiplier was set there. */
9904 price_base_multipliers[p] = price_base_multipliers[fallback_price];
9905 }
9906 }
9907 }
9908
9909 /* Decide local/global scope of price base multipliers */
9910 for (GRFFile * const file : _grf_files) {
9911 PriceMultipliers &price_base_multipliers = file->price_base_multipliers;
9912 for (Price p = PR_BEGIN; p < PR_END; p++) {
9913 if (price_base_multipliers[p] == INVALID_PRICE_MODIFIER) {
9914 /* No multiplier was set; set it to a neutral value */
9915 price_base_multipliers[p] = 0;
9916 } else {
9917 if (!HasBit(file->grf_features, _price_base_specs[p].grf_feature)) {
9918 /* The grf does not define any objects of the feature,
9919 * so it must be a difficulty setting. Apply it globally */
9920 Debug(grf, 3, "'{}' sets global price base multiplier {}", file->filename, p);
9921 SetPriceBaseMultiplier(p, price_base_multipliers[p]);
9922 price_base_multipliers[p] = 0;
9923 } else {
9924 Debug(grf, 3, "'{}' sets local price base multiplier {}", file->filename, p);
9925 }
9926 }
9927 }
9928 }
9929 }
9930
9931 extern void InitGRFTownGeneratorNames();
9932
9934 static void AfterLoadGRFs()
9935 {
9936 for (StringIDMapping &it : _string_to_grf_mapping) {
9937 *it.target = MapGRFStringID(it.grfid, it.source);
9938 }
9939 _string_to_grf_mapping.clear();
9940
9941 /* Clear the action 6 override sprites. */
9942 _grf_line_to_action6_sprite_override.clear();
9943
9944 /* Polish cargoes */
9945 FinaliseCargoArray();
9946
9947 /* Pre-calculate all refit masks after loading GRF files. */
9948 CalculateRefitMasks();
9949
9950 /* Polish engines */
9951 FinaliseEngineArray();
9952
9953 /* Set the actually used Canal properties */
9954 FinaliseCanals();
9955
9956 /* Add all new houses to the house array. */
9957 FinaliseHouseArray();
9958
9959 /* Add all new industries to the industry array. */
9960 FinaliseIndustriesArray();
9961
9962 /* Add all new objects to the object array. */
9963 FinaliseObjectsArray();
9964
9965 InitializeSortedCargoSpecs();
9966
9967 /* Sort the list of industry types. */
9968 SortIndustryTypes();
9969
9970 /* Create dynamic list of industry legends for smallmap_gui.cpp */
9971 BuildIndustriesLegend();
9972
9973 /* Build the routemap legend, based on the available cargos */
9974 BuildLinkStatsLegend();
9975
9976 /* Add all new airports to the airports array. */
9977 FinaliseAirportsArray();
9978 BindAirportSpecs();
9979
9980 /* Update the townname generators list */
9981 InitGRFTownGeneratorNames();
9982
9983 /* Run all queued vehicle list order changes */
9984 CommitVehicleListOrderChanges();
9985
9986 /* Load old shore sprites in new position, if they were replaced by ActionA */
9987 ActivateOldShore();
9988
9989 /* Load old tram depot sprites in new position, if no new ones are present */
9990 ActivateOldTramDepot();
9991
9992 /* Set up custom rail types */
9993 InitRailTypes();
9994 InitRoadTypes();
9995
9996 for (Engine *e : Engine::IterateType(VEH_ROAD)) {
9997 if (_gted[e->index].rv_max_speed != 0) {
9998 /* Set RV maximum speed from the mph/0.8 unit value */
9999 e->u.road.max_speed = _gted[e->index].rv_max_speed * 4;
10000 }
10001
10002 RoadTramType rtt = HasBit(e->info.misc_flags, EF_ROAD_TRAM) ? RTT_TRAM : RTT_ROAD;
10003
10004 const GRFFile *file = e->GetGRF();
10005 if (file == nullptr || _gted[e->index].roadtramtype == 0) {
10006 e->u.road.roadtype = (rtt == RTT_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD;
10007 continue;
10008 }
10009
10010 /* Remove +1 offset. */
10011 _gted[e->index].roadtramtype--;
10012
10013 const std::vector<RoadTypeLabel> *list = (rtt == RTT_TRAM) ? &file->tramtype_list : &file->roadtype_list;
10014 if (_gted[e->index].roadtramtype < list->size())
10015 {
10016 RoadTypeLabel rtl = (*list)[_gted[e->index].roadtramtype];
10017 RoadType rt = GetRoadTypeByLabel(rtl);
10018 if (rt != INVALID_ROADTYPE && GetRoadTramType(rt) == rtt) {
10019 e->u.road.roadtype = rt;
10020 continue;
10021 }
10022 }
10023
10024 /* Road type is not available, so disable this engine */
10025 e->info.climates = 0;
10026 }
10027
10028 for (Engine *e : Engine::IterateType(VEH_TRAIN)) {
10029 RailType railtype = GetRailTypeByLabel(_gted[e->index].railtypelabel);
10030 if (railtype == INVALID_RAILTYPE) {
10031 /* Rail type is not available, so disable this engine */
10032 e->info.climates = 0;
10033 } else {
10034 e->u.rail.railtype = railtype;
10035 e->u.rail.intended_railtype = railtype;
10036 }
10037 }
10038
10039 SetYearEngineAgingStops();
10040
10041 FinalisePriceBaseMultipliers();
10042
10043 /* Deallocate temporary loading data */
10044 _gted.clear();
10045 _grm_sprites.clear();
10046 }
10047
10053 void LoadNewGRF(uint load_index, uint num_baseset)
10054 {
10055 /* In case of networking we need to "sync" the start values
10056 * so all NewGRFs are loaded equally. For this we use the
10057 * start date of the game and we set the counters, etc. to
10058 * 0 so they're the same too. */
10059 TimerGameCalendar::Date date = TimerGameCalendar::date;
10060 TimerGameCalendar::Year year = TimerGameCalendar::year;
10061 TimerGameCalendar::DateFract date_fract = TimerGameCalendar::date_fract;
10062
10063 TimerGameEconomy::Date economy_date = TimerGameEconomy::date;
10064 TimerGameEconomy::Year economy_year = TimerGameEconomy::year;
10065 TimerGameEconomy::DateFract economy_date_fract = TimerGameEconomy::date_fract;
10066
10067 uint64_t tick_counter = TimerGameTick::counter;
10068 byte display_opt = _display_opt;
10069
10070 if (_networking) {
10071 TimerGameCalendar::year = _settings_game.game_creation.starting_year;
10072 TimerGameCalendar::date = TimerGameCalendar::ConvertYMDToDate(TimerGameCalendar::year, 0, 1);
10073 TimerGameCalendar::date_fract = 0;
10074
10075 TimerGameEconomy::year = _settings_game.game_creation.starting_year.base();
10076 TimerGameEconomy::date = TimerGameEconomy::ConvertYMDToDate(TimerGameEconomy::year, 0, 1);
10077 TimerGameEconomy::date_fract = 0;
10078
10079 TimerGameTick::counter = 0;
10080 _display_opt = 0;
10081 }
10082
10083 InitializeGRFSpecial();
10084
10085 ResetNewGRFData();
10086
10087 /*
10088 * Reset the status of all files, so we can 'retry' to load them.
10089 * This is needed when one for example rearranges the NewGRFs in-game
10090 * and a previously disabled NewGRF becomes usable. If it would not
10091 * be reset, the NewGRF would remain disabled even though it should
10092 * have been enabled.
10093 */
10094 for (GRFConfig *c = _grfconfig; c != nullptr; c = c->next) {
10095 if (c->status != GCS_NOT_FOUND) c->status = GCS_UNKNOWN;
10096 }
10097
10098 _cur.spriteid = load_index;
10099
10100 /* Load newgrf sprites
10101 * in each loading stage, (try to) open each file specified in the config
10102 * and load information from it. */
10103 for (GrfLoadingStage stage = GLS_LABELSCAN; stage <= GLS_ACTIVATION; stage++) {
10104 /* Set activated grfs back to will-be-activated between reservation- and activation-stage.
10105 * This ensures that action7/9 conditions 0x06 - 0x0A work correctly. */
10106 for (GRFConfig *c = _grfconfig; c != nullptr; c = c->next) {
10107 if (c->status == GCS_ACTIVATED) c->status = GCS_INITIALISED;
10108 }
10109
10110 if (stage == GLS_RESERVE) {
10111 static const uint32_t overrides[][2] = {
10112 { 0x44442202, 0x44440111 }, // UKRS addons modifies UKRS
10113 { 0x6D620402, 0x6D620401 }, // DBSetXL ECS extension modifies DBSetXL
10114 { 0x4D656f20, 0x4D656F17 }, // LV4cut modifies LV4
10115 };
10116 for (size_t i = 0; i < lengthof(overrides); i++) {
10117 SetNewGRFOverride(BSWAP32(overrides[i][0]), BSWAP32(overrides[i][1]));
10118 }
10119 }
10120
10121 uint num_grfs = 0;
10122 uint num_non_static = 0;
10123
10124 _cur.stage = stage;
10125 for (GRFConfig *c = _grfconfig; c != nullptr; c = c->next) {
10126 if (c->status == GCS_DISABLED || c->status == GCS_NOT_FOUND) continue;
10127 if (stage > GLS_INIT && HasBit(c->flags, GCF_INIT_ONLY)) continue;
10128
10129 Subdirectory subdir = num_grfs < num_baseset ? BASESET_DIR : NEWGRF_DIR;
10130 if (!FioCheckFileExists(c->filename, subdir)) {
10131 Debug(grf, 0, "NewGRF file is missing '{}'; disabling", c->filename);
10132 c->status = GCS_NOT_FOUND;
10133 continue;
10134 }
10135
10136 if (stage == GLS_LABELSCAN) InitNewGRFFile(c);
10137
10138 if (!HasBit(c->flags, GCF_STATIC) && !HasBit(c->flags, GCF_SYSTEM)) {
10139 if (num_non_static == NETWORK_MAX_GRF_COUNT) {
10140 Debug(grf, 0, "'{}' is not loaded as the maximum number of non-static GRFs has been reached", c->filename);
10141 c->status = GCS_DISABLED;
10142 c->error = {STR_NEWGRF_ERROR_MSG_FATAL, STR_NEWGRF_ERROR_TOO_MANY_NEWGRFS_LOADED};
10143 continue;
10144 }
10145 num_non_static++;
10146 }
10147
10148 num_grfs++;
10149
10150 LoadNewGRFFile(c, stage, subdir, false);
10151 if (stage == GLS_RESERVE) {
10152 SetBit(c->flags, GCF_RESERVED);
10153 } else if (stage == GLS_ACTIVATION) {
10154 ClrBit(c->flags, GCF_RESERVED);
10155 assert(GetFileByGRFID(c->ident.grfid) == _cur.grffile);
10156 ClearTemporaryNewGRFData(_cur.grffile);
10157 BuildCargoTranslationMap();
10158 Debug(sprite, 2, "LoadNewGRF: Currently {} sprites are loaded", _cur.spriteid);
10159 } else if (stage == GLS_INIT && HasBit(c->flags, GCF_INIT_ONLY)) {
10160 /* We're not going to activate this, so free whatever data we allocated */
10161 ClearTemporaryNewGRFData(_cur.grffile);
10162 }
10163 }
10164 }
10165
10166 /* Pseudo sprite processing is finished; free temporary stuff */
10167 _cur.ClearDataForNextFile();
10168
10169 /* Call any functions that should be run after GRFs have been loaded. */
10170 AfterLoadGRFs();
10171
10172 /* Now revert back to the original situation */
10173 TimerGameCalendar::year = year;
10174 TimerGameCalendar::date = date;
10175 TimerGameCalendar::date_fract = date_fract;
10176
10177 TimerGameEconomy::year = economy_year;
10178 TimerGameEconomy::date = economy_date;
10179 TimerGameEconomy::date_fract = economy_date_fract;
10180
10181 TimerGameTick::counter = tick_counter;
10182 _display_opt = display_opt;
10183 }
VEH_AIRCRAFT
@ VEH_AIRCRAFT
Aircraft vehicle type.
Definition: vehicle_type.h:27
ResetCustomHouses
static void ResetCustomHouses()
Reset and clear all NewGRF houses.
Definition: newgrf.cpp:8705
RoadTypeInfo::flags
RoadTypeFlags flags
Bit mask of road type flags.
Definition: road.h:127
ChangeGRFName
static bool ChangeGRFName(byte langid, const char *str)
Callback function for 'INFO'->'NAME' to add a translation to the newgrf name.
Definition: newgrf.cpp:8101
AllowedSubtags::call_handler
bool call_handler
True if there is a callback function for this node, false if there is a list of subnodes.
Definition: newgrf.cpp:8381
RoadTypeInfo::new_engine
StringID new_engine
Name of an engine for this type of road in the engine preview GUI.
Definition: road.h:108
StationChangeInfo
static ChangeInfoResult StationChangeInfo(uint stid, int numinfo, int prop, ByteReader *buf)
Define properties for stations.
Definition: newgrf.cpp:1910
ParamSet
static void ParamSet(ByteReader *buf)
Action 0x0D: Set parameter.
Definition: newgrf.cpp:7394
GRFLocation
Definition: newgrf.cpp:362
CalculateRefitMasks
static void CalculateRefitMasks()
Precalculate refit masks from cargo classes for all vehicles.
Definition: newgrf.cpp:9007
OBJECT_SIZE_1X1
static const uint8_t OBJECT_SIZE_1X1
The value of a NewGRF's size property when the object is 1x1 tiles: low nibble for X,...
Definition: newgrf_object.h:43
GRFP_USE_MASK
@ GRFP_USE_MASK
Bitmask to get only the use palette use states.
Definition: newgrf_config.h:68
RoadTypeInfo::toolbar_caption
StringID toolbar_caption
Caption in the construction toolbar GUI for this rail type.
Definition: road.h:104
HouseSpec::removal_cost
byte removal_cost
cost multiplier for removing it
Definition: house.h:103
_standard_cargo_mask
CargoTypes _standard_cargo_mask
Bitmask of real cargo types available.
Definition: cargotype.cpp:36
RoadStopSpec::clear_cost_multiplier
uint8_t clear_cost_multiplier
Clear cost multiplier per tile.
Definition: newgrf_roadstop.h:147
AllocateSound
SoundEntry * AllocateSound(uint num)
Allocate sound slots.
Definition: newgrf_sound.cpp:31
RailVehicleInfo::pow_wag_power
uint16_t pow_wag_power
Extra power applied to consist if wagon should be powered.
Definition: engine_type.h:56
GRFTempEngineData::UpdateRefittability
void UpdateRefittability(bool non_empty)
Update the summary refittability on setting a refittability property.
Definition: newgrf.cpp:341
RailVehicleInfo::curve_speed_mod
int16_t curve_speed_mod
Modifier to maximum speed in curves (fixed-point binary with 8 fractional bits)
Definition: engine_type.h:63
INVALID_ENGINE
static const EngineID INVALID_ENGINE
Constant denoting an invalid engine.
Definition: engine_type.h:206
Action5Type::sprite_base
SpriteID sprite_base
Load the sprites starting from this sprite.
Definition: newgrf.cpp:6404
OrderSettings::improved_load
bool improved_load
improved loading algorithm
Definition: settings_type.h:505
GRFTownName::styles
std::vector< TownNameStyle > styles
Style names defined by the Town Name NewGRF.
Definition: newgrf_townname.h:42
INVALID_AIRPORTTILE
static const uint INVALID_AIRPORTTILE
id for an invalid airport tile
Definition: airport.h:25
RoadTypeInfo
Definition: road.h:78
DuplicateTileTable
static void DuplicateTileTable(AirportSpec *as)
Create a copy of the tile table so it can be freed later without problems.
Definition: newgrf.cpp:3870
NUM_STATIONS_PER_GRF
static const uint NUM_STATIONS_PER_GRF
The maximum amount of stations a single GRF is allowed to add.
Definition: newgrf.cpp:316
PROP_TRAIN_SPEED
@ PROP_TRAIN_SPEED
Max. speed: 1 unit = 1/1.6 mph = 1 km-ish/h.
Definition: newgrf_properties.h:21
GRFConfig::info
GRFTextWrapper info
NOSAVE: GRF info (author, copyright, ...) (Action 0x08)
Definition: newgrf_config.h:158
AllowedSubtags::AllowedSubtags
AllowedSubtags()
Create empty subtags object used to identify the end of a list.
Definition: newgrf.cpp:8316
ROADTYPE_END
@ ROADTYPE_END
Used for iterations.
Definition: road_type.h:29
RAILTYPE_MAGLEV
@ RAILTYPE_MAGLEV
Maglev.
Definition: rail_type.h:32
RailTypeInfo::introduction_date
TimerGameCalendar::Date introduction_date
Introduction date.
Definition: rail.h:255
ResetCustomObjects
static void ResetCustomObjects()
Reset and clear all NewObjects.
Definition: newgrf.cpp:8743
RoadStopAvailabilityType
RoadStopAvailabilityType
Various different options for availability, restricting the roadstop to be only for busses or for tru...
Definition: newgrf_roadstop.h:46
RailVehicleInfo::pow_wag_weight
byte pow_wag_weight
Extra weight applied to consist if wagon should be powered.
Definition: engine_type.h:57
Engine::IterateType
static Pool::IterateWrapperFiltered< Engine, EngineTypeFilter > IterateType(VehicleType vt, size_t from=0)
Returns an iterable ensemble of all valid engines of the given type.
Definition: engine_base.h:186
IndustrySpec::map_colour
byte map_colour
colour used for the small map
Definition: industrytype.h:126
EngineDisplayFlags::HasVariants
@ HasVariants
Set if engine has variants.
SetBit
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
Definition: bitmath_func.hpp:121
TPE_NONE
@ TPE_NONE
Town will not produce this cargo type.
Definition: cargotype.h:35
LanguageMetadata
Make sure the size is right.
Definition: language.h:93
VE_DISABLE_EFFECT
@ VE_DISABLE_EFFECT
Flag to disable visual effect.
Definition: vehicle_base.h:91
MCT_GRAIN_WHEAT_MAIZE
@ MCT_GRAIN_WHEAT_MAIZE
Cargo can be grain, wheat or maize.
Definition: cargo_type.h:85
newgrf_station.h
SetUnicodeGlyph
void SetUnicodeGlyph(FontSize size, char32_t key, SpriteID sprite)
Map a SpriteID to the font size and key.
Definition: fontcache.h:167
newgrf_house.h
TPE_MAIL
@ TPE_MAIL
Cargo behaves mail-like for production.
Definition: cargotype.h:37
GRFFile::language_map
struct LanguageMap * language_map
Mappings related to the languages.
Definition: newgrf.h:143
GRFFile::roadtype_list
std::vector< RoadTypeLabel > roadtype_list
Roadtype translation table (road)
Definition: newgrf.h:135
Pool::PoolItem<&_engine_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:339
EngineOverrideManager::ResetToDefaultMapping
void ResetToDefaultMapping()
Initializes the EngineOverrideManager with the default engines.
Definition: engine.cpp:509
CargoSpec::label
CargoLabel label
Unique label of the cargo type.
Definition: cargotype.h:69
AircraftVehicleInfo::max_range
uint16_t max_range
Maximum range of this aircraft.
Definition: engine_type.h:110
TimerGameTick::counter
static TickCounter counter
Monotonic counter, in ticks, since start of game.
Definition: timer_game_tick.h:60
StationSpec::flags
byte flags
Bitmask of flags, bit 0: use different sprite set; bit 1: divide cargo about by station size.
Definition: newgrf_station.h:159
OBJECT_FLAG_2CC_COLOUR
@ OBJECT_FLAG_2CC_COLOUR
Object wants 2CC colour mapping.
Definition: newgrf_object.h:34
LanguageMap::case_map
std::vector< Mapping > case_map
Mapping of NewGRF and OpenTTD IDs for cases.
Definition: newgrf_text.h:67
PROP_TRAIN_CARGO_CAPACITY
@ PROP_TRAIN_CARGO_CAPACITY
Capacity (if dualheaded: for each single vehicle)
Definition: newgrf_properties.h:24
Direction
Direction
Defines the 8 directions on the map.
Definition: direction_type.h:24
GameSettings::station
StationSettings station
settings related to station management
Definition: settings_type.h:629
ResetCustomAirports
static void ResetCustomAirports()
Reset and clear all NewGRF airports.
Definition: newgrf.cpp:8713
AircraftVehicleInfo::max_speed
uint16_t max_speed
Maximum speed (1 unit = 8 mph = 12.8 km-ish/h)
Definition: engine_type.h:107
GRFTextList
std::vector< GRFText > GRFTextList
A GRF text with a list of translations.
Definition: newgrf_text.h:28
PROP_ROADVEH_TRACTIVE_EFFORT
@ PROP_ROADVEH_TRACTIVE_EFFORT
Tractive effort coefficient in 1/256.
Definition: newgrf_properties.h:39
SNOW_LINE_DAYS
static const uint SNOW_LINE_DAYS
Number of days in each month in the snow line table.
Definition: landscape.h:17
ObjectChangeInfo
static ChangeInfoResult ObjectChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
Define properties for objects.
Definition: newgrf.cpp:4120
RoadTypeInfo::menu_text
StringID menu_text
Name of this rail type in the main toolbar dropdown.
Definition: road.h:105
TimerGameConst< struct Calendar >::DAYS_TILL_ORIGINAL_BASE_YEAR
static constexpr TimerGame< struct Calendar >::Date DAYS_TILL_ORIGINAL_BASE_YEAR
The date of the first day of the original base year.
Definition: timer_game_common.h:184
GetFileByGRFID
static GRFFile * GetFileByGRFID(uint32_t grfid)
Obtain a NewGRF file by its grfID.
Definition: newgrf.cpp:403
DeterministicSpriteGroupRange
Definition: newgrf_spritegroup.h:160
GRFConfig::num_valid_params
uint8_t num_valid_params
NOSAVE: Number of valid parameters (action 0x14)
Definition: newgrf_config.h:169
StationSpec::renderdata
std::vector< NewGRFSpriteLayout > renderdata
Number of tile layouts.
Definition: newgrf_station.h:147
NUM_INDUSTRYTYPES_PER_GRF
static const IndustryType NUM_INDUSTRYTYPES_PER_GRF
maximum number of industry types per NewGRF; limited to 128 because bit 7 has a special meaning in so...
Definition: industry_type.h:23
SPR_SHORE_BASE
static const SpriteID SPR_SHORE_BASE
shore tiles - action 05-0D
Definition: sprites.h:224
IndustryProductionSpriteGroup::num_output
uint8_t num_output
How many add_output values are valid.
Definition: newgrf_spritegroup.h:275
TAE_FOOD
@ TAE_FOOD
Cargo behaves food/fizzy-drinks-like.
Definition: cargotype.h:28
TLF_DODRAW
@ TLF_DODRAW
Only draw sprite if value of register TileLayoutRegisters::dodraw is non-zero.
Definition: newgrf_commons.h:35
ReusableBuffer
A reusable buffer that can be used for places that temporary allocate a bit of memory and do that ver...
Definition: alloc_type.hpp:24
AircraftVehicleInfo::subtype
byte subtype
Type of aircraft.
Definition: engine_type.h:104
ShipVehicleChangeInfo
static ChangeInfoResult ShipVehicleChangeInfo(uint engine, int numinfo, int prop, ByteReader *buf)
Define properties for ships.
Definition: newgrf.cpp:1553
GetRoadTypeByLabel
RoadType GetRoadTypeByLabel(RoadTypeLabel label, bool allow_alternate_labels)
Get the road type for a given label.
Definition: road.cpp:254
GRFError::custom_message
std::string custom_message
Custom message (if present)
Definition: newgrf_config.h:112
PROP_ROADVEH_COST_FACTOR
@ PROP_ROADVEH_COST_FACTOR
Purchase cost.
Definition: newgrf_properties.h:35
IsInsideMM
constexpr bool IsInsideMM(const T x, const size_t min, const size_t max) noexcept
Checks if a value is in an interval.
Definition: math_func.hpp:268
GCS_ACTIVATED
@ GCS_ACTIVATED
GRF file has been activated.
Definition: newgrf_config.h:39
ObjectSpec
Allow incrementing of ObjectClassID variables.
Definition: newgrf_object.h:60
RoadStopSpec
Road stop specification.
Definition: newgrf_roadstop.h:122
TileLayoutRegisters::dodraw
uint8_t dodraw
Register deciding whether the sprite shall be drawn at all. Non-zero means drawing.
Definition: newgrf_commons.h:92
ObjectSpec::grf_prop
GRFFilePropsBase< 2 > grf_prop
Properties related the the grf file.
Definition: newgrf_object.h:62
GrfProcessingState::grffile
GRFFile * grffile
Currently processed GRF file.
Definition: newgrf.cpp:105
DrawTileSeqStruct::IsParentSprite
bool IsParentSprite() const
Check whether this is a parent sprite with a boundingbox.
Definition: sprite.h:47
BridgeSpec::flags
byte flags
bit 0 set: disable drawing of far pillars.
Definition: bridge.h:53
RoadTypeInfo::introduction_date
TimerGameCalendar::Date introduction_date
Introduction date.
Definition: road.h:166
NamePartList::maxprob
uint16_t maxprob
Total probability of all parts.
Definition: newgrf_townname.h:27
_engine_offsets
const uint8_t _engine_offsets[4]
Offset of the first engine of each vehicle type in original engine data.
Definition: engine.cpp:61
GetRailTypeInfo
const RailTypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
Definition: rail.h:307
IsValidNewGRFImageIndex
static bool IsValidNewGRFImageIndex(uint8_t image_index)
Helper to check whether an image index is valid for a particular NewGRF vehicle.
Definition: newgrf.cpp:206
ResetCustomIndustries
static void ResetCustomIndustries()
Reset and clear all NewGRF industries.
Definition: newgrf.cpp:8734
PROP_TRAIN_RUNNING_COST_FACTOR
@ PROP_TRAIN_RUNNING_COST_FACTOR
Yearly runningcost (if dualheaded: sum of both vehicles)
Definition: newgrf_properties.h:23
TimerGameCalendar::date_fract
static DateFract date_fract
Fractional part of the day.
Definition: timer_game_calendar.h:35
smallmap_gui.h
_grf_files
static std::vector< GRFFile * > _grf_files
List of all loaded GRF files.
Definition: newgrf.cpp:68
SPRITE_WIDTH
@ SPRITE_WIDTH
number of bits for the sprite number
Definition: sprites.h:1527
GameCreationSettings::landscape
byte landscape
the landscape we're currently in
Definition: settings_type.h:355
ShipVehicleInfo::canal_speed_frac
byte canal_speed_frac
Fraction of maximum speed for canal/river tiles.
Definition: engine_type.h:78
TLF_CHILD_X_OFFSET
@ TLF_CHILD_X_OFFSET
Add signed offset to child sprite X positions from register TileLayoutRegisters::delta....
Definition: newgrf_commons.h:43
RoadTypeInfo::introduces_roadtypes
RoadTypes introduces_roadtypes
Bitmask of which other roadtypes are introduced when this roadtype is introduced.
Definition: road.h:177
GRFFile::price_base_multipliers
PriceMultipliers price_base_multipliers
Price base multipliers as set by the grf.
Definition: newgrf.h:149
FeatureTownName
static void FeatureTownName(ByteReader *buf)
Action 0x0F - Define Town names.
Definition: newgrf.cpp:7744
Map::LogX
static debug_inline uint LogX()
Logarithm of the map size along the X side.
Definition: map_func.h:251
AllowedSubtags::AllowedSubtags
AllowedSubtags(uint32_t id, BranchHandler handler)
Create a branch node with a callback handler.
Definition: newgrf.cpp:8350
HouseSpec::max_year
TimerGameCalendar::Year max_year
last year it can be built
Definition: house.h:101
IndustriesChangeInfo
static ChangeInfoResult IndustriesChangeInfo(uint indid, int numinfo, int prop, ByteReader *buf)
Define properties for industries.
Definition: newgrf.cpp:3491
DeterministicSpriteGroup
Definition: newgrf_spritegroup.h:167
PROP_TRAIN_TRACTIVE_EFFORT
@ PROP_TRAIN_TRACTIVE_EFFORT
Tractive effort coefficient in 1/256.
Definition: newgrf_properties.h:27
AllowedSubtags::branch
BranchHandler branch
Callback function for a branch node, only valid if type == 'C' && call_handler.
Definition: newgrf.cpp:8378
TimerGameEconomy::ConvertYMDToDate
static Date ConvertYMDToDate(Year year, Month month, Day day)
Converts a tuple of Year, Month and Day to a Date.
Definition: timer_game_economy.cpp:66
timer_game_calendar.h
HandleNodes
static bool HandleNodes(ByteReader *buf, AllowedSubtags subtags[])
Handle the contents of a 'C' choice of an Action14.
Definition: newgrf.cpp:8573
EngineDisplayFlags::IsFolded
@ IsFolded
Set if display of variants should be folded (hidden).
HouseSpec::accepts_cargo
CargoID accepts_cargo[HOUSE_NUM_ACCEPTS]
input cargo slots
Definition: house.h:108
RoadTypeInfo::sorting_order
byte sorting_order
The sorting order of this roadtype for the toolbar dropdown.
Definition: road.h:182
BuildCargoLabelMap
void BuildCargoLabelMap()
Build cargo label map.
Definition: cargotype.cpp:93
AirportSpec::size_y
byte size_y
size of airport in y direction
Definition: newgrf_airport.h:108
NewGRFSpriteLayout::AllocateRegisters
void AllocateRegisters()
Allocate memory for register modifiers.
Definition: newgrf_commons.cpp:615
PALETTE_MODIFIER_COLOUR
@ PALETTE_MODIFIER_COLOUR
this bit is set when a recolouring process is in action
Definition: sprites.h:1542
BASESET_DIR
@ BASESET_DIR
Subdirectory for all base data (base sets, intro game)
Definition: fileio_type.h:116
currency.h
RoadStopSpec::name
StringID name
Name of this stop.
Definition: newgrf_roadstop.h:132
AnimationInfo::triggers
uint16_t triggers
The triggers that trigger animation.
Definition: newgrf_animation_type.h:22
StringID
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
NamePart::prob
byte prob
The relative probability of the following name to appear in the bottom 7 bits.
Definition: newgrf_townname.h:21
Price
Price
Enumeration of all base prices for use with Prices.
Definition: economy_type.h:89
PROP_AIRCRAFT_MAIL_CAPACITY
@ PROP_AIRCRAFT_MAIL_CAPACITY
Mail Capacity.
Definition: newgrf_properties.h:53
RailTypeInfo::new_loco
StringID new_loco
Name of an engine for this type of rail in the engine preview GUI.
Definition: rail.h:181
AirportSpec::name
StringID name
name of this airport
Definition: newgrf_airport.h:113
CC_EXPRESS
@ CC_EXPRESS
Express cargo (Goods, Food, Candy, but also possible for passengers)
Definition: cargotype.h:52
FinaliseCanals
static void FinaliseCanals()
Set to use the correct action0 properties for each canal feature.
Definition: newgrf.cpp:9184
CanalProperties::callback_mask
uint8_t callback_mask
Bitmask of canal callbacks that have to be called.
Definition: newgrf.h:40
LanguageMap::plural_form
int plural_form
The plural form used for this language.
Definition: newgrf_text.h:68
CanalProperties::flags
uint8_t flags
Flags controlling display.
Definition: newgrf.h:41
CargoLabel
StrongType::Typedef< uint32_t, struct CargoLabelTag, StrongType::Compare > CargoLabel
Globally unique label of a cargo type.
Definition: cargo_type.h:17
CurrencySpec::symbol_pos
byte symbol_pos
The currency symbol is represented by two possible values, prefix and suffix Usage of one or the othe...
Definition: currency.h:90
EC_STEAM
@ EC_STEAM
Steam rail engine.
Definition: engine_type.h:34
PriceBaseSpec::grf_feature
uint grf_feature
GRF Feature that decides whether price multipliers apply locally or globally, #GSF_END if none.
Definition: economy_type.h:210
GB
constexpr static debug_inline uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
Definition: bitmath_func.hpp:32
RandomizedSpriteGroup::cmp_mode
RandomizedSpriteGroupCompareMode cmp_mode
Check for these triggers:
Definition: newgrf_spritegroup.h:195
DeterministicSpriteGroupAdjust::parameter
byte parameter
Used for variables between 0x60 and 0x7F inclusive.
Definition: newgrf_spritegroup.h:151
VE_DEFAULT
@ VE_DEFAULT
Default value to indicate that visual effect should be based on engine class.
Definition: vehicle_base.h:95
A5BLOCK_INVALID
@ A5BLOCK_INVALID
unknown/not-implemented type
Definition: newgrf.cpp:6399
Action5BlockType
Action5BlockType
The type of action 5 type.
Definition: newgrf.cpp:6396
ChangeGRFParamLimits
static bool ChangeGRFParamLimits(size_t len, ByteReader *buf)
Callback function for 'INFO'->'PARAM'->param_num->'LIMI' to set the min/max value of a parameter.
Definition: newgrf.cpp:8248
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:238
PROP_ROADVEH_SHORTEN_FACTOR
@ PROP_ROADVEH_SHORTEN_FACTOR
Shorter vehicles.
Definition: newgrf_properties.h:41
BridgeSpec::sprite_table
PalSpriteID ** sprite_table
table of sprites for drawing the bridge
Definition: bridge.h:52
CargoSpec::Get
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo ID.
Definition: cargotype.h:131
ResetPersistentNewGRFData
void ResetPersistentNewGRFData()
Reset NewGRF data which is stored persistently in savegames.
Definition: newgrf.cpp:8877
PROP_SHIP_CARGO_CAPACITY
@ PROP_SHIP_CARGO_CAPACITY
Capacity.
Definition: newgrf_properties.h:45
ObjectSpec::generate_amount
uint8_t generate_amount
Number of objects which are attempted to be generated per 256^2 map during world generation.
Definition: newgrf_object.h:77
HouseExtraFlags
HouseExtraFlags
Definition: house.h:88
_bridge
BridgeSpec _bridge[MAX_BRIDGES]
The specification of all bridges.
Definition: tunnelbridge_cmd.cpp:52
PalSpriteID::sprite
SpriteID sprite
The 'real' sprite.
Definition: gfx_type.h:23
GrfProcessingState::ClearDataForNextFile
void ClearDataForNextFile()
Clear temporary data before processing the next file in the current loading stage.
Definition: newgrf.cpp:116
PROP_AIRCRAFT_RUNNING_COST_FACTOR
@ PROP_AIRCRAFT_RUNNING_COST_FACTOR
Yearly runningcost.
Definition: newgrf_properties.h:51
RAILTYPE_MONO
@ RAILTYPE_MONO
Monorail.
Definition: rail_type.h:31
HouseSpec::enabled
bool enabled
the house is available to build (true by default, but can be disabled by newgrf)
Definition: house.h:112
AirportSpec::noise_level
byte noise_level
noise that this airport generates
Definition: newgrf_airport.h:109
ChangeGRFVersion
static bool ChangeGRFVersion(size_t len, ByteReader *buf)
Callback function for 'INFO'->'VRSN' to the version of the NewGRF.
Definition: newgrf.cpp:8182
IndustryProductionSpriteGroup::add_output
uint16_t add_output[INDUSTRY_NUM_OUTPUTS]
Add this much output cargo when successful (unsigned, is indirect in cb version 1+)
Definition: newgrf_spritegroup.h:276
SortIndustryTypes
void SortIndustryTypes()
Initialize the list of sorted industry types.
Definition: industry_gui.cpp:234
ResetPriceBaseMultipliers
void ResetPriceBaseMultipliers()
Reset changes to the price base multipliers.
Definition: economy.cpp:886
ChangeGRFParamName
static bool ChangeGRFParamName(byte langid, const char *str)
Callback function for 'INFO'->'PARAM'->param_num->'NAME' to set the name of a parameter.
Definition: newgrf.cpp:8217
ResetRailTypes
void ResetRailTypes()
Reset all rail type information to its default values.
Definition: rail_cmd.cpp:65
GrfProcessingState::spritesets
std::map< uint, SpriteSet > spritesets[GSF_END]
Currently referenceable spritesets.
Definition: newgrf.cpp:96
StrMakeValid
static void StrMakeValid(T &dst, const char *str, const char *last, StringValidationSettings settings)
Copies the valid (UTF-8) characters from str up to last to the dst.
Definition: string.cpp:114
GrfProcessingState::spriteid
SpriteID spriteid
First available SpriteID for loading realsprites.
Definition: newgrf.cpp:101
GRFConfig::filename
std::string filename
Filename - either with or without full path.
Definition: newgrf_config.h:156
RailTypeInfo
This struct contains all the info that is needed to draw and construct tracks.
Definition: rail.h:127
VehicleSettings::wagon_speed_limits
bool wagon_speed_limits
enable wagon speed limits
Definition: settings_type.h:521
CIR_INVALID_ID
@ CIR_INVALID_ID
Attempt to modify an invalid ID.
Definition: newgrf.cpp:983
GRFParameterInfo::param_nr
byte param_nr
GRF parameter to store content in.
Definition: newgrf_config.h:135
TLF_CUSTOM_PALETTE
@ TLF_CUSTOM_PALETTE
Palette is from Action 1 (moved to SPRITE_MODIFIER_CUSTOM_SPRITE in palette during loading).
Definition: newgrf_commons.h:38
ObjectSpec::height
uint8_t height
The height of this structure, in heightlevels; max MAX_TILE_HEIGHT.
Definition: newgrf_object.h:75
RailTypeInfo::alternate_labels
RailTypeLabelList alternate_labels
Rail type labels this type provides in addition to the main label.
Definition: rail.h:241
IndustryTileSpec::acceptance
std::array< int8_t, INDUSTRY_NUM_INPUTS > acceptance
Level of acceptance per cargo type (signed, may be negative!)
Definition: industrytype.h:159
IndustryTileSpec::callback_mask
uint8_t callback_mask
Bitmask of industry tile callbacks that have to be called.
Definition: industrytype.h:169
_tags_info
AllowedSubtags _tags_info[]
Action14 tags for the INFO node.
Definition: newgrf.cpp:8469
AnimationInfo::frames
uint8_t frames
The number of frames.
Definition: newgrf_animation_type.h:19
vehicle_base.h
ConvertTTDBasePrice
static void ConvertTTDBasePrice(uint32_t base_pointer, const char *error_location, Price *index)
Converts TTD(P) Base Price pointers into the enum used by OTTD See http://wiki.ttdpatch....
Definition: newgrf.cpp:958
fileio_func.h
GCS_NOT_FOUND
@ GCS_NOT_FOUND
GRF file was not found in the local cache.
Definition: newgrf_config.h:37
AirportSpec::min_year
TimerGameCalendar::Year min_year
first year the airport is available
Definition: newgrf_airport.h:111
IsDefaultCargo
bool IsDefaultCargo(CargoID cid)
Test if a cargo is a default cargo type.
Definition: cargotype.cpp:111
newgrf_airport.h
SetupCargoForClimate
void SetupCargoForClimate(LandscapeID l)
Set up the default cargo types for the given landscape type.
Definition: cargotype.cpp:48
HouseSpec::callback_mask
uint16_t callback_mask
Bitmask of house callbacks that have to be called.
Definition: house.h:116
build_industry.h
GRFTempEngineData::ctt_include_mask
CargoTypes ctt_include_mask
Cargo types always included in the refit mask.
Definition: newgrf.cpp:334
HouseSpec::building_name
StringID building_name
building name
Definition: house.h:104
TimerGameEconomy::date_fract
static DateFract date_fract
Fractional part of the day.
Definition: timer_game_economy.h:38
CargoSpec::Iterate
static IterateWrapper Iterate(size_t from=0)
Returns an iterable ensemble of all valid CargoSpec.
Definition: cargotype.h:187
SetupEngines
void SetupEngines()
Initialise the engine pool with the data from the original vehicles.
Definition: engine.cpp:565
GRFConfig::ident
GRFIdentifier ident
grfid and md5sum to uniquely identify newgrfs
Definition: newgrf_config.h:154
newgrf_townname.h
RailTypeInfo::introduction_required_railtypes
RailTypes introduction_required_railtypes
Bitmask of railtypes that are required for this railtype to be introduced at a given introduction_dat...
Definition: rail.h:261
AirportSpec::max_year
TimerGameCalendar::Year max_year
last year the airport is available
Definition: newgrf_airport.h:112
ttd_strnlen
size_t ttd_strnlen(const char *str, size_t maxlen)
Get the length of a string, within a limited buffer.
Definition: string_func.h:68
LiveryScheme
LiveryScheme
List of different livery schemes.
Definition: livery.h:21
AirportSpec::ResetAirports
static void ResetAirports()
This function initializes the airportspec array.
Definition: newgrf_airport.cpp:110
CargoSpec
Specification of a cargo type.
Definition: cargotype.h:68
GetNewEngine
static Engine * GetNewEngine(const GRFFile *file, VehicleType type, uint16_t internal_id, bool static_access=false)
Returns the engine associated to a certain internal_id, resp.
Definition: newgrf.cpp:598
ReusableBuffer::Allocate
T * Allocate(size_t count)
Get buffer of at least count times T.
Definition: alloc_type.hpp:42
GRFConfig::status
GRFStatus status
NOSAVE: GRFStatus, enum.
Definition: newgrf_config.h:165
GetNewGRFSoundID
SoundID GetNewGRFSoundID(const GRFFile *file, SoundID sound_id)
Resolve NewGRF sound ID.
Definition: newgrf_sound.cpp:169
VE_TYPE_COUNT
@ VE_TYPE_COUNT
Number of bits used for the effect type.
Definition: vehicle_base.h:85
town.h
GetGRFConfig
GRFConfig * GetGRFConfig(uint32_t grfid, uint32_t mask)
Retrieve a NewGRF from the current config by its grfid.
Definition: newgrf_config.cpp:716
NUM_OBJECTS_PER_GRF
static const ObjectType NUM_OBJECTS_PER_GRF
Number of supported objects per NewGRF.
Definition: object_type.h:24
BridgeSpec::speed
uint16_t speed
maximum travel speed (1 unit = 1/1.6 mph = 1 km-ish/h)
Definition: bridge.h:47
CC_LIQUID
@ CC_LIQUID
Liquids (Oil, Water, Rubber)
Definition: cargotype.h:56
RoadStopSpec::cls_id
RoadStopClassID cls_id
The class to which this spec belongs.
Definition: newgrf_roadstop.h:130
GRFP_GRF_UNSET
@ GRFP_GRF_UNSET
The NewGRF provided no information.
Definition: newgrf_config.h:70
StrongType::Typedef
Templated helper to make a type-safe 'typedef' representing a single POD value.
Definition: strong_typedef_type.hpp:150
ObjectFlags
ObjectFlags
Various object behaviours.
Definition: newgrf_object.h:24
EngineInfo
Information about a vehicle.
Definition: engine_type.h:144
ChangeGRFParamType
static bool ChangeGRFParamType(size_t len, ByteReader *buf)
Callback function for 'INFO'->'PARAM'->param_num->'TYPE' to set the typeof a parameter.
Definition: newgrf.cpp:8231
DSGA_OP_ADD
@ DSGA_OP_ADD
a + b
Definition: newgrf_spritegroup.h:121
GrfProcessingState::file
SpriteFile * file
File of currently processed GRF file.
Definition: newgrf.cpp:104
GRFLoadedFeatures::used_liveries
uint64_t used_liveries
Bitmask of LiveryScheme used by the defined engines.
Definition: newgrf.h:179
GMB_TRAIN_WIDTH_32_PIXELS
@ GMB_TRAIN_WIDTH_32_PIXELS
Use 32 pixels per train vehicle in depot gui and vehicle details. Never set in the global variable;.
Definition: newgrf.h:60
IndustrySpec::station_name
StringID station_name
Default name for nearby station.
Definition: industrytype.h:132
DIR_W
@ DIR_W
West.
Definition: direction_type.h:32
_display_opt
byte _display_opt
What do we want to draw/do?
Definition: transparency_gui.cpp:26
CIR_SUCCESS
@ CIR_SUCCESS
Variable was parsed and read.
Definition: newgrf.cpp:979
GRFConfig::min_loadable_version
uint32_t min_loadable_version
NOSAVE: Minimum compatible version a NewGRF can define.
Definition: newgrf_config.h:163
MAX_SPRITEGROUP
static const uint MAX_SPRITEGROUP
Maximum GRF-local ID for a spritegroup.
Definition: newgrf.cpp:84
VehicleSettings::road_side
byte road_side
the side of the road vehicles drive on
Definition: settings_type.h:532
RoadTypeInfo::replace_text
StringID replace_text
Text used in the autoreplace GUI.
Definition: road.h:107
AllowedSubtags::text
TextHandler text
Callback function for a text node, only valid if type == 'T'.
Definition: newgrf.cpp:8375
RailTypeInfo::group
const SpriteGroup * group[RTSG_END]
Sprite groups for resolving sprites.
Definition: rail.h:281
VSG_SCOPE_PARENT
@ VSG_SCOPE_PARENT
Related object of the resolved one.
Definition: newgrf_spritegroup.h:101
Engine
Definition: engine_base.h:37
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
CC_PASSENGERS
@ CC_PASSENGERS
Passengers.
Definition: cargotype.h:50
Action5Type::max_sprites
uint16_t max_sprites
If the Action5 contains more sprites, only the first max_sprites sprites will be used.
Definition: newgrf.cpp:6406
IndustryTileSpec::accepts_cargo
std::array< CargoID, INDUSTRY_NUM_INPUTS > accepts_cargo
Cargo accepted by this tile.
Definition: industrytype.h:157
GRFParameterInfo::type
GRFParameterType type
The type of this parameter.
Definition: newgrf_config.h:131
SoundEffectChangeInfo
static ChangeInfoResult SoundEffectChangeInfo(uint sid, int numinfo, int prop, ByteReader *buf)
Define properties for sound effects.
Definition: newgrf.cpp:3138
RailTypeInfo::strings
struct RailTypeInfo::@26 strings
Strings associated with the rail type.
_tags_parameters
AllowedSubtags _tags_parameters[]
Action14 parameter tags.
Definition: newgrf.cpp:8425
RoadVehicleInfo::roadtype
RoadType roadtype
Road type.
Definition: engine_type.h:128
SpriteFile::GetContainerVersion
byte GetContainerVersion() const
Get the version number of container type used by the file.
Definition: sprite_file_type.hpp:38
SoundEntry::grf_container_ver
byte grf_container_ver
NewGRF container version if the sound is from a NewGRF.
Definition: sound_type.h:22
IndustrySpec::cost_multiplier
uint8_t cost_multiplier
Base construction cost multiplier.
Definition: industrytype.h:107
fios.h
BridgeSpec::price
uint16_t price
the price multiplier
Definition: bridge.h:46
TranslateGRFStrings
static void TranslateGRFStrings(ByteReader *buf)
Action 0x13.
Definition: newgrf.cpp:8048
ConstructionSettings::max_bridge_length
uint16_t max_bridge_length
maximum length of bridges
Definition: settings_type.h:372
FinalisePriceBaseMultipliers
static void FinalisePriceBaseMultipliers()
Decide whether price base multipliers of grfs shall apply globally or only to the grf specifying them...
Definition: newgrf.cpp:9819
RandomAccessFile::ReadBlock
void ReadBlock(void *ptr, size_t size)
Read a block.
Definition: random_access_file.cpp:139
_engine_counts
const uint8_t _engine_counts[4]
Number of engines of each vehicle type in original engine data.
Definition: engine.cpp:53
TLF_BB_Z_OFFSET
@ TLF_BB_Z_OFFSET
Add signed offset to bounding box Z positions from register TileLayoutRegisters::delta....
Definition: newgrf_commons.h:41
StrEmpty
bool StrEmpty(const char *s)
Check if a string buffer is empty.
Definition: string_func.h:56
PaletteID
uint32_t PaletteID
The number of the palette.
Definition: gfx_type.h:18
GFX_WATERTILE_SPECIALCHECK
@ GFX_WATERTILE_SPECIALCHECK
not really a tile, but rather a very special check
Definition: industry_map.h:54
AirportSpec
Defines the data structure for an airport.
Definition: newgrf_airport.h:100
HasExactlyOneBit
constexpr bool HasExactlyOneBit(T value)
Test whether value has exactly 1 bit set.
Definition: bitmath_func.hpp:259
GRFParameterInfo::min_value
uint32_t min_value
The minimal value this parameter can have.
Definition: newgrf_config.h:132
NUM_HOUSES_PER_GRF
static const HouseID NUM_HOUSES_PER_GRF
Number of supported houses per NewGRF; limited to 255 to allow extending Action3 with an extended byt...
Definition: house.h:25
INVALID_ROADTYPE
@ INVALID_ROADTYPE
flag for invalid roadtype
Definition: road_type.h:30
genworld.h
TileLayoutRegisters
Additional modifiers for items in sprite layouts.
Definition: newgrf_commons.h:90
CargoSpec::initial_payment
int32_t initial_payment
Initial payment rate before inflation is applied.
Definition: cargotype.h:76
GRFP_BLT_UNSET
@ GRFP_BLT_UNSET
The NewGRF provided no information or doesn't care about a 32 bpp blitter.
Definition: newgrf_config.h:76
RandomAccessFile::ReadByte
byte ReadByte()
Read a byte from the file.
Definition: random_access_file.cpp:101
RailTypeInfo::curve_speed
byte curve_speed
Multiplier for curve maximum speed advantage.
Definition: rail.h:206
ObjectSpec::animation
AnimationInfo animation
Information about the animation.
Definition: newgrf_object.h:63
CIR_UNHANDLED
@ CIR_UNHANDLED
Variable was parsed but unread.
Definition: newgrf.cpp:981
Debug
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
Definition: debug.h:37
VSG_SCOPE_SELF
@ VSG_SCOPE_SELF
Resolved object itself.
Definition: newgrf_spritegroup.h:100
SPR_AQUEDUCT_BASE
static const SpriteID SPR_AQUEDUCT_BASE
Sprites for the Aqueduct.
Definition: sprites.h:186
RailVehicleInfo::cost_factor
byte cost_factor
Purchase cost factor; For multiheaded engines the sum of both engine prices.
Definition: engine_type.h:45
GrfProcessingState::nfo_line
uint32_t nfo_line
Currently processed pseudo sprite number in the GRF.
Definition: newgrf.cpp:107
RailTypeInfo::sorting_order
byte sorting_order
The sorting order of this railtype for the toolbar dropdown.
Definition: rail.h:271
ObjectSpec::callback_mask
uint16_t callback_mask
Bitmask of requested/allowed callbacks.
Definition: newgrf_object.h:74
industry_map.h
CargoSpec::array
static CargoSpec array[NUM_CARGO]
Array holding all CargoSpecs.
Definition: cargotype.h:193
DeterministicSpriteGroupAdjustOperation
DeterministicSpriteGroupAdjustOperation
Definition: newgrf_spritegroup.h:120
AllowedSubtags::AllowedSubtags
AllowedSubtags(uint32_t id, DataHandler handler)
Create a binary leaf node.
Definition: newgrf.cpp:8326
GameSettings::game_creation
GameCreationSettings game_creation
settings used during the creation of a game (map)
Definition: settings_type.h:618
GRFParameterInfo::num_bit
byte num_bit
Number of bits to use for this parameter.
Definition: newgrf_config.h:137
ReallocT
T * ReallocT(T *t_ptr, size_t num_elements)
Simplified reallocation function that allocates the specified number of elements of the given type.
Definition: alloc_func.hpp:111
RAILTYPE_ELECTRIC
@ RAILTYPE_ELECTRIC
Electric rails.
Definition: rail_type.h:30
RandomizedSpriteGroup::var_scope
VarSpriteGroupScope var_scope
Take this object:
Definition: newgrf_spritegroup.h:193
GCF_INVALID
@ GCF_INVALID
GRF is unusable with this version of OpenTTD.
Definition: newgrf_config.h:30
AllocateRoadType
RoadType AllocateRoadType(RoadTypeLabel label, RoadTramType rtt)
Allocate a new road type label.
Definition: road_cmd.cpp:134
AirportChangeInfo
static ChangeInfoResult AirportChangeInfo(uint airport, int numinfo, int prop, ByteReader *buf)
Define properties for airports.
Definition: newgrf.cpp:3899
IndustryTileLayout
std::vector< IndustryTileLayoutTile > IndustryTileLayout
A complete tile layout for an industry is a list of tiles.
Definition: industrytype.h:100
GCF_INIT_ONLY
@ GCF_INIT_ONLY
GRF file is processed up to GLS_INIT.
Definition: newgrf_config.h:28
EC_ELECTRIC
@ EC_ELECTRIC
Electric rail engine.
Definition: engine_type.h:36
find_index
int find_index(Container const &container, typename Container::const_reference item)
Helper function to get the index of an item Consider using std::set, std::unordered_set or std::flat_...
Definition: container_func.hpp:41
FinaliseCargoArray
void FinaliseCargoArray()
Check for invalid cargoes.
Definition: newgrf.cpp:9262
StringIDMapping::target
StringID * target
Destination for mapping result.
Definition: newgrf.cpp:463
BridgeSpec
Struct containing information about a single bridge type.
Definition: bridge.h:42
IndustrySpec::closure_text
StringID closure_text
Message appearing when the industry closes.
Definition: industrytype.h:129
RailTypeInfo::compatible_railtypes
RailTypes compatible_railtypes
bitmask to the OTHER railtypes on which an engine of THIS railtype can physically travel
Definition: rail.h:191
Engine::GetGRF
const GRFFile * GetGRF() const
Retrieve the NewGRF the engine is tied to.
Definition: engine_base.h:167
GrfProcessingState::SpriteSet::sprite
SpriteID sprite
SpriteID of the first sprite of the set.
Definition: newgrf.cpp:91
MemCpyT
void MemCpyT(T *destination, const T *source, size_t num=1)
Type-safe version of memcpy().
Definition: mem_func.hpp:23
GRFFile::traininfo_vehicle_pitch
int traininfo_vehicle_pitch
Vertical offset for drawing train images in depot GUI and vehicle details.
Definition: newgrf.h:145
AirportTileSpec::ResetAirportTiles
static void ResetAirportTiles()
This function initializes the tile array of AirportTileSpec.
Definition: newgrf_airporttiles.cpp:58
TLF_KNOWN_FLAGS
@ TLF_KNOWN_FLAGS
Known flags. Any unknown set flag will disable the GRF.
Definition: newgrf_commons.h:49
ShipVehicleInfo::visual_effect
byte visual_effect
Bitstuffed NewGRF visual effect data.
Definition: engine_type.h:76
DrawTileSprites::ground
PalSpriteID ground
Palette and sprite for the ground.
Definition: sprite.h:59
HouseSpec::extra_flags
HouseExtraFlags extra_flags
some more flags
Definition: house.h:119
TileLayoutRegisters::sprite_var10
uint8_t sprite_var10
Value for variable 10 when resolving the sprite.
Definition: newgrf_commons.h:101
AirportTileSpec
Defines the data structure of each individual tile of an airport.
Definition: newgrf_airporttiles.h:68
HouseSpec::probability
byte probability
Relative probability of appearing (16 is the standard value)
Definition: house.h:118
NETWORK_MAX_GRF_COUNT
static const uint NETWORK_MAX_GRF_COUNT
Maximum number of GRFs that can be sent.
Definition: config.h:92
IndustryTileSpec::special_flags
IndustryTileSpecialFlags special_flags
Bitmask of extra flags used by the tile.
Definition: industrytype.h:171
StationSpec::cls_id
StationClassID cls_id
The class to which this spec belongs.
Definition: newgrf_station.h:125
RailTypeInfo::name
StringID name
Name of this rail type.
Definition: rail.h:176
EC_MAGLEV
@ EC_MAGLEV
Maglev engine.
Definition: engine_type.h:38
GRFTempEngineData::Refittability
Refittability
Summary state of refittability properties.
Definition: newgrf.cpp:321
GRFFileProps::override
uint16_t override
id of the entity been replaced by
Definition: newgrf_commons.h:332
newgrf_airporttiles.h
GameSettings::order
OrderSettings order
settings related to orders
Definition: settings_type.h:625
RealSpriteGroup::loading
std::vector< const SpriteGroup * > loading
List of loading groups (can be SpriteIDs or Callback results)
Definition: newgrf_spritegroup.h:90
Pool::PoolItem<&_engine_pool >::GetPoolSize
static size_t GetPoolSize()
Returns first unused index.
Definition: pool_type.hpp:360
Slope
Slope
Enumeration for the slope-type.
Definition: slope_type.h:48
ObjectSpec::BindToClasses
static void BindToClasses()
Tie all ObjectSpecs to their class.
Definition: newgrf_object.cpp:111
InitGRFTownGeneratorNames
void InitGRFTownGeneratorNames()
Allocate memory for the NewGRF town names.
Definition: newgrf_townname.cpp:81
GRFP_GRF_DOS
@ GRFP_GRF_DOS
The NewGRF says the DOS palette can be used.
Definition: newgrf_config.h:71
ObjectSpec::size
uint8_t size
The size of this objects; low nibble for X, high nibble for Y.
Definition: newgrf_object.h:68
MAX_CATCHMENT
@ MAX_CATCHMENT
Maximum catchment for airports with "modified catchment" enabled.
Definition: station_type.h:84
TileLayoutRegisters::palette
uint8_t palette
Register specifying a signed offset for the palette.
Definition: newgrf_commons.h:94
MAX_NUM_CASES
static const uint8_t MAX_NUM_CASES
Maximum number of supported cases.
Definition: language.h:21
AllowedSubtags::AllowedSubtags
AllowedSubtags(uint32_t id, TextHandler handler)
Create a text leaf node.
Definition: newgrf.cpp:8338
GRFLoadedFeatures::has_2CC
bool has_2CC
Set if any vehicle is loaded which uses 2cc (two company colours).
Definition: newgrf.h:178
PROP_ROADVEH_SPEED
@ PROP_ROADVEH_SPEED
Max. speed: 1 unit = 1/0.8 mph = 2 km-ish/h.
Definition: newgrf_properties.h:38
RailVehicleInfo::visual_effect
byte visual_effect
Bitstuffed NewGRF visual effect data.
Definition: engine_type.h:58
GrfProcessingState::HasValidSpriteSets
bool HasValidSpriteSets(byte feature) const
Check whether there are any valid spritesets for a feature.
Definition: newgrf.cpp:152
DisableStaticNewGRFInfluencingNonStaticNewGRFs
static void DisableStaticNewGRFInfluencingNonStaticNewGRFs(GRFConfig *c)
Disable a static NewGRF when it is influencing another (non-static) NewGRF as this could cause desync...
Definition: newgrf.cpp:6830
LoadNewGRF
void LoadNewGRF(uint load_index, uint num_baseset)
Load all the NewGRFs.
Definition: newgrf.cpp:10053
AirportSpec::rotation
const Direction * rotation
the rotation of each tiletable
Definition: newgrf_airport.h:103
LoadNewGRFFile
void LoadNewGRFFile(GRFConfig *config, GrfLoadingStage stage, Subdirectory subdir, bool temporary)
Load a particular NewGRF.
Definition: newgrf.cpp:9731
SHORE_REPLACE_NONE
@ SHORE_REPLACE_NONE
No shore sprites were replaced.
Definition: newgrf.h:165
RailVehicleInfo::ai_passenger_only
byte ai_passenger_only
Bit value to tell AI that this engine is for passenger use only.
Definition: engine_type.h:55
GRFConfig::version
uint32_t version
NOSAVE: Version a NewGRF can set so only the newest NewGRF is shown.
Definition: newgrf_config.h:162
AnimationInfo::status
uint8_t status
Status; 0: no looping, 1: looping, 0xFF: no animation.
Definition: newgrf_animation_type.h:20
EconomySettings::station_noise_level
bool station_noise_level
build new airports when the town noise level is still within accepted limits
Definition: settings_type.h:556
RailVehicleInfo
Information about a rail vehicle.
Definition: engine_type.h:42
GRFLoadedFeatures::shore
ShoreReplacement shore
In which way shore sprites were replaced.
Definition: newgrf.h:180
RailTypeInfo::maintenance_multiplier
uint16_t maintenance_multiplier
Cost multiplier for maintenance of this rail type.
Definition: rail.h:221
error_func.h
RoadTypeInfo::powered_roadtypes
RoadTypes powered_roadtypes
bitmask to the OTHER roadtypes on which a vehicle of THIS roadtype generates power
Definition: road.h:122
NUM_AIRPORTTILES_PER_GRF
static const uint NUM_AIRPORTTILES_PER_GRF
Number of airport tiles per NewGRF; limited to 255 to allow extending Action3 with an extended byte l...
Definition: airport.h:21
RailVehicleInfo::engclass
EngineClass engclass
Class of engine for this vehicle.
Definition: engine_type.h:53
GRFParameterInfo::value_names
std::map< uint32_t, GRFTextList > value_names
Names for each value.
Definition: newgrf_config.h:138
BindAirportSpecs
void BindAirportSpecs()
Tie all airportspecs to their class.
Definition: newgrf_airport.cpp:123
EngineInfo::callback_mask
uint16_t callback_mask
Bitmask of vehicle callbacks that have to be called.
Definition: engine_type.h:156
LoadNextSprite
bool LoadNextSprite(int load_index, SpriteFile &file, uint file_sprite_id)
Load a real or recolour sprite.
Definition: spritecache.cpp:609
VE_TYPE_START
@ VE_TYPE_START
First bit used for the type of effect.
Definition: vehicle_base.h:84
RailType
RailType
Enumeration for all possible railtypes.
Definition: rail_type.h:27
VehicleSettings::freight_trains
uint8_t freight_trains
value to multiply the weight of cargo by
Definition: settings_type.h:528
GRFFile::tramtype_list
std::vector< RoadTypeLabel > tramtype_list
Roadtype translation table (tram)
Definition: newgrf.h:138
GetSnowLine
byte GetSnowLine()
Get the current snow line, either variable or static.
Definition: landscape.cpp:611
BSWAP32
static uint32_t BSWAP32(uint32_t x)
Perform a 32 bits endianness bitswap on x.
Definition: bitmath_func.hpp:345
SetBitIterator
Iterable ensemble of each set bit in a value.
Definition: bitmath_func.hpp:282
PROP_AIRCRAFT_CARGO_AGE_PERIOD
@ PROP_AIRCRAFT_CARGO_AGE_PERIOD
Number of ticks before carried cargo is aged.
Definition: newgrf_properties.h:54
NEW_INDUSTRYOFFSET
static const IndustryType NEW_INDUSTRYOFFSET
original number of industry types
Definition: industry_type.h:25
RailVehicleInfo::air_drag
byte air_drag
Coefficient of air drag.
Definition: engine_type.h:61
GCF_UNSAFE
@ GCF_UNSAFE
GRF file is unsafe for static usage.
Definition: newgrf_config.h:24
GCS_INITIALISED
@ GCS_INITIALISED
GRF file has been initialised.
Definition: newgrf_config.h:38
GRFConfig
Information about GRF, used in the game and (part of it) in savegames.
Definition: newgrf_config.h:147
NUM_HOUSES
static const HouseID NUM_HOUSES
Total number of houses.
Definition: house.h:29
CargoSpec::weight
uint8_t weight
Weight of a single unit of this cargo type in 1/16 ton (62.5 kg).
Definition: cargotype.h:73
newgrf_engine.h
PROP_ROADVEH_CARGO_AGE_PERIOD
@ PROP_ROADVEH_CARGO_AGE_PERIOD
Number of ticks before carried cargo is aged.
Definition: newgrf_properties.h:40
GRFUnsafe
static void GRFUnsafe(ByteReader *)
Set the current NewGRF as unsafe for static use.
Definition: newgrf.cpp:8598
MAX_BRIDGES
static const uint MAX_BRIDGES
Maximal number of available bridge specs.
Definition: bridge.h:35
StringIDMapping::source
StringID source
Source StringID (GRF local).
Definition: newgrf.cpp:462
AirportSpec::num_table
byte num_table
number of elements in the table
Definition: newgrf_airport.h:104
SetPriceBaseMultiplier
void SetPriceBaseMultiplier(Price price, int factor)
Change a price base by the given factor.
Definition: economy.cpp:898
IndustrySpec::conflicting
IndustryType conflicting[3]
Industries this industry cannot be close to.
Definition: industrytype.h:110
RoadStopSpec::spec_id
int spec_id
The ID of this spec inside the class.
Definition: newgrf_roadstop.h:131
MapNewGRFIndustryType
IndustryType MapNewGRFIndustryType(IndustryType grf_type, uint32_t grf_id)
Map the GRF local type to an industry type.
Definition: newgrf_industries.cpp:40
CurrencySpec::suffix
std::string suffix
Suffix to apply when formatting money in this currency.
Definition: currency.h:79
TLF_BB_XY_OFFSET
@ TLF_BB_XY_OFFSET
Add signed offset to bounding box X and Y positions from register TileLayoutRegisters::delta....
Definition: newgrf_commons.h:40
DIR_E
@ DIR_E
East.
Definition: direction_type.h:28
StationSpec::layouts
std::vector< std::vector< std::vector< byte > > > layouts
Custom platform layouts.
Definition: newgrf_station.h:175
GetGRFSpriteOffset
size_t GetGRFSpriteOffset(uint32_t id)
Get the file offset for a specific sprite in the sprite section of a GRF.
Definition: spritecache.cpp:544
OverrideManagerBase::ResetMapping
void ResetMapping()
Resets the mapping, which is used while initializing game.
Definition: newgrf_commons.cpp:72
FinaliseIndustriesArray
static void FinaliseIndustriesArray()
Add all new industries to the industry array.
Definition: newgrf.cpp:9443
TLF_CHILD_Y_OFFSET
@ TLF_CHILD_Y_OFFSET
Add signed offset to child sprite Y positions from register TileLayoutRegisters::delta....
Definition: newgrf_commons.h:44
GRFP_GRF_ANY
@ GRFP_GRF_ANY
The NewGRF says any palette can be used.
Definition: newgrf_config.h:73
GCF_SYSTEM
@ GCF_SYSTEM
GRF file is an openttd-internal system grf.
Definition: newgrf_config.h:23
NEW_HOUSE_OFFSET
static const HouseID NEW_HOUSE_OFFSET
Offset for new houses.
Definition: house.h:28
HandleParameterInfo
static bool HandleParameterInfo(ByteReader *buf)
Callback function for 'INFO'->'PARA' to set extra information about the parameters.
Definition: newgrf.cpp:8442
StationSpec::pylons
byte pylons
Bitmask of base tiles (0 - 7) which should contain elrail pylons.
Definition: newgrf_station.h:161
AirportTileTable::gfx
StationGfx gfx
AirportTile to use for this tile.
Definition: newgrf_airport.h:27
free
void free(const void *ptr)
Version of the standard free that accepts const pointers.
Definition: stdafx.h:382
CallbackResultSpriteGroup
Definition: newgrf_spritegroup.h:210
CargoSpec::units_volume
StringID units_volume
Name of a single unit of cargo of this type.
Definition: cargotype.h:87
CargoSpec::IsValid
bool IsValid() const
Tests for validity of this cargospec.
Definition: cargotype.h:112
TAE_GOODS
@ TAE_GOODS
Cargo behaves goods/candy-like.
Definition: cargotype.h:26
RoadTypeInfo::maintenance_multiplier
uint16_t maintenance_multiplier
Cost multiplier for maintenance of this road type.
Definition: road.h:137
IndustryProductionSpriteGroup::version
uint8_t version
Production callback version used, or 0xFF if marked invalid.
Definition: newgrf_spritegroup.h:271
HouseSpec::building_flags
BuildingFlags building_flags
some flags that describe the house (size, stadium etc...)
Definition: house.h:110
GetFileByFilename
static GRFFile * GetFileByFilename(const std::string &filename)
Obtain a NewGRF file by its filename.
Definition: newgrf.cpp:416
ConstructionSettings::map_height_limit
uint8_t map_height_limit
the maximum allowed heightlevel
Definition: settings_type.h:369
RoadVehicleInfo
Information about a road vehicle.
Definition: engine_type.h:114
CC_PIECE_GOODS
@ CC_PIECE_GOODS
Piece goods (Livestock, Wood, Steel, Paper)
Definition: cargotype.h:55
DrawTileSeqStruct::delta_z
int8_t delta_z
0x80 identifies child sprites
Definition: sprite.h:28
RoadStopSpec::build_cost_multiplier
uint8_t build_cost_multiplier
Build cost multiplier per tile.
Definition: newgrf_roadstop.h:146
BranchHandler
bool(* BranchHandler)(ByteReader *)
Type of callback function for branch nodes.
Definition: newgrf.cpp:8305
EngineIDMapping::grfid
uint32_t grfid
The GRF ID of the file the entity belongs to.
Definition: engine_base.h:193
ObjectSpec::end_of_life_date
TimerGameCalendar::Date end_of_life_date
When can't this object be built anymore.
Definition: newgrf_object.h:72
LanguageMap::Mapping::openttd_id
byte openttd_id
OpenTTD's internal ID for a case/gender.
Definition: newgrf_text.h:57
RoadVehicleInfo::visual_effect
byte visual_effect
Bitstuffed NewGRF visual effect data.
Definition: engine_type.h:126
IndustryProductionSpriteGroup
Definition: newgrf_spritegroup.h:268
IndustrySpec::layouts
std::vector< IndustryTileLayout > layouts
List of possible tile layouts for the industry.
Definition: industrytype.h:106
TimerGameCalendar::ConvertYMDToDate
static Date ConvertYMDToDate(Year year, Month month, Day day)
Converts a tuple of Year, Month and Day to a Date.
Definition: timer_game_calendar.cpp:55
SPRITE_MODIFIER_OPAQUE
@ SPRITE_MODIFIER_OPAQUE
Set when a sprite must not ever be displayed transparently.
Definition: sprites.h:1540
AnimationInfo::speed
uint8_t speed
The speed, i.e. the amount of time between frames.
Definition: newgrf_animation_type.h:21
IndustrySpec::accepts_cargo
CargoID accepts_cargo[INDUSTRY_NUM_INPUTS]
16 accepted cargoes.
Definition: industrytype.h:120
INDUSTRYTILE_NOANIM
static const IndustryGfx INDUSTRYTILE_NOANIM
flag to mark industry tiles as having no animation
Definition: industry_type.h:31
INVALID_INDUSTRYTILE
static const IndustryGfx INVALID_INDUSTRYTILE
one above amount is considered invalid
Definition: industry_type.h:34
EF_USES_2CC
@ EF_USES_2CC
Vehicle uses two company colours.
Definition: engine_type.h:170
SHORE_REPLACE_ONLY_NEW
@ SHORE_REPLACE_ONLY_NEW
Only corner-shores were loaded by Action5 (openttd(w/d).grf only).
Definition: newgrf.h:168
BridgeSpec::transport_name
StringID transport_name[2]
description of the bridge, when built for road or rail
Definition: bridge.h:51
CC_BULK
@ CC_BULK
Bulk cargo (Coal, Grain etc., Ores, Fruit)
Definition: cargotype.h:54
_cargo_mask
CargoTypes _cargo_mask
Bitmask of cargo types available.
Definition: cargotype.cpp:31
SP_CUSTOM
@ SP_CUSTOM
No profile, special "custom" highscore.
Definition: settings_type.h:46
NUM_AIRPORTS_PER_GRF
@ NUM_AIRPORTS_PER_GRF
Maximal number of airports per NewGRF.
Definition: airport.h:40
IndustrySpec::production_up_text
StringID production_up_text
Message appearing when the industry's production is increasing.
Definition: industrytype.h:130
CleanUpStrings
void CleanUpStrings()
House cleaning.
Definition: newgrf_text.cpp:682
RailTypeInfo::toolbar_caption
StringID toolbar_caption
Caption in the construction toolbar GUI for this rail type.
Definition: rail.h:177
EnsureEarlyHouse
static void EnsureEarlyHouse(HouseZones bitmask)
Make sure there is at least one house available in the year 0 for the given climate / housezone combi...
Definition: newgrf.cpp:9338
GrfProcessingState::SpriteSet
Definition of a single Action1 spriteset.
Definition: newgrf.cpp:90
LoadNewGRFFileFromFile
static void LoadNewGRFFileFromFile(GRFConfig *config, GrfLoadingStage stage, SpriteFile &file)
Load a particular NewGRF from a SpriteFile.
Definition: newgrf.cpp:9642
CargoSpec::grffile
const struct GRFFile * grffile
NewGRF where #group belongs to.
Definition: cargotype.h:93
StaticGRFInfo
static void StaticGRFInfo(ByteReader *buf)
Handle Action 0x14.
Definition: newgrf.cpp:8588
EC_DIESEL
@ EC_DIESEL
Diesel rail engine.
Definition: engine_type.h:35
HZ_ZONALL
@ HZ_ZONALL
1F This is just to englobe all above types at once
Definition: house.h:78
SpriteGroupCargo::SG_DEFAULT
static constexpr CargoID SG_DEFAULT
Default type used when no more-specific cargo matches.
Definition: newgrf_cargo.h:23
NewGRFClass
Struct containing information relating to NewGRF classes for stations and airports.
Definition: newgrf_class.h:20
StationSettings::never_expire_airports
bool never_expire_airports
never expire airports
Definition: settings_type.h:593
AfterLoadGRFs
static void AfterLoadGRFs()
Finish loading NewGRFs and execute needed post-processing.
Definition: newgrf.cpp:9934
_cur_parameter
static GRFParameterInfo * _cur_parameter
The parameter which info is currently changed by the newgrf.
Definition: newgrf.cpp:8214
IndustrySpec::minimal_cargo
byte minimal_cargo
minimum amount of cargo transported to the stations.
Definition: industrytype.h:119
TileLayoutRegisters::max_palette_offset
uint16_t max_palette_offset
Maximum offset to add to the palette. (limited by size of the spriteset)
Definition: newgrf_commons.h:96
RoadTypeInfo::group
const SpriteGroup * group[ROTSG_END]
Sprite groups for resolving sprites.
Definition: road.h:192
LanguageMap::gender_map
std::vector< Mapping > gender_map
Mapping of NewGRF and OpenTTD IDs for genders.
Definition: newgrf_text.h:66
SHORE_REPLACE_ACTION_5
@ SHORE_REPLACE_ACTION_5
Shore sprites were replaced by Action5.
Definition: newgrf.h:166
StringIDMapping
Information for mapping static StringIDs.
Definition: newgrf.cpp:460
MAX_NUM_GENDERS
static const uint8_t MAX_NUM_GENDERS
Maximum number of supported genders.
Definition: language.h:20
RoadVehicleInfo::air_drag
uint8_t air_drag
Coefficient of air drag.
Definition: engine_type.h:125
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:55
StationSpec::cargo_threshold
uint16_t cargo_threshold
Cargo threshold for choosing between little and lots of cargo.
Definition: newgrf_station.h:153
HouseSpec::animation
AnimationInfo animation
information about the animation.
Definition: house.h:121
NUM_INDUSTRYTILES_PER_GRF
static const IndustryGfx NUM_INDUSTRYTILES_PER_GRF
Maximum number of industry tiles per NewGRF; limited to 255 to allow extending Action3 with an extend...
Definition: industry_type.h:29
ValidateIndustryLayout
static bool ValidateIndustryLayout(const IndustryTileLayout &layout)
Validate the industry layout; e.g.
Definition: newgrf.cpp:3458
RailTypeInfo::label
RailTypeLabel label
Unique 32 bit rail type identifier.
Definition: rail.h:236
timer_game_tick.h
TimerGameConst< struct Calendar >::ORIGINAL_MAX_YEAR
static constexpr TimerGame< struct Calendar >::Year ORIGINAL_MAX_YEAR
The maximum year of the original TTD.
Definition: timer_game_common.h:167
RoadTypeInfo::alternate_labels
RoadTypeLabelList alternate_labels
Road type labels this type provides in addition to the main label.
Definition: road.h:152
ChangeGRFURL
static bool ChangeGRFURL(byte langid, const char *str)
Callback function for 'INFO'->'URL_' to set the newgrf url.
Definition: newgrf.cpp:8115
_water_feature
WaterFeature _water_feature[CF_END]
Table of canal 'feature' sprite groups.
Definition: newgrf_canal.cpp:21
PriceBaseSpec::fallback_price
Price fallback_price
Fallback price multiplier for new prices but old grfs.
Definition: economy_type.h:211
GRFParameterInfo
Information about one grf parameter.
Definition: newgrf_config.h:127
CargoSpec::sprite
SpriteID sprite
Icon to display this cargo type, may be 0xFFF (which means to resolve an action123 chain).
Definition: cargotype.h:91
GRFConfig::error
std::optional< GRFError > error
NOSAVE: Error/Warning during GRF loading (Action 0x0B)
Definition: newgrf_config.h:160
ANIM_STATUS_NO_ANIMATION
static const uint8_t ANIM_STATUS_NO_ANIMATION
There is no animation.
Definition: newgrf_animation_type.h:15
GameSettings::economy
EconomySettings economy
settings to change the economy
Definition: settings_type.h:627
DrawTileSeqStruct::IsTerminator
bool IsTerminator() const
Check whether this is a sequence terminator.
Definition: sprite.h:41
AirportSpec::ttd_airport_type
TTDPAirportType ttd_airport_type
ttdpatch airport type (Small/Large/Helipad/Oilrig)
Definition: newgrf_airport.h:114
PROP_SHIP_CARGO_AGE_PERIOD
@ PROP_SHIP_CARGO_AGE_PERIOD
Number of ticks before carried cargo is aged.
Definition: newgrf_properties.h:47
CurrencySpec::code
std::string code
3 letter untranslated code to identify the currency.
Definition: currency.h:80
_action5_types
static const Action5Type _action5_types[]
The information about action 5 types.
Definition: newgrf.cpp:6411
NewGRFSpriteLayout
NewGRF supplied spritelayout.
Definition: newgrf_commons.h:112
MAX_LANG
static const uint MAX_LANG
Maximum number of languages supported by the game, and the NewGRF specs.
Definition: strings_type.h:19
TimerGameCalendar::ConvertDateToYMD
static YearMonthDay ConvertDateToYMD(Date date)
Converts a Date to a Year, Month & Day.
Definition: timer_game_calendar.cpp:42
safeguards.h
RoadVehicleInfo::power
uint8_t power
Power in 10hp units.
Definition: engine_type.h:123
EngineIDMapping::substitute_id
uint8_t substitute_id
The (original) entity ID to use if this GRF is not available (currently not used)
Definition: engine_base.h:196
ChangeGRFParamMask
static bool ChangeGRFParamMask(size_t len, ByteReader *buf)
Callback function for 'INFO'->'PARAM'->param_num->'MASK' to set the parameter and bits to use.
Definition: newgrf.cpp:8270
StationSpec::name
StringID name
Name of this station.
Definition: newgrf_station.h:126
ObjectOverrideManager::SetEntitySpec
void SetEntitySpec(ObjectSpec *spec)
Method to install the new object data in its proper slot The slot assignment is internal of this meth...
Definition: newgrf_commons.cpp:298
GameCreationSettings::starting_year
TimerGameCalendar::Year starting_year
starting date
Definition: settings_type.h:340
AddGRFString
StringID AddGRFString(uint32_t grfid, uint16_t stringid, byte langid_to_add, bool new_scheme, bool allow_newlines, const char *text_to_add, StringID def_string)
Add the new read string into our structure.
Definition: newgrf_text.cpp:543
lengthof
#define lengthof(array)
Return the length of an fixed size array.
Definition: stdafx.h:303
GRFP_BLT_32BPP
@ GRFP_BLT_32BPP
The NewGRF prefers a 32 bpp blitter.
Definition: newgrf_config.h:77
IndustryTileSpec::slopes_refused
Slope slopes_refused
slope pattern on which this tile cannot be built
Definition: industrytype.h:160
ChangeGRFParamValueNames
static bool ChangeGRFParamValueNames(ByteReader *buf)
Callback function for 'INFO'->'PARA'->param_num->'VALU' to set the names of some parameter values (ty...
Definition: newgrf.cpp:8395
ImportGRFSound
static void ImportGRFSound(SoundEntry *sound)
Process a sound import from another GRF file.
Definition: newgrf.cpp:7840
GRFConfig::has_param_defaults
bool has_param_defaults
NOSAVE: did this newgrf specify any defaults for it's parameters.
Definition: newgrf_config.h:172
GRFFile::param_end
uint param_end
one more than the highest set parameter
Definition: newgrf.h:125
TLR_MAX_VAR10
static const uint TLR_MAX_VAR10
Maximum value for var 10.
Definition: newgrf_commons.h:105
GrfProcessingState
Temporary data during loading of GRFs.
Definition: newgrf.cpp:87
IndustryProductionSpriteGroup::subtract_input
int16_t subtract_input[INDUSTRY_NUM_INPUTS]
Take this much of the input cargo (can be negative, is indirect in cb version 1+)
Definition: newgrf_spritegroup.h:273
SPRITE_MODIFIER_CUSTOM_SPRITE
@ SPRITE_MODIFIER_CUSTOM_SPRITE
Set when a sprite originates from an Action 1.
Definition: sprites.h:1539
IndustryTileSpec::enabled
bool enabled
entity still available (by default true).newgrf can disable it, though
Definition: industrytype.h:172
_tags_root
AllowedSubtags _tags_root[]
Action14 root tags.
Definition: newgrf.cpp:8483
FinaliseObjectsArray
static void FinaliseObjectsArray()
Add all new objects to the object array.
Definition: newgrf.cpp:9517
GRFTempEngineData::EMPTY
@ EMPTY
GRF defined vehicle as not-refittable. The vehicle shall only carry the default cargo.
Definition: newgrf.cpp:323
GRFTownName::partlists
std::vector< NamePartList > partlists[MAX_LISTS]
Lists of town name parts.
Definition: newgrf_townname.h:43
NamePart::text
std::string text
If probability bit 7 is clear.
Definition: newgrf_townname.h:19
DrawTileSprites
Ground palette sprite of a tile, together with its sprite layout.
Definition: sprite.h:58
HouseSpec::minimum_life
byte minimum_life
The minimum number of years this house will survive before the town rebuilds it.
Definition: house.h:123
RoadStopSpec::grf_prop
GRFFilePropsBase< NUM_CARGO+3 > grf_prop
Properties related the the grf file.
Definition: newgrf_roadstop.h:129
_networking
bool _networking
are we in networking mode?
Definition: network.cpp:65
AirportSpec::maintenance_cost
uint16_t maintenance_cost
maintenance cost multiplier
Definition: newgrf_airport.h:117
ROADTYPE_ROAD
@ ROADTYPE_ROAD
Basic road type.
Definition: road_type.h:27
CurrencySpec::rate
uint16_t rate
The conversion rate compared to the base currency.
Definition: currency.h:75
TTDPAirportType
TTDPAirportType
Allow incrementing of AirportClassID variables.
Definition: newgrf_airport.h:83
CanalChangeInfo
static ChangeInfoResult CanalChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
Define properties for water features.
Definition: newgrf.cpp:2157
WaterFeature::callback_mask
uint8_t callback_mask
Bitmask of canal callbacks that have to be called.
Definition: newgrf_canal.h:25
CargoSpec::callback_mask
uint8_t callback_mask
Bitmask of cargo callbacks that have to be called.
Definition: cargotype.h:83
GlobalVarChangeInfo
static ChangeInfoResult GlobalVarChangeInfo(uint gvid, int numinfo, int prop, ByteReader *buf)
Define properties for global variables.
Definition: newgrf.cpp:2683
newgrf_text.h
road.h
RoadVehicleInfo::tractive_effort
uint8_t tractive_effort
Coefficient of tractive effort.
Definition: engine_type.h:124
ObjectSpec::introduction_date
TimerGameCalendar::Date introduction_date
From when can this object be built.
Definition: newgrf_object.h:71
IndustrySpec::prospecting_chance
uint32_t prospecting_chance
Chance prospecting succeeds.
Definition: industrytype.h:109
NamePartList::bitcount
byte bitcount
Number of bits of random seed to use.
Definition: newgrf_townname.h:26
CargoID
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:22
RoadTypeInfo::name
StringID name
Name of this rail type.
Definition: road.h:103
error.h
GrfProcessingState::GetSprite
SpriteID GetSprite(byte feature, uint set) const
Returns the first sprite of a spriteset.
Definition: newgrf.cpp:177
RailVehicleChangeInfo
static ChangeInfoResult RailVehicleChangeInfo(uint engine, int numinfo, int prop, ByteReader *buf)
Define properties for rail vehicles.
Definition: newgrf.cpp:1038
OverrideManagerBase::AddEntityID
virtual uint16_t AddEntityID(uint16_t grf_local_id, uint32_t grfid, uint16_t substitute_id)
Reserves a place in the mapping array for an entity to be installed.
Definition: newgrf_commons.cpp:109
CargoSpec::is_freight
bool is_freight
Cargo type is considered to be freight (affects train freight multiplier).
Definition: cargotype.h:79
RailTypeInfo::cost_multiplier
uint16_t cost_multiplier
Cost multiplier for building this rail type.
Definition: rail.h:216
HZ_ZON5
@ HZ_ZON5
center of town
Definition: house.h:77
TimerGameConst< struct Calendar >::MAX_YEAR
static constexpr TimerGame< struct Calendar >::Year MAX_YEAR
MAX_YEAR, nicely rounded value of the number of years that can be encoded in a single 32 bits date,...
Definition: timer_game_common.h:173
GRFTempEngineData::ctt_exclude_mask
CargoTypes ctt_exclude_mask
Cargo types always excluded from the refit mask.
Definition: newgrf.cpp:335
GRFTempEngineData::defaultcargo_grf
const GRFFile * defaultcargo_grf
GRF defining the cargo translation table to use if the default cargo is the 'first refittable'.
Definition: newgrf.cpp:331
ResetCurrencies
void ResetCurrencies(bool preserve_custom)
Will fill _currency_specs array with default values from origin_currency_specs Called only from newgr...
Definition: currency.cpp:159
EngineIDMapping
Definition: engine_base.h:192
AirportTileTable
Tile-offset / AirportTileID pair.
Definition: newgrf_airport.h:25
IndustrySpec::appear_creation
byte appear_creation[NUM_LANDSCAPE]
Probability of appearance during map creation.
Definition: industrytype.h:134
GRFP_GRF_MASK
@ GRFP_GRF_MASK
Bitmask to get only the NewGRF supplied information.
Definition: newgrf_config.h:74
_loaded_newgrf_features
GRFLoadedFeatures _loaded_newgrf_features
Indicates which are the newgrf features currently loaded ingame.
Definition: newgrf.cpp:82
Pool::CleanPool
void CleanPool() override
Virtual method that deletes all items in the pool.
language.h
RoadTypeInfo::cost_multiplier
uint16_t cost_multiplier
Cost multiplier for building this road type.
Definition: road.h:132
IndustryTileSpec::anim_production
byte anim_production
Animation frame to start when goods are produced.
Definition: industrytype.h:161
newgrf_roadstop.h
RandomAccessFile::filename
std::string filename
Full name of the file; relative path to subdir plus the extension of the file.
Definition: random_access_file_type.h:26
CargoSpec::bitnum
uint8_t bitnum
Cargo bit number, is INVALID_CARGO_BITNUM for a non-used spec.
Definition: cargotype.h:70
RailVehicleInfo::tractive_effort
byte tractive_effort
Tractive effort coefficient.
Definition: engine_type.h:60
GetActiveCargoLabel
static CargoLabel GetActiveCargoLabel(const std::initializer_list< CargoLabel > &labels)
Find first cargo label that exists and is active from a list of cargo labels.
Definition: newgrf.cpp:8976
GRFFile::traininfo_vehicle_width
uint traininfo_vehicle_width
Width (in pixels) of a 8/8 train vehicle in depot GUI and vehicle details.
Definition: newgrf.h:146
GetGRFStringID
StringID GetGRFStringID(uint32_t grfid, StringID stringid)
Returns the index for this stringid associated with its grfID.
Definition: newgrf_text.cpp:587
CargoChangeInfo
static ChangeInfoResult CargoChangeInfo(uint cid, int numinfo, int prop, ByteReader *buf)
Define properties for cargoes.
Definition: newgrf.cpp:2980
SoundEntry
Definition: sound_type.h:13
StationSpec::disallowed_platforms
byte disallowed_platforms
Bitmask of number of platforms available for the station.
Definition: newgrf_station.h:132
stdafx.h
GrfProcessingState::grfconfig
GRFConfig * grfconfig
Config of the currently processed GRF file.
Definition: newgrf.cpp:106
TLF_NON_GROUND_FLAGS
@ TLF_NON_GROUND_FLAGS
Flags which do not work for the (first) ground sprite.
Definition: newgrf_commons.h:55
VehicleType
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
RailTypeInfo::grffile
const GRFFile * grffile[RTSG_END]
NewGRF providing the Action3 for the railtype.
Definition: rail.h:276
landscape.h
OTTDByteReaderSignal
Definition: newgrf.cpp:211
PROP_AIRCRAFT_COST_FACTOR
@ PROP_AIRCRAFT_COST_FACTOR
Purchase cost.
Definition: newgrf_properties.h:49
IndustrySpec
Defines the data structure for constructing industry.
Definition: industrytype.h:105
SpriteID
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:17
PROP_TRAIN_CURVE_SPEED_MOD
@ PROP_TRAIN_CURVE_SPEED_MOD
Modifier to maximum speed in curves.
Definition: newgrf_properties.h:31
IndustryTileSpec::grf_prop
GRFFileProps grf_prop
properties related to the grf file
Definition: industrytype.h:173
SPR_RAILTYPE_TUNNEL_BASE
static const SpriteID SPR_RAILTYPE_TUNNEL_BASE
Tunnel sprites with grass only for custom railtype tunnel.
Definition: sprites.h:299
EngineClass
EngineClass
Type of rail engine.
Definition: engine_type.h:33
PALETTE_MODIFIER_TRANSPARENT
@ PALETTE_MODIFIER_TRANSPARENT
when a sprite is to be displayed transparently, this bit needs to be set.
Definition: sprites.h:1541
NEWGRF_DIR
@ NEWGRF_DIR
Subdirectory for all NewGRFs.
Definition: fileio_type.h:117
IgnoreIndustryProperty
static ChangeInfoResult IgnoreIndustryProperty(int prop, ByteReader *buf)
Ignore an industry property.
Definition: newgrf.cpp:3368
GRFTempEngineData::refittability
Refittability refittability
Did the newgrf set any refittability property? If not, default refittability will be applied.
Definition: newgrf.cpp:332
EngineInfo::misc_flags
byte misc_flags
Miscellaneous flags.
Definition: engine_type.h:155
HouseSpec::mail_generation
byte mail_generation
mail generation multiplier (tile based, as the acceptances below)
Definition: house.h:106
A5BLOCK_FIXED
@ A5BLOCK_FIXED
Only allow replacing a whole block of sprites. (TTDP compatible)
Definition: newgrf.cpp:6397
GRFTownName
Definition: newgrf_townname.h:38
A5BLOCK_ALLOW_OFFSET
@ A5BLOCK_ALLOW_OFFSET
Allow replacing any subset by specifiing an offset.
Definition: newgrf.cpp:6398
GRFConfig::palette
uint8_t palette
GRFPalette, bitset.
Definition: newgrf_config.h:170
HouseSpec::population
byte population
population (Zero on other tiles in multi tile house.)
Definition: house.h:102
PROP_SHIP_RUNNING_COST_FACTOR
@ PROP_SHIP_RUNNING_COST_FACTOR
Yearly runningcost.
Definition: newgrf_properties.h:46
SkipSpriteData
bool SkipSpriteData(SpriteFile &file, byte type, uint16_t num)
Skip the given amount of sprite graphics data.
Definition: spritecache.cpp:113
IndustryProductionSpriteGroup::num_input
uint8_t num_input
How many subtract_input values are valid.
Definition: newgrf_spritegroup.h:272
GRFConfig::param_info
std::vector< std::optional< GRFParameterInfo > > param_info
NOSAVE: extra information about the parameters.
Definition: newgrf_config.h:171
RAILVEH_WAGON
@ RAILVEH_WAGON
simple wagon, not motorized
Definition: engine_type.h:29
RealSpriteGroup::loaded
std::vector< const SpriteGroup * > loaded
List of loaded groups (can be SpriteIDs or Callback results)
Definition: newgrf_spritegroup.h:89
LanguageMap::Mapping
Mapping between NewGRF and OpenTTD IDs.
Definition: newgrf_text.h:55
VehicleSettings::plane_speed
uint8_t plane_speed
divisor for speed of aircraft
Definition: settings_type.h:527
NamePartList::bitstart
byte bitstart
Start of random seed bits to use.
Definition: newgrf_townname.h:25
BuildCargoTranslationMap
static void BuildCargoTranslationMap()
Construct the Cargo Mapping.
Definition: newgrf.cpp:8892
IndustrySpec::number_of_sounds
uint8_t number_of_sounds
Number of sounds available in the sounds array.
Definition: industrytype.h:135
HouseSpec::cargo_acceptance
byte cargo_acceptance[HOUSE_NUM_ACCEPTS]
acceptance level for the cargo slots
Definition: house.h:107
WaterFeature::grffile
const GRFFile * grffile
NewGRF where 'group' belongs to.
Definition: newgrf_canal.h:24
HandleNode
static bool HandleNode(byte type, uint32_t id, ByteReader *buf, AllowedSubtags subtags[])
Handle the nodes of an Action14.
Definition: newgrf.cpp:8535
GRFFilePropsBase::local_id
uint16_t local_id
id defined by the grf file for this entity
Definition: newgrf_commons.h:318
ShipVehicleInfo::old_refittable
bool old_refittable
Is ship refittable; only used during initialisation. Later use EngineInfo::refit_mask.
Definition: engine_type.h:75
AllowedSubtags::type
byte type
The type of the node, must be one of 'C', 'B' or 'T'.
Definition: newgrf.cpp:8372
GRFParameterInfo::first_bit
byte first_bit
First bit to use in the GRF parameter.
Definition: newgrf_config.h:136
BuildIndustriesLegend
void BuildIndustriesLegend()
Fills an array for the industries legends.
Definition: smallmap_gui.cpp:186
SetSnowLine
void SetSnowLine(byte table[SNOW_LINE_MONTHS][SNOW_LINE_DAYS])
Set a variable snow line, as loaded from a newgrf file.
Definition: landscape.cpp:592
newgrf_object.h
RailTypeInfo::max_speed
uint16_t max_speed
Maximum speed for vehicles travelling on this rail type.
Definition: rail.h:231
ReadSpriteLayoutSprite
static TileLayoutFlags ReadSpriteLayoutSprite(ByteReader *buf, bool read_flags, bool invert_action1_flag, bool use_cur_spritesets, int feature, PalSpriteID *grf_sprite, uint16_t *max_sprite_offset=nullptr, uint16_t *max_palette_offset=nullptr)
Read a sprite and a palette from the GRF and convert them into a format suitable to OpenTTD.
Definition: newgrf.cpp:737
BridgeSpec::min_length
byte min_length
the minimum length (not counting start and end tile)
Definition: bridge.h:44
IndustrySpec::callback_mask
uint16_t callback_mask
Bitmask of industry callbacks that have to be called.
Definition: industrytype.h:138
ObjectSpec::name
StringID name
The name for this object.
Definition: newgrf_object.h:65
ChangeGRFBlitter
static bool ChangeGRFBlitter(size_t len, ByteReader *buf)
Callback function for 'INFO'->'BLTR' to set the blitter info.
Definition: newgrf.cpp:8160
RailTypeInfo::powered_railtypes
RailTypes powered_railtypes
bitmask to the OTHER railtypes on which an engine of THIS railtype generates power
Definition: rail.h:188
GRFTempEngineData::rv_max_speed
uint8_t rv_max_speed
Temporary storage of RV prop 15, maximum speed in mph/0.8.
Definition: newgrf.cpp:333
RandomAccessFile::GetPos
size_t GetPos() const
Get position in the file.
Definition: random_access_file.cpp:74
AirportSpec::size_x
byte size_x
size of airport in x direction
Definition: newgrf_airport.h:107
FinaliseEngineArray
static void FinaliseEngineArray()
Check for invalid engines.
Definition: newgrf.cpp:9195
GRFParameterType
GRFParameterType
The possible types of a newgrf parameter.
Definition: newgrf_config.h:120
ChangeGRFNumUsedParams
static bool ChangeGRFNumUsedParams(size_t len, ByteReader *buf)
Callback function for 'INFO'->'NPAR' to set the number of valid parameters.
Definition: newgrf.cpp:8122
GRFTempEngineData::UNSET
@ UNSET
No properties assigned. Default refit masks shall be activated.
Definition: newgrf.cpp:322
TranslateRefitMask
static CargoTypes TranslateRefitMask(uint32_t refit_mask)
Translate the refit mask.
Definition: newgrf.cpp:941
ChangeGRFMinVersion
static bool ChangeGRFMinVersion(size_t len, ByteReader *buf)
Callback function for 'INFO'->'MINV' to the minimum compatible version of the NewGRF.
Definition: newgrf.cpp:8195
GetGlobalVariable
bool GetGlobalVariable(byte param, uint32_t *value, const GRFFile *grffile)
Reads a variable common to VarAction2 and Action7/9/D.
Definition: newgrf.cpp:6552
RAILTYPE_RAIL
@ RAILTYPE_RAIL
Standard non-electric rails.
Definition: rail_type.h:29
_generating_world
bool _generating_world
Whether we are generating the map or not.
Definition: genworld.cpp:62
GCS_UNKNOWN
@ GCS_UNKNOWN
The status of this grf file is unknown.
Definition: newgrf_config.h:35
RailTypeInfo::menu_text
StringID menu_text
Name of this rail type in the main toolbar dropdown.
Definition: rail.h:178
SpriteFile
RandomAccessFile with some extra information specific for sprite files.
Definition: sprite_file_type.hpp:19
DeterministicSpriteGroupAdjust
Definition: newgrf_spritegroup.h:147
PriceBaseSpec
Describes properties of price bases.
Definition: economy_type.h:207
GRFError::param_value
std::array< uint32_t, 2 > param_value
Values of GRF parameters to show for message and custom_message.
Definition: newgrf_config.h:116
string_func.h
IndustrySpec::enabled
bool enabled
entity still available (by default true).newgrf can disable it, though
Definition: industrytype.h:140
GRFFile::canal_local_properties
CanalProperties canal_local_properties[CF_END]
Canal properties as set by this NewGRF.
Definition: newgrf.h:141
GRFError
Information about why GRF had problems during initialisation.
Definition: newgrf_config.h:109
RoadTypeInfo::grffile
const GRFFile * grffile[ROTSG_END]
NewGRF providing the Action3 for the roadtype.
Definition: road.h:187
NUM_ROADSTOPS_PER_GRF
static const int NUM_ROADSTOPS_PER_GRF
The maximum amount of roadstops a single GRF is allowed to add.
Definition: newgrf_roadstop.h:23
ChangeGRFDescription
static bool ChangeGRFDescription(byte langid, const char *str)
Callback function for 'INFO'->'DESC' to add a translation to the newgrf description.
Definition: newgrf.cpp:8108
GCS_DISABLED
@ GCS_DISABLED
GRF file is disabled.
Definition: newgrf_config.h:36
CIR_DISABLED
@ CIR_DISABLED
GRF was disabled due to error.
Definition: newgrf.cpp:980
RandomAccessFile::ReadWord
uint16_t ReadWord()
Read a word (16 bits) from the file (in low endian format).
Definition: random_access_file.cpp:118
CT_INVALID
static constexpr CargoLabel CT_INVALID
Invalid cargo type.
Definition: cargo_type.h:71
GRFError::message
StringID message
Default message.
Definition: newgrf_config.h:114
AllocateRailType
RailType AllocateRailType(RailTypeLabel label)
Allocate a new rail type label.
Definition: rail_cmd.cpp:150
GRFParameterInfo::max_value
uint32_t max_value
The maximal value of this parameter.
Definition: newgrf_config.h:133
vehicle_func.h
rev.h
CURRENCY_END
@ CURRENCY_END
always the last item
Definition: currency.h:70
PROP_TRAIN_WEIGHT
@ PROP_TRAIN_WEIGHT
Weight in t (if dualheaded: for each single vehicle)
Definition: newgrf_properties.h:25
PROP_VEHICLE_LOAD_AMOUNT
@ PROP_VEHICLE_LOAD_AMOUNT
Loading speed.
Definition: newgrf_properties.h:19
GRFFile::GRFFile
GRFFile(const struct GRFConfig *config)
Constructor for GRFFile.
Definition: newgrf.cpp:8931
INVALID_TPE
@ INVALID_TPE
Invalid town production effect.
Definition: cargotype.h:44
CT_PASSENGERS
static constexpr CargoLabel CT_PASSENGERS
Available types of cargo Labels may be re-used between different climates.
Definition: cargo_type.h:30
CargoSpec::town_production_effect
TownProductionEffect town_production_effect
The effect on town cargo production.
Definition: cargotype.h:81
VehicleSettings::dynamic_engines
bool dynamic_engines
enable dynamic allocation of engine data
Definition: settings_type.h:529
newgrf_sound.h
RoadVehicleInfo::shorten_factor
byte shorten_factor
length on main map for this type is 8 - shorten_factor
Definition: engine_type.h:127
Pool::PoolItem<&_engine_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:388
GRFFilePropsBase::spritegroup
const struct SpriteGroup * spritegroup[Tcnt]
pointer to the different sprites of the entity
Definition: newgrf_commons.h:320
GRFConfig::flags
uint8_t flags
NOSAVE: GCF_Flags, bitset.
Definition: newgrf_config.h:164
GRFP_GRF_WINDOWS
@ GRFP_GRF_WINDOWS
The NewGRF says the Windows palette can be used.
Definition: newgrf_config.h:72
strings_func.h
TLF_VAR10_FLAGS
@ TLF_VAR10_FLAGS
Flags which refer to using multiple action-1-2-3 chains.
Definition: newgrf_commons.h:58
TimerGameEconomy::year
static Year year
Current year, starting at 0.
Definition: timer_game_economy.h:35
StationSpec
Station specification.
Definition: newgrf_station.h:112
CLEAN_RANDOMSOUNDS
@ CLEAN_RANDOMSOUNDS
Free the dynamically allocated sounds table.
Definition: industrytype.h:22
AirportSpec::enabled
bool enabled
Entity still available (by default true). Newgrf can disable it, though.
Definition: newgrf_airport.h:119
SetNewGRFOverride
static void SetNewGRFOverride(uint32_t source_grfid, uint32_t target_grfid)
Set the override for a NewGRF.
Definition: newgrf.cpp:584
LanguageMap
Mapping of language data between a NewGRF and OpenTTD.
Definition: newgrf_text.h:53
PROP_TRAIN_SHORTEN_FACTOR
@ PROP_TRAIN_SHORTEN_FACTOR
Shorter vehicles.
Definition: newgrf_properties.h:28
IndustrySpec::removal_cost_multiplier
uint32_t removal_cost_multiplier
Base removal cost multiplier.
Definition: industrytype.h:108
IndustrytilesChangeInfo
static ChangeInfoResult IndustrytilesChangeInfo(uint indtid, int numinfo, int prop, ByteReader *buf)
Define properties for industry tiles.
Definition: newgrf.cpp:3233
FioCheckFileExists
bool FioCheckFileExists(const std::string &filename, Subdirectory subdir)
Check whether the given file exists.
Definition: fileio.cpp:127
bridge.h
RailTypeInfo::map_colour
byte map_colour
Colour on mini-map.
Definition: rail.h:246
EngineIDMapping::internal_id
uint16_t internal_id
The internal ID within the GRF file.
Definition: engine_base.h:194
NEW_AIRPORT_OFFSET
@ NEW_AIRPORT_OFFSET
Number of the first newgrf airport.
Definition: airport.h:39
RandomAccessFile::SkipBytes
void SkipBytes(size_t n)
Skip n bytes ahead in the file.
Definition: random_access_file.cpp:149
EngineInfo::base_life
TimerGameCalendar::Year base_life
Basic duration of engine availability (without random parts). 0xFF means infinite life.
Definition: engine_type.h:147
GameCreationSettings::generation_seed
uint32_t generation_seed
noise seed for world generation
Definition: settings_type.h:339
GRFTempEngineData
Temporary engine data used when loading only.
Definition: newgrf.cpp:319
CC_ARMOURED
@ CC_ARMOURED
Armoured cargo (Valuables, Gold, Diamonds)
Definition: cargotype.h:53
ResetNewGRFErrors
static void ResetNewGRFErrors()
Clear all NewGRF errors.
Definition: newgrf.cpp:8769
IsHouseSpecValid
static bool IsHouseSpecValid(HouseSpec *hs, const HouseSpec *next1, const HouseSpec *next2, const HouseSpec *next3, const std::string &filename)
Check if a given housespec is valid and disable it if it's not.
Definition: newgrf.cpp:9292
GRFConfig::name
GRFTextWrapper name
NOSAVE: GRF name (Action 0x08)
Definition: newgrf_config.h:157
ResetNewGRF
static void ResetNewGRF()
Reset and clear all NewGRFs.
Definition: newgrf.cpp:8758
GRFLoadedFeatures::tram
TramReplacement tram
In which way tram depots were replaced.
Definition: newgrf.h:181
GRFConfig::param
std::array< uint32_t, 0x80 > param
GRF parameters.
Definition: newgrf_config.h:167
GRFParameterInfo::desc
GRFTextList desc
The description of this parameter.
Definition: newgrf_config.h:130
AllowedSubtags
Data structure to store the allowed id/type combinations for action 14.
Definition: newgrf.cpp:8314
FinaliseAirportsArray
static void FinaliseAirportsArray()
Add all new airports to the airport array.
Definition: newgrf.cpp:9535
TileLayoutRegisters::parent
uint8_t parent[3]
Registers for signed offsets for the bounding box position of parent sprites.
Definition: newgrf_commons.h:98
RailTypeInfo::fallback_railtype
byte fallback_railtype
Original railtype number to use when drawing non-newgrf railtypes, or when drawing stations.
Definition: rail.h:201
SHORE_REPLACE_ACTION_A
@ SHORE_REPLACE_ACTION_A
Shore sprites were replaced by ActionA (using grass tiles for the corner-shores).
Definition: newgrf.h:167
GCF_RESERVED
@ GCF_RESERVED
GRF file passed GLS_RESERVE stage.
Definition: newgrf_config.h:29
NamePartList
Definition: newgrf_townname.h:24
TRAMWAY_REPLACE_DEPOT_WITH_TRACK
@ TRAMWAY_REPLACE_DEPOT_WITH_TRACK
Electrified depot graphics with tram track were loaded.
Definition: newgrf.h:173
abs
constexpr T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition: math_func.hpp:23
IndustryTileSpec::animation
AnimationInfo animation
Information about the animation (is it looping, how many loops etc)
Definition: industrytype.h:170
MapSpriteMappingRecolour
static void MapSpriteMappingRecolour(PalSpriteID *grf_sprite)
Map the colour modifiers of TTDPatch to those that Open is using.
Definition: newgrf.cpp:706
ObjectSpec::climate
uint8_t climate
In which climates is this object available?
Definition: newgrf_object.h:67
TranslateTTDPatchCodes
std::string TranslateTTDPatchCodes(uint32_t grfid, uint8_t language_id, bool allow_newlines, const std::string &str, StringControlCode byte80)
Translate TTDPatch string codes into something OpenTTD can handle (better).
Definition: newgrf_text.cpp:236
RAILTYPE_END
@ RAILTYPE_END
Used for iterations.
Definition: rail_type.h:33
CC_REFRIGERATED
@ CC_REFRIGERATED
Refrigerated cargo (Food, Fruit)
Definition: cargotype.h:57
CommonVehicleChangeInfo
static ChangeInfoResult CommonVehicleChangeInfo(EngineInfo *ei, int prop, ByteReader *buf)
Define properties common to all vehicles.
Definition: newgrf.cpp:995
ConstructionSettings::build_on_slopes
bool build_on_slopes
allow building on slopes
Definition: settings_type.h:370
RealSpriteGroup
Definition: newgrf_spritegroup.h:79
AllowedSubtags::subtags
AllowedSubtags * subtags
Pointer to a list of subtags, only valid if type == 'C' && !call_handler.
Definition: newgrf.cpp:8379
MCT_LIVESTOCK_FRUIT
@ MCT_LIVESTOCK_FRUIT
Cargo can be livestock or fruit.
Definition: cargo_type.h:84
HZ_SUBARTC_ABOVE
@ HZ_SUBARTC_ABOVE
11 800 can appear in sub-arctic climate above the snow line
Definition: house.h:79
TextHandler
bool(* TextHandler)(byte, const char *str)
Type of callback function for text nodes.
Definition: newgrf.cpp:8304
Action5Type::block_type
Action5BlockType block_type
How is this Action5 type processed?
Definition: newgrf.cpp:6403
AirportSpec::grf_prop
struct GRFFileProps grf_prop
Properties related to the grf file.
Definition: newgrf_airport.h:120
CargoSpec::quantifier
StringID quantifier
Text for multiple units of cargo of this type.
Definition: cargotype.h:88
IndustrySpec::random_sounds
const uint8_t * random_sounds
array of random sounds.
Definition: industrytype.h:136
SPR_AIRPORT_PREVIEW_BASE
static const SpriteID SPR_AIRPORT_PREVIEW_BASE
Airport preview sprites.
Definition: sprites.h:248
GRFConfig::next
struct GRFConfig * next
NOSAVE: Next item in the linked list.
Definition: newgrf_config.h:174
industrytype.h
RAILVEH_MULTIHEAD
@ RAILVEH_MULTIHEAD
indicates a combination of two locomotives
Definition: engine_type.h:28
TimerGame< struct Calendar >::IsLeapYear
static constexpr bool IsLeapYear(Year year)
Checks whether the given year is a leap year or not.
Definition: timer_game_common.h:63
GetEngineLiveryScheme
LiveryScheme GetEngineLiveryScheme(EngineID engine_type, EngineID parent_engine_type, const Vehicle *v)
Determines the LiveryScheme for a vehicle.
Definition: vehicle.cpp:1963
ShipVehicleInfo::acceleration
uint8_t acceleration
Acceleration (1 unit = 1/3.2 mph per tick = 0.5 km-ish/h per tick)
Definition: engine_type.h:70
LanguagePackHeader::GetGenderIndex
uint8_t GetGenderIndex(const char *gender_str) const
Get the index for the given gender.
Definition: language.h:68
InitializeSortedCargoSpecs
void InitializeSortedCargoSpecs()
Initialize the list of sorted cargo specifications.
Definition: cargotype.cpp:201
EngineInfo::variant_id
EngineID variant_id
Engine variant ID. If set, will be treated specially in purchase lists.
Definition: engine_type.h:160
EngineOverrideManager::GetID
EngineID GetID(VehicleType type, uint16_t grf_local_id, uint32_t grfid)
Looks up an EngineID in the EngineOverrideManager.
Definition: engine.cpp:532
GrfProcessingState::AddSpriteSets
void AddSpriteSets(byte feature, SpriteID first_sprite, uint first_set, uint numsets, uint numents)
Records new spritesets.
Definition: newgrf.cpp:136
SPR_OPENTTD_BASE
static const SpriteID SPR_OPENTTD_BASE
Extra graphic spritenumbers.
Definition: sprites.h:56
SpriteGroupCargo::SG_PURCHASE
static constexpr CargoID SG_PURCHASE
Used in purchase lists before an item exists.
Definition: newgrf_cargo.h:24
IndustrySpec::production_down_text
StringID production_down_text
Message appearing when the industry's production is decreasing.
Definition: industrytype.h:131
TAE_WATER
@ TAE_WATER
Cargo behaves water-like.
Definition: cargotype.h:27
TRAMWAY_REPLACE_DEPOT_NONE
@ TRAMWAY_REPLACE_DEPOT_NONE
No tram depot graphics were loaded.
Definition: newgrf.h:172
RailVehicleInfo::user_def_data
byte user_def_data
Property 0x25: "User-defined bit mask" Used only for (very few) NewGRF vehicles.
Definition: engine_type.h:62
AlterVehicleListOrder
void AlterVehicleListOrder(EngineID engine, uint target)
Record a vehicle ListOrderChange.
Definition: newgrf_engine.cpp:1299
GetNewEngineID
EngineID GetNewEngineID(const GRFFile *file, VehicleType type, uint16_t internal_id)
Return the ID of a new engine.
Definition: newgrf.cpp:690
RoadVehicleChangeInfo
static ChangeInfoResult RoadVehicleChangeInfo(uint engine, int numinfo, int prop, ByteReader *buf)
Define properties for road vehicles.
Definition: newgrf.cpp:1347
LanguageMap::GetLanguageMap
static const LanguageMap * GetLanguageMap(uint32_t grfid, uint8_t language_id)
Get the language map associated with a given NewGRF and language.
Definition: newgrf.cpp:2630
AirportTileSpec::enabled
bool enabled
entity still available (by default true). newgrf can disable it, though
Definition: newgrf_airporttiles.h:73
GetString
std::string GetString(StringID string)
Resolve the given StringID into a std::string with all the associated DParam lookups and formatting.
Definition: strings.cpp:327
IndustrySpec::appear_ingame
byte appear_ingame[NUM_LANDSCAPE]
Probability of appearance in game.
Definition: industrytype.h:133
IndustrySpec::grf_prop
GRFFileProps grf_prop
properties related to the grf file
Definition: industrytype.h:141
_ttdpatch_flags
static uint32_t _ttdpatch_flags[8]
32 * 8 = 256 flags.
Definition: newgrf.cpp:79
TRAMWAY_REPLACE_DEPOT_NO_TRACK
@ TRAMWAY_REPLACE_DEPOT_NO_TRACK
Electrified depot graphics without tram track were loaded.
Definition: newgrf.h:174
RoadTypeInfo::map_colour
byte map_colour
Colour on mini-map.
Definition: road.h:157
NewGRFSpriteLayout::consistent_max_offset
uint consistent_max_offset
Number of sprites in all referenced spritesets.
Definition: newgrf_commons.h:119
HouseSpec::watched_cargoes
CargoTypes watched_cargoes
Cargo types watched for acceptance.
Definition: house.h:124
IsSnowLineSet
bool IsSnowLineSet()
Has a snow line table already been loaded.
Definition: landscape.cpp:582
StationClassID
StationClassID
Definition: newgrf_station.h:83
ConstructionSettings::train_signal_side
byte train_signal_side
show signals on left / driving / right side
Definition: settings_type.h:375
HouseSpec::class_id
HouseClassID class_id
defines the class this house has (not grf file based)
Definition: house.h:120
GRFParameterInfo::name
GRFTextList name
The name of this parameter.
Definition: newgrf_config.h:129
IndustrySpec::cleanup_flag
uint8_t cleanup_flag
flags indicating which data should be freed upon cleaning up
Definition: industrytype.h:139
GRFParameterInfo::def_value
uint32_t def_value
Default value of this parameter.
Definition: newgrf_config.h:134
RailVehicleInfo::weight
uint16_t weight
Weight of vehicle (tons); For multiheaded engines the weight of each single engine.
Definition: engine_type.h:50
Pool::PoolItem<&_engine_pool >::CanAllocateItem
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
Definition: pool_type.hpp:309
IndustryTileLayoutTile
Definition of one tile in an industry tile layout.
Definition: industrytype.h:94
EngineInfo::cargo_age_period
uint16_t cargo_age_period
Number of ticks before carried cargo is aged.
Definition: engine_type.h:159
VehicleSettings::disable_elrails
bool disable_elrails
when true, the elrails are disabled
Definition: settings_type.h:522
TimerGameConst< struct Calendar >::MIN_YEAR
static constexpr TimerGame< struct Calendar >::Year MIN_YEAR
The absolute minimum year in OTTD.
Definition: timer_game_common.h:176
InitNewGRFFile
static void InitNewGRFFile(const GRFConfig *config)
Prepare loading a NewGRF file with its config.
Definition: newgrf.cpp:8914
CommitVehicleListOrderChanges
void CommitVehicleListOrderChanges()
Deternine default engine sorting and execute recorded ListOrderChanges from AlterVehicleListOrder.
Definition: newgrf_engine.cpp:1329
ShipVehicleInfo
Information about a ship vehicle.
Definition: engine_type.h:67
HouseSpec::building_availability
HouseZones building_availability
where can it be built (climates, zones)
Definition: house.h:111
NFO_UTF8_IDENTIFIER
static const char32_t NFO_UTF8_IDENTIFIER
This character, the thorn ('þ'), indicates a unicode string to NFO.
Definition: newgrf_text.h:19
NewGRFClass::name
StringID name
Name of this class.
Definition: newgrf_class.h:39
RoadType
RoadType
The different roadtypes we support.
Definition: road_type.h:25
MapGRFStringID
StringID MapGRFStringID(uint32_t grfid, StringID str)
Used when setting an object's property to map to the GRF's strings while taking in consideration the ...
Definition: newgrf.cpp:550
RoadTypeFlags
RoadTypeFlags
Roadtype flags.
Definition: road.h:46
Subdirectory
Subdirectory
The different kinds of subdirectories OpenTTD uses.
Definition: fileio_type.h:108
AirportSpec::GetWithoutOverride
static AirportSpec * GetWithoutOverride(byte type)
Retrieve airport spec for the given airport.
Definition: newgrf_airport.cpp:74
TileLayoutFlags
TileLayoutFlags
Flags to enable register usage in sprite layouts.
Definition: newgrf_commons.h:32
CargoSpec::name
StringID name
Name of this type of cargo.
Definition: cargotype.h:85
PROP_ROADVEH_CARGO_CAPACITY
@ PROP_ROADVEH_CARGO_CAPACITY
Capacity.
Definition: newgrf_properties.h:34
RailVehicleInfo::railtype
RailType railtype
Railtype, mangled if elrail is disabled.
Definition: engine_type.h:46
ResetNewGRFData
void ResetNewGRFData()
Reset all NewGRF loaded data.
Definition: newgrf.cpp:8779
AircraftVehicleChangeInfo
static ChangeInfoResult AircraftVehicleChangeInfo(uint engine, int numinfo, int prop, ByteReader *buf)
Define properties for aircraft.
Definition: newgrf.cpp:1745
GRFFile::cargo_list
std::vector< CargoLabel > cargo_list
Cargo translation table (local ID -> label)
Definition: newgrf.h:129
SanitizeSpriteOffset
static uint16_t SanitizeSpriteOffset(uint16_t &num, uint16_t offset, int max_sprites, const char *name)
Sanitize incoming sprite offsets for Action 5 graphics replacements.
Definition: newgrf.cpp:6374
GrfMsgI
void GrfMsgI(int severity, const std::string &msg)
Debug() function dedicated to newGRF debugging messages Function is essentially the same as Debug(grf...
Definition: newgrf.cpp:393
PalSpriteID
Combination of a palette sprite and a 'real' sprite.
Definition: gfx_type.h:22
GRFConfig::url
GRFTextWrapper url
NOSAVE: URL belonging to this GRF.
Definition: newgrf_config.h:159
GRFFile::labels
std::vector< GRFLabel > labels
List of labels.
Definition: newgrf.h:127
VSG_SCOPE_RELATIVE
@ VSG_SCOPE_RELATIVE
Relative position (vehicles only)
Definition: newgrf_spritegroup.h:102
ActivateOldTramDepot
static void ActivateOldTramDepot()
Replocate the old tram depot sprites to the new position, if no new ones were loaded.
Definition: newgrf.cpp:9804
AllowedSubtags::AllowedSubtags
AllowedSubtags(uint32_t id, AllowedSubtags *subtags)
Create a branch node with a list of sub-nodes.
Definition: newgrf.cpp:8363
container_func.hpp
ExtraEngineFlags
ExtraEngineFlags
Definition: engine_type.h:131
HZ_CLIMALL
@ HZ_CLIMALL
Bitmask of all climate bits.
Definition: house.h:84
RoadTypeInfo::strings
struct RoadTypeInfo::@29 strings
Strings associated with the rail type.
GrfProcessingState::stage
GrfLoadingStage stage
Current loading stage.
Definition: newgrf.cpp:100
ORIGINAL_SAMPLE_COUNT
static const uint ORIGINAL_SAMPLE_COUNT
The number of sounds in the original sample.cat.
Definition: sound_type.h:116
_gted
static std::vector< GRFTempEngineData > _gted
Temporary engine data used during NewGRF loading.
Definition: newgrf.cpp:351
IgnoreObjectProperty
static ChangeInfoResult IgnoreObjectProperty(uint prop, ByteReader *buf)
Ignore properties for objects.
Definition: newgrf.cpp:4073
CHECK_NOTHING
@ CHECK_NOTHING
Always succeeds.
Definition: industrytype.h:38
AircraftVehicleInfo::mail_capacity
byte mail_capacity
Mail capacity (bags).
Definition: engine_type.h:108
NamePart
Definition: newgrf_townname.h:18
CargoSpec::name_single
StringID name_single
Name of a single entity of this type of cargo.
Definition: cargotype.h:86
GRFTownName::MAX_LISTS
static const uint MAX_LISTS
Maximum number of town name lists that can be defined per GRF.
Definition: newgrf_townname.h:39
PTYPE_END
@ PTYPE_END
Invalid parameter type.
Definition: newgrf_config.h:123
AllowedSubtags::id
uint32_t id
The identifier for this node.
Definition: newgrf.cpp:8371
GrfProcessingState::GetNumEnts
uint GetNumEnts(byte feature, uint set) const
Returns the number of sprites in a spriteset.
Definition: newgrf.cpp:189
CargoSpec::abbrev
StringID abbrev
Two letter abbreviation for this cargo type.
Definition: cargotype.h:89
HouseSpec::processing_time
byte processing_time
Periodic refresh multiplier.
Definition: house.h:122
IndustrySpec::life_type
IndustryLifeType life_type
This is also known as Industry production flag, in newgrf specs.
Definition: industrytype.h:123
Action5Type::name
const char * name
Name for error messages.
Definition: newgrf.cpp:6407
WaterFeature::flags
uint8_t flags
Flags controlling display.
Definition: newgrf_canal.h:26
RailVehicleInfo::power
uint16_t power
Power of engine (hp); For multiheaded engines the sum of both engine powers.
Definition: engine_type.h:49
FinaliseHouseArray
static void FinaliseHouseArray()
Add all new houses to the house array.
Definition: newgrf.cpp:9365
RailVehicleInfo::intended_railtype
RailType intended_railtype
Intended railtype, regardless of elrail being enabled or disabled.
Definition: engine_type.h:47
ObjectSpec::build_cost_multiplier
uint8_t build_cost_multiplier
Build cost multiplier per tile.
Definition: newgrf_object.h:69
NamePartList::parts
std::vector< NamePart > parts
List of parts to choose from.
Definition: newgrf_townname.h:28
LoadTranslationTable
static ChangeInfoResult LoadTranslationTable(uint gvid, int numinfo, ByteReader *buf, std::vector< T > &translation_table, const char *name)
Load a cargo- or railtype-translation table.
Definition: newgrf.cpp:2647
NewGRFSpriteLayout::Clone
void Clone(const DrawTileSeqStruct *source)
Clone the building sprites of a spritelayout.
Definition: newgrf_commons.cpp:565
TileIndexDiffC::y
int16_t y
The y value of the coordinate.
Definition: map_type.h:33
RandomAccessFile::SeekTo
void SeekTo(size_t pos, int mode)
Seek in the current file.
Definition: random_access_file.cpp:84
RailTypeInfo::introduces_railtypes
RailTypes introduces_railtypes
Bitmask of which other railtypes are introduced when this railtype is introduced.
Definition: rail.h:266
RailVehicleInfo::shorten_factor
byte shorten_factor
length on main map for this type is 8 - shorten_factor
Definition: engine_type.h:59
CurrencySpec::to_euro
TimerGameCalendar::Year to_euro
Year of switching to the Euro. May also be CF_NOEURO or CF_ISEURO.
Definition: currency.h:77
_grfconfig
GRFConfig * _grfconfig
First item in list of current GRF set up.
Definition: newgrf_config.cpp:164
DrawTileSprites::seq
const DrawTileSeqStruct * seq
Array of child sprites. Terminated with a terminator entry.
Definition: sprite.h:60
CIR_UNKNOWN
@ CIR_UNKNOWN
Variable is unknown.
Definition: newgrf.cpp:982
GRFTempEngineData::NONEMPTY
@ NONEMPTY
GRF defined the vehicle as refittable. If the refitmask is empty after translation (cargotypes not av...
Definition: newgrf.cpp:324
TimerGame< struct Calendar >::DateFract
uint16_t DateFract
The fraction of a date we're in, i.e.
Definition: timer_game_common.h:38
IndustrySpec::behaviour
IndustryBehaviour behaviour
How this industry will behave, and how others entities can use it.
Definition: industrytype.h:125
ResetObjects
void ResetObjects()
This function initialize the spec arrays of objects.
Definition: newgrf_object.cpp:121
EngineInfo::retire_early
int8_t retire_early
Number of years early to retire vehicle.
Definition: engine_type.h:157
TileLayoutRegisters::sprite
uint8_t sprite
Register specifying a signed offset for the sprite.
Definition: newgrf_commons.h:93
RoadTypeInfo::max_speed
uint16_t max_speed
Maximum speed for vehicles travelling on this road type.
Definition: road.h:142
CurrencySpec::separator
std::string separator
The thousands separator for this currency.
Definition: currency.h:76
StationSpec::grf_prop
GRFFilePropsBase< NUM_CARGO+3 > grf_prop
Properties related the the grf file.
Definition: newgrf_station.h:124
RailVehicleInfo::max_speed
uint16_t max_speed
Maximum speed (1 unit = 1/1.6 mph = 1 km-ish/h)
Definition: engine_type.h:48
NewGRFClass::Get
static NewGRFClass * Get(Tid cls_id)
Get a particular class.
Definition: newgrf_class_func.h:98
Map::LogY
static uint LogY()
Logarithm of the map size along the y side.
Definition: map_func.h:261
InitializeGRFSpecial
static void InitializeGRFSpecial()
Initialize the TTDPatch flags.
Definition: newgrf.cpp:8608
BridgeSpec::avail_year
TimerGameCalendar::Year avail_year
the year where it becomes available
Definition: bridge.h:43
MemSetT
void MemSetT(T *ptr, byte value, size_t num=1)
Type-safe version of memset().
Definition: mem_func.hpp:49
HouseSpec::accepts_cargo_label
CargoLabel accepts_cargo_label[HOUSE_NUM_ACCEPTS]
input landscape cargo slots
Definition: house.h:109
DataHandler
bool(* DataHandler)(size_t, ByteReader *)
Type of callback function for binary nodes.
Definition: newgrf.cpp:8303
GRFIdentifier::grfid
uint32_t grfid
GRF ID (defined by Action 0x08)
Definition: newgrf_config.h:84
RandomizedSpriteGroup::lowest_randbit
byte lowest_randbit
Look for this in the per-object randomized bitmask:
Definition: newgrf_spritegroup.h:199
ActivateOldShore
static void ActivateOldShore()
Relocates the old shore sprites at new positions.
Definition: newgrf.cpp:9767
AircraftVehicleInfo::passenger_capacity
uint16_t passenger_capacity
Passenger capacity (persons).
Definition: engine_type.h:109
BridgeSpec::material
StringID material
the string that contains the bridge description
Definition: bridge.h:50
TileLayoutRegisters::flags
TileLayoutFlags flags
Flags defining which members are valid and to be used.
Definition: newgrf_commons.h:91
AirportSpec::depot_table
const HangarTileTable * depot_table
gives the position of the depots on the airports
Definition: newgrf_airport.h:105
GRFConfig::num_params
uint8_t num_params
Number of used parameters.
Definition: newgrf_config.h:168
SkipUnknownInfo
static bool SkipUnknownInfo(ByteReader *buf, byte type)
Try to skip the current node and all subnodes (if it's a branch node).
Definition: newgrf.cpp:8495
LanguagePackHeader::GetCaseIndex
uint8_t GetCaseIndex(const char *case_str) const
Get the index for the given case.
Definition: language.h:81
newgrf_canal.h
TimerGameConst< struct Calendar >::ORIGINAL_BASE_YEAR
static constexpr TimerGame< struct Calendar >::Year ORIGINAL_BASE_YEAR
The minimum starting year/base year of the original TTD.
Definition: timer_game_common.h:163
TILE_HEIGHT
static const uint TILE_HEIGHT
Height of a height level in world coordinate AND in pixels in #ZOOM_LVL_BASE.
Definition: tile_type.h:18
IgnoreTownHouseProperty
static ChangeInfoResult IgnoreTownHouseProperty(int prop, ByteReader *buf)
Ignore a house property.
Definition: newgrf.cpp:2306
RoadStopDrawMode
RoadStopDrawMode
Different draw modes to disallow rendering of some parts of the stop or road.
Definition: newgrf_roadstop.h:58
ROADTYPE_TRAM
@ ROADTYPE_TRAM
Trams.
Definition: road_type.h:28
TileLayoutRegisters::child
uint8_t child[2]
Registers for signed offsets for the position of child sprites.
Definition: newgrf_commons.h:99
VehicleSettings::never_expire_vehicles
bool never_expire_vehicles
never expire vehicles
Definition: settings_type.h:530
OverrideManagerBase::Add
void Add(uint16_t local_id, uint32_t grfid, uint entity_type)
Since the entity IDs defined by the GRF file does not necessarily correlate to those used by the game...
Definition: newgrf_commons.cpp:62
HouseSpec
Definition: house.h:98
config.h
GetNewgrfCurrencyIdConverted
byte GetNewgrfCurrencyIdConverted(byte grfcurr_id)
Will return the ottd's index correspondence to the ttdpatch's id.
Definition: currency.cpp:115
GrfProcessingState::SpriteSet::num_sprites
uint num_sprites
Number of sprites in the set.
Definition: newgrf.cpp:92
NEW_AIRPORTTILE_OFFSET
static const uint NEW_AIRPORTTILE_OFFSET
offset of first newgrf airport tile
Definition: airport.h:24
RoadVehicleInfo::weight
uint8_t weight
Weight in 1/4t units.
Definition: engine_type.h:122
PROP_SHIP_COST_FACTOR
@ PROP_SHIP_COST_FACTOR
Purchase cost.
Definition: newgrf_properties.h:43
ChangeInfoResult
ChangeInfoResult
Possible return values for the FeatureChangeInfo functions.
Definition: newgrf.cpp:978
engine_base.h
IndustryProductionSpriteGroup::cargo_output
CargoID cargo_output[INDUSTRY_NUM_OUTPUTS]
Which output cargoes to add to (only cb version 2)
Definition: newgrf_spritegroup.h:277
SpriteGroupCargo::SG_DEFAULT_NA
static constexpr CargoID SG_DEFAULT_NA
Used only by stations and roads when no more-specific cargo matches.
Definition: newgrf_cargo.h:25
IgnoreRoadStopProperty
static ChangeInfoResult IgnoreRoadStopProperty(uint prop, ByteReader *buf)
Ignore properties for roadstops.
Definition: newgrf.cpp:4779
BridgeChangeInfo
static ChangeInfoResult BridgeChangeInfo(uint brid, int numinfo, int prop, ByteReader *buf)
Define properties for bridges.
Definition: newgrf.cpp:2195
RailTypeInfo::flags
RailTypeFlags flags
Bit mask of rail type flags.
Definition: rail.h:211
fontcache.h
_object_mngr
ObjectOverrideManager _object_mngr
The override manager for our objects.
RandomAccessFile::ReadDword
uint32_t ReadDword()
Read a double word (32 bits) from the file (in low endian format).
Definition: random_access_file.cpp:128
HouseZones
HouseZones
Definition: house.h:71
ShipVehicleInfo::max_speed
uint16_t max_speed
Maximum speed (1 unit = 1/3.2 mph = 0.5 km-ish/h)
Definition: engine_type.h:71
ReadDWordAsString
static std::string ReadDWordAsString(ByteReader *reader)
Helper to read a DWord worth of bytes from the reader and to return it as a valid string.
Definition: newgrf.cpp:2668
IsValidCargoID
bool IsValidCargoID(CargoID t)
Test whether cargo type is not INVALID_CARGO.
Definition: cargo_type.h:107
RailTypeChangeInfo
static ChangeInfoResult RailTypeChangeInfo(uint id, int numinfo, int prop, ByteReader *buf)
Define properties for railtypes.
Definition: newgrf.cpp:4252
Engine::grf_prop
GRFFilePropsBase< NUM_CARGO+2 > grf_prop
Properties related the the grf file.
Definition: engine_base.h:77
RAILVEH_SINGLEHEAD
@ RAILVEH_SINGLEHEAD
indicates a "standalone" locomotive
Definition: engine_type.h:27
MCT_VALUABLES_GOLD_DIAMONDS
@ MCT_VALUABLES_GOLD_DIAMONDS
Cargo can be valuables, gold or diamonds.
Definition: cargo_type.h:86
GRFFile::GetParam
uint32_t GetParam(uint number) const
Get GRF Parameter with range checking.
Definition: newgrf.h:155
IndustryTileSpecialFlags
IndustryTileSpecialFlags
Flags for miscellaneous industry tile specialities.
Definition: industrytype.h:86
IndustrySpec::check_proc
byte check_proc
Index to a procedure to check for conflicting circumstances.
Definition: industrytype.h:111
ReadGRFSpriteOffsets
void ReadGRFSpriteOffsets(SpriteFile &file)
Parse the sprite section of GRFs.
Definition: spritecache.cpp:553
SB
constexpr T SB(T &x, const uint8_t s, const uint8_t n, const U d)
Set n bits in x starting at bit s to d.
Definition: bitmath_func.hpp:58
RailVehicleInfo::running_cost
byte running_cost
Running cost of engine; For multiheaded engines the sum of both running costs.
Definition: engine_type.h:51
EF_ROAD_TRAM
@ EF_ROAD_TRAM
Road vehicle is a tram/light rail vehicle.
Definition: engine_type.h:169
GetRailTypeByLabel
RailType GetRailTypeByLabel(RailTypeLabel label, bool allow_alternate_labels)
Get the rail type for a given label.
Definition: rail.cpp:311
NEW_INDUSTRYTILEOFFSET
static const IndustryGfx NEW_INDUSTRYTILEOFFSET
original number of tiles
Definition: industry_type.h:32
newgrf_industries.h
PalSpriteID::pal
PaletteID pal
The palette (use PAL_NONE) if not needed)
Definition: gfx_type.h:24
EconomySettings::inflation
bool inflation
disable inflation
Definition: settings_type.h:538
TimerGameCalendar::date
static Date date
Current date in days (day counter).
Definition: timer_game_calendar.h:34
TAE_NONE
@ TAE_NONE
Cargo has no effect.
Definition: cargotype.h:23
GameSettings::construction
ConstructionSettings construction
construction of things in-game
Definition: settings_type.h:619
GrfProcessingState::IsValidSpriteSet
bool IsValidSpriteSet(byte feature, uint set) const
Check whether a specific set is defined.
Definition: newgrf.cpp:165
GameSettings::vehicle
VehicleSettings vehicle
options for vehicles
Definition: settings_type.h:626
FontSize
FontSize
Available font sizes.
Definition: gfx_type.h:202
EngineID
uint16_t EngineID
Unique identification number of an engine.
Definition: engine_type.h:21
TLF_PALETTE_REG_FLAGS
@ TLF_PALETTE_REG_FLAGS
Flags which require resolving the action-1-2-3 chain for the palette, even if it is no action-1 palet...
Definition: newgrf_commons.h:64
TLF_SPRITE
@ TLF_SPRITE
Add signed offset to sprite from register TileLayoutRegisters::sprite.
Definition: newgrf_commons.h:36
ClearTemporaryNewGRFData
static void ClearTemporaryNewGRFData(GRFFile *gf)
Reset all NewGRFData that was used only while processing data.
Definition: newgrf.cpp:425
EngineInfo::climates
byte climates
Climates supported by the engine.
Definition: engine_type.h:150
TLF_PALETTE
@ TLF_PALETTE
Add signed offset to palette from register TileLayoutRegisters::palette.
Definition: newgrf_commons.h:37
PTYPE_UINT_ENUM
@ PTYPE_UINT_ENUM
The parameter allows a range of numbers, each of which can have a special name.
Definition: newgrf_config.h:121
AirportSpec::nof_depots
byte nof_depots
the number of hangar tiles in this airport
Definition: newgrf_airport.h:106
_grm_cargoes
static uint32_t _grm_cargoes[NUM_CARGO *2]
Contains the GRF ID of the owner of a cargo if it has been reserved.
Definition: newgrf.cpp:360
PROP_AIRCRAFT_PASSENGER_CAPACITY
@ PROP_AIRCRAFT_PASSENGER_CAPACITY
Passenger Capacity.
Definition: newgrf_properties.h:52
PROP_SHIP_SPEED
@ PROP_SHIP_SPEED
Max. speed: 1 unit = 1/3.2 mph = 0.5 km-ish/h.
Definition: newgrf_properties.h:44
ClearSnowLine
void ClearSnowLine()
Clear the variable snow line table and free the memory.
Definition: landscape.cpp:643
HouseSpec::random_colour
Colours random_colour[4]
4 "random" colours
Definition: house.h:117
ResetRoadTypes
void ResetRoadTypes()
Reset all road type information to its default values.
Definition: road_cmd.cpp:67
AirportTileSpec::callback_mask
uint8_t callback_mask
Bitmask telling which grf callback is set.
Definition: newgrf_airporttiles.h:71
GRFPalette
GRFPalette
Information that can/has to be stored about a GRF's palette.
Definition: newgrf_config.h:59
StationSpec::callback_mask
byte callback_mask
Bitmask of station callbacks that have to be called.
Definition: newgrf_station.h:157
PROP_ROADVEH_POWER
@ PROP_ROADVEH_POWER
Power in 10 HP.
Definition: newgrf_properties.h:36
VEH_TRAIN
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
RandomizedSpriteGroup
Definition: newgrf_spritegroup.h:190
IndustrySpec::name
StringID name
Displayed name of the industry.
Definition: industrytype.h:127
ChangeGRFParamDefault
static bool ChangeGRFParamDefault(size_t len, ByteReader *buf)
Callback function for 'INFO'->'PARAM'->param_num->'DFLT' to set the default value.
Definition: newgrf.cpp:8291
IndustryBehaviour
IndustryBehaviour
Various industry behaviours mostly to represent original TTD specialities.
Definition: industrytype.h:59
PROP_TRAIN_COST_FACTOR
@ PROP_TRAIN_COST_FACTOR
Purchase cost (if dualheaded: sum of both vehicles)
Definition: newgrf_properties.h:26
IndustrySpec::new_industry_text
StringID new_industry_text
Message appearing when the industry is built.
Definition: industrytype.h:128
StationSpec::disallowed_lengths
byte disallowed_lengths
Bitmask of platform lengths available for the station.
Definition: newgrf_station.h:137
_misc_grf_features
byte _misc_grf_features
Miscellaneous GRF features, set by Action 0x0D, parameter 0x9E.
Definition: newgrf.cpp:76
RailVehicleInfo::capacity
byte capacity
Cargo capacity of vehicle; For multiheaded engines the capacity of each single engine.
Definition: engine_type.h:54
IndustryProductionSpriteGroup::cargo_input
CargoID cargo_input[INDUSTRY_NUM_INPUTS]
Which input cargoes to take from (only cb version 2)
Definition: newgrf_spritegroup.h:274
DefineGotoLabel
static void DefineGotoLabel(ByteReader *buf)
Action 0x10 - Define goto label.
Definition: newgrf.cpp:7822
TPE_PASSENGERS
@ TPE_PASSENGERS
Cargo behaves passenger-like for production.
Definition: cargotype.h:36
ByteReader
Class to read from a NewGRF file.
Definition: newgrf.cpp:214
LoadGRFSound
static void LoadGRFSound(size_t offs, SoundEntry *sound)
Load a sound from a file.
Definition: newgrf.cpp:7871
Clamp
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition: math_func.hpp:79
TTDPStringIDToOTTDStringIDMapping
static StringID TTDPStringIDToOTTDStringIDMapping(StringID str)
Perform a mapping from TTDPatch's string IDs to OpenTTD's string IDs, but only for the ones we are aw...
Definition: newgrf.cpp:486
GRFFilePropsBase::grffile
const struct GRFFile * grffile
grf file that introduced this entity
Definition: newgrf_commons.h:319
PROP_AIRCRAFT_SPEED
@ PROP_AIRCRAFT_SPEED
Max. speed: 1 unit = 8 mph = 12.8 km-ish/h.
Definition: newgrf_properties.h:50
CanalProperties
Canal properties local to the NewGRF.
Definition: newgrf.h:39
CargoSpec::town_production_multiplier
uint16_t town_production_multiplier
Town production multipler, if commanded by TownProductionEffect.
Definition: cargotype.h:82
ResetBridges
void ResetBridges()
Reset the data been eventually changed by the grf loaded.
Definition: tunnelbridge_cmd.cpp:86
Utf8Decode
size_t Utf8Decode(char32_t *c, const char *s)
Decode and consume the next UTF-8 encoded character.
Definition: string.cpp:438
AllowedSubtags::data
DataHandler data
Callback function for a binary node, only valid if type == 'B'.
Definition: newgrf.cpp:8374
AirportTileTable::ti
TileIndexDiffC ti
Tile offset from the top-most airport tile.
Definition: newgrf_airport.h:26
NUM_CARGO
static const CargoID NUM_CARGO
Maximum number of cargo types in a game.
Definition: cargo_type.h:74
EngineInfo::string_id
StringID string_id
Default name of engine.
Definition: engine_type.h:158
AircraftVehicleInfo
Information about a aircraft vehicle.
Definition: engine_type.h:100
GetLanguage
const LanguageMetadata * GetLanguage(byte newgrflangid)
Get the language with the given NewGRF language ID.
Definition: strings.cpp:2044
RailTypeFlags
RailTypeFlags
Railtype flags.
Definition: rail.h:35
TileLayoutRegisters::max_sprite_offset
uint16_t max_sprite_offset
Maximum offset to add to the sprite. (limited by size of the spriteset)
Definition: newgrf_commons.h:95
AirportSpec::table
const AirportTileTable *const * table
list of the tiles composing the airport
Definition: newgrf_airport.h:102
HangarTileTable
A list of all hangar tiles in an airport.
Definition: newgrf_airport.h:91
DrawTileSeqStruct::delta_x
int8_t delta_x
0x80 is sequence terminator
Definition: sprite.h:26
CreateGroupFromGroupID
static const SpriteGroup * CreateGroupFromGroupID(byte feature, byte setid, byte type, uint16_t spriteid)
Helper function to either create a callback or a result sprite group.
Definition: newgrf.cpp:5169
PROP_TRAIN_POWER
@ PROP_TRAIN_POWER
Power in hp (if dualheaded: sum of both vehicles)
Definition: newgrf_properties.h:22
AirportTileSpec::Get
static const AirportTileSpec * Get(StationGfx gfx)
Retrieve airport tile spec for the given airport tile.
Definition: newgrf_airporttiles.cpp:37
HouseSpec::min_year
TimerGameCalendar::Year min_year
introduction year of the house
Definition: house.h:100
TownHouseChangeInfo
static ChangeInfoResult TownHouseChangeInfo(uint hid, int numinfo, int prop, ByteReader *buf)
Define properties for houses.
Definition: newgrf.cpp:2373
HouseSpec::remove_rating_decrease
uint16_t remove_rating_decrease
rating decrease if removed
Definition: house.h:105
TAE_MAIL
@ TAE_MAIL
Cargo behaves mail-like.
Definition: cargotype.h:25
IndustryOverrideManager::SetEntitySpec
void SetEntitySpec(IndustrySpec *inds)
Method to install the new industry data in its proper slot The slot assignment is internal of this me...
Definition: newgrf_commons.cpp:243
PROP_TRAIN_CARGO_AGE_PERIOD
@ PROP_TRAIN_CARGO_AGE_PERIOD
Number of ticks before carried cargo is aged.
Definition: newgrf_properties.h:30
ResetIndustries
void ResetIndustries()
This function initialize the spec arrays of both industry and industry tiles.
Definition: industry_cmd.cpp:80
VEH_SHIP
@ VEH_SHIP
Ship vehicle type.
Definition: vehicle_type.h:26
ChangeGRFPalette
static bool ChangeGRFPalette(size_t len, ByteReader *buf)
Callback function for 'INFO'->'PALS' to set the number of valid parameters.
Definition: newgrf.cpp:8134
LoadFontGlyph
static void LoadFontGlyph(ByteReader *buf)
Action 0x12.
Definition: newgrf.cpp:7991
PROP_ROADVEH_RUNNING_COST_FACTOR
@ PROP_ROADVEH_RUNNING_COST_FACTOR
Yearly runningcost.
Definition: newgrf_properties.h:33
SPR_TRACKS_FOR_SLOPES_BASE
static const SpriteID SPR_TRACKS_FOR_SLOPES_BASE
Sprites for 'highlighting' tracks on sloped land.
Definition: sprites.h:198
ResultSpriteGroup
Definition: newgrf_spritegroup.h:236
GetCargoTranslation
CargoID GetCargoTranslation(uint8_t cargo, const GRFFile *grffile, bool usebit)
Translate a GRF-local cargo slot/bitnum into a CargoID.
Definition: newgrf_cargo.cpp:79
IndustryTileSpec::anim_next
byte anim_next
Next frame in an animation.
Definition: industrytype.h:162
IndustryTileSpec
Defines the data structure of each individual tile of an industry.
Definition: industrytype.h:156
GRFLoadedFeatures
Definition: newgrf.h:177
TLF_DRAWING_FLAGS
@ TLF_DRAWING_FLAGS
Flags which are still required after loading the GRF.
Definition: newgrf_commons.h:52
TLF_PALETTE_VAR10
@ TLF_PALETTE_VAR10
Resolve palette with a specific value in variable 10.
Definition: newgrf_commons.h:47
InitRailTypes
void InitRailTypes()
Resolve sprites of custom rail types.
Definition: rail_cmd.cpp:130
CurrencySpec::prefix
std::string prefix
Prefix to apply when formatting money in this currency.
Definition: currency.h:78
CC_MAIL
@ CC_MAIL
Mail.
Definition: cargotype.h:51
RailTypeInfo::build_caption
StringID build_caption
Caption of the build vehicle GUI for this rail type.
Definition: rail.h:179
RoadVehicleInfo::max_speed
uint16_t max_speed
Maximum speed (1 unit = 1/3.2 mph = 0.5 km-ish/h)
Definition: engine_type.h:120
ClrBit
constexpr T ClrBit(T &x, const uint8_t y)
Clears a bit in a variable.
Definition: bitmath_func.hpp:151
DisableGrf
static GRFError * DisableGrf(StringID message=STR_NULL, GRFConfig *config=nullptr)
Disable a GRF.
Definition: newgrf.cpp:436
AirportTileSpec::grf_prop
GRFFileProps grf_prop
properties related the the grf file
Definition: newgrf_airporttiles.h:74
TLF_SPRITE_REG_FLAGS
@ TLF_SPRITE_REG_FLAGS
Flags which require resolving the action-1-2-3 chain for the sprite, even if it is no action-1 sprite...
Definition: newgrf_commons.h:61
InitRoadTypes
void InitRoadTypes()
Resolve sprites of custom road types.
Definition: road_cmd.cpp:114
RailTypeInfo::acceleration_type
uint8_t acceleration_type
Acceleration type of this rail type.
Definition: rail.h:226
RoadTypeInfo::build_caption
StringID build_caption
Caption of the build vehicle GUI for this rail type.
Definition: road.h:106
GrfProcessingState::skip_sprites
int skip_sprites
Number of pseudo sprites to skip before processing the next one. (-1 to skip to end of file)
Definition: newgrf.cpp:110
RailTypeInfo::replace_text
StringID replace_text
Text used in the autoreplace GUI.
Definition: rail.h:180
OpenCachedSpriteFile
SpriteFile & OpenCachedSpriteFile(const std::string &filename, Subdirectory subdir, bool palette_remap)
Open/get the SpriteFile that is cached for use in the sprite cache.
Definition: spritecache.cpp:84
ResetCustomStations
static void ResetCustomStations()
Reset and clear all NewGRF stations.
Definition: newgrf.cpp:8697
HZ_ZON1
@ HZ_ZON1
0..4 1,2,4,8,10 which town zones the building can be built in, Zone1 been the further suburb
Definition: house.h:73
TLF_SPRITE_VAR10
@ TLF_SPRITE_VAR10
Resolve sprite with a specific value in variable 10.
Definition: newgrf_commons.h:46
PROP_AIRCRAFT_RANGE
@ PROP_AIRCRAFT_RANGE
Aircraft range.
Definition: newgrf_properties.h:55
EconomySettings::allow_town_roads
bool allow_town_roads
towns are allowed to build roads (always allowed when generating world / in SE)
Definition: settings_type.h:554
GRFFile::cargo_map
std::array< uint8_t, NUM_CARGO > cargo_map
Inverse cargo translation table (CargoID -> local ID)
Definition: newgrf.h:130
BuildLinkStatsLegend
void BuildLinkStatsLegend()
Populate legend table for the link stat view.
Definition: smallmap_gui.cpp:216
ChangeGRFParamDescription
static bool ChangeGRFParamDescription(byte langid, const char *str)
Callback function for 'INFO'->'PARAM'->param_num->'DESC' to set the description of a parameter.
Definition: newgrf.cpp:8224
IndustrySpec::input_cargo_multiplier
uint16_t input_cargo_multiplier[INDUSTRY_NUM_INPUTS][INDUSTRY_NUM_OUTPUTS]
Input cargo multipliers (multiply amount of incoming cargo for the produced cargoes)
Definition: industrytype.h:122
RoadTypeInfo::introduction_required_roadtypes
RoadTypes introduction_required_roadtypes
Bitmask of roadtypes that are required for this roadtype to be introduced at a given introduction_dat...
Definition: road.h:172
ReadSpriteLayout
static bool ReadSpriteLayout(ByteReader *buf, uint num_building_sprites, bool use_cur_spritesets, byte feature, bool allow_var10, bool no_z_position, NewGRFSpriteLayout *dts)
Read a spritelayout from the GRF.
Definition: newgrf.cpp:848
TileIndexDiffC::x
int16_t x
The x value of the coordinate.
Definition: map_type.h:32
newgrf_cargo.h
SetYearEngineAgingStops
void SetYearEngineAgingStops()
Compute the value for _year_engine_aging_stops.
Definition: engine.cpp:657
GRFFile::railtype_list
std::vector< RailTypeLabel > railtype_list
Railtype translation table.
Definition: newgrf.h:132
AirportSpec::catchment
byte catchment
catchment area of this airport
Definition: newgrf_airport.h:110
RandomizedSpriteGroup::groups
std::vector< const SpriteGroup * > groups
Take the group with appropriate index:
Definition: newgrf_spritegroup.h:201
StationSpec::cargo_triggers
CargoTypes cargo_triggers
Bitmask of cargo types which cause trigger re-randomizing.
Definition: newgrf_station.h:155
ObjectSpec::clear_cost_multiplier
uint8_t clear_cost_multiplier
Clear cost multiplier per tile.
Definition: newgrf_object.h:70
SpriteGroup
Definition: newgrf_spritegroup.h:57
GRFLabel
Definition: newgrf.h:98
SkipAct12
static void SkipAct12(ByteReader *buf)
Action 0x12 (SKIP)
Definition: newgrf.cpp:8022
SPR_ONEWAY_BASE
static const SpriteID SPR_ONEWAY_BASE
One way road sprites.
Definition: sprites.h:293
HouseSpec::grf_prop
GRFFileProps grf_prop
Properties related the the grf file.
Definition: house.h:115
AddStringForMapping
static void AddStringForMapping(StringID source, StringID *target)
Record a static StringID for getting translated later.
Definition: newgrf.cpp:473
CargoSpec::multiplier
uint16_t multiplier
Capacity multiplier for vehicles. (8 fractional bits)
Definition: cargotype.h:74
ResetGenericCallbacks
void ResetGenericCallbacks()
Reset all generic feature callback sprite groups.
Definition: newgrf_generic.cpp:94
Action5Type
Information about a single action 5 type.
Definition: newgrf.cpp:6402
_currency_specs
CurrencySpec _currency_specs[CURRENCY_END]
Array of currencies used by the system.
Definition: currency.cpp:76
EngineInfo::base_intro
TimerGameCalendar::Date base_intro
Basic date of engine introduction (without random parts).
Definition: engine_type.h:145
NamePart::id
byte id
If probability bit 7 is set.
Definition: newgrf_townname.h:20
LanguageMap::Mapping::newgrf_id
byte newgrf_id
NewGRF's internal ID for a case/gender.
Definition: newgrf_text.h:56
StationSpec::wires
byte wires
Bitmask of base tiles (0 - 7) which should contain elrail wires.
Definition: newgrf_station.h:162
TAE_PASSENGERS
@ TAE_PASSENGERS
Cargo behaves passenger-like.
Definition: cargotype.h:24
AddGRFTextToList
static void AddGRFTextToList(GRFTextList &list, byte langid, const std::string &text_to_add)
Add a new text to a GRFText list.
Definition: newgrf_text.cpp:485
EngineInfo::lifelength
TimerGameCalendar::Year lifelength
Lifetime of a single vehicle.
Definition: engine_type.h:146
RoadStopSpec::cargo_triggers
CargoTypes cargo_triggers
Bitmask of cargo types which cause trigger re-randomizing.
Definition: newgrf_roadstop.h:139
SetEngineGRF
void SetEngineGRF(EngineID engine, const GRFFile *file)
Tie a GRFFile entry to an engine, to allow us to retrieve GRF parameters etc during a game.
Definition: newgrf_engine.cpp:71
OrderSettings::gradual_loading
bool gradual_loading
load vehicles gradually
Definition: settings_type.h:506
Action5Type::min_sprites
uint16_t min_sprites
If the Action5 contains less sprites, the whole block will be ignored.
Definition: newgrf.cpp:6405
GCF_STATIC
@ GCF_STATIC
GRF file is used statically (can be used in any MP game)
Definition: newgrf_config.h:25
NewGRFSpriteLayout::Allocate
void Allocate(uint num_sprites)
Allocate a spritelayout for num_sprites building sprites.
Definition: newgrf_commons.cpp:603
IndustryLifeType
IndustryLifeType
Available types of industry lifetimes.
Definition: industrytype.h:26
GRFFile
Dynamic data of a loaded NewGRF.
Definition: newgrf.h:107
ObjectSpec::cls_id
ObjectClassID cls_id
The class to which this spec belongs.
Definition: newgrf_object.h:64
PROP_TRAIN_USER_DATA
@ PROP_TRAIN_USER_DATA
User defined data for vehicle variable 0x42.
Definition: newgrf_properties.h:29
ShipVehicleInfo::ocean_speed_frac
byte ocean_speed_frac
Fraction of maximum speed for ocean tiles.
Definition: engine_type.h:77
Engine::type
VehicleType type
Vehicle type, ie VEH_ROAD, VEH_TRAIN, etc.
Definition: engine_base.h:56
IgnoreIndustryTileProperty
static ChangeInfoResult IgnoreIndustryTileProperty(int prop, ByteReader *buf)
Ignore an industry tile property.
Definition: newgrf.cpp:3193
StationSpec::blocked
byte blocked
Bitmask of base tiles (0 - 7) which are blocked to trains.
Definition: newgrf_station.h:163
debug.h
OverrideManagerBase::GetID
virtual uint16_t GetID(uint16_t grf_local_id, uint32_t grfid) const
Return the ID (if ever available) of a previously inserted entity.
Definition: newgrf_commons.cpp:90
_grm_engines
static uint32_t _grm_engines[256]
Contains the GRF ID of the owner of a vehicle if it has been reserved.
Definition: newgrf.cpp:357
TileLayoutSpriteGroup
Action 2 sprite layout for houses, industry tiles, objects and airport tiles.
Definition: newgrf_spritegroup.h:259
GRFConfig::GetName
const char * GetName() const
Get the name of this grf.
Definition: newgrf_config.cpp:98
BridgeSpec::max_length
uint16_t max_length
the maximum length (not counting start and end tile)
Definition: bridge.h:45
PROP_ROADVEH_WEIGHT
@ PROP_ROADVEH_WEIGHT
Weight in 1/4 t.
Definition: newgrf_properties.h:37
SPR_TRAMWAY_BASE
static const SpriteID SPR_TRAMWAY_BASE
Tramway sprites.
Definition: sprites.h:272
engine_func.h
AddGenericCallback
void AddGenericCallback(uint8_t feature, const GRFFile *file, const SpriteGroup *group)
Add a generic feature callback sprite group to the appropriate feature list.
Definition: newgrf_generic.cpp:108
AirportTileSpec::animation
AnimationInfo animation
Information about the animation.
Definition: newgrf_airporttiles.h:69
EC_MONORAIL
@ EC_MONORAIL
Mono rail engine.
Definition: engine_type.h:37
GRFError::data
std::string data
Additional data for message and custom_message.
Definition: newgrf_config.h:113
WaterFeature::group
const SpriteGroup * group
Sprite group to start resolving.
Definition: newgrf_canal.h:23
CargoSpec::classes
uint16_t classes
Classes of this cargo type.
Definition: cargotype.h:75
TimerGameCalendar::year
static Year year
Current year, starting at 0.
Definition: timer_game_calendar.h:32
INVALID_RAILTYPE
@ INVALID_RAILTYPE
Flag for invalid railtype.
Definition: rail_type.h:34
DrawTileSeqStruct
A tile child sprite and palette to draw for stations etc, with 3D bounding box.
Definition: sprite.h:25
TileLayoutRegisters::palette_var10
uint8_t palette_var10
Value for variable 10 when resolving the palette.
Definition: newgrf_commons.h:102
ObjectSpec::flags
ObjectFlags flags
Flags/settings related to the object.
Definition: newgrf_object.h:73
RoadTypeChangeInfo
static ChangeInfoResult RoadTypeChangeInfo(uint id, int numinfo, int prop, ByteReader *buf, RoadTramType rtt)
Define properties for roadtypes.
Definition: newgrf.cpp:4470
HouseOverrideManager::SetEntitySpec
void SetEntitySpec(const HouseSpec *hs)
Install the specs into the HouseSpecs array It will find itself the proper slot on which it will go.
Definition: newgrf_commons.cpp:159
ObjectSpec::views
uint8_t views
The number of views.
Definition: newgrf_object.h:76
StringIDMapping::grfid
uint32_t grfid
Source NewGRF.
Definition: newgrf.cpp:461
GRFFile::grf_features
uint32_t grf_features
Bitset of GrfSpecFeature the grf uses.
Definition: newgrf.h:148
TimerGameEconomy::date
static Date date
Current date in days (day counter).
Definition: timer_game_economy.h:37
SNOW_LINE_MONTHS
static const uint SNOW_LINE_MONTHS
Number of months in the snow line table.
Definition: landscape.h:16
CargoSpec::town_acceptance_effect
TownAcceptanceEffect town_acceptance_effect
The effect that delivering this cargo type has on towns. Also affects destination of subsidies.
Definition: cargotype.h:80
ReadSpriteLayoutRegisters
static void ReadSpriteLayoutRegisters(ByteReader *buf, TileLayoutFlags flags, bool is_parent, NewGRFSpriteLayout *dts, uint index)
Preprocess the TileLayoutFlags and read register modifiers from the GRF.
Definition: newgrf.cpp:795
GRFP_BLT_MASK
@ GRFP_BLT_MASK
Bitmask to only get the blitter information.
Definition: newgrf_config.h:78
FindFirstBit
constexpr uint8_t FindFirstBit(T x)
Search the first set bit in a value.
Definition: bitmath_func.hpp:194
HasBit
constexpr debug_inline bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103