OpenTTD Source  20241108-master-g80f628063a
newgrf_railtype.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 #include "core/container_func.hpp"
12 #include "debug.h"
13 #include "newgrf_railtype.h"
15 #include "depot_base.h"
16 #include "town.h"
17 
18 #include "safeguards.h"
19 
20 /* virtual */ uint32_t RailTypeScopeResolver::GetRandomBits() const
21 {
22  uint tmp = CountBits(this->tile.base() + (TileX(this->tile) + TileY(this->tile)) * TILE_SIZE);
23  return GB(tmp, 0, 2);
24 }
25 
26 /* virtual */ uint32_t RailTypeScopeResolver::GetVariable(uint8_t variable, [[maybe_unused]] uint32_t parameter, bool &available) const
27 {
28  if (this->tile == INVALID_TILE) {
29  switch (variable) {
30  case 0x40: return 0;
31  case 0x41: return 0;
32  case 0x42: return 0;
33  case 0x43: return TimerGameCalendar::date.base();
34  case 0x44: return HZB_TOWN_EDGE;
35  }
36  }
37 
38  switch (variable) {
39  case 0x40: return GetTerrainType(this->tile, this->context);
40  case 0x41: return 0;
41  case 0x42: return IsLevelCrossingTile(this->tile) && IsCrossingBarred(this->tile);
42  case 0x43:
43  if (IsRailDepotTile(this->tile)) return Depot::GetByTile(this->tile)->build_date.base();
44  return TimerGameCalendar::date.base();
45  case 0x44: {
46  const Town *t = nullptr;
47  if (IsRailDepotTile(this->tile)) {
48  t = Depot::GetByTile(this->tile)->town;
49  } else if (IsLevelCrossingTile(this->tile)) {
50  t = ClosestTownFromTile(this->tile, UINT_MAX);
51  }
52  return t != nullptr ? GetTownRadiusGroup(t, this->tile) : HZB_TOWN_EDGE;
53  }
54  }
55 
56  Debug(grf, 1, "Unhandled rail type tile variable 0x{:X}", variable);
57 
58  available = false;
59  return UINT_MAX;
60 }
61 
63 {
64  return GSF_RAILTYPES;
65 }
66 
68 {
69  return this->railtype_scope.rti->label;
70 }
71 
81 RailTypeResolverObject::RailTypeResolverObject(const RailTypeInfo *rti, TileIndex tile, TileContext context, RailTypeSpriteGroup rtsg, uint32_t param1, uint32_t param2)
82  : ResolverObject(rti != nullptr ? rti->grffile[rtsg] : nullptr, CBID_NO_CALLBACK, param1, param2), railtype_scope(*this, rti, tile, context)
83 {
84  this->root_spritegroup = rti != nullptr ? rti->group[rtsg] : nullptr;
85 }
86 
96 SpriteID GetCustomRailSprite(const RailTypeInfo *rti, TileIndex tile, RailTypeSpriteGroup rtsg, TileContext context, uint *num_results)
97 {
98  assert(rtsg < RTSG_END);
99 
100  if (rti->group[rtsg] == nullptr) return 0;
101 
102  RailTypeResolverObject object(rti, tile, context, rtsg);
103  const SpriteGroup *group = object.Resolve();
104  if (group == nullptr || group->GetNumResults() == 0) return 0;
105 
106  if (num_results) *num_results = group->GetNumResults();
107 
108  return group->GetResult();
109 }
110 
122 {
123  if (rti->group[RTSG_SIGNALS] == nullptr) return 0;
124 
125  uint32_t param1 = gui ? 0x10 : 0x00;
126  uint32_t param2 = (type << 16) | (var << 8) | state;
127  RailTypeResolverObject object(rti, tile, TCX_NORMAL, RTSG_SIGNALS, param1, param2);
128 
129  const SpriteGroup *group = object.Resolve();
130  if (group == nullptr || group->GetNumResults() == 0) return 0;
131 
132  return group->GetResult();
133 }
134 
141 RailType GetRailTypeTranslation(uint8_t railtype, const GRFFile *grffile)
142 {
143  if (grffile == nullptr || grffile->railtype_list.empty()) {
144  /* No railtype table present. Return railtype as-is (if valid), so it works for original railtypes. */
145  if (railtype >= RAILTYPE_END || GetRailTypeInfo(static_cast<RailType>(railtype))->label == 0) return INVALID_RAILTYPE;
146 
147  return static_cast<RailType>(railtype);
148  } else {
149  /* Railtype table present, but invalid index, return invalid type. */
150  if (railtype >= grffile->railtype_list.size()) return INVALID_RAILTYPE;
151 
152  /* Look up railtype including alternate labels. */
153  return GetRailTypeByLabel(grffile->railtype_list[railtype]);
154  }
155 }
156 
163 uint8_t GetReverseRailTypeTranslation(RailType railtype, const GRFFile *grffile)
164 {
165  /* No rail type table present, return rail type as-is */
166  if (grffile == nullptr || grffile->railtype_list.empty()) return railtype;
167 
168  /* Look for a matching rail type label in the table */
169  RailTypeLabel label = GetRailTypeInfo(railtype)->label;
170 
171  int idx = find_index(grffile->railtype_list, label);
172  if (idx >= 0) return idx;
173 
174  /* If not found, return as invalid */
175  return 0xFF;
176 }
constexpr uint CountBits(T value)
Counts the number of set bits in a variable.
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.
This struct contains all the info that is needed to draw and construct tracks.
Definition: rail.h:127
RailTypeLabel label
Unique 32 bit rail type identifier.
Definition: rail.h:236
const SpriteGroup * group[RTSG_END]
Sprite groups for resolving sprites.
Definition: rail.h:281
static Date date
Current date in days (day counter).
Some simple functions to help with accessing containers.
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_...
Functions related to debugging.
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
Definition: debug.h:37
Base for all depots (except hangars)
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:18
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:425
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:415
GrfSpecFeature
Definition: newgrf.h:67
@ CBID_NO_CALLBACK
Set when using the callback resolve system, but not to resolve a callback.
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 ...
TileContext
Context for tile accesses.
@ TCX_NORMAL
Nothing special.
SpriteID GetCustomSignalSprite(const RailTypeInfo *rti, TileIndex tile, SignalType type, SignalVariant var, SignalState state, bool gui)
Get the sprite to draw for a given signal.
uint8_t GetReverseRailTypeTranslation(RailType railtype, const GRFFile *grffile)
Perform a reverse railtype lookup to get the GRF internal ID.
SpriteID GetCustomRailSprite(const RailTypeInfo *rti, TileIndex tile, RailTypeSpriteGroup rtsg, TileContext context, uint *num_results)
Get the sprite to draw for the given tile.
RailType GetRailTypeTranslation(uint8_t railtype, const GRFFile *grffile)
Translate an index to the GRF-local railtype-translation table into a RailType.
NewGRF handling of rail types.
RailType GetRailTypeByLabel(RailTypeLabel label, bool allow_alternate_labels)
Get the rail type for a given label.
Definition: rail.cpp:311
RailTypeSpriteGroup
Sprite groups for a railtype.
Definition: rail.h:49
@ RTSG_SIGNALS
Signal images.
Definition: rail.h:61
const RailTypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
Definition: rail.h:307
static debug_inline bool IsRailDepotTile(Tile t)
Is this tile rail tile and a rail depot?
Definition: rail_map.h:105
RailType
Enumeration for all possible railtypes.
Definition: rail_type.h:27
@ RAILTYPE_END
Used for iterations.
Definition: rail_type.h:33
@ INVALID_RAILTYPE
Flag for invalid railtype.
Definition: rail_type.h:34
bool IsLevelCrossingTile(Tile t)
Return whether a tile is a level crossing tile.
Definition: road_map.h:95
bool IsCrossingBarred(Tile t)
Check if the level crossing is barred.
Definition: road_map.h:416
A number of safeguards to prevent using unsafe methods.
SignalType
Type of signal, i.e.
Definition: signal_type.h:23
SignalState
These are states in which a signal can be.
Definition: signal_type.h:42
SignalVariant
Variant of the signal, i.e.
Definition: signal_type.h:16
Definition of base types and functions in a cross-platform compatible way.
TimerGameCalendar::Date build_date
Date of construction.
Definition: depot_base.h:26
Dynamic data of a loaded NewGRF.
Definition: newgrf.h:108
std::vector< RailTypeLabel > railtype_list
Railtype translation table.
Definition: newgrf.h:133
Resolver object for rail types.
GrfSpecFeature GetFeature() const override
Get the feature number being resolved for.
RailTypeResolverObject(const RailTypeInfo *rti, TileIndex tile, TileContext context, RailTypeSpriteGroup rtsg, uint32_t param1=0, uint32_t param2=0)
Resolver object for rail types.
uint32_t GetDebugID() const override
Get an identifier for the item being resolved.
RailTypeScopeResolver railtype_scope
Resolver for the railtype scope.
TileContext context
Are we resolving sprites for the upper halftile, or on a bridge?
uint32_t GetRandomBits() const override
Get a few random bits.
uint32_t GetVariable(uint8_t variable, [[maybe_unused]] uint32_t parameter, bool &available) const override
Get a variable value.
TileIndex tile
Tracktile. For track on a bridge this is the southern bridgehead.
Interface for SpriteGroup-s to access the gamestate.
const SpriteGroup * root_spritegroup
Root SpriteGroup to use for resolving.
virtual const SpriteGroup * Resolve([[maybe_unused]] ResolverObject &object) const
Base sprite group resolver.
Town data structure.
Definition: town.h:54
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:15
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.
Definition: town_cmd.cpp:2447
Town * ClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest (in distance or ownership) to a given tile, within a given threshold.
Definition: town_cmd.cpp:3870