| author | tron |
| Sun, 05 Dec 2004 12:43:04 +0000 | |
| changeset 555 | 02df8a1b7f33 |
| parent 541 | 625227bb2a3d |
| child 578 | 1e66514eb621 |
| permissions | -rw-r--r-- |
| 0 | 1 |
#include "stdafx.h" |
2 |
#include "ttd.h" |
|
|
507
04b5403aaf6b
(svn r815) Include strings.h only in the files which need it.
tron
parents:
458
diff
changeset
|
3 |
#include "table/strings.h" |
| 0 | 4 |
#include "vehicle.h" |
5 |
#include "engine.h" |
|
6 |
#include "command.h" |
|
7 |
#include "station.h" |
|
8 |
#include "news.h" |
|
9 |
#include "gfx.h" |
|
|
337
cbe0c766c947
(svn r513) Merge revisions 402, 416, 417, 478, 479, 511, 512 from map to trunk
tron
parents:
193
diff
changeset
|
10 |
#include "sound.h" |
| 0 | 11 |
#include "player.h" |
12 |
#include "airport.h" |
|
13 |
||
14 |
static bool AirportMove(Vehicle *v, const AirportFTAClass *Airport); |
|
15 |
static bool AirportSetBlocks(Vehicle *v, AirportFTA *current_pos, const AirportFTAClass *Airport); |
|
16 |
static bool AirportHasBlock(Vehicle *v, AirportFTA *current_pos, const AirportFTAClass *Airport); |
|
17 |
static bool AirportFindFreeTerminal(Vehicle *v, const AirportFTAClass *Airport); |
|
18 |
static bool AirportFindFreeHelipad(Vehicle *v, const AirportFTAClass *Airport); |
|
19 |
static void AirportGoToNextPosition(Vehicle *v, const AirportFTAClass *Airport); |
|
20 |
||
21 |
static void AircraftNextAirportPos_and_Order(Vehicle *v); |
|
22 |
static byte GetAircraftFlyingAltitude(const Vehicle *v); |
|
23 |
||
24 |
static const SpriteID _aircraft_sprite[] = {
|
|
25 |
0x0EB5, 0x0EBD, 0x0EC5, 0x0ECD, |
|
26 |
0x0ED5, 0x0EDD, 0x0E9D, 0x0EA5, |
|
27 |
0x0EAD, 0x0EE5, 0x0F05, 0x0F0D, |
|
28 |
0x0F15, 0x0F1D, 0x0F25, 0x0F2D, |
|
29 |
0x0EED, 0x0EF5, 0x0EFD, 0x0F35, |
|
30 |
0x0E9D, 0x0EA5, 0x0EAD, 0x0EB5, |
|
31 |
0x0EBD, 0x0EC5 |
|
32 |
}; |
|
33 |
||
34 |
int GetAircraftImage(Vehicle *v, byte direction) |
|
35 |
{
|
|
36 |
int spritenum = v->spritenum; |
|
37 |
||
38 |
if (is_custom_sprite(spritenum)) {
|
|
39 |
int sprite = GetCustomVehicleSprite(v, direction); |
|
40 |
||
41 |
if (sprite) return sprite; |
|
42 |
spritenum = _engine_original_sprites[v->engine_type]; |
|
43 |
} |
|
44 |
return direction + _aircraft_sprite[spritenum]; |
|
45 |
} |
|
46 |
||
47 |
void DrawAircraftEngine(int x, int y, int engine, uint32 image_ormod) |
|
48 |
{
|
|
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
49 |
int spritenum = AircraftVehInfo(engine)->image_index; |
| 0 | 50 |
|
|
381
527e47c8feec
(svn r570) -newgrf: Support for custom aircrafts via GRF files. Planeset seems to work :). Also use aircraft_vehinfo() instead of the old tables (pasky).
darkvater
parents:
337
diff
changeset
|
51 |
if (is_custom_sprite(spritenum)) {
|
|
527e47c8feec
(svn r570) -newgrf: Support for custom aircrafts via GRF files. Planeset seems to work :). Also use aircraft_vehinfo() instead of the old tables (pasky).
darkvater
parents:
337
diff
changeset
|
52 |
int sprite = GetCustomVehicleIcon(engine, 6); |
|
527e47c8feec
(svn r570) -newgrf: Support for custom aircrafts via GRF files. Planeset seems to work :). Also use aircraft_vehinfo() instead of the old tables (pasky).
darkvater
parents:
337
diff
changeset
|
53 |
|
|
527e47c8feec
(svn r570) -newgrf: Support for custom aircrafts via GRF files. Planeset seems to work :). Also use aircraft_vehinfo() instead of the old tables (pasky).
darkvater
parents:
337
diff
changeset
|
54 |
if (sprite) {
|
|
527e47c8feec
(svn r570) -newgrf: Support for custom aircrafts via GRF files. Planeset seems to work :). Also use aircraft_vehinfo() instead of the old tables (pasky).
darkvater
parents:
337
diff
changeset
|
55 |
DrawSprite(sprite | image_ormod, x, y); |
|
527e47c8feec
(svn r570) -newgrf: Support for custom aircrafts via GRF files. Planeset seems to work :). Also use aircraft_vehinfo() instead of the old tables (pasky).
darkvater
parents:
337
diff
changeset
|
56 |
return; |
|
527e47c8feec
(svn r570) -newgrf: Support for custom aircrafts via GRF files. Planeset seems to work :). Also use aircraft_vehinfo() instead of the old tables (pasky).
darkvater
parents:
337
diff
changeset
|
57 |
} |
|
527e47c8feec
(svn r570) -newgrf: Support for custom aircrafts via GRF files. Planeset seems to work :). Also use aircraft_vehinfo() instead of the old tables (pasky).
darkvater
parents:
337
diff
changeset
|
58 |
spritenum = _engine_original_sprites[engine]; |
|
527e47c8feec
(svn r570) -newgrf: Support for custom aircrafts via GRF files. Planeset seems to work :). Also use aircraft_vehinfo() instead of the old tables (pasky).
darkvater
parents:
337
diff
changeset
|
59 |
} |
|
527e47c8feec
(svn r570) -newgrf: Support for custom aircrafts via GRF files. Planeset seems to work :). Also use aircraft_vehinfo() instead of the old tables (pasky).
darkvater
parents:
337
diff
changeset
|
60 |
|
|
527e47c8feec
(svn r570) -newgrf: Support for custom aircrafts via GRF files. Planeset seems to work :). Also use aircraft_vehinfo() instead of the old tables (pasky).
darkvater
parents:
337
diff
changeset
|
61 |
DrawSprite((6 + _aircraft_sprite[spritenum]) | image_ormod, x, y); |
|
527e47c8feec
(svn r570) -newgrf: Support for custom aircrafts via GRF files. Planeset seems to work :). Also use aircraft_vehinfo() instead of the old tables (pasky).
darkvater
parents:
337
diff
changeset
|
62 |
|
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
63 |
if ((AircraftVehInfo(engine)->subtype & 1) == 0) |
| 0 | 64 |
DrawSprite(0xF3D, x, y-5); |
65 |
} |
|
66 |
||
67 |
void DrawAircraftEngineInfo(int engine, int x, int y, int maxw) |
|
68 |
{
|
|
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
69 |
const AircraftVehicleInfo *avi = AircraftVehInfo(engine); |
|
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
70 |
SetDParam(0, ((_price.aircraft_base >> 3) * avi->base_cost) >> 5); |
|
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
71 |
SetDParam(1, avi->max_speed << 3); |
|
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
72 |
SetDParam(2, avi->passanger_capacity); |
|
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
73 |
SetDParam(3, avi->mail_capacity); |
|
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
74 |
SetDParam(4, avi->running_cost * _price.aircraft_running >> 8); |
| 0 | 75 |
|
76 |
DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw); |
|
77 |
} |
|
78 |
||
79 |
/* Allocate many vehicles */ |
|
| 410 | 80 |
static bool AllocateVehicles(Vehicle **vl, int num) |
| 0 | 81 |
{
|
82 |
int i; |
|
83 |
Vehicle *v; |
|
84 |
bool success = true; |
|
85 |
||
86 |
for(i=0; i!=num; i++) {
|
|
87 |
vl[i] = v = AllocateVehicle(); |
|
88 |
if (v == NULL) {
|
|
89 |
success = false; |
|
90 |
break; |
|
91 |
} |
|
92 |
v->type = 1; |
|
93 |
} |
|
94 |
||
95 |
while (--i >= 0) {
|
|
96 |
vl[i]->type = 0; |
|
97 |
} |
|
98 |
||
99 |
return success; |
|
100 |
} |
|
101 |
||
102 |
static int32 EstimateAircraftCost(uint16 engine_type) |
|
103 |
{
|
|
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
104 |
return AircraftVehInfo(engine_type)->base_cost * (_price.aircraft_base>>3)>>5; |
| 0 | 105 |
} |
106 |
||
107 |
||
108 |
/* p1 = engine */ |
|
109 |
int32 CmdBuildAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
|
110 |
{
|
|
111 |
int32 value; |
|
112 |
Vehicle *vl[3], *v, *u, *w; |
|
113 |
byte unit_num; |
|
114 |
uint tile = TILE_FROM_XY(x,y); |
|
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
115 |
const AircraftVehicleInfo *avi = AircraftVehInfo(p1); |
| 0 | 116 |
Engine *e; |
117 |
||
118 |
SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES); |
|
119 |
||
120 |
value = EstimateAircraftCost(p1); |
|
121 |
||
122 |
if (flags & DC_QUERY_COST) |
|
123 |
return value; |
|
124 |
||
125 |
// allocate 2 or 3 vehicle structs, depending on type |
|
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
126 |
if (!AllocateVehicles(vl, (avi->subtype & 1) == 0 ? 3 : 2) || |
| 0 | 127 |
_ptr_to_next_order >= endof(_order_array)) |
128 |
return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME); |
|
129 |
||
130 |
unit_num = GetFreeUnitNumber(VEH_Aircraft); |
|
131 |
if (unit_num > _patches.max_aircraft) |
|
132 |
return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME); |
|
133 |
||
134 |
if (flags & DC_EXEC) {
|
|
135 |
v = vl[0]; |
|
136 |
u = vl[1]; |
|
137 |
||
138 |
v->unitnumber = unit_num; |
|
139 |
v->type = u->type = VEH_Aircraft; |
|
140 |
v->direction = 3; |
|
141 |
||
142 |
v->owner = u->owner = _current_player; |
|
143 |
||
144 |
v->tile = tile; |
|
145 |
// u->tile = 0; |
|
146 |
||
147 |
x = GET_TILE_X(tile)*16 + 5; |
|
148 |
y = GET_TILE_Y(tile)*16 + 3; |
|
149 |
||
150 |
v->x_pos = u->x_pos = x; |
|
151 |
v->y_pos = u->y_pos = y; |
|
152 |
||
153 |
u->z_pos = GetSlopeZ(x, y); |
|
154 |
v->z_pos = u->z_pos + 1; |
|
155 |
||
156 |
v->x_offs = v->y_offs = -1; |
|
157 |
// u->delta_x = u->delta_y = 0; |
|
158 |
||
159 |
v->sprite_width = v->sprite_height = 2; |
|
160 |
v->z_height = 5; |
|
161 |
||
162 |
u->sprite_width = u->sprite_height = 2; |
|
163 |
u->z_height = 1; |
|
164 |
||
165 |
v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL; |
|
166 |
u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER; |
|
167 |
||
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
168 |
v->spritenum = avi->image_index; |
| 0 | 169 |
// v->cargo_count = u->number_of_pieces = 0; |
170 |
||
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
171 |
v->cargo_cap = avi->passanger_capacity; |
|
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
172 |
u->cargo_cap = avi->mail_capacity; |
| 0 | 173 |
|
174 |
v->cargo_type = CT_PASSENGERS; |
|
175 |
u->cargo_type = CT_MAIL; |
|
176 |
||
177 |
v->string_id = STR_SV_AIRCRAFT_NAME; |
|
178 |
// v->next_order_param = v->next_order = 0; |
|
179 |
||
180 |
// v->load_unload_time_rem = 0; |
|
181 |
// v->progress = 0; |
|
182 |
v->last_station_visited = 0xFF; |
|
183 |
// v->destination_coords = 0; |
|
184 |
||
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
185 |
v->max_speed = avi->max_speed; |
|
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
186 |
v->acceleration = avi->acceleration; |
| 0 | 187 |
v->engine_type = (byte)p1; |
188 |
||
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
189 |
v->subtype = (avi->subtype & 1) == 0 ? 0 : 2; |
| 0 | 190 |
v->value = value; |
191 |
||
192 |
u->subtype = 4; |
|
193 |
||
194 |
e = &_engines[p1]; |
|
195 |
v->reliability = e->reliability; |
|
196 |
v->reliability_spd_dec = e->reliability_spd_dec; |
|
197 |
v->max_age = e->lifelength * 366; |
|
198 |
||
199 |
_new_aircraft_id = v->index; |
|
200 |
||
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
201 |
_ptr_to_next_order->type = OT_NOTHING; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
202 |
_ptr_to_next_order->flags = 0; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
203 |
v->schedule_ptr = _ptr_to_next_order++; |
| 0 | 204 |
// the AI doesn't click on a tile to build airplanes, so the below code will |
205 |
// never work. Therefore just assume the AI's planes always come from Hangar0 |
|
|
84
1e0721c29bad
(svn r85) -Add: initial commit of new AI (enable in Patch menu)
truelight
parents:
76
diff
changeset
|
206 |
// On hold for NewAI |
|
1e0721c29bad
(svn r85) -Add: initial commit of new AI (enable in Patch menu)
truelight
parents:
76
diff
changeset
|
207 |
v->u.air.pos = (!_patches.ainew_active && _is_ai_player) ? 0:MAX_ELEMENTS; |
| 0 | 208 |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
209 |
/* When we click on hangar we know the tile (it is in var 'tile')it is on. By that we know |
|
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
210 |
its position in the array of depots the airport has.....we can search |
| 0 | 211 |
->layout for #th position of depot. Since layout must start with depots, it is simple |
212 |
*/ |
|
213 |
{
|
|
214 |
Station *st; |
|
215 |
const AirportFTAClass *Airport; |
|
216 |
const uint16 *cur_depot; |
|
217 |
byte i = 0; |
|
218 |
st = DEREF_STATION(_map2[tile]); |
|
219 |
Airport = GetAirport(st->airport_type); |
|
220 |
// first element of depot array contains #of depots on the airport |
|
221 |
for (cur_depot=&Airport->airport_depots[1]; i != Airport->airport_depots[0]; cur_depot++) {
|
|
222 |
if ((uint)(st->airport_tile + *cur_depot) == tile) {
|
|
223 |
assert(Airport->layout[i].heading == HANGAR); |
|
224 |
v->u.air.pos = Airport->layout[i].position; |
|
225 |
break; |
|
226 |
} |
|
227 |
i++; |
|
228 |
} |
|
229 |
// to ensure v->u.air.pos has been given a value |
|
230 |
assert(v->u.air.pos != MAX_ELEMENTS); |
|
231 |
} |
|
232 |
||
233 |
v->u.air.state = HANGAR; |
|
234 |
v->u.air.previous_pos = v->u.air.pos; |
|
235 |
v->u.air.targetairport = _map2[tile]; |
|
236 |
v->next = u; |
|
237 |
||
238 |
v->service_interval = _patches.servint_aircraft; |
|
239 |
||
240 |
v->date_of_last_service = _date; |
|
241 |
v->build_year = _cur_year; |
|
242 |
||
243 |
v->cur_image = u->cur_image = 0xEA0; |
|
244 |
||
245 |
VehiclePositionChanged(v); |
|
246 |
VehiclePositionChanged(u); |
|
247 |
||
248 |
// Aircraft with 3 vehicles? |
|
249 |
if (v->subtype == 0) {
|
|
250 |
w = vl[2]; |
|
251 |
||
252 |
u->next = w; |
|
253 |
||
254 |
w->type = VEH_Aircraft; |
|
255 |
w->direction = 0; |
|
256 |
w->owner = _current_player; |
|
257 |
w->x_pos = v->x_pos; |
|
258 |
w->y_pos = v->y_pos; |
|
259 |
w->z_pos = v->z_pos + 5; |
|
260 |
w->x_offs = w->y_offs = -1; |
|
261 |
w->sprite_width = w->sprite_height = 2; |
|
262 |
w->z_height = 1; |
|
263 |
w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE; |
|
264 |
w->subtype = 6; |
|
265 |
w->cur_image = 0xF3D; |
|
266 |
VehiclePositionChanged(w); |
|
267 |
} |
|
268 |
||
269 |
InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); |
|
|
164
0cbdf3c9bde1
(svn r165) -Feature: Option to sort vehicles in vehicle-list window by different criteria. Total independent sort for all types and players. Periodic resort of list every 10 TTD days. Thank you for your graphical inspiration follow and buxo (since none of you provided any code).
darkvater
parents:
156
diff
changeset
|
270 |
_vehicle_sort_dirty[VEHAIRCRAFT] = true; // build aircraft |
| 0 | 271 |
InvalidateWindow(WC_AIRCRAFT_LIST, v->owner); |
272 |
InvalidateWindow(WC_COMPANY, v->owner); |
|
273 |
} |
|
274 |
||
275 |
return value; |
|
276 |
} |
|
277 |
||
278 |
bool IsAircraftHangarTile(TileIndex tile) |
|
279 |
{
|
|
280 |
// 0x56 - hangar facing other way international airport (86) |
|
281 |
// 0x20 - hangar large airport (32) |
|
282 |
// 0x41 - hangar small airport (65) |
|
283 |
return IS_TILETYPE(tile, MP_STATION) && |
|
284 |
(_map5[tile] == 32 || _map5[tile] == 65 || _map5[tile] == 86); |
|
285 |
} |
|
286 |
||
287 |
static bool CheckStoppedInHangar(Vehicle *v) |
|
288 |
{
|
|
289 |
if (!(v->vehstatus&VS_STOPPED) || |
|
290 |
!IsAircraftHangarTile(v->tile)) {
|
|
291 |
_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED; |
|
292 |
return false; |
|
293 |
} |
|
294 |
||
295 |
return true; |
|
296 |
} |
|
297 |
||
298 |
||
| 410 | 299 |
static void DoDeleteAircraft(Vehicle *v) |
| 0 | 300 |
{
|
301 |
DeleteWindowById(WC_VEHICLE_VIEW, v->index); |
|
|
164
0cbdf3c9bde1
(svn r165) -Feature: Option to sort vehicles in vehicle-list window by different criteria. Total independent sort for all types and players. Periodic resort of list every 10 TTD days. Thank you for your graphical inspiration follow and buxo (since none of you provided any code).
darkvater
parents:
156
diff
changeset
|
302 |
_vehicle_sort_dirty[VEHAIRCRAFT] = true; // delete aircraft |
| 0 | 303 |
InvalidateWindow(WC_AIRCRAFT_LIST, v->owner); |
304 |
InvalidateWindow(WC_COMPANY, v->owner); |
|
305 |
DeleteVehicleChain(v); |
|
306 |
} |
|
307 |
||
308 |
// p1 = vehicle |
|
309 |
int32 CmdSellAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
|
310 |
{
|
|
311 |
Vehicle *v; |
|
312 |
||
313 |
SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES); |
|
314 |
||
315 |
v = &_vehicles[p1]; |
|
316 |
||
317 |
if (!CheckOwnership(v->owner) || !CheckStoppedInHangar(v)) |
|
318 |
return CMD_ERROR; |
|
319 |
||
320 |
if (flags & DC_EXEC) {
|
|
321 |
// Invalidate depot |
|
322 |
InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); |
|
323 |
||
324 |
DoDeleteAircraft(v); |
|
325 |
||
326 |
} |
|
327 |
||
328 |
return -(int32)v->value; |
|
329 |
} |
|
330 |
||
331 |
// p1 = vehicle |
|
332 |
int32 CmdStartStopAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
|
333 |
{
|
|
334 |
Vehicle *v; |
|
335 |
||
336 |
v = &_vehicles[p1]; |
|
337 |
||
338 |
if (!CheckOwnership(v->owner)) |
|
339 |
return CMD_ERROR; |
|
340 |
||
341 |
// cannot stop airplane when in flight, or when taking off / landing |
|
342 |
if (v->u.air.state >= STARTTAKEOFF) {
|
|
343 |
return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT); |
|
344 |
} |
|
345 |
||
346 |
if (flags & DC_EXEC) {
|
|
347 |
v->vehstatus ^= VS_STOPPED; |
|
348 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, 4); |
|
349 |
InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); |
|
350 |
} |
|
351 |
||
352 |
return 0; |
|
353 |
} |
|
354 |
||
355 |
// p1 = vehicle |
|
356 |
int32 CmdSendAircraftToHangar(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
|
357 |
{
|
|
358 |
Vehicle *v; |
|
359 |
Station *st; |
|
360 |
||
361 |
v = &_vehicles[p1]; |
|
362 |
||
363 |
if (!CheckOwnership(v->owner)) |
|
364 |
return CMD_ERROR; |
|
365 |
||
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
366 |
if (v->current_order.type == OT_GOTO_DEPOT) {
|
| 0 | 367 |
if (flags & DC_EXEC) {
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
368 |
if (v->current_order.flags & OF_UNLOAD) v->cur_order_index++; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
369 |
v->current_order.type = OT_DUMMY; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
370 |
v->current_order.flags = 0; |
| 0 | 371 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, 4); |
372 |
} |
|
373 |
} else {
|
|
374 |
st = DEREF_STATION(v->u.air.targetairport); |
|
375 |
// If an airport doesn't have terminals (so no landing space for airports), |
|
376 |
// it surely doesn't have any hangars |
|
377 |
if (st->xy == 0 || st->airport_tile == 0 || GetAirport(st->airport_type)->nofterminals == 0) |
|
378 |
return CMD_ERROR; |
|
379 |
||
380 |
if (flags & DC_EXEC) {
|
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
381 |
v->current_order.type = OT_GOTO_DEPOT; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
382 |
v->current_order.flags = OF_NON_STOP | OF_FULL_LOAD; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
383 |
v->current_order.station = v->u.air.targetairport; |
| 0 | 384 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, 4); |
385 |
} |
|
386 |
} |
|
387 |
||
388 |
return 0; |
|
389 |
} |
|
390 |
||
391 |
// p1 = vehicle |
|
392 |
// p2 = new service int |
|
393 |
int32 CmdChangeAircraftServiceInt(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
|
394 |
{
|
|
395 |
Vehicle *v; |
|
396 |
||
397 |
v = &_vehicles[p1]; |
|
398 |
||
399 |
if (!CheckOwnership(v->owner)) |
|
400 |
return CMD_ERROR; |
|
401 |
||
402 |
if (flags & DC_EXEC) {
|
|
403 |
v->service_interval = (uint16)p2; |
|
404 |
InvalidateWindowWidget(WC_VEHICLE_DETAILS, v->index, 7); |
|
405 |
} |
|
406 |
||
407 |
return 0; |
|
408 |
} |
|
409 |
||
410 |
// p1 = vehicle |
|
411 |
// p2 = new cargo type |
|
412 |
int32 CmdRefitAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
|
413 |
{
|
|
414 |
Vehicle *v,*u; |
|
415 |
int pass, mail; |
|
416 |
int32 cost; |
|
417 |
||
418 |
SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN); |
|
419 |
||
420 |
v = &_vehicles[p1]; |
|
421 |
if (!CheckOwnership(v->owner) || !CheckStoppedInHangar(v)) |
|
422 |
return CMD_ERROR; |
|
423 |
||
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
424 |
pass = AircraftVehInfo(v->engine_type)->passanger_capacity; |
| 0 | 425 |
if (p2 != 0) {
|
426 |
pass >>= 1; |
|
427 |
if (p2 != 5) |
|
428 |
pass >>= 1; |
|
429 |
} |
|
430 |
_aircraft_refit_capacity = pass; |
|
431 |
||
432 |
cost = 0; |
|
433 |
if (IS_HUMAN_PLAYER(v->owner) && (byte)p2 != v->cargo_type) {
|
|
434 |
cost = _price.aircraft_base >> 7; |
|
435 |
} |
|
436 |
||
437 |
if (flags & DC_EXEC) {
|
|
438 |
v->cargo_cap = pass; |
|
439 |
||
440 |
u = v->next; |
|
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
441 |
mail = AircraftVehInfo(v->engine_type)->mail_capacity; |
| 0 | 442 |
if (p2 != 0) {
|
443 |
mail = 0; |
|
444 |
} |
|
445 |
u->cargo_cap = mail; |
|
446 |
v->cargo_count = u->cargo_count = 0; |
|
447 |
v->cargo_type = (byte)p2; |
|
448 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
|
449 |
} |
|
450 |
||
451 |
return cost; |
|
452 |
} |
|
453 |
||
454 |
void HandleClickOnAircraft(Vehicle *v) |
|
455 |
{
|
|
456 |
ShowAircraftViewWindow(v); |
|
457 |
} |
|
458 |
||
459 |
static void CheckIfAircraftNeedsService(Vehicle *v) |
|
460 |
{
|
|
461 |
Station *st; |
|
462 |
||
|
76
30511cbc5188
(svn r77) -Fix: [1010788] AI service interval bug (tnx truesatan)
truelight
parents:
70
diff
changeset
|
463 |
if (_patches.servint_aircraft == 0) |
|
11
836bc4b37b5b
(svn r12) Change: removed patch no_train_service. Instead you can set the default service interval for any vehicle type to 'disabled'.
dominik
parents:
0
diff
changeset
|
464 |
return; |
|
836bc4b37b5b
(svn r12) Change: removed patch no_train_service. Instead you can set the default service interval for any vehicle type to 'disabled'.
dominik
parents:
0
diff
changeset
|
465 |
|
|
156
8fef5e5752d6
(svn r157) -Feature: [1009708] Percent-based service intervals. Send a vehicle to depot after it has lost X% of its reliability (mivlad)
darkvater
parents:
99
diff
changeset
|
466 |
if (SERVICE_INTERVAL) |
| 0 | 467 |
return; |
468 |
||
469 |
if (v->vehstatus & VS_STOPPED) |
|
470 |
return; |
|
471 |
||
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
472 |
if (v->current_order.type == OT_GOTO_DEPOT && |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
473 |
v->current_order.flags & OF_FULL_LOAD) |
| 0 | 474 |
return; |
475 |
||
|
76
30511cbc5188
(svn r77) -Fix: [1010788] AI service interval bug (tnx truesatan)
truelight
parents:
70
diff
changeset
|
476 |
if (_patches.gotodepot && ScheduleHasDepotOrders(v->schedule_ptr)) |
| 0 | 477 |
return; |
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
478 |
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
479 |
st = DEREF_STATION(v->current_order.station); |
| 0 | 480 |
// only goto depot if the target airport has terminals (eg. it is airport) |
481 |
if (st->xy != 0 && st->airport_tile != 0 && GetAirport(st->airport_type)->nofterminals != 0) {
|
|
482 |
// printf("targetairport = %d, st->index = %d\n", v->u.air.targetairport, st->index);
|
|
483 |
// v->u.air.targetairport = st->index; |
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
484 |
v->current_order.type = OT_GOTO_DEPOT; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
485 |
v->current_order.flags = OF_NON_STOP; |
| 0 | 486 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, 4); |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
487 |
} else if (v->current_order.type == OT_GOTO_DEPOT) {
|
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
488 |
v->current_order.type = OT_DUMMY; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
489 |
v->current_order.flags = 0; |
| 0 | 490 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, 4); |
491 |
} |
|
492 |
} |
|
493 |
||
494 |
void OnNewDay_Aircraft(Vehicle *v) |
|
495 |
{
|
|
496 |
int32 cost; |
|
497 |
||
498 |
if (v->subtype > 2) |
|
499 |
return; |
|
500 |
||
501 |
if ((++v->day_counter & 7) == 0) |
|
502 |
DecreaseVehicleValue(v); |
|
503 |
||
|
19
6080d2b6a959
(svn r20) Feature: warning when a vehicle has invalid orders (celestar)
dominik
parents:
11
diff
changeset
|
504 |
CheckOrders(v); |
|
6080d2b6a959
(svn r20) Feature: warning when a vehicle has invalid orders (celestar)
dominik
parents:
11
diff
changeset
|
505 |
|
| 0 | 506 |
CheckVehicleBreakdown(v); |
507 |
AgeVehicle(v); |
|
508 |
CheckIfAircraftNeedsService(v); |
|
509 |
||
510 |
if (v->vehstatus & VS_STOPPED) |
|
511 |
return; |
|
512 |
||
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
513 |
cost = AircraftVehInfo(v->engine_type)->running_cost * _price.aircraft_running / 364; |
| 0 | 514 |
|
515 |
v->profit_this_year -= cost >> 8; |
|
516 |
||
517 |
SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN); |
|
518 |
SubtractMoneyFromPlayerFract(v->owner, cost); |
|
519 |
||
520 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
|
521 |
InvalidateWindow(WC_AIRCRAFT_LIST, v->owner); |
|
522 |
} |
|
523 |
||
524 |
void AircraftYearlyLoop() |
|
525 |
{
|
|
526 |
Vehicle *v; |
|
527 |
||
528 |
FOR_ALL_VEHICLES(v) {
|
|
529 |
if (v->type == VEH_Aircraft && v->subtype <= 2) {
|
|
530 |
v->profit_last_year = v->profit_this_year; |
|
531 |
v->profit_this_year = 0; |
|
532 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
|
533 |
} |
|
534 |
} |
|
535 |
} |
|
536 |
||
537 |
static void AgeAircraftCargo(Vehicle *v) |
|
538 |
{
|
|
539 |
if (_age_cargo_skip_counter != 0) |
|
540 |
return; |
|
541 |
||
542 |
do {
|
|
543 |
if (v->cargo_days != 0xFF) |
|
544 |
v->cargo_days++; |
|
545 |
} while ( (v=v->next) != NULL ); |
|
546 |
} |
|
547 |
||
548 |
static void HelicopterTickHandler(Vehicle *v) |
|
549 |
{
|
|
550 |
Vehicle *u; |
|
551 |
int tick,spd; |
|
552 |
uint16 img; |
|
553 |
||
554 |
u = v->next->next; |
|
555 |
||
556 |
if (u->vehstatus & VS_HIDDEN) |
|
557 |
return; |
|
558 |
||
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
559 |
// if true, helicopter rotors do not rotate. This should only be the case if a helicopter is |
| 0 | 560 |
// loading/unloading at a terminal or stopped |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
561 |
if (v->current_order.type == OT_LOADING || (v->vehstatus & VS_STOPPED)) {
|
| 0 | 562 |
if (u->cur_speed != 0) {
|
563 |
u->cur_speed++; |
|
564 |
if (u->cur_speed >= 0x80 && u->cur_image == 0xF40) {
|
|
565 |
u->cur_speed = 0; |
|
566 |
} |
|
567 |
} |
|
568 |
} else {
|
|
569 |
if (u->cur_speed == 0) |
|
570 |
u->cur_speed = 0x70; |
|
571 |
||
572 |
if (u->cur_speed >= 0x50) |
|
573 |
u->cur_speed--; |
|
574 |
} |
|
575 |
||
576 |
tick = ++u->tick_counter; |
|
577 |
spd = u->cur_speed >> 4; |
|
578 |
||
579 |
if (spd == 0) {
|
|
580 |
img = 0xF3D; |
|
581 |
if (u->cur_image == img) |
|
582 |
return; |
|
583 |
} else if (tick >= spd) {
|
|
584 |
u->tick_counter = 0; |
|
585 |
img = u->cur_image + 1; |
|
586 |
if (img > 0xF40) |
|
587 |
img = 0xF3E; |
|
588 |
} else |
|
589 |
return; |
|
590 |
||
591 |
u->cur_image=img; |
|
592 |
||
593 |
BeginVehicleMove(u); |
|
594 |
VehiclePositionChanged(u); |
|
595 |
EndVehicleMove(u); |
|
596 |
} |
|
597 |
||
598 |
static void SetAircraftPosition(Vehicle *v, int x, int y, int z) |
|
599 |
{
|
|
600 |
Vehicle *u; |
|
601 |
int yt; |
|
602 |
||
603 |
v->x_pos = x; |
|
604 |
v->y_pos = y; |
|
605 |
v->z_pos = z; |
|
606 |
||
607 |
v->cur_image = GetAircraftImage(v, v->direction); |
|
608 |
||
609 |
BeginVehicleMove(v); |
|
610 |
VehiclePositionChanged(v); |
|
611 |
EndVehicleMove(v); |
|
612 |
||
613 |
u = v->next; |
|
614 |
||
615 |
yt = y - ((v->z_pos-GetSlopeZ(x, y-1)) >> 3); |
|
616 |
u->x_pos = x; |
|
617 |
u->y_pos = yt; |
|
618 |
u->z_pos = GetSlopeZ(x,yt); |
|
619 |
u->cur_image = v->cur_image; |
|
620 |
||
621 |
BeginVehicleMove(u); |
|
622 |
VehiclePositionChanged(u); |
|
623 |
EndVehicleMove(u); |
|
624 |
||
625 |
if ((u=u->next) != NULL) {
|
|
626 |
u->x_pos = x; |
|
627 |
u->y_pos = y; |
|
628 |
u->z_pos = z + 5; |
|
629 |
||
630 |
BeginVehicleMove(u); |
|
631 |
VehiclePositionChanged(u); |
|
632 |
EndVehicleMove(u); |
|
633 |
} |
|
634 |
} |
|
635 |
||
636 |
static void ServiceAircraft(Vehicle *v) |
|
637 |
{
|
|
638 |
Vehicle *u; |
|
639 |
||
640 |
v->cur_speed = 0; |
|
641 |
v->subspeed = 0; |
|
642 |
v->progress = 0; |
|
643 |
v->vehstatus |= VS_HIDDEN; |
|
644 |
||
645 |
u = v->next; |
|
646 |
u->vehstatus |= VS_HIDDEN; |
|
647 |
if ((u=u->next) != NULL) {
|
|
648 |
u->vehstatus |= VS_HIDDEN; |
|
649 |
u->cur_speed = 0; |
|
650 |
} |
|
651 |
||
652 |
SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos); |
|
653 |
InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); |
|
654 |
||
655 |
v->date_of_last_service = _date; |
|
656 |
v->breakdowns_since_last_service = 0; |
|
657 |
v->reliability = _engines[v->engine_type].reliability; |
|
658 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
|
659 |
} |
|
660 |
||
661 |
static void PlayAircraftSound(Vehicle *v) |
|
662 |
{
|
|
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
663 |
SndPlayVehicleFx(AircraftVehInfo(v->engine_type)->sfx, v); |
| 0 | 664 |
} |
665 |
||
666 |
static bool UpdateAircraftSpeed(Vehicle *v) |
|
667 |
{
|
|
668 |
uint spd = v->acceleration * 2; |
|
669 |
byte t; |
|
670 |
||
671 |
v->subspeed = (t=v->subspeed) + (byte)spd; |
|
672 |
spd = min( v->cur_speed + (spd >> 8) + (v->subspeed < t), v->max_speed); |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
673 |
|
| 0 | 674 |
// adjust speed for broken vehicles |
675 |
if(v->vehstatus&VS_AIRCRAFT_BROKEN) spd = min(spd, 27); |
|
676 |
||
677 |
//updates statusbar only if speed have changed to save CPU time |
|
678 |
if (spd != v->cur_speed) {
|
|
679 |
v->cur_speed = spd; |
|
680 |
if (_patches.vehicle_speed) |
|
681 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, 4); |
|
682 |
} |
|
683 |
||
684 |
if (!(v->direction & 1)) {
|
|
685 |
spd = spd * 3 >> 2; |
|
686 |
} |
|
687 |
||
688 |
if (spd == 0) |
|
689 |
return false; |
|
690 |
||
691 |
if ((byte)++spd == 0) |
|
692 |
return true; |
|
693 |
||
694 |
v->progress = (t = v->progress) - (byte)spd; |
|
695 |
||
696 |
return (t < v->progress); |
|
697 |
} |
|
698 |
||
699 |
// get Aircraft running altitude |
|
700 |
static byte GetAircraftFlyingAltitude(const Vehicle *v) |
|
701 |
{
|
|
702 |
byte maxz = 162; |
|
703 |
if (v->max_speed != 37) {
|
|
704 |
maxz = 171; |
|
705 |
if (v->max_speed != 74) {maxz = 180;}
|
|
706 |
} |
|
707 |
return maxz; |
|
708 |
} |
|
709 |
||
710 |
static bool Aircraft_5(Vehicle *v) |
|
711 |
{
|
|
712 |
Station *st; |
|
713 |
const AirportMovingData *amd; |
|
714 |
Vehicle *u; |
|
715 |
byte z,dirdiff,newdir,maxz,curz; |
|
716 |
GetNewVehiclePosResult gp; |
|
717 |
uint dist; |
|
718 |
int x,y; |
|
719 |
||
720 |
st = DEREF_STATION(v->u.air.targetairport); |
|
721 |
||
722 |
// prevent going to 0,0 if airport is deleted. |
|
723 |
{
|
|
724 |
uint tile = st->airport_tile; |
|
725 |
if (tile == 0) tile = st->xy; |
|
726 |
// xy of destination |
|
727 |
x = GET_TILE_X(tile)*16; |
|
728 |
y = GET_TILE_Y(tile)*16; |
|
729 |
} |
|
730 |
||
731 |
// get airport moving data |
|
732 |
assert(v->u.air.pos < GetAirport(st->airport_type)->nofelements); |
|
733 |
amd = &_airport_moving_datas[st->airport_type][v->u.air.pos]; |
|
734 |
||
735 |
// Helicopter raise |
|
736 |
if (amd->flag & AMED_HELI_RAISE) {
|
|
737 |
u = v->next->next; |
|
738 |
||
739 |
// Make sure the rotors don't rotate too fast |
|
740 |
if (u->cur_speed > 32) {
|
|
741 |
v->cur_speed = 0; |
|
742 |
if (--u->cur_speed == 32) {
|
|
| 541 | 743 |
SndPlayVehicleFx(SND_18_HELICOPTER, v); |
| 0 | 744 |
} |
745 |
} else {
|
|
746 |
u->cur_speed = 32; |
|
747 |
if (UpdateAircraftSpeed(v)) {
|
|
748 |
v->tile = 0; |
|
749 |
||
750 |
// Reached altitude? |
|
751 |
if (v->z_pos >= 184) {
|
|
752 |
v->cur_speed = 0; |
|
753 |
return true; |
|
754 |
} |
|
755 |
SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos+1); |
|
756 |
} |
|
757 |
} |
|
758 |
return false; |
|
759 |
} |
|
760 |
||
761 |
// Helicopter landing. |
|
762 |
if (amd->flag & AMED_HELI_LOWER) {
|
|
763 |
if (UpdateAircraftSpeed(v)) {
|
|
764 |
if (st->airport_tile == 0) {
|
|
765 |
// FIXME - Aircraft_5 -> if station no longer exists, do not land |
|
766 |
// helicopter will circle until sign disappears, then go to next order |
|
767 |
// * what to do when it is the only order left, right now it just stays in 1 place |
|
768 |
v->u.air.state = FLYING; |
|
769 |
AircraftNextAirportPos_and_Order(v); |
|
770 |
return false; |
|
771 |
} |
|
772 |
||
773 |
// Vehicle is now at the airport. |
|
774 |
v->tile = st->airport_tile; |
|
775 |
||
776 |
// Find altitude of landing position. |
|
777 |
z = GetSlopeZ(x, y) + 1; |
|
778 |
if (st->airport_type == AT_OILRIG) z += 54; |
|
779 |
if (st->airport_type == AT_HELIPORT) z += 60; |
|
780 |
||
781 |
if (z == v->z_pos) {
|
|
782 |
u = v->next->next; |
|
783 |
||
784 |
// Increase speed of rotors. When speed is 80, we've landed. |
|
785 |
if (u->cur_speed >= 80) |
|
786 |
return true; |
|
787 |
u->cur_speed+=4; |
|
788 |
} else if (v->z_pos > z) {
|
|
789 |
SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos-1); |
|
790 |
} else {
|
|
791 |
SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos+1); |
|
792 |
} |
|
793 |
} |
|
794 |
return false; |
|
795 |
} |
|
796 |
||
797 |
// Get distance from destination pos to current pos. |
|
798 |
dist = myabs(x + amd->x - v->x_pos) + myabs(y + amd->y - v->y_pos); |
|
799 |
||
800 |
// Need exact position? |
|
801 |
if (!(amd->flag & AMED_EXACTPOS) && dist <= (uint)((amd->flag&AMED_SLOWTURN)?8:4)) |
|
802 |
return true; |
|
803 |
||
804 |
// At final pos? |
|
805 |
if (dist == 0) {
|
|
806 |
||
807 |
// Clamp speed to 12. |
|
808 |
if (v->cur_speed > 12) |
|
809 |
v->cur_speed = 12; |
|
810 |
||
811 |
// Change direction smoothly to final direction. |
|
812 |
dirdiff = amd->direction - v->direction; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
813 |
// if distance is 0, and plane points in right direction, no point in calling |
| 0 | 814 |
// UpdateAircraftSpeed(). So do it only afterwards |
815 |
if (dirdiff == 0) {
|
|
816 |
v->cur_speed = 0; |
|
817 |
return true; |
|
818 |
} |
|
819 |
||
820 |
if (!UpdateAircraftSpeed(v)) |
|
821 |
return false; |
|
822 |
||
823 |
v->direction = (v->direction+((dirdiff&7)<5?1:-1)) & 7; |
|
824 |
v->cur_speed >>= 1; |
|
825 |
||
826 |
SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos); |
|
827 |
return false; |
|
828 |
} |
|
829 |
||
830 |
// Clamp speed? |
|
831 |
if (!(amd->flag & AMED_NOSPDCLAMP) && v->cur_speed > 12) |
|
832 |
v->cur_speed = 12; |
|
833 |
||
834 |
if (!UpdateAircraftSpeed(v)) |
|
835 |
return false; |
|
836 |
||
837 |
// Decrease animation counter. |
|
838 |
if (v->load_unload_time_rem != 0) |
|
839 |
v->load_unload_time_rem--; |
|
840 |
||
841 |
// Turn. Do it slowly if in the air. |
|
842 |
newdir = GetDirectionTowards(v, x + amd->x, y + amd->y); |
|
843 |
if (newdir != v->direction) {
|
|
844 |
if (amd->flag & AMED_SLOWTURN) {
|
|
845 |
if (v->load_unload_time_rem == 0) {
|
|
846 |
v->load_unload_time_rem = 8; |
|
847 |
} |
|
| 99 | 848 |
v->direction = newdir; |
| 0 | 849 |
} else {
|
850 |
v->cur_speed >>= 1; |
|
851 |
v->direction = newdir; |
|
852 |
} |
|
853 |
} |
|
854 |
||
855 |
// Move vehicle. |
|
856 |
GetNewVehiclePos(v, &gp); |
|
857 |
v->tile = gp.new_tile; |
|
858 |
||
859 |
// If vehicle is in the air, use tile coordinate 0. |
|
860 |
if (amd->flag & (AMED_TAKEOFF | AMED_SLOWTURN | AMED_LAND)) {
|
|
861 |
v->tile = 0; |
|
862 |
} |
|
863 |
||
864 |
// Adjust Z for land or takeoff? |
|
865 |
z = v->z_pos; |
|
866 |
||
867 |
if (amd->flag & AMED_TAKEOFF) {
|
|
868 |
z+=2; |
|
869 |
// Determine running altitude |
|
870 |
maxz = GetAircraftFlyingAltitude(v); |
|
871 |
if (z > maxz) |
|
872 |
z = maxz; |
|
873 |
} |
|
874 |
||
875 |
if (amd->flag & AMED_LAND) {
|
|
876 |
if (st->airport_tile == 0) {
|
|
877 |
//FIXME -- FIXED - Aircraft_5 -> if station no longer exists, do not land |
|
878 |
// * what to do when it is the only order left, right now it just stays in 1 place? |
|
879 |
v->u.air.state = FLYING; |
|
880 |
AircraftNextAirportPos_and_Order(v); |
|
881 |
// get aircraft back on running altitude |
|
882 |
SetAircraftPosition(v, gp.x, gp.y, GetAircraftFlyingAltitude(v)); |
|
883 |
return false; |
|
884 |
} |
|
885 |
||
886 |
curz = GetSlopeZ(x, y) + 1; |
|
887 |
||
888 |
if (curz > z) {
|
|
889 |
z++; |
|
890 |
} else {
|
|
891 |
int t = max(1, dist-4); |
|
892 |
||
893 |
z -= ((z - curz) + t - 1) / t; |
|
894 |
if (z < curz) z = curz; |
|
895 |
} |
|
896 |
} |
|
897 |
||
898 |
// We've landed. Decrase speed when we're reaching end of runway. |
|
899 |
if (amd->flag & AMED_BRAKE) {
|
|
900 |
curz = GetSlopeZ(x, y) + 1; |
|
901 |
||
902 |
if (z > curz) z--; |
|
903 |
else if (z < curz) z++; |
|
904 |
||
905 |
if (dist < 64 && v->cur_speed > 12) |
|
906 |
v->cur_speed -= 4; |
|
907 |
} |
|
908 |
||
909 |
SetAircraftPosition(v, gp.x, gp.y, z); |
|
910 |
return false; |
|
911 |
} |
|
912 |
||
913 |
static const int8 _crashed_aircraft_moddir[4] = {
|
|
914 |
-1,0,0,1 |
|
915 |
}; |
|
916 |
||
917 |
static void HandleCrashedAircraft(Vehicle *v) |
|
918 |
{
|
|
919 |
uint32 r; |
|
920 |
Station *st; |
|
921 |
||
922 |
v->u.air.crashed_counter++; |
|
923 |
||
924 |
if (v->u.air.crashed_counter < 650) {
|
|
925 |
if (CHANCE16R(1,32,r)) {
|
|
926 |
v->direction = (v->direction+_crashed_aircraft_moddir[(r >> 16)&3]) & 7; |
|
927 |
SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos); |
|
928 |
r = Random(); |
|
929 |
CreateEffectVehicleRel(v, |
|
930 |
4 + (r&0xF), |
|
931 |
4 + ((r>>4)&0xF), |
|
932 |
((r>>8)&0xF), |
|
933 |
EV_DEMOLISH); |
|
934 |
} |
|
935 |
} else if (v->u.air.crashed_counter >= 10000) {
|
|
936 |
st = DEREF_STATION(v->u.air.targetairport); |
|
937 |
// remove rubble of crashed airplane |
|
938 |
||
939 |
// clear runway-in on all airports, set by crashing plane |
|
940 |
// small airports use AIRPORT_BUSY, city airports use RUNWAY_IN_OUT_block, etc. |
|
941 |
// but they all share the same number |
|
942 |
CLRBITS(st->airport_flags, RUNWAY_IN_block); |
|
943 |
||
944 |
BeginVehicleMove(v); |
|
945 |
EndVehicleMove(v); |
|
946 |
||
947 |
DoDeleteAircraft(v); |
|
948 |
} |
|
949 |
} |
|
950 |
||
951 |
static void HandleBrokenAircraft(Vehicle *v) |
|
952 |
{
|
|
953 |
if (v->breakdown_ctr != 1) {
|
|
954 |
v->breakdown_ctr = 1; |
|
955 |
v->vehstatus |= VS_AIRCRAFT_BROKEN; |
|
956 |
||
957 |
if (v->breakdowns_since_last_service != 255) |
|
958 |
v->breakdowns_since_last_service++; |
|
959 |
InvalidateWindow(WC_VEHICLE_VIEW, v->index); |
|
960 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
|
961 |
} |
|
962 |
} |
|
963 |
||
964 |
static const int8 _aircraft_smoke_xy[16] = {
|
|
965 |
5,6,5,0,-5,-6,-5,0, /* x coordinates */ |
|
966 |
5,0,-5,-6,-5,0,5,6, /* y coordinate */ |
|
967 |
}; |
|
968 |
||
969 |
static void HandleAircraftSmoke(Vehicle *v) |
|
970 |
{
|
|
971 |
if (!(v->vehstatus&VS_AIRCRAFT_BROKEN)) |
|
972 |
return; |
|
973 |
||
974 |
if (v->cur_speed < 10) {
|
|
975 |
v->vehstatus &= ~VS_AIRCRAFT_BROKEN; |
|
976 |
v->breakdown_ctr = 0; |
|
977 |
return; |
|
978 |
} |
|
979 |
||
980 |
if ((v->tick_counter & 0x1F) == 0) {
|
|
981 |
CreateEffectVehicleRel(v, |
|
982 |
_aircraft_smoke_xy[v->direction], |
|
983 |
_aircraft_smoke_xy[v->direction + 8], |
|
984 |
2, |
|
985 |
EV_SMOKE_3 |
|
986 |
); |
|
987 |
} |
|
988 |
} |
|
989 |
||
990 |
static void ProcessAircraftOrder(Vehicle *v) |
|
991 |
{
|
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
992 |
Order order; |
| 0 | 993 |
|
994 |
// OT_GOTO_DEPOT, OT_LOADING |
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
995 |
if (v->current_order.type >= OT_GOTO_DEPOT && |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
996 |
v->current_order.type <= OT_LOADING) {
|
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
997 |
if (v->current_order.type != OT_GOTO_DEPOT || |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
998 |
!(v->current_order.flags & OF_UNLOAD)) |
| 0 | 999 |
return; |
1000 |
} |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1001 |
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1002 |
if (v->current_order.type == OT_GOTO_DEPOT && |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1003 |
(v->current_order.flags & (OF_UNLOAD | OF_FULL_LOAD)) == (OF_UNLOAD | OF_FULL_LOAD) && |
|
156
8fef5e5752d6
(svn r157) -Feature: [1009708] Percent-based service intervals. Send a vehicle to depot after it has lost X% of its reliability (mivlad)
darkvater
parents:
99
diff
changeset
|
1004 |
SERVICE_INTERVAL) {
|
| 0 | 1005 |
v->cur_order_index++; |
1006 |
} |
|
1007 |
||
1008 |
if (v->cur_order_index >= v->num_orders) |
|
1009 |
v->cur_order_index = 0; |
|
1010 |
||
1011 |
order = v->schedule_ptr[v->cur_order_index]; |
|
1012 |
||
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1013 |
if (order.type == OT_NOTHING) {
|
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1014 |
v->current_order.type = OT_NOTHING; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1015 |
v->current_order.flags = 0; |
| 0 | 1016 |
return; |
1017 |
} |
|
1018 |
||
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1019 |
if (order.type == v->current_order.type && |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1020 |
order.flags == v->current_order.flags && |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1021 |
order.station == v->current_order.station) |
| 0 | 1022 |
return; |
1023 |
||
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1024 |
v->current_order = order; |
| 0 | 1025 |
|
1026 |
// orders are changed in flight, ensure going to the right station |
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1027 |
if (order.type == OT_GOTO_STATION && v->u.air.state == FLYING) {
|
| 0 | 1028 |
AircraftNextAirportPos_and_Order(v); |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1029 |
v->u.air.targetairport = order.station; |
| 0 | 1030 |
} |
1031 |
||
1032 |
InvalidateVehicleOrderWidget(v); |
|
1033 |
} |
|
1034 |
||
1035 |
static void HandleAircraftLoading(Vehicle *v, int mode) |
|
1036 |
{
|
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1037 |
if (v->current_order.type == OT_NOTHING) |
| 0 | 1038 |
return; |
1039 |
||
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1040 |
if (v->current_order.type != OT_DUMMY) {
|
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1041 |
if (v->current_order.type != OT_LOADING) |
| 0 | 1042 |
return; |
1043 |
||
1044 |
if (mode != 0) |
|
1045 |
return; |
|
1046 |
||
1047 |
if (--v->load_unload_time_rem) |
|
1048 |
return; |
|
1049 |
||
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1050 |
if (v->current_order.flags & OF_FULL_LOAD && CanFillVehicle(v)) {
|
| 0 | 1051 |
SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_INC); |
1052 |
LoadUnloadVehicle(v); |
|
1053 |
return; |
|
1054 |
} |
|
1055 |
||
1056 |
{
|
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1057 |
Order b = v->current_order; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1058 |
v->current_order.type = OT_NOTHING; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1059 |
v->current_order.flags = 0; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1060 |
if (!(b.flags & OF_NON_STOP)) |
| 0 | 1061 |
return; |
1062 |
} |
|
1063 |
} |
|
1064 |
v->cur_order_index++; |
|
1065 |
InvalidateVehicleOrderWidget(v); |
|
1066 |
} |
|
1067 |
||
1068 |
static void MaybeCrashAirplane(Vehicle *v) |
|
1069 |
{
|
|
1070 |
Station *st; |
|
1071 |
uint16 prob; |
|
1072 |
int i; |
|
1073 |
uint16 amt; |
|
1074 |
||
1075 |
st = DEREF_STATION(v->u.air.targetairport); |
|
1076 |
||
1077 |
//FIXME -- MaybeCrashAirplane -> increase crashing chances of very modern airplanes on smaller than AT_METROPOLITAN airports |
|
1078 |
prob = 0x10000 / 1500; |
|
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
1079 |
if (st->airport_type == AT_SMALL && (AircraftVehInfo(v->engine_type)->subtype & 2) && !_cheats.no_jetcrash.value) {
|
| 0 | 1080 |
prob = 0x10000 / 20; |
1081 |
} |
|
1082 |
||
1083 |
if ((uint16)Random() > prob) |
|
1084 |
return; |
|
1085 |
||
1086 |
// Crash the airplane. Remove all goods stored at the station. |
|
1087 |
for(i=0; i!=NUM_CARGO; i++) {
|
|
1088 |
st->goods[i].rating = 1; |
|
1089 |
st->goods[i].waiting_acceptance &= ~0xFFF; |
|
1090 |
} |
|
1091 |
||
1092 |
v->vehstatus |= VS_CRASHED; |
|
1093 |
v->u.air.crashed_counter = 0; |
|
1094 |
||
1095 |
CreateEffectVehicleRel(v, 4, 4, 8, EV_CRASHED_SMOKE); |
|
1096 |
||
1097 |
InvalidateWindow(WC_VEHICLE_VIEW, v->index); |
|
1098 |
||
1099 |
amt = 2; |
|
1100 |
if (v->cargo_type == CT_PASSENGERS) amt += v->cargo_count; |
|
|
534
306bc86eb23e
(svn r901) Small step in the process to clean up the DPARAM mess:
tron
parents:
507
diff
changeset
|
1101 |
SetDParam(0, amt); |
| 0 | 1102 |
|
1103 |
v->cargo_count = 0; |
|
1104 |
v->next->cargo_count = 0, |
|
1105 |
||
|
534
306bc86eb23e
(svn r901) Small step in the process to clean up the DPARAM mess:
tron
parents:
507
diff
changeset
|
1106 |
SetDParam(1, st->index); |
| 0 | 1107 |
AddNewsItem(STR_A034_PLANE_CRASH_DIE_IN_FIREBALL, |
1108 |
NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ACCIDENT, 0), |
|
1109 |
v->index, |
|
1110 |
0); |
|
1111 |
||
1112 |
ModifyStationRatingAround(TILE_FROM_XY(v->x_pos, v->y_pos), v->owner, -160, 30); |
|
| 541 | 1113 |
SndPlayVehicleFx(SND_12_EXPLOSION, v); |
| 0 | 1114 |
} |
1115 |
||
1116 |
// we've landed and just arrived at a terminal |
|
1117 |
static void AircraftEntersTerminal(Vehicle *v) |
|
1118 |
{
|
|
1119 |
Station *st; |
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1120 |
Order old_order; |
| 0 | 1121 |
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1122 |
if (v->current_order.type == OT_GOTO_DEPOT) |
| 0 | 1123 |
return; |
1124 |
||
1125 |
st = DEREF_STATION(v->u.air.targetairport); |
|
1126 |
v->last_station_visited = v->u.air.targetairport; |
|
1127 |
||
1128 |
/* Check if station was ever visited before */ |
|
1129 |
if (!(st->had_vehicle_of_type & HVOT_AIRCRAFT)) {
|
|
1130 |
uint32 flags; |
|
1131 |
||
1132 |
st->had_vehicle_of_type |= HVOT_AIRCRAFT; |
|
|
534
306bc86eb23e
(svn r901) Small step in the process to clean up the DPARAM mess:
tron
parents:
507
diff
changeset
|
1133 |
SetDParam(0, st->index); |
| 0 | 1134 |
// show newsitem of celebrating citizens |
1135 |
flags = (v->owner == _local_player) ? NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_PLAYER, 0) : NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_OTHER, 0); |
|
1136 |
AddNewsItem( |
|
1137 |
STR_A033_CITIZENS_CELEBRATE_FIRST, |
|
1138 |
flags, |
|
1139 |
v->index, |
|
1140 |
0); |
|
1141 |
} |
|
1142 |
||
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1143 |
old_order = v->current_order; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1144 |
v->current_order.type = OT_LOADING; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1145 |
v->current_order.flags = 0; |
| 0 | 1146 |
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1147 |
if (old_order.type == OT_GOTO_STATION && |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1148 |
v->current_order.station == v->last_station_visited) {
|
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1149 |
v->current_order.flags = |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1150 |
(old_order.flags & (OF_FULL_LOAD | OF_UNLOAD)) | OF_NON_STOP; |
| 0 | 1151 |
} |
1152 |
||
1153 |
SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_INC); |
|
1154 |
LoadUnloadVehicle(v); |
|
1155 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, 4); |
|
1156 |
} |
|
1157 |
||
1158 |
static void AircraftEnterHangar(Vehicle *v) |
|
1159 |
{
|
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1160 |
Order old_order; |
| 0 | 1161 |
|
1162 |
ServiceAircraft(v); |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1163 |
|
| 0 | 1164 |
MaybeRenewVehicle(v, EstimateAircraftCost(v->engine_type)); |
1165 |
||
|
445
beafc0fb8f12
(svn r654) Hopefully complete support for randomized variational spritegroups (i.e. the cars transporter in DBSetXL gets different cars each time) (pasky)
tron
parents:
410
diff
changeset
|
1166 |
TriggerVehicle(v, VEHICLE_TRIGGER_DEPOT); |
|
beafc0fb8f12
(svn r654) Hopefully complete support for randomized variational spritegroups (i.e. the cars transporter in DBSetXL gets different cars each time) (pasky)
tron
parents:
410
diff
changeset
|
1167 |
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1168 |
if (v->current_order.type == OT_GOTO_DEPOT) {
|
| 0 | 1169 |
InvalidateWindow(WC_VEHICLE_VIEW, v->index); |
1170 |
||
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1171 |
old_order = v->current_order; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1172 |
v->current_order.type = OT_NOTHING; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1173 |
v->current_order.flags = 0; |
| 0 | 1174 |
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1175 |
if (old_order.flags & OF_UNLOAD) {
|
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1176 |
v->cur_order_index++; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1177 |
} else if (old_order.flags & OF_FULL_LOAD) { // force depot visit
|
| 0 | 1178 |
v->vehstatus |= VS_STOPPED; |
1179 |
||
1180 |
if (v->owner == _local_player) {
|
|
|
534
306bc86eb23e
(svn r901) Small step in the process to clean up the DPARAM mess:
tron
parents:
507
diff
changeset
|
1181 |
SetDParam(0, v->unitnumber); |
| 0 | 1182 |
AddNewsItem( |
1183 |
STR_A014_AIRCRAFT_IS_WAITING_IN, |
|
1184 |
NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0), |
|
1185 |
v->index, |
|
1186 |
0); |
|
1187 |
} |
|
1188 |
} |
|
1189 |
} |
|
1190 |
} |
|
1191 |
||
1192 |
static void AircraftLand(Vehicle *v) |
|
1193 |
{
|
|
1194 |
v->sprite_width = v->sprite_height = 2; |
|
1195 |
} |
|
1196 |
||
1197 |
static void AircraftLandAirplane(Vehicle *v) |
|
1198 |
{
|
|
1199 |
AircraftLand(v); |
|
| 541 | 1200 |
SndPlayVehicleFx(SND_17_SKID_PLANE, v); |
| 0 | 1201 |
MaybeCrashAirplane(v); |
1202 |
} |
|
1203 |
||
1204 |
// set the right pos when heading to other airports after takeoff |
|
1205 |
static void AircraftNextAirportPos_and_Order(Vehicle *v) |
|
1206 |
{
|
|
1207 |
Station *st; |
|
1208 |
const AirportFTAClass *Airport; |
|
1209 |
||
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1210 |
if (v->current_order.type == OT_GOTO_STATION || |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1211 |
v->current_order.type == OT_GOTO_DEPOT) |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1212 |
v->u.air.targetairport = v->current_order.station; |
| 0 | 1213 |
|
1214 |
st = DEREF_STATION(v->u.air.targetairport); |
|
1215 |
Airport = GetAirport(st->airport_type); |
|
1216 |
v->u.air.pos = v->u.air.previous_pos = Airport->entry_point; |
|
1217 |
} |
|
1218 |
||
1219 |
static void AircraftLeaveHangar(Vehicle *v) |
|
1220 |
{
|
|
1221 |
v->cur_speed = 0; |
|
1222 |
v->subspeed = 0; |
|
1223 |
v->progress = 0; |
|
1224 |
v->direction = 3; |
|
1225 |
v->vehstatus &= ~VS_HIDDEN; |
|
1226 |
{
|
|
1227 |
Vehicle *u = v->next; |
|
1228 |
u->vehstatus &= ~VS_HIDDEN; |
|
1229 |
||
1230 |
// Rotor blades |
|
1231 |
if ((u=u->next) != NULL) {
|
|
1232 |
u->vehstatus &= ~VS_HIDDEN; |
|
1233 |
u->cur_speed = 80; |
|
1234 |
} |
|
1235 |
} |
|
1236 |
||
1237 |
SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos); |
|
1238 |
InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); |
|
1239 |
} |
|
1240 |
||
1241 |
||
1242 |
//////////////////////////////////////////////////////////////////////////////// |
|
1243 |
/////////////////// AIRCRAFT MOVEMENT SCHEME //////////////////////////////// |
|
1244 |
//////////////////////////////////////////////////////////////////////////////// |
|
1245 |
static void AircraftEventHandler_EnterTerminal(Vehicle *v, const AirportFTAClass *Airport) |
|
1246 |
{
|
|
1247 |
AircraftEntersTerminal(v); |
|
1248 |
v->u.air.state = Airport->layout[v->u.air.pos].heading; |
|
1249 |
} |
|
1250 |
||
1251 |
static void AircraftEventHandler_EnterHangar(Vehicle *v, const AirportFTAClass *Airport) |
|
1252 |
{
|
|
1253 |
AircraftEnterHangar(v); |
|
1254 |
v->u.air.state = Airport->layout[v->u.air.pos].heading; |
|
1255 |
} |
|
1256 |
||
1257 |
// In an Airport Hangar |
|
1258 |
static void AircraftEventHandler_InHangar(Vehicle *v, const AirportFTAClass *Airport) |
|
1259 |
{
|
|
1260 |
// if we just arrived, execute EnterHangar first |
|
1261 |
if (v->u.air.previous_pos != v->u.air.pos) {
|
|
1262 |
AircraftEventHandler_EnterHangar(v, Airport); |
|
1263 |
return; |
|
1264 |
} |
|
1265 |
||
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1266 |
// if we were sent to the depot, stay there |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1267 |
if (v->current_order.type == OT_GOTO_DEPOT && (v->vehstatus & VS_STOPPED)) {
|
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1268 |
v->current_order.type = OT_NOTHING; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1269 |
v->current_order.flags = 0; |
| 0 | 1270 |
return; |
1271 |
} |
|
1272 |
||
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1273 |
if (v->current_order.type != OT_GOTO_STATION && |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1274 |
v->current_order.type != OT_GOTO_DEPOT) |
| 0 | 1275 |
return; |
1276 |
||
1277 |
// if the block of the next position is busy, stay put |
|
1278 |
if (AirportHasBlock(v, &Airport->layout[v->u.air.pos], Airport)) {return;}
|
|
1279 |
||
1280 |
// We are already at the target airport, we need to find a terminal |
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1281 |
if (v->current_order.station == v->u.air.targetairport) {
|
| 0 | 1282 |
// FindFreeTerminal: |
1283 |
// 1. Find a free terminal, 2. Occupy it, 3. Set the vehicle's state to that terminal |
|
1284 |
if (v->subtype != 0) {if(!AirportFindFreeTerminal(v, Airport)) {return;}} // airplane
|
|
1285 |
else {if(!AirportFindFreeHelipad(v, Airport)) {return;}} // helicopter
|
|
1286 |
} |
|
1287 |
else { // Else prepare for launch.
|
|
1288 |
// airplane goto state takeoff, helicopter to helitakeoff |
|
1289 |
v->u.air.state = (v->subtype != 0) ? TAKEOFF : HELITAKEOFF; |
|
1290 |
} |
|
1291 |
AircraftLeaveHangar(v); |
|
1292 |
AirportMove(v, Airport); |
|
1293 |
} |
|
1294 |
||
1295 |
// At one of the Airport's Terminals |
|
1296 |
static void AircraftEventHandler_AtTerminal(Vehicle *v, const AirportFTAClass *Airport) |
|
1297 |
{
|
|
1298 |
// if we just arrived, execute EnterTerminal first |
|
1299 |
if (v->u.air.previous_pos != v->u.air.pos) {
|
|
1300 |
AircraftEventHandler_EnterTerminal(v, Airport); |
|
1301 |
// on an airport with helipads, a helicopter will always land there |
|
1302 |
// and get serviced at the same time - patch setting |
|
1303 |
if (_patches.serviceathelipad) {
|
|
1304 |
if (v->subtype == 0 && Airport->nofhelipads > 0) {
|
|
1305 |
// an exerpt of ServiceAircraft, without the invisibility stuff |
|
1306 |
v->date_of_last_service = _date; |
|
1307 |
v->breakdowns_since_last_service = 0; |
|
1308 |
v->reliability = _engines[v->engine_type].reliability; |
|
1309 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
|
1310 |
} |
|
1311 |
} |
|
1312 |
return; |
|
1313 |
} |
|
1314 |
||
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1315 |
if (v->current_order.type == OT_NOTHING) return; |
| 0 | 1316 |
|
1317 |
// if the block of the next position is busy, stay put |
|
1318 |
if (AirportHasBlock(v, &Airport->layout[v->u.air.pos], Airport)) {
|
|
1319 |
return; |
|
1320 |
} |
|
1321 |
||
1322 |
// airport-road is free. We either have to go to another airport, or to the hangar |
|
1323 |
// ---> start moving |
|
1324 |
||
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1325 |
switch (v->current_order.type) {
|
| 0 | 1326 |
case OT_GOTO_STATION: // ready to fly to another airport |
1327 |
// airplane goto state takeoff, helicopter to helitakeoff |
|
1328 |
v->u.air.state = (v->subtype != 0) ? TAKEOFF : HELITAKEOFF; |
|
1329 |
break; |
|
1330 |
case OT_GOTO_DEPOT: // visit hangar for serivicing, sale, etc. |
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1331 |
if (v->current_order.station == v->u.air.targetairport) |
| 0 | 1332 |
v->u.air.state = HANGAR; |
1333 |
else |
|
1334 |
v->u.air.state = (v->subtype != 0) ? TAKEOFF : HELITAKEOFF; |
|
1335 |
break; |
|
1336 |
default: // orders have been deleted (no orders), goto depot and don't bother us |
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1337 |
v->current_order.type = OT_NOTHING; |
|
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1338 |
v->current_order.flags = 0; |
| 0 | 1339 |
v->u.air.state = HANGAR; |
1340 |
} |
|
1341 |
AirportMove(v, Airport); |
|
1342 |
} |
|
1343 |
||
1344 |
static void AircraftEventHandler_General(Vehicle *v, const AirportFTAClass *Airport) |
|
1345 |
{
|
|
|
70
60216d94f7c1
(svn r71) -Cheat: [976127] no extra frequent jet crash on small airports (truesatan)
darkvater
parents:
19
diff
changeset
|
1346 |
DEBUG(misc, 0) ("OK, you shouldn't be here, check your Airport Scheme!");
|
|
60216d94f7c1
(svn r71) -Cheat: [976127] no extra frequent jet crash on small airports (truesatan)
darkvater
parents:
19
diff
changeset
|
1347 |
assert(0); |
| 0 | 1348 |
} |
1349 |
||
1350 |
static void AircraftEventHandler_TakeOff(Vehicle *v, const AirportFTAClass *Airport) {
|
|
1351 |
PlayAircraftSound(v); // play takeoffsound for airplanes |
|
1352 |
v->u.air.state = STARTTAKEOFF; |
|
1353 |
} |
|
1354 |
||
1355 |
static void AircraftEventHandler_StartTakeOff(Vehicle *v, const AirportFTAClass *Airport) |
|
1356 |
{
|
|
1357 |
v->sprite_width = v->sprite_height = 24; // ??? no idea what this is |
|
1358 |
v->u.air.state = ENDTAKEOFF; |
|
1359 |
} |
|
1360 |
||
1361 |
static void AircraftEventHandler_EndTakeOff(Vehicle *v, const AirportFTAClass *Airport) |
|
1362 |
{
|
|
1363 |
v->u.air.state = FLYING; |
|
1364 |
// get the next position to go to, differs per airport |
|
1365 |
AircraftNextAirportPos_and_Order(v); |
|
1366 |
} |
|
1367 |
||
1368 |
static void AircraftEventHandler_HeliTakeOff(Vehicle *v, const AirportFTAClass *Airport) |
|
1369 |
{
|
|
1370 |
v->sprite_width = v->sprite_height = 24; // ??? no idea what this is |
|
1371 |
v->u.air.state = FLYING; |
|
1372 |
// get the next position to go to, differs per airport |
|
1373 |
AircraftNextAirportPos_and_Order(v); |
|
1374 |
} |
|
1375 |
||
1376 |
static void AircraftEventHandler_Flying(Vehicle *v, const AirportFTAClass *Airport) |
|
1377 |
{
|
|
1378 |
Station *st; |
|
1379 |
byte landingtype; |
|
1380 |
AirportFTA *current; |
|
1381 |
uint16 tcur_speed, tsubspeed; |
|
1382 |
||
1383 |
st = DEREF_STATION(v->u.air.targetairport); |
|
1384 |
// flying device is accepted at this station |
|
1385 |
// small airport --> no helicopters (AIRCRAFT_ONLY) |
|
1386 |
// all other airports --> all types of flying devices (ALL) |
|
1387 |
// heliport/oilrig, etc --> no airplanes (HELICOPTERS_ONLY) |
|
1388 |
// runway busy or not allowed to use this airstation, circle |
|
1389 |
if (! (v->subtype == Airport->acc_planes || |
|
1390 |
st->airport_tile == 0 || (st->owner != OWNER_NONE && st->owner != v->owner) )) {
|
|
1391 |
||
1392 |
// {32,FLYING,NOTHING_block,37}, {32,LANDING,N,33}, {32,HELILANDING,N,41},
|
|
1393 |
// if it is an airplane, look for LANDING, for helicopter HELILANDING |
|
1394 |
// it is possible to choose from multiple landing runways, so loop until a free one is found |
|
1395 |
landingtype = (v->subtype != 0) ? LANDING : HELILANDING; |
|
1396 |
current = Airport->layout[v->u.air.pos].next_in_chain; |
|
1397 |
while (current != NULL) {
|
|
1398 |
if (current->heading == landingtype) {
|
|
1399 |
// save speed before, since if AirportHasBlock is false, it resets them to 0 |
|
1400 |
// we don't want that for plane in air |
|
1401 |
// hack for speed thingie |
|
1402 |
tcur_speed = v->cur_speed; |
|
1403 |
tsubspeed = v->subspeed; |
|
1404 |
if (!AirportHasBlock(v, current, Airport)) {
|
|
1405 |
v->u.air.state = landingtype; // LANDING / HELILANDING |
|
1406 |
// it's a bit dirty, but I need to set position to next position, otherwise |
|
1407 |
// if there are multiple runways, plane won't know which one it took (because |
|
1408 |
// they all have heading LANDING). And also occupy that block! |
|
1409 |
v->u.air.pos = current->next_position; |
|
1410 |
SETBITS(st->airport_flags, Airport->layout[v->u.air.pos].block); |
|
1411 |
return; |
|
1412 |
} |
|
1413 |
v->cur_speed = tcur_speed; |
|
1414 |
v->subspeed = tsubspeed; |
|
1415 |
} |
|
1416 |
current = current->next_in_chain; |
|
1417 |
} |
|
1418 |
} |
|
1419 |
v->u.air.state = FLYING; |
|
1420 |
v->u.air.pos = Airport->layout[v->u.air.pos].next_position; |
|
1421 |
} |
|
1422 |
||
1423 |
static void AircraftEventHandler_Landing(Vehicle *v, const AirportFTAClass *Airport) |
|
1424 |
{
|
|
1425 |
AircraftLandAirplane(v); // maybe crash airplane |
|
1426 |
v->u.air.state = ENDLANDING; |
|
1427 |
} |
|
1428 |
||
1429 |
static void AircraftEventHandler_HeliLanding(Vehicle *v, const AirportFTAClass *Airport) |
|
1430 |
{
|
|
1431 |
AircraftLand(v); // helicopters don't crash |
|
1432 |
v->u.air.state = HELIENDLANDING; |
|
1433 |
} |
|
1434 |
||
1435 |
static void AircraftEventHandler_EndLanding(Vehicle *v, const AirportFTAClass *Airport) |
|
1436 |
{
|
|
1437 |
// next block busy, don't do a thing, just wait |
|
1438 |
if(AirportHasBlock(v, &Airport->layout[v->u.air.pos], Airport)) {return;}
|
|
1439 |
||
1440 |
// if going to terminal (OT_GOTO_STATION) choose one |
|
1441 |
// 1. in case all terminals are busy AirportFindFreeTerminal() returns false or |
|
1442 |
// 2. not going for terminal (but depot, no order), |
|
1443 |
// --> get out of the way to the hangar. |
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1444 |
if (v->current_order.type == OT_GOTO_STATION) {
|
| 0 | 1445 |
if (AirportFindFreeTerminal(v, Airport)) {return;}
|
1446 |
} |
|
1447 |
v->u.air.state = HANGAR; |
|
1448 |
||
1449 |
} |
|
1450 |
||
1451 |
static void AircraftEventHandler_HeliEndLanding(Vehicle *v, const AirportFTAClass *Airport) |
|
1452 |
{
|
|
1453 |
// next block busy, don't do a thing, just wait |
|
1454 |
if(AirportHasBlock(v, &Airport->layout[v->u.air.pos], Airport)) {return;}
|
|
1455 |
||
1456 |
// if going to helipad (OT_GOTO_STATION) choose one. If airport doesn't have helipads, choose terminal |
|
1457 |
// 1. in case all terminals/helipads are busy (AirportFindFreeHelipad() returns false) or |
|
1458 |
// 2. not going for terminal (but depot, no order), |
|
1459 |
// --> get out of the way to the hangar IF there are terminals on the airport. |
|
1460 |
// --> else TAKEOFF |
|
1461 |
// the reason behind this is that if an airport has a terminal, it also has a hangar. Airplanes |
|
1462 |
// must go to a hangar. |
|
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1463 |
if (v->current_order.type == OT_GOTO_STATION) {
|
| 0 | 1464 |
if (AirportFindFreeHelipad(v, Airport)) {return;}
|
1465 |
} |
|
1466 |
v->u.air.state = (Airport->nofterminals != 0) ? HANGAR : HELITAKEOFF; |
|
1467 |
} |
|
1468 |
||
1469 |
typedef void AircraftStateHandler(Vehicle *v, const AirportFTAClass *Airport); |
|
1470 |
static AircraftStateHandler * const _aircraft_state_handlers[] = {
|
|
1471 |
AircraftEventHandler_General, // TO_ALL = 0 |
|
1472 |
AircraftEventHandler_InHangar, // HANGAR = 1 |
|
1473 |
AircraftEventHandler_AtTerminal, // TERM1 = 2 |
|
1474 |
AircraftEventHandler_AtTerminal, // TERM2 = 3 |
|
1475 |
AircraftEventHandler_AtTerminal, // TERM3 = 4 |
|
1476 |
AircraftEventHandler_AtTerminal, // TERM4 = 5 |
|
1477 |
AircraftEventHandler_AtTerminal, // TERM5 = 6 |
|
1478 |
AircraftEventHandler_AtTerminal, // TERM6 = 7 |
|
1479 |
AircraftEventHandler_AtTerminal, // HELIPAD1 = 8 |
|
1480 |
AircraftEventHandler_AtTerminal, // HELIPAD2 = 9 |
|
1481 |
AircraftEventHandler_TakeOff, // TAKEOFF = 10 |
|
1482 |
AircraftEventHandler_StartTakeOff, // STARTTAKEOFF = 11 |
|
1483 |
AircraftEventHandler_EndTakeOff, // ENDTAKEOFF = 12 |
|
1484 |
AircraftEventHandler_HeliTakeOff, // HELITAKEOFF = 13 |
|
1485 |
AircraftEventHandler_Flying, // FLYING = 14 |
|
1486 |
AircraftEventHandler_Landing, // LANDING = 15 |
|
1487 |
AircraftEventHandler_EndLanding, // ENDLANDING = 16 |
|
1488 |
AircraftEventHandler_HeliLanding, // HELILANDING = 17 |
|
1489 |
AircraftEventHandler_HeliEndLanding,// HELIENDLANDING = 18 |
|
1490 |
}; |
|
1491 |
||
1492 |
static void AirportClearBlock(Vehicle *v, const AirportFTAClass *Airport) |
|
1493 |
{
|
|
1494 |
Station *st; |
|
1495 |
// we have left the previous block, and entered the new one. Free the previous block |
|
1496 |
if (Airport->layout[v->u.air.previous_pos].block != Airport->layout[v->u.air.pos].block) {
|
|
1497 |
st = DEREF_STATION(v->u.air.targetairport); |
|
1498 |
CLRBITS(st->airport_flags, Airport->layout[v->u.air.previous_pos].block); |
|
1499 |
} |
|
1500 |
} |
|
1501 |
||
1502 |
static void AirportGoToNextPosition(Vehicle *v, const AirportFTAClass *Airport) |
|
1503 |
{
|
|
1504 |
// if aircraft is not in position, wait until it is |
|
1505 |
if (!Aircraft_5(v)) {return;}
|
|
1506 |
||
1507 |
AirportClearBlock(v, Airport); |
|
1508 |
AirportMove(v, Airport); // move aircraft to next position |
|
1509 |
} |
|
1510 |
||
1511 |
// gets pos from vehicle and next orders |
|
1512 |
static bool AirportMove(Vehicle *v, const AirportFTAClass *Airport) |
|
1513 |
{
|
|
1514 |
AirportFTA *current; |
|
1515 |
byte prev_pos; |
|
1516 |
bool retval = false; |
|
1517 |
||
1518 |
// error handling |
|
1519 |
if (v->u.air.pos >= Airport->nofelements) {
|
|
|
70
60216d94f7c1
(svn r71) -Cheat: [976127] no extra frequent jet crash on small airports (truesatan)
darkvater
parents:
19
diff
changeset
|
1520 |
DEBUG(misc, 0) ("position %d is not valid for current airport. Max position is %d", v->u.air.pos, Airport->nofelements-1);
|
| 0 | 1521 |
assert(v->u.air.pos < Airport->nofelements); |
1522 |
} |
|
1523 |
||
1524 |
current = &Airport->layout[v->u.air.pos]; |
|
1525 |
// we have arrived in an important state (eg terminal, hangar, etc.) |
|
1526 |
if (current->heading == v->u.air.state) {
|
|
1527 |
prev_pos = v->u.air.pos; // location could be changed in state, so save it before-hand |
|
1528 |
_aircraft_state_handlers[v->u.air.state](v, Airport); |
|
1529 |
if (v->u.air.state != FLYING) {v->u.air.previous_pos = prev_pos;}
|
|
1530 |
return true; |
|
1531 |
} |
|
1532 |
||
1533 |
v->u.air.previous_pos = v->u.air.pos; // save previous location |
|
1534 |
||
1535 |
// there is only one choice to move to |
|
1536 |
if (current->next_in_chain == NULL) {
|
|
1537 |
if (AirportSetBlocks(v, current, Airport)) {
|
|
1538 |
v->u.air.pos = current->next_position; |
|
1539 |
} // move to next position |
|
1540 |
return retval; |
|
1541 |
} |
|
1542 |
||
1543 |
// there are more choices to choose from, choose the one that |
|
1544 |
// matches our heading |
|
1545 |
do {
|
|
1546 |
if (v->u.air.state == current->heading || current->heading == TO_ALL) {
|
|
1547 |
if (AirportSetBlocks(v, current, Airport)) {
|
|
1548 |
v->u.air.pos = current->next_position; |
|
1549 |
} // move to next position |
|
1550 |
return retval; |
|
1551 |
} |
|
1552 |
current = current->next_in_chain; |
|
1553 |
} while (current != NULL); |
|
1554 |
||
|
70
60216d94f7c1
(svn r71) -Cheat: [976127] no extra frequent jet crash on small airports (truesatan)
darkvater
parents:
19
diff
changeset
|
1555 |
DEBUG(misc, 0) ("Cannot move further on Airport...! pos:%d state:%d", v->u.air.pos, v->u.air.state);
|
|
60216d94f7c1
(svn r71) -Cheat: [976127] no extra frequent jet crash on small airports (truesatan)
darkvater
parents:
19
diff
changeset
|
1556 |
DEBUG(misc, 0) ("Airport entry point: %d, Vehicle: %d", Airport->entry_point, v->index);
|
| 0 | 1557 |
assert(0); |
1558 |
return false; |
|
1559 |
} |
|
1560 |
||
1561 |
// returns true if the road ahead is busy, eg. you must wait before proceeding |
|
1562 |
static bool AirportHasBlock(Vehicle *v, AirportFTA *current_pos, const AirportFTAClass *Airport) |
|
1563 |
{
|
|
1564 |
Station *st; |
|
1565 |
uint32 airport_flags; |
|
1566 |
AirportFTA *next, *reference; |
|
1567 |
reference = &Airport->layout[v->u.air.pos]; |
|
1568 |
next = &Airport->layout[current_pos->next_position]; |
|
1569 |
||
1570 |
// same block, then of course we can move |
|
1571 |
if (Airport->layout[current_pos->position].block != next->block) {
|
|
1572 |
airport_flags = next->block; |
|
1573 |
st = DEREF_STATION(v->u.air.targetairport); |
|
1574 |
// check additional possible extra blocks |
|
1575 |
if (current_pos != reference && current_pos->block != NOTHING_block) {
|
|
1576 |
airport_flags |= current_pos->block; |
|
1577 |
} |
|
1578 |
||
1579 |
if (HASBITS(st->airport_flags, airport_flags)) {
|
|
1580 |
v->cur_speed = 0; |
|
1581 |
v->subspeed = 0; |
|
1582 |
return true; |
|
1583 |
} |
|
1584 |
} |
|
1585 |
return false; |
|
1586 |
} |
|
1587 |
||
1588 |
// returns true on success. Eg, next block was free and we have occupied it |
|
1589 |
static bool AirportSetBlocks(Vehicle *v, AirportFTA *current_pos, const AirportFTAClass *Airport) |
|
1590 |
{
|
|
1591 |
Station *st; |
|
1592 |
uint32 airport_flags; |
|
1593 |
AirportFTA *current, *reference, *next; |
|
1594 |
next = &Airport->layout[current_pos->next_position]; |
|
1595 |
reference = &Airport->layout[v->u.air.pos]; |
|
1596 |
||
1597 |
// if the next position is in another block, check it and wait until it is free |
|
1598 |
if (Airport->layout[current_pos->position].block != next->block) {
|
|
1599 |
airport_flags = next->block; |
|
1600 |
st = DEREF_STATION(v->u.air.targetairport); |
|
1601 |
//search for all all elements in the list with the same state, and blocks != N |
|
1602 |
// this means more blocks should be checked/set |
|
1603 |
current = current_pos; |
|
1604 |
if (current == reference) { current = current->next_in_chain;}
|
|
1605 |
while (current != NULL) {
|
|
1606 |
if (current->heading == current_pos->heading && current->block != 0) {
|
|
1607 |
airport_flags |= current->block; |
|
1608 |
break; |
|
1609 |
} |
|
1610 |
current = current->next_in_chain; |
|
1611 |
}; |
|
1612 |
||
1613 |
// if the block to be checked is in the next position, then exclude that from |
|
1614 |
// checking, because it has been set by the airplane before |
|
1615 |
if (current_pos->block == next->block) {airport_flags ^= next->block;}
|
|
1616 |
||
1617 |
if (HASBITS(st->airport_flags, airport_flags)) {
|
|
1618 |
v->cur_speed = 0; |
|
1619 |
v->subspeed = 0; |
|
1620 |
return false; |
|
1621 |
} |
|
1622 |
||
1623 |
if (next->block != NOTHING_block) {
|
|
1624 |
SETBITS(st->airport_flags, airport_flags); // occupy next block |
|
1625 |
} |
|
1626 |
} |
|
1627 |
return true; |
|
1628 |
} |
|
1629 |
||
1630 |
static bool FreeTerminal(Vehicle *v, byte i, byte last_terminal) |
|
1631 |
{
|
|
1632 |
Station *st = DEREF_STATION(v->u.air.targetairport); |
|
1633 |
for (; i < last_terminal; i++) {
|
|
1634 |
if (!HASBIT(st->airport_flags, i)) {
|
|
1635 |
// TERMINAL# HELIPAD# |
|
1636 |
v->u.air.state = i + TERM1; // start moving to that terminal/helipad |
|
1637 |
SETBIT(st->airport_flags, i); // occupy terminal/helipad |
|
1638 |
return true; |
|
1639 |
} |
|
1640 |
} |
|
1641 |
return false; |
|
1642 |
} |
|
1643 |
||
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1644 |
static bool AirportFindFreeTerminal(Vehicle *v, const AirportFTAClass *Airport) |
| 0 | 1645 |
{
|
1646 |
byte nofterminalspergroup, i; |
|
1647 |
AirportFTA *temp; |
|
1648 |
Station *st; |
|
1649 |
||
1650 |
/* example of more terminalgroups |
|
1651 |
{0,HANGAR,NOTHING_block,1}, {0,255,TERM_GROUP1_block,0}, {0,255,TERM_GROUP2_ENTER_block,1}, {0,0,N,1},
|
|
1652 |
Heading 255 denotes a group. We see 2 groups here: |
|
1653 |
1. group 0 -- TERM_GROUP1_block (check block) |
|
1654 |
2. group 1 -- TERM_GROUP2_ENTER_block (check block) |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1655 |
First in line is checked first, group 0. If the block (TERM_GROUP1_block) is free, it |
|
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1656 |
looks at the corresponding terminals of that group. If no free ones are found, other |
|
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1657 |
possible groups are checked (in this case group 1, since that is after group 0). If that |
| 0 | 1658 |
fails, then attempt fails and plane waits |
1659 |
*/ |
|
1660 |
if (Airport->nofterminalgroups > 1) {
|
|
1661 |
st = DEREF_STATION(v->u.air.targetairport); |
|
1662 |
nofterminalspergroup = Airport->nofterminals / Airport->nofterminalgroups; |
|
1663 |
temp = Airport->layout[v->u.air.pos].next_in_chain; |
|
1664 |
while (temp != NULL) {
|
|
1665 |
if (temp->heading == 255) {
|
|
1666 |
if (!HASBITS(st->airport_flags, temp->block)) {
|
|
1667 |
i = temp->next_position * nofterminalspergroup; // next_position denotes the group to check |
|
1668 |
// only that group will be checked (eg 6 terms, 2 groups) |
|
1669 |
// with i = 0 terms 1 - 3 and |
|
1670 |
// with i = 1 terms 4 - 6 |
|
1671 |
if (FreeTerminal(v, i, i + nofterminalspergroup)) {return true;}
|
|
1672 |
} |
|
1673 |
} |
|
1674 |
else {return false;} // once the heading isn't 255, we've exhausted the possible blocks. So we cannot move
|
|
1675 |
temp = temp->next_in_chain; |
|
1676 |
} |
|
1677 |
} |
|
1678 |
||
1679 |
// if there is only 1 terminalgroup, all terminals are checked (starting from 0 to max) |
|
1680 |
return FreeTerminal(v, 0, Airport->nofterminals); |
|
1681 |
} |
|
1682 |
||
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1683 |
static bool AirportFindFreeHelipad(Vehicle *v, const AirportFTAClass *Airport) |
| 0 | 1684 |
{
|
1685 |
Station *st; |
|
1686 |
byte nofhelipadspergroup, i; |
|
1687 |
AirportFTA *temp; |
|
1688 |
||
1689 |
// if an airport doesn't have helipads, use terminals |
|
1690 |
if (Airport->nofhelipads == 0) {return AirportFindFreeTerminal(v, Airport);}
|
|
1691 |
||
1692 |
// if there are more helicoptergroups, pick one, just as in AirportFindFreeTerminal() |
|
1693 |
if (Airport->nofhelipadgroups > 1) {
|
|
1694 |
st = DEREF_STATION(v->u.air.targetairport); |
|
1695 |
nofhelipadspergroup = Airport->nofhelipads / Airport->nofhelipadgroups; |
|
1696 |
temp = Airport->layout[v->u.air.pos].next_in_chain; |
|
1697 |
while (temp != NULL) {
|
|
1698 |
if (temp->heading == 255) {
|
|
1699 |
if (!HASBITS(st->airport_flags, temp->block)) {
|
|
1700 |
i = temp->next_position * nofhelipadspergroup; // next position is the group to check |
|
1701 |
// heliports start from after TERMINALS, so MAX_TERMINALS needs to be added |
|
1702 |
if (FreeTerminal(v, i + MAX_TERMINALS, i + MAX_TERMINALS + nofhelipadspergroup)) {return true;}
|
|
1703 |
} |
|
1704 |
} |
|
1705 |
else {return false;} // once the heading isn't 255, we've exhausted the possible blocks. So we cannot move
|
|
1706 |
temp = temp->next_in_chain; |
|
1707 |
} |
|
1708 |
} |
|
1709 |
// only 1 helicoptergroup, check all helipads |
|
1710 |
// The blocks for helipads start after the last terminal (MAX_TERMINALS) |
|
1711 |
else {return FreeTerminal(v, MAX_TERMINALS, Airport->nofhelipads + MAX_TERMINALS);}
|
|
1712 |
return false; // it shouldn't get here anytime, but just to be sure |
|
1713 |
} |
|
1714 |
||
1715 |
static void AircraftEventHandler(Vehicle *v, int loop) |
|
1716 |
{
|
|
1717 |
v->tick_counter++; |
|
1718 |
||
1719 |
if (v->vehstatus & VS_CRASHED) {
|
|
1720 |
HandleCrashedAircraft(v); |
|
1721 |
return; |
|
1722 |
} |
|
1723 |
||
1724 |
/* exit if aircraft is stopped */ |
|
1725 |
if (v->vehstatus & VS_STOPPED) |
|
1726 |
return; |
|
1727 |
||
1728 |
/* aircraft is broken down? */ |
|
1729 |
if (v->breakdown_ctr != 0) {
|
|
1730 |
if (v->breakdown_ctr <= 2) {
|
|
1731 |
HandleBrokenAircraft(v); |
|
1732 |
} else {
|
|
1733 |
v->breakdown_ctr--; |
|
1734 |
} |
|
1735 |
} |
|
1736 |
||
1737 |
HandleAircraftSmoke(v); |
|
1738 |
ProcessAircraftOrder(v); |
|
1739 |
HandleAircraftLoading(v, loop); |
|
1740 |
||
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1741 |
if (v->current_order.type >= OT_LOADING) |
| 0 | 1742 |
return; |
1743 |
||
1744 |
// pass the right airport structure to the functions |
|
1745 |
// DEREF_STATION gets target airport (Station *st), its type is passed to GetAirport |
|
1746 |
// that returns the correct layout depending on type |
|
1747 |
AirportGoToNextPosition(v, GetAirport(DEREF_STATION(v->u.air.targetairport)->airport_type)); |
|
1748 |
} |
|
1749 |
||
1750 |
void Aircraft_Tick(Vehicle *v) |
|
1751 |
{
|
|
1752 |
int i; |
|
1753 |
||
1754 |
if (v->subtype > 2) |
|
1755 |
return; |
|
1756 |
||
1757 |
if (v->subtype == 0) |
|
1758 |
HelicopterTickHandler(v); |
|
1759 |
||
1760 |
AgeAircraftCargo(v); |
|
1761 |
||
1762 |
for(i=0; i!=6; i++) {
|
|
1763 |
AircraftEventHandler(v, i); |
|
1764 |
if (v->type != VEH_Aircraft) // In case it was deleted |
|
1765 |
break; |
|
1766 |
} |
|
1767 |
} |
|
1768 |
||
1769 |
// need to be called to load aircraft from old version |
|
1770 |
void UpdateOldAircraft() |
|
1771 |
{
|
|
1772 |
Station *st; |
|
1773 |
Vehicle *v_oldstyle; |
|
1774 |
GetNewVehiclePosResult gp; |
|
1775 |
||
1776 |
// set airport_flags to 0 for all airports just to be sure |
|
1777 |
FOR_ALL_STATIONS(st) {
|
|
1778 |
st->airport_flags = 0; // reset airport |
|
1779 |
// type of oilrig has been moved, update it (3-5) |
|
1780 |
if (st->airport_type == 3) {st->airport_type = AT_OILRIG;}
|
|
1781 |
} |
|
1782 |
||
1783 |
FOR_ALL_VEHICLES(v_oldstyle) {
|
|
1784 |
// airplane has another vehicle with subtype 4 (shadow), helicopter also has 3 (rotor) |
|
1785 |
// skip those |
|
1786 |
if (v_oldstyle->type == VEH_Aircraft && v_oldstyle->subtype <= 2) {
|
|
1787 |
// airplane in terminal stopped doesn't hurt anyone, so goto next |
|
1788 |
if ((v_oldstyle->vehstatus & VS_STOPPED) && (v_oldstyle->u.air.state == 0)) {
|
|
1789 |
v_oldstyle->u.air.state = HANGAR; |
|
1790 |
continue; |
|
1791 |
} |
|
1792 |
||
1793 |
AircraftLeaveHangar(v_oldstyle); // make airplane visible if it was in a depot for example |
|
1794 |
v_oldstyle->vehstatus &= ~VS_STOPPED; // make airplane moving |
|
1795 |
v_oldstyle->u.air.state = FLYING; |
|
1796 |
AircraftNextAirportPos_and_Order(v_oldstyle); // move it to the entry point of the airport |
|
1797 |
GetNewVehiclePos(v_oldstyle, &gp); // get the position of the plane (to be used for setting) |
|
1798 |
v_oldstyle->tile = 0; // aircraft in air is tile=0 |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1799 |
|
| 0 | 1800 |
// correct speed of helicopter-rotors |
1801 |
if (v_oldstyle->subtype == 0) {v_oldstyle->next->next->cur_speed = 32;}
|
|
1802 |
||
1803 |
// set new position x,y,z |
|
1804 |
SetAircraftPosition(v_oldstyle, gp.x, gp.y, GetAircraftFlyingAltitude(v_oldstyle)); |
|
1805 |
} |
|
1806 |
} |
|
1807 |
} |
|
1808 |
||
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1809 |
void UpdateAirplanesOnNewStation(Station *st) |
| 0 | 1810 |
{
|
1811 |
GetNewVehiclePosResult gp; |
|
1812 |
Vehicle *v; |
|
1813 |
byte takeofftype; |
|
1814 |
uint16 cnt; |
|
1815 |
// only 1 station is updated per function call, so it is enough to get entry_point once |
|
1816 |
const AirportFTAClass *ap = GetAirport(st->airport_type); |
|
1817 |
FOR_ALL_VEHICLES(v) {
|
|
1818 |
if (v->type == VEH_Aircraft && v->subtype <= 2) {
|
|
1819 |
if (v->u.air.targetairport == st->index) { // if heading to this airport
|
|
1820 |
/* update position of airplane. If plane is not flying, landing, or taking off |
|
1821 |
you cannot delete airport, so it doesn't matter |
|
1822 |
*/ |
|
1823 |
if (v->u.air.state >= FLYING) { // circle around
|
|
1824 |
v->u.air.pos = v->u.air.previous_pos = ap->entry_point; |
|
1825 |
v->u.air.state = FLYING; |
|
1826 |
// landing plane needs to be reset to flying height (only if in pause mode upgrade, |
|
1827 |
// in normal mode, plane is reset in Aircraft_5. It doesn't hurt for FLYING |
|
1828 |
GetNewVehiclePos(v, &gp); |
|
1829 |
// set new position x,y,z |
|
1830 |
SetAircraftPosition(v, gp.x, gp.y, GetAircraftFlyingAltitude(v)); |
|
1831 |
} |
|
1832 |
else {
|
|
1833 |
assert(v->u.air.state == ENDTAKEOFF || v->u.air.state == HELITAKEOFF); |
|
1834 |
takeofftype = (v->subtype == 0) ? HELITAKEOFF : ENDTAKEOFF; |
|
1835 |
// search in airportdata for that heading |
|
1836 |
// easiest to do, since this doesn't happen a lot |
|
1837 |
for (cnt = 0; cnt < ap->nofelements; cnt++) {
|
|
1838 |
if (ap->layout[cnt].heading == takeofftype) {
|
|
1839 |
v->u.air.pos = ap->layout[cnt].position; |
|
1840 |
break; |
|
1841 |
} |
|
1842 |
} |
|
1843 |
} |
|
1844 |
} |
|
1845 |
} |
|
1846 |
} |
|
1847 |
} |