OpenTTD Source: src/aircraft_cmd.cpp Source File

OpenTTD Source 12.2

aircraft_cmd.cpp
Go to the documentation of this file.
1 /*
2 * This file is part of OpenTTD.
3 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6 */
7
13 #include "stdafx.h"
14 #include "aircraft.h"
15 #include "landscape.h"
16 #include "news_func.h"
17 #include "newgrf_engine.h"
18 #include "newgrf_sound.h"
19 #include "spritecache.h"
20 #include "strings_func.h"
21 #include "command_func.h"
22 #include "window_func.h"
23 #include "date_func.h"
24 #include "vehicle_func.h"
25 #include "sound_func.h"
26 #include "cheat_type.h"
27 #include "company_base.h"
28 #include "ai/ai.hpp"
29 #include "game/game.hpp"
30 #include "company_func.h"
31 #include "effectvehicle_func.h"
32 #include "station_base.h"
33 #include "engine_base.h"
34 #include "core/random_func.hpp"
35 #include "core/backup_type.hpp"
36 #include "zoom_func.h"
37 #include "disaster_vehicle.h"
38 #include "newgrf_airporttiles.h"
39 #include "framerate_type.h"
40
41 #include "table/strings.h"
42
43 #include "safeguards.h"
44
45 void Aircraft::UpdateDeltaXY()
46 {
47 this->x_offs = -1;
48 this->y_offs = -1;
49 this->x_extent = 2;
50 this->y_extent = 2;
51
52 switch (this->subtype) {
53 default: NOT_REACHED();
54
55 case AIR_AIRCRAFT:
56 case AIR_HELICOPTER:
57 switch (this->state) {
58 default: break;
59 case ENDTAKEOFF:
60 case LANDING:
61 case HELILANDING:
62 case FLYING:
63 this->x_extent = 24;
64 this->y_extent = 24;
65 break;
66 }
67 this->z_extent = 5;
68 break;
69
70 case AIR_SHADOW:
71 this->z_extent = 1;
72 this->x_offs = 0;
73 this->y_offs = 0;
74 break;
75
76 case AIR_ROTOR:
77 this->z_extent = 1;
78 break;
79 }
80 }
81
82 static bool AirportMove(Aircraft *v, const AirportFTAClass *apc);
83 static bool AirportSetBlocks(Aircraft *v, const AirportFTA *current_pos, const AirportFTAClass *apc);
84 static bool AirportHasBlock(Aircraft *v, const AirportFTA *current_pos, const AirportFTAClass *apc);
85 static bool AirportFindFreeTerminal(Aircraft *v, const AirportFTAClass *apc);
86 static bool AirportFindFreeHelipad(Aircraft *v, const AirportFTAClass *apc);
87 static void CrashAirplane(Aircraft *v);
88
89 static const SpriteID _aircraft_sprite[] = {
90 0x0EB5, 0x0EBD, 0x0EC5, 0x0ECD,
91 0x0ED5, 0x0EDD, 0x0E9D, 0x0EA5,
92 0x0EAD, 0x0EE5, 0x0F05, 0x0F0D,
93 0x0F15, 0x0F1D, 0x0F25, 0x0F2D,
94 0x0EED, 0x0EF5, 0x0EFD, 0x0F35,
95 0x0E9D, 0x0EA5, 0x0EAD, 0x0EB5,
96 0x0EBD, 0x0EC5
97 };
98
99 template <>
100 bool IsValidImageIndex<VEH_AIRCRAFT>(uint8 image_index)
101 {
102 return image_index < lengthof(_aircraft_sprite);
103 }
104
106 enum HelicopterRotorStates {
107 HRS_ROTOR_STOPPED,
108 HRS_ROTOR_MOVING_1,
109 HRS_ROTOR_MOVING_2,
110 HRS_ROTOR_MOVING_3,
111 };
112
120 static StationID FindNearestHangar(const Aircraft *v)
121 {
122 uint best = 0;
123 StationID index = INVALID_STATION;
124 TileIndex vtile = TileVirtXY(v->x_pos, v->y_pos);
125 const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type);
126 uint max_range = v->acache.cached_max_range_sqr;
127
128 /* Determine destinations where it's coming from and where it's heading to */
129 const Station *last_dest = nullptr;
130 const Station *next_dest = nullptr;
131 if (max_range != 0) {
132 if (v->current_order.IsType(OT_GOTO_STATION) ||
133 (v->current_order.IsType(OT_GOTO_DEPOT) && v->current_order.GetDepotActionType() != ODATFB_NEAREST_DEPOT)) {
134 last_dest = Station::GetIfValid(v->last_station_visited);
135 next_dest = Station::GetIfValid(v->current_order.GetDestination());
136 } else {
137 last_dest = GetTargetAirportIfValid(v);
138 next_dest = Station::GetIfValid(v->GetNextStoppingStation().value);
139 }
140 }
141
142 for (const Station *st : Station::Iterate()) {
143 if (st->owner != v->owner || !(st->facilities & FACIL_AIRPORT) || !st->airport.HasHangar()) continue;
144
145 const AirportFTAClass *afc = st->airport.GetFTA();
146
147 /* don't crash the plane if we know it can't land at the airport */
148 if ((afc->flags & AirportFTAClass::SHORT_STRIP) && (avi->subtype & AIR_FAST) && !_cheats.no_jetcrash.value) continue;
149
150 /* the plane won't land at any helicopter station */
151 if (!(afc->flags & AirportFTAClass::AIRPLANES) && (avi->subtype & AIR_CTOL)) continue;
152
153 /* Check if our last and next destinations can be reached from the depot airport. */
154 if (max_range != 0) {
155 uint last_dist = (last_dest != nullptr && last_dest->airport.tile != INVALID_TILE) ? DistanceSquare(st->airport.tile, last_dest->airport.tile) : 0;
156 uint next_dist = (next_dest != nullptr && next_dest->airport.tile != INVALID_TILE) ? DistanceSquare(st->airport.tile, next_dest->airport.tile) : 0;
157 if (last_dist > max_range || next_dist > max_range) continue;
158 }
159
160 /* v->tile can't be used here, when aircraft is flying v->tile is set to 0 */
161 uint distance = DistanceSquare(vtile, st->airport.tile);
162 if (distance < best || index == INVALID_STATION) {
163 best = distance;
164 index = st->index;
165 }
166 }
167 return index;
168 }
169
170 void Aircraft::GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const
171 {
172 uint8 spritenum = this->spritenum;
173
174 if (is_custom_sprite(spritenum)) {
175 GetCustomVehicleSprite(this, direction, image_type, result);
176 if (result->IsValid()) return;
177
178 spritenum = this->GetEngine()->original_image_index;
179 }
180
181 assert(IsValidImageIndex<VEH_AIRCRAFT>(spritenum));
182 result->Set(direction + _aircraft_sprite[spritenum]);
183 }
184
185 void GetRotorImage(const Aircraft *v, EngineImageType image_type, VehicleSpriteSeq *result)
186 {
187 assert(v->subtype == AIR_HELICOPTER);
188
189 const Aircraft *w = v->Next()->Next();
190 if (is_custom_sprite(v->spritenum)) {
191 GetCustomRotorSprite(v, false, image_type, result);
192 if (result->IsValid()) return;
193 }
194
195 /* Return standard rotor sprites if there are no custom sprites for this helicopter */
196 result->Set(SPR_ROTOR_STOPPED + w->state);
197 }
198
199 static void GetAircraftIcon(EngineID engine, EngineImageType image_type, VehicleSpriteSeq *result)
200 {
201 const Engine *e = Engine::Get(engine);
202 uint8 spritenum = e->u.air.image_index;
203
204 if (is_custom_sprite(spritenum)) {
205 GetCustomVehicleIcon(engine, DIR_W, image_type, result);
206 if (result->IsValid()) return;
207
208 spritenum = e->original_image_index;
209 }
210
211 assert(IsValidImageIndex<VEH_AIRCRAFT>(spritenum));
212 result->Set(DIR_W + _aircraft_sprite[spritenum]);
213 }
214
215 void DrawAircraftEngine(int left, int right, int preferred_x, int y, EngineID engine, PaletteID pal, EngineImageType image_type)
216 {
217 VehicleSpriteSeq seq;
218 GetAircraftIcon(engine, image_type, &seq);
219
220 Rect rect;
221 seq.GetBounds(&rect);
222 preferred_x = Clamp(preferred_x,
223 left - UnScaleGUI(rect.left),
224 right - UnScaleGUI(rect.right));
225
226 seq.Draw(preferred_x, y, pal, pal == PALETTE_CRASH);
227
228 if (!(AircraftVehInfo(engine)->subtype & AIR_CTOL)) {
229 VehicleSpriteSeq rotor_seq;
230 GetCustomRotorIcon(engine, image_type, &rotor_seq);
231 if (!rotor_seq.IsValid()) rotor_seq.Set(SPR_ROTOR_STOPPED);
232 rotor_seq.Draw(preferred_x, y - ScaleGUITrad(5), PAL_NONE, false);
233 }
234 }
235
245 void GetAircraftSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
246 {
247 VehicleSpriteSeq seq;
248 GetAircraftIcon(engine, image_type, &seq);
249
250 Rect rect;
251 seq.GetBounds(&rect);
252
253 width = UnScaleGUI(rect.right - rect.left + 1);
254 height = UnScaleGUI(rect.bottom - rect.top + 1);
255 xoffs = UnScaleGUI(rect.left);
256 yoffs = UnScaleGUI(rect.top);
257 }
258
268 CommandCost CmdBuildAircraft(TileIndex tile, DoCommandFlag flags, const Engine *e, uint16 data, Vehicle **ret)
269 {
270 const AircraftVehicleInfo *avi = &e->u.air;
271 const Station *st = Station::GetByTile(tile);
272
273 /* Prevent building aircraft types at places which can't handle them */
274 if (!CanVehicleUseStation(e->index, st)) return CMD_ERROR;
275
276 /* Make sure all aircraft end up in the first tile of the hangar. */
277 tile = st->airport.GetHangarTile(st->airport.GetHangarNum(tile));
278
279 if (flags & DC_EXEC) {
280 Aircraft *v = new Aircraft(); // aircraft
281 Aircraft *u = new Aircraft(); // shadow
282 *ret = v;
283
284 v->direction = DIR_SE;
285
286 v->owner = u->owner = _current_company;
287
288 v->tile = tile;
289
290 uint x = TileX(tile) * TILE_SIZE + 5;
291 uint y = TileY(tile) * TILE_SIZE + 3;
292
293 v->x_pos = u->x_pos = x;
294 v->y_pos = u->y_pos = y;
295
296 u->z_pos = GetSlopePixelZ(x, y);
297 v->z_pos = u->z_pos + 1;
298
299 v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;
300 u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_SHADOW;
301
302 v->spritenum = avi->image_index;
303
304 v->cargo_cap = avi->passenger_capacity;
305 v->refit_cap = 0;
306 u->cargo_cap = avi->mail_capacity;
307 u->refit_cap = 0;
308
309 v->cargo_type = e->GetDefaultCargoType();
310 u->cargo_type = CT_MAIL;
311
312 v->name.clear();
313 v->last_station_visited = INVALID_STATION;
314 v->last_loading_station = INVALID_STATION;
315
316 v->acceleration = avi->acceleration;
317 v->engine_type = e->index;
318 u->engine_type = e->index;
319
320 v->subtype = (avi->subtype & AIR_CTOL ? AIR_AIRCRAFT : AIR_HELICOPTER);
321 v->UpdateDeltaXY();
322
323 u->subtype = AIR_SHADOW;
324 u->UpdateDeltaXY();
325
326 v->reliability = e->reliability;
327 v->reliability_spd_dec = e->reliability_spd_dec;
328 v->max_age = e->GetLifeLengthInDays();
329
330 _new_vehicle_id = v->index;
331
332 v->pos = GetVehiclePosOnBuild(tile);
333
334 v->state = HANGAR;
335 v->previous_pos = v->pos;
336 v->targetairport = GetStationIndex(tile);
337 v->SetNext(u);
338
339 v->SetServiceInterval(Company::Get(_current_company)->settings.vehicle.servint_aircraft);
340
341 v->date_of_last_service = _date;
342 v->build_year = u->build_year = _cur_year;
343
344 v->sprite_cache.sprite_seq.Set(SPR_IMG_QUERY);
345 u->sprite_cache.sprite_seq.Set(SPR_IMG_QUERY);
346
347 v->random_bits = VehicleRandomBits();
348 u->random_bits = VehicleRandomBits();
349
350 v->vehicle_flags = 0;
351 if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) SetBit(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE);
352 v->SetServiceIntervalIsPercent(Company::Get(_current_company)->settings.vehicle.servint_ispercent);
353
354 v->InvalidateNewGRFCacheOfChain();
355
356 v->cargo_cap = e->DetermineCapacity(v, &u->cargo_cap);
357
358 v->InvalidateNewGRFCacheOfChain();
359
360 UpdateAircraftCache(v, true);
361
362 v->UpdatePosition();
363 u->UpdatePosition();
364
365 /* Aircraft with 3 vehicles (chopper)? */
366 if (v->subtype == AIR_HELICOPTER) {
367 Aircraft *w = new Aircraft();
368 w->engine_type = e->index;
369 w->direction = DIR_N;
370 w->owner = _current_company;
371 w->x_pos = v->x_pos;
372 w->y_pos = v->y_pos;
373 w->z_pos = v->z_pos + ROTOR_Z_OFFSET;
374 w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE;
375 w->spritenum = 0xFF;
376 w->subtype = AIR_ROTOR;
377 w->sprite_cache.sprite_seq.Set(SPR_ROTOR_STOPPED);
378 w->random_bits = VehicleRandomBits();
379 /* Use rotor's air.state to store the rotor animation frame */
380 w->state = HRS_ROTOR_STOPPED;
381 w->UpdateDeltaXY();
382
383 u->SetNext(w);
384 w->UpdatePosition();
385 }
386 }
387
388 return CommandCost();
389 }
390
391
392 bool Aircraft::FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse)
393 {
394 const Station *st = GetTargetAirportIfValid(this);
395 /* If the station is not a valid airport or if it has no hangars */
396 if (st == nullptr || !CanVehicleUseStation(this, st) || !st->airport.HasHangar()) {
397 /* the aircraft has to search for a hangar on its own */
398 StationID station = FindNearestHangar(this);
399
400 if (station == INVALID_STATION) return false;
401
402 st = Station::Get(station);
403 }
404
405 if (location != nullptr) *location = st->xy;
406 if (destination != nullptr) *destination = st->index;
407
408 return true;
409 }
410
411 static void CheckIfAircraftNeedsService(Aircraft *v)
412 {
413 if (Company::Get(v->owner)->settings.vehicle.servint_aircraft == 0 || !v->NeedsAutomaticServicing()) return;
414 if (v->IsChainInDepot()) {
415 VehicleServiceInDepot(v);
416 return;
417 }
418
419 /* When we're parsing conditional orders and the like
420 * we don't want to consider going to a depot too. */
421 if (!v->current_order.IsType(OT_GOTO_DEPOT) && !v->current_order.IsType(OT_GOTO_STATION)) return;
422
423 const Station *st = Station::Get(v->current_order.GetDestination());
424
425 assert(st != nullptr);
426
427 /* only goto depot if the target airport has a depot */
428 if (st->airport.HasHangar() && CanVehicleUseStation(v, st)) {
429 v->current_order.MakeGoToDepot(st->index, ODTFB_SERVICE);
430 SetWindowWidgetDirty(WC_VEHICLE_VIEW, v->index, WID_VV_START_STOP);
431 } else if (v->current_order.IsType(OT_GOTO_DEPOT)) {
432 v->current_order.MakeDummy();
433 SetWindowWidgetDirty(WC_VEHICLE_VIEW, v->index, WID_VV_START_STOP);
434 }
435 }
436
437 Money Aircraft::GetRunningCost() const
438 {
439 const Engine *e = this->GetEngine();
440 uint cost_factor = GetVehicleProperty(this, PROP_AIRCRAFT_RUNNING_COST_FACTOR, e->u.air.running_cost);
441 return GetPrice(PR_RUNNING_AIRCRAFT, cost_factor, e->GetGRF());
442 }
443
444 void Aircraft::OnNewDay()
445 {
446 if (!this->IsNormalAircraft()) return;
447
448 if ((++this->day_counter & 7) == 0) DecreaseVehicleValue(this);
449
450 CheckOrders(this);
451
452 CheckVehicleBreakdown(this);
453 AgeVehicle(this);
454 CheckIfAircraftNeedsService(this);
455
456 if (this->running_ticks == 0) return;
457
458 CommandCost cost(EXPENSES_AIRCRAFT_RUN, this->GetRunningCost() * this->running_ticks / (DAYS_IN_YEAR * DAY_TICKS));
459
460 this->profit_this_year -= cost.GetCost();
461 this->running_ticks = 0;
462
463 SubtractMoneyFromCompanyFract(this->owner, cost);
464
465 SetWindowDirty(WC_VEHICLE_DETAILS, this->index);
466 SetWindowClassesDirty(WC_AIRCRAFT_LIST);
467 }
468
469 static void HelicopterTickHandler(Aircraft *v)
470 {
471 Aircraft *u = v->Next()->Next();
472
473 if (u->vehstatus & VS_HIDDEN) return;
474
475 /* if true, helicopter rotors do not rotate. This should only be the case if a helicopter is
476 * loading/unloading at a terminal or stopped */
477 if (v->current_order.IsType(OT_LOADING) || (v->vehstatus & VS_STOPPED)) {
478 if (u->cur_speed != 0) {
479 u->cur_speed++;
480 if (u->cur_speed >= 0x80 && u->state == HRS_ROTOR_MOVING_3) {
481 u->cur_speed = 0;
482 }
483 }
484 } else {
485 if (u->cur_speed == 0) {
486 u->cur_speed = 0x70;
487 }
488 if (u->cur_speed >= 0x50) {
489 u->cur_speed--;
490 }
491 }
492
493 int tick = ++u->tick_counter;
494 int spd = u->cur_speed >> 4;
495
496 VehicleSpriteSeq seq;
497 if (spd == 0) {
498 u->state = HRS_ROTOR_STOPPED;
499 GetRotorImage(v, EIT_ON_MAP, &seq);
500 if (u->sprite_cache.sprite_seq == seq) return;
501 } else if (tick >= spd) {
502 u->tick_counter = 0;
503 u->state++;
504 if (u->state > HRS_ROTOR_MOVING_3) u->state = HRS_ROTOR_MOVING_1;
505 GetRotorImage(v, EIT_ON_MAP, &seq);
506 } else {
507 return;
508 }
509
510 u->sprite_cache.sprite_seq = seq;
511
512 u->UpdatePositionAndViewport();
513 }
514
522 void SetAircraftPosition(Aircraft *v, int x, int y, int z)
523 {
524 v->x_pos = x;
525 v->y_pos = y;
526 v->z_pos = z;
527
528 v->UpdatePosition();
529 v->UpdateViewport(true, false);
530 if (v->subtype == AIR_HELICOPTER) {
531 GetRotorImage(v, EIT_ON_MAP, &v->Next()->Next()->sprite_cache.sprite_seq);
532 }
533
534 Aircraft *u = v->Next();
535
536 int safe_x = Clamp(x, 0, MapMaxX() * TILE_SIZE);
537 int safe_y = Clamp(y - 1, 0, MapMaxY() * TILE_SIZE);
538 u->x_pos = x;
539 u->y_pos = y - ((v->z_pos - GetSlopePixelZ(safe_x, safe_y)) >> 3);
540
541 safe_y = Clamp(u->y_pos, 0, MapMaxY() * TILE_SIZE);
542 u->z_pos = GetSlopePixelZ(safe_x, safe_y);
543 u->sprite_cache.sprite_seq.CopyWithoutPalette(v->sprite_cache.sprite_seq); // the shadow is never coloured
544
545 u->UpdatePositionAndViewport();
546
547 u = u->Next();
548 if (u != nullptr) {
549 u->x_pos = x;
550 u->y_pos = y;
551 u->z_pos = z + ROTOR_Z_OFFSET;
552
553 u->UpdatePositionAndViewport();
554 }
555 }
556
561 void HandleAircraftEnterHangar(Aircraft *v)
562 {
563 v->subspeed = 0;
564 v->progress = 0;
565
566 Aircraft *u = v->Next();
567 u->vehstatus |= VS_HIDDEN;
568 u = u->Next();
569 if (u != nullptr) {
570 u->vehstatus |= VS_HIDDEN;
571 u->cur_speed = 0;
572 }
573
574 SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos);
575 }
576
577 static void PlayAircraftSound(const Vehicle *v)
578 {
579 if (!PlayVehicleSound(v, VSE_START)) {
580 SndPlayVehicleFx(AircraftVehInfo(v->engine_type)->sfx, v);
581 }
582 }
583
584
591 void UpdateAircraftCache(Aircraft *v, bool update_range)
592 {
593 uint max_speed = GetVehicleProperty(v, PROP_AIRCRAFT_SPEED, 0);
594 if (max_speed != 0) {
595 /* Convert from original units to km-ish/h */
596 max_speed = (max_speed * 128) / 10;
597
598 v->vcache.cached_max_speed = max_speed;
599 } else {
600 /* Use the default max speed of the vehicle. */
601 v->vcache.cached_max_speed = AircraftVehInfo(v->engine_type)->max_speed;
602 }
603
604 /* Update cargo aging period. */
605 v->vcache.cached_cargo_age_period = GetVehicleProperty(v, PROP_AIRCRAFT_CARGO_AGE_PERIOD, EngInfo(v->engine_type)->cargo_age_period);
606 Aircraft *u = v->Next(); // Shadow for mail
607 u->vcache.cached_cargo_age_period = GetVehicleProperty(u, PROP_AIRCRAFT_CARGO_AGE_PERIOD, EngInfo(u->engine_type)->cargo_age_period);
608
609 /* Update aircraft range. */
610 if (update_range) {
611 v->acache.cached_max_range = GetVehicleProperty(v, PROP_AIRCRAFT_RANGE, AircraftVehInfo(v->engine_type)->max_range);
612 /* Squared it now so we don't have to do it later all the time. */
613 v->acache.cached_max_range_sqr = v->acache.cached_max_range * v->acache.cached_max_range;
614 }
615 }
616
617
621 enum AircraftSpeedLimits {
622 SPEED_LIMIT_TAXI = 50,
623 SPEED_LIMIT_APPROACH = 230,
624 SPEED_LIMIT_BROKEN = 320,
625 SPEED_LIMIT_HOLD = 425,
626 SPEED_LIMIT_NONE = 0xFFFF,
627 };
628
636 static int UpdateAircraftSpeed(Aircraft *v, uint speed_limit = SPEED_LIMIT_NONE, bool hard_limit = true)
637 {
645 uint spd = v->acceleration * 77;
646 byte t;
647
648 /* Adjust speed limits by plane speed factor to prevent taxiing
649 * and take-off speeds being too low. */
650 speed_limit *= _settings_game.vehicle.plane_speed;
651
652 /* adjust speed for broken vehicles */
653 if (v->vehstatus & VS_AIRCRAFT_BROKEN) {
654 if (SPEED_LIMIT_BROKEN < speed_limit) hard_limit = false;
655 speed_limit = std::min<uint>(speed_limit, SPEED_LIMIT_BROKEN);
656 }
657
658 if (v->vcache.cached_max_speed < speed_limit) {
659 if (v->cur_speed < speed_limit) hard_limit = false;
660 speed_limit = v->vcache.cached_max_speed;
661 }
662
663 v->subspeed = (t = v->subspeed) + (byte)spd;
664
665 /* Aircraft's current speed is used twice so that very fast planes are
666 * forced to slow down rapidly in the short distance needed. The magic
667 * value 16384 was determined to give similar results to the old speed/48
668 * method at slower speeds. This also results in less reduction at slow
669 * speeds to that aircraft do not get to taxi speed straight after
670 * touchdown. */
671 if (!hard_limit && v->cur_speed > speed_limit) {
672 speed_limit = v->cur_speed - std::max(1, ((v->cur_speed * v->cur_speed) / 16384) / _settings_game.vehicle.plane_speed);
673 }
674
675 spd = std::min(v->cur_speed + (spd >> 8) + (v->subspeed < t), speed_limit);
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 SetWindowWidgetDirty(WC_VEHICLE_VIEW, v->index, WID_VV_START_STOP);
681 }
682
683 /* Adjust distance moved by plane speed setting */
684 if (_settings_game.vehicle.plane_speed > 1) spd /= _settings_game.vehicle.plane_speed;
685
686 /* Convert direction-independent speed into direction-dependent speed. (old movement method) */
687 spd = v->GetOldAdvanceSpeed(spd);
688
689 spd += v->progress;
690 v->progress = (byte)spd;
691 return spd >> 8;
692 }
693
701 int GetTileHeightBelowAircraft(const Vehicle *v)
702 {
703 int safe_x = Clamp(v->x_pos, 0, MapMaxX() * TILE_SIZE);
704 int safe_y = Clamp(v->y_pos, 0, MapMaxY() * TILE_SIZE);
705 return TileHeight(TileVirtXY(safe_x, safe_y)) * TILE_HEIGHT;
706 }
707
718 void GetAircraftFlightLevelBounds(const Vehicle *v, int *min_level, int *max_level)
719 {
720 int base_altitude = GetTileHeightBelowAircraft(v);
721 if (v->type == VEH_AIRCRAFT && Aircraft::From(v)->subtype == AIR_HELICOPTER) {
722 base_altitude += HELICOPTER_HOLD_MAX_FLYING_ALTITUDE - PLANE_HOLD_MAX_FLYING_ALTITUDE;
723 }
724
725 /* Make sure eastbound and westbound planes do not "crash" into each
726 * other by providing them with vertical separation
727 */
728 switch (v->direction) {
729 case DIR_N:
730 case DIR_NE:
731 case DIR_E:
732 case DIR_SE:
733 base_altitude += 10;
734 break;
735
736 default: break;
737 }
738
739 /* Make faster planes fly higher so that they can overtake slower ones */
740 base_altitude += std::min(20 * (v->vcache.cached_max_speed / 200) - 90, 0);
741
742 if (min_level != nullptr) *min_level = base_altitude + AIRCRAFT_MIN_FLYING_ALTITUDE;
743 if (max_level != nullptr) *max_level = base_altitude + AIRCRAFT_MAX_FLYING_ALTITUDE;
744 }
745
753 int GetAircraftHoldMaxAltitude(const Aircraft *v)
754 {
755 int tile_height = GetTileHeightBelowAircraft(v);
756
757 return tile_height + ((v->subtype == AIR_HELICOPTER) ? HELICOPTER_HOLD_MAX_FLYING_ALTITUDE : PLANE_HOLD_MAX_FLYING_ALTITUDE);
758 }
759
760 template <class T>
761 int GetAircraftFlightLevel(T *v, bool takeoff)
762 {
763 /* Aircraft is in flight. We want to enforce it being somewhere
764 * between the minimum and the maximum allowed altitude. */
765 int aircraft_min_altitude;
766 int aircraft_max_altitude;
767 GetAircraftFlightLevelBounds(v, &aircraft_min_altitude, &aircraft_max_altitude);
768 int aircraft_middle_altitude = (aircraft_min_altitude + aircraft_max_altitude) / 2;
769
770 /* If those assumptions would be violated, aircraft would behave fairly strange. */
771 assert(aircraft_min_altitude < aircraft_middle_altitude);
772 assert(aircraft_middle_altitude < aircraft_max_altitude);
773
774 int z = v->z_pos;
775 if (z < aircraft_min_altitude ||
776 (HasBit(v->flags, VAF_IN_MIN_HEIGHT_CORRECTION) && z < aircraft_middle_altitude)) {
777 /* Ascend. And don't fly into that mountain right ahead.
778 * And avoid our aircraft become a stairclimber, so if we start
779 * correcting altitude, then we stop correction not too early. */
780 SetBit(v->flags, VAF_IN_MIN_HEIGHT_CORRECTION);
781 z += takeoff ? 2 : 1;
782 } else if (!takeoff && (z > aircraft_max_altitude ||
783 (HasBit(v->flags, VAF_IN_MAX_HEIGHT_CORRECTION) && z > aircraft_middle_altitude))) {
784 /* Descend lower. You are an aircraft, not an space ship.
785 * And again, don't stop correcting altitude too early. */
786 SetBit(v->flags, VAF_IN_MAX_HEIGHT_CORRECTION);
787 z--;
788 } else if (HasBit(v->flags, VAF_IN_MIN_HEIGHT_CORRECTION) && z >= aircraft_middle_altitude) {
789 /* Now, we have corrected altitude enough. */
790 ClrBit(v->flags, VAF_IN_MIN_HEIGHT_CORRECTION);
791 } else if (HasBit(v->flags, VAF_IN_MAX_HEIGHT_CORRECTION) && z <= aircraft_middle_altitude) {
792 /* Now, we have corrected altitude enough. */
793 ClrBit(v->flags, VAF_IN_MAX_HEIGHT_CORRECTION);
794 }
795
796 return z;
797 }
798
799 template int GetAircraftFlightLevel(DisasterVehicle *v, bool takeoff);
800 template int GetAircraftFlightLevel(Aircraft *v, bool takeoff);
801
816 static byte AircraftGetEntryPoint(const Aircraft *v, const AirportFTAClass *apc, Direction rotation)
817 {
818 assert(v != nullptr);
819 assert(apc != nullptr);
820
821 /* In the case the station doesn't exit anymore, set target tile 0.
822 * It doesn't hurt much, aircraft will go to next order, nearest hangar
823 * or it will simply crash in next tick */
824 TileIndex tile = 0;
825
826 const Station *st = Station::GetIfValid(v->targetairport);
827 if (st != nullptr) {
828 /* Make sure we don't go to INVALID_TILE if the airport has been removed. */
829 tile = (st->airport.tile != INVALID_TILE) ? st->airport.tile : st->xy;
830 }
831
832 int delta_x = v->x_pos - TileX(tile) * TILE_SIZE;
833 int delta_y = v->y_pos - TileY(tile) * TILE_SIZE;
834
835 DiagDirection dir;
836 if (abs(delta_y) < abs(delta_x)) {
837 /* We are northeast or southwest of the airport */
838 dir = delta_x < 0 ? DIAGDIR_NE : DIAGDIR_SW;
839 } else {
840 /* We are northwest or southeast of the airport */
841 dir = delta_y < 0 ? DIAGDIR_NW : DIAGDIR_SE;
842 }
843 dir = ChangeDiagDir(dir, DiagDirDifference(DIAGDIR_NE, DirToDiagDir(rotation)));
844 return apc->entry_points[dir];
845 }
846
847
848 static void MaybeCrashAirplane(Aircraft *v);
849
857 static bool AircraftController(Aircraft *v)
858 {
859 /* nullptr if station is invalid */
860 const Station *st = Station::GetIfValid(v->targetairport);
861 /* INVALID_TILE if there is no station */
862 TileIndex tile = INVALID_TILE;
863 Direction rotation = DIR_N;
864 uint size_x = 1, size_y = 1;
865 if (st != nullptr) {
866 if (st->airport.tile != INVALID_TILE) {
867 tile = st->airport.tile;
868 rotation = st->airport.rotation;
869 size_x = st->airport.w;
870 size_y = st->airport.h;
871 } else {
872 tile = st->xy;
873 }
874 }
875 /* DUMMY if there is no station or no airport */
876 const AirportFTAClass *afc = tile == INVALID_TILE ? GetAirport(AT_DUMMY) : st->airport.GetFTA();
877
878 /* prevent going to INVALID_TILE if airport is deleted. */
879 if (st == nullptr || st->airport.tile == INVALID_TILE) {
880 /* Jump into our "holding pattern" state machine if possible */
881 if (v->pos >= afc->nofelements) {
882 v->pos = v->previous_pos = AircraftGetEntryPoint(v, afc, DIR_N);
883 } else if (v->targetairport != v->current_order.GetDestination()) {
884 /* If not possible, just get out of here fast */
885 v->state = FLYING;
886 UpdateAircraftCache(v);
887 AircraftNextAirportPos_and_Order(v);
888 /* get aircraft back on running altitude */
889 SetAircraftPosition(v, v->x_pos, v->y_pos, GetAircraftFlightLevel(v));
890 return false;
891 }
892 }
893
894 /* get airport moving data */
895 const AirportMovingData amd = RotateAirportMovingData(afc->MovingData(v->pos), rotation, size_x, size_y);
896
897 int x = TileX(tile) * TILE_SIZE;
898 int y = TileY(tile) * TILE_SIZE;
899
900 /* Helicopter raise */
901 if (amd.flag & AMED_HELI_RAISE) {
902 Aircraft *u = v->Next()->Next();
903
904 /* Make sure the rotors don't rotate too fast */
905 if (u->cur_speed > 32) {
906 v->cur_speed = 0;
907 if (--u->cur_speed == 32) {
908 if (!PlayVehicleSound(v, VSE_START)) {
909 SoundID sfx = AircraftVehInfo(v->engine_type)->sfx;
910 /* For compatibility with old NewGRF we ignore the sfx property, unless a NewGRF-defined sound is used.
911 * The baseset has only one helicopter sound, so this only limits using plane or cow sounds. */
912 if (sfx < ORIGINAL_SAMPLE_COUNT) sfx = SND_18_TAKEOFF_HELICOPTER;
913 SndPlayVehicleFx(sfx, v);
914 }
915 }
916 } else {
917 u->cur_speed = 32;
918 int count = UpdateAircraftSpeed(v);
919 if (count > 0) {
920 v->tile = 0;
921
922 int z_dest;
923 GetAircraftFlightLevelBounds(v, &z_dest, nullptr);
924
925 /* Reached altitude? */
926 if (v->z_pos >= z_dest) {
927 v->cur_speed = 0;
928 return true;
929 }
930 SetAircraftPosition(v, v->x_pos, v->y_pos, std::min(v->z_pos + count, z_dest));
931 }
932 }
933 return false;
934 }
935
936 /* Helicopter landing. */
937 if (amd.flag & AMED_HELI_LOWER) {
938 SetBit(v->flags, VAF_HELI_DIRECT_DESCENT);
939
940 if (st == nullptr) {
941 /* FIXME - AircraftController -> if station no longer exists, do not land
942 * helicopter will circle until sign disappears, then go to next order
943 * what to do when it is the only order left, right now it just stays in 1 place */
944 v->state = FLYING;
945 UpdateAircraftCache(v);
946 AircraftNextAirportPos_and_Order(v);
947 return false;
948 }
949
950 /* Vehicle is now at the airport.
951 * Helicopter has arrived at the target landing pad, so the current position is also where it should land.
952 * Except for Oilrigs which are special due to being a 1x1 station, and helicopters land outside it. */
953 if (st->airport.type != AT_OILRIG) {
954 x = v->x_pos;
955 y = v->y_pos;
956 tile = TileVirtXY(x, y);
957 }
958 v->tile = tile;
959
960 /* Find altitude of landing position. */
961 int z = GetSlopePixelZ(x, y) + 1 + afc->delta_z;
962
963 if (z == v->z_pos) {
964 Vehicle *u = v->Next()->Next();
965
966 /* Increase speed of rotors. When speed is 80, we've landed. */
967 if (u->cur_speed >= 80) {
968 ClrBit(v->flags, VAF_HELI_DIRECT_DESCENT);
969 return true;
970 }
971 u->cur_speed += 4;
972 } else {
973 int count = UpdateAircraftSpeed(v);
974 if (count > 0) {
975 if (v->z_pos > z) {
976 SetAircraftPosition(v, v->x_pos, v->y_pos, std::max(v->z_pos - count, z));
977 } else {
978 SetAircraftPosition(v, v->x_pos, v->y_pos, std::min(v->z_pos + count, z));
979 }
980 }
981 }
982 return false;
983 }
984
985 /* Get distance from destination pos to current pos. */
986 uint dist = abs(x + amd.x - v->x_pos) + abs(y + amd.y - v->y_pos);
987
988 /* Need exact position? */
989 if (!(amd.flag & AMED_EXACTPOS) && dist <= (amd.flag & AMED_SLOWTURN ? 8U : 4U)) return true;
990
991 /* At final pos? */
992 if (dist == 0) {
993 /* Change direction smoothly to final direction. */
994 DirDiff dirdiff = DirDifference(amd.direction, v->direction);
995 /* if distance is 0, and plane points in right direction, no point in calling
996 * UpdateAircraftSpeed(). So do it only afterwards */
997 if (dirdiff == DIRDIFF_SAME) {
998 v->cur_speed = 0;
999 return true;
1000 }
1001
1002 if (!UpdateAircraftSpeed(v, SPEED_LIMIT_TAXI)) return false;
1003
1004 v->direction = ChangeDir(v->direction, dirdiff > DIRDIFF_REVERSE ? DIRDIFF_45LEFT : DIRDIFF_45RIGHT);
1005 v->cur_speed >>= 1;
1006
1007 SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos);
1008 return false;
1009 }
1010
1011 if (amd.flag & AMED_BRAKE && v->cur_speed > SPEED_LIMIT_TAXI * _settings_game.vehicle.plane_speed) {
1012 MaybeCrashAirplane(v);
1013 if ((v->vehstatus & VS_CRASHED) != 0) return false;
1014 }
1015
1016 uint speed_limit = SPEED_LIMIT_TAXI;
1017 bool hard_limit = true;
1018
1019 if (amd.flag & AMED_NOSPDCLAMP) speed_limit = SPEED_LIMIT_NONE;
1020 if (amd.flag & AMED_HOLD) { speed_limit = SPEED_LIMIT_HOLD; hard_limit = false; }
1021 if (amd.flag & AMED_LAND) { speed_limit = SPEED_LIMIT_APPROACH; hard_limit = false; }
1022 if (amd.flag & AMED_BRAKE) { speed_limit = SPEED_LIMIT_TAXI; hard_limit = false; }
1023
1024 int count = UpdateAircraftSpeed(v, speed_limit, hard_limit);
1025 if (count == 0) return false;
1026
1027 /* If the plane will be a few subpixels away from the destination after
1028 * this movement loop, start nudging it towards the exact position for
1029 * the whole loop. Otherwise, heavily depending on the speed of the plane,
1030 * it is possible we totally overshoot the target, causing the plane to
1031 * make a loop, and trying again, and again, and again .. */
1032 bool nudge_towards_target = static_cast<uint>(count) + 3 > dist;
1033
1034 if (v->turn_counter != 0) v->turn_counter--;
1035
1036 do {
1037
1038 GetNewVehiclePosResult gp;
1039
1040 if (nudge_towards_target || (amd.flag & AMED_LAND)) {
1041 /* move vehicle one pixel towards target */
1042 gp.x = (v->x_pos != (x + amd.x)) ?
1043 v->x_pos + ((x + amd.x > v->x_pos) ? 1 : -1) :
1044 v->x_pos;
1045 gp.y = (v->y_pos != (y + amd.y)) ?
1046 v->y_pos + ((y + amd.y > v->y_pos) ? 1 : -1) :
1047 v->y_pos;
1048
1049 /* Oilrigs must keep v->tile as st->airport.tile, since the landing pad is in a non-airport tile */
1050 gp.new_tile = (st->airport.type == AT_OILRIG) ? st->airport.tile : TileVirtXY(gp.x, gp.y);
1051
1052 } else {
1053
1054 /* Turn. Do it slowly if in the air. */
1055 Direction newdir = GetDirectionTowards(v, x + amd.x, y + amd.y);
1056 if (newdir != v->direction) {
1057 if (amd.flag & AMED_SLOWTURN && v->number_consecutive_turns < 8 && v->subtype == AIR_AIRCRAFT) {
1058 if (v->turn_counter == 0 || newdir == v->last_direction) {
1059 if (newdir == v->last_direction) {
1060 v->number_consecutive_turns = 0;
1061 } else {
1062 v->number_consecutive_turns++;
1063 }
1064 v->turn_counter = 2 * _settings_game.vehicle.plane_speed;
1065 v->last_direction = v->direction;
1066 v->direction = newdir;
1067 }
1068
1069 /* Move vehicle. */
1070 gp = GetNewVehiclePos(v);
1071 } else {
1072 v->cur_speed >>= 1;
1073 v->direction = newdir;
1074
1075 /* When leaving a terminal an aircraft often goes to a position
1076 * directly in front of it. If it would move while turning it
1077 * would need an two extra turns to end up at the correct position.
1078 * To make it easier just disallow all moving while turning as
1079 * long as an aircraft is on the ground. */
1080 gp.x = v->x_pos;
1081 gp.y = v->y_pos;
1082 gp.new_tile = gp.old_tile = v->tile;
1083 }
1084 } else {
1085 v->number_consecutive_turns = 0;
1086 /* Move vehicle. */
1087 gp = GetNewVehiclePos(v);
1088 }
1089 }
1090
1091 v->tile = gp.new_tile;
1092 /* If vehicle is in the air, use tile coordinate 0. */
1093 if (amd.flag & (AMED_TAKEOFF | AMED_SLOWTURN | AMED_LAND)) v->tile = 0;
1094
1095 /* Adjust Z for land or takeoff? */
1096 int z = v->z_pos;
1097
1098 if (amd.flag & AMED_TAKEOFF) {
1099 z = GetAircraftFlightLevel(v, true);
1100 } else if (amd.flag & AMED_HOLD) {
1101 /* Let the plane drop from normal flight altitude to holding pattern altitude */
1102 if (z > GetAircraftHoldMaxAltitude(v)) z--;
1103 } else if ((amd.flag & AMED_SLOWTURN) && (amd.flag & AMED_NOSPDCLAMP)) {
1104 z = GetAircraftFlightLevel(v);
1105 }
1106
1107 /* NewGRF airports (like a rotated intercontinental from OpenGFX+Airports) can be non-rectangular
1108 * and their primary (north-most) tile does not have to be part of the airport.
1109 * As such, the height of the primary tile can be different from the rest of the airport.
1110 * Given we are landing/breaking, and as such are not a helicopter, we know that there has to be a hangar.
1111 * We also know that the airport itself has to be completely flat (otherwise it is not a valid airport).
1112 * Therefore, use the height of this hangar to calculate our z-value. */
1113 int airport_z = v->z_pos;
1114 if ((amd.flag & (AMED_LAND | AMED_BRAKE)) && st != nullptr) {
1115 assert(st->airport.HasHangar());
1116 TileIndex hangar_tile = st->airport.GetHangarTile(0);
1117 airport_z = GetTileMaxPixelZ(hangar_tile) + 1; // To avoid clashing with the shadow
1118 }
1119
1120 if (amd.flag & AMED_LAND) {
1121 if (st->airport.tile == INVALID_TILE) {
1122 /* Airport has been removed, abort the landing procedure */
1123 v->state = FLYING;
1124 UpdateAircraftCache(v);
1125 AircraftNextAirportPos_and_Order(v);
1126 /* get aircraft back on running altitude */
1127 SetAircraftPosition(v, gp.x, gp.y, GetAircraftFlightLevel(v));
1128 continue;
1129 }
1130
1131 /* We're not flying below our destination, right? */
1132 assert(airport_z <= z);
1133 int t = std::max(1U, dist - 4);
1134 int delta = z - airport_z;
1135
1136 /* Only start lowering when we're sufficiently close for a 1:1 glide */
1137 if (delta >= t) {
1138 z -= CeilDiv(z - airport_z, t);
1139 }
1140 if (z < airport_z) z = airport_z;
1141 }
1142
1143 /* We've landed. Decrease speed when we're reaching end of runway. */
1144 if (amd.flag & AMED_BRAKE) {
1145
1146 if (z > airport_z) {
1147 z--;
1148 } else if (z < airport_z) {
1149 z++;
1150 }
1151
1152 }
1153
1154 SetAircraftPosition(v, gp.x, gp.y, z);
1155 } while (--count != 0);
1156 return false;
1157 }
1158
1163 static bool HandleCrashedAircraft(Aircraft *v)
1164 {
1165 v->crashed_counter += 3;
1166
1167 Station *st = GetTargetAirportIfValid(v);
1168
1169 /* make aircraft crash down to the ground */
1170 if (v->crashed_counter < 500 && st == nullptr && ((v->crashed_counter % 3) == 0) ) {
1171 int z = GetSlopePixelZ(Clamp(v->x_pos, 0, MapMaxX() * TILE_SIZE), Clamp(v->y_pos, 0, MapMaxY() * TILE_SIZE));
1172 v->z_pos -= 1;
1173 if (v->z_pos == z) {
1174 v->crashed_counter = 500;
1175 v->z_pos++;
1176 }
1177 }
1178
1179 if (v->crashed_counter < 650) {
1180 uint32 r;
1181 if (Chance16R(1, 32, r)) {
1182 static const DirDiff delta[] = {
1183 DIRDIFF_45LEFT, DIRDIFF_SAME, DIRDIFF_SAME, DIRDIFF_45RIGHT
1184 };
1185
1186 v->direction = ChangeDir(v->direction, delta[GB(r, 16, 2)]);
1187 SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos);
1188 r = Random();
1189 CreateEffectVehicleRel(v,
1190 GB(r, 0, 4) - 4,
1191 GB(r, 4, 4) - 4,
1192 GB(r, 8, 4),
1193 EV_EXPLOSION_SMALL);
1194 }
1195 } else if (v->crashed_counter >= 10000) {
1196 /* remove rubble of crashed airplane */
1197
1198 /* clear runway-in on all airports, set by crashing plane
1199 * small airports use AIRPORT_BUSY, city airports use RUNWAY_IN_OUT_block, etc.
1200 * but they all share the same number */
1201 if (st != nullptr) {
1202 CLRBITS(st->airport.flags, RUNWAY_IN_block);
1203 CLRBITS(st->airport.flags, RUNWAY_IN_OUT_block); // commuter airport
1204 CLRBITS(st->airport.flags, RUNWAY_IN2_block); // intercontinental
1205 }
1206
1207 delete v;
1208
1209 return false;
1210 }
1211
1212 return true;
1213 }
1214
1215
1221 static void HandleAircraftSmoke(Aircraft *v, bool mode)
1222 {
1223 static const struct {
1224 int8 x;
1225 int8 y;
1226 } smoke_pos[] = {
1227 { 5, 5 },
1228 { 6, 0 },
1229 { 5, -5 },
1230 { 0, -6 },
1231 { -5, -5 },
1232 { -6, 0 },
1233 { -5, 5 },
1234 { 0, 6 }
1235 };
1236
1237 if (!(v->vehstatus & VS_AIRCRAFT_BROKEN)) return;
1238
1239 /* Stop smoking when landed */
1240 if (v->cur_speed < 10) {
1241 v->vehstatus &= ~VS_AIRCRAFT_BROKEN;
1242 v->breakdown_ctr = 0;
1243 return;
1244 }
1245
1246 /* Spawn effect et most once per Tick, i.e. !mode */
1247 if (!mode && (v->tick_counter & 0x0F) == 0) {
1248 CreateEffectVehicleRel(v,
1249 smoke_pos[v->direction].x,
1250 smoke_pos[v->direction].y,
1251 2,
1252 EV_BREAKDOWN_SMOKE_AIRCRAFT
1253 );
1254 }
1255 }
1256
1257 void HandleMissingAircraftOrders(Aircraft *v)
1258 {
1259 /*
1260 * We do not have an order. This can be divided into two cases:
1261 * 1) we are heading to an invalid station. In this case we must
1262 * find another airport to go to. If there is nowhere to go,
1263 * we will destroy the aircraft as it otherwise will enter
1264 * the holding pattern for the first airport, which can cause
1265 * the plane to go into an undefined state when building an
1266 * airport with the same StationID.
1267 * 2) we are (still) heading to a (still) valid airport, then we
1268 * can continue going there. This can happen when you are
1269 * changing the aircraft's orders while in-flight or in for
1270 * example a depot. However, when we have a current order to
1271 * go to a depot, we have to keep that order so the aircraft
1272 * actually stops.
1273 */
1274 const Station *st = GetTargetAirportIfValid(v);
1275 if (st == nullptr) {
1276 Backup<CompanyID> cur_company(_current_company, v->owner, FILE_LINE);
1277 CommandCost ret = DoCommand(v->tile, v->index, 0, DC_EXEC, CMD_SEND_VEHICLE_TO_DEPOT);
1278 cur_company.Restore();
1279
1280 if (ret.Failed()) CrashAirplane(v);
1281 } else if (!v->current_order.IsType(OT_GOTO_DEPOT)) {
1282 v->current_order.Free();
1283 }
1284 }
1285
1286
1287 TileIndex Aircraft::GetOrderStationLocation(StationID station)
1288 {
1289 /* Orders are changed in flight, ensure going to the right station. */
1290 if (this->state == FLYING) {
1291 AircraftNextAirportPos_and_Order(this);
1292 }
1293
1294 /* Aircraft do not use dest-tile */
1295 return 0;
1296 }
1297
1298 void Aircraft::MarkDirty()
1299 {
1300 this->colourmap = PAL_NONE;
1301 this->UpdateViewport(true, false);
1302 if (this->subtype == AIR_HELICOPTER) {
1303 GetRotorImage(this, EIT_ON_MAP, &this->Next()->Next()->sprite_cache.sprite_seq);
1304 }
1305 }
1306
1307
1308 uint Aircraft::Crash(bool flooded)
1309 {
1310 uint pass = Vehicle::Crash(flooded) + 2; // pilots
1311 this->crashed_counter = flooded ? 9000 : 0; // max 10000, disappear pretty fast when flooded
1312
1313 return pass;
1314 }
1315
1320 static void CrashAirplane(Aircraft *v)
1321 {
1322 CreateEffectVehicleRel(v, 4, 4, 8, EV_EXPLOSION_LARGE);
1323
1324 uint pass = v->Crash();
1325 SetDParam(0, pass);
1326
1327 v->cargo.Truncate();
1328 v->Next()->cargo.Truncate();
1329 const Station *st = GetTargetAirportIfValid(v);
1330 StringID newsitem;
1331 TileIndex vt;
1332 if (st == nullptr) {
1333 newsitem = STR_NEWS_PLANE_CRASH_OUT_OF_FUEL;
1334 vt = TileVirtXY(v->x_pos, v->y_pos);
1335 } else {
1336 SetDParam(1, st->index);
1337 newsitem = STR_NEWS_AIRCRAFT_CRASH;
1338 vt = v->tile;
1339 }
1340
1341 AI::NewEvent(v->owner, new ScriptEventVehicleCrashed(v->index, vt, st == nullptr ? ScriptEventVehicleCrashed::CRASH_AIRCRAFT_NO_AIRPORT : ScriptEventVehicleCrashed::CRASH_PLANE_LANDING));
1342 Game::NewEvent(new ScriptEventVehicleCrashed(v->index, vt, st == nullptr ? ScriptEventVehicleCrashed::CRASH_AIRCRAFT_NO_AIRPORT : ScriptEventVehicleCrashed::CRASH_PLANE_LANDING));
1343
1344 AddTileNewsItem(newsitem, NT_ACCIDENT, vt, nullptr, st != nullptr ? st->index : INVALID_STATION);
1345
1346 ModifyStationRatingAround(vt, v->owner, -160, 30);
1347 if (_settings_client.sound.disaster) SndPlayVehicleFx(SND_12_EXPLOSION, v);
1348 }
1349
1354 static void MaybeCrashAirplane(Aircraft *v)
1355 {
1356
1357 Station *st = Station::Get(v->targetairport);
1358
1359 uint32 prob;
1360 if ((st->airport.GetFTA()->flags & AirportFTAClass::SHORT_STRIP) &&
1361 (AircraftVehInfo(v->engine_type)->subtype & AIR_FAST) &&
1362 !_cheats.no_jetcrash.value) {
1363 prob = 3276;
1364 } else {
1365 if (_settings_game.vehicle.plane_crashes == 0) return;
1366 prob = (0x4000 << _settings_game.vehicle.plane_crashes) / 1500;
1367 }
1368
1369 if (GB(Random(), 0, 22) > prob) return;
1370
1371 /* Crash the airplane. Remove all goods stored at the station. */
1372 for (CargoID i = 0; i < NUM_CARGO; i++) {
1373 st->goods[i].rating = 1;
1374 st->goods[i].cargo.Truncate();
1375 }
1376
1377 CrashAirplane(v);
1378 }
1379
1385 static void AircraftEntersTerminal(Aircraft *v)
1386 {
1387 if (v->current_order.IsType(OT_GOTO_DEPOT)) return;
1388
1389 Station *st = Station::Get(v->targetairport);
1390 v->last_station_visited = v->targetairport;
1391
1392 /* Check if station was ever visited before */
1393 if (!(st->had_vehicle_of_type & HVOT_AIRCRAFT)) {
1394 st->had_vehicle_of_type |= HVOT_AIRCRAFT;
1395 SetDParam(0, st->index);
1396 /* show newsitem of celebrating citizens */
1397 AddVehicleNewsItem(
1398 STR_NEWS_FIRST_AIRCRAFT_ARRIVAL,
1399 (v->owner == _local_company) ? NT_ARRIVAL_COMPANY : NT_ARRIVAL_OTHER,
1400 v->index,
1401 st->index
1402 );
1403 AI::NewEvent(v->owner, new ScriptEventStationFirstVehicle(st->index, v->index));
1404 Game::NewEvent(new ScriptEventStationFirstVehicle(st->index, v->index));
1405 }
1406
1407 v->BeginLoading();
1408 }
1409
1414 static void AircraftLandAirplane(Aircraft *v)
1415 {
1416 Station *st = Station::Get(v->targetairport);
1417
1418 TileIndex vt = TileVirtXY(v->x_pos, v->y_pos);
1419
1420 v->UpdateDeltaXY();
1421
1422 AirportTileAnimationTrigger(st, vt, AAT_STATION_AIRPLANE_LAND);
1423
1424 if (!PlayVehicleSound(v, VSE_TOUCHDOWN)) {
1425 SndPlayVehicleFx(SND_17_SKID_PLANE, v);
1426 }
1427 }
1428
1429
1431 void AircraftNextAirportPos_and_Order(Aircraft *v)
1432 {
1433 if (v->current_order.IsType(OT_GOTO_STATION) || v->current_order.IsType(OT_GOTO_DEPOT)) {
1434 v->targetairport = v->current_order.GetDestination();
1435 }
1436
1437 const Station *st = GetTargetAirportIfValid(v);
1438 const AirportFTAClass *apc = st == nullptr ? GetAirport(AT_DUMMY) : st->airport.GetFTA();
1439 Direction rotation = st == nullptr ? DIR_N : st->airport.rotation;
1440 v->pos = v->previous_pos = AircraftGetEntryPoint(v, apc, rotation);
1441 }
1442
1451 void AircraftLeaveHangar(Aircraft *v, Direction exit_dir)
1452 {
1453 v->cur_speed = 0;
1454 v->subspeed = 0;
1455 v->progress = 0;
1456 v->direction = exit_dir;
1457 v->vehstatus &= ~VS_HIDDEN;
1458 {
1459 Vehicle *u = v->Next();
1460 u->vehstatus &= ~VS_HIDDEN;
1461
1462 /* Rotor blades */
1463 u = u->Next();
1464 if (u != nullptr) {
1465 u->vehstatus &= ~VS_HIDDEN;
1466 u->cur_speed = 80;
1467 }
1468 }
1469
1470 VehicleServiceInDepot(v);
1471 SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos);
1472 InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
1473 SetWindowClassesDirty(WC_AIRCRAFT_LIST);
1474 }
1475
1479 static void AircraftEventHandler_EnterTerminal(Aircraft *v, const AirportFTAClass *apc)
1480 {
1481 AircraftEntersTerminal(v);
1482 v->state = apc->layout[v->pos].heading;
1483 }
1484
1490 static void AircraftEventHandler_EnterHangar(Aircraft *v, const AirportFTAClass *apc)
1491 {
1492 VehicleEnterDepot(v);
1493 v->state = apc->layout[v->pos].heading;
1494 }
1495
1501 static void AircraftEventHandler_InHangar(Aircraft *v, const AirportFTAClass *apc)
1502 {
1503 /* if we just arrived, execute EnterHangar first */
1504 if (v->previous_pos != v->pos) {
1505 AircraftEventHandler_EnterHangar(v, apc);
1506 return;
1507 }
1508
1509 /* if we were sent to the depot, stay there */
1510 if (v->current_order.IsType(OT_GOTO_DEPOT) && (v->vehstatus & VS_STOPPED)) {
1511 v->current_order.Free();
1512 return;
1513 }
1514
1515 if (!v->current_order.IsType(OT_GOTO_STATION) &&
1516 !v->current_order.IsType(OT_GOTO_DEPOT))
1517 return;
1518
1519 /* We are leaving a hangar, but have to go to the exact same one; re-enter */
1520 if (v->current_order.IsType(OT_GOTO_DEPOT) && v->current_order.GetDestination() == v->targetairport) {
1521 VehicleEnterDepot(v);
1522 return;
1523 }
1524
1525 /* if the block of the next position is busy, stay put */
1526 if (AirportHasBlock(v, &apc->layout[v->pos], apc)) return;
1527
1528 /* We are already at the target airport, we need to find a terminal */
1529 if (v->current_order.GetDestination() == v->targetairport) {
1530 /* FindFreeTerminal:
1531 * 1. Find a free terminal, 2. Occupy it, 3. Set the vehicle's state to that terminal */
1532 if (v->subtype == AIR_HELICOPTER) {
1533 if (!AirportFindFreeHelipad(v, apc)) return; // helicopter
1534 } else {
1535 if (!AirportFindFreeTerminal(v, apc)) return; // airplane
1536 }
1537 } else { // Else prepare for launch.
1538 /* airplane goto state takeoff, helicopter to helitakeoff */
1539 v->state = (v->subtype == AIR_HELICOPTER) ? HELITAKEOFF : TAKEOFF;
1540 }
1541 const Station *st = Station::GetByTile(v->tile);
1542 AircraftLeaveHangar(v, st->airport.GetHangarExitDirection(v->tile));
1543 AirportMove(v, apc);
1544 }
1545
1547 static void AircraftEventHandler_AtTerminal(Aircraft *v, const AirportFTAClass *apc)
1548 {
1549 /* if we just arrived, execute EnterTerminal first */
1550 if (v->previous_pos != v->pos) {
1551 AircraftEventHandler_EnterTerminal(v, apc);
1552 /* on an airport with helipads, a helicopter will always land there
1553 * and get serviced at the same time - setting */
1554 if (_settings_game.order.serviceathelipad) {
1555 if (v->subtype == AIR_HELICOPTER && apc->num_helipads > 0) {
1556 /* an excerpt of ServiceAircraft, without the invisibility stuff */
1557 v->date_of_last_service = _date;
1558 v->breakdowns_since_last_service = 0;
1559 v->reliability = v->GetEngine()->reliability;
1560 SetWindowDirty(WC_VEHICLE_DETAILS, v->index);
1561 }
1562 }
1563 return;
1564 }
1565
1566 if (v->current_order.IsType(OT_NOTHING)) return;
1567
1568 /* if the block of the next position is busy, stay put */
1569 if (AirportHasBlock(v, &apc->layout[v->pos], apc)) return;
1570
1571 /* airport-road is free. We either have to go to another airport, or to the hangar
1572 * ---> start moving */
1573
1574 bool go_to_hangar = false;
1575 switch (v->current_order.GetType()) {
1576 case OT_GOTO_STATION: // ready to fly to another airport
1577 break;
1578 case OT_GOTO_DEPOT: // visit hangar for servicing, sale, etc.
1579 go_to_hangar = v->current_order.GetDestination() == v->targetairport;
1580 break;
1581 case OT_CONDITIONAL:
1582 /* In case of a conditional order we just have to wait a tick
1583 * longer, so the conditional order can actually be processed;
1584 * we should not clear the order as that makes us go nowhere. */
1585 return;
1586 default: // orders have been deleted (no orders), goto depot and don't bother us
1587 v->current_order.Free();
1588 go_to_hangar = Station::Get(v->targetairport)->airport.HasHangar();
1589 }
1590
1591 if (go_to_hangar && Station::Get(v->targetairport)->airport.HasHangar()) {
1592 v->state = HANGAR;
1593 } else {
1594 /* airplane goto state takeoff, helicopter to helitakeoff */
1595 v->state = (v->subtype == AIR_HELICOPTER) ? HELITAKEOFF : TAKEOFF;
1596 }
1597 AirportMove(v, apc);
1598 }
1599
1600 static void AircraftEventHandler_General(Aircraft *v, const AirportFTAClass *apc)
1601 {
1602 error("OK, you shouldn't be here, check your Airport Scheme!");
1603 }
1604
1605 static void AircraftEventHandler_TakeOff(Aircraft *v, const AirportFTAClass *apc)
1606 {
1607 PlayAircraftSound(v); // play takeoffsound for airplanes
1608 v->state = STARTTAKEOFF;
1609 }
1610
1611 static void AircraftEventHandler_StartTakeOff(Aircraft *v, const AirportFTAClass *apc)
1612 {
1613 v->state = ENDTAKEOFF;
1614 v->UpdateDeltaXY();
1615 }
1616
1617 static void AircraftEventHandler_EndTakeOff(Aircraft *v, const AirportFTAClass *apc)
1618 {
1619 v->state = FLYING;
1620 /* get the next position to go to, differs per airport */
1621 AircraftNextAirportPos_and_Order(v);
1622 }
1623
1624 static void AircraftEventHandler_HeliTakeOff(Aircraft *v, const AirportFTAClass *apc)
1625 {
1626 v->state = FLYING;
1627 v->UpdateDeltaXY();
1628
1629 /* get the next position to go to, differs per airport */
1630 AircraftNextAirportPos_and_Order(v);
1631
1632 /* Send the helicopter to a hangar if needed for replacement */
1633 if (v->NeedsAutomaticServicing()) {
1634 Backup<CompanyID> cur_company(_current_company, v->owner, FILE_LINE);
1635 DoCommand(v->tile, v->index | DEPOT_SERVICE | DEPOT_LOCATE_HANGAR, 0, DC_EXEC, CMD_SEND_VEHICLE_TO_DEPOT);
1636 cur_company.Restore();
1637 }
1638 }
1639
1640 static void AircraftEventHandler_Flying(Aircraft *v, const AirportFTAClass *apc)
1641 {
1642 Station *st = Station::Get(v->targetairport);
1643
1644 /* Runway busy, not allowed to use this airstation or closed, circle. */
1645 if (CanVehicleUseStation(v, st) && (st->owner == OWNER_NONE || st->owner == v->owner) && !(st->airport.flags & AIRPORT_CLOSED_block)) {
1646 /* {32,FLYING,NOTHING_block,37}, {32,LANDING,N,33}, {32,HELILANDING,N,41},
1647 * if it is an airplane, look for LANDING, for helicopter HELILANDING
1648 * it is possible to choose from multiple landing runways, so loop until a free one is found */
1649 byte landingtype = (v->subtype == AIR_HELICOPTER) ? HELILANDING : LANDING;
1650 const AirportFTA *current = apc->layout[v->pos].next;
1651 while (current != nullptr) {
1652 if (current->heading == landingtype) {
1653 /* save speed before, since if AirportHasBlock is false, it resets them to 0
1654 * we don't want that for plane in air
1655 * hack for speed thingie */
1656 uint16 tcur_speed = v->cur_speed;
1657 uint16 tsubspeed = v->subspeed;
1658 if (!AirportHasBlock(v, current, apc)) {
1659 v->state = landingtype; // LANDING / HELILANDING
1660 if (v->state == HELILANDING) SetBit(v->flags, VAF_HELI_DIRECT_DESCENT);
1661 /* it's a bit dirty, but I need to set position to next position, otherwise
1662 * if there are multiple runways, plane won't know which one it took (because
1663 * they all have heading LANDING). And also occupy that block! */
1664 v->pos = current->next_position;
1665 SETBITS(st->airport.flags, apc->layout[v->pos].block);
1666 return;
1667 }
1668 v->cur_speed = tcur_speed;
1669 v->subspeed = tsubspeed;
1670 }
1671 current = current->next;
1672 }
1673 }
1674 v->state = FLYING;
1675 v->pos = apc->layout[v->pos].next_position;
1676 }
1677
1678 static void AircraftEventHandler_Landing(Aircraft *v, const AirportFTAClass *apc)
1679 {
1680 v->state = ENDLANDING;
1681 AircraftLandAirplane(v); // maybe crash airplane
1682
1683 /* check if the aircraft needs to be replaced or renewed and send it to a hangar if needed */
1684 if (v->NeedsAutomaticServicing()) {
1685 Backup<CompanyID> cur_company(_current_company, v->owner, FILE_LINE);
1686 DoCommand(v->tile, v->index | DEPOT_SERVICE, 0, DC_EXEC, CMD_SEND_VEHICLE_TO_DEPOT);
1687 cur_company.Restore();
1688 }
1689 }
1690
1691 static void AircraftEventHandler_HeliLanding(Aircraft *v, const AirportFTAClass *apc)
1692 {
1693 v->state = HELIENDLANDING;
1694 v->UpdateDeltaXY();
1695 }
1696
1697 static void AircraftEventHandler_EndLanding(Aircraft *v, const AirportFTAClass *apc)
1698 {
1699 /* next block busy, don't do a thing, just wait */
1700 if (AirportHasBlock(v, &apc->layout[v->pos], apc)) return;
1701
1702 /* if going to terminal (OT_GOTO_STATION) choose one
1703 * 1. in case all terminals are busy AirportFindFreeTerminal() returns false or
1704 * 2. not going for terminal (but depot, no order),
1705 * --> get out of the way to the hangar. */
1706 if (v->current_order.IsType(OT_GOTO_STATION)) {
1707 if (AirportFindFreeTerminal(v, apc)) return;
1708 }
1709 v->state = HANGAR;
1710
1711 }
1712
1713 static void AircraftEventHandler_HeliEndLanding(Aircraft *v, const AirportFTAClass *apc)
1714 {
1715 /* next block busy, don't do a thing, just wait */
1716 if (AirportHasBlock(v, &apc->layout[v->pos], apc)) return;
1717
1718 /* if going to helipad (OT_GOTO_STATION) choose one. If airport doesn't have helipads, choose terminal
1719 * 1. in case all terminals/helipads are busy (AirportFindFreeHelipad() returns false) or
1720 * 2. not going for terminal (but depot, no order),
1721 * --> get out of the way to the hangar IF there are terminals on the airport.
1722 * --> else TAKEOFF
1723 * the reason behind this is that if an airport has a terminal, it also has a hangar. Airplanes
1724 * must go to a hangar. */
1725 if (v->current_order.IsType(OT_GOTO_STATION)) {
1726 if (AirportFindFreeHelipad(v, apc)) return;
1727 }
1728 v->state = Station::Get(v->targetairport)->airport.HasHangar() ? HANGAR : HELITAKEOFF;
1729 }
1730
1736 typedef void AircraftStateHandler(Aircraft *v, const AirportFTAClass *apc);
1738 static AircraftStateHandler * const _aircraft_state_handlers[] = {
1739 AircraftEventHandler_General, // TO_ALL = 0
1740 AircraftEventHandler_InHangar, // HANGAR = 1
1741 AircraftEventHandler_AtTerminal, // TERM1 = 2
1742 AircraftEventHandler_AtTerminal, // TERM2 = 3
1743 AircraftEventHandler_AtTerminal, // TERM3 = 4
1744 AircraftEventHandler_AtTerminal, // TERM4 = 5
1745 AircraftEventHandler_AtTerminal, // TERM5 = 6
1746 AircraftEventHandler_AtTerminal, // TERM6 = 7
1747 AircraftEventHandler_AtTerminal, // HELIPAD1 = 8
1748 AircraftEventHandler_AtTerminal, // HELIPAD2 = 9
1749 AircraftEventHandler_TakeOff, // TAKEOFF = 10
1750 AircraftEventHandler_StartTakeOff, // STARTTAKEOFF = 11
1751 AircraftEventHandler_EndTakeOff, // ENDTAKEOFF = 12
1752 AircraftEventHandler_HeliTakeOff, // HELITAKEOFF = 13
1753 AircraftEventHandler_Flying, // FLYING = 14
1754 AircraftEventHandler_Landing, // LANDING = 15
1755 AircraftEventHandler_EndLanding, // ENDLANDING = 16
1756 AircraftEventHandler_HeliLanding, // HELILANDING = 17
1757 AircraftEventHandler_HeliEndLanding, // HELIENDLANDING = 18
1758 AircraftEventHandler_AtTerminal, // TERM7 = 19
1759 AircraftEventHandler_AtTerminal, // TERM8 = 20
1760 AircraftEventHandler_AtTerminal, // HELIPAD3 = 21
1761 };
1762
1763 static void AirportClearBlock(const Aircraft *v, const AirportFTAClass *apc)
1764 {
1765 /* we have left the previous block, and entered the new one. Free the previous block */
1766 if (apc->layout[v->previous_pos].block != apc->layout[v->pos].block) {
1767 Station *st = Station::Get(v->targetairport);
1768
1769 CLRBITS(st->airport.flags, apc->layout[v->previous_pos].block);
1770 }
1771 }
1772
1773 static void AirportGoToNextPosition(Aircraft *v)
1774 {
1775 /* if aircraft is not in position, wait until it is */
1776 if (!AircraftController(v)) return;
1777
1778 const AirportFTAClass *apc = Station::Get(v->targetairport)->airport.GetFTA();
1779
1780 AirportClearBlock(v, apc);
1781 AirportMove(v, apc); // move aircraft to next position
1782 }
1783
1784 /* gets pos from vehicle and next orders */
1785 static bool AirportMove(Aircraft *v, const AirportFTAClass *apc)
1786 {
1787 /* error handling */
1788 if (v->pos >= apc->nofelements) {
1789 Debug(misc, 0, "[Ap] position {} is not valid for current airport. Max position is {}", v->pos, apc->nofelements-1);
1790 assert(v->pos < apc->nofelements);
1791 }
1792
1793 const AirportFTA *current = &apc->layout[v->pos];
1794 /* we have arrived in an important state (eg terminal, hangar, etc.) */
1795 if (current->heading == v->state) {
1796 byte prev_pos = v->pos; // location could be changed in state, so save it before-hand
1797 byte prev_state = v->state;
1798 _aircraft_state_handlers[v->state](v, apc);
1799 if (v->state != FLYING) v->previous_pos = prev_pos;
1800 if (v->state != prev_state || v->pos != prev_pos) UpdateAircraftCache(v);
1801 return true;
1802 }
1803
1804 v->previous_pos = v->pos; // save previous location
1805
1806 /* there is only one choice to move to */
1807 if (current->next == nullptr) {
1808 if (AirportSetBlocks(v, current, apc)) {
1809 v->pos = current->next_position;
1810 UpdateAircraftCache(v);
1811 } // move to next position
1812 return false;
1813 }
1814
1815 /* there are more choices to choose from, choose the one that
1816 * matches our heading */
1817 do {
1818 if (v->state == current->heading || current->heading == TO_ALL) {
1819 if (AirportSetBlocks(v, current, apc)) {
1820 v->pos = current->next_position;
1821 UpdateAircraftCache(v);
1822 } // move to next position
1823 return false;
1824 }
1825 current = current->next;
1826 } while (current != nullptr);
1827
1828 Debug(misc, 0, "[Ap] cannot move further on Airport! (pos {} state {}) for vehicle {}", v->pos, v->state, v->index);
1829 NOT_REACHED();
1830 }
1831
1833 static bool AirportHasBlock(Aircraft *v, const AirportFTA *current_pos, const AirportFTAClass *apc)
1834 {
1835 const AirportFTA *reference = &apc->layout[v->pos];
1836 const AirportFTA *next = &apc->layout[current_pos->next_position];
1837
1838 /* same block, then of course we can move */
1839 if (apc->layout[current_pos->position].block != next->block) {
1840 const Station *st = Station::Get(v->targetairport);
1841 uint64 airport_flags = next->block;
1842
1843 /* check additional possible extra blocks */
1844 if (current_pos != reference && current_pos->block != NOTHING_block) {
1845 airport_flags |= current_pos->block;
1846 }
1847
1848 if (st->airport.flags & airport_flags) {
1849 v->cur_speed = 0;
1850 v->subspeed = 0;
1851 return true;
1852 }
1853 }
1854 return false;
1855 }
1856
1864 static bool AirportSetBlocks(Aircraft *v, const AirportFTA *current_pos, const AirportFTAClass *apc)
1865 {
1866 const AirportFTA *next = &apc->layout[current_pos->next_position];
1867 const AirportFTA *reference = &apc->layout[v->pos];
1868
1869 /* if the next position is in another block, check it and wait until it is free */
1870 if ((apc->layout[current_pos->position].block & next->block) != next->block) {
1871 uint64 airport_flags = next->block;
1872 /* search for all all elements in the list with the same state, and blocks != N
1873 * this means more blocks should be checked/set */
1874 const AirportFTA *current = current_pos;
1875 if (current == reference) current = current->next;
1876 while (current != nullptr) {
1877 if (current->heading == current_pos->heading && current->block != 0) {
1878 airport_flags |= current->block;
1879 break;
1880 }
1881 current = current->next;
1882 }
1883
1884 /* if the block to be checked is in the next position, then exclude that from
1885 * checking, because it has been set by the airplane before */
1886 if (current_pos->block == next->block) airport_flags ^= next->block;
1887
1888 Station *st = Station::Get(v->targetairport);
1889 if (st->airport.flags & airport_flags) {
1890 v->cur_speed = 0;
1891 v->subspeed = 0;
1892 return false;
1893 }
1894
1895 if (next->block != NOTHING_block) {
1896 SETBITS(st->airport.flags, airport_flags); // occupy next block
1897 }
1898 }
1899 return true;
1900 }
1901
1906 struct MovementTerminalMapping {
1907 AirportMovementStates state;
1908 uint64 airport_flag;
1909 };
1910
1912 static const MovementTerminalMapping _airport_terminal_mapping[] = {
1913 {TERM1, TERM1_block},
1914 {TERM2, TERM2_block},
1915 {TERM3, TERM3_block},
1916 {TERM4, TERM4_block},
1917 {TERM5, TERM5_block},
1918 {TERM6, TERM6_block},
1919 {TERM7, TERM7_block},
1920 {TERM8, TERM8_block},
1921 {HELIPAD1, HELIPAD1_block},
1922 {HELIPAD2, HELIPAD2_block},
1923 {HELIPAD3, HELIPAD3_block},
1924 };
1925
1933 static bool FreeTerminal(Aircraft *v, byte i, byte last_terminal)
1934 {
1935 assert(last_terminal <= lengthof(_airport_terminal_mapping));
1936 Station *st = Station::Get(v->targetairport);
1937 for (; i < last_terminal; i++) {
1938 if ((st->airport.flags & _airport_terminal_mapping[i].airport_flag) == 0) {
1939 /* TERMINAL# HELIPAD# */
1940 v->state = _airport_terminal_mapping[i].state; // start moving to that terminal/helipad
1941 SETBITS(st->airport.flags, _airport_terminal_mapping[i].airport_flag); // occupy terminal/helipad
1942 return true;
1943 }
1944 }
1945 return false;
1946 }
1947
1953 static uint GetNumTerminals(const AirportFTAClass *apc)
1954 {
1955 uint num = 0;
1956
1957 for (uint i = apc->terminals[0]; i > 0; i--) num += apc->terminals[i];
1958
1959 return num;
1960 }
1961
1968 static bool AirportFindFreeTerminal(Aircraft *v, const AirportFTAClass *apc)
1969 {
1970 /* example of more terminalgroups
1971 * {0,HANGAR,NOTHING_block,1}, {0,TERMGROUP,TERM_GROUP1_block,0}, {0,TERMGROUP,TERM_GROUP2_ENTER_block,1}, {0,0,N,1},
1972 * Heading TERMGROUP denotes a group. We see 2 groups here:
1973 * 1. group 0 -- TERM_GROUP1_block (check block)
1974 * 2. group 1 -- TERM_GROUP2_ENTER_block (check block)
1975 * First in line is checked first, group 0. If the block (TERM_GROUP1_block) is free, it
1976 * looks at the corresponding terminals of that group. If no free ones are found, other
1977 * possible groups are checked (in this case group 1, since that is after group 0). If that
1978 * fails, then attempt fails and plane waits
1979 */
1980 if (apc->terminals[0] > 1) {
1981 const Station *st = Station::Get(v->targetairport);
1982 const AirportFTA *temp = apc->layout[v->pos].next;
1983
1984 while (temp != nullptr) {
1985 if (temp->heading == TERMGROUP) {
1986 if (!(st->airport.flags & temp->block)) {
1987 /* read which group do we want to go to?
1988 * (the first free group) */
1989 uint target_group = temp->next_position + 1;
1990
1991 /* at what terminal does the group start?
1992 * that means, sum up all terminals of
1993 * groups with lower number */
1994 uint group_start = 0;
1995 for (uint i = 1; i < target_group; i++) {
1996 group_start += apc->terminals[i];
1997 }
1998
1999 uint group_end = group_start + apc->terminals[target_group];
2000 if (FreeTerminal(v, group_start, group_end)) return true;
2001 }
2002 } else {
2003 /* once the heading isn't 255, we've exhausted the possible blocks.
2004 * So we cannot move */
2005 return false;
2006 }
2007 temp = temp->next;
2008 }
2009 }
2010
2011 /* if there is only 1 terminalgroup, all terminals are checked (starting from 0 to max) */
2012 return FreeTerminal(v, 0, GetNumTerminals(apc));
2013 }
2014
2021 static bool AirportFindFreeHelipad(Aircraft *v, const AirportFTAClass *apc)
2022 {
2023 /* if an airport doesn't have helipads, use terminals */
2024 if (apc->num_helipads == 0) return AirportFindFreeTerminal(v, apc);
2025
2026 /* only 1 helicoptergroup, check all helipads
2027 * The blocks for helipads start after the last terminal (MAX_TERMINALS) */
2028 return FreeTerminal(v, MAX_TERMINALS, apc->num_helipads + MAX_TERMINALS);
2029 }
2030
2036 static void AircraftHandleDestTooFar(Aircraft *v, bool too_far)
2037 {
2038 if (too_far) {
2039 if (!HasBit(v->flags, VAF_DEST_TOO_FAR)) {
2040 SetBit(v->flags, VAF_DEST_TOO_FAR);
2041 SetWindowWidgetDirty(WC_VEHICLE_VIEW, v->index, WID_VV_START_STOP);
2042 AI::NewEvent(v->owner, new ScriptEventAircraftDestTooFar(v->index));
2043 if (v->owner == _local_company) {
2044 /* Post a news message. */
2045 SetDParam(0, v->index);
2046 AddVehicleAdviceNewsItem(STR_NEWS_AIRCRAFT_DEST_TOO_FAR, v->index);
2047 }
2048 }
2049 return;
2050 }
2051
2052 if (HasBit(v->flags, VAF_DEST_TOO_FAR)) {
2053 /* Not too far anymore, clear flag and message. */
2054 ClrBit(v->flags, VAF_DEST_TOO_FAR);
2055 SetWindowWidgetDirty(WC_VEHICLE_VIEW, v->index, WID_VV_START_STOP);
2056 DeleteVehicleNews(v->index, STR_NEWS_AIRCRAFT_DEST_TOO_FAR);
2057 }
2058 }
2059
2060 static bool AircraftEventHandler(Aircraft *v, int loop)
2061 {
2062 if (v->vehstatus & VS_CRASHED) {
2063 return HandleCrashedAircraft(v);
2064 }
2065
2066 if (v->vehstatus & VS_STOPPED) return true;
2067
2068 v->HandleBreakdown();
2069
2070 HandleAircraftSmoke(v, loop != 0);
2071 ProcessOrders(v);
2072 v->HandleLoading(loop != 0);
2073
2074 if (v->current_order.IsType(OT_LOADING) || v->current_order.IsType(OT_LEAVESTATION)) return true;
2075
2076 if (v->state >= ENDTAKEOFF && v->state <= HELIENDLANDING) {
2077 /* If we are flying, unconditionally clear the 'dest too far' state. */
2078 AircraftHandleDestTooFar(v, false);
2079 } else if (v->acache.cached_max_range_sqr != 0) {
2080 /* Check the distance to the next destination. This code works because the target
2081 * airport is only updated after take off and not on the ground. */
2082 Station *cur_st = Station::GetIfValid(v->targetairport);
2083 Station *next_st = v->current_order.IsType(OT_GOTO_STATION) || v->current_order.IsType(OT_GOTO_DEPOT) ? Station::GetIfValid(v->current_order.GetDestination()) : nullptr;
2084
2085 if (cur_st != nullptr && cur_st->airport.tile != INVALID_TILE && next_st != nullptr && next_st->airport.tile != INVALID_TILE) {
2086 uint dist = DistanceSquare(cur_st->airport.tile, next_st->airport.tile);
2087 AircraftHandleDestTooFar(v, dist > v->acache.cached_max_range_sqr);
2088 }
2089 }
2090
2091 if (!HasBit(v->flags, VAF_DEST_TOO_FAR)) AirportGoToNextPosition(v);
2092
2093 return true;
2094 }
2095
2096 bool Aircraft::Tick()
2097 {
2098 if (!this->IsNormalAircraft()) return true;
2099
2100 PerformanceAccumulator framerate(PFE_GL_AIRCRAFT);
2101
2102 this->tick_counter++;
2103
2104 if (!(this->vehstatus & VS_STOPPED)) this->running_ticks++;
2105
2106 if (this->subtype == AIR_HELICOPTER) HelicopterTickHandler(this);
2107
2108 this->current_order_time++;
2109
2110 for (uint i = 0; i != 2; i++) {
2111 /* stop if the aircraft was deleted */
2112 if (!AircraftEventHandler(this, i)) return false;
2113 }
2114
2115 return true;
2116 }
2117
2118
2125 Station *GetTargetAirportIfValid(const Aircraft *v)
2126 {
2127 assert(v->type == VEH_AIRCRAFT);
2128
2129 Station *st = Station::GetIfValid(v->targetairport);
2130 if (st == nullptr) return nullptr;
2131
2132 return st->airport.tile == INVALID_TILE ? nullptr : st;
2133 }
2134
2139 void UpdateAirplanesOnNewStation(const Station *st)
2140 {
2141 /* only 1 station is updated per function call, so it is enough to get entry_point once */
2142 const AirportFTAClass *ap = st->airport.GetFTA();
2143 Direction rotation = st->airport.tile == INVALID_TILE ? DIR_N : st->airport.rotation;
2144
2145 for (Aircraft *v : Aircraft::Iterate()) {
2146 if (!v->IsNormalAircraft() || v->targetairport != st->index) continue;
2147 assert(v->state == FLYING);
2148
2149 Order *o = &v->current_order;
2150 /* The aircraft is heading to a hangar, but the new station doesn't have one,
2151 * or the aircraft can't land on the new station. Cancel current order. */
2152 if (o->IsType(OT_GOTO_DEPOT) && !(o->GetDepotOrderType() & ODTFB_PART_OF_ORDERS) && o->GetDestination() == st->index &&
2153 (!st->airport.HasHangar() || !CanVehicleUseStation(v, st))) {
2154 o->MakeDummy();
2155 SetWindowWidgetDirty(WC_VEHICLE_VIEW, v->index, WID_VV_START_STOP);
2156 }
2157 v->pos = v->previous_pos = AircraftGetEntryPoint(v, ap, rotation);
2158 UpdateAircraftCache(v);
2159 }
2160
2161 /* Heliports don't have a hangar. Invalidate all go to hangar orders from all aircraft. */
2162 if (!st->airport.HasHangar()) RemoveOrderFromAllVehicles(OT_GOTO_DEPOT, st->index, true);
2163 }
VEH_AIRCRAFT
@ VEH_AIRCRAFT
Aircraft vehicle type.
Definition: vehicle_type.h:27
VSE_START
@ VSE_START
Vehicle starting, i.e. leaving, the station.
Definition: newgrf_sound.h:19
game.hpp
CrashAirplane
static void CrashAirplane(Aircraft *v)
Bring the aircraft in a crashed state, create the explosion animation, and create a news item about t...
Definition: aircraft_cmd.cpp:1320
Vehicle::IsChainInDepot
virtual bool IsChainInDepot() const
Check whether the whole vehicle chain is in the depot.
Definition: vehicle_base.h:523
Aircraft::targetairport
StationID targetairport
Airport to go to next.
Definition: aircraft.h:78
AircraftEventHandler_EnterHangar
static void AircraftEventHandler_EnterHangar(Aircraft *v, const AirportFTAClass *apc)
Aircraft arrived in an airport hangar.
Definition: aircraft_cmd.cpp:1490
DIAGDIR_SE
@ DIAGDIR_SE
Southeast.
Definition: direction_type.h:80
AirportFTA::heading
byte heading
heading (current orders), guiding an airplane to its target on an airport
Definition: airport.h:195
HELILANDING
@ HELILANDING
Helicopter wants to land.
Definition: airport.h:78
PlayVehicleSound
bool PlayVehicleSound(const Vehicle *v, VehicleSoundEvent event)
Checks whether a NewGRF wants to play a different vehicle sound effect.
Definition: newgrf_sound.cpp:186
AircraftHandleDestTooFar
static void AircraftHandleDestTooFar(Aircraft *v, bool too_far)
Handle the 'dest too far' flag and the corresponding news message for aircraft.
Definition: aircraft_cmd.cpp:2036
Cheats::no_jetcrash
Cheat no_jetcrash
no jet will crash on small airports anymore
Definition: cheat_type.h:31
UpdateAircraftSpeed
static int UpdateAircraftSpeed(Aircraft *v, uint speed_limit=SPEED_LIMIT_NONE, bool hard_limit=true)
Sets the new speed for an aircraft.
Definition: aircraft_cmd.cpp:636
TileIndex
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:83
InvalidateWindowData
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
Definition: window.cpp:3234
Order::MakeDummy
void MakeDummy()
Makes this order a Dummy order.
Definition: order_cmd.cpp:132
sound_func.h
Airport::GetHangarExitDirection
Direction GetHangarExitDirection(TileIndex tile) const
Get the exit direction of the hangar at a specific tile.
Definition: station_base.h:387
Station::goods
GoodsEntry goods[NUM_CARGO]
Goods at this station.
Definition: station_base.h:476
DIRDIFF_REVERSE
@ DIRDIFF_REVERSE
One direction is the opposite of the other one.
Definition: direction_type.h:66
DoCommand
CommandCost DoCommand(const CommandContainer *container, DoCommandFlag flags)
Shorthand for calling the long DoCommand with a container.
Definition: command.cpp:450
Order::IsType
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition: order_base.h:64
Pool::PoolItem<&_engine_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:337
SND_18_TAKEOFF_HELICOPTER
@ SND_18_TAKEOFF_HELICOPTER
22 == 0x16 Takeoff: helicopter
Definition: sound_type.h:61
Direction
Direction
Defines the 8 directions on the map.
Definition: direction_type.h:24
ENDTAKEOFF
@ ENDTAKEOFF
Airplane has reached end-point of the take-off runway.
Definition: airport.h:73
Airport::GetHangarNum
uint GetHangarNum(TileIndex tile) const
Get the hangar number of the hangar at a specific tile.
Definition: station_base.h:400
Vehicle::y_pos
int32 y_pos
y coordinate.
Definition: vehicle_base.h:281
SetWindowDirty
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition: window.cpp:3136
MutableSpriteCache::sprite_seq
VehicleSpriteSeq sprite_seq
Vehicle appearance.
Definition: vehicle_base.h:194
VehicleSpriteSeq::CopyWithoutPalette
void CopyWithoutPalette(const VehicleSpriteSeq &src)
Copy data from another sprite sequence, while dropping all recolouring information.
Definition: vehicle_base.h:172
AirportMovingData
A single location on an airport where aircraft can move to.
Definition: airport.h:131
GetPrice
Money GetPrice(Price index, uint cost_factor, const GRFFile *grf_file, int shift)
Determine a certain price.
Definition: economy.cpp:953
GB
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
Definition: bitmath_func.hpp:32
NT_ARRIVAL_OTHER
@ NT_ARRIVAL_OTHER
First vehicle arrived for competitor.
Definition: news_type.h:23
Vehicle::x_pos
int32 x_pos
x coordinate.
Definition: vehicle_base.h:280
DIRDIFF_45LEFT
@ DIRDIFF_45LEFT
Angle of 45 degrees left.
Definition: direction_type.h:68
ChangeDir
static Direction ChangeDir(Direction d, DirDiff delta)
Change a direction by a given difference.
Definition: direction_func.h:104
AircraftVehicleInfo::subtype
byte subtype
Type of aircraft.
Definition: engine_type.h:102
command_func.h
DIR_SE
@ DIR_SE
Southeast.
Definition: direction_type.h:29
GetAircraftHoldMaxAltitude
int GetAircraftHoldMaxAltitude(const Aircraft *v)
Gets the maximum 'flight level' for the holding pattern of the aircraft, in pixels 'z_pos' 0,...
Definition: aircraft_cmd.cpp:753
RotateAirportMovingData
AirportMovingData RotateAirportMovingData(const AirportMovingData *orig, Direction rotation, uint num_tiles_x, uint num_tiles_y)
Rotate the airport moving data to another rotation.
Definition: airport.cpp:80
ODTFB_SERVICE
@ ODTFB_SERVICE
This depot order is because of the servicing limit.
Definition: order_type.h:95
CMD_ERROR
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
Definition: command_func.h:23
GetTileHeightBelowAircraft
int GetTileHeightBelowAircraft(const Vehicle *v)
Get the tile height below the aircraft.
Definition: aircraft_cmd.cpp:701
HELIPAD3_block
static const uint64 HELIPAD3_block
Block belonging to helipad 3.
Definition: airport.h:117
_airport_terminal_mapping
static const MovementTerminalMapping _airport_terminal_mapping[]
A list of all valid terminals and their associated blocks.
Definition: aircraft_cmd.cpp:1912
CheckOrders
void CheckOrders(const Vehicle *v)
Check the orders of a vehicle, to see if there are invalid orders and stuff.
Definition: order_cmd.cpp:1731
Engine::reliability_spd_dec
uint16 reliability_spd_dec
Speed of reliability decay between services (per day).
Definition: engine_base.h:32
Backup
Class to backup a specific variable and restore it later.
Definition: backup_type.hpp:21
AMED_LAND
@ AMED_LAND
Landing onto landing strip.
Definition: airport.h:51
company_base.h
Vehicle::Next
Vehicle * Next() const
Get the next vehicle of this vehicle.
Definition: vehicle_base.h:596
_cur_year
Year _cur_year
Current year, starting at 0.
Definition: date.cpp:26
HELIENDLANDING
@ HELIENDLANDING
Helicopter wants to finish landing.
Definition: airport.h:79
SpecializedVehicle::Next
T * Next() const
Get next vehicle in the chain.
Definition: vehicle_base.h:1081
DIRDIFF_SAME
@ DIRDIFF_SAME
Both directions faces to the same direction.
Definition: direction_type.h:63
Vehicle::y_extent
byte y_extent
y-extent of vehicle bounding box
Definition: vehicle_base.h:293
Station
Station data structure.
Definition: station_base.h:447
Order::GetDestination
DestinationID GetDestination() const
Gets the destination of this order.
Definition: order_base.h:97
Vehicle::NeedsAutomaticServicing
bool NeedsAutomaticServicing() const
Checks if the current order should be interrupted for a service-in-depot order.
Definition: vehicle.cpp:252
Vehicle::z_pos
int32 z_pos
z coordinate.
Definition: vehicle_base.h:282
VehicleSpriteSeq::Set
void Set(SpriteID sprite)
Assign a single sprite to the sequence.
Definition: vehicle_base.h:162
PLANE_HOLD_MAX_FLYING_ALTITUDE
@ PLANE_HOLD_MAX_FLYING_ALTITUDE
holding flying altitude above tile of planes.
Definition: aircraft.h:23
VSE_TOUCHDOWN
@ VSE_TOUCHDOWN
Whenever a plane touches down.
Definition: newgrf_sound.h:23
HandleAircraftSmoke
static void HandleAircraftSmoke(Aircraft *v, bool mode)
Handle smoke of broken aircraft.
Definition: aircraft_cmd.cpp:1221
Vehicle::random_bits
byte random_bits
Bits used for determining which randomized variational spritegroups to use when drawing.
Definition: vehicle_base.h:310
Vehicle::vehstatus
byte vehstatus
Status.
Definition: vehicle_base.h:328
BaseConsist::name
std::string name
Name of vehicle.
Definition: base_consist.h:19
TERM5_block
static const uint64 TERM5_block
Block belonging to terminal 5.
Definition: airport.h:93
AircraftVehicleInfo::passenger_capacity
uint16 passenger_capacity
Passenger capacity (persons).
Definition: engine_type.h:107
MovementTerminalMapping::airport_flag
uint64 airport_flag
Bitmask in the airport flags that need to be free for this terminal.
Definition: aircraft_cmd.cpp:1908
VS_DEFPAL
@ VS_DEFPAL
Use default vehicle palette.
Definition: vehicle_base.h:34
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:235
Vehicle::SetNext
void SetNext(Vehicle *next)
Set the next vehicle of this vehicle.
Definition: vehicle.cpp:2740
CMD_SEND_VEHICLE_TO_DEPOT
@ CMD_SEND_VEHICLE_TO_DEPOT
send a vehicle to a depot
Definition: command_type.h:217
Vehicle::Crash
virtual uint Crash(bool flooded=false)
Crash the (whole) vehicle chain.
Definition: vehicle.cpp:260
AirportFTAClass::SHORT_STRIP
@ SHORT_STRIP
This airport has a short landing strip, dangerous for fast aircraft.
Definition: airport.h:150
Vehicle::acceleration
byte acceleration
used by train & aircraft
Definition: vehicle_base.h:306
AMED_TAKEOFF
@ AMED_TAKEOFF
Takeoff movement.
Definition: airport.h:49
PROP_AIRCRAFT_RUNNING_COST_FACTOR
@ PROP_AIRCRAFT_RUNNING_COST_FACTOR
Yearly runningcost.
Definition: newgrf_properties.h:51
Order::Free
void Free()
'Free' the order
Definition: order_cmd.cpp:62
DeleteVehicleNews
void DeleteVehicleNews(VehicleID vid, StringID news)
Delete a news item type about a vehicle.
Definition: news_gui.cpp:905
HasBit
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103
TERM1
@ TERM1
Heading for terminal 1.
Definition: airport.h:63
UnScaleGUI
static int UnScaleGUI(int value)
Short-hand to apply GUI zoom level.
Definition: zoom_func.h:66
AircraftStateHandler
void AircraftStateHandler(Aircraft *v, const AirportFTAClass *apc)
Signature of the aircraft handler function.
Definition: aircraft_cmd.cpp:1736
SND_12_EXPLOSION
@ SND_12_EXPLOSION
16 == 0x10 Destruction, crashes, disasters, ...
Definition: sound_type.h:55
ClrBit
static T ClrBit(T &x, const uint8 y)
Clears a bit in a variable.
Definition: bitmath_func.hpp:151
VAF_IN_MAX_HEIGHT_CORRECTION
@ VAF_IN_MAX_HEIGHT_CORRECTION
The vehicle is currently lowering its altitude because it hit the upper bound.
Definition: aircraft.h:44
AirportFTAClass::num_helipads
const byte num_helipads
Number of helipads on this airport. When 0 helicopters will go to normal terminals.
Definition: airport.h:179
EXPENSES_AIRCRAFT_RUN
@ EXPENSES_AIRCRAFT_RUN
Running costs aircraft.
Definition: economy_type.h:162
Aircraft::number_consecutive_turns
byte number_consecutive_turns
Protection to prevent the aircraft of making a lot of turns in order to reach a specific point.
Definition: aircraft.h:81
ENDLANDING
@ ENDLANDING
Airplane wants to finish landing.
Definition: airport.h:77
zoom_func.h
HandleAircraftEnterHangar
void HandleAircraftEnterHangar(Aircraft *v)
Handle Aircraft specific tasks when an Aircraft enters a hangar.
Definition: aircraft_cmd.cpp:561
aircraft.h
TILE_SIZE
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:13
AddVehicleNewsItem
static void AddVehicleNewsItem(StringID string, NewsType type, VehicleID vehicle, StationID station=INVALID_STATION)
Adds a newsitem referencing a vehicle.
Definition: news_func.h:30
Vehicle::running_ticks
byte running_ticks
Number of ticks this vehicle was not stopped this day.
Definition: vehicle_base.h:326
SpecializedStation< Station, false >::Get
static Station * Get(size_t index)
Gets station with given index.
Definition: base_station_base.h:219
DEPOT_LOCATE_HANGAR
@ DEPOT_LOCATE_HANGAR
Find another airport if the target one lacks a hangar.
Definition: vehicle_type.h:69
DirDifference
static DirDiff DirDifference(Direction d0, Direction d1)
Calculate the difference between two directions.
Definition: direction_func.h:68
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:52
VehicleEnterDepot
void VehicleEnterDepot(Vehicle *v)
Vehicle entirely entered the depot, update its status, orders, vehicle windows, service it,...
Definition: vehicle.cpp:1487
TileY
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:215
GetAircraftSpriteSize
void GetAircraftSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
Get the size of the sprite of an aircraft sprite heading west (used for lists).
Definition: aircraft_cmd.cpp:245
Engine::GetLifeLengthInDays
Date GetLifeLengthInDays() const
Returns the vehicle's (not model's!) life length in days.
Definition: engine.cpp:431
DIAGDIR_NW
@ DIAGDIR_NW
Northwest.
Definition: direction_type.h:82
DIR_W
@ DIR_W
West.
Definition: direction_type.h:32
EV_EXPLOSION_SMALL
@ EV_EXPLOSION_SMALL
Various explosions.
Definition: effectvehicle_func.h:24
EngineImageType
EngineImageType
Visualisation contexts of vehicles and engines.
Definition: vehicle_type.h:85
GetTargetAirportIfValid
Station * GetTargetAirportIfValid(const Aircraft *v)
Returns aircraft's target station if v->target_airport is a valid station with airport.
Definition: aircraft_cmd.cpp:2125
Engine
Definition: engine_base.h:27
Vehicle::cur_speed
uint16 cur_speed
current speed
Definition: vehicle_base.h:304
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:221
Engine::GetDefaultCargoType
CargoID GetDefaultCargoType() const
Determines the default cargo type of an engine.
Definition: engine_base.h:83
VehicleSpriteSeq::Draw
void Draw(int x, int y, PaletteID default_pal, bool force_pal) const
Draw the sprite sequence.
Definition: vehicle.cpp:126
Vehicle::owner
Owner owner
Which company owns the vehicle?
Definition: vehicle_base.h:285
VehicleCache::cached_cargo_age_period
uint16 cached_cargo_age_period
Number of ticks before carried cargo is aged.
Definition: vehicle_base.h:123
EV_EXPLOSION_LARGE
@ EV_EXPLOSION_LARGE
Various explosions.
Definition: effectvehicle_func.h:22
DC_EXEC
@ DC_EXEC
execute the given command
Definition: command_type.h:348
BaseStation::owner
Owner owner
The owner of this station.
Definition: base_station_base.h:62
DIR_N
@ DIR_N
North.
Definition: direction_type.h:26
AIR_AIRCRAFT
@ AIR_AIRCRAFT
an airplane
Definition: aircraft.h:32
HELIPAD2_block
static const uint64 HELIPAD2_block
Block belonging to helipad 2.
Definition: airport.h:96
Aircraft::FindClosestDepot
bool FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse)
Find the closest depot for this vehicle and tell us the location, DestinationID and whether we should...
Definition: aircraft_cmd.cpp:392
SetDParam
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings_func.h:196
VS_AIRCRAFT_BROKEN
@ VS_AIRCRAFT_BROKEN
Aircraft is broken down.
Definition: vehicle_base.h:37
HANGAR
@ HANGAR
Heading for hangar.
Definition: airport.h:62
DoCommandFlag
DoCommandFlag
List of flags for a command.
Definition: command_type.h:346
VehicleServiceInDepot
void VehicleServiceInDepot(Vehicle *v)
Service a vehicle and all subsequent vehicles in the consist.
Definition: vehicle.cpp:162
SPEED_LIMIT_APPROACH
@ SPEED_LIMIT_APPROACH
Maximum speed of an aircraft on finals.
Definition: aircraft_cmd.cpp:623
Vehicle::breakdowns_since_last_service
byte breakdowns_since_last_service
Counter for the amount of breakdowns.
Definition: vehicle_base.h:277
AIR_SHADOW
@ AIR_SHADOW
shadow of the aircraft
Definition: aircraft.h:33
SETBITS
#define SETBITS(x, y)
Sets several bits in a variable.
Definition: bitmath_func.hpp:136
GetAirport
const AirportFTAClass * GetAirport(const byte airport_type)
Get the finite state machine of an airport type.
Definition: airport.cpp:207
TERM7
@ TERM7
Heading for terminal 7.
Definition: airport.h:80
TileX
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:205
AirportMovingData::direction
Direction direction
Direction to turn the aircraft after reaching the destination.
Definition: airport.h:135
TERM3
@ TERM3
Heading for terminal 3.
Definition: airport.h:65
effectvehicle_func.h
SpecializedStation< Station, false >::Iterate
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
Returns an iterable ensemble of all valid stations of type T.
Definition: base_station_base.h:270
AMED_EXACTPOS
@ AMED_EXACTPOS
Go exactly to the destination coordinates.
Definition: airport.h:52
Airport::GetFTA
const AirportFTAClass * GetFTA() const
Get the finite-state machine for this airport or the finite-state machine for the dummy airport in ca...
Definition: station_base.h:329
AircraftEventHandler_InHangar
static void AircraftEventHandler_InHangar(Aircraft *v, const AirportFTAClass *apc)
Handle aircraft movement/decision making in an airport hangar.
Definition: aircraft_cmd.cpp:1501
ai.hpp
Order::MakeGoToDepot
void MakeGoToDepot(DepotID destination, OrderDepotTypeFlags order, OrderNonStopFlags non_stop_type=ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS, OrderDepotActionFlags action=ODATF_SERVICE_ONLY, CargoID cargo=CT_NO_REFIT)
Makes this order a Go To Depot order.
Definition: order_cmd.cpp:89
Order::GetType
OrderType GetType() const
Get the type of order of this order.
Definition: order_base.h:70
Aircraft
Aircraft, helicopters, rotors and their shadows belong to this class.
Definition: aircraft.h:74
SpriteID
uint32 SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:17
Engine::GetGRF
const GRFFile * GetGRF() const
Retrieve the NewGRF the engine is tied to.
Definition: engine_base.h:142
GoodsEntry::cargo
StationCargoList cargo
The cargo packets of cargo waiting in this station.
Definition: station_base.h:252
SetWindowWidgetDirty
void SetWindowWidgetDirty(WindowClass cls, WindowNumber number, byte widget_index)
Mark a particular widget in a particular window as dirty (in need of repainting)
Definition: window.cpp:3149
ENGINE_EXCLUSIVE_PREVIEW
@ ENGINE_EXCLUSIVE_PREVIEW
This vehicle is in the exclusive preview stage, either being used or being offered to a company.
Definition: engine_type.h:170
newgrf_airporttiles.h
GameSettings::order
OrderSettings order
settings related to orders
Definition: settings_type.h:584
VehicleSettings::plane_crashes
uint8 plane_crashes
number of plane crashes, 0 = none, 1 = reduced, 2 = normal
Definition: settings_type.h:495
Airport::HasHangar
bool HasHangar() const
Check if this airport has at least one hangar.
Definition: station_base.h:335
Vehicle::BeginLoading
void BeginLoading()
Prepare everything to begin the loading when arriving at a station.
Definition: vehicle.cpp:2113
DIAGDIR_SW
@ DIAGDIR_SW
Southwest.
Definition: direction_type.h:81
DiagDirDifference
static DiagDirDiff DiagDirDifference(DiagDirection d0, DiagDirection d1)
Calculate the difference between two DiagDirection values.
Definition: direction_func.h:131
Airport::rotation
Direction rotation
How this airport is rotated.
Definition: station_base.h:308
Vehicle::breakdown_ctr
byte breakdown_ctr
Counter for managing breakdown events.
Definition: vehicle_base.h:275
VS_HIDDEN
@ VS_HIDDEN
Vehicle is not visible.
Definition: vehicle_base.h:31
EngineID
uint16 EngineID
Unique identification number of an engine.
Definition: engine_type.h:21
SND_17_SKID_PLANE
@ SND_17_SKID_PLANE
21 == 0x15 Plane landing / touching ground
Definition: sound_type.h:60
AAT_STATION_AIRPLANE_LAND
@ AAT_STATION_AIRPLANE_LAND
Triggered when an airplane (not a helicopter) touches down at the airport (for single tile).
Definition: newgrf_animation_type.h:52
VehicleSpriteSeq::IsValid
bool IsValid() const
Check whether the sequence contains any sprites.
Definition: vehicle_base.h:146
DirToDiagDir
static DiagDirection DirToDiagDir(Direction dir)
Convert a Direction to a DiagDirection.
Definition: direction_func.h:166
AirportSetBlocks
static bool AirportSetBlocks(Aircraft *v, const AirportFTA *current_pos, const AirportFTAClass *apc)
"reserve" a block for the plane
Definition: aircraft_cmd.cpp:1864
AIRCRAFT_MAX_FLYING_ALTITUDE
@ AIRCRAFT_MAX_FLYING_ALTITUDE
Maximum flying altitude above tile.
Definition: aircraft.h:22
AI::NewEvent
static void NewEvent(CompanyID company, ScriptEvent *event)
Queue a new event for an AI.
Definition: ai_core.cpp:234
Aircraft::GetRunningCost
Money GetRunningCost() const
Gets the running cost of a vehicle.
Definition: aircraft_cmd.cpp:437
CommandCost
Common return value for all commands.
Definition: command_type.h:23
VAF_HELI_DIRECT_DESCENT
@ VAF_HELI_DIRECT_DESCENT
The helicopter is descending directly at its destination (helipad or in front of hangar)
Definition: aircraft.h:47
_date
Date _date
Current date in days (day counter)
Definition: date.cpp:28
PROP_AIRCRAFT_CARGO_AGE_PERIOD
@ PROP_AIRCRAFT_CARGO_AGE_PERIOD
Number of ticks before carried cargo is aged.
Definition: newgrf_properties.h:54
VehicleCargoList::Truncate
uint Truncate(uint max_move=UINT_MAX)
Truncates the cargo in this list to the given amount.
Definition: cargopacket.cpp:654
AMED_SLOWTURN
@ AMED_SLOWTURN
Turn slowly (mostly used in the air).
Definition: airport.h:50
WC_VEHICLE_VIEW
@ WC_VEHICLE_VIEW
Vehicle view; Window numbers:
Definition: window_type.h:331
TileHeight
static uint TileHeight(TileIndex tile)
Returns the height of a tile.
Definition: tile_map.h:29
ClientSettings::sound
SoundSettings sound
sound effect settings
Definition: settings_type.h:597
AirportMovingData::flag
uint16 flag
special flags when moving towards the destination.
Definition: airport.h:134
newgrf_engine.h
ChangeDiagDir
static DiagDirection ChangeDiagDir(DiagDirection d, DiagDirDiff delta)
Applies a difference on a DiagDirection.
Definition: direction_func.h:149
DIR_E
@ DIR_E
East.
Definition: direction_type.h:28
Aircraft::turn_counter
byte turn_counter
Ticks between each turn to prevent > 45 degree turns.
Definition: aircraft.h:82
AirportFTAClass::nofelements
byte nofelements
number of positions the airport consists of
Definition: airport.h:181
EV_BREAKDOWN_SMOKE_AIRCRAFT
@ EV_BREAKDOWN_SMOKE_AIRCRAFT
Smoke of broken aircraft.
Definition: effectvehicle_func.h:27
SubtractMoneyFromCompanyFract
void SubtractMoneyFromCompanyFract(CompanyID company, const CommandCost &cst)
Subtract money from a company, including the money fraction.
Definition: company_cmd.cpp:254
Vehicle::tile
TileIndex tile
Current tile index.
Definition: vehicle_base.h:242
AircraftGetEntryPoint
static byte AircraftGetEntryPoint(const Aircraft *v, const AirportFTAClass *apc, Direction rotation)
Find the entry point to an airport depending on direction which the airport is being approached from.
Definition: aircraft_cmd.cpp:816
EIT_ON_MAP
@ EIT_ON_MAP
Vehicle drawn in viewport.
Definition: vehicle_type.h:86
Vehicle::engine_type
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:299
VS_CRASHED
@ VS_CRASHED
Vehicle is crashed.
Definition: vehicle_base.h:38
_cheats
Cheats _cheats
All the cheats.
Definition: cheat.cpp:16
VehicleSpriteSeq
Sprite sequence for a vehicle part.
Definition: vehicle_base.h:129
CmdBuildAircraft
CommandCost CmdBuildAircraft(TileIndex tile, DoCommandFlag flags, const Engine *e, uint16 data, Vehicle **ret)
Build an aircraft.
Definition: aircraft_cmd.cpp:268
Vehicle::last_station_visited
StationID last_station_visited
The last station we stopped at.
Definition: vehicle_base.h:313
OrthogonalTileArea::w
uint16 w
The width of the area.
Definition: tilearea_type.h:20
AMED_HOLD
@ AMED_HOLD
Holding pattern movement (above the airport).
Definition: airport.h:56
Vehicle::cargo
VehicleCargoList cargo
The cargo this vehicle is carrying.
Definition: vehicle_base.h:320
Vehicle::GetOldAdvanceSpeed
uint GetOldAdvanceSpeed(uint speed)
Determines the effective direction-specific vehicle movement speed.
Definition: vehicle_base.h:398
CommandCost::Failed
bool Failed() const
Did this command fail?
Definition: command_type.h:159
SPEED_LIMIT_TAXI
@ SPEED_LIMIT_TAXI
Maximum speed of an aircraft while taxiing.
Definition: aircraft_cmd.cpp:622
Vehicle::current_order
Order current_order
The current order (+ status, like: loading)
Definition: vehicle_base.h:329
Airport::GetHangarTile
TileIndex GetHangarTile(uint hangar_num) const
Get the first tile of the given hangar.
Definition: station_base.h:370
AirportFindFreeHelipad
static bool AirportFindFreeHelipad(Aircraft *v, const AirportFTAClass *apc)
Find a free helipad, and assign it if available.
Definition: aircraft_cmd.cpp:2021
Vehicle::max_age
Date max_age
Maximum age.
Definition: vehicle_base.h:271
Station::airport
Airport airport
Tile area the airport covers.
Definition: station_base.h:461
HelicopterRotorStates
HelicopterRotorStates
Helicopter rotor animation states.
Definition: aircraft_cmd.cpp:106
AirportFTAClass::layout
struct AirportFTA * layout
state machine for airport
Definition: airport.h:177
DIR_NE
@ DIR_NE
Northeast.
Definition: direction_type.h:27
AirportFTAClass::flags
Flags flags
Flags for this airport type.
Definition: airport.h:180
ODATFB_NEAREST_DEPOT
@ ODATFB_NEAREST_DEPOT
Send the vehicle to the nearest depot.
Definition: order_type.h:105
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:53
WC_VEHICLE_DETAILS
@ WC_VEHICLE_DETAILS
Vehicle details; Window numbers:
Definition: window_type.h:192
AirportFTA
Internal structure used in openttd - Finite sTate mAchine --> FTA.
Definition: airport.h:190
Game::NewEvent
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition: game_core.cpp:141
VS_STOPPED
@ VS_STOPPED
Vehicle is stopped by the player.
Definition: vehicle_base.h:32
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:46
Vehicle::GetEngine
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
Definition: vehicle.cpp:741
safeguards.h
GetNewVehiclePosResult::new_tile
TileIndex new_tile
Tile of the vehicle after moving.
Definition: vehicle_func.h:78
Vehicle::reliability_spd_dec
uint16 reliability_spd_dec
Reliability decrease speed.
Definition: vehicle_base.h:274
Vehicle::last_loading_station
StationID last_loading_station
Last station the vehicle has stopped at and could possibly leave from with any cargo loaded.
Definition: vehicle_base.h:314
Airport::flags
uint64 flags
stores which blocks on the airport are taken. was 16 bit earlier on, then 32
Definition: station_base.h:305
CommandCost::GetCost
Money GetCost() const
The costs as made up to this moment.
Definition: command_type.h:82
Aircraft::Crash
uint Crash(bool flooded=false)
Crash the (whole) vehicle chain.
Definition: aircraft_cmd.cpp:1308
Vehicle::profit_this_year
Money profit_this_year
Profit this year << 8, low 8 bits are fract.
Definition: vehicle_base.h:251
AircraftSpeedLimits
AircraftSpeedLimits
Special velocities for aircraft.
Definition: aircraft_cmd.cpp:621
ODTFB_PART_OF_ORDERS
@ ODTFB_PART_OF_ORDERS
This depot order is because of a regular order.
Definition: order_type.h:96
settings
fluid_settings_t * settings
FluidSynth settings handle.
Definition: fluidsynth.cpp:21
SPEED_LIMIT_HOLD
@ SPEED_LIMIT_HOLD
Maximum speed of an aircraft that flies the holding pattern.
Definition: aircraft_cmd.cpp:625
VAF_IN_MIN_HEIGHT_CORRECTION
@ VAF_IN_MIN_HEIGHT_CORRECTION
The vehicle is currently raising its altitude because it hit the lower bound.
Definition: aircraft.h:45
MovementTerminalMapping
Combination of aircraft state for going to a certain terminal and the airport flag for that terminal ...
Definition: aircraft_cmd.cpp:1906
OrderSettings::serviceathelipad
bool serviceathelipad
service helicopters at helipads automatically (no need to send to depot)
Definition: settings_type.h:472
GoodsEntry::rating
byte rating
Station rating for this cargo.
Definition: station_base.h:232
AirportFTAClass
Finite sTate mAchine (FTA) of an airport.
Definition: airport.h:143
SoundSettings::disaster
bool disaster
Play disaster and accident sounds.
Definition: settings_type.h:212
GetVehiclePosOnBuild
byte GetVehiclePosOnBuild(TileIndex hangar_tile)
Get the vehicle position when an aircraft is build at the given tile.
Definition: airport.cpp:218
HVOT_AIRCRAFT
@ HVOT_AIRCRAFT
Station has seen an aircraft.
Definition: station_type.h:67
MaybeCrashAirplane
static void MaybeCrashAirplane(Aircraft *v)
Decide whether aircraft v should crash.
Definition: aircraft_cmd.cpp:1354
GetNumTerminals
static uint GetNumTerminals(const AirportFTAClass *apc)
Get the number of terminals at the airport.
Definition: aircraft_cmd.cpp:1953
DirDiff
DirDiff
Enumeration for the difference between two directions.
Definition: direction_type.h:62
DiagDirection
DiagDirection
Enumeration for diagonal directions.
Definition: direction_type.h:77
Vehicle::HandleLoading
void HandleLoading(bool mode=false)
Handle the loading of the vehicle; when not it skips through dummy orders and does nothing in all oth...
Definition: vehicle.cpp:2323
PFE_GL_AIRCRAFT
@ PFE_GL_AIRCRAFT
Time spent processing aircraft.
Definition: framerate_type.h:54
CreateEffectVehicleRel
EffectVehicle * CreateEffectVehicleRel(const Vehicle *v, int x, int y, int z, EffectVehicleType type)
Create an effect vehicle above a particular vehicle.
Definition: effectvehicle.cpp:638
TERM7_block
static const uint64 TERM7_block
Block belonging to terminal 7.
Definition: airport.h:115
date_func.h
stdafx.h
TERM5
@ TERM5
Heading for terminal 5.
Definition: airport.h:67
BaseConsist::vehicle_flags
uint16 vehicle_flags
Used for gradual loading and other miscellaneous things (.
Definition: base_consist.h:31
WID_VV_START_STOP
@ WID_VV_START_STOP
Start or stop this vehicle, and show information about the current state.
Definition: vehicle_widget.h:17
Vehicle::sprite_cache
MutableSpriteCache sprite_cache
Cache of sprites and values related to recalculating them, see MutableSpriteCache.
Definition: vehicle_base.h:343
landscape.h
Cheat::value
bool value
tells if the bool cheat is active or not
Definition: cheat_type.h:18
HELIPAD3
@ HELIPAD3
Heading for helipad 3.
Definition: airport.h:82
AirportHasBlock
static bool AirportHasBlock(Aircraft *v, const AirportFTA *current_pos, const AirportFTAClass *apc)
returns true if the road ahead is busy, eg.
Definition: aircraft_cmd.cpp:1833
Vehicle::y_offs
int8 y_offs
y offset for vehicle sprite
Definition: vehicle_base.h:298
Vehicle::colourmap
SpriteID colourmap
NOSAVE: cached colour mapping.
Definition: vehicle_base.h:266
AircraftLeaveHangar
void AircraftLeaveHangar(Aircraft *v, Direction exit_dir)
Aircraft is about to leave the hangar.
Definition: aircraft_cmd.cpp:1451
TERM1_block
static const uint64 TERM1_block
Movement Blocks on Airports blocks (eg_airport_flags).
Definition: airport.h:89
DisasterVehicle
Disasters, like submarines, skyrangers and their shadows, belong to this class.
Definition: disaster_vehicle.h:37
Aircraft::GetImage
void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const
Gets the sprite to show for the given direction.
Definition: aircraft_cmd.cpp:170
VF_BUILT_AS_PROTOTYPE
@ VF_BUILT_AS_PROTOTYPE
Vehicle is a prototype (accepted as exclusive preview).
Definition: vehicle_base.h:45
Vehicle::direction
Direction direction
facing
Definition: vehicle_base.h:283
OrthogonalTileArea::h
uint16 h
The height of the area.
Definition: tilearea_type.h:21
MAX_TERMINALS
static const uint MAX_TERMINALS
Some airport-related constants.
Definition: airport.h:17
TERM2
@ TERM2
Heading for terminal 2.
Definition: airport.h:64
DistanceSquare
uint DistanceSquare(TileIndex t0, TileIndex t1)
Gets the 'Square' distance between the two given tiles.
Definition: map.cpp:174
AirportFTAClass::delta_z
byte delta_z
Z adjustment for helicopter pads.
Definition: airport.h:183
Aircraft::GetOrderStationLocation
TileIndex GetOrderStationLocation(StationID station)
Determine the location for the station where the vehicle goes to next.
Definition: aircraft_cmd.cpp:1287
PerformanceAccumulator
RAII class for measuring multi-step elements of performance.
Definition: framerate_type.h:114
AirportMovingData::x
int16 x
x-coordinate of the destination.
Definition: airport.h:132
ProcessOrders
bool ProcessOrders(Vehicle *v)
Handle the orders of a vehicle and determine the next place to go to if needed.
Definition: order_cmd.cpp:2132
VAF_DEST_TOO_FAR
@ VAF_DEST_TOO_FAR
Next destination is too far away.
Definition: aircraft.h:39
spritecache.h
AIRPORT_CLOSED_block
static const uint64 AIRPORT_CLOSED_block
Dummy block for indicating a closed airport.
Definition: airport.h:128
Vehicle::x_extent
byte x_extent
x-extent of vehicle bounding box
Definition: vehicle_base.h:292
HandleCrashedAircraft
static bool HandleCrashedAircraft(Aircraft *v)
Handle crashed aircraft v.
Definition: aircraft_cmd.cpp:1163
StringID
uint32 StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
Vehicle::vcache
VehicleCache vcache
Cache of often used vehicle values.
Definition: vehicle_base.h:341
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:47
vehicle_func.h
DEPOT_SERVICE
@ DEPOT_SERVICE
The vehicle will leave the depot right after arrival (service only)
Definition: vehicle_type.h:66
station_base.h
AircraftCache::cached_max_range_sqr
uint32 cached_max_range_sqr
Cached squared maximum range.
Definition: aircraft.h:67
newgrf_sound.h
Clamp
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition: math_func.hpp:77
AirportFTA::next
AirportFTA * next
possible extra movement choices from this position
Definition: airport.h:191
PALETTE_CRASH
static const PaletteID PALETTE_CRASH
Recolour sprite greying of crashed vehicles.
Definition: sprites.h:1600
strings_func.h
SmallStackItem::value
Titem value
Value of current item.
Definition: smallstack_type.hpp:97
AirportMovementStates
AirportMovementStates
Movement States on Airports (headings target)
Definition: airport.h:60
Vehicle::tick_counter
byte tick_counter
Increased by one for each tick.
Definition: vehicle_base.h:325
Vehicle::cargo_cap
uint16 cargo_cap
total capacity
Definition: vehicle_base.h:318
MapMaxY
static uint MapMaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
Definition: map_func.h:111
HELICOPTER_HOLD_MAX_FLYING_ALTITUDE
@ HELICOPTER_HOLD_MAX_FLYING_ALTITUDE
holding flying altitude above tile of helicopters.
Definition: aircraft.h:24
Vehicle::x_offs
int8 x_offs
x offset for vehicle sprite
Definition: vehicle_base.h:297
Vehicle::subspeed
byte subspeed
fractional speed
Definition: vehicle_base.h:305
SpecializedVehicle< Aircraft, VEH_AIRCRAFT >::From
static Aircraft * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Definition: vehicle_base.h:1166
DIRDIFF_45RIGHT
@ DIRDIFF_45RIGHT
Angle of 45 degrees right.
Definition: direction_type.h:64
Aircraft::crashed_counter
uint16 crashed_counter
Timer for handling crash animations.
Definition: aircraft.h:75
Vehicle::z_extent
byte z_extent
z-extent of vehicle bounding box
Definition: vehicle_base.h:294
VehicleRandomBits
byte VehicleRandomBits()
Get a value for a vehicle's random_bits.
Definition: vehicle.cpp:363
Vehicle::InvalidateNewGRFCacheOfChain
void InvalidateNewGRFCacheOfChain()
Invalidates cached NewGRF variables of all vehicles in the chain (after the current vehicle)
Definition: vehicle_base.h:473
ScaleGUITrad
static int ScaleGUITrad(int value)
Scale traditional pixel dimensions to GUI zoom level.
Definition: zoom_func.h:76
OrthogonalTileArea::tile
TileIndex tile
The base tile of the area.
Definition: tilearea_type.h:19
PaletteID
uint32 PaletteID
The number of the palette.
Definition: gfx_type.h:18
Aircraft::OnNewDay
void OnNewDay()
Calls the new day handler of the vehicle.
Definition: aircraft_cmd.cpp:444
AIR_HELICOPTER
@ AIR_HELICOPTER
an helicopter
Definition: aircraft.h:31
RemoveOrderFromAllVehicles
void RemoveOrderFromAllVehicles(OrderType type, DestinationID destination, bool hangar)
Removes an order from all vehicles.
Definition: order_cmd.cpp:1807
framerate_type.h
Aircraft::IsNormalAircraft
bool IsNormalAircraft() const
Check if the aircraft type is a normal flying device; eg not a rotor or a shadow.
Definition: aircraft.h:121
cheat_type.h
BaseConsist::current_order_time
uint32 current_order_time
How many ticks have passed since this order started.
Definition: base_consist.h:22
AircraftEntersTerminal
static void AircraftEntersTerminal(Aircraft *v)
Aircraft arrives at a terminal.
Definition: aircraft_cmd.cpp:1385
FreeTerminal
static bool FreeTerminal(Aircraft *v, byte i, byte last_terminal)
Find a free terminal or helipad, and if available, assign it.
Definition: aircraft_cmd.cpp:1933
OWNER_NONE
@ OWNER_NONE
The tile has no ownership.
Definition: company_type.h:25
UpdateAircraftCache
void UpdateAircraftCache(Aircraft *v, bool update_range)
Update cached values of an aircraft.
Definition: aircraft_cmd.cpp:591
GetNewVehiclePosResult
Position information of a vehicle after it moved.
Definition: vehicle_func.h:75
WC_VEHICLE_DEPOT
@ WC_VEHICLE_DEPOT
Depot view; Window numbers:
Definition: window_type.h:343
NUM_CARGO
@ NUM_CARGO
Maximal number of cargo types in a game.
Definition: cargo_type.h:65
GetStationIndex
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
Definition: station_map.h:28
SpecializedStation< Station, false >::GetByTile
static Station * GetByTile(TileIndex tile)
Get the station belonging to a specific tile.
Definition: base_station_base.h:238
Vehicle::build_year
Year build_year
Year the vehicle has been built.
Definition: vehicle_base.h:269
Aircraft::previous_pos
byte previous_pos
Previous desired position of the aircraft.
Definition: aircraft.h:77
AircraftEventHandler_AtTerminal
static void AircraftEventHandler_AtTerminal(Aircraft *v, const AirportFTAClass *apc)
At one of the Airport's Terminals.
Definition: aircraft_cmd.cpp:1547
HELIPAD1
@ HELIPAD1
Heading for helipad 1.
Definition: airport.h:69
UpdateAirplanesOnNewStation
void UpdateAirplanesOnNewStation(const Station *st)
Updates the status of the Aircraft heading or in the station.
Definition: aircraft_cmd.cpp:2139
NT_ACCIDENT
@ NT_ACCIDENT
An accident or disaster has occurred.
Definition: news_type.h:24
AirportMovingData::y
int16 y
y-coordinate of the destination.
Definition: airport.h:133
HELITAKEOFF
@ HELITAKEOFF
Helicopter wants to leave the airport.
Definition: airport.h:74
DAYS_IN_YEAR
static const int DAYS_IN_YEAR
days per year
Definition: date_type.h:29
AircraftNextAirportPos_and_Order
void AircraftNextAirportPos_and_Order(Aircraft *v)
set the right pos when heading to other airports after takeoff
Definition: aircraft_cmd.cpp:1431
SPEED_LIMIT_NONE
@ SPEED_LIMIT_NONE
No environmental speed limit. Speed limit is type dependent.
Definition: aircraft_cmd.cpp:626
BaseStation::xy
TileIndex xy
Base tile of the station.
Definition: base_station_base.h:53
GetTileMaxPixelZ
static int GetTileMaxPixelZ(TileIndex tile)
Get top height of the tile.
Definition: tile_map.h:304
VehicleCache::cached_max_speed
uint16 cached_max_speed
Maximum speed of the consist (minimum of the max speed of all vehicles in the consist).
Definition: vehicle_base.h:122
FindNearestHangar
static StationID FindNearestHangar(const Aircraft *v)
Find the nearest hangar to v INVALID_STATION is returned, if the company does not have any suitable a...
Definition: aircraft_cmd.cpp:120
company_func.h
ORIGINAL_SAMPLE_COUNT
static const uint ORIGINAL_SAMPLE_COUNT
The number of sounds in the original sample.cat.
Definition: sound_type.h:116
AircraftVehicleInfo::mail_capacity
byte mail_capacity
Mail capacity (bags).
Definition: engine_type.h:106
SpecializedVehicle< Aircraft, VEH_AIRCRAFT >::Iterate
static Pool::IterateWrapper< Aircraft > Iterate(size_t from=0)
Returns an iterable ensemble of all valid vehicles of type T.
Definition: vehicle_base.h:1235
MapMaxX
static uint MapMaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Definition: map_func.h:102
NT_ARRIVAL_COMPANY
@ NT_ARRIVAL_COMPANY
First vehicle arrived for company.
Definition: news_type.h:22
Engine::original_image_index
uint8 original_image_index
Original vehicle image index, thus the image index of the overridden vehicle.
Definition: engine_base.h:45
GetNewVehiclePosResult::old_tile
TileIndex old_tile
Current tile of the vehicle.
Definition: vehicle_func.h:77
abs
static T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition: math_func.hpp:21
AirportFTA::block
uint64 block
64 bit blocks (st->airport.flags), should be enough for the most complex airports
Definition: airport.h:192
error
void CDECL error(const char *s,...)
Error handling for fatal non-user errors.
Definition: openttd.cpp:132
Order::GetDepotOrderType
OrderDepotTypeFlags GetDepotOrderType() const
What caused us going to the depot?
Definition: order_base.h:138
Aircraft::pos
byte pos
Next desired position of the aircraft.
Definition: aircraft.h:76
AddVehicleAdviceNewsItem
static void AddVehicleAdviceNewsItem(StringID string, VehicleID vehicle)
Adds a vehicle-advice news item.
Definition: news_func.h:40
AIR_CTOL
@ AIR_CTOL
Conventional Take Off and Landing, i.e. planes.
Definition: engine_type.h:93
Vehicle::subtype
byte subtype
subtype (Filled with values from AircraftSubType/DisasterSubType/EffectVehicleType/GroundVehicleSubty...
Definition: vehicle_base.h:338
Vehicle::day_counter
byte day_counter
Increased by one for each day.
Definition: vehicle_base.h:324
VS_UNCLICKABLE
@ VS_UNCLICKABLE
Vehicle is not clickable by the user (shadow vehicles).
Definition: vehicle_base.h:33
TERMGROUP
@ TERMGROUP
Aircraft is looking for a free terminal in a terminalgroup.
Definition: airport.h:84
window_func.h
Debug
#define Debug(name, level, format_string,...)
Ouptut a line of debugging information.
Definition: debug.h:37
SetBit
static T SetBit(T &x, const uint8 y)
Set a bit in a variable.
Definition: bitmath_func.hpp:121
TO_ALL
@ TO_ALL
Go in this direction for every target.
Definition: airport.h:61
AircraftController
static bool AircraftController(Aircraft *v)
Controls the movement of an aircraft.
Definition: aircraft_cmd.cpp:857
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:378
random_func.hpp
AgeVehicle
void AgeVehicle(Vehicle *v)
Update age of a vehicle.
Definition: vehicle.cpp:1378
SpecializedStation< Station, false >::GetIfValid
static Station * GetIfValid(size_t index)
Returns station if the index is a valid index for this station type.
Definition: base_station_base.h:228
Vehicle::progress
byte progress
The percentage (if divided by 256) this vehicle already crossed the tile unit.
Definition: vehicle_base.h:308
AirportFTAClass::terminals
const byte * terminals
Array with the number of terminal groups, followed by the number of terminals in each group.
Definition: airport.h:178
STARTTAKEOFF
@ STARTTAKEOFF
Airplane has arrived at a runway for take-off.
Definition: airport.h:72
TILE_HEIGHT
static const uint TILE_HEIGHT
Height of a height level in world coordinate AND in pixels in #ZOOM_LVL_BASE.
Definition: tile_type.h:16
Engine::DetermineCapacity
uint DetermineCapacity(const Vehicle *v, uint16 *mail_capacity=nullptr) const
Determines capacity of a given vehicle from scratch.
Definition: engine.cpp:191
OverflowSafeInt< int64 >
TERM8_block
static const uint64 TERM8_block
Block belonging to terminal 8.
Definition: airport.h:116
Airport::type
byte type
Type of this airport,.
Definition: station_base.h:306
CargoID
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:20
INVALID_TILE
static const TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:88
Chance16R
static bool Chance16R(const uint a, const uint b, uint32 &r)
Flips a coin with a given probability and saves the randomize-number in a variable.
Definition: random_func.hpp:155
engine_base.h
Vehicle::cargo_type
CargoID cargo_type
type of cargo this vehicle is carrying
Definition: vehicle_base.h:316
VehicleSettings::plane_speed
uint8 plane_speed
divisor for speed of aircraft
Definition: settings_type.h:489
Vehicle::spritenum
byte spritenum
currently displayed sprite index 0xfd == custom sprite, 0xfe == custom second head sprite 0xff == res...
Definition: vehicle_base.h:291
AMED_HELI_RAISE
@ AMED_HELI_RAISE
Helicopter take-off.
Definition: airport.h:54
AircraftCache::cached_max_range
uint16 cached_max_range
Cached maximum range.
Definition: aircraft.h:68
LANDING
@ LANDING
Airplane wants to land.
Definition: airport.h:76
CeilDiv
static uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
Definition: math_func.hpp:254
Aircraft::state
byte state
State of the airport.
Definition: aircraft.h:79
TERM4_block
static const uint64 TERM4_block
Block belonging to terminal 4.
Definition: airport.h:92
AirportFTA::position
byte position
the position that an airplane is at
Definition: airport.h:193
TERM6
@ TERM6
Heading for terminal 6.
Definition: airport.h:68
GameSettings::vehicle
VehicleSettings vehicle
options for vehicles
Definition: settings_type.h:585
BaseVehicle::type
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:52
AirportFTAClass::entry_points
const byte * entry_points
when an airplane arrives at this airport, enter it at position entry_point, index depends on directio...
Definition: airport.h:182
Vehicle::UpdatePositionAndViewport
void UpdatePositionAndViewport()
Update the position of the vehicle, and update the viewport.
Definition: vehicle.cpp:1681
FACIL_AIRPORT
@ FACIL_AIRPORT
Station with an airport.
Definition: station_type.h:55
Vehicle::reliability
uint16 reliability
Reliability.
Definition: vehicle_base.h:273
PROP_AIRCRAFT_SPEED
@ PROP_AIRCRAFT_SPEED
Max. speed: 1 unit = 8 mph = 12.8 km-ish/h.
Definition: newgrf_properties.h:50
MovementTerminalMapping::state
AirportMovementStates state
Aircraft movement state when going to this terminal.
Definition: aircraft_cmd.cpp:1907
TERM8
@ TERM8
Heading for terminal 8.
Definition: airport.h:81
Vehicle::UpdatePosition
void UpdatePosition()
Update the position of the vehicle.
Definition: vehicle.cpp:1610
GetAircraftFlightLevelBounds
void GetAircraftFlightLevelBounds(const Vehicle *v, int *min_level, int *max_level)
Get the 'flight level' bounds, in pixels from 'z_pos' 0 for a particular vehicle for normal flight si...
Definition: aircraft_cmd.cpp:718
Engine::flags
byte flags
Flags of the engine.
Definition: engine_base.h:39
AirportFindFreeTerminal
static bool AirportFindFreeTerminal(Aircraft *v, const AirportFTAClass *apc)
Find a free terminal, and assign it if available.
Definition: aircraft_cmd.cpp:1968
CanVehicleUseStation
bool CanVehicleUseStation(EngineID engine_type, const Station *st)
Can this station be used by the given engine type?
Definition: vehicle.cpp:2860
AircraftLandAirplane
static void AircraftLandAirplane(Aircraft *v)
Aircraft touched down at the landing strip.
Definition: aircraft_cmd.cpp:1414
Vehicle::HandleBreakdown
bool HandleBreakdown()
Handle all of the aspects of a vehicle breakdown This includes adding smoke and sounds,...
Definition: vehicle.cpp:1312
AircraftVehicleInfo
Information about a aircraft vehicle.
Definition: engine_type.h:98
DecreaseVehicleValue
void DecreaseVehicleValue(Vehicle *v)
Decrease the value of a vehicle.
Definition: vehicle.cpp:1250
GetNewVehiclePosResult::y
int y
x and y position of the vehicle after moving
Definition: vehicle_func.h:76
disaster_vehicle.h
Aircraft::Tick
bool Tick()
Calls the tick handler of the vehicle.
Definition: aircraft_cmd.cpp:2096
DIAGDIR_NE
@ DIAGDIR_NE
Northeast, upper right on your monitor.
Definition: direction_type.h:79
TAKEOFF
@ TAKEOFF
Airplane wants to leave the airport.
Definition: airport.h:71
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition: geometry_type.hpp:47
AirportFTAClass::AIRPLANES
@ AIRPLANES
Can planes land on this airport type?
Definition: airport.h:147
SPEED_LIMIT_BROKEN
@ SPEED_LIMIT_BROKEN
Maximum speed of an aircraft that is broken.
Definition: aircraft_cmd.cpp:624
SetWindowClassesDirty
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition: window.cpp:3162
VehicleSpriteSeq::GetBounds
void GetBounds(Rect *bounds) const
Determine shared bounds of all sprites.
Definition: vehicle.cpp:98
Order::GetDepotActionType
OrderDepotActionFlags GetDepotActionType() const
What are we going to do when in the depot.
Definition: order_base.h:140
WC_AIRCRAFT_LIST
@ WC_AIRCRAFT_LIST
Aircraft list; Window numbers:
Definition: window_type.h:318
Aircraft::UpdateDeltaXY
void UpdateDeltaXY()
Updates the x and y offsets and the size of the sprite used for this vehicle.
Definition: aircraft_cmd.cpp:45
CLRBITS
#define CLRBITS(x, y)
Clears several bits in a variable.
Definition: bitmath_func.hpp:166
PROP_AIRCRAFT_RANGE
@ PROP_AIRCRAFT_RANGE
Aircraft range.
Definition: newgrf_properties.h:55
AirportFTAClass::MovingData
const AirportMovingData * MovingData(byte position) const
Get movement data at a position.
Definition: airport.h:170
HELIPAD2
@ HELIPAD2
Heading for helipad 2.
Definition: airport.h:70
HELIPAD1_block
static const uint64 HELIPAD1_block
Block belonging to helipad 1.
Definition: airport.h:95
SpecializedVehicle::UpdateViewport
void UpdateViewport(bool force_update, bool update_delta)
Update vehicle sprite- and position caches.
Definition: vehicle_base.h:1188
Aircraft::MarkDirty
void MarkDirty()
Marks the vehicles to be redrawn and updates cached variables.
Definition: aircraft_cmd.cpp:1298
Order
Definition: order_base.h:33
TERM3_block
static const uint64 TERM3_block
Block belonging to terminal 3.
Definition: airport.h:91
VS_SHADOW
@ VS_SHADOW
Vehicle is a shadow vehicle.
Definition: vehicle_base.h:36
AirportFTA::next_position
byte next_position
next position from this position
Definition: airport.h:194
Aircraft::flags
byte flags
Aircraft flags.
Definition: aircraft.h:83
TERM2_block
static const uint64 TERM2_block
Block belonging to terminal 2.
Definition: airport.h:90
StationCargoList::Truncate
uint Truncate(uint max_move=UINT_MAX, StationCargoAmountMap *cargo_per_source=nullptr)
Truncates where each destination loses roughly the same percentage of its cargo.
Definition: cargopacket.cpp:769
DAY_TICKS
static const int DAY_TICKS
1 day is 74 ticks; _date_fract used to be uint16 and incremented by 885.
Definition: date_type.h:28
TERM6_block
static const uint64 TERM6_block
Block belonging to terminal 6.
Definition: airport.h:94
AT_DUMMY
@ AT_DUMMY
Dummy airport.
Definition: airport.h:43
FLYING
@ FLYING
Vehicle is flying in the air.
Definition: airport.h:75
AMED_HELI_LOWER
@ AMED_HELI_LOWER
Helicopter landing.
Definition: airport.h:55
AIRCRAFT_MIN_FLYING_ALTITUDE
@ AIRCRAFT_MIN_FLYING_ALTITUDE
Minimum flying altitude above tile.
Definition: aircraft.h:21
_aircraft_state_handlers
static AircraftStateHandler *const _aircraft_state_handlers[]
Array of handler functions for each target of the aircraft.
Definition: aircraft_cmd.cpp:1738
AT_OILRIG
@ AT_OILRIG
Oilrig airport.
Definition: airport.h:38
Engine::reliability
uint16 reliability
Current reliability of the engine.
Definition: engine_base.h:31
Vehicle::refit_cap
uint16 refit_cap
Capacity left over from before last refit.
Definition: vehicle_base.h:319
Vehicle::date_of_last_service
Date date_of_last_service
Last date the vehicle had a service at a depot.
Definition: vehicle_base.h:272
GetNewVehiclePos
GetNewVehiclePosResult GetNewVehiclePos(const Vehicle *v)
Get position information of a vehicle when moving one pixel in the direction it is facing.
Definition: vehicle.cpp:1701
SetAircraftPosition
void SetAircraftPosition(Aircraft *v, int x, int y, int z)
Set aircraft position.
Definition: aircraft_cmd.cpp:522
AMED_BRAKE
@ AMED_BRAKE
Taxiing at the airport.
Definition: airport.h:53
TERM4
@ TERM4
Heading for terminal 4.
Definition: airport.h:66
TileVirtXY
static TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
Definition: map_func.h:194
AIR_ROTOR
@ AIR_ROTOR
rotor of an helicopter
Definition: aircraft.h:34
Vehicle::GetNextStoppingStation
StationIDStack GetNextStoppingStation() const
Get the next station the vehicle will stop at.
Definition: vehicle_base.h:714
news_func.h
AMED_NOSPDCLAMP
@ AMED_NOSPDCLAMP
No speed restrictions.
Definition: airport.h:48
ROTOR_Z_OFFSET
static const int ROTOR_Z_OFFSET
Z Offset between helicopter- and rotorsprite.
Definition: aircraft.h:50
backup_type.hpp