author | tron |
Wed, 20 Jul 2005 15:29:28 +0000 | |
changeset 2140 | a04d0142ad65 |
parent 2133 | d7f582b7001d |
child 2163 | b17b313113a0 |
permissions | -rw-r--r-- |
0 | 1 |
#include "stdafx.h" |
1891
862800791170
(svn r2397) - CodeChange: rename all "ttd" files to "openttd" files.
Darkvater
parents:
1877
diff
changeset
|
2 |
#include "openttd.h" |
1299
39c06aba09aa
(svn r1803) Move debugging stuff into files of it's own
tron
parents:
1282
diff
changeset
|
3 |
#include "debug.h" |
507
04b5403aaf6b
(svn r815) Include strings.h only in the files which need it.
tron
parents:
458
diff
changeset
|
4 |
#include "table/strings.h" |
679
04ca2cd69420
(svn r1117) Move map arrays and some related macros into their own files map.c and map.h
tron
parents:
593
diff
changeset
|
5 |
#include "map.h" |
1209
2e00193652b2
(svn r1713) Split off several functions which query/set information about a single tile from map.h and put them into a seperate file tile.h
tron
parents:
1206
diff
changeset
|
6 |
#include "tile.h" |
0 | 7 |
#include "vehicle.h" |
1790
47963a0cfca3
(svn r2294) - CodeChange: check the service interval settings when changing of all vehicle-types. To simplify things introduce GetServiceIntervalClamped() that returns the same or clamped value of the new service interval. There were some inconsistencies in the gui files so I had to change those, and const correctness kicked in, so it's a bit messy at certain points.
Darkvater
parents:
1786
diff
changeset
|
8 |
#include "depot.h" |
0 | 9 |
#include "engine.h" |
10 |
#include "command.h" |
|
11 |
#include "station.h" |
|
12 |
#include "news.h" |
|
337
cbe0c766c947
(svn r513) Merge revisions 402, 416, 417, 478, 479, 511, 512 from map to trunk
tron
parents:
193
diff
changeset
|
13 |
#include "sound.h" |
0 | 14 |
#include "player.h" |
15 |
#include "airport.h" |
|
1752
d65cd19f7117
(svn r2256) - Fix: Trains cannot find a depot when they are in a tunnel. (glx)
matthijs
parents:
1614
diff
changeset
|
16 |
#include "vehicle_gui.h" |
0 | 17 |
|
18 |
static bool AirportMove(Vehicle *v, const AirportFTAClass *Airport); |
|
19 |
static bool AirportSetBlocks(Vehicle *v, AirportFTA *current_pos, const AirportFTAClass *Airport); |
|
20 |
static bool AirportHasBlock(Vehicle *v, AirportFTA *current_pos, const AirportFTAClass *Airport); |
|
21 |
static bool AirportFindFreeTerminal(Vehicle *v, const AirportFTAClass *Airport); |
|
22 |
static bool AirportFindFreeHelipad(Vehicle *v, const AirportFTAClass *Airport); |
|
23 |
static void AirportGoToNextPosition(Vehicle *v, const AirportFTAClass *Airport); |
|
899
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
24 |
static void CrashAirplane(Vehicle *v); |
0 | 25 |
|
26 |
static void AircraftNextAirportPos_and_Order(Vehicle *v); |
|
27 |
static byte GetAircraftFlyingAltitude(const Vehicle *v); |
|
28 |
||
29 |
static const SpriteID _aircraft_sprite[] = { |
|
30 |
0x0EB5, 0x0EBD, 0x0EC5, 0x0ECD, |
|
31 |
0x0ED5, 0x0EDD, 0x0E9D, 0x0EA5, |
|
32 |
0x0EAD, 0x0EE5, 0x0F05, 0x0F0D, |
|
33 |
0x0F15, 0x0F1D, 0x0F25, 0x0F2D, |
|
34 |
0x0EED, 0x0EF5, 0x0EFD, 0x0F35, |
|
35 |
0x0E9D, 0x0EA5, 0x0EAD, 0x0EB5, |
|
36 |
0x0EBD, 0x0EC5 |
|
37 |
}; |
|
38 |
||
1532
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
39 |
/* Find the nearest hangar to v |
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
40 |
* INVALID_STATION is returned, if the player does not have any suitable |
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
41 |
* airports (like helipads only) |
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
42 |
*/ |
1793
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
43 |
static StationID FindNearestHangar(const Vehicle *v) |
1194
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
44 |
{ |
1532
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
45 |
const Station *st; |
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
46 |
uint best = 0; |
1793
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
47 |
StationID index = INVALID_STATION; |
1194
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
48 |
|
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
49 |
FOR_ALL_STATIONS(st) { |
1532
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
50 |
if (st->owner == v->owner && st->facilities & FACIL_AIRPORT && |
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
51 |
GetAirport(st->airport_type)->nof_depots > 0) { |
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
52 |
uint distance; |
1204
747d1f630eda
(svn r1708) - Fix: FindNearestHangar() will no longer return a hangar where a jet will crash if it is a jet, that is searching
bjarni
parents:
1200
diff
changeset
|
53 |
|
1532
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
54 |
// don't crash the plane if we know it can't land at the airport |
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
55 |
if (HASBIT(v->subtype, 1) && st->airport_type == AT_SMALL && |
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
56 |
!_cheats.no_jetcrash.value) |
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
57 |
continue; |
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
58 |
|
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
59 |
distance = DistanceSquare(v->tile, st->airport_tile); |
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
60 |
if (distance < best || index == INVALID_STATION) { |
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
61 |
best = distance; |
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
62 |
index = st->index; |
1194
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
63 |
} |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
64 |
} |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
65 |
} |
1532
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
66 |
return index; |
1194
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
67 |
} |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
68 |
|
1614
f6f2c918356d
(svn r2118) - Fix: Fix compilation with network disabled, and comment out some of the warnings (unused function)
Darkvater
parents:
1533
diff
changeset
|
69 |
#if 0 |
1194
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
70 |
// returns true if vehicle v have an airport in the schedule, that has a hangar |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
71 |
static bool HaveHangarInOrderList(Vehicle *v) |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
72 |
{ |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
73 |
const Order *order; |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
74 |
|
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
75 |
FOR_VEHICLE_ORDERS(v, order) { |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
76 |
const Station *st = GetStation(order->station); |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
77 |
if (st->owner == v->owner && st->facilities & FACIL_AIRPORT) { |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
78 |
// If an airport doesn't have terminals (so no landing space for airports), |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
79 |
// it surely doesn't have any hangars |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
80 |
if (GetAirport(st->airport_type)->terminals != NULL) |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
81 |
return true; |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
82 |
} |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
83 |
} |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
84 |
|
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
85 |
return false; |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
86 |
} |
1614
f6f2c918356d
(svn r2118) - Fix: Fix compilation with network disabled, and comment out some of the warnings (unused function)
Darkvater
parents:
1533
diff
changeset
|
87 |
#endif |
1194
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
88 |
|
1790
47963a0cfca3
(svn r2294) - CodeChange: check the service interval settings when changing of all vehicle-types. To simplify things introduce GetServiceIntervalClamped() that returns the same or clamped value of the new service interval. There were some inconsistencies in the gui files so I had to change those, and const correctness kicked in, so it's a bit messy at certain points.
Darkvater
parents:
1786
diff
changeset
|
89 |
int GetAircraftImage(const Vehicle *v, byte direction) |
0 | 90 |
{ |
91 |
int spritenum = v->spritenum; |
|
92 |
||
93 |
if (is_custom_sprite(spritenum)) { |
|
94 |
int sprite = GetCustomVehicleSprite(v, direction); |
|
95 |
||
96 |
if (sprite) return sprite; |
|
97 |
spritenum = _engine_original_sprites[v->engine_type]; |
|
98 |
} |
|
99 |
return direction + _aircraft_sprite[spritenum]; |
|
100 |
} |
|
101 |
||
102 |
void DrawAircraftEngine(int x, int y, int engine, uint32 image_ormod) |
|
103 |
{ |
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
104 |
int spritenum = AircraftVehInfo(engine)->image_index; |
1200
d5ef134866de
(svn r1704) - Fix: [newgrf] rotors of custom helicopters are displayed correctly in the hangar window
dominik
parents:
1197
diff
changeset
|
105 |
int sprite = (6 + _aircraft_sprite[spritenum]); |
0 | 106 |
|
381
527e47c8feec
(svn r570) -newgrf: Support for custom aircrafts via GRF files. Planeset seems to work :). Also use aircraft_vehinfo() instead of the old tables (pasky).
darkvater
parents:
337
diff
changeset
|
107 |
if (is_custom_sprite(spritenum)) { |
1200
d5ef134866de
(svn r1704) - Fix: [newgrf] rotors of custom helicopters are displayed correctly in the hangar window
dominik
parents:
1197
diff
changeset
|
108 |
sprite = GetCustomVehicleIcon(engine, 6); |
d5ef134866de
(svn r1704) - Fix: [newgrf] rotors of custom helicopters are displayed correctly in the hangar window
dominik
parents:
1197
diff
changeset
|
109 |
if (!sprite) |
d5ef134866de
(svn r1704) - Fix: [newgrf] rotors of custom helicopters are displayed correctly in the hangar window
dominik
parents:
1197
diff
changeset
|
110 |
sprite = _engine_original_sprites[engine]; |
381
527e47c8feec
(svn r570) -newgrf: Support for custom aircrafts via GRF files. Planeset seems to work :). Also use aircraft_vehinfo() instead of the old tables (pasky).
darkvater
parents:
337
diff
changeset
|
111 |
} |
527e47c8feec
(svn r570) -newgrf: Support for custom aircrafts via GRF files. Planeset seems to work :). Also use aircraft_vehinfo() instead of the old tables (pasky).
darkvater
parents:
337
diff
changeset
|
112 |
|
1200
d5ef134866de
(svn r1704) - Fix: [newgrf] rotors of custom helicopters are displayed correctly in the hangar window
dominik
parents:
1197
diff
changeset
|
113 |
DrawSprite(sprite | image_ormod, x, y); |
381
527e47c8feec
(svn r570) -newgrf: Support for custom aircrafts via GRF files. Planeset seems to work :). Also use aircraft_vehinfo() instead of the old tables (pasky).
darkvater
parents:
337
diff
changeset
|
114 |
|
1200
d5ef134866de
(svn r1704) - Fix: [newgrf] rotors of custom helicopters are displayed correctly in the hangar window
dominik
parents:
1197
diff
changeset
|
115 |
if ((AircraftVehInfo(engine)->subtype & 1) == 0) { |
0 | 116 |
DrawSprite(0xF3D, x, y-5); |
1200
d5ef134866de
(svn r1704) - Fix: [newgrf] rotors of custom helicopters are displayed correctly in the hangar window
dominik
parents:
1197
diff
changeset
|
117 |
} |
0 | 118 |
} |
119 |
||
120 |
/* Allocate many vehicles */ |
|
410 | 121 |
static bool AllocateVehicles(Vehicle **vl, int num) |
0 | 122 |
{ |
123 |
int i; |
|
124 |
Vehicle *v; |
|
125 |
bool success = true; |
|
126 |
||
127 |
for(i=0; i!=num; i++) { |
|
128 |
vl[i] = v = AllocateVehicle(); |
|
129 |
if (v == NULL) { |
|
130 |
success = false; |
|
131 |
break; |
|
132 |
} |
|
133 |
v->type = 1; |
|
134 |
} |
|
135 |
||
136 |
while (--i >= 0) { |
|
137 |
vl[i]->type = 0; |
|
138 |
} |
|
139 |
||
140 |
return success; |
|
141 |
} |
|
142 |
||
1793
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
143 |
int32 EstimateAircraftCost(EngineID engine_type) |
0 | 144 |
{ |
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
145 |
return AircraftVehInfo(engine_type)->base_cost * (_price.aircraft_base>>3)>>5; |
0 | 146 |
} |
147 |
||
148 |
||
1793
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
149 |
/** Build an aircraft. |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
150 |
* @param x,y tile coordinates of depot where aircraft is built |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
151 |
* @param p1 aircraft type being built (engine) |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
152 |
* @param p2 unused |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
153 |
*/ |
0 | 154 |
int32 CmdBuildAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
155 |
{ |
|
156 |
int32 value; |
|
157 |
Vehicle *vl[3], *v, *u, *w; |
|
1282
ea2ae881814c
(svn r1786) -Fix: unitnumber is increased to 16bit, so now you can have up to 5000
truelight
parents:
1266
diff
changeset
|
158 |
UnitID unit_num; |
1980
6c5917cfcb78
(svn r2486) Turn TILE_FROM_XY into an inline function and rename it to TileVirtXY
tron
parents:
1977
diff
changeset
|
159 |
TileIndex tile = TileVirtXY(x, y); |
1877
ab6a315fa930
(svn r2383) - Fix: Monkey-testing turned up some command crashes.
Darkvater
parents:
1874
diff
changeset
|
160 |
const AircraftVehicleInfo *avi; |
0 | 161 |
Engine *e; |
162 |
||
1197 | 163 |
if (!IsEngineBuildable(p1, VEH_Aircraft)) return CMD_ERROR; |
1196
67f7f3017d99
(svn r1700) - Fix: Hacked clients can no longer be used to build vehicles that are not available yet (Hackykid)
bjarni
parents:
1195
diff
changeset
|
164 |
|
1226
f0cb2c427b84
(svn r1730) - Fix: Ships and Aircrafts have to be build in depots owned by _current_player (hacked client protection)
bjarni
parents:
1209
diff
changeset
|
165 |
// Workaround: TODO: make AI players try to build planes in a hangar instead of just an airport tile. |
1533
613a5f81ad79
(svn r2037) uint -> TileIndex, remove pointless casts, const, misc.
tron
parents:
1532
diff
changeset
|
166 |
if (!IsAircraftHangarTile(tile) && IS_HUMAN_PLAYER(_current_player)) return CMD_ERROR; |
1226
f0cb2c427b84
(svn r1730) - Fix: Ships and Aircrafts have to be build in depots owned by _current_player (hacked client protection)
bjarni
parents:
1209
diff
changeset
|
167 |
|
1901
03bf9bf99319
(svn r2407) Use {Get,Is}TileOwner to get/check the owner of a tile and fix some bogus reads of _map_owner
tron
parents:
1897
diff
changeset
|
168 |
if (!IsTileOwner(tile, _current_player) && IS_HUMAN_PLAYER(_current_player)) return CMD_ERROR; |
1226
f0cb2c427b84
(svn r1730) - Fix: Ships and Aircrafts have to be build in depots owned by _current_player (hacked client protection)
bjarni
parents:
1209
diff
changeset
|
169 |
|
0 | 170 |
SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES); |
171 |
||
172 |
value = EstimateAircraftCost(p1); |
|
173 |
||
1793
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
174 |
if (flags & DC_QUERY_COST) return value; |
0 | 175 |
|
1877
ab6a315fa930
(svn r2383) - Fix: Monkey-testing turned up some command crashes.
Darkvater
parents:
1874
diff
changeset
|
176 |
avi = AircraftVehInfo(p1); |
0 | 177 |
// allocate 2 or 3 vehicle structs, depending on type |
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
178 |
if (!AllocateVehicles(vl, (avi->subtype & 1) == 0 ? 3 : 2) || |
1024
5e446b5b3ec5
(svn r1525) -Codechange: rewrote the _order_array, now it can be made dynamic.
truelight
parents:
1020
diff
changeset
|
179 |
IsOrderPoolFull()) |
0 | 180 |
return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME); |
181 |
||
182 |
unit_num = GetFreeUnitNumber(VEH_Aircraft); |
|
183 |
if (unit_num > _patches.max_aircraft) |
|
184 |
return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME); |
|
185 |
||
186 |
if (flags & DC_EXEC) { |
|
187 |
v = vl[0]; |
|
188 |
u = vl[1]; |
|
189 |
||
190 |
v->unitnumber = unit_num; |
|
191 |
v->type = u->type = VEH_Aircraft; |
|
192 |
v->direction = 3; |
|
193 |
||
194 |
v->owner = u->owner = _current_player; |
|
195 |
||
196 |
v->tile = tile; |
|
197 |
// u->tile = 0; |
|
198 |
||
926
a6d140a6a4de
(svn r1414) Move TileIndex, TILE_MASK and GET_TILE_[XY] to map.h and turn the latter into inline functions names Tile[XY]
tron
parents:
924
diff
changeset
|
199 |
x = TileX(tile) * 16 + 5; |
a6d140a6a4de
(svn r1414) Move TileIndex, TILE_MASK and GET_TILE_[XY] to map.h and turn the latter into inline functions names Tile[XY]
tron
parents:
924
diff
changeset
|
200 |
y = TileY(tile) * 16 + 3; |
0 | 201 |
|
202 |
v->x_pos = u->x_pos = x; |
|
203 |
v->y_pos = u->y_pos = y; |
|
204 |
||
205 |
u->z_pos = GetSlopeZ(x, y); |
|
206 |
v->z_pos = u->z_pos + 1; |
|
207 |
||
208 |
v->x_offs = v->y_offs = -1; |
|
209 |
// u->delta_x = u->delta_y = 0; |
|
210 |
||
211 |
v->sprite_width = v->sprite_height = 2; |
|
212 |
v->z_height = 5; |
|
213 |
||
214 |
u->sprite_width = u->sprite_height = 2; |
|
215 |
u->z_height = 1; |
|
216 |
||
217 |
v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL; |
|
218 |
u->vehstatus = VS_HIDDEN | VS_UNCLICKABLE | VS_DISASTER; |
|
219 |
||
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
220 |
v->spritenum = avi->image_index; |
0 | 221 |
// v->cargo_count = u->number_of_pieces = 0; |
222 |
||
922
10035216cbaf
(svn r1410) Replaced all occurences of 'passanger' by 'passenger' in the code
celestar
parents:
919
diff
changeset
|
223 |
v->cargo_cap = avi->passenger_capacity; |
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
224 |
u->cargo_cap = avi->mail_capacity; |
0 | 225 |
|
226 |
v->cargo_type = CT_PASSENGERS; |
|
227 |
u->cargo_type = CT_MAIL; |
|
228 |
||
229 |
v->string_id = STR_SV_AIRCRAFT_NAME; |
|
230 |
// v->next_order_param = v->next_order = 0; |
|
231 |
||
232 |
// v->load_unload_time_rem = 0; |
|
233 |
// v->progress = 0; |
|
1266
eccd576e322f
(svn r1770) -Fix: Hopefully last pieces of code that are containing a station-id
truelight
parents:
1263
diff
changeset
|
234 |
v->last_station_visited = INVALID_STATION; |
0 | 235 |
// v->destination_coords = 0; |
236 |
||
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
237 |
v->max_speed = avi->max_speed; |
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
238 |
v->acceleration = avi->acceleration; |
0 | 239 |
v->engine_type = (byte)p1; |
240 |
||
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
241 |
v->subtype = (avi->subtype & 1) == 0 ? 0 : 2; |
0 | 242 |
v->value = value; |
243 |
||
244 |
u->subtype = 4; |
|
245 |
||
1926
530480d14685
(svn r2432) Use GetEngine() instead of DEREF_ENGINE() or even _engines[]
tron
parents:
1901
diff
changeset
|
246 |
e = GetEngine(p1); |
0 | 247 |
v->reliability = e->reliability; |
248 |
v->reliability_spd_dec = e->reliability_spd_dec; |
|
249 |
v->max_age = e->lifelength * 366; |
|
250 |
||
251 |
_new_aircraft_id = v->index; |
|
252 |
||
253 |
// the AI doesn't click on a tile to build airplanes, so the below code will |
|
254 |
// never work. Therefore just assume the AI's planes always come from Hangar0 |
|
84
1e0721c29bad
(svn r85) -Add: initial commit of new AI (enable in Patch menu)
truelight
parents:
76
diff
changeset
|
255 |
// On hold for NewAI |
1e0721c29bad
(svn r85) -Add: initial commit of new AI (enable in Patch menu)
truelight
parents:
76
diff
changeset
|
256 |
v->u.air.pos = (!_patches.ainew_active && _is_ai_player) ? 0:MAX_ELEMENTS; |
0 | 257 |
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
258 |
/* When we click on hangar we know the tile (it is in var 'tile')it is on. By that we know |
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
259 |
its position in the array of depots the airport has.....we can search |
0 | 260 |
->layout for #th position of depot. Since layout must start with depots, it is simple |
261 |
*/ |
|
262 |
{ |
|
2049
538e73c53f54
(svn r2558) Change the internal map format from 7 arrays to one array of structs, this doesn't change the saved format for now. It's a stepping stone for further changes.
tron
parents:
1998
diff
changeset
|
263 |
const Station* st = GetStation(_m[tile].m2); |
1533
613a5f81ad79
(svn r2037) uint -> TileIndex, remove pointless casts, const, misc.
tron
parents:
1532
diff
changeset
|
264 |
const AirportFTAClass* Airport = GetAirport(st->airport_type); |
613a5f81ad79
(svn r2037) uint -> TileIndex, remove pointless casts, const, misc.
tron
parents:
1532
diff
changeset
|
265 |
uint i; |
613a5f81ad79
(svn r2037) uint -> TileIndex, remove pointless casts, const, misc.
tron
parents:
1532
diff
changeset
|
266 |
|
613a5f81ad79
(svn r2037) uint -> TileIndex, remove pointless casts, const, misc.
tron
parents:
1532
diff
changeset
|
267 |
for (i = 0; i < Airport->nof_depots; i++) { |
613a5f81ad79
(svn r2037) uint -> TileIndex, remove pointless casts, const, misc.
tron
parents:
1532
diff
changeset
|
268 |
if (st->airport_tile + ToTileIndexDiff(Airport->airport_depots[i]) == tile) { |
0 | 269 |
assert(Airport->layout[i].heading == HANGAR); |
270 |
v->u.air.pos = Airport->layout[i].position; |
|
271 |
break; |
|
272 |
} |
|
273 |
} |
|
274 |
// to ensure v->u.air.pos has been given a value |
|
275 |
assert(v->u.air.pos != MAX_ELEMENTS); |
|
276 |
} |
|
277 |
||
278 |
v->u.air.state = HANGAR; |
|
279 |
v->u.air.previous_pos = v->u.air.pos; |
|
2049
538e73c53f54
(svn r2558) Change the internal map format from 7 arrays to one array of structs, this doesn't change the saved format for now. It's a stepping stone for further changes.
tron
parents:
1998
diff
changeset
|
280 |
v->u.air.targetairport = _m[tile].m2; |
0 | 281 |
v->next = u; |
282 |
||
283 |
v->service_interval = _patches.servint_aircraft; |
|
284 |
||
285 |
v->date_of_last_service = _date; |
|
1874
808140792074
(svn r2380) - Fix: Build year for mail compartment of planes was not set correctly, affected station ratings (Asterix_)
orudge
parents:
1802
diff
changeset
|
286 |
v->build_year = u->build_year = _cur_year; |
0 | 287 |
|
288 |
v->cur_image = u->cur_image = 0xEA0; |
|
289 |
||
290 |
VehiclePositionChanged(v); |
|
291 |
VehiclePositionChanged(u); |
|
292 |
||
1793
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
293 |
// Aircraft with 3 vehicles (chopper)? |
0 | 294 |
if (v->subtype == 0) { |
295 |
w = vl[2]; |
|
296 |
||
297 |
u->next = w; |
|
298 |
||
299 |
w->type = VEH_Aircraft; |
|
300 |
w->direction = 0; |
|
301 |
w->owner = _current_player; |
|
302 |
w->x_pos = v->x_pos; |
|
303 |
w->y_pos = v->y_pos; |
|
304 |
w->z_pos = v->z_pos + 5; |
|
305 |
w->x_offs = w->y_offs = -1; |
|
306 |
w->sprite_width = w->sprite_height = 2; |
|
307 |
w->z_height = 1; |
|
308 |
w->vehstatus = VS_HIDDEN | VS_UNCLICKABLE; |
|
309 |
w->subtype = 6; |
|
310 |
w->cur_image = 0xF3D; |
|
311 |
VehiclePositionChanged(w); |
|
312 |
} |
|
313 |
||
314 |
InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); |
|
588 | 315 |
RebuildVehicleLists(); |
0 | 316 |
InvalidateWindow(WC_COMPANY, v->owner); |
1793
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
317 |
InvalidateWindow(WC_REPLACE_VEHICLE, VEH_Aircraft); //updates the replace Aircraft window |
0 | 318 |
} |
319 |
||
320 |
return value; |
|
321 |
} |
|
322 |
||
323 |
bool IsAircraftHangarTile(TileIndex tile) |
|
324 |
{ |
|
325 |
// 0x56 - hangar facing other way international airport (86) |
|
326 |
// 0x20 - hangar large airport (32) |
|
327 |
// 0x41 - hangar small airport (65) |
|
1035
812f837ee03f
(svn r1536) Move GET_TILEHEIGHT, GET_TILETYPE and IS_TILETYPE to map.h, turn them into inline functions and add some asserts
tron
parents:
1024
diff
changeset
|
328 |
return IsTileType(tile, MP_STATION) && |
2049
538e73c53f54
(svn r2558) Change the internal map format from 7 arrays to one array of structs, this doesn't change the saved format for now. It's a stepping stone for further changes.
tron
parents:
1998
diff
changeset
|
329 |
(_m[tile].m5 == 32 || _m[tile].m5 == 65 || _m[tile].m5 == 86); |
0 | 330 |
} |
331 |
||
332 |
static bool CheckStoppedInHangar(Vehicle *v) |
|
333 |
{ |
|
1533
613a5f81ad79
(svn r2037) uint -> TileIndex, remove pointless casts, const, misc.
tron
parents:
1532
diff
changeset
|
334 |
if (!(v->vehstatus & VS_STOPPED) || !IsAircraftHangarTile(v->tile)) { |
0 | 335 |
_error_message = STR_A01B_AIRCRAFT_MUST_BE_STOPPED; |
336 |
return false; |
|
337 |
} |
|
338 |
||
339 |
return true; |
|
340 |
} |
|
341 |
||
342 |
||
410 | 343 |
static void DoDeleteAircraft(Vehicle *v) |
0 | 344 |
{ |
345 |
DeleteWindowById(WC_VEHICLE_VIEW, v->index); |
|
588 | 346 |
RebuildVehicleLists(); |
0 | 347 |
InvalidateWindow(WC_COMPANY, v->owner); |
348 |
DeleteVehicleChain(v); |
|
1055
cc4f60cc9102
(svn r1556) -Fix: Vehicle list updates should now really work
Celestar
parents:
1053
diff
changeset
|
349 |
InvalidateWindowClasses(WC_AIRCRAFT_LIST); |
0 | 350 |
} |
351 |
||
1786
7cfd46c3fcc4
(svn r2290) - CodeChange: protect the next batch of commands. This brings us to a total of 61, which is 53% :)
Darkvater
parents:
1752
diff
changeset
|
352 |
/** Sell an aircraft. |
7cfd46c3fcc4
(svn r2290) - CodeChange: protect the next batch of commands. This brings us to a total of 61, which is 53% :)
Darkvater
parents:
1752
diff
changeset
|
353 |
* @param x,y unused |
7cfd46c3fcc4
(svn r2290) - CodeChange: protect the next batch of commands. This brings us to a total of 61, which is 53% :)
Darkvater
parents:
1752
diff
changeset
|
354 |
* @param p1 vehicle ID to be sold |
7cfd46c3fcc4
(svn r2290) - CodeChange: protect the next batch of commands. This brings us to a total of 61, which is 53% :)
Darkvater
parents:
1752
diff
changeset
|
355 |
* @param p2 unused |
7cfd46c3fcc4
(svn r2290) - CodeChange: protect the next batch of commands. This brings us to a total of 61, which is 53% :)
Darkvater
parents:
1752
diff
changeset
|
356 |
*/ |
0 | 357 |
int32 CmdSellAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
358 |
{ |
|
359 |
Vehicle *v; |
|
360 |
||
1237
1c7a3f9c94b9
(svn r1741) - Fix: added IsVehicleIndex() so it's possible to protect GetVehicle() from reading an invalid vehicle index
bjarni
parents:
1235
diff
changeset
|
361 |
if (!IsVehicleIndex(p1)) return CMD_ERROR; |
0 | 362 |
|
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
363 |
v = GetVehicle(p1); |
0 | 364 |
|
1235
b9938f523286
(svn r1739) - Fix: type checking when selling vehicles (TrueLight)
darkvater
parents:
1226
diff
changeset
|
365 |
if (v->type != VEH_Aircraft || !CheckOwnership(v->owner) || !CheckStoppedInHangar(v)) |
0 | 366 |
return CMD_ERROR; |
367 |
||
1237
1c7a3f9c94b9
(svn r1741) - Fix: added IsVehicleIndex() so it's possible to protect GetVehicle() from reading an invalid vehicle index
bjarni
parents:
1235
diff
changeset
|
368 |
SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES); |
1c7a3f9c94b9
(svn r1741) - Fix: added IsVehicleIndex() so it's possible to protect GetVehicle() from reading an invalid vehicle index
bjarni
parents:
1235
diff
changeset
|
369 |
|
0 | 370 |
if (flags & DC_EXEC) { |
371 |
// Invalidate depot |
|
372 |
InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); |
|
373 |
DoDeleteAircraft(v); |
|
1793
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
374 |
InvalidateWindow(WC_REPLACE_VEHICLE, VEH_Aircraft); // updates the replace Aircraft window |
0 | 375 |
} |
376 |
||
377 |
return -(int32)v->value; |
|
378 |
} |
|
379 |
||
1786
7cfd46c3fcc4
(svn r2290) - CodeChange: protect the next batch of commands. This brings us to a total of 61, which is 53% :)
Darkvater
parents:
1752
diff
changeset
|
380 |
/** Start/Stop an aircraft. |
7cfd46c3fcc4
(svn r2290) - CodeChange: protect the next batch of commands. This brings us to a total of 61, which is 53% :)
Darkvater
parents:
1752
diff
changeset
|
381 |
* @param x,y unused |
1793
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
382 |
* @param p1 aircraft ID to start/stop |
1786
7cfd46c3fcc4
(svn r2290) - CodeChange: protect the next batch of commands. This brings us to a total of 61, which is 53% :)
Darkvater
parents:
1752
diff
changeset
|
383 |
* @param p2 unused |
7cfd46c3fcc4
(svn r2290) - CodeChange: protect the next batch of commands. This brings us to a total of 61, which is 53% :)
Darkvater
parents:
1752
diff
changeset
|
384 |
*/ |
0 | 385 |
int32 CmdStartStopAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
386 |
{ |
|
387 |
Vehicle *v; |
|
388 |
||
1237
1c7a3f9c94b9
(svn r1741) - Fix: added IsVehicleIndex() so it's possible to protect GetVehicle() from reading an invalid vehicle index
bjarni
parents:
1235
diff
changeset
|
389 |
if (!IsVehicleIndex(p1)) return CMD_ERROR; |
1c7a3f9c94b9
(svn r1741) - Fix: added IsVehicleIndex() so it's possible to protect GetVehicle() from reading an invalid vehicle index
bjarni
parents:
1235
diff
changeset
|
390 |
|
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
391 |
v = GetVehicle(p1); |
0 | 392 |
|
1786
7cfd46c3fcc4
(svn r2290) - CodeChange: protect the next batch of commands. This brings us to a total of 61, which is 53% :)
Darkvater
parents:
1752
diff
changeset
|
393 |
if (v->type != VEH_Aircraft || !CheckOwnership(v->owner)) return CMD_ERROR; |
0 | 394 |
|
395 |
// cannot stop airplane when in flight, or when taking off / landing |
|
1786
7cfd46c3fcc4
(svn r2290) - CodeChange: protect the next batch of commands. This brings us to a total of 61, which is 53% :)
Darkvater
parents:
1752
diff
changeset
|
396 |
if (v->u.air.state >= STARTTAKEOFF) |
0 | 397 |
return_cmd_error(STR_A017_AIRCRAFT_IS_IN_FLIGHT); |
398 |
||
399 |
if (flags & DC_EXEC) { |
|
400 |
v->vehstatus ^= VS_STOPPED; |
|
755
80091de50044
(svn r1211) -Feature: Introduce sticky windows to all vehicle windows...Just make sure you do not sticky more than 23 at a time. Also a lot of places in the code invalidated the 'status bar' of the vehicle, referring to it as widget 4. This is now widget 5 and has been #definitized
darkvater
parents:
699
diff
changeset
|
401 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR); |
0 | 402 |
InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); |
1055
cc4f60cc9102
(svn r1556) -Fix: Vehicle list updates should now really work
Celestar
parents:
1053
diff
changeset
|
403 |
InvalidateWindowClasses(WC_AIRCRAFT_LIST); |
0 | 404 |
} |
405 |
||
406 |
return 0; |
|
407 |
} |
|
408 |
||
1793
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
409 |
/** Send an aircraft to the hangar. |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
410 |
* @param x,y unused |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
411 |
* @param p1 vehicle ID to send to the hangar |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
412 |
* @param p2 various bitmasked elements |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
413 |
* - p2 = 0 - aircraft goes to the depot and stays there (user command) |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
414 |
* - p2 non-zero - aircraft will try to goto a depot, but not stop there (eg forced servicing) |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
415 |
* - p2 (bit 17) - aircraft will try to goto a depot at the next airport |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
416 |
*/ |
0 | 417 |
int32 CmdSendAircraftToHangar(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
418 |
{ |
|
419 |
Vehicle *v; |
|
420 |
||
1237
1c7a3f9c94b9
(svn r1741) - Fix: added IsVehicleIndex() so it's possible to protect GetVehicle() from reading an invalid vehicle index
bjarni
parents:
1235
diff
changeset
|
421 |
if (!IsVehicleIndex(p1)) return CMD_ERROR; |
1c7a3f9c94b9
(svn r1741) - Fix: added IsVehicleIndex() so it's possible to protect GetVehicle() from reading an invalid vehicle index
bjarni
parents:
1235
diff
changeset
|
422 |
|
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
423 |
v = GetVehicle(p1); |
0 | 424 |
|
1793
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
425 |
if (v->type != VEH_Aircraft || !CheckOwnership(v->owner)) return CMD_ERROR; |
1206
5d3c1d2c3214
(svn r1710) - Fix: [autoreplace] vehicles do no longer go to a depot all the time if the owner clicked 'stop replacing' ( ship+aircraft+road vehicles )
bjarni
parents:
1204
diff
changeset
|
426 |
|
1195
54d50ac3311a
(svn r1699) - Feature [autoreplace] a plane will now go to the hangar right after landing if it needs to be replaced
bjarni
parents:
1194
diff
changeset
|
427 |
if (v->current_order.type == OT_GOTO_DEPOT && p2 == 0) { |
0 | 428 |
if (flags & DC_EXEC) { |
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
429 |
if (v->current_order.flags & OF_UNLOAD) v->cur_order_index++; |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
430 |
v->current_order.type = OT_DUMMY; |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
431 |
v->current_order.flags = 0; |
755
80091de50044
(svn r1211) -Feature: Introduce sticky windows to all vehicle windows...Just make sure you do not sticky more than 23 at a time. Also a lot of places in the code invalidated the 'status bar' of the vehicle, referring to it as widget 4. This is now widget 5 and has been #definitized
darkvater
parents:
699
diff
changeset
|
432 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR); |
0 | 433 |
} |
434 |
} else { |
|
1262
e3473b1afda9
(svn r1766) - Feature: Aircrafts will now go to the nearest hangar if the next airport in the orders do not have one (helipads)
bjarni
parents:
1245
diff
changeset
|
435 |
bool next_airport_has_hangar = true; |
1793
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
436 |
/* XXX - I don't think p2 is any valid station cause all calls use either 0, 1, or 1<<16!!!!!!!!! */ |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
437 |
StationID next_airport_index = (HASBIT(p2, 17)) ? (StationID)p2 : v->u.air.targetairport; |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
438 |
const Station *st = GetStation(next_airport_index); |
0 | 439 |
// If an airport doesn't have terminals (so no landing space for airports), |
440 |
// it surely doesn't have any hangars |
|
1793
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
441 |
if (!IsValidStation(st) || st->airport_tile == 0 || GetAirport(st->airport_type)->nof_depots == 0) { |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
442 |
StationID station; |
1532
a69fdc89b5fc
(svn r2036) Fix FindNearestHanger(), it never worked correctly because 0xFFFF != 65000 and a 16bit number has no 17th bit
tron
parents:
1530
diff
changeset
|
443 |
|
1793
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
444 |
if (p2 != 0) return CMD_ERROR; |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
445 |
// the aircraft has to search for a hangar on its own |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
446 |
station = FindNearestHangar(v); |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
447 |
|
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
448 |
next_airport_has_hangar = false; |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
449 |
if (station == INVALID_STATION) return CMD_ERROR; |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
450 |
st = GetStation(station); |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
451 |
next_airport_index = station; |
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
452 |
|
1262
e3473b1afda9
(svn r1766) - Feature: Aircrafts will now go to the nearest hangar if the next airport in the orders do not have one (helipads)
bjarni
parents:
1245
diff
changeset
|
453 |
} |
0 | 454 |
|
455 |
if (flags & DC_EXEC) { |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
456 |
v->current_order.type = OT_GOTO_DEPOT; |
1262
e3473b1afda9
(svn r1766) - Feature: Aircrafts will now go to the nearest hangar if the next airport in the orders do not have one (helipads)
bjarni
parents:
1245
diff
changeset
|
457 |
v->current_order.flags = HASBIT(p2, 16) ? 0 : OF_NON_STOP | OF_FULL_LOAD; |
1194
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
458 |
v->current_order.station = next_airport_index; |
755
80091de50044
(svn r1211) -Feature: Introduce sticky windows to all vehicle windows...Just make sure you do not sticky more than 23 at a time. Also a lot of places in the code invalidated the 'status bar' of the vehicle, referring to it as widget 4. This is now widget 5 and has been #definitized
darkvater
parents:
699
diff
changeset
|
459 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR); |
1262
e3473b1afda9
(svn r1766) - Feature: Aircrafts will now go to the nearest hangar if the next airport in the orders do not have one (helipads)
bjarni
parents:
1245
diff
changeset
|
460 |
if (HASBIT(p2, 17) || (p2 == 0 && v->u.air.state == FLYING && !next_airport_has_hangar)) { |
e3473b1afda9
(svn r1766) - Feature: Aircrafts will now go to the nearest hangar if the next airport in the orders do not have one (helipads)
bjarni
parents:
1245
diff
changeset
|
461 |
// the aircraft is now heading for a different hangar than the next in the orders |
1194
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
462 |
AircraftNextAirportPos_and_Order(v); |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
463 |
v->u.air.targetairport = next_airport_index; |
2b25b1477623
(svn r1698) - Feature [autoreplace] helicopters will now go to the nearest hangar if they are set to autoreplace and don't have any airport with a hangar in
bjarni
parents:
1151
diff
changeset
|
464 |
} |
0 | 465 |
} |
466 |
} |
|
467 |
||
468 |
return 0; |
|
469 |
} |
|
470 |
||
1790
47963a0cfca3
(svn r2294) - CodeChange: check the service interval settings when changing of all vehicle-types. To simplify things introduce GetServiceIntervalClamped() that returns the same or clamped value of the new service interval. There were some inconsistencies in the gui files so I had to change those, and const correctness kicked in, so it's a bit messy at certain points.
Darkvater
parents:
1786
diff
changeset
|
471 |
/** Change the service interval for aircraft. |
47963a0cfca3
(svn r2294) - CodeChange: check the service interval settings when changing of all vehicle-types. To simplify things introduce GetServiceIntervalClamped() that returns the same or clamped value of the new service interval. There were some inconsistencies in the gui files so I had to change those, and const correctness kicked in, so it's a bit messy at certain points.
Darkvater
parents:
1786
diff
changeset
|
472 |
* @param x,y unused |
47963a0cfca3
(svn r2294) - CodeChange: check the service interval settings when changing of all vehicle-types. To simplify things introduce GetServiceIntervalClamped() that returns the same or clamped value of the new service interval. There were some inconsistencies in the gui files so I had to change those, and const correctness kicked in, so it's a bit messy at certain points.
Darkvater
parents:
1786
diff
changeset
|
473 |
* @param p1 vehicle ID that is being service-interval-changed |
47963a0cfca3
(svn r2294) - CodeChange: check the service interval settings when changing of all vehicle-types. To simplify things introduce GetServiceIntervalClamped() that returns the same or clamped value of the new service interval. There were some inconsistencies in the gui files so I had to change those, and const correctness kicked in, so it's a bit messy at certain points.
Darkvater
parents:
1786
diff
changeset
|
474 |
* @param p2 new service interval |
47963a0cfca3
(svn r2294) - CodeChange: check the service interval settings when changing of all vehicle-types. To simplify things introduce GetServiceIntervalClamped() that returns the same or clamped value of the new service interval. There were some inconsistencies in the gui files so I had to change those, and const correctness kicked in, so it's a bit messy at certain points.
Darkvater
parents:
1786
diff
changeset
|
475 |
*/ |
0 | 476 |
int32 CmdChangeAircraftServiceInt(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
477 |
{ |
|
478 |
Vehicle *v; |
|
1790
47963a0cfca3
(svn r2294) - CodeChange: check the service interval settings when changing of all vehicle-types. To simplify things introduce GetServiceIntervalClamped() that returns the same or clamped value of the new service interval. There were some inconsistencies in the gui files so I had to change those, and const correctness kicked in, so it's a bit messy at certain points.
Darkvater
parents:
1786
diff
changeset
|
479 |
uint16 serv_int = GetServiceIntervalClamped(p2); /* Double check the service interval from the user-input */ |
0 | 480 |
|
1790
47963a0cfca3
(svn r2294) - CodeChange: check the service interval settings when changing of all vehicle-types. To simplify things introduce GetServiceIntervalClamped() that returns the same or clamped value of the new service interval. There were some inconsistencies in the gui files so I had to change those, and const correctness kicked in, so it's a bit messy at certain points.
Darkvater
parents:
1786
diff
changeset
|
481 |
if (serv_int != p2 || !IsVehicleIndex(p1)) return CMD_ERROR; |
1237
1c7a3f9c94b9
(svn r1741) - Fix: added IsVehicleIndex() so it's possible to protect GetVehicle() from reading an invalid vehicle index
bjarni
parents:
1235
diff
changeset
|
482 |
|
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
483 |
v = GetVehicle(p1); |
0 | 484 |
|
1790
47963a0cfca3
(svn r2294) - CodeChange: check the service interval settings when changing of all vehicle-types. To simplify things introduce GetServiceIntervalClamped() that returns the same or clamped value of the new service interval. There were some inconsistencies in the gui files so I had to change those, and const correctness kicked in, so it's a bit messy at certain points.
Darkvater
parents:
1786
diff
changeset
|
485 |
if (v->type != VEH_Aircraft || !CheckOwnership(v->owner)) return CMD_ERROR; |
0 | 486 |
|
487 |
if (flags & DC_EXEC) { |
|
1790
47963a0cfca3
(svn r2294) - CodeChange: check the service interval settings when changing of all vehicle-types. To simplify things introduce GetServiceIntervalClamped() that returns the same or clamped value of the new service interval. There were some inconsistencies in the gui files so I had to change those, and const correctness kicked in, so it's a bit messy at certain points.
Darkvater
parents:
1786
diff
changeset
|
488 |
v->service_interval = serv_int; |
0 | 489 |
InvalidateWindowWidget(WC_VEHICLE_DETAILS, v->index, 7); |
490 |
} |
|
491 |
||
492 |
return 0; |
|
493 |
} |
|
494 |
||
1802
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
495 |
/** Refits an aircraft to the specified cargo type. |
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
496 |
* @param x,y unused |
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
497 |
* @param p1 vehicle ID of the aircraft to refit |
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
498 |
* @param p2 various bitstuffed elements |
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
499 |
* - p2 = (bit 0-7) - the new cargo type to refit to (p2 & 0xFF) |
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
500 |
* - p2 = (bit 8) - skip check for stopped in hangar, used by autoreplace (p2 & 0x100) |
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
501 |
* @todo p2 bit8 check <b>NEEDS TO GO</b> |
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
502 |
*/ |
0 | 503 |
int32 CmdRefitAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
504 |
{ |
|
1802
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
505 |
Vehicle *v; |
0 | 506 |
int pass, mail; |
507 |
int32 cost; |
|
1802
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
508 |
bool SkipStoppedInHangerCheck = !!HASBIT(p2, 8); // XXX - needs to go, yes? |
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
509 |
CargoID new_cid = p2 & 0xFF; //gets the cargo number |
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
510 |
const AircraftVehicleInfo *avi; |
0 | 511 |
|
1237
1c7a3f9c94b9
(svn r1741) - Fix: added IsVehicleIndex() so it's possible to protect GetVehicle() from reading an invalid vehicle index
bjarni
parents:
1235
diff
changeset
|
512 |
if (!IsVehicleIndex(p1)) return CMD_ERROR; |
0 | 513 |
|
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
514 |
v = GetVehicle(p1); |
1237
1c7a3f9c94b9
(svn r1741) - Fix: added IsVehicleIndex() so it's possible to protect GetVehicle() from reading an invalid vehicle index
bjarni
parents:
1235
diff
changeset
|
515 |
|
1802
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
516 |
if (v->type != VEH_Aircraft || !CheckOwnership(v->owner)) return CMD_ERROR; |
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
517 |
if (!SkipStoppedInHangerCheck && !CheckStoppedInHangar(v)) return_cmd_error(STR_A01B_AIRCRAFT_MUST_BE_STOPPED); |
1237
1c7a3f9c94b9
(svn r1741) - Fix: added IsVehicleIndex() so it's possible to protect GetVehicle() from reading an invalid vehicle index
bjarni
parents:
1235
diff
changeset
|
518 |
|
924
6fbd4419db2a
(svn r1412) -Feature/Fix: Aircraft refit options have been restricted to "sane"
celestar
parents:
922
diff
changeset
|
519 |
avi = AircraftVehInfo(v->engine_type); |
1237
1c7a3f9c94b9
(svn r1741) - Fix: added IsVehicleIndex() so it's possible to protect GetVehicle() from reading an invalid vehicle index
bjarni
parents:
1235
diff
changeset
|
520 |
|
1802
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
521 |
/* Check cargo */ |
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
522 |
if (new_cid > NUM_CARGO || !CanRefitTo(v, new_cid)) return CMD_ERROR; |
0 | 523 |
|
1237
1c7a3f9c94b9
(svn r1741) - Fix: added IsVehicleIndex() so it's possible to protect GetVehicle() from reading an invalid vehicle index
bjarni
parents:
1235
diff
changeset
|
524 |
SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN); |
1c7a3f9c94b9
(svn r1741) - Fix: added IsVehicleIndex() so it's possible to protect GetVehicle() from reading an invalid vehicle index
bjarni
parents:
1235
diff
changeset
|
525 |
|
1802
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
526 |
switch (new_cid) { |
924
6fbd4419db2a
(svn r1412) -Feature/Fix: Aircraft refit options have been restricted to "sane"
celestar
parents:
922
diff
changeset
|
527 |
case CT_PASSENGERS: |
6fbd4419db2a
(svn r1412) -Feature/Fix: Aircraft refit options have been restricted to "sane"
celestar
parents:
922
diff
changeset
|
528 |
pass = avi->passenger_capacity; |
6fbd4419db2a
(svn r1412) -Feature/Fix: Aircraft refit options have been restricted to "sane"
celestar
parents:
922
diff
changeset
|
529 |
break; |
6fbd4419db2a
(svn r1412) -Feature/Fix: Aircraft refit options have been restricted to "sane"
celestar
parents:
922
diff
changeset
|
530 |
case CT_MAIL: |
6fbd4419db2a
(svn r1412) -Feature/Fix: Aircraft refit options have been restricted to "sane"
celestar
parents:
922
diff
changeset
|
531 |
pass = avi->passenger_capacity + avi->mail_capacity; |
6fbd4419db2a
(svn r1412) -Feature/Fix: Aircraft refit options have been restricted to "sane"
celestar
parents:
922
diff
changeset
|
532 |
break; |
6fbd4419db2a
(svn r1412) -Feature/Fix: Aircraft refit options have been restricted to "sane"
celestar
parents:
922
diff
changeset
|
533 |
case CT_GOODS: |
6fbd4419db2a
(svn r1412) -Feature/Fix: Aircraft refit options have been restricted to "sane"
celestar
parents:
922
diff
changeset
|
534 |
pass = avi->passenger_capacity + avi->mail_capacity; |
6fbd4419db2a
(svn r1412) -Feature/Fix: Aircraft refit options have been restricted to "sane"
celestar
parents:
922
diff
changeset
|
535 |
pass /= 2; |
6fbd4419db2a
(svn r1412) -Feature/Fix: Aircraft refit options have been restricted to "sane"
celestar
parents:
922
diff
changeset
|
536 |
break; |
6fbd4419db2a
(svn r1412) -Feature/Fix: Aircraft refit options have been restricted to "sane"
celestar
parents:
922
diff
changeset
|
537 |
default: |
6fbd4419db2a
(svn r1412) -Feature/Fix: Aircraft refit options have been restricted to "sane"
celestar
parents:
922
diff
changeset
|
538 |
pass = avi->passenger_capacity + avi->mail_capacity; |
6fbd4419db2a
(svn r1412) -Feature/Fix: Aircraft refit options have been restricted to "sane"
celestar
parents:
922
diff
changeset
|
539 |
pass /= 4; |
6fbd4419db2a
(svn r1412) -Feature/Fix: Aircraft refit options have been restricted to "sane"
celestar
parents:
922
diff
changeset
|
540 |
break; |
0 | 541 |
} |
542 |
_aircraft_refit_capacity = pass; |
|
543 |
||
544 |
cost = 0; |
|
1802
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
545 |
if (IS_HUMAN_PLAYER(v->owner) && new_cid != v->cargo_type) { |
0 | 546 |
cost = _price.aircraft_base >> 7; |
547 |
} |
|
548 |
||
549 |
if (flags & DC_EXEC) { |
|
1802
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
550 |
Vehicle *u; |
0 | 551 |
v->cargo_cap = pass; |
552 |
||
553 |
u = v->next; |
|
1802
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
554 |
mail = (new_cid != CT_PASSENGERS) ? 0 : avi->mail_capacity; |
0 | 555 |
u->cargo_cap = mail; |
842 | 556 |
//autorefitted planes wants to keep the cargo |
557 |
//it will be checked if the cargo is valid in CmdReplaceVehicle |
|
558 |
if (!(SkipStoppedInHangerCheck)) |
|
559 |
v->cargo_count = u->cargo_count = 0; |
|
1802
da61740cc1e7
(svn r2306) - CodeChange: Check the last commands; refits. This needed an extensive rewrite and global/local-cargo ID juggling and bitmasking. However with this done it looks better as well and is compatible with newgrf handling. Big thanks to HackyKid for doing most of the work. This also closes patch "[ 1199277 ] Command checks"
Darkvater
parents:
1793
diff
changeset
|
560 |
v->cargo_type = new_cid; |
0 | 561 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
562 |
} |
|
563 |
||
564 |
return cost; |
|
565 |
} |
|
566 |
||
567 |
void HandleClickOnAircraft(Vehicle *v) |
|
568 |
{ |
|
569 |
ShowAircraftViewWindow(v); |
|
570 |
} |
|
571 |
||
572 |
static void CheckIfAircraftNeedsService(Vehicle *v) |
|
573 |
{ |
|
574 |
Station *st; |
|
575 |
||
76
30511cbc5188
(svn r77) -Fix: [1010788] AI service interval bug (tnx truesatan)
truelight
parents:
70
diff
changeset
|
576 |
if (_patches.servint_aircraft == 0) |
11
836bc4b37b5b
(svn r12) Change: removed patch no_train_service. Instead you can set the default service interval for any vehicle type to 'disabled'.
dominik
parents:
0
diff
changeset
|
577 |
return; |
836bc4b37b5b
(svn r12) Change: removed patch no_train_service. Instead you can set the default service interval for any vehicle type to 'disabled'.
dominik
parents:
0
diff
changeset
|
578 |
|
593 | 579 |
if (!VehicleNeedsService(v)) |
0 | 580 |
return; |
581 |
||
582 |
if (v->vehstatus & VS_STOPPED) |
|
583 |
return; |
|
584 |
||
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
585 |
if (v->current_order.type == OT_GOTO_DEPOT && |
1530
2b46869fc0d4
(svn r2034) -Codechange: Replaced the rather meaningless LOAD and UNLOAD flags for depots by something more meaningful
celestar
parents:
1520
diff
changeset
|
586 |
v->current_order.flags & OF_HALT_IN_DEPOT) |
0 | 587 |
return; |
588 |
||
1024
5e446b5b3ec5
(svn r1525) -Codechange: rewrote the _order_array, now it can be made dynamic.
truelight
parents:
1020
diff
changeset
|
589 |
if (_patches.gotodepot && VehicleHasDepotOrders(v)) |
0 | 590 |
return; |
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
591 |
|
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
592 |
st = GetStation(v->current_order.station); |
0 | 593 |
// only goto depot if the target airport has terminals (eg. it is airport) |
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
594 |
if (st->xy != 0 && st->airport_tile != 0 && GetAirport(st->airport_type)->terminals != NULL) { |
0 | 595 |
// printf("targetairport = %d, st->index = %d\n", v->u.air.targetairport, st->index); |
596 |
// v->u.air.targetairport = st->index; |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
597 |
v->current_order.type = OT_GOTO_DEPOT; |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
598 |
v->current_order.flags = OF_NON_STOP; |
755
80091de50044
(svn r1211) -Feature: Introduce sticky windows to all vehicle windows...Just make sure you do not sticky more than 23 at a time. Also a lot of places in the code invalidated the 'status bar' of the vehicle, referring to it as widget 4. This is now widget 5 and has been #definitized
darkvater
parents:
699
diff
changeset
|
599 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR); |
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
600 |
} else if (v->current_order.type == OT_GOTO_DEPOT) { |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
601 |
v->current_order.type = OT_DUMMY; |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
602 |
v->current_order.flags = 0; |
755
80091de50044
(svn r1211) -Feature: Introduce sticky windows to all vehicle windows...Just make sure you do not sticky more than 23 at a time. Also a lot of places in the code invalidated the 'status bar' of the vehicle, referring to it as widget 4. This is now widget 5 and has been #definitized
darkvater
parents:
699
diff
changeset
|
603 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR); |
0 | 604 |
} |
605 |
} |
|
606 |
||
607 |
void OnNewDay_Aircraft(Vehicle *v) |
|
608 |
{ |
|
609 |
int32 cost; |
|
610 |
||
611 |
if (v->subtype > 2) |
|
612 |
return; |
|
613 |
||
614 |
if ((++v->day_counter & 7) == 0) |
|
615 |
DecreaseVehicleValue(v); |
|
616 |
||
1053
8d90844ddc2e
(svn r1554) -Fix: [ 1103187 ] Order Check messages are now validated before
celestar
parents:
1043
diff
changeset
|
617 |
CheckOrders(v->index, OC_INIT); |
19
6080d2b6a959
(svn r20) Feature: warning when a vehicle has invalid orders (celestar)
dominik
parents:
11
diff
changeset
|
618 |
|
0 | 619 |
CheckVehicleBreakdown(v); |
620 |
AgeVehicle(v); |
|
621 |
CheckIfAircraftNeedsService(v); |
|
622 |
||
623 |
if (v->vehstatus & VS_STOPPED) |
|
624 |
return; |
|
625 |
||
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
626 |
cost = AircraftVehInfo(v->engine_type)->running_cost * _price.aircraft_running / 364; |
0 | 627 |
|
628 |
v->profit_this_year -= cost >> 8; |
|
629 |
||
630 |
SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN); |
|
631 |
SubtractMoneyFromPlayerFract(v->owner, cost); |
|
632 |
||
633 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
|
1055
cc4f60cc9102
(svn r1556) -Fix: Vehicle list updates should now really work
Celestar
parents:
1053
diff
changeset
|
634 |
InvalidateWindowClasses(WC_AIRCRAFT_LIST); |
0 | 635 |
} |
636 |
||
1093
4fdc46eaf423
(svn r1594) Convert all undefined parameter lists to (void) and add the appropriate warning flags in the Makefile
tron
parents:
1064
diff
changeset
|
637 |
void AircraftYearlyLoop(void) |
0 | 638 |
{ |
639 |
Vehicle *v; |
|
640 |
||
641 |
FOR_ALL_VEHICLES(v) { |
|
642 |
if (v->type == VEH_Aircraft && v->subtype <= 2) { |
|
643 |
v->profit_last_year = v->profit_this_year; |
|
644 |
v->profit_this_year = 0; |
|
645 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
|
646 |
} |
|
647 |
} |
|
648 |
} |
|
649 |
||
650 |
static void AgeAircraftCargo(Vehicle *v) |
|
651 |
{ |
|
652 |
if (_age_cargo_skip_counter != 0) |
|
653 |
return; |
|
654 |
||
655 |
do { |
|
656 |
if (v->cargo_days != 0xFF) |
|
657 |
v->cargo_days++; |
|
658 |
} while ( (v=v->next) != NULL ); |
|
659 |
} |
|
660 |
||
661 |
static void HelicopterTickHandler(Vehicle *v) |
|
662 |
{ |
|
663 |
Vehicle *u; |
|
664 |
int tick,spd; |
|
665 |
uint16 img; |
|
666 |
||
667 |
u = v->next->next; |
|
668 |
||
669 |
if (u->vehstatus & VS_HIDDEN) |
|
670 |
return; |
|
671 |
||
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
672 |
// if true, helicopter rotors do not rotate. This should only be the case if a helicopter is |
0 | 673 |
// loading/unloading at a terminal or stopped |
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
674 |
if (v->current_order.type == OT_LOADING || (v->vehstatus & VS_STOPPED)) { |
0 | 675 |
if (u->cur_speed != 0) { |
676 |
u->cur_speed++; |
|
677 |
if (u->cur_speed >= 0x80 && u->cur_image == 0xF40) { |
|
678 |
u->cur_speed = 0; |
|
679 |
} |
|
680 |
} |
|
681 |
} else { |
|
682 |
if (u->cur_speed == 0) |
|
683 |
u->cur_speed = 0x70; |
|
684 |
||
685 |
if (u->cur_speed >= 0x50) |
|
686 |
u->cur_speed--; |
|
687 |
} |
|
688 |
||
689 |
tick = ++u->tick_counter; |
|
690 |
spd = u->cur_speed >> 4; |
|
691 |
||
692 |
if (spd == 0) { |
|
693 |
img = 0xF3D; |
|
694 |
if (u->cur_image == img) |
|
695 |
return; |
|
696 |
} else if (tick >= spd) { |
|
697 |
u->tick_counter = 0; |
|
698 |
img = u->cur_image + 1; |
|
699 |
if (img > 0xF40) |
|
700 |
img = 0xF3E; |
|
701 |
} else |
|
702 |
return; |
|
703 |
||
704 |
u->cur_image=img; |
|
705 |
||
706 |
BeginVehicleMove(u); |
|
707 |
VehiclePositionChanged(u); |
|
708 |
EndVehicleMove(u); |
|
709 |
} |
|
710 |
||
711 |
static void SetAircraftPosition(Vehicle *v, int x, int y, int z) |
|
712 |
{ |
|
713 |
Vehicle *u; |
|
714 |
int yt; |
|
715 |
||
716 |
v->x_pos = x; |
|
717 |
v->y_pos = y; |
|
718 |
v->z_pos = z; |
|
719 |
||
720 |
v->cur_image = GetAircraftImage(v, v->direction); |
|
721 |
||
722 |
BeginVehicleMove(v); |
|
723 |
VehiclePositionChanged(v); |
|
724 |
EndVehicleMove(v); |
|
725 |
||
726 |
u = v->next; |
|
727 |
||
728 |
yt = y - ((v->z_pos-GetSlopeZ(x, y-1)) >> 3); |
|
729 |
u->x_pos = x; |
|
730 |
u->y_pos = yt; |
|
731 |
u->z_pos = GetSlopeZ(x,yt); |
|
732 |
u->cur_image = v->cur_image; |
|
733 |
||
734 |
BeginVehicleMove(u); |
|
735 |
VehiclePositionChanged(u); |
|
736 |
EndVehicleMove(u); |
|
737 |
||
738 |
if ((u=u->next) != NULL) { |
|
739 |
u->x_pos = x; |
|
740 |
u->y_pos = y; |
|
741 |
u->z_pos = z + 5; |
|
742 |
||
743 |
BeginVehicleMove(u); |
|
744 |
VehiclePositionChanged(u); |
|
745 |
EndVehicleMove(u); |
|
746 |
} |
|
747 |
} |
|
748 |
||
749 |
static void ServiceAircraft(Vehicle *v) |
|
750 |
{ |
|
751 |
Vehicle *u; |
|
752 |
||
753 |
v->cur_speed = 0; |
|
754 |
v->subspeed = 0; |
|
755 |
v->progress = 0; |
|
756 |
v->vehstatus |= VS_HIDDEN; |
|
757 |
||
758 |
u = v->next; |
|
759 |
u->vehstatus |= VS_HIDDEN; |
|
760 |
if ((u=u->next) != NULL) { |
|
761 |
u->vehstatus |= VS_HIDDEN; |
|
762 |
u->cur_speed = 0; |
|
763 |
} |
|
764 |
||
765 |
SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos); |
|
766 |
InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); |
|
767 |
||
578
1e66514eb621
(svn r998) now vehicles are serviced both when entering and when leaving depots to prevent that vehicles might need service when leaving after a long stay (ln--)
bjarni
parents:
555
diff
changeset
|
768 |
VehicleServiceInDepot(v); |
0 | 769 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
770 |
} |
|
771 |
||
772 |
static void PlayAircraftSound(Vehicle *v) |
|
773 |
{ |
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
774 |
SndPlayVehicleFx(AircraftVehInfo(v->engine_type)->sfx, v); |
0 | 775 |
} |
776 |
||
777 |
static bool UpdateAircraftSpeed(Vehicle *v) |
|
778 |
{ |
|
779 |
uint spd = v->acceleration * 2; |
|
780 |
byte t; |
|
781 |
||
782 |
v->subspeed = (t=v->subspeed) + (byte)spd; |
|
783 |
spd = min( v->cur_speed + (spd >> 8) + (v->subspeed < t), v->max_speed); |
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
784 |
|
0 | 785 |
// adjust speed for broken vehicles |
786 |
if(v->vehstatus&VS_AIRCRAFT_BROKEN) spd = min(spd, 27); |
|
787 |
||
788 |
//updates statusbar only if speed have changed to save CPU time |
|
789 |
if (spd != v->cur_speed) { |
|
790 |
v->cur_speed = spd; |
|
791 |
if (_patches.vehicle_speed) |
|
755
80091de50044
(svn r1211) -Feature: Introduce sticky windows to all vehicle windows...Just make sure you do not sticky more than 23 at a time. Also a lot of places in the code invalidated the 'status bar' of the vehicle, referring to it as widget 4. This is now widget 5 and has been #definitized
darkvater
parents:
699
diff
changeset
|
792 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR); |
0 | 793 |
} |
794 |
||
795 |
if (!(v->direction & 1)) { |
|
796 |
spd = spd * 3 >> 2; |
|
797 |
} |
|
798 |
||
799 |
if (spd == 0) |
|
800 |
return false; |
|
801 |
||
802 |
if ((byte)++spd == 0) |
|
803 |
return true; |
|
804 |
||
805 |
v->progress = (t = v->progress) - (byte)spd; |
|
806 |
||
807 |
return (t < v->progress); |
|
808 |
} |
|
809 |
||
810 |
// get Aircraft running altitude |
|
811 |
static byte GetAircraftFlyingAltitude(const Vehicle *v) |
|
812 |
{ |
|
1897 | 813 |
switch (v->max_speed) { |
814 |
case 37: return 162; |
|
815 |
case 74: return 171; |
|
816 |
default: return 180; |
|
0 | 817 |
} |
818 |
} |
|
819 |
||
1401
44a7e0f04d28
(svn r1905) - Fix: [ 1118810 ] openttd: ship_cmd.c:642 ... Assertion failed. Mapwrap fixed in ship_cmd.c (was implicitely ok before biggermaps).
Darkvater
parents:
1359
diff
changeset
|
820 |
static bool AircraftController(Vehicle *v) |
0 | 821 |
{ |
822 |
Station *st; |
|
823 |
const AirportMovingData *amd; |
|
824 |
Vehicle *u; |
|
825 |
byte z,dirdiff,newdir,maxz,curz; |
|
826 |
GetNewVehiclePosResult gp; |
|
827 |
uint dist; |
|
828 |
int x,y; |
|
829 |
||
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
830 |
st = GetStation(v->u.air.targetairport); |
0 | 831 |
|
832 |
// prevent going to 0,0 if airport is deleted. |
|
833 |
{ |
|
1977
37bbebf94434
(svn r2483) Replace almost 500 "uint tile" (and variants) with "TileIndex tile"
tron
parents:
1926
diff
changeset
|
834 |
TileIndex tile = st->airport_tile; |
37bbebf94434
(svn r2483) Replace almost 500 "uint tile" (and variants) with "TileIndex tile"
tron
parents:
1926
diff
changeset
|
835 |
|
0 | 836 |
if (tile == 0) tile = st->xy; |
837 |
// xy of destination |
|
926
a6d140a6a4de
(svn r1414) Move TileIndex, TILE_MASK and GET_TILE_[XY] to map.h and turn the latter into inline functions names Tile[XY]
tron
parents:
924
diff
changeset
|
838 |
x = TileX(tile) * 16; |
a6d140a6a4de
(svn r1414) Move TileIndex, TILE_MASK and GET_TILE_[XY] to map.h and turn the latter into inline functions names Tile[XY]
tron
parents:
924
diff
changeset
|
839 |
y = TileY(tile) * 16; |
0 | 840 |
} |
841 |
||
842 |
// get airport moving data |
|
843 |
assert(v->u.air.pos < GetAirport(st->airport_type)->nofelements); |
|
844 |
amd = &_airport_moving_datas[st->airport_type][v->u.air.pos]; |
|
845 |
||
846 |
// Helicopter raise |
|
847 |
if (amd->flag & AMED_HELI_RAISE) { |
|
848 |
u = v->next->next; |
|
849 |
||
850 |
// Make sure the rotors don't rotate too fast |
|
851 |
if (u->cur_speed > 32) { |
|
852 |
v->cur_speed = 0; |
|
853 |
if (--u->cur_speed == 32) { |
|
541 | 854 |
SndPlayVehicleFx(SND_18_HELICOPTER, v); |
0 | 855 |
} |
856 |
} else { |
|
857 |
u->cur_speed = 32; |
|
858 |
if (UpdateAircraftSpeed(v)) { |
|
859 |
v->tile = 0; |
|
860 |
||
861 |
// Reached altitude? |
|
862 |
if (v->z_pos >= 184) { |
|
863 |
v->cur_speed = 0; |
|
864 |
return true; |
|
865 |
} |
|
866 |
SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos+1); |
|
867 |
} |
|
868 |
} |
|
869 |
return false; |
|
870 |
} |
|
871 |
||
872 |
// Helicopter landing. |
|
873 |
if (amd->flag & AMED_HELI_LOWER) { |
|
874 |
if (UpdateAircraftSpeed(v)) { |
|
875 |
if (st->airport_tile == 0) { |
|
1401
44a7e0f04d28
(svn r1905) - Fix: [ 1118810 ] openttd: ship_cmd.c:642 ... Assertion failed. Mapwrap fixed in ship_cmd.c (was implicitely ok before biggermaps).
Darkvater
parents:
1359
diff
changeset
|
876 |
// FIXME - AircraftController -> if station no longer exists, do not land |
0 | 877 |
// helicopter will circle until sign disappears, then go to next order |
878 |
// * what to do when it is the only order left, right now it just stays in 1 place |
|
879 |
v->u.air.state = FLYING; |
|
880 |
AircraftNextAirportPos_and_Order(v); |
|
881 |
return false; |
|
882 |
} |
|
883 |
||
884 |
// Vehicle is now at the airport. |
|
885 |
v->tile = st->airport_tile; |
|
886 |
||
887 |
// Find altitude of landing position. |
|
888 |
z = GetSlopeZ(x, y) + 1; |
|
889 |
if (st->airport_type == AT_OILRIG) z += 54; |
|
890 |
if (st->airport_type == AT_HELIPORT) z += 60; |
|
891 |
||
892 |
if (z == v->z_pos) { |
|
893 |
u = v->next->next; |
|
894 |
||
895 |
// Increase speed of rotors. When speed is 80, we've landed. |
|
896 |
if (u->cur_speed >= 80) |
|
897 |
return true; |
|
898 |
u->cur_speed+=4; |
|
899 |
} else if (v->z_pos > z) { |
|
900 |
SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos-1); |
|
901 |
} else { |
|
902 |
SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos+1); |
|
903 |
} |
|
904 |
} |
|
905 |
return false; |
|
906 |
} |
|
907 |
||
908 |
// Get distance from destination pos to current pos. |
|
909 |
dist = myabs(x + amd->x - v->x_pos) + myabs(y + amd->y - v->y_pos); |
|
910 |
||
911 |
// Need exact position? |
|
2133 | 912 |
if (!(amd->flag & AMED_EXACTPOS) && dist <= (amd->flag & AMED_SLOWTURN ? 8 : 4)) |
0 | 913 |
return true; |
914 |
||
915 |
// At final pos? |
|
916 |
if (dist == 0) { |
|
917 |
||
918 |
// Clamp speed to 12. |
|
919 |
if (v->cur_speed > 12) |
|
920 |
v->cur_speed = 12; |
|
921 |
||
922 |
// Change direction smoothly to final direction. |
|
923 |
dirdiff = amd->direction - v->direction; |
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
924 |
// if distance is 0, and plane points in right direction, no point in calling |
0 | 925 |
// UpdateAircraftSpeed(). So do it only afterwards |
926 |
if (dirdiff == 0) { |
|
927 |
v->cur_speed = 0; |
|
928 |
return true; |
|
929 |
} |
|
930 |
||
931 |
if (!UpdateAircraftSpeed(v)) |
|
932 |
return false; |
|
933 |
||
934 |
v->direction = (v->direction+((dirdiff&7)<5?1:-1)) & 7; |
|
935 |
v->cur_speed >>= 1; |
|
936 |
||
937 |
SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos); |
|
938 |
return false; |
|
939 |
} |
|
940 |
||
941 |
// Clamp speed? |
|
942 |
if (!(amd->flag & AMED_NOSPDCLAMP) && v->cur_speed > 12) |
|
943 |
v->cur_speed = 12; |
|
944 |
||
945 |
if (!UpdateAircraftSpeed(v)) |
|
946 |
return false; |
|
947 |
||
948 |
// Decrease animation counter. |
|
949 |
if (v->load_unload_time_rem != 0) |
|
950 |
v->load_unload_time_rem--; |
|
951 |
||
952 |
// Turn. Do it slowly if in the air. |
|
953 |
newdir = GetDirectionTowards(v, x + amd->x, y + amd->y); |
|
954 |
if (newdir != v->direction) { |
|
955 |
if (amd->flag & AMED_SLOWTURN) { |
|
956 |
if (v->load_unload_time_rem == 0) { |
|
957 |
v->load_unload_time_rem = 8; |
|
958 |
} |
|
99 | 959 |
v->direction = newdir; |
0 | 960 |
} else { |
961 |
v->cur_speed >>= 1; |
|
962 |
v->direction = newdir; |
|
963 |
} |
|
964 |
} |
|
965 |
||
966 |
// Move vehicle. |
|
967 |
GetNewVehiclePos(v, &gp); |
|
968 |
v->tile = gp.new_tile; |
|
969 |
||
970 |
// If vehicle is in the air, use tile coordinate 0. |
|
971 |
if (amd->flag & (AMED_TAKEOFF | AMED_SLOWTURN | AMED_LAND)) { |
|
972 |
v->tile = 0; |
|
973 |
} |
|
974 |
||
975 |
// Adjust Z for land or takeoff? |
|
976 |
z = v->z_pos; |
|
977 |
||
978 |
if (amd->flag & AMED_TAKEOFF) { |
|
979 |
z+=2; |
|
980 |
// Determine running altitude |
|
981 |
maxz = GetAircraftFlyingAltitude(v); |
|
982 |
if (z > maxz) |
|
983 |
z = maxz; |
|
984 |
} |
|
985 |
||
986 |
if (amd->flag & AMED_LAND) { |
|
987 |
if (st->airport_tile == 0) { |
|
988 |
v->u.air.state = FLYING; |
|
989 |
AircraftNextAirportPos_and_Order(v); |
|
990 |
// get aircraft back on running altitude |
|
991 |
SetAircraftPosition(v, gp.x, gp.y, GetAircraftFlyingAltitude(v)); |
|
992 |
return false; |
|
993 |
} |
|
994 |
||
995 |
curz = GetSlopeZ(x, y) + 1; |
|
996 |
||
997 |
if (curz > z) { |
|
998 |
z++; |
|
999 |
} else { |
|
1000 |
int t = max(1, dist-4); |
|
1001 |
||
1002 |
z -= ((z - curz) + t - 1) / t; |
|
1003 |
if (z < curz) z = curz; |
|
1004 |
} |
|
1005 |
} |
|
1006 |
||
1007 |
// We've landed. Decrase speed when we're reaching end of runway. |
|
1008 |
if (amd->flag & AMED_BRAKE) { |
|
1009 |
curz = GetSlopeZ(x, y) + 1; |
|
1010 |
||
1011 |
if (z > curz) z--; |
|
1012 |
else if (z < curz) z++; |
|
1013 |
||
1014 |
if (dist < 64 && v->cur_speed > 12) |
|
1015 |
v->cur_speed -= 4; |
|
1016 |
} |
|
1017 |
||
1018 |
SetAircraftPosition(v, gp.x, gp.y, z); |
|
1019 |
return false; |
|
1020 |
} |
|
1021 |
||
1022 |
static const int8 _crashed_aircraft_moddir[4] = { |
|
1023 |
-1,0,0,1 |
|
1024 |
}; |
|
1025 |
||
1026 |
static void HandleCrashedAircraft(Vehicle *v) |
|
1027 |
{ |
|
1028 |
uint32 r; |
|
1029 |
Station *st; |
|
899
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1030 |
int z; |
0 | 1031 |
|
1032 |
v->u.air.crashed_counter++; |
|
1033 |
||
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
1034 |
st = GetStation(v->u.air.targetairport); |
899
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1035 |
|
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1036 |
// make aircraft crash down to the ground |
1150
7b5946a53372
(svn r1651) Fix: [ 1098696 ] Airport shadow remains after crashing
dominik
parents:
1139
diff
changeset
|
1037 |
if (v->u.air.crashed_counter < 500 && st->airport_tile==0 && ((v->u.air.crashed_counter % 3) == 0) ) { |
7b5946a53372
(svn r1651) Fix: [ 1098696 ] Airport shadow remains after crashing
dominik
parents:
1139
diff
changeset
|
1038 |
z = GetSlopeZ(v->x_pos, v->y_pos); |
899
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1039 |
v->z_pos -= 1; |
1150
7b5946a53372
(svn r1651) Fix: [ 1098696 ] Airport shadow remains after crashing
dominik
parents:
1139
diff
changeset
|
1040 |
if (v->z_pos == z) { |
7b5946a53372
(svn r1651) Fix: [ 1098696 ] Airport shadow remains after crashing
dominik
parents:
1139
diff
changeset
|
1041 |
v->u.air.crashed_counter = 500; |
7b5946a53372
(svn r1651) Fix: [ 1098696 ] Airport shadow remains after crashing
dominik
parents:
1139
diff
changeset
|
1042 |
v->z_pos++; |
7b5946a53372
(svn r1651) Fix: [ 1098696 ] Airport shadow remains after crashing
dominik
parents:
1139
diff
changeset
|
1043 |
} |
899
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1044 |
} |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1045 |
|
0 | 1046 |
if (v->u.air.crashed_counter < 650) { |
1047 |
if (CHANCE16R(1,32,r)) { |
|
2140
a04d0142ad65
(svn r2650) Convert many explicit shifts+ands to extract bits to invocations of GB - should be a bit nicer to read
tron
parents:
2133
diff
changeset
|
1048 |
v->direction = (v->direction + _crashed_aircraft_moddir[GB(r, 16, 2)]) & 7; |
0 | 1049 |
SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos); |
1050 |
r = Random(); |
|
1051 |
CreateEffectVehicleRel(v, |
|
2140
a04d0142ad65
(svn r2650) Convert many explicit shifts+ands to extract bits to invocations of GB - should be a bit nicer to read
tron
parents:
2133
diff
changeset
|
1052 |
GB(r, 0, 4) + 4, |
a04d0142ad65
(svn r2650) Convert many explicit shifts+ands to extract bits to invocations of GB - should be a bit nicer to read
tron
parents:
2133
diff
changeset
|
1053 |
GB(r, 4, 4) + 4, |
a04d0142ad65
(svn r2650) Convert many explicit shifts+ands to extract bits to invocations of GB - should be a bit nicer to read
tron
parents:
2133
diff
changeset
|
1054 |
GB(r, 8, 4), |
1359
52782e5cf7c9
(svn r1863) Give the effect vehicle type enums more descriptive names and use the enum as parameter type for CreateEffectVehicle*()
tron
parents:
1299
diff
changeset
|
1055 |
EV_EXPLOSION_SMALL); |
0 | 1056 |
} |
1057 |
} else if (v->u.air.crashed_counter >= 10000) { |
|
1058 |
// remove rubble of crashed airplane |
|
1059 |
||
1060 |
// clear runway-in on all airports, set by crashing plane |
|
1061 |
// small airports use AIRPORT_BUSY, city airports use RUNWAY_IN_OUT_block, etc. |
|
1062 |
// but they all share the same number |
|
1063 |
CLRBITS(st->airport_flags, RUNWAY_IN_block); |
|
1064 |
||
1065 |
BeginVehicleMove(v); |
|
1066 |
EndVehicleMove(v); |
|
1067 |
||
1068 |
DoDeleteAircraft(v); |
|
1069 |
} |
|
1070 |
} |
|
1071 |
||
1072 |
static void HandleBrokenAircraft(Vehicle *v) |
|
1073 |
{ |
|
1074 |
if (v->breakdown_ctr != 1) { |
|
1075 |
v->breakdown_ctr = 1; |
|
1076 |
v->vehstatus |= VS_AIRCRAFT_BROKEN; |
|
1077 |
||
1078 |
if (v->breakdowns_since_last_service != 255) |
|
1079 |
v->breakdowns_since_last_service++; |
|
1080 |
InvalidateWindow(WC_VEHICLE_VIEW, v->index); |
|
1081 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
|
1082 |
} |
|
1083 |
} |
|
1084 |
||
1085 |
static const int8 _aircraft_smoke_xy[16] = { |
|
1086 |
5,6,5,0,-5,-6,-5,0, /* x coordinates */ |
|
1087 |
5,0,-5,-6,-5,0,5,6, /* y coordinate */ |
|
1088 |
}; |
|
1089 |
||
1090 |
static void HandleAircraftSmoke(Vehicle *v) |
|
1091 |
{ |
|
1092 |
if (!(v->vehstatus&VS_AIRCRAFT_BROKEN)) |
|
1093 |
return; |
|
1094 |
||
1095 |
if (v->cur_speed < 10) { |
|
1096 |
v->vehstatus &= ~VS_AIRCRAFT_BROKEN; |
|
1097 |
v->breakdown_ctr = 0; |
|
1098 |
return; |
|
1099 |
} |
|
1100 |
||
1101 |
if ((v->tick_counter & 0x1F) == 0) { |
|
1102 |
CreateEffectVehicleRel(v, |
|
1103 |
_aircraft_smoke_xy[v->direction], |
|
1104 |
_aircraft_smoke_xy[v->direction + 8], |
|
1105 |
2, |
|
1359
52782e5cf7c9
(svn r1863) Give the effect vehicle type enums more descriptive names and use the enum as parameter type for CreateEffectVehicle*()
tron
parents:
1299
diff
changeset
|
1106 |
EV_SMOKE |
0 | 1107 |
); |
1108 |
} |
|
1109 |
} |
|
1110 |
||
1111 |
static void ProcessAircraftOrder(Vehicle *v) |
|
1112 |
{ |
|
1043
44508ede2f92
(svn r1544) -Fix: SwapOrder did not use AssignOrder, which caused the saveroutine to
truelight
parents:
1035
diff
changeset
|
1113 |
const Order *order; |
0 | 1114 |
|
1115 |
// OT_GOTO_DEPOT, OT_LOADING |
|
899
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1116 |
if (v->current_order.type == OT_GOTO_DEPOT || |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1117 |
v->current_order.type == OT_LOADING) { |
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1118 |
if (v->current_order.type != OT_GOTO_DEPOT || |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1119 |
!(v->current_order.flags & OF_UNLOAD)) |
1151
06c115ce7b7a
(svn r1652) Fix: train and road vehicle lists are now redrawn when vehicles enters/leaves a depot (Hackykid)
bjarni
parents:
1150
diff
changeset
|
1120 |
return; |
06c115ce7b7a
(svn r1652) Fix: train and road vehicle lists are now redrawn when vehicles enters/leaves a depot (Hackykid)
bjarni
parents:
1150
diff
changeset
|
1121 |
} |
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1122 |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1123 |
if (v->current_order.type == OT_GOTO_DEPOT && |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1124 |
(v->current_order.flags & (OF_UNLOAD | OF_FULL_LOAD)) == (OF_UNLOAD | OF_FULL_LOAD) && |
1520
d88442095697
(svn r2024) -Fix: [autoreplace] reverted all changes involving v->set_for_replacement as they caused desyncs.
bjarni
parents:
1401
diff
changeset
|
1125 |
!VehicleNeedsService(v)) { |
1151
06c115ce7b7a
(svn r1652) Fix: train and road vehicle lists are now redrawn when vehicles enters/leaves a depot (Hackykid)
bjarni
parents:
1150
diff
changeset
|
1126 |
v->cur_order_index++; |
06c115ce7b7a
(svn r1652) Fix: train and road vehicle lists are now redrawn when vehicles enters/leaves a depot (Hackykid)
bjarni
parents:
1150
diff
changeset
|
1127 |
} |
0 | 1128 |
|
1129 |
if (v->cur_order_index >= v->num_orders) |
|
1130 |
v->cur_order_index = 0; |
|
1131 |
||
1024
5e446b5b3ec5
(svn r1525) -Codechange: rewrote the _order_array, now it can be made dynamic.
truelight
parents:
1020
diff
changeset
|
1132 |
order = GetVehicleOrder(v, v->cur_order_index); |
0 | 1133 |
|
1024
5e446b5b3ec5
(svn r1525) -Codechange: rewrote the _order_array, now it can be made dynamic.
truelight
parents:
1020
diff
changeset
|
1134 |
if (order == NULL) { |
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1135 |
v->current_order.type = OT_NOTHING; |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1136 |
v->current_order.flags = 0; |
0 | 1137 |
return; |
1138 |
} |
|
1139 |
||
1024
5e446b5b3ec5
(svn r1525) -Codechange: rewrote the _order_array, now it can be made dynamic.
truelight
parents:
1020
diff
changeset
|
1140 |
if (order->type == OT_DUMMY && !CheckForValidOrders(v)) |
901
0e42c4b151e3
(svn r1387) Fix: Airplanes now also crash when only one invalid order is in the schedule
dominik
parents:
899
diff
changeset
|
1141 |
CrashAirplane(v); |
0e42c4b151e3
(svn r1387) Fix: Airplanes now also crash when only one invalid order is in the schedule
dominik
parents:
899
diff
changeset
|
1142 |
|
1024
5e446b5b3ec5
(svn r1525) -Codechange: rewrote the _order_array, now it can be made dynamic.
truelight
parents:
1020
diff
changeset
|
1143 |
if (order->type == v->current_order.type && |
5e446b5b3ec5
(svn r1525) -Codechange: rewrote the _order_array, now it can be made dynamic.
truelight
parents:
1020
diff
changeset
|
1144 |
order->flags == v->current_order.flags && |
5e446b5b3ec5
(svn r1525) -Codechange: rewrote the _order_array, now it can be made dynamic.
truelight
parents:
1020
diff
changeset
|
1145 |
order->station == v->current_order.station) |
0 | 1146 |
return; |
1147 |
||
1024
5e446b5b3ec5
(svn r1525) -Codechange: rewrote the _order_array, now it can be made dynamic.
truelight
parents:
1020
diff
changeset
|
1148 |
v->current_order = *order; |
0 | 1149 |
|
1150 |
// orders are changed in flight, ensure going to the right station |
|
1024
5e446b5b3ec5
(svn r1525) -Codechange: rewrote the _order_array, now it can be made dynamic.
truelight
parents:
1020
diff
changeset
|
1151 |
if (order->type == OT_GOTO_STATION && v->u.air.state == FLYING) { |
0 | 1152 |
AircraftNextAirportPos_and_Order(v); |
1024
5e446b5b3ec5
(svn r1525) -Codechange: rewrote the _order_array, now it can be made dynamic.
truelight
parents:
1020
diff
changeset
|
1153 |
v->u.air.targetairport = order->station; |
0 | 1154 |
} |
1155 |
||
1024
5e446b5b3ec5
(svn r1525) -Codechange: rewrote the _order_array, now it can be made dynamic.
truelight
parents:
1020
diff
changeset
|
1156 |
InvalidateVehicleOrder(v); |
5e446b5b3ec5
(svn r1525) -Codechange: rewrote the _order_array, now it can be made dynamic.
truelight
parents:
1020
diff
changeset
|
1157 |
|
1055
cc4f60cc9102
(svn r1556) -Fix: Vehicle list updates should now really work
Celestar
parents:
1053
diff
changeset
|
1158 |
InvalidateWindowClasses(WC_AIRCRAFT_LIST); |
0 | 1159 |
} |
1160 |
||
1161 |
static void HandleAircraftLoading(Vehicle *v, int mode) |
|
1162 |
{ |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1163 |
if (v->current_order.type == OT_NOTHING) |
0 | 1164 |
return; |
1165 |
||
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1166 |
if (v->current_order.type != OT_DUMMY) { |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1167 |
if (v->current_order.type != OT_LOADING) |
0 | 1168 |
return; |
1169 |
||
1170 |
if (mode != 0) |
|
1171 |
return; |
|
1172 |
||
1173 |
if (--v->load_unload_time_rem) |
|
1174 |
return; |
|
1175 |
||
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1176 |
if (v->current_order.flags & OF_FULL_LOAD && CanFillVehicle(v)) { |
0 | 1177 |
SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_INC); |
1178 |
LoadUnloadVehicle(v); |
|
1179 |
return; |
|
1180 |
} |
|
1181 |
||
1182 |
{ |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1183 |
Order b = v->current_order; |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1184 |
v->current_order.type = OT_NOTHING; |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1185 |
v->current_order.flags = 0; |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1186 |
if (!(b.flags & OF_NON_STOP)) |
0 | 1187 |
return; |
1188 |
} |
|
1189 |
} |
|
1190 |
v->cur_order_index++; |
|
1024
5e446b5b3ec5
(svn r1525) -Codechange: rewrote the _order_array, now it can be made dynamic.
truelight
parents:
1020
diff
changeset
|
1191 |
InvalidateVehicleOrder(v); |
0 | 1192 |
} |
1193 |
||
899
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1194 |
static void CrashAirplane(Vehicle *v) |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1195 |
{ |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1196 |
uint16 amt; |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1197 |
Station *st; |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1198 |
StringID newsitem; |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1199 |
|
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1200 |
v->vehstatus |= VS_CRASHED; |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1201 |
v->u.air.crashed_counter = 0; |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1202 |
|
1359
52782e5cf7c9
(svn r1863) Give the effect vehicle type enums more descriptive names and use the enum as parameter type for CreateEffectVehicle*()
tron
parents:
1299
diff
changeset
|
1203 |
CreateEffectVehicleRel(v, 4, 4, 8, EV_EXPLOSION_LARGE); |
899
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1204 |
|
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1205 |
InvalidateWindow(WC_VEHICLE_VIEW, v->index); |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1206 |
|
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1207 |
amt = 2; |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1208 |
if (v->cargo_type == CT_PASSENGERS) amt += v->cargo_count; |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1209 |
SetDParam(0, amt); |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1210 |
|
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1211 |
v->cargo_count = 0; |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1212 |
v->next->cargo_count = 0, |
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
1213 |
st = GetStation(v->u.air.targetairport); |
899
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1214 |
if(st->airport_tile==0) { |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1215 |
newsitem = STR_PLANE_CRASH_OUT_OF_FUEL; |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1216 |
} else { |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1217 |
SetDParam(1, st->index); |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1218 |
newsitem = STR_A034_PLANE_CRASH_DIE_IN_FIREBALL; |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1219 |
} |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1220 |
|
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1221 |
SetDParam(1, st->index); |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1222 |
AddNewsItem(newsitem, |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1223 |
NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ACCIDENT, 0), |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1224 |
v->index, |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1225 |
0); |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1226 |
|
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1227 |
SndPlayVehicleFx(SND_12_EXPLOSION, v); |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1228 |
} |
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1229 |
|
0 | 1230 |
static void MaybeCrashAirplane(Vehicle *v) |
1231 |
{ |
|
1232 |
Station *st; |
|
1233 |
uint16 prob; |
|
1234 |
int i; |
|
1235 |
||
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
1236 |
st = GetStation(v->u.air.targetairport); |
0 | 1237 |
|
1238 |
//FIXME -- MaybeCrashAirplane -> increase crashing chances of very modern airplanes on smaller than AT_METROPOLITAN airports |
|
1239 |
prob = 0x10000 / 1500; |
|
538
24fdb517fbe5
(svn r920) Replace vehicle info macros with inline functions and add asserts to check limits
tron
parents:
534
diff
changeset
|
1240 |
if (st->airport_type == AT_SMALL && (AircraftVehInfo(v->engine_type)->subtype & 2) && !_cheats.no_jetcrash.value) { |
0 | 1241 |
prob = 0x10000 / 20; |
1242 |
} |
|
1243 |
||
1244 |
if ((uint16)Random() > prob) |
|
1245 |
return; |
|
1246 |
||
1247 |
// Crash the airplane. Remove all goods stored at the station. |
|
1248 |
for(i=0; i!=NUM_CARGO; i++) { |
|
1249 |
st->goods[i].rating = 1; |
|
1250 |
st->goods[i].waiting_acceptance &= ~0xFFF; |
|
1251 |
} |
|
1252 |
||
899
69db9cb6bc9d
(svn r1385) Fix: [ 1095020 ] When all stations in an aircraft's order list are demolished, the plane eventually crashes (running out of fuel)
dominik
parents:
842
diff
changeset
|
1253 |
CrashAirplane(v); |
0 | 1254 |
} |
1255 |
||
1256 |
// we've landed and just arrived at a terminal |
|
1257 |
static void AircraftEntersTerminal(Vehicle *v) |
|
1258 |
{ |
|
1259 |
Station *st; |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1260 |
Order old_order; |
0 | 1261 |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1262 |
if (v->current_order.type == OT_GOTO_DEPOT) |
0 | 1263 |
return; |
1264 |
||
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
1265 |
st = GetStation(v->u.air.targetairport); |
0 | 1266 |
v->last_station_visited = v->u.air.targetairport; |
1267 |
||
1268 |
/* Check if station was ever visited before */ |
|
1269 |
if (!(st->had_vehicle_of_type & HVOT_AIRCRAFT)) { |
|
1270 |
uint32 flags; |
|
1271 |
||
1272 |
st->had_vehicle_of_type |= HVOT_AIRCRAFT; |
|
534
306bc86eb23e
(svn r901) Small step in the process to clean up the DPARAM mess:
tron
parents:
507
diff
changeset
|
1273 |
SetDParam(0, st->index); |
0 | 1274 |
// show newsitem of celebrating citizens |
1275 |
flags = (v->owner == _local_player) ? NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_PLAYER, 0) : NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_OTHER, 0); |
|
1276 |
AddNewsItem( |
|
1277 |
STR_A033_CITIZENS_CELEBRATE_FIRST, |
|
1278 |
flags, |
|
1279 |
v->index, |
|
1280 |
0); |
|
1281 |
} |
|
1282 |
||
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1283 |
old_order = v->current_order; |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1284 |
v->current_order.type = OT_LOADING; |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1285 |
v->current_order.flags = 0; |
0 | 1286 |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1287 |
if (old_order.type == OT_GOTO_STATION && |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1288 |
v->current_order.station == v->last_station_visited) { |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1289 |
v->current_order.flags = |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1290 |
(old_order.flags & (OF_FULL_LOAD | OF_UNLOAD)) | OF_NON_STOP; |
0 | 1291 |
} |
1292 |
||
1293 |
SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_INC); |
|
1294 |
LoadUnloadVehicle(v); |
|
755
80091de50044
(svn r1211) -Feature: Introduce sticky windows to all vehicle windows...Just make sure you do not sticky more than 23 at a time. Also a lot of places in the code invalidated the 'status bar' of the vehicle, referring to it as widget 4. This is now widget 5 and has been #definitized
darkvater
parents:
699
diff
changeset
|
1295 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR); |
1055
cc4f60cc9102
(svn r1556) -Fix: Vehicle list updates should now really work
Celestar
parents:
1053
diff
changeset
|
1296 |
InvalidateWindowClasses(WC_AIRCRAFT_LIST); |
0 | 1297 |
} |
1298 |
||
1064
2242cd7419bb
(svn r1565) -Fix: [ 1104969 ] Aircraft in hangar messages are now revalidated before
celestar
parents:
1055
diff
changeset
|
1299 |
static bool ValidateAircraftInHangar( uint data_a, uint data_b ) |
2242cd7419bb
(svn r1565) -Fix: [ 1104969 ] Aircraft in hangar messages are now revalidated before
celestar
parents:
1055
diff
changeset
|
1300 |
{ |
2242cd7419bb
(svn r1565) -Fix: [ 1104969 ] Aircraft in hangar messages are now revalidated before
celestar
parents:
1055
diff
changeset
|
1301 |
Vehicle *v = GetVehicle(data_a); |
2242cd7419bb
(svn r1565) -Fix: [ 1104969 ] Aircraft in hangar messages are now revalidated before
celestar
parents:
1055
diff
changeset
|
1302 |
|
2242cd7419bb
(svn r1565) -Fix: [ 1104969 ] Aircraft in hangar messages are now revalidated before
celestar
parents:
1055
diff
changeset
|
1303 |
return (IsAircraftHangarTile(v->tile) && (v->vehstatus & VS_STOPPED)); |
2242cd7419bb
(svn r1565) -Fix: [ 1104969 ] Aircraft in hangar messages are now revalidated before
celestar
parents:
1055
diff
changeset
|
1304 |
} |
2242cd7419bb
(svn r1565) -Fix: [ 1104969 ] Aircraft in hangar messages are now revalidated before
celestar
parents:
1055
diff
changeset
|
1305 |
|
0 | 1306 |
static void AircraftEnterHangar(Vehicle *v) |
1307 |
{ |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1308 |
Order old_order; |
0 | 1309 |
|
1310 |
ServiceAircraft(v); |
|
1055
cc4f60cc9102
(svn r1556) -Fix: Vehicle list updates should now really work
Celestar
parents:
1053
diff
changeset
|
1311 |
InvalidateWindowClasses(WC_AIRCRAFT_LIST); |
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1312 |
|
842 | 1313 |
MaybeReplaceVehicle(v); |
0 | 1314 |
|
445
beafc0fb8f12
(svn r654) Hopefully complete support for randomized variational spritegroups (i.e. the cars transporter in DBSetXL gets different cars each time) (pasky)
tron
parents:
410
diff
changeset
|
1315 |
TriggerVehicle(v, VEHICLE_TRIGGER_DEPOT); |
beafc0fb8f12
(svn r654) Hopefully complete support for randomized variational spritegroups (i.e. the cars transporter in DBSetXL gets different cars each time) (pasky)
tron
parents:
410
diff
changeset
|
1316 |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1317 |
if (v->current_order.type == OT_GOTO_DEPOT) { |
0 | 1318 |
InvalidateWindow(WC_VEHICLE_VIEW, v->index); |
1319 |
||
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1320 |
old_order = v->current_order; |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1321 |
v->current_order.type = OT_NOTHING; |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1322 |
v->current_order.flags = 0; |
0 | 1323 |
|
1530
2b46869fc0d4
(svn r2034) -Codechange: Replaced the rather meaningless LOAD and UNLOAD flags for depots by something more meaningful
celestar
parents:
1520
diff
changeset
|
1324 |
if (HASBIT(old_order.flags, OFB_PART_OF_ORDERS)) { |
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1325 |
v->cur_order_index++; |
1530
2b46869fc0d4
(svn r2034) -Codechange: Replaced the rather meaningless LOAD and UNLOAD flags for depots by something more meaningful
celestar
parents:
1520
diff
changeset
|
1326 |
} else if (HASBIT(old_order.flags, OFB_HALT_IN_DEPOT)) { // force depot visit |
0 | 1327 |
v->vehstatus |= VS_STOPPED; |
1055
cc4f60cc9102
(svn r1556) -Fix: Vehicle list updates should now really work
Celestar
parents:
1053
diff
changeset
|
1328 |
InvalidateWindowClasses(WC_AIRCRAFT_LIST); |
0 | 1329 |
|
1330 |
if (v->owner == _local_player) { |
|
534
306bc86eb23e
(svn r901) Small step in the process to clean up the DPARAM mess:
tron
parents:
507
diff
changeset
|
1331 |
SetDParam(0, v->unitnumber); |
1064
2242cd7419bb
(svn r1565) -Fix: [ 1104969 ] Aircraft in hangar messages are now revalidated before
celestar
parents:
1055
diff
changeset
|
1332 |
AddValidatedNewsItem( |
0 | 1333 |
STR_A014_AIRCRAFT_IS_WAITING_IN, |
1334 |
NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0), |
|
1335 |
v->index, |
|
1064
2242cd7419bb
(svn r1565) -Fix: [ 1104969 ] Aircraft in hangar messages are now revalidated before
celestar
parents:
1055
diff
changeset
|
1336 |
0, |
2242cd7419bb
(svn r1565) -Fix: [ 1104969 ] Aircraft in hangar messages are now revalidated before
celestar
parents:
1055
diff
changeset
|
1337 |
ValidateAircraftInHangar); |
0 | 1338 |
} |
1339 |
} |
|
1340 |
} |
|
1341 |
} |
|
1342 |
||
1343 |
static void AircraftLand(Vehicle *v) |
|
1344 |
{ |
|
1345 |
v->sprite_width = v->sprite_height = 2; |
|
1346 |
} |
|
1347 |
||
1348 |
static void AircraftLandAirplane(Vehicle *v) |
|
1349 |
{ |
|
1350 |
AircraftLand(v); |
|
541 | 1351 |
SndPlayVehicleFx(SND_17_SKID_PLANE, v); |
0 | 1352 |
MaybeCrashAirplane(v); |
1353 |
} |
|
1354 |
||
1355 |
// set the right pos when heading to other airports after takeoff |
|
1356 |
static void AircraftNextAirportPos_and_Order(Vehicle *v) |
|
1357 |
{ |
|
1358 |
Station *st; |
|
1359 |
const AirportFTAClass *Airport; |
|
1360 |
||
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1361 |
if (v->current_order.type == OT_GOTO_STATION || |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1362 |
v->current_order.type == OT_GOTO_DEPOT) |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1363 |
v->u.air.targetairport = v->current_order.station; |
0 | 1364 |
|
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
1365 |
st = GetStation(v->u.air.targetairport); |
0 | 1366 |
Airport = GetAirport(st->airport_type); |
1367 |
v->u.air.pos = v->u.air.previous_pos = Airport->entry_point; |
|
1368 |
} |
|
1369 |
||
1370 |
static void AircraftLeaveHangar(Vehicle *v) |
|
1371 |
{ |
|
1372 |
v->cur_speed = 0; |
|
1373 |
v->subspeed = 0; |
|
1374 |
v->progress = 0; |
|
1375 |
v->direction = 3; |
|
1376 |
v->vehstatus &= ~VS_HIDDEN; |
|
1377 |
{ |
|
1378 |
Vehicle *u = v->next; |
|
1379 |
u->vehstatus &= ~VS_HIDDEN; |
|
1380 |
||
1381 |
// Rotor blades |
|
1382 |
if ((u=u->next) != NULL) { |
|
1383 |
u->vehstatus &= ~VS_HIDDEN; |
|
1384 |
u->cur_speed = 80; |
|
1385 |
} |
|
1386 |
} |
|
1387 |
||
578
1e66514eb621
(svn r998) now vehicles are serviced both when entering and when leaving depots to prevent that vehicles might need service when leaving after a long stay (ln--)
bjarni
parents:
555
diff
changeset
|
1388 |
VehicleServiceInDepot(v); |
0 | 1389 |
SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos); |
1390 |
InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); |
|
1055
cc4f60cc9102
(svn r1556) -Fix: Vehicle list updates should now really work
Celestar
parents:
1053
diff
changeset
|
1391 |
InvalidateWindowClasses(WC_AIRCRAFT_LIST); |
0 | 1392 |
} |
1393 |
||
1394 |
||
1395 |
//////////////////////////////////////////////////////////////////////////////// |
|
1396 |
/////////////////// AIRCRAFT MOVEMENT SCHEME //////////////////////////////// |
|
1397 |
//////////////////////////////////////////////////////////////////////////////// |
|
1398 |
static void AircraftEventHandler_EnterTerminal(Vehicle *v, const AirportFTAClass *Airport) |
|
1399 |
{ |
|
1400 |
AircraftEntersTerminal(v); |
|
1401 |
v->u.air.state = Airport->layout[v->u.air.pos].heading; |
|
1402 |
} |
|
1403 |
||
1404 |
static void AircraftEventHandler_EnterHangar(Vehicle *v, const AirportFTAClass *Airport) |
|
1405 |
{ |
|
1406 |
AircraftEnterHangar(v); |
|
1407 |
v->u.air.state = Airport->layout[v->u.air.pos].heading; |
|
1408 |
} |
|
1409 |
||
1410 |
// In an Airport Hangar |
|
1411 |
static void AircraftEventHandler_InHangar(Vehicle *v, const AirportFTAClass *Airport) |
|
1412 |
{ |
|
1413 |
// if we just arrived, execute EnterHangar first |
|
1414 |
if (v->u.air.previous_pos != v->u.air.pos) { |
|
1415 |
AircraftEventHandler_EnterHangar(v, Airport); |
|
1416 |
return; |
|
1417 |
} |
|
1418 |
||
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1419 |
// if we were sent to the depot, stay there |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1420 |
if (v->current_order.type == OT_GOTO_DEPOT && (v->vehstatus & VS_STOPPED)) { |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1421 |
v->current_order.type = OT_NOTHING; |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1422 |
v->current_order.flags = 0; |
0 | 1423 |
return; |
1424 |
} |
|
1425 |
||
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1426 |
if (v->current_order.type != OT_GOTO_STATION && |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1427 |
v->current_order.type != OT_GOTO_DEPOT) |
0 | 1428 |
return; |
1429 |
||
1430 |
// if the block of the next position is busy, stay put |
|
1431 |
if (AirportHasBlock(v, &Airport->layout[v->u.air.pos], Airport)) {return;} |
|
1432 |
||
1433 |
// We are already at the target airport, we need to find a terminal |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1434 |
if (v->current_order.station == v->u.air.targetairport) { |
0 | 1435 |
// FindFreeTerminal: |
1436 |
// 1. Find a free terminal, 2. Occupy it, 3. Set the vehicle's state to that terminal |
|
1437 |
if (v->subtype != 0) {if(!AirportFindFreeTerminal(v, Airport)) {return;}} // airplane |
|
1438 |
else {if(!AirportFindFreeHelipad(v, Airport)) {return;}} // helicopter |
|
1439 |
} |
|
1440 |
else { // Else prepare for launch. |
|
1441 |
// airplane goto state takeoff, helicopter to helitakeoff |
|
1442 |
v->u.air.state = (v->subtype != 0) ? TAKEOFF : HELITAKEOFF; |
|
1443 |
} |
|
1444 |
AircraftLeaveHangar(v); |
|
1445 |
AirportMove(v, Airport); |
|
1446 |
} |
|
1447 |
||
1448 |
// At one of the Airport's Terminals |
|
1449 |
static void AircraftEventHandler_AtTerminal(Vehicle *v, const AirportFTAClass *Airport) |
|
1450 |
{ |
|
1451 |
// if we just arrived, execute EnterTerminal first |
|
1452 |
if (v->u.air.previous_pos != v->u.air.pos) { |
|
1453 |
AircraftEventHandler_EnterTerminal(v, Airport); |
|
1454 |
// on an airport with helipads, a helicopter will always land there |
|
1455 |
// and get serviced at the same time - patch setting |
|
1456 |
if (_patches.serviceathelipad) { |
|
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1457 |
if (v->subtype == 0 && Airport->helipads != NULL) { |
0 | 1458 |
// an exerpt of ServiceAircraft, without the invisibility stuff |
1459 |
v->date_of_last_service = _date; |
|
1460 |
v->breakdowns_since_last_service = 0; |
|
1926
530480d14685
(svn r2432) Use GetEngine() instead of DEREF_ENGINE() or even _engines[]
tron
parents:
1901
diff
changeset
|
1461 |
v->reliability = GetEngine(v->engine_type)->reliability; |
0 | 1462 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
1463 |
} |
|
1464 |
} |
|
1465 |
return; |
|
1466 |
} |
|
1467 |
||
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1468 |
if (v->current_order.type == OT_NOTHING) return; |
0 | 1469 |
|
1470 |
// if the block of the next position is busy, stay put |
|
1471 |
if (AirportHasBlock(v, &Airport->layout[v->u.air.pos], Airport)) { |
|
1472 |
return; |
|
1473 |
} |
|
1474 |
||
1475 |
// airport-road is free. We either have to go to another airport, or to the hangar |
|
1476 |
// ---> start moving |
|
1477 |
||
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1478 |
switch (v->current_order.type) { |
0 | 1479 |
case OT_GOTO_STATION: // ready to fly to another airport |
1480 |
// airplane goto state takeoff, helicopter to helitakeoff |
|
1481 |
v->u.air.state = (v->subtype != 0) ? TAKEOFF : HELITAKEOFF; |
|
1482 |
break; |
|
1483 |
case OT_GOTO_DEPOT: // visit hangar for serivicing, sale, etc. |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1484 |
if (v->current_order.station == v->u.air.targetairport) |
0 | 1485 |
v->u.air.state = HANGAR; |
1486 |
else |
|
1487 |
v->u.air.state = (v->subtype != 0) ? TAKEOFF : HELITAKEOFF; |
|
1488 |
break; |
|
1489 |
default: // orders have been deleted (no orders), goto depot and don't bother us |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1490 |
v->current_order.type = OT_NOTHING; |
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1491 |
v->current_order.flags = 0; |
0 | 1492 |
v->u.air.state = HANGAR; |
1493 |
} |
|
1494 |
AirportMove(v, Airport); |
|
1495 |
} |
|
1496 |
||
1497 |
static void AircraftEventHandler_General(Vehicle *v, const AirportFTAClass *Airport) |
|
1498 |
{ |
|
70
60216d94f7c1
(svn r71) -Cheat: [976127] no extra frequent jet crash on small airports (truesatan)
darkvater
parents:
19
diff
changeset
|
1499 |
DEBUG(misc, 0) ("OK, you shouldn't be here, check your Airport Scheme!"); |
60216d94f7c1
(svn r71) -Cheat: [976127] no extra frequent jet crash on small airports (truesatan)
darkvater
parents:
19
diff
changeset
|
1500 |
assert(0); |
0 | 1501 |
} |
1502 |
||
1503 |
static void AircraftEventHandler_TakeOff(Vehicle *v, const AirportFTAClass *Airport) { |
|
1504 |
PlayAircraftSound(v); // play takeoffsound for airplanes |
|
1505 |
v->u.air.state = STARTTAKEOFF; |
|
1506 |
} |
|
1507 |
||
1508 |
static void AircraftEventHandler_StartTakeOff(Vehicle *v, const AirportFTAClass *Airport) |
|
1509 |
{ |
|
1510 |
v->sprite_width = v->sprite_height = 24; // ??? no idea what this is |
|
1511 |
v->u.air.state = ENDTAKEOFF; |
|
1512 |
} |
|
1513 |
||
1514 |
static void AircraftEventHandler_EndTakeOff(Vehicle *v, const AirportFTAClass *Airport) |
|
1515 |
{ |
|
1516 |
v->u.air.state = FLYING; |
|
1517 |
// get the next position to go to, differs per airport |
|
1518 |
AircraftNextAirportPos_and_Order(v); |
|
1519 |
} |
|
1520 |
||
1521 |
static void AircraftEventHandler_HeliTakeOff(Vehicle *v, const AirportFTAClass *Airport) |
|
1522 |
{ |
|
1523 |
v->sprite_width = v->sprite_height = 24; // ??? no idea what this is |
|
1524 |
v->u.air.state = FLYING; |
|
1525 |
// get the next position to go to, differs per airport |
|
1526 |
AircraftNextAirportPos_and_Order(v); |
|
1135
6c3b6e855c98
(svn r1636) fix: helicopters now go to a hangar if they are set for replacement or needs to be renewed
bjarni
parents:
1128
diff
changeset
|
1527 |
|
6c3b6e855c98
(svn r1636) fix: helicopters now go to a hangar if they are set for replacement or needs to be renewed
bjarni
parents:
1128
diff
changeset
|
1528 |
// check if the aircraft needs to be replaced or renewed and send it to a hangar if needed |
1520
d88442095697
(svn r2024) -Fix: [autoreplace] reverted all changes involving v->set_for_replacement as they caused desyncs.
bjarni
parents:
1401
diff
changeset
|
1529 |
if ((v->owner == _local_player && _autoreplace_array[v->engine_type] != v->engine_type) || |
d88442095697
(svn r2024) -Fix: [autoreplace] reverted all changes involving v->set_for_replacement as they caused desyncs.
bjarni
parents:
1401
diff
changeset
|
1530 |
(v->owner == _local_player && _patches.autorenew && v->age - v->max_age > (_patches.autorenew_months * 30))) { |
d88442095697
(svn r2024) -Fix: [autoreplace] reverted all changes involving v->set_for_replacement as they caused desyncs.
bjarni
parents:
1401
diff
changeset
|
1531 |
_current_player = _local_player; |
d88442095697
(svn r2024) -Fix: [autoreplace] reverted all changes involving v->set_for_replacement as they caused desyncs.
bjarni
parents:
1401
diff
changeset
|
1532 |
DoCommandP(v->tile, v->index, 1, NULL, CMD_SEND_AIRCRAFT_TO_HANGAR | CMD_SHOW_NO_ERROR); |
d88442095697
(svn r2024) -Fix: [autoreplace] reverted all changes involving v->set_for_replacement as they caused desyncs.
bjarni
parents:
1401
diff
changeset
|
1533 |
_current_player = OWNER_NONE; |
1135
6c3b6e855c98
(svn r1636) fix: helicopters now go to a hangar if they are set for replacement or needs to be renewed
bjarni
parents:
1128
diff
changeset
|
1534 |
} |
0 | 1535 |
} |
1536 |
||
1537 |
static void AircraftEventHandler_Flying(Vehicle *v, const AirportFTAClass *Airport) |
|
1538 |
{ |
|
1539 |
Station *st; |
|
1540 |
byte landingtype; |
|
1541 |
AirportFTA *current; |
|
1542 |
uint16 tcur_speed, tsubspeed; |
|
1543 |
||
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
1544 |
st = GetStation(v->u.air.targetairport); |
0 | 1545 |
// flying device is accepted at this station |
1546 |
// small airport --> no helicopters (AIRCRAFT_ONLY) |
|
1547 |
// all other airports --> all types of flying devices (ALL) |
|
1548 |
// heliport/oilrig, etc --> no airplanes (HELICOPTERS_ONLY) |
|
1549 |
// runway busy or not allowed to use this airstation, circle |
|
1550 |
if (! (v->subtype == Airport->acc_planes || |
|
1551 |
st->airport_tile == 0 || (st->owner != OWNER_NONE && st->owner != v->owner) )) { |
|
1552 |
||
1553 |
// {32,FLYING,NOTHING_block,37}, {32,LANDING,N,33}, {32,HELILANDING,N,41}, |
|
1554 |
// if it is an airplane, look for LANDING, for helicopter HELILANDING |
|
1555 |
// it is possible to choose from multiple landing runways, so loop until a free one is found |
|
1556 |
landingtype = (v->subtype != 0) ? LANDING : HELILANDING; |
|
1557 |
current = Airport->layout[v->u.air.pos].next_in_chain; |
|
1558 |
while (current != NULL) { |
|
1559 |
if (current->heading == landingtype) { |
|
1560 |
// save speed before, since if AirportHasBlock is false, it resets them to 0 |
|
1561 |
// we don't want that for plane in air |
|
1562 |
// hack for speed thingie |
|
1563 |
tcur_speed = v->cur_speed; |
|
1564 |
tsubspeed = v->subspeed; |
|
1565 |
if (!AirportHasBlock(v, current, Airport)) { |
|
1566 |
v->u.air.state = landingtype; // LANDING / HELILANDING |
|
1567 |
// it's a bit dirty, but I need to set position to next position, otherwise |
|
1568 |
// if there are multiple runways, plane won't know which one it took (because |
|
1569 |
// they all have heading LANDING). And also occupy that block! |
|
1570 |
v->u.air.pos = current->next_position; |
|
1571 |
SETBITS(st->airport_flags, Airport->layout[v->u.air.pos].block); |
|
1572 |
return; |
|
1573 |
} |
|
1574 |
v->cur_speed = tcur_speed; |
|
1575 |
v->subspeed = tsubspeed; |
|
1576 |
} |
|
1577 |
current = current->next_in_chain; |
|
1578 |
} |
|
1579 |
} |
|
1580 |
v->u.air.state = FLYING; |
|
1581 |
v->u.air.pos = Airport->layout[v->u.air.pos].next_position; |
|
1582 |
} |
|
1583 |
||
1584 |
static void AircraftEventHandler_Landing(Vehicle *v, const AirportFTAClass *Airport) |
|
1585 |
{ |
|
1586 |
AircraftLandAirplane(v); // maybe crash airplane |
|
1587 |
v->u.air.state = ENDLANDING; |
|
1195
54d50ac3311a
(svn r1699) - Feature [autoreplace] a plane will now go to the hangar right after landing if it needs to be replaced
bjarni
parents:
1194
diff
changeset
|
1588 |
// check if the aircraft needs to be replaced or renewed and send it to a hangar if needed |
54d50ac3311a
(svn r1699) - Feature [autoreplace] a plane will now go to the hangar right after landing if it needs to be replaced
bjarni
parents:
1194
diff
changeset
|
1589 |
if (v->current_order.type != OT_GOTO_DEPOT && v->owner == _local_player) { |
54d50ac3311a
(svn r1699) - Feature [autoreplace] a plane will now go to the hangar right after landing if it needs to be replaced
bjarni
parents:
1194
diff
changeset
|
1590 |
// only the vehicle owner needs to calculate the rest (locally) |
54d50ac3311a
(svn r1699) - Feature [autoreplace] a plane will now go to the hangar right after landing if it needs to be replaced
bjarni
parents:
1194
diff
changeset
|
1591 |
if ((_autoreplace_array[v->engine_type] != v->engine_type) || |
54d50ac3311a
(svn r1699) - Feature [autoreplace] a plane will now go to the hangar right after landing if it needs to be replaced
bjarni
parents:
1194
diff
changeset
|
1592 |
(_patches.autorenew && v->age - v->max_age > (_patches.autorenew_months * 30))) { |
1793
b9a37c98b468
(svn r2297) - CodeChange: server-check the next batch of commands.
Darkvater
parents:
1790
diff
changeset
|
1593 |
// send the aircraft to the hangar at next airport (bit 17 set) |
1195
54d50ac3311a
(svn r1699) - Feature [autoreplace] a plane will now go to the hangar right after landing if it needs to be replaced
bjarni
parents:
1194
diff
changeset
|
1594 |
_current_player = _local_player; |
54d50ac3311a
(svn r1699) - Feature [autoreplace] a plane will now go to the hangar right after landing if it needs to be replaced
bjarni
parents:
1194
diff
changeset
|
1595 |
DoCommandP(v->tile, v->index, 1 << 16, NULL, CMD_SEND_AIRCRAFT_TO_HANGAR | CMD_SHOW_NO_ERROR); |
54d50ac3311a
(svn r1699) - Feature [autoreplace] a plane will now go to the hangar right after landing if it needs to be replaced
bjarni
parents:
1194
diff
changeset
|
1596 |
_current_player = OWNER_NONE; |
54d50ac3311a
(svn r1699) - Feature [autoreplace] a plane will now go to the hangar right after landing if it needs to be replaced
bjarni
parents:
1194
diff
changeset
|
1597 |
} |
54d50ac3311a
(svn r1699) - Feature [autoreplace] a plane will now go to the hangar right after landing if it needs to be replaced
bjarni
parents:
1194
diff
changeset
|
1598 |
} |
0 | 1599 |
} |
1600 |
||
1601 |
static void AircraftEventHandler_HeliLanding(Vehicle *v, const AirportFTAClass *Airport) |
|
1602 |
{ |
|
1603 |
AircraftLand(v); // helicopters don't crash |
|
1604 |
v->u.air.state = HELIENDLANDING; |
|
1605 |
} |
|
1606 |
||
1607 |
static void AircraftEventHandler_EndLanding(Vehicle *v, const AirportFTAClass *Airport) |
|
1608 |
{ |
|
1609 |
// next block busy, don't do a thing, just wait |
|
1610 |
if(AirportHasBlock(v, &Airport->layout[v->u.air.pos], Airport)) {return;} |
|
1611 |
||
1612 |
// if going to terminal (OT_GOTO_STATION) choose one |
|
1613 |
// 1. in case all terminals are busy AirportFindFreeTerminal() returns false or |
|
1614 |
// 2. not going for terminal (but depot, no order), |
|
1615 |
// --> get out of the way to the hangar. |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1616 |
if (v->current_order.type == OT_GOTO_STATION) { |
0 | 1617 |
if (AirportFindFreeTerminal(v, Airport)) {return;} |
1618 |
} |
|
1619 |
v->u.air.state = HANGAR; |
|
1620 |
||
1621 |
} |
|
1622 |
||
1623 |
static void AircraftEventHandler_HeliEndLanding(Vehicle *v, const AirportFTAClass *Airport) |
|
1624 |
{ |
|
1625 |
// next block busy, don't do a thing, just wait |
|
1626 |
if(AirportHasBlock(v, &Airport->layout[v->u.air.pos], Airport)) {return;} |
|
1627 |
||
1628 |
// if going to helipad (OT_GOTO_STATION) choose one. If airport doesn't have helipads, choose terminal |
|
1629 |
// 1. in case all terminals/helipads are busy (AirportFindFreeHelipad() returns false) or |
|
1630 |
// 2. not going for terminal (but depot, no order), |
|
1631 |
// --> get out of the way to the hangar IF there are terminals on the airport. |
|
1632 |
// --> else TAKEOFF |
|
1633 |
// the reason behind this is that if an airport has a terminal, it also has a hangar. Airplanes |
|
1634 |
// must go to a hangar. |
|
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1635 |
if (v->current_order.type == OT_GOTO_STATION) { |
0 | 1636 |
if (AirportFindFreeHelipad(v, Airport)) {return;} |
1637 |
} |
|
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1638 |
v->u.air.state = (Airport->terminals != NULL) ? HANGAR : HELITAKEOFF; |
0 | 1639 |
} |
1640 |
||
1641 |
typedef void AircraftStateHandler(Vehicle *v, const AirportFTAClass *Airport); |
|
1642 |
static AircraftStateHandler * const _aircraft_state_handlers[] = { |
|
1643 |
AircraftEventHandler_General, // TO_ALL = 0 |
|
1644 |
AircraftEventHandler_InHangar, // HANGAR = 1 |
|
1645 |
AircraftEventHandler_AtTerminal, // TERM1 = 2 |
|
1646 |
AircraftEventHandler_AtTerminal, // TERM2 = 3 |
|
1647 |
AircraftEventHandler_AtTerminal, // TERM3 = 4 |
|
1648 |
AircraftEventHandler_AtTerminal, // TERM4 = 5 |
|
1649 |
AircraftEventHandler_AtTerminal, // TERM5 = 6 |
|
1650 |
AircraftEventHandler_AtTerminal, // TERM6 = 7 |
|
1651 |
AircraftEventHandler_AtTerminal, // HELIPAD1 = 8 |
|
1652 |
AircraftEventHandler_AtTerminal, // HELIPAD2 = 9 |
|
1653 |
AircraftEventHandler_TakeOff, // TAKEOFF = 10 |
|
1654 |
AircraftEventHandler_StartTakeOff, // STARTTAKEOFF = 11 |
|
1655 |
AircraftEventHandler_EndTakeOff, // ENDTAKEOFF = 12 |
|
1656 |
AircraftEventHandler_HeliTakeOff, // HELITAKEOFF = 13 |
|
1657 |
AircraftEventHandler_Flying, // FLYING = 14 |
|
1658 |
AircraftEventHandler_Landing, // LANDING = 15 |
|
1659 |
AircraftEventHandler_EndLanding, // ENDLANDING = 16 |
|
1660 |
AircraftEventHandler_HeliLanding, // HELILANDING = 17 |
|
1661 |
AircraftEventHandler_HeliEndLanding,// HELIENDLANDING = 18 |
|
1662 |
}; |
|
1663 |
||
1664 |
static void AirportClearBlock(Vehicle *v, const AirportFTAClass *Airport) |
|
1665 |
{ |
|
1666 |
Station *st; |
|
1667 |
// we have left the previous block, and entered the new one. Free the previous block |
|
1668 |
if (Airport->layout[v->u.air.previous_pos].block != Airport->layout[v->u.air.pos].block) { |
|
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
1669 |
st = GetStation(v->u.air.targetairport); |
0 | 1670 |
CLRBITS(st->airport_flags, Airport->layout[v->u.air.previous_pos].block); |
1671 |
} |
|
1672 |
} |
|
1673 |
||
1674 |
static void AirportGoToNextPosition(Vehicle *v, const AirportFTAClass *Airport) |
|
1675 |
{ |
|
1676 |
// if aircraft is not in position, wait until it is |
|
1401
44a7e0f04d28
(svn r1905) - Fix: [ 1118810 ] openttd: ship_cmd.c:642 ... Assertion failed. Mapwrap fixed in ship_cmd.c (was implicitely ok before biggermaps).
Darkvater
parents:
1359
diff
changeset
|
1677 |
if (!AircraftController(v)) {return;} |
0 | 1678 |
|
1679 |
AirportClearBlock(v, Airport); |
|
1680 |
AirportMove(v, Airport); // move aircraft to next position |
|
1681 |
} |
|
1682 |
||
1683 |
// gets pos from vehicle and next orders |
|
1684 |
static bool AirportMove(Vehicle *v, const AirportFTAClass *Airport) |
|
1685 |
{ |
|
1686 |
AirportFTA *current; |
|
1687 |
byte prev_pos; |
|
1688 |
bool retval = false; |
|
1689 |
||
1690 |
// error handling |
|
1691 |
if (v->u.air.pos >= Airport->nofelements) { |
|
70
60216d94f7c1
(svn r71) -Cheat: [976127] no extra frequent jet crash on small airports (truesatan)
darkvater
parents:
19
diff
changeset
|
1692 |
DEBUG(misc, 0) ("position %d is not valid for current airport. Max position is %d", v->u.air.pos, Airport->nofelements-1); |
0 | 1693 |
assert(v->u.air.pos < Airport->nofelements); |
1694 |
} |
|
1695 |
||
1696 |
current = &Airport->layout[v->u.air.pos]; |
|
1697 |
// we have arrived in an important state (eg terminal, hangar, etc.) |
|
1698 |
if (current->heading == v->u.air.state) { |
|
1699 |
prev_pos = v->u.air.pos; // location could be changed in state, so save it before-hand |
|
1700 |
_aircraft_state_handlers[v->u.air.state](v, Airport); |
|
1701 |
if (v->u.air.state != FLYING) {v->u.air.previous_pos = prev_pos;} |
|
1702 |
return true; |
|
1703 |
} |
|
1704 |
||
1705 |
v->u.air.previous_pos = v->u.air.pos; // save previous location |
|
1706 |
||
1707 |
// there is only one choice to move to |
|
1708 |
if (current->next_in_chain == NULL) { |
|
1709 |
if (AirportSetBlocks(v, current, Airport)) { |
|
1710 |
v->u.air.pos = current->next_position; |
|
1711 |
} // move to next position |
|
1712 |
return retval; |
|
1713 |
} |
|
1714 |
||
1715 |
// there are more choices to choose from, choose the one that |
|
1716 |
// matches our heading |
|
1717 |
do { |
|
1718 |
if (v->u.air.state == current->heading || current->heading == TO_ALL) { |
|
1719 |
if (AirportSetBlocks(v, current, Airport)) { |
|
1720 |
v->u.air.pos = current->next_position; |
|
1721 |
} // move to next position |
|
1722 |
return retval; |
|
1723 |
} |
|
1724 |
current = current->next_in_chain; |
|
1725 |
} while (current != NULL); |
|
1726 |
||
70
60216d94f7c1
(svn r71) -Cheat: [976127] no extra frequent jet crash on small airports (truesatan)
darkvater
parents:
19
diff
changeset
|
1727 |
DEBUG(misc, 0) ("Cannot move further on Airport...! pos:%d state:%d", v->u.air.pos, v->u.air.state); |
60216d94f7c1
(svn r71) -Cheat: [976127] no extra frequent jet crash on small airports (truesatan)
darkvater
parents:
19
diff
changeset
|
1728 |
DEBUG(misc, 0) ("Airport entry point: %d, Vehicle: %d", Airport->entry_point, v->index); |
0 | 1729 |
assert(0); |
1730 |
return false; |
|
1731 |
} |
|
1732 |
||
1733 |
// returns true if the road ahead is busy, eg. you must wait before proceeding |
|
1734 |
static bool AirportHasBlock(Vehicle *v, AirportFTA *current_pos, const AirportFTAClass *Airport) |
|
1735 |
{ |
|
1736 |
Station *st; |
|
1737 |
uint32 airport_flags; |
|
1738 |
AirportFTA *next, *reference; |
|
1739 |
reference = &Airport->layout[v->u.air.pos]; |
|
1740 |
next = &Airport->layout[current_pos->next_position]; |
|
1741 |
||
1742 |
// same block, then of course we can move |
|
1743 |
if (Airport->layout[current_pos->position].block != next->block) { |
|
1744 |
airport_flags = next->block; |
|
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
1745 |
st = GetStation(v->u.air.targetairport); |
0 | 1746 |
// check additional possible extra blocks |
1747 |
if (current_pos != reference && current_pos->block != NOTHING_block) { |
|
1748 |
airport_flags |= current_pos->block; |
|
1749 |
} |
|
1750 |
||
1751 |
if (HASBITS(st->airport_flags, airport_flags)) { |
|
1752 |
v->cur_speed = 0; |
|
1753 |
v->subspeed = 0; |
|
1754 |
return true; |
|
1755 |
} |
|
1756 |
} |
|
1757 |
return false; |
|
1758 |
} |
|
1759 |
||
1760 |
// returns true on success. Eg, next block was free and we have occupied it |
|
1761 |
static bool AirportSetBlocks(Vehicle *v, AirportFTA *current_pos, const AirportFTAClass *Airport) |
|
1762 |
{ |
|
1763 |
Station *st; |
|
1764 |
uint32 airport_flags; |
|
1765 |
AirportFTA *current, *reference, *next; |
|
1766 |
next = &Airport->layout[current_pos->next_position]; |
|
1767 |
reference = &Airport->layout[v->u.air.pos]; |
|
1768 |
||
1769 |
// if the next position is in another block, check it and wait until it is free |
|
1770 |
if (Airport->layout[current_pos->position].block != next->block) { |
|
1771 |
airport_flags = next->block; |
|
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
1772 |
st = GetStation(v->u.air.targetairport); |
0 | 1773 |
//search for all all elements in the list with the same state, and blocks != N |
1774 |
// this means more blocks should be checked/set |
|
1775 |
current = current_pos; |
|
1776 |
if (current == reference) { current = current->next_in_chain;} |
|
1777 |
while (current != NULL) { |
|
1778 |
if (current->heading == current_pos->heading && current->block != 0) { |
|
1779 |
airport_flags |= current->block; |
|
1780 |
break; |
|
1781 |
} |
|
1782 |
current = current->next_in_chain; |
|
1783 |
}; |
|
1784 |
||
1785 |
// if the block to be checked is in the next position, then exclude that from |
|
1786 |
// checking, because it has been set by the airplane before |
|
1787 |
if (current_pos->block == next->block) {airport_flags ^= next->block;} |
|
1788 |
||
1789 |
if (HASBITS(st->airport_flags, airport_flags)) { |
|
1790 |
v->cur_speed = 0; |
|
1791 |
v->subspeed = 0; |
|
1792 |
return false; |
|
1793 |
} |
|
1794 |
||
1795 |
if (next->block != NOTHING_block) { |
|
1796 |
SETBITS(st->airport_flags, airport_flags); // occupy next block |
|
1797 |
} |
|
1798 |
} |
|
1799 |
return true; |
|
1800 |
} |
|
1801 |
||
1802 |
static bool FreeTerminal(Vehicle *v, byte i, byte last_terminal) |
|
1803 |
{ |
|
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
1804 |
Station *st = GetStation(v->u.air.targetairport); |
0 | 1805 |
for (; i < last_terminal; i++) { |
1806 |
if (!HASBIT(st->airport_flags, i)) { |
|
1807 |
// TERMINAL# HELIPAD# |
|
1808 |
v->u.air.state = i + TERM1; // start moving to that terminal/helipad |
|
1809 |
SETBIT(st->airport_flags, i); // occupy terminal/helipad |
|
1810 |
return true; |
|
1811 |
} |
|
1812 |
} |
|
1813 |
return false; |
|
1814 |
} |
|
1815 |
||
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1816 |
static int GetNumTerminals(const AirportFTAClass *Airport) |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1817 |
{ |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1818 |
int i, num = 0; |
1019
6bae6c11e865
(svn r1520) Trim 134 (!) lines with trailing whitespace ):
tron
parents:
1018
diff
changeset
|
1819 |
|
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1820 |
for (i = Airport->terminals[0]; i > 0; i--) |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1821 |
num += Airport->terminals[i]; |
1019
6bae6c11e865
(svn r1520) Trim 134 (!) lines with trailing whitespace ):
tron
parents:
1018
diff
changeset
|
1822 |
|
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1823 |
return num; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1824 |
} |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1825 |
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1826 |
static bool AirportFindFreeTerminal(Vehicle *v, const AirportFTAClass *Airport) |
0 | 1827 |
{ |
1828 |
AirportFTA *temp; |
|
1829 |
Station *st; |
|
1830 |
||
1831 |
/* example of more terminalgroups |
|
1832 |
{0,HANGAR,NOTHING_block,1}, {0,255,TERM_GROUP1_block,0}, {0,255,TERM_GROUP2_ENTER_block,1}, {0,0,N,1}, |
|
1833 |
Heading 255 denotes a group. We see 2 groups here: |
|
1834 |
1. group 0 -- TERM_GROUP1_block (check block) |
|
1835 |
2. group 1 -- TERM_GROUP2_ENTER_block (check block) |
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1836 |
First in line is checked first, group 0. If the block (TERM_GROUP1_block) is free, it |
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1837 |
looks at the corresponding terminals of that group. If no free ones are found, other |
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1838 |
possible groups are checked (in this case group 1, since that is after group 0). If that |
0 | 1839 |
fails, then attempt fails and plane waits |
1840 |
*/ |
|
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1841 |
if (Airport->terminals[0] > 1) { |
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
1842 |
st = GetStation(v->u.air.targetairport); |
0 | 1843 |
temp = Airport->layout[v->u.air.pos].next_in_chain; |
1844 |
while (temp != NULL) { |
|
1845 |
if (temp->heading == 255) { |
|
1846 |
if (!HASBITS(st->airport_flags, temp->block)) { |
|
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1847 |
int target_group; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1848 |
int i; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1849 |
int group_start = 0; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1850 |
int group_end; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1851 |
|
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1852 |
//read which group do we want to go to? |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1853 |
//(the first free group) |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1854 |
target_group = temp->next_position + 1; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1855 |
|
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1856 |
//at what terminal does the group start? |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1857 |
//that means, sum up all terminals of |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1858 |
//groups with lower number |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1859 |
for(i = 1; i < target_group; i++) |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1860 |
group_start += Airport->terminals[i]; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1861 |
|
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1862 |
group_end = group_start + Airport->terminals[target_group]; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1863 |
if (FreeTerminal(v, group_start, group_end)) {return true;} |
0 | 1864 |
} |
1865 |
} |
|
1866 |
else {return false;} // once the heading isn't 255, we've exhausted the possible blocks. So we cannot move |
|
1867 |
temp = temp->next_in_chain; |
|
1868 |
} |
|
1869 |
} |
|
1870 |
||
1871 |
// if there is only 1 terminalgroup, all terminals are checked (starting from 0 to max) |
|
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1872 |
return FreeTerminal(v, 0, GetNumTerminals(Airport)); |
0 | 1873 |
} |
1874 |
||
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1875 |
static int GetNumHelipads(const AirportFTAClass *Airport) |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1876 |
{ |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1877 |
int i, num = 0; |
1019
6bae6c11e865
(svn r1520) Trim 134 (!) lines with trailing whitespace ):
tron
parents:
1018
diff
changeset
|
1878 |
|
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1879 |
for (i = Airport->helipads[0]; i > 0; i--) |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1880 |
num += Airport->helipads[i]; |
1019
6bae6c11e865
(svn r1520) Trim 134 (!) lines with trailing whitespace ):
tron
parents:
1018
diff
changeset
|
1881 |
|
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1882 |
return num; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1883 |
} |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1884 |
|
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1885 |
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1886 |
static bool AirportFindFreeHelipad(Vehicle *v, const AirportFTAClass *Airport) |
0 | 1887 |
{ |
1888 |
Station *st; |
|
1889 |
AirportFTA *temp; |
|
1890 |
||
1891 |
// if an airport doesn't have helipads, use terminals |
|
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1892 |
if (Airport->helipads == NULL) {return AirportFindFreeTerminal(v, Airport);} |
0 | 1893 |
|
1894 |
// if there are more helicoptergroups, pick one, just as in AirportFindFreeTerminal() |
|
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1895 |
if (Airport->helipads[0] > 1) { |
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
1896 |
st = GetStation(v->u.air.targetairport); |
0 | 1897 |
temp = Airport->layout[v->u.air.pos].next_in_chain; |
1898 |
while (temp != NULL) { |
|
1899 |
if (temp->heading == 255) { |
|
1900 |
if (!HASBITS(st->airport_flags, temp->block)) { |
|
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1901 |
int target_group; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1902 |
int i; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1903 |
int group_start = 0; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1904 |
int group_end; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1905 |
|
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1906 |
//read which group do we want to go to? |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1907 |
//(the first free group) |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1908 |
target_group = temp->next_position + 1; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1909 |
|
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1910 |
//at what terminal does the group start? |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1911 |
//that means, sum up all terminals of |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1912 |
//groups with lower number |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1913 |
for(i = 1; i < target_group; i++) |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1914 |
group_start += Airport->helipads[i]; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1915 |
|
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1916 |
group_end = group_start + Airport->helipads[target_group]; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1917 |
if (FreeTerminal(v, group_start, group_end)) {return true;} |
0 | 1918 |
} |
1919 |
} |
|
1920 |
else {return false;} // once the heading isn't 255, we've exhausted the possible blocks. So we cannot move |
|
1921 |
temp = temp->next_in_chain; |
|
1922 |
} |
|
1923 |
} |
|
1924 |
// only 1 helicoptergroup, check all helipads |
|
1925 |
// The blocks for helipads start after the last terminal (MAX_TERMINALS) |
|
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1926 |
else {return FreeTerminal(v, MAX_TERMINALS, GetNumHelipads(Airport) + MAX_TERMINALS);} |
0 | 1927 |
return false; // it shouldn't get here anytime, but just to be sure |
1928 |
} |
|
1929 |
||
1930 |
static void AircraftEventHandler(Vehicle *v, int loop) |
|
1931 |
{ |
|
1932 |
v->tick_counter++; |
|
1933 |
||
1934 |
if (v->vehstatus & VS_CRASHED) { |
|
1935 |
HandleCrashedAircraft(v); |
|
1936 |
return; |
|
1937 |
} |
|
1938 |
||
1939 |
/* exit if aircraft is stopped */ |
|
1940 |
if (v->vehstatus & VS_STOPPED) |
|
1941 |
return; |
|
1942 |
||
1943 |
/* aircraft is broken down? */ |
|
1944 |
if (v->breakdown_ctr != 0) { |
|
1945 |
if (v->breakdown_ctr <= 2) { |
|
1946 |
HandleBrokenAircraft(v); |
|
1947 |
} else { |
|
1948 |
v->breakdown_ctr--; |
|
1949 |
} |
|
1950 |
} |
|
1951 |
||
1952 |
HandleAircraftSmoke(v); |
|
1953 |
ProcessAircraftOrder(v); |
|
1954 |
HandleAircraftLoading(v, loop); |
|
1955 |
||
555
02df8a1b7f33
(svn r955) Replace uint16 for orders with struct Order
tron
parents:
541
diff
changeset
|
1956 |
if (v->current_order.type >= OT_LOADING) |
0 | 1957 |
return; |
1958 |
||
1959 |
// pass the right airport structure to the functions |
|
1960 |
// DEREF_STATION gets target airport (Station *st), its type is passed to GetAirport |
|
1961 |
// that returns the correct layout depending on type |
|
919
544f374ee392
(svn r1407) -Codechange: changed a lot around _stations, _vehicles, _towns and _industries
truelight
parents:
909
diff
changeset
|
1962 |
AirportGoToNextPosition(v, GetAirport(GetStation(v->u.air.targetairport)->airport_type)); |
0 | 1963 |
} |
1964 |
||
1965 |
void Aircraft_Tick(Vehicle *v) |
|
1966 |
{ |
|
1967 |
int i; |
|
1968 |
||
1969 |
if (v->subtype > 2) |
|
1970 |
return; |
|
1971 |
||
1972 |
if (v->subtype == 0) |
|
1973 |
HelicopterTickHandler(v); |
|
1974 |
||
1975 |
AgeAircraftCargo(v); |
|
1976 |
||
1977 |
for(i=0; i!=6; i++) { |
|
1978 |
AircraftEventHandler(v, i); |
|
1979 |
if (v->type != VEH_Aircraft) // In case it was deleted |
|
1980 |
break; |
|
1981 |
} |
|
1982 |
} |
|
1983 |
||
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1984 |
void UpdateOilRig( void ) |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1985 |
{ |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1986 |
Station *st; |
1019
6bae6c11e865
(svn r1520) Trim 134 (!) lines with trailing whitespace ):
tron
parents:
1018
diff
changeset
|
1987 |
|
950
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1988 |
FOR_ALL_STATIONS(st) { |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1989 |
if (st->airport_type == 5) st->airport_type = AT_OILRIG; |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1990 |
} |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1991 |
} |
165341d74973
(svn r1440) -Feature: Allows more flexible airport layouts now, as the number of
celestar
parents:
926
diff
changeset
|
1992 |
|
0 | 1993 |
// need to be called to load aircraft from old version |
1093
4fdc46eaf423
(svn r1594) Convert all undefined parameter lists to (void) and add the appropriate warning flags in the Makefile
tron
parents:
1064
diff
changeset
|
1994 |
void UpdateOldAircraft(void) |
0 | 1995 |
{ |
1996 |
Station *st; |
|
1997 |
Vehicle *v_oldstyle; |
|
1998 |
GetNewVehiclePosResult gp; |
|
1999 |
||
2000 |
// set airport_flags to 0 for all airports just to be sure |
|
2001 |
FOR_ALL_STATIONS(st) { |
|
2002 |
st->airport_flags = 0; // reset airport |
|
2003 |
// type of oilrig has been moved, update it (3-5) |
|
2004 |
if (st->airport_type == 3) {st->airport_type = AT_OILRIG;} |
|
2005 |
} |
|
2006 |
||
2007 |
FOR_ALL_VEHICLES(v_oldstyle) { |
|
2008 |
// airplane has another vehicle with subtype 4 (shadow), helicopter also has 3 (rotor) |
|
2009 |
// skip those |
|
2010 |
if (v_oldstyle->type == VEH_Aircraft && v_oldstyle->subtype <= 2) { |
|
2011 |
// airplane in terminal stopped doesn't hurt anyone, so goto next |
|
2012 |
if ((v_oldstyle->vehstatus & VS_STOPPED) && (v_oldstyle->u.air.state == 0)) { |
|
2013 |
v_oldstyle->u.air.state = HANGAR; |
|
2014 |
continue; |
|
2015 |
} |
|
2016 |
||
2017 |
AircraftLeaveHangar(v_oldstyle); // make airplane visible if it was in a depot for example |
|
2018 |
v_oldstyle->vehstatus &= ~VS_STOPPED; // make airplane moving |
|
2019 |
v_oldstyle->u.air.state = FLYING; |
|
2020 |
AircraftNextAirportPos_and_Order(v_oldstyle); // move it to the entry point of the airport |
|
2021 |
GetNewVehiclePos(v_oldstyle, &gp); // get the position of the plane (to be used for setting) |
|
2022 |
v_oldstyle->tile = 0; // aircraft in air is tile=0 |
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
2023 |
|
0 | 2024 |
// correct speed of helicopter-rotors |
2025 |
if (v_oldstyle->subtype == 0) {v_oldstyle->next->next->cur_speed = 32;} |
|
2026 |
||
2027 |
// set new position x,y,z |
|
2028 |
SetAircraftPosition(v_oldstyle, gp.x, gp.y, GetAircraftFlyingAltitude(v_oldstyle)); |
|
2029 |
} |
|
2030 |
} |
|
2031 |
} |
|
2032 |
||
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
2033 |
void UpdateAirplanesOnNewStation(Station *st) |
0 | 2034 |
{ |
2035 |
GetNewVehiclePosResult gp; |
|
2036 |
Vehicle *v; |
|
2037 |
byte takeofftype; |
|
2038 |
uint16 cnt; |
|
2039 |
// only 1 station is updated per function call, so it is enough to get entry_point once |
|
2040 |
const AirportFTAClass *ap = GetAirport(st->airport_type); |
|
2041 |
FOR_ALL_VEHICLES(v) { |
|
2042 |
if (v->type == VEH_Aircraft && v->subtype <= 2) { |
|
2043 |
if (v->u.air.targetairport == st->index) { // if heading to this airport |
|
2044 |
/* update position of airplane. If plane is not flying, landing, or taking off |
|
2045 |
you cannot delete airport, so it doesn't matter |
|
2046 |
*/ |
|
2047 |
if (v->u.air.state >= FLYING) { // circle around |
|
2048 |
v->u.air.pos = v->u.air.previous_pos = ap->entry_point; |
|
2049 |
v->u.air.state = FLYING; |
|
2050 |
// landing plane needs to be reset to flying height (only if in pause mode upgrade, |
|
1401
44a7e0f04d28
(svn r1905) - Fix: [ 1118810 ] openttd: ship_cmd.c:642 ... Assertion failed. Mapwrap fixed in ship_cmd.c (was implicitely ok before biggermaps).
Darkvater
parents:
1359
diff
changeset
|
2051 |
// in normal mode, plane is reset in AircraftController. It doesn't hurt for FLYING |
0 | 2052 |
GetNewVehiclePos(v, &gp); |
2053 |
// set new position x,y,z |
|
2054 |
SetAircraftPosition(v, gp.x, gp.y, GetAircraftFlyingAltitude(v)); |
|
2055 |
} |
|
2056 |
else { |
|
2057 |
assert(v->u.air.state == ENDTAKEOFF || v->u.air.state == HELITAKEOFF); |
|
2058 |
takeofftype = (v->subtype == 0) ? HELITAKEOFF : ENDTAKEOFF; |
|
2059 |
// search in airportdata for that heading |
|
2060 |
// easiest to do, since this doesn't happen a lot |
|
2061 |
for (cnt = 0; cnt < ap->nofelements; cnt++) { |
|
2062 |
if (ap->layout[cnt].heading == takeofftype) { |
|
2063 |
v->u.air.pos = ap->layout[cnt].position; |
|
2064 |
break; |
|
2065 |
} |
|
2066 |
} |
|
2067 |
} |
|
2068 |
} |
|
2069 |
} |
|
2070 |
} |
|
2071 |
} |