OpenTTD Source: src/newgrf_roadtype.cpp Source File

OpenTTD Source 1.11.0-RC1

newgrf_roadtype.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 "debug.h"
12 #include "newgrf_roadtype.h"
13 #include "date_func.h"
14 #include "depot_base.h"
15 #include "town.h"
16
17 #include "safeguards.h"
18
19 /* virtual */ uint32 RoadTypeScopeResolver::GetRandomBits() const
20 {
21 uint tmp = CountBits(this->tile + (TileX(this->tile) + TileY(this->tile)) * TILE_SIZE);
22 return GB(tmp, 0, 2);
23 }
24
25 /* virtual */ uint32 RoadTypeScopeResolver::GetVariable(byte variable, uint32 parameter, bool *available) const
26 {
27 if (this->tile == INVALID_TILE) {
28 switch (variable) {
29 case 0x40: return 0;
30 case 0x41: return 0;
31 case 0x42: return 0;
32 case 0x43: return _date;
33 case 0x44: return HZB_TOWN_EDGE;
34 }
35 }
36
37 switch (variable) {
38 case 0x40: return GetTerrainType(this->tile, this->context);
39 case 0x41: return 0;
40 case 0x42: return IsLevelCrossingTile(this->tile) && IsCrossingBarred(this->tile);
41 case 0x43:
42 if (IsRoadDepotTile(this->tile)) return Depot::GetByTile(this->tile)->build_date;
43 return _date;
44 case 0x44: {
45 const Town *t = nullptr;
46 if (IsRoadDepotTile(this->tile)) {
47 t = Depot::GetByTile(this->tile)->town;
48 } else {
49 t = ClosestTownFromTile(this->tile, UINT_MAX);
50 }
51 return t != nullptr ? GetTownRadiusGroup(t, this->tile) : HZB_TOWN_EDGE;
52 }
53 }
54
55 DEBUG(grf, 1, "Unhandled road type tile variable 0x%X", variable);
56
57 *available = false;
58 return UINT_MAX;
59 }
60
61 /* virtual */ const SpriteGroup *RoadTypeResolverObject::ResolveReal(const RealSpriteGroup *group) const
62 {
63 if (group->num_loading > 0) return group->loading[0];
64 if (group->num_loaded > 0) return group->loaded[0];
65 return nullptr;
66 }
67
68 GrfSpecFeature RoadTypeResolverObject::GetFeature() const
69 {
70 RoadType rt = GetRoadTypeByLabel(this->roadtype_scope.rti->label, false);
71 switch (GetRoadTramType(rt)) {
72 case RTT_ROAD: return GSF_ROADTYPES;
73 case RTT_TRAM: return GSF_TRAMTYPES;
74 default: return GSF_INVALID;
75 }
76 }
77
78 uint32 RoadTypeResolverObject::GetDebugID() const
79 {
80 return this->roadtype_scope.rti->label;
81 }
82
89 RoadTypeScopeResolver::RoadTypeScopeResolver(ResolverObject &ro, const RoadTypeInfo *rti, TileIndex tile, TileContext context) : ScopeResolver(ro)
90 {
91 this->tile = tile;
92 this->context = context;
93 this->rti = rti;
94 }
95
105 RoadTypeResolverObject::RoadTypeResolverObject(const RoadTypeInfo *rti, TileIndex tile, TileContext context, RoadTypeSpriteGroup rtsg, uint32 param1, uint32 param2)
106 : ResolverObject(rti != nullptr ? rti->grffile[rtsg] : nullptr, CBID_NO_CALLBACK, param1, param2), roadtype_scope(*this, rti, tile, context)
107 {
108 this->root_spritegroup = rti != nullptr ? rti->group[rtsg] : nullptr;
109 }
110
120 SpriteID GetCustomRoadSprite(const RoadTypeInfo *rti, TileIndex tile, RoadTypeSpriteGroup rtsg, TileContext context, uint *num_results)
121 {
122 assert(rtsg < ROTSG_END);
123
124 if (rti->group[rtsg] == nullptr) return 0;
125
126 RoadTypeResolverObject object(rti, tile, context, rtsg);
127 const SpriteGroup *group = object.Resolve();
128 if (group == nullptr || group->GetNumResults() == 0) return 0;
129
130 if (num_results) *num_results = group->GetNumResults();
131
132 return group->GetResult();
133 }
134
142 RoadType GetRoadTypeTranslation(RoadTramType rtt, uint8 tracktype, const GRFFile *grffile)
143 {
144 /* Because OpenTTD mixes RoadTypes and TramTypes into the same type,
145 * the mapping of the original road- and tramtypes does not match the default GRF-local mapping.
146 * So, this function cannot provide any similar behavior to GetCargoTranslation() and GetRailTypeTranslation()
147 * when the GRF defines no translation table.
148 * But since there is only one default road/tram-type, this makes little sense anyway.
149 * So for GRF without translation table, we always return INVALID_ROADTYPE.
150 */
151
152 if (grffile == nullptr) return INVALID_ROADTYPE;
153
154 const auto &list = rtt == RTT_TRAM ? grffile->tramtype_list : grffile->roadtype_list;
155 if (tracktype >= list.size()) return INVALID_ROADTYPE;
156
157 /* Look up roadtype including alternate labels. */
158 RoadType result = GetRoadTypeByLabel(list[tracktype]);
159
160 /* Check whether the result is actually the wanted road/tram-type */
161 if (result != INVALID_ROADTYPE && GetRoadTramType(result) != rtt) return INVALID_ROADTYPE;
162
163 return result;
164 }
165
172 uint8 GetReverseRoadTypeTranslation(RoadType roadtype, const GRFFile *grffile)
173 {
174 /* No road type table present, return road type as-is */
175 if (grffile == nullptr) return roadtype;
176
177 const std::vector<RoadTypeLabel> *list = RoadTypeIsRoad(roadtype) ? &grffile->roadtype_list : &grffile->tramtype_list;
178 if (list->size() == 0) return roadtype;
179
180 /* Look for a matching road type label in the table */
181 RoadTypeLabel label = GetRoadTypeInfo(roadtype)->label;
182
183 int index = find_index(*list, label);
184 if (index >= 0) return index;
185
186 /* If not found, return as invalid */
187 return 0xFF;
188 }
TileIndex
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:78
RoadTypeInfo
Definition: road.h:75
RealSpriteGroup::loaded
const SpriteGroup ** loaded
List of loaded groups (can be SpriteIDs or Callback results)
Definition: newgrf_spritegroup.h:92
GRFFile::roadtype_list
std::vector< RoadTypeLabel > roadtype_list
Roadtype translation table (road)
Definition: newgrf.h:132
GB
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
Definition: bitmath_func.hpp:32
GetRoadTypeByLabel
RoadType GetRoadTypeByLabel(RoadTypeLabel label, bool allow_alternate_labels)
Get the road type for a given label.
Definition: road.cpp:243
ClosestTownFromTile
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:3595
RealSpriteGroup::num_loaded
byte num_loaded
Number of loaded groups.
Definition: newgrf_spritegroup.h:90
RoadTypeScopeResolver::RoadTypeScopeResolver
RoadTypeScopeResolver(ResolverObject &ro, const RoadTypeInfo *rti, TileIndex tile, TileContext context)
Constructor of the roadtype scope resolvers.
Definition: newgrf_roadtype.cpp:89
RoadTypeResolverObject::RoadTypeResolverObject
RoadTypeResolverObject(const RoadTypeInfo *rti, TileIndex tile, TileContext context, RoadTypeSpriteGroup rtsg, uint32 param1=0, uint32 param2=0)
Resolver object for road types.
Definition: newgrf_roadtype.cpp:105
INVALID_ROADTYPE
@ INVALID_ROADTYPE
flag for invalid roadtype
Definition: road_type.h:27
IsRoadDepotTile
static bool IsRoadDepotTile(TileIndex t)
Return whether a tile is a road depot tile.
Definition: road_map.h:115
RoadTypeScopeResolver::context
TileContext context
Are we resolving sprites for the upper halftile, or on a bridge?
Definition: newgrf_roadtype.h:20
ResolverObject
Interface for SpriteGroup-s to access the gamestate.
Definition: newgrf_spritegroup.h:315
TILE_SIZE
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:13
GetReverseRoadTypeTranslation
uint8 GetReverseRoadTypeTranslation(RoadType roadtype, const GRFFile *grffile)
Perform a reverse roadtype lookup to get the GRF internal ID.
Definition: newgrf_roadtype.cpp:172
town.h
TileY
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:215
GSF_INVALID
@ GSF_INVALID
An invalid spec feature.
Definition: newgrf.h:92
ScopeResolver
Interface to query and set values specific to a single VarSpriteGroupScope (action 2 scope).
Definition: newgrf_spritegroup.h:296
TileX
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:205
CountBits
static uint CountBits(T value)
Counts the number of set bits in a variable.
Definition: bitmath_func.hpp:251
GetTownRadiusGroup
HouseZonesBits GetTownRadiusGroup(const Town *t, TileIndex tile)
Returns the bit corresponding to the town zone of the specified tile.
Definition: town_cmd.cpp:2253
SpriteID
uint32 SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:17
RealSpriteGroup::loading
const SpriteGroup ** loading
List of loading groups (can be SpriteIDs or Callback results)
Definition: newgrf_spritegroup.h:93
GetCustomRoadSprite
SpriteID GetCustomRoadSprite(const RoadTypeInfo *rti, TileIndex tile, RoadTypeSpriteGroup rtsg, TileContext context, uint *num_results)
Get the sprite to draw for the given tile.
Definition: newgrf_roadtype.cpp:120
RoadTypeSpriteGroup
RoadTypeSpriteGroup
Sprite groups for a roadtype.
Definition: road.h:57
RoadTypeResolverObject::ResolveReal
const SpriteGroup * ResolveReal(const RealSpriteGroup *group) const override
Get the real sprites of the grf.
Definition: newgrf_roadtype.cpp:61
depot_base.h
GRFFile::tramtype_list
std::vector< RoadTypeLabel > tramtype_list
Roadtype translation table (tram)
Definition: newgrf.h:135
_date
Date _date
Current date in days (day counter)
Definition: date.cpp:28
DEBUG
#define DEBUG(name, level,...)
Output a line of debugging information.
Definition: debug.h:35
CBID_NO_CALLBACK
@ CBID_NO_CALLBACK
Set when using the callback resolve system, but not to resolve a callback.
Definition: newgrf_callbacks.h:22
ResolverObject::root_spritegroup
const SpriteGroup * root_spritegroup
Root SpriteGroup to use for resolving.
Definition: newgrf_spritegroup.h:344
find_index
int find_index(std::vector< T > const &vec, T const &item)
Helper function to get the index of an item Consider using std::set, std::unordered_set or std::flat_...
Definition: smallvec_type.hpp:44
RoadTypeInfo::group
const SpriteGroup * group[ROTSG_END]
Sprite groups for resolving sprites.
Definition: road.h:189
IsCrossingBarred
static bool IsCrossingBarred(TileIndex t)
Check if the level crossing is barred.
Definition: road_map.h:416
TileContext
TileContext
Context for tile accesses.
Definition: newgrf_commons.h:24
RoadTypeResolverObject::GetDebugID
uint32 GetDebugID() const override
Get an identifier for the item being resolved.
Definition: newgrf_roadtype.cpp:78
safeguards.h
date_func.h
stdafx.h
RoadType
RoadType
The different roadtypes we support.
Definition: road_type.h:22
RoadTypeResolverObject::GetFeature
GrfSpecFeature GetFeature() const override
Get the feature number being resolved for.
Definition: newgrf_roadtype.cpp:68
GrfSpecFeature
GrfSpecFeature
Definition: newgrf.h:66
SpriteGroup::Resolve
virtual const SpriteGroup * Resolve(ResolverObject &object) const
Base sprite group resolver.
Definition: newgrf_spritegroup.h:61
RoadTypeResolverObject
Resolver object for road types.
Definition: newgrf_roadtype.h:30
newgrf_roadtype.h
RoadTypeInfo::label
RoadTypeLabel label
Unique 32 bit road type identifier.
Definition: road.h:144
GetRoadTypeTranslation
RoadType GetRoadTypeTranslation(RoadTramType rtt, uint8 tracktype, const GRFFile *grffile)
Translate an index to the GRF-local road/tramtype-translation table into a RoadType.
Definition: newgrf_roadtype.cpp:142
RealSpriteGroup
Definition: newgrf_spritegroup.h:79
GetRoadTypeInfo
static const RoadTypeInfo * GetRoadTypeInfo(RoadType roadtype)
Returns a pointer to the Roadtype information for a given roadtype.
Definition: road.h:224
IsLevelCrossingTile
static bool IsLevelCrossingTile(TileIndex t)
Return whether a tile is a level crossing tile.
Definition: road_map.h:94
Depot::build_date
Date build_date
Date of construction.
Definition: depot_base.h:25
RoadTypeScopeResolver::tile
TileIndex tile
Tracktile. For track on a bridge this is the southern bridgehead.
Definition: newgrf_roadtype.h:19
Town
Town data structure.
Definition: town.h:50
RealSpriteGroup::num_loading
byte num_loading
Number of loading groups.
Definition: newgrf_spritegroup.h:91
RoadTypeResolverObject::roadtype_scope
RoadTypeScopeResolver roadtype_scope
Resolver for the roadtype scope.
Definition: newgrf_roadtype.h:31
INVALID_TILE
static const TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:83
SpriteGroup
Definition: newgrf_spritegroup.h:57
RoadTypeScopeResolver::GetVariable
uint32 GetVariable(byte variable, uint32 parameter, bool *available) const
Get a variable value.
Definition: newgrf_roadtype.cpp:25
RoadTypeScopeResolver::GetRandomBits
uint32 GetRandomBits() const
Get a few random bits.
Definition: newgrf_roadtype.cpp:19
GetTerrainType
uint32 GetTerrainType(TileIndex tile, TileContext context)
Function used by houses (and soon industries) to get information on type of "terrain" the tile it is ...
Definition: newgrf_commons.cpp:348
GRFFile
Dynamic data of a loaded NewGRF.
Definition: newgrf.h:105
debug.h