1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
/*
* This file is part of OpenTTD.
* 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.
* 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.
* 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/>.
*/
/** @file newgrf_roadtype.cpp NewGRF handling of road types. */
#include "stdafx.h"
#include "debug.h"
#include "newgrf_roadtype.h"
#include "date_func.h"
#include "depot_base.h"
#include "town.h"
#include "safeguards.h"
/* virtual */ uint32 RoadTypeScopeResolver::GetRandomBits() const
{
uint tmp = CountBits(this->tile + (TileX(this->tile) + TileY(this->tile)) * TILE_SIZE);
return GB(tmp, 0, 2);
}
/* virtual */ uint32 RoadTypeScopeResolver::GetVariable(byte variable, uint32 parameter, bool *available) const
{
if (this->tile == INVALID_TILE) {
switch (variable) {
case 0x40: return 0;
case 0x41: return 0;
case 0x42: return 0;
case 0x43: return _date;
case 0x44: return HZB_TOWN_EDGE;
}
}
switch (variable) {
case 0x40: return GetTerrainType(this->tile, this->context);
case 0x41: return 0;
case 0x42: return IsLevelCrossingTile(this->tile) && IsCrossingBarred(this->tile);
case 0x43:
if (IsRoadDepotTile(this->tile)) return Depot::GetByTile(this->tile)->build_date;
return _date;
case 0x44: {
const Town *t = nullptr;
if (IsRoadDepotTile(this->tile)) {
t = Depot::GetByTile(this->tile)->town;
} else {
t = ClosestTownFromTile(this->tile, UINT_MAX);
}
return t != nullptr ? GetTownRadiusGroup(t, this->tile) : HZB_TOWN_EDGE;
}
}
DEBUG(grf, 1, "Unhandled road type tile variable 0x%X", variable);
*available = false;
return UINT_MAX;
}
/* virtual */ const SpriteGroup *RoadTypeResolverObject::ResolveReal(const RealSpriteGroup *group) const
{
if (!group->loading.empty()) return group->loading[0];
if (!group->loaded.empty()) return group->loaded[0];
return nullptr;
}
GrfSpecFeature RoadTypeResolverObject::GetFeature() const
{
RoadType rt = GetRoadTypeByLabel(this->roadtype_scope.rti->label, false);
switch (GetRoadTramType(rt)) {
case RTT_ROAD: return GSF_ROADTYPES;
case RTT_TRAM: return GSF_TRAMTYPES;
default: return GSF_INVALID;
}
}
uint32 RoadTypeResolverObject::GetDebugID() const
{
return this->roadtype_scope.rti->label;
}
/**
* Constructor of the roadtype scope resolvers.
* @param ro Surrounding resolver.
* @param tile %Tile containing the track. For track on a bridge this is the southern bridgehead.
* @param context Are we resolving sprites for the upper halftile, or on a bridge?
*/
RoadTypeScopeResolver::RoadTypeScopeResolver(ResolverObject &ro, const RoadTypeInfo *rti, TileIndex tile, TileContext context) : ScopeResolver(ro)
{
this->tile = tile;
this->context = context;
this->rti = rti;
}
/**
* Resolver object for road types.
* @param rti Roadtype. nullptr in NewGRF Inspect window.
* @param tile %Tile containing the track. For track on a bridge this is the southern bridgehead.
* @param context Are we resolving sprites for the upper halftile, or on a bridge?
* @param rtsg Roadpart of interest
* @param param1 Extra parameter (first parameter of the callback, except roadtypes do not have callbacks).
* @param param2 Extra parameter (second parameter of the callback, except roadtypes do not have callbacks).
*/
RoadTypeResolverObject::RoadTypeResolverObject(const RoadTypeInfo *rti, TileIndex tile, TileContext context, RoadTypeSpriteGroup rtsg, uint32 param1, uint32 param2)
: ResolverObject(rti != nullptr ? rti->grffile[rtsg] : nullptr, CBID_NO_CALLBACK, param1, param2), roadtype_scope(*this, rti, tile, context)
{
this->root_spritegroup = rti != nullptr ? rti->group[rtsg] : nullptr;
}
/**
* Get the sprite to draw for the given tile.
* @param rti The road type data (spec).
* @param tile The tile to get the sprite for.
* @param rtsg The type of sprite to draw.
* @param content Where are we drawing the tile?
* @param [out] num_results If not nullptr, return the number of sprites in the spriteset.
* @return The sprite to draw.
*/
SpriteID GetCustomRoadSprite(const RoadTypeInfo *rti, TileIndex tile, RoadTypeSpriteGroup rtsg, TileContext context, uint *num_results)
{
assert(rtsg < ROTSG_END);
if (rti->group[rtsg] == nullptr) return 0;
RoadTypeResolverObject object(rti, tile, context, rtsg);
const SpriteGroup *group = object.Resolve();
if (group == nullptr || group->GetNumResults() == 0) return 0;
if (num_results) *num_results = group->GetNumResults();
return group->GetResult();
}
/**
* Translate an index to the GRF-local road/tramtype-translation table into a RoadType.
* @param rtt Whether to index the road- or tramtype-table.
* @param tracktype Index into GRF-local translation table.
* @param grffile Originating GRF file.
* @return RoadType or INVALID_ROADTYPE if the roadtype is unknown.
*/
RoadType GetRoadTypeTranslation(RoadTramType rtt, uint8 tracktype, const GRFFile *grffile)
{
/* Because OpenTTD mixes RoadTypes and TramTypes into the same type,
* the mapping of the original road- and tramtypes does not match the default GRF-local mapping.
* So, this function cannot provide any similar behavior to GetCargoTranslation() and GetRailTypeTranslation()
* when the GRF defines no translation table.
* But since there is only one default road/tram-type, this makes little sense anyway.
* So for GRF without translation table, we always return INVALID_ROADTYPE.
*/
if (grffile == nullptr) return INVALID_ROADTYPE;
const auto &list = rtt == RTT_TRAM ? grffile->tramtype_list : grffile->roadtype_list;
if (tracktype >= list.size()) return INVALID_ROADTYPE;
/* Look up roadtype including alternate labels. */
RoadType result = GetRoadTypeByLabel(list[tracktype]);
/* Check whether the result is actually the wanted road/tram-type */
if (result != INVALID_ROADTYPE && GetRoadTramType(result) != rtt) return INVALID_ROADTYPE;
return result;
}
/**
* Perform a reverse roadtype lookup to get the GRF internal ID.
* @param roadtype The global (OpenTTD) roadtype.
* @param grffile The GRF to do the lookup for.
* @return the GRF internal ID.
*/
uint8 GetReverseRoadTypeTranslation(RoadType roadtype, const GRFFile *grffile)
{
/* No road type table present, return road type as-is */
if (grffile == nullptr) return roadtype;
const std::vector<RoadTypeLabel> *list = RoadTypeIsRoad(roadtype) ? &grffile->roadtype_list : &grffile->tramtype_list;
if (list->size() == 0) return roadtype;
/* Look for a matching road type label in the table */
RoadTypeLabel label = GetRoadTypeInfo(roadtype)->label;
int index = find_index(*list, label);
if (index >= 0) return index;
/* If not found, return as invalid */
return 0xFF;
}
|
