OpenTTD Source 20250218-master-g53dd1258a7
newgrf_roadstop.cpp
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#include "debug.h"
12#include "station_base.h"
13#include "roadstop_base.h"
14#include "newgrf_badge.h"
15#include "newgrf_roadstop.h"
16#include "newgrf_class_func.h"
17#include "newgrf_cargo.h"
18#include "newgrf_roadtype.h"
19#include "gfx_type.h"
20#include "company_func.h"
21#include "road.h"
22#include "window_type.h"
24#include "town.h"
25#include "viewport_func.h"
27#include "newgrf_sound.h"
28
29#include "safeguards.h"
30
31template <>
33{
34 /* Set up initial data */
35 RoadStopClass::Get(RoadStopClass::Allocate(ROADSTOP_CLASS_LABEL_DEFAULT))->name = STR_STATION_CLASS_DFLT;
36 RoadStopClass::Get(RoadStopClass::Allocate(ROADSTOP_CLASS_LABEL_DEFAULT))->Insert(nullptr);
37 RoadStopClass::Get(RoadStopClass::Allocate(ROADSTOP_CLASS_LABEL_WAYPOINT))->name = STR_STATION_CLASS_WAYP;
38 RoadStopClass::Get(RoadStopClass::Allocate(ROADSTOP_CLASS_LABEL_WAYPOINT))->Insert(nullptr);
39}
40
41template <>
42bool RoadStopClass::IsUIAvailable(uint) const
43{
44 return true;
45}
46
47/* Instantiate RoadStopClass. */
49
50static const uint NUM_ROADSTOPSPECS_PER_STATION = 63;
51
53{
54 if (this->st == nullptr) return 0;
55
56 uint32_t bits = this->st->random_bits;
57 if (this->tile != INVALID_TILE && Station::IsExpected(this->st)) {
58 bits |= Station::From(this->st)->GetRoadStopRandomBits(this->tile) << 16;
59 }
60 return bits;
61}
62
64{
65 return this->st == nullptr ? 0 : this->st->waiting_triggers;
66}
67
68uint32_t RoadStopScopeResolver::GetVariable(uint8_t variable, [[maybe_unused]] uint32_t parameter, bool &available) const
69{
70 auto get_road_type_variable = [&](RoadTramType rtt) -> uint32_t {
71 RoadType rt;
72 if (this->tile == INVALID_TILE) {
73 rt = (GetRoadTramType(this->roadtype) == rtt) ? this->roadtype : INVALID_ROADTYPE;
74 } else {
75 rt = GetRoadType(this->tile, rtt);
76 }
77 if (rt == INVALID_ROADTYPE) {
78 return 0xFFFFFFFF;
79 } else {
81 }
82 };
83
84 switch (variable) {
85 /* View/rotation */
86 case 0x40: return this->view;
87
88 /* Stop type: 0: bus, 1: truck, 2: waypoint */
89 case 0x41:
90 if (this->type == StationType::Bus) return 0;
91 if (this->type == StationType::Truck) return 1;
92 return 2;
93
94 /* Terrain type */
95 case 0x42: return this->tile == INVALID_TILE ? 0 : (GetTileSlope(this->tile) << 8 | GetTerrainType(this->tile, TCX_NORMAL));
96
97 /* Road type */
98 case 0x43: return get_road_type_variable(RTT_ROAD);
99
100 /* Tram type */
101 case 0x44: return get_road_type_variable(RTT_TRAM);
102
103 /* Town zone and Manhattan distance of closest town */
104 case 0x45: {
105 if (this->tile == INVALID_TILE) return HZB_TOWN_EDGE << 16;
106 const Town *t = (this->st == nullptr) ? ClosestTownFromTile(this->tile, UINT_MAX) : this->st->town;
107 return t != nullptr ? (GetTownRadiusGroup(t, this->tile) << 16 | ClampTo<uint16_t>(DistanceManhattan(this->tile, t->xy))) : HZB_TOWN_EDGE << 16;
108 }
109
110 /* Get square of Euclidean distance of closest town */
111 case 0x46: {
112 if (this->tile == INVALID_TILE) return 0;
113 const Town *t = (this->st == nullptr) ? ClosestTownFromTile(this->tile, UINT_MAX) : this->st->town;
114 return t != nullptr ? DistanceSquare(this->tile, t->xy) : 0;
115 }
116
117 /* Company information */
118 case 0x47: return GetCompanyInfo(this->st == nullptr ? _current_company : this->st->owner);
119
120 /* Animation frame */
121 case 0x49: return this->tile == INVALID_TILE ? 0 : this->st->GetRoadStopAnimationFrame(this->tile);
122
123 /* Misc info */
124 case 0x50: {
125 uint32_t result = 0;
126 if (this->tile == INVALID_TILE) {
127 SetBit(result, 4);
128 }
129 return result;
130 }
131
132 /* Variables which use the parameter */
133 /* Variables 0x60 to 0x65 and 0x69 are handled separately below */
134
135 /* Animation frame of nearby tile */
136 case 0x66: {
137 if (this->tile == INVALID_TILE) return UINT_MAX;
138 TileIndex tile = this->tile;
139 if (parameter != 0) tile = GetNearbyTile(parameter, tile);
140 return (IsAnyRoadStopTile(tile) && GetStationIndex(tile) == this->st->index) ? this->st->GetRoadStopAnimationFrame(tile) : UINT_MAX;
141 }
142
143 /* Land info of nearby tile */
144 case 0x67: {
145 if (this->tile == INVALID_TILE) return 0;
146 TileIndex tile = this->tile;
147 if (parameter != 0) tile = GetNearbyTile(parameter, tile); // only perform if it is required
148 return GetNearbyTileInformation(tile, this->ro.grffile->grf_version >= 8);
149 }
150
151 /* Road stop info of nearby tiles */
152 case 0x68: {
153 if (this->tile == INVALID_TILE) return 0xFFFFFFFF;
154 TileIndex nearby_tile = GetNearbyTile(parameter, this->tile);
155
156 if (!IsAnyRoadStopTile(nearby_tile)) return 0xFFFFFFFF;
157
158 uint32_t grfid = this->st->roadstop_speclist[GetCustomRoadStopSpecIndex(this->tile)].grfid;
159 bool same_orientation = GetStationGfx(this->tile) == GetStationGfx(nearby_tile);
160 bool same_station = GetStationIndex(nearby_tile) == this->st->index;
161 uint32_t res = GetStationGfx(nearby_tile) << 12 | !same_orientation << 11 | !!same_station << 10;
162 StationType type = GetStationType(nearby_tile);
163 if (type == StationType::Truck) res |= (1 << 16);
164 if (type == StationType::RoadWaypoint) res |= (2 << 16);
165 if (type == this->type) SetBit(res, 20);
166
167 if (IsCustomRoadStopSpecIndex(nearby_tile)) {
168 const auto &sm = BaseStation::GetByTile(nearby_tile)->roadstop_speclist[GetCustomRoadStopSpecIndex(nearby_tile)];
169 res |= 1 << (sm.grfid != grfid ? 9 : 8) | ClampTo<uint8_t>(sm.localidx);
170 }
171 return res;
172 }
173
174 /* GRFID of nearby road stop tiles */
175 case 0x6A: {
176 if (this->tile == INVALID_TILE) return 0xFFFFFFFF;
177 TileIndex nearby_tile = GetNearbyTile(parameter, this->tile);
178
179 if (!IsAnyRoadStopTile(nearby_tile)) return 0xFFFFFFFF;
180 if (!IsCustomRoadStopSpecIndex(nearby_tile)) return 0;
181
182 const auto &sm = BaseStation::GetByTile(nearby_tile)->roadstop_speclist[GetCustomRoadStopSpecIndex(nearby_tile)];
183 return sm.grfid;
184 }
185
186 /* 16 bit road stop ID of nearby tiles */
187 case 0x6B: {
188 if (this->tile == INVALID_TILE) return 0xFFFFFFFF;
189 TileIndex nearby_tile = GetNearbyTile(parameter, this->tile);
190
191 if (!IsAnyRoadStopTile(nearby_tile)) return 0xFFFFFFFF;
192 if (!IsCustomRoadStopSpecIndex(nearby_tile)) return 0xFFFE;
193
194 uint32_t grfid = this->st->roadstop_speclist[GetCustomRoadStopSpecIndex(this->tile)].grfid;
195
196 const auto &sm = BaseStation::GetByTile(nearby_tile)->roadstop_speclist[GetCustomRoadStopSpecIndex(nearby_tile)];
197 if (sm.grfid == grfid) {
198 return sm.localidx;
199 }
200
201 return 0xFFFE;
202 }
203
204 case 0x7A: return GetBadgeVariableResult(*this->ro.grffile, this->roadstopspec->badges, parameter);
205
206 case 0xF0: return this->st == nullptr ? 0 : this->st->facilities.base(); // facilities
207
208 case 0xFA: return ClampTo<uint16_t>((this->st == nullptr ? TimerGameCalendar::date : this->st->build_date) - CalendarTime::DAYS_TILL_ORIGINAL_BASE_YEAR); // build date
209 }
210
211 if (this->st != nullptr) return this->st->GetNewGRFVariable(this->ro, variable, parameter, available);
212
213 available = false;
214 return UINT_MAX;
215}
216
218{
219 if (group == nullptr) return nullptr;
220
221 return group->loading[0];
222}
223
224RoadStopResolverObject::RoadStopResolverObject(const RoadStopSpec *roadstopspec, BaseStation *st, TileIndex tile, RoadType roadtype, StationType type, uint8_t view,
225 CallbackID callback, uint32_t param1, uint32_t param2)
226 : ResolverObject(roadstopspec->grf_prop.grffile, callback, param1, param2), roadstop_scope(*this, st, roadstopspec, tile, roadtype, type, view)
227{
229
230 if (st == nullptr) {
231 /* No station, so we are in a purchase list */
233 this->root_spritegroup = roadstopspec->grf_prop.GetSpriteGroup(ctype);
234 } else if (Station::IsExpected(st)) {
235 const Station *station = Station::From(st);
236 /* Pick the first cargo that we have waiting */
237 for (const auto &[cargo, spritegroup] : roadstopspec->grf_prop.spritegroups) {
238 if (cargo < NUM_CARGO && station->goods[cargo].HasData() && station->goods[cargo].GetData().cargo.TotalCount() > 0) {
239 ctype = cargo;
240 this->root_spritegroup = spritegroup;
241 break;
242 }
243 }
244
245 if (this->root_spritegroup == nullptr) {
247 this->root_spritegroup = roadstopspec->grf_prop.GetSpriteGroup(ctype);
248 }
249 }
250
251 if (this->root_spritegroup == nullptr) {
253 this->root_spritegroup = roadstopspec->grf_prop.GetSpriteGroup(ctype);
254 }
255
256 /* Remember the cargo type we've picked */
257 this->roadstop_scope.cargo_type = ctype;
258}
259
260TownScopeResolver *RoadStopResolverObject::GetTown()
261{
262 if (!this->town_scope.has_value()) {
263 Town *t;
264 if (this->roadstop_scope.st != nullptr) {
265 t = this->roadstop_scope.st->town;
266 } else {
267 t = ClosestTownFromTile(this->roadstop_scope.tile, UINT_MAX);
268 }
269 if (t == nullptr) return nullptr;
270 this->town_scope.emplace(*this, t, this->roadstop_scope.st == nullptr);
271 }
272 return &*this->town_scope;
273}
274
275uint16_t GetRoadStopCallback(CallbackID callback, uint32_t param1, uint32_t param2, const RoadStopSpec *roadstopspec, BaseStation *st, TileIndex tile, RoadType roadtype, StationType type, uint8_t view)
276{
277 RoadStopResolverObject object(roadstopspec, st, tile, roadtype, type, view, callback, param1, param2);
278 return object.ResolveCallback();
279}
280
290void DrawRoadStopTile(int x, int y, RoadType roadtype, const RoadStopSpec *spec, StationType type, int view)
291{
292 assert(roadtype != INVALID_ROADTYPE);
293 assert(spec != nullptr);
294
295 const RoadTypeInfo *rti = GetRoadTypeInfo(roadtype);
296 RoadStopResolverObject object(spec, nullptr, INVALID_TILE, roadtype, type, view);
297 const SpriteGroup *group = object.Resolve();
298 if (group == nullptr || group->type != SGT_TILELAYOUT) return;
299 const DrawTileSprites *dts = ((const TileLayoutSpriteGroup *)group)->ProcessRegisters(nullptr);
300
301 PaletteID palette = COMPANY_SPRITE_COLOUR(_local_company);
302
303 SpriteID image = dts->ground.sprite;
304 PaletteID pal = dts->ground.pal;
305
306 RoadStopDrawModes draw_mode;
307 if (spec->flags.Test(RoadStopSpecFlag::DrawModeRegister)) {
308 draw_mode = static_cast<RoadStopDrawMode>(GetRegister(0x100));
309 } else {
310 draw_mode = spec->draw_mode;
311 }
312
313 if (type == StationType::RoadWaypoint) {
314 DrawSprite(SPR_ROAD_PAVED_STRAIGHT_X, PAL_NONE, x, y);
315 if (draw_mode.Test(RoadStopDrawMode::WaypGround) && GB(image, 0, SPRITE_WIDTH) != 0) {
316 DrawSprite(image, GroundSpritePaletteTransform(image, pal, palette), x, y);
317 }
318 } else if (GB(image, 0, SPRITE_WIDTH) != 0) {
319 DrawSprite(image, GroundSpritePaletteTransform(image, pal, palette), x, y);
320 }
321
322 if (view >= 4) {
323 /* Drive-through stop */
324 uint sprite_offset = 5 - view;
325
326 /* Road underlay takes precedence over tram */
327 if (type == StationType::RoadWaypoint || draw_mode.Test(RoadStopDrawMode::Overlay)) {
328 if (rti->UsesOverlay()) {
330 DrawSprite(ground + sprite_offset, PAL_NONE, x, y);
331
333 if (overlay) DrawSprite(overlay + sprite_offset, PAL_NONE, x, y);
334 } else if (RoadTypeIsTram(roadtype)) {
335 DrawSprite(SPR_TRAMWAY_TRAM + sprite_offset, PAL_NONE, x, y);
336 }
337 }
338 } else {
339 /* Bay stop */
340 if (draw_mode.Test(RoadStopDrawMode::Road) && rti->UsesOverlay()) {
342 DrawSprite(ground + view, PAL_NONE, x, y);
343 }
344 }
345
346 DrawCommonTileSeqInGUI(x, y, dts, 0, 0, palette, true);
347}
348
350uint16_t GetAnimRoadStopCallback(CallbackID callback, uint32_t param1, uint32_t param2, const RoadStopSpec *roadstopspec, BaseStation *st, TileIndex tile, int)
351{
352 return GetRoadStopCallback(callback, param1, param2, roadstopspec, st, tile, INVALID_ROADTYPE, GetStationType(tile), GetStationGfx(tile));
353}
354
356 static uint8_t Get(BaseStation *st, TileIndex tile) { return st->GetRoadStopAnimationFrame(tile); }
357 static bool Set(BaseStation *st, TileIndex tile, uint8_t frame) { return st->SetRoadStopAnimationFrame(tile, frame); }
358};
359
368
369void AnimateRoadStopTile(TileIndex tile)
370{
371 const RoadStopSpec *ss = GetRoadStopSpec(tile);
372 if (ss == nullptr) return;
373
375}
376
377void TriggerRoadStopAnimation(BaseStation *st, TileIndex trigger_tile, StationAnimationTrigger trigger, CargoType cargo_type)
378{
379 /* Get Station if it wasn't supplied */
380 if (st == nullptr) st = BaseStation::GetByTile(trigger_tile);
381
382 /* Check the cached animation trigger bitmask to see if we need
383 * to bother with any further processing. */
384 if (!HasBit(st->cached_roadstop_anim_triggers, trigger)) return;
385
386 uint16_t random_bits = Random();
387 auto process_tile = [&](TileIndex cur_tile) {
388 const RoadStopSpec *ss = GetRoadStopSpec(cur_tile);
389 if (ss != nullptr && HasBit(ss->animation.triggers, trigger)) {
390 CargoType cargo;
391 if (!IsValidCargoType(cargo_type)) {
392 cargo = INVALID_CARGO;
393 } else {
394 cargo = ss->grf_prop.grffile->cargo_map[cargo_type];
395 }
396 RoadStopAnimationBase::ChangeAnimationFrame(CBID_STATION_ANIM_START_STOP, ss, st, cur_tile, (random_bits << 16) | Random(), (uint8_t)trigger | (cargo << 8));
397 }
398 };
399
400 if (trigger == SAT_NEW_CARGO || trigger == SAT_CARGO_TAKEN || trigger == SAT_250_TICKS) {
401 for (const RoadStopTileData &tile_data : st->custom_roadstop_tile_data) {
402 process_tile(tile_data.tile);
403 }
404 } else {
405 process_tile(trigger_tile);
406 }
407}
408
417void TriggerRoadStopRandomisation(Station *st, TileIndex tile, RoadStopRandomTrigger trigger, CargoType cargo_type)
418{
419 if (st == nullptr) st = Station::GetByTile(tile);
420
421 /* Check the cached cargo trigger bitmask to see if we need
422 * to bother with any further processing. */
423 if (st->cached_roadstop_cargo_triggers == 0) return;
424 if (IsValidCargoType(cargo_type) && !HasBit(st->cached_roadstop_cargo_triggers, cargo_type)) return;
425
426 SetBit(st->waiting_triggers, trigger);
427
428 uint32_t whole_reseed = 0;
429
430 /* Bitmask of completely empty cargo types to be matched. */
431 CargoTypes empty_mask = (trigger == RSRT_CARGO_TAKEN) ? GetEmptyMask(st) : 0;
432
433 uint32_t used_triggers = 0;
434 auto process_tile = [&](TileIndex cur_tile) {
435 const RoadStopSpec *ss = GetRoadStopSpec(cur_tile);
436 if (ss == nullptr) return;
437
438 /* Cargo taken "will only be triggered if all of those
439 * cargo types have no more cargo waiting." */
440 if (trigger == RSRT_CARGO_TAKEN) {
441 if ((ss->cargo_triggers & ~empty_mask) != 0) return;
442 }
443
444 if (!IsValidCargoType(cargo_type) || HasBit(ss->cargo_triggers, cargo_type)) {
445 RoadStopResolverObject object(ss, st, cur_tile, INVALID_ROADTYPE, GetStationType(cur_tile), GetStationGfx(cur_tile));
446 object.waiting_triggers = st->waiting_triggers;
447
448 const SpriteGroup *group = object.Resolve();
449 if (group == nullptr) return;
450
451 used_triggers |= object.used_triggers;
452
453 uint32_t reseed = object.GetReseedSum();
454 if (reseed != 0) {
455 whole_reseed |= reseed;
456 reseed >>= 16;
457
458 /* Set individual tile random bits */
459 uint8_t random_bits = st->GetRoadStopRandomBits(cur_tile);
460 random_bits &= ~reseed;
461 random_bits |= Random() & reseed;
462 st->SetRoadStopRandomBits(cur_tile, random_bits);
463
464 MarkTileDirtyByTile(cur_tile);
465 }
466 }
467 };
468 if (trigger == RSRT_NEW_CARGO || trigger == RSRT_CARGO_TAKEN) {
469 for (const RoadStopTileData &tile_data : st->custom_roadstop_tile_data) {
470 process_tile(tile_data.tile);
471 }
472 } else {
473 process_tile(tile);
474 }
475
476 /* Update whole station random bits */
477 st->waiting_triggers &= ~used_triggers;
478 if ((whole_reseed & 0xFFFF) != 0) {
479 st->random_bits &= ~whole_reseed;
480 st->random_bits |= Random() & whole_reseed;
481 }
482}
483
490bool GetIfNewStopsByType(RoadStopType rs, RoadType roadtype)
491{
492 for (const auto &cls : RoadStopClass::Classes()) {
493 /* Ignore the waypoint class. */
494 if (IsWaypointClass(cls)) continue;
495 /* Ignore the default class with only the default station. */
496 if (cls.Index() == ROADSTOP_CLASS_DFLT && cls.GetSpecCount() == 1) continue;
497 if (GetIfClassHasNewStopsByType(&cls, rs, roadtype)) return true;
498 }
499 return false;
500}
501
509bool GetIfClassHasNewStopsByType(const RoadStopClass *roadstopclass, RoadStopType rs, RoadType roadtype)
510{
511 for (const auto spec : roadstopclass->Specs()) {
512 if (GetIfStopIsForType(spec, rs, roadtype)) return true;
513 }
514 return false;
515}
516
524bool GetIfStopIsForType(const RoadStopSpec *roadstopspec, RoadStopType rs, RoadType roadtype)
525{
526 // The roadstopspec is nullptr, must be the default station, always return true.
527 if (roadstopspec == nullptr) return true;
528
529 if (roadstopspec->flags.Test(RoadStopSpecFlag::RoadOnly) && !RoadTypeIsRoad(roadtype)) return false;
530 if (roadstopspec->flags.Test(RoadStopSpecFlag::TramOnly) && !RoadTypeIsTram(roadtype)) return false;
531
532 if (roadstopspec->stop_type == ROADSTOPTYPE_ALL) return true;
533
534 switch (rs) {
536 if (roadstopspec->stop_type == ROADSTOPTYPE_PASSENGER) return true;
537 break;
538
540 if (roadstopspec->stop_type == ROADSTOPTYPE_FREIGHT) return true;
541 break;
542
543 default:
544 NOT_REACHED();
545 }
546 return false;
547}
548
549const RoadStopSpec *GetRoadStopSpec(TileIndex t)
550{
551 if (!IsCustomRoadStopSpecIndex(t)) return nullptr;
552
553 const BaseStation *st = BaseStation::GetByTile(t);
554 uint specindex = GetCustomRoadStopSpecIndex(t);
555 return specindex < st->roadstop_speclist.size() ? st->roadstop_speclist[specindex].spec : nullptr;
556}
557
558int AllocateSpecToRoadStop(const RoadStopSpec *statspec, BaseStation *st, bool exec)
559{
560 uint i;
561
562 if (statspec == nullptr || st == nullptr) return 0;
563
564 /* Try to find the same spec and return that one */
565 for (i = 1; i < st->roadstop_speclist.size() && i < NUM_ROADSTOPSPECS_PER_STATION; i++) {
566 if (st->roadstop_speclist[i].spec == statspec) return i;
567 }
568
569 /* Try to find an unused spec slot */
570 for (i = 1; i < st->roadstop_speclist.size() && i < NUM_ROADSTOPSPECS_PER_STATION; i++) {
571 if (st->roadstop_speclist[i].spec == nullptr && st->roadstop_speclist[i].grfid == 0) break;
572 }
573
574 if (i == NUM_ROADSTOPSPECS_PER_STATION) {
575 /* Full, give up */
576 return -1;
577 }
578
579 if (exec) {
580 if (i >= st->roadstop_speclist.size()) st->roadstop_speclist.resize(i + 1);
581 st->roadstop_speclist[i].spec = statspec;
582 st->roadstop_speclist[i].grfid = statspec->grf_prop.grfid;
583 st->roadstop_speclist[i].localidx = statspec->grf_prop.local_id;
584
585 RoadStopUpdateCachedTriggers(st);
586 }
587
588 return i;
589}
590
591void DeallocateSpecFromRoadStop(BaseStation *st, uint8_t specindex)
592{
593 /* specindex of 0 (default) is never freeable */
594 if (specindex == 0) return;
595
596 /* Check custom road stop tiles if the specindex is still in use */
597 for (const RoadStopTileData &tile_data : st->custom_roadstop_tile_data) {
598 if (GetCustomRoadStopSpecIndex(tile_data.tile) == specindex) {
599 return;
600 }
601 }
602
603 /* This specindex is no longer in use, so deallocate it */
604 st->roadstop_speclist[specindex].spec = nullptr;
605 st->roadstop_speclist[specindex].grfid = 0;
606 st->roadstop_speclist[specindex].localidx = 0;
607
608 /* If this was the highest spec index, reallocate */
609 if (specindex == st->roadstop_speclist.size() - 1) {
610 size_t num_specs;
611 for (num_specs = st->roadstop_speclist.size() - 1; num_specs > 0; num_specs--) {
612 if (st->roadstop_speclist[num_specs].grfid != 0) break;
613 }
614
615 if (num_specs > 0) {
616 st->roadstop_speclist.resize(num_specs + 1);
617 } else {
618 st->roadstop_speclist.clear();
621 return;
622 }
623 }
624
625 RoadStopUpdateCachedTriggers(st);
626}
627
632void RoadStopUpdateCachedTriggers(BaseStation *st)
633{
636
637 /* Combine animation trigger bitmask for all road stop specs
638 * of this station. */
639 for (const auto &sm : GetStationSpecList<RoadStopSpec>(st)) {
640 if (sm.spec == nullptr) continue;
641 st->cached_roadstop_anim_triggers |= sm.spec->animation.triggers;
642 st->cached_roadstop_cargo_triggers |= sm.spec->cargo_triggers;
643 }
644}
debug_inline constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
debug_inline static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
uint8_t CargoType
Cargo slots to indicate a cargo type within a game.
Definition cargo_type.h:23
bool IsValidCargoType(CargoType t)
Test whether cargo type is not INVALID_CARGO.
Definition cargo_type.h:106
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
constexpr Tstorage base() const noexcept
Retrieve the raw value behind this bit set.
Struct containing information relating to NewGRF classes for stations and airports.
static std::span< NewGRFClass< Tspec, Tindex, Tmax > const > Classes()
Get read-only span of all classes of this type.
StringID name
Name of this class.
bool IsUIAvailable(uint index) const
Check whether the spec will be available to the user at some point in time.
void Insert(Tspec *spec)
Insert a spec into the class, and update its index.
std::span< Tspec *const > Specs() const
Get read-only span of specs of this class.
static NewGRFClass * Get(Tindex class_index)
Get a particular class.
static Tindex Allocate(uint32_t global_id)
Allocate a class with a given global class ID.
static void InsertDefaults()
Initialise the defaults.
uint TotalCount() const
Returns total count of cargo at the station, including cargo which is already reserved for loading.
static Date date
Current date in days (day counter).
static constexpr TimerGame< struct Calendar >::Date DAYS_TILL_ORIGINAL_BASE_YEAR
The date of the first day of the original base year.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
CompanyID _current_company
Company currently doing an action.
Functions related to companies.
Functions related to debugging.
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
Draw a sprite, not in a viewport.
Definition gfx.cpp:988
Types related to the graphics and/or input devices.
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition gfx_type.h:17
uint32_t PaletteID
The number of the palette.
Definition gfx_type.h:18
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
@ Random
Randomise borders.
uint DistanceSquare(TileIndex t0, TileIndex t1)
Gets the 'Square' distance between the two given tiles.
Definition map.cpp:160
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
Definition map.cpp:143
static constexpr CargoType SG_PURCHASE
Used in purchase lists before an item exists.
static constexpr CargoType SG_DEFAULT
Default type used when no more-specific cargo matches.
static constexpr CargoType SG_DEFAULT_NA
Used only by stations and roads when no more-specific cargo matches.
Function implementations related to NewGRF animation.
StationAnimationTrigger
Animation triggers for station.
@ SAT_CARGO_TAKEN
Trigger station when cargo is completely taken.
@ SAT_NEW_CARGO
Trigger station on new cargo arrival.
@ SAT_250_TICKS
Trigger station every 250 ticks.
uint32_t GetBadgeVariableResult(const GRFFile &grffile, std::span< const BadgeID > badges, uint32_t parameter)
Test for a matching badge in a list of badges, returning the number of matching bits.
Functions related to NewGRF badges.
CallbackID
List of implemented NewGRF callbacks.
@ CBID_STATION_ANIMATION_SPEED
Called to indicate how long the current animation frame should last.
@ CBID_STATION_ANIM_START_STOP
Called for periodically starting or stopping the animation.
@ CBID_STATION_ANIM_NEXT_FRAME
Called to determine station tile next animation frame.
RoadStopCallbackMask
Callback masks for road stops.
@ AnimationNextFrame
Use a custom next frame callback.
@ AnimationSpeed
Customize the animation speed of the road stop.
Cargo support for NewGRFs.
Implementation of the NewGRF class' functions.
uint32_t GetCompanyInfo(CompanyID owner, const Livery *l)
Returns company information like in vehicle var 43 or station var 43.
uint32_t GetNearbyTileInformation(TileIndex tile, bool grf_version8)
Common part of station var 0x67, house var 0x62, indtile var 0x60, industry var 0x62.
uint32_t GetTerrainType(TileIndex tile, TileContext context)
Function used by houses (and soon industries) to get information on type of "terrain" the tile it is ...
TileIndex GetNearbyTile(uint8_t parameter, TileIndex tile, bool signed_offsets, Axis axis)
Get the tile at the given offset.
@ TCX_NORMAL
Nothing special.
NewGRF definitions and structures for road stops.
RoadStopDrawMode
Different draw modes to disallow rendering of some parts of the stop or road.
@ Overlay
Drive-through stops: Draw the road overlay, e.g. pavement.
@ WaypGround
Waypoints: Draw the sprite layout ground tile (on top of the road)
@ Road
Bay stops: Draw the road itself.
bool IsWaypointClass(const RoadStopClass &cls)
Test if a RoadStopClass is the waypoint class.
RoadStopRandomTrigger
@ RSRT_CARGO_TAKEN
Trigger roadstop when cargo is completely taken.
@ RSRT_NEW_CARGO
Trigger roadstop on arrival of new cargo.
@ ROADSTOP_CLASS_DFLT
Default road stop class.
@ ROADSTOPTYPE_FREIGHT
This RoadStop is for freight (truck) stops.
@ ROADSTOPTYPE_ALL
This RoadStop is for both types of station road stops.
@ ROADSTOPTYPE_PASSENGER
This RoadStop is for passenger (bus) stops.
@ RoadOnly
Only show in the road build menu (not tram).
@ Cb141RandomBits
Callback 141 needs random bits.
@ TramOnly
Only show in the tram build menu (not road).
@ DrawModeRegister
Read draw mode from register 0x100.
SpriteID GetCustomRoadSprite(const RoadTypeInfo *rti, TileIndex tile, RoadTypeSpriteGroup rtsg, TileContext context, uint *num_results)
Get the sprite to draw for the given tile.
uint8_t GetReverseRoadTypeTranslation(RoadType roadtype, const GRFFile *grffile)
Perform a reverse roadtype lookup to get the GRF internal ID.
NewGRF handling of road types.
Functions related to NewGRF provided sounds.
uint32_t GetRegister(uint i)
Gets the value of a so-called newgrf "register".
Road specific functions.
const RoadTypeInfo * GetRoadTypeInfo(RoadType roadtype)
Returns a pointer to the Roadtype information for a given roadtype.
Definition road.h:220
@ ROTSG_OVERLAY
Optional: Images for overlaying track.
Definition road.h:52
@ ROTSG_ROADSTOP
Required: Bay stop surface.
Definition road.h:61
@ ROTSG_GROUND
Required: Main group of ground images.
Definition road.h:53
RoadType
The different roadtypes we support.
Definition road_type.h:25
@ INVALID_ROADTYPE
flag for invalid roadtype
Definition road_type.h:30
Base class for roadstops.
A number of safeguards to prevent using unsafe methods.
void DrawCommonTileSeqInGUI(int x, int y, const DrawTileSprites *dts, int32_t orig_offset, uint32_t newgrf_offset, PaletteID default_palette, bool child_offset_is_unsigned)
Draws a tile sprite sequence in the GUI.
Definition sprite.cpp:91
PaletteID GroundSpritePaletteTransform(SpriteID image, PaletteID pal, PaletteID default_pal)
Applies PALETTE_MODIFIER_COLOUR to a palette entry of a ground sprite.
Definition sprite.h:174
static constexpr uint8_t SPRITE_WIDTH
number of bits for the sprite number
Definition sprites.h:1535
Base classes/functions for stations.
CargoTypes GetEmptyMask(const Station *st)
Get a mask of the cargo types that are empty at the station.
StationType GetStationType(Tile t)
Get the station type of this tile.
Definition station_map.h:44
StationGfx GetStationGfx(Tile t)
Get the station graphics of this tile.
Definition station_map.h:68
uint GetCustomRoadStopSpecIndex(Tile t)
Get the custom road stop spec for this tile.
StationID GetStationIndex(Tile t)
Get StationID from a tile.
Definition station_map.h:28
bool IsCustomRoadStopSpecIndex(Tile t)
Is there a custom road stop spec on this tile?
bool IsAnyRoadStopTile(Tile t)
Is tile t a road stop station?
RoadStopType
Types of RoadStops.
@ Bus
A standard stop for buses.
@ Truck
A standard stop for trucks.
StationType
Station types.
Definition of base types and functions in a cross-platform compatible way.
Helper class for a unified approach to NewGRF animation.
static void AnimateTile(const RoadStopSpec *spec, BaseStation *obj, TileIndex tile, bool random_animation, int extra_data=0)
Animate a single tile.
static void ChangeAnimationFrame(CallbackID cb, const RoadStopSpec *spec, BaseStation *obj, TileIndex tile, uint32_t random_bits, uint32_t trigger, int extra_data=0)
Check a callback to determine what the next animation step is and execute that step.
uint16_t triggers
The triggers that trigger animation.
Base class for all station-ish types.
virtual uint32_t GetNewGRFVariable(const struct ResolverObject &object, uint8_t variable, uint8_t parameter, bool &available) const =0
Helper function to get a NewGRF variable that isn't implemented by the base class.
std::vector< SpecMapping< RoadStopSpec > > roadstop_speclist
List of road stop specs of this station.
StationFacilities facilities
The facilities that this station has.
uint8_t cached_roadstop_anim_triggers
NOSAVE: Combined animation trigger bitmask for road stops, used to determine if trigger processing sh...
Owner owner
The owner of this station.
Town * town
The town this station is associated with.
static BaseStation * GetByTile(TileIndex tile)
Get the base station belonging to a specific tile.
CargoTypes cached_roadstop_cargo_triggers
NOSAVE: Combined cargo trigger bitmask for road stops.
uint16_t random_bits
Random bits assigned to this station.
std::vector< RoadStopTileData > custom_roadstop_tile_data
List of custom road stop tile data.
uint8_t waiting_triggers
Waiting triggers (NewGRF) for this station.
TimerGameCalendar::Date build_date
Date of construction.
Ground palette sprite of a tile, together with its sprite layout.
Definition sprite.h:46
PalSpriteID ground
Palette and sprite for the ground.
Definition sprite.h:47
const struct GRFFile * grffile
grf file that introduced this entity
uint16_t local_id
id defined by the grf file for this entity
uint32_t grfid
grfid that introduced this entity.
std::array< uint8_t, NUM_CARGO > cargo_map
Inverse cargo translation table (CargoType -> local ID)
Definition newgrf.h:134
StationCargoList cargo
The cargo packets of cargo waiting in this station.
debug_inline const GoodsEntryData & GetData() const
Get optional cargo packet/flow data.
SpriteID sprite
The 'real' sprite.
Definition gfx_type.h:23
PaletteID pal
The palette (use PAL_NONE) if not needed)
Definition gfx_type.h:24
Tindex index
Index of this pool item.
std::vector< const SpriteGroup * > loading
List of loading groups (can be SpriteIDs or Callback results)
Interface for SpriteGroup-s to access the gamestate.
const GRFFile * grffile
GRFFile the resolved SpriteGroup belongs to.
const SpriteGroup * root_spritegroup
Root SpriteGroup to use for resolving.
Helper class for animation control.
Road stop resolver.
const SpriteGroup * ResolveReal(const RealSpriteGroup *group) const override
Get the real sprites of the grf.
std::optional< TownScopeResolver > town_scope
The town scope resolver (created on the first call).
RoadStopScopeResolver roadstop_scope
The stop scope resolver.
uint8_t view
Station axis.
uint32_t GetTriggers() const override
Get the triggers.
RoadType roadtype
Road type (used when no tile)
uint32_t GetVariable(uint8_t variable, uint32_t parameter, bool &available) const override
Get a variable value.
StationType type
Station type.
const struct RoadStopSpec * roadstopspec
Station (type) specification.
struct BaseStation * st
Instance of the station.
CargoType cargo_type
Type of cargo of the station.
TileIndex tile
Tile of the station.
uint32_t GetRandomBits() const override
Get a few random bits.
Road stop specification.
CargoTypes cargo_triggers
Bitmask of cargo types which cause trigger re-randomizing.
VariableGRFFileProps grf_prop
Properties related the the grf file.
ResolverObject & ro
Surrounding resolver object.
static bool IsExpected(const BaseStation *st)
Helper for checking whether the given station is of this type.
static Station * From(BaseStation *st)
Converts a BaseStation to SpecializedStation with type checking.
virtual const SpriteGroup * Resolve(ResolverObject &object) const
Base sprite group resolver.
Station data structure.
GoodsEntry goods[NUM_CARGO]
Goods at this station.
Action 2 sprite layout for houses, industry tiles, objects and airport tiles.
Scope resolver for a town.
Definition newgrf_town.h:22
Town data structure.
Definition town.h:52
TileIndex xy
town center tile
Definition town.h:53
const struct SpriteGroup * GetSpriteGroup(size_t index) const
Get the SpriteGroup at the specified index.
Slope GetTileSlope(TileIndex tile)
Return the slope of a given tile inside the map.
Definition tile_map.h:279
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition tile_type.h:95
Definition of the game-calendar-timer.
Base of the town class.
HouseZonesBits GetTownRadiusGroup(const Town *t, TileIndex tile)
Returns the bit corresponding to the town zone of the specified tile.
Town * ClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest (in distance or ownership) to a given tile, within a given threshold.
Functions related to (drawing on) viewports.
Types related to windows.