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
8 /** @file newgrf_airporttiles.cpp NewGRF handling of airport tiles. */
9
10 #include "stdafx.h"
11 #include "debug.h"
12 #include "newgrf_airporttiles.h"
13 #include "newgrf_spritegroup.h"
14 #include "newgrf_sound.h"
15 #include "station_base.h"
16 #include "water.h"
17 #include "landscape.h"
18 #include "company_base.h"
19 #include "town.h"
20 #include "table/strings.h"
21 #include "table/airporttiles.h"
22 #include "newgrf_animation_base.h"
23
24 #include "safeguards.h"
25
26
27 AirportTileSpec AirportTileSpec::tiles[NUM_AIRPORTTILES];
28
29 AirportTileOverrideManager _airporttile_mngr(NEW_AIRPORTTILE_OFFSET, NUM_AIRPORTTILES, INVALID_AIRPORTTILE);
30
31 /**
32 * Retrieve airport tile spec for the given airport tile
33 * @param gfx index of airport tile
34 * @return A pointer to the corresponding AirportTileSpec
35 */
Get(StationGfx gfx)36 /* static */ const AirportTileSpec *AirportTileSpec::Get(StationGfx gfx)
37 {
38 /* should be assert(gfx < lengthof(tiles)), but that gives compiler warnings
39 * since it's always true if the following holds: */
40 static_assert(MAX_UVALUE(StationGfx) + 1 == lengthof(tiles));
41 return &AirportTileSpec::tiles[gfx];
42 }
43
44 /**
45 * Retrieve airport tile spec for the given airport tile.
46 * @param tile The airport tile.
47 * @return A pointer to the corresponding AirportTileSpec.
48 */
GetByTile(TileIndex tile)49 /* static */ const AirportTileSpec *AirportTileSpec::GetByTile(TileIndex tile)
50 {
51 return AirportTileSpec::Get(GetAirportGfx(tile));
52 }
53
54 /**
55 * This function initializes the tile array of AirportTileSpec
56 */
ResetAirportTiles()57 void AirportTileSpec::ResetAirportTiles()
58 {
59 memset(&AirportTileSpec::tiles, 0, sizeof(AirportTileSpec::tiles));
60 memcpy(&AirportTileSpec::tiles, &_origin_airporttile_specs, sizeof(_origin_airporttile_specs));
61
62 /* Reset any overrides that have been set. */
63 _airporttile_mngr.ResetOverride();
64 }
65
SetEntitySpec(const AirportTileSpec * airpts)66 void AirportTileOverrideManager::SetEntitySpec(const AirportTileSpec *airpts)
67 {
68 StationGfx airpt_id = this->AddEntityID(airpts->grf_prop.local_id, airpts->grf_prop.grffile->grfid, airpts->grf_prop.subst_id);
69
70 if (airpt_id == invalid_ID) {
71 grfmsg(1, "AirportTile.SetEntitySpec: Too many airport tiles allocated. Ignoring.");
72 return;
73 }
74
75 memcpy(&AirportTileSpec::tiles[airpt_id], airpts, sizeof(*airpts));
76
77 /* Now add the overrides. */
78 for (int i = 0; i < max_offset; i++) {
79 AirportTileSpec *overridden_airpts = &AirportTileSpec::tiles[i];
80
81 if (entity_overrides[i] != airpts->grf_prop.local_id || grfid_overrides[i] != airpts->grf_prop.grffile->grfid) continue;
82
83 overridden_airpts->grf_prop.override = airpt_id;
84 overridden_airpts->enabled = false;
85 entity_overrides[i] = invalid_ID;
86 grfid_overrides[i] = 0;
87 }
88 }
89
90 /**
91 * Do airporttile gfx ID translation for NewGRFs.
92 * @param gfx the type to get the override for.
93 * @return the gfx to actually work with.
94 */
GetTranslatedAirportTileID(StationGfx gfx)95 StationGfx GetTranslatedAirportTileID(StationGfx gfx)
96 {
97 const AirportTileSpec *it = AirportTileSpec::Get(gfx);
98 return it->grf_prop.override == INVALID_AIRPORTTILE ? gfx : it->grf_prop.override;
99 }
100
101 /**
102 * Based on newhouses/newindustries equivalent, but adapted for airports.
103 * @param parameter from callback. It's in fact a pair of coordinates
104 * @param tile TileIndex from which the callback was initiated
105 * @param index of the industry been queried for
106 * @param grf_version8 True, if we are dealing with a new NewGRF which uses GRF version >= 8.
107 * @return a construction of bits obeying the newgrf format
108 */
GetNearbyAirportTileInformation(byte parameter,TileIndex tile,StationID index,bool grf_version8)109 static uint32 GetNearbyAirportTileInformation(byte parameter, TileIndex tile, StationID index, bool grf_version8)
110 {
111 if (parameter != 0) tile = GetNearbyTile(parameter, tile); // only perform if it is required
112 bool is_same_airport = (IsTileType(tile, MP_STATION) && IsAirport(tile) && GetStationIndex(tile) == index);
113
114 return GetNearbyTileInformation(tile, grf_version8) | (is_same_airport ? 1 : 0) << 8;
115 }
116
117
118 /**
119 * Make an analysis of a tile and check whether it belongs to the same
120 * airport, and/or the same grf file
121 * @param tile TileIndex of the tile to query
122 * @param st Station to which to compare the tile to
123 * @param cur_grfid GRFID of the current callback
124 * @return value encoded as per NFO specs
125 */
GetAirportTileIDAtOffset(TileIndex tile,const Station * st,uint32 cur_grfid)126 static uint32 GetAirportTileIDAtOffset(TileIndex tile, const Station *st, uint32 cur_grfid)
127 {
128 if (!st->TileBelongsToAirport(tile)) {
129 return 0xFFFF;
130 }
131
132 StationGfx gfx = GetAirportGfx(tile);
133 const AirportTileSpec *ats = AirportTileSpec::Get(gfx);
134
135 if (gfx < NEW_AIRPORTTILE_OFFSET) { // Does it belongs to an old type?
136 /* It is an old tile. We have to see if it's been overridden */
137 if (ats->grf_prop.override == INVALID_AIRPORTTILE) { // has it been overridden?
138 return 0xFF << 8 | gfx; // no. Tag FF + the gfx id of that tile
139 }
140 /* Overridden */
141 const AirportTileSpec *tile_ovr = AirportTileSpec::Get(ats->grf_prop.override);
142
143 if (tile_ovr->grf_prop.grffile->grfid == cur_grfid) {
144 return tile_ovr->grf_prop.local_id; // same grf file
145 } else {
146 return 0xFFFE; // not the same grf file
147 }
148 }
149 /* Not an 'old type' tile */
150 if (ats->grf_prop.spritegroup[0] != nullptr) { // tile has a spritegroup ?
151 if (ats->grf_prop.grffile->grfid == cur_grfid) { // same airport, same grf ?
152 return ats->grf_prop.local_id;
153 } else {
154 return 0xFFFE; // Defined in another grf file
155 }
156 }
157 /* The tile has no spritegroup */
158 return 0xFF << 8 | ats->grf_prop.subst_id; // so just give it the substitute
159 }
160
GetVariable(byte variable,uint32 parameter,bool * available) const161 /* virtual */ uint32 AirportTileScopeResolver::GetVariable(byte variable, uint32 parameter, bool *available) const
162 {
163 assert(this->st != nullptr);
164
165 extern uint32 GetRelativePosition(TileIndex tile, TileIndex ind_tile);
166
167 switch (variable) {
168 /* Terrain type */
169 case 0x41: return GetTerrainType(this->tile);
170
171 /* Current town zone of the tile in the nearest town */
172 case 0x42: return GetTownRadiusGroup(ClosestTownFromTile(this->tile, UINT_MAX), this->tile);
173
174 /* Position relative to most northern airport tile. */
175 case 0x43: return GetRelativePosition(this->tile, this->st->airport.tile);
176
177 /* Animation frame of tile */
178 case 0x44: return GetAnimationFrame(this->tile);
179
180 /* Land info of nearby tiles */
181 case 0x60: return GetNearbyAirportTileInformation(parameter, this->tile, this->st->index, this->ro.grffile->grf_version >= 8);
182
183 /* Animation stage of nearby tiles */
184 case 0x61: {
185 TileIndex tile = GetNearbyTile(parameter, this->tile);
186 if (this->st->TileBelongsToAirport(tile)) {
187 return GetAnimationFrame(tile);
188 }
189 return UINT_MAX;
190 }
191
192 /* Get airport tile ID at offset */
193 case 0x62: return GetAirportTileIDAtOffset(GetNearbyTile(parameter, this->tile), this->st, this->ro.grffile->grfid);
194 }
195
196 Debug(grf, 1, "Unhandled airport tile variable 0x{:X}", variable);
197
198 *available = false;
199 return UINT_MAX;
200 }
201
GetRandomBits() const202 /* virtual */ uint32 AirportTileScopeResolver::GetRandomBits() const
203 {
204 return (this->st == nullptr ? 0 : this->st->random_bits) | (this->tile == INVALID_TILE ? 0 : GetStationTileRandomBits(this->tile) << 16);
205 }
206
207 /**
208 * Constructor of the resolver for airport tiles.
209 * @param ats Specification of the airport tiles.
210 * @param tile %Tile for the callback, only valid for airporttile callbacks.
211 * @param st Station of the airport for which the callback is run, or \c nullptr for build gui.
212 * @param callback Callback ID.
213 * @param callback_param1 First parameter (var 10) of the callback.
214 * @param callback_param2 Second parameter (var 18) of the callback.
215 */
AirportTileResolverObject(const AirportTileSpec * ats,TileIndex tile,Station * st,CallbackID callback,uint32 callback_param1,uint32 callback_param2)216 AirportTileResolverObject::AirportTileResolverObject(const AirportTileSpec *ats, TileIndex tile, Station *st,
217 CallbackID callback, uint32 callback_param1, uint32 callback_param2)
218 : ResolverObject(ats->grf_prop.grffile, callback, callback_param1, callback_param2), tiles_scope(*this, ats, tile, st)
219 {
220 this->root_spritegroup = ats->grf_prop.spritegroup[0];
221 }
222
GetFeature() const223 GrfSpecFeature AirportTileResolverObject::GetFeature() const
224 {
225 return GSF_AIRPORTTILES;
226 }
227
GetDebugID() const228 uint32 AirportTileResolverObject::GetDebugID() const
229 {
230 return this->tiles_scope.ats->grf_prop.local_id;
231 }
232
GetAirportTileCallback(CallbackID callback,uint32 param1,uint32 param2,const AirportTileSpec * ats,Station * st,TileIndex tile,int extra_data=0)233 uint16 GetAirportTileCallback(CallbackID callback, uint32 param1, uint32 param2, const AirportTileSpec *ats, Station *st, TileIndex tile, int extra_data = 0)
234 {
235 AirportTileResolverObject object(ats, tile, st, callback, param1, param2);
236 return object.ResolveCallback();
237 }
238
AirportDrawTileLayout(const TileInfo * ti,const TileLayoutSpriteGroup * group,byte colour,StationGfx gfx)239 static void AirportDrawTileLayout(const TileInfo *ti, const TileLayoutSpriteGroup *group, byte colour, StationGfx gfx)
240 {
241 const DrawTileSprites *dts = group->ProcessRegisters(nullptr);
242
243 SpriteID image = dts->ground.sprite;
244 SpriteID pal = dts->ground.pal;
245
246 if (GB(image, 0, SPRITE_WIDTH) != 0) {
247 if (image == SPR_FLAT_WATER_TILE && IsTileOnWater(ti->tile)) {
248 DrawWaterClassGround(ti);
249 } else {
250 DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, GENERAL_SPRITE_COLOUR(colour)));
251 }
252 }
253
254 DrawNewGRFTileSeq(ti, dts, TO_BUILDINGS, 0, GENERAL_SPRITE_COLOUR(colour));
255 }
256
DrawNewAirportTile(TileInfo * ti,Station * st,StationGfx gfx,const AirportTileSpec * airts)257 bool DrawNewAirportTile(TileInfo *ti, Station *st, StationGfx gfx, const AirportTileSpec *airts)
258 {
259 if (ti->tileh != SLOPE_FLAT) {
260 bool draw_old_one = true;
261 if (HasBit(airts->callback_mask, CBM_AIRT_DRAW_FOUNDATIONS)) {
262 /* Called to determine the type (if any) of foundation to draw */
263 uint32 callback_res = GetAirportTileCallback(CBID_AIRPTILE_DRAW_FOUNDATIONS, 0, 0, airts, st, ti->tile);
264 if (callback_res != CALLBACK_FAILED) draw_old_one = ConvertBooleanCallback(airts->grf_prop.grffile, CBID_AIRPTILE_DRAW_FOUNDATIONS, callback_res);
265 }
266
267 if (draw_old_one) DrawFoundation(ti, FOUNDATION_LEVELED);
268 }
269
270 AirportTileResolverObject object(airts, ti->tile, st);
271 const SpriteGroup *group = object.Resolve();
272 if (group == nullptr || group->type != SGT_TILELAYOUT) {
273 return false;
274 }
275
276 const TileLayoutSpriteGroup *tlgroup = (const TileLayoutSpriteGroup *)group;
277 AirportDrawTileLayout(ti, tlgroup, Company::Get(st->owner)->colour, gfx);
278 return true;
279 }
280
281 /** Helper class for animation control. */
282 struct AirportTileAnimationBase : public AnimationBase<AirportTileAnimationBase, AirportTileSpec, Station, int, GetAirportTileCallback> {
283 static const CallbackID cb_animation_speed = CBID_AIRPTILE_ANIMATION_SPEED;
284 static const CallbackID cb_animation_next_frame = CBID_AIRPTILE_ANIM_NEXT_FRAME;
285
286 static const AirportTileCallbackMask cbm_animation_speed = CBM_AIRT_ANIM_SPEED;
287 static const AirportTileCallbackMask cbm_animation_next_frame = CBM_AIRT_ANIM_NEXT_FRAME;
288 };
289
AnimateAirportTile(TileIndex tile)290 void AnimateAirportTile(TileIndex tile)
291 {
292 const AirportTileSpec *ats = AirportTileSpec::GetByTile(tile);
293 if (ats == nullptr) return;
294
295 AirportTileAnimationBase::AnimateTile(ats, Station::GetByTile(tile), tile, HasBit(ats->animation_special_flags, 0));
296 }
297
AirportTileAnimationTrigger(Station * st,TileIndex tile,AirpAnimationTrigger trigger,CargoID cargo_type)298 void AirportTileAnimationTrigger(Station *st, TileIndex tile, AirpAnimationTrigger trigger, CargoID cargo_type)
299 {
300 const AirportTileSpec *ats = AirportTileSpec::GetByTile(tile);
301 if (!HasBit(ats->animation.triggers, trigger)) return;
302
303 AirportTileAnimationBase::ChangeAnimationFrame(CBID_AIRPTILE_ANIM_START_STOP, ats, st, tile, Random(), (uint8)trigger | (cargo_type << 8));
304 }
305
AirportAnimationTrigger(Station * st,AirpAnimationTrigger trigger,CargoID cargo_type)306 void AirportAnimationTrigger(Station *st, AirpAnimationTrigger trigger, CargoID cargo_type)
307 {
308 if (st->airport.tile == INVALID_TILE) return;
309
310 for (TileIndex tile : st->airport) {
311 if (st->TileBelongsToAirport(tile)) AirportTileAnimationTrigger(st, tile, trigger, cargo_type);
312 }
313 }
314
315