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
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
|
/*
* 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 airport.cpp Functions related to airports. */
#include "stdafx.h"
#include "station_base.h"
#include "table/strings.h"
#include "table/airport_movement.h"
#include "table/airporttile_ids.h"
#include "safeguards.h"
/**
* Define a generic airport.
* @param name Suffix of the names of the airport data.
* @param terminals The terminals.
* @param num_helipads Number of heli pads.
* @param flags Information about the class of FTA.
* @param delta_z Height of the airport above the land.
*/
#define AIRPORT_GENERIC(name, terminals, num_helipads, flags, delta_z) \
static const AirportFTAClass _airportfta_ ## name(_airport_moving_data_ ## name, terminals, \
num_helipads, _airport_entries_ ## name, flags, _airport_fta_ ## name, delta_z);
/**
* Define an airport.
* @param name Suffix of the names of the airport data.
* @param num_helipads Number of heli pads.
* @param short_strip Airport has a short land/take-off strip.
*/
#define AIRPORT(name, num_helipads, short_strip) \
AIRPORT_GENERIC(name, _airport_terminal_ ## name, num_helipads, AirportFTAClass::ALL | (short_strip ? AirportFTAClass::SHORT_STRIP : (AirportFTAClass::Flags)0), 0)
/**
* Define a heliport.
* @param name Suffix of the names of the helipad data.
* @param num_helipads Number of heli pads.
* @param delta_z Height of the airport above the land.
*/
#define HELIPORT(name, num_helipads, delta_z) \
AIRPORT_GENERIC(name, nullptr, num_helipads, AirportFTAClass::HELICOPTERS, delta_z)
AIRPORT(country, 0, true)
AIRPORT(city, 0, false)
HELIPORT(heliport, 1, 60)
AIRPORT(metropolitan, 0, false)
AIRPORT(international, 2, false)
AIRPORT(commuter, 2, true)
HELIPORT(helidepot, 1, 0)
AIRPORT(intercontinental, 2, false)
HELIPORT(helistation, 3, 0)
HELIPORT(oilrig, 1, 54)
AIRPORT_GENERIC(dummy, nullptr, 0, AirportFTAClass::ALL, 0)
#undef HELIPORT
#undef AIRPORT
#undef AIRPORT_GENERIC
#include "table/airport_defaults.h"
static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA);
static AirportFTA *AirportBuildAutomata(uint nofelements, const AirportFTAbuildup *apFA);
/**
* Rotate the airport moving data to another rotation.
* @param orig Pointer to the moving data to rotate.
* @param rotation How to rotate the moving data.
* @param num_tiles_x Number of tiles in x direction.
* @param num_tiles_y Number of tiles in y direction.
* @return The rotated moving data.
*/
AirportMovingData RotateAirportMovingData(const AirportMovingData *orig, Direction rotation, uint num_tiles_x, uint num_tiles_y)
{
AirportMovingData amd;
amd.flag = orig->flag;
amd.direction = ChangeDir(orig->direction, (DirDiff)rotation);
switch (rotation) {
case DIR_N:
amd.x = orig->x;
amd.y = orig->y;
break;
case DIR_E:
amd.x = orig->y;
amd.y = num_tiles_y * TILE_SIZE - orig->x - 1;
break;
case DIR_S:
amd.x = num_tiles_x * TILE_SIZE - orig->x - 1;
amd.y = num_tiles_y * TILE_SIZE - orig->y - 1;
break;
case DIR_W:
amd.x = num_tiles_x * TILE_SIZE - orig->y - 1;
amd.y = orig->x;
break;
default: NOT_REACHED();
}
return amd;
}
AirportFTAClass::AirportFTAClass(
const AirportMovingData *moving_data_,
const byte *terminals_,
const byte num_helipads_,
const byte *entry_points_,
Flags flags_,
const AirportFTAbuildup *apFA,
byte delta_z_
) :
moving_data(moving_data_),
terminals(terminals_),
num_helipads(num_helipads_),
flags(flags_),
nofelements(AirportGetNofElements(apFA)),
entry_points(entry_points_),
delta_z(delta_z_)
{
/* Build the state machine itself */
this->layout = AirportBuildAutomata(this->nofelements, apFA);
}
AirportFTAClass::~AirportFTAClass()
{
for (uint i = 0; i < nofelements; i++) {
AirportFTA *current = layout[i].next;
while (current != nullptr) {
AirportFTA *next = current->next;
free(current);
current = next;
}
}
free(layout);
}
/**
* Get the number of elements of a source Airport state automata
* Since it is actually just a big array of AirportFTA types, we only
* know one element from the other by differing 'position' identifiers
*/
static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA)
{
uint16 nofelements = 0;
int temp = apFA[0].position;
for (uint i = 0; i < MAX_ELEMENTS; i++) {
if (temp != apFA[i].position) {
nofelements++;
temp = apFA[i].position;
}
if (apFA[i].position == MAX_ELEMENTS) break;
}
return nofelements;
}
/**
* Construct the FTA given a description.
* @param nofelements The number of elements in the FTA.
* @param apFA The description of the FTA.
* @return The FTA describing the airport.
*/
static AirportFTA *AirportBuildAutomata(uint nofelements, const AirportFTAbuildup *apFA)
{
AirportFTA *FAutomata = MallocT<AirportFTA>(nofelements);
uint16 internalcounter = 0;
for (uint i = 0; i < nofelements; i++) {
AirportFTA *current = &FAutomata[i];
current->position = apFA[internalcounter].position;
current->heading = apFA[internalcounter].heading;
current->block = apFA[internalcounter].block;
current->next_position = apFA[internalcounter].next;
/* outgoing nodes from the same position, create linked list */
while (current->position == apFA[internalcounter + 1].position) {
AirportFTA *newNode = MallocT<AirportFTA>(1);
newNode->position = apFA[internalcounter + 1].position;
newNode->heading = apFA[internalcounter + 1].heading;
newNode->block = apFA[internalcounter + 1].block;
newNode->next_position = apFA[internalcounter + 1].next;
/* create link */
current->next = newNode;
current = current->next;
internalcounter++;
}
current->next = nullptr;
internalcounter++;
}
return FAutomata;
}
/**
* Get the finite state machine of an airport type.
* @param airport_type %Airport type to query FTA from. @see AirportTypes
* @return Finite state machine of the airport.
*/
const AirportFTAClass *GetAirport(const byte airport_type)
{
if (airport_type == AT_DUMMY) return &_airportfta_dummy;
return AirportSpec::Get(airport_type)->fsm;
}
/**
* Get the vehicle position when an aircraft is build at the given tile
* @param hangar_tile The tile on which the vehicle is build
* @return The position (index in airport node array) where the aircraft ends up
*/
byte GetVehiclePosOnBuild(TileIndex hangar_tile)
{
const Station *st = Station::GetByTile(hangar_tile);
const AirportFTAClass *apc = st->airport.GetFTA();
/* When we click on hangar we know the tile it is on. By that we know
* its position in the array of depots the airport has.....we can search
* layout for #th position of depot. Since layout must start with a listing
* of all depots, it is simple */
for (uint i = 0;; i++) {
if (st->airport.GetHangarTile(i) == hangar_tile) {
assert(apc->layout[i].heading == HANGAR);
return apc->layout[i].position;
}
}
NOT_REACHED();
}
|
