| author | darkvater |
| Fri, 12 Nov 2004 19:03:37 +0000 | |
| changeset 363 | 2a01c271fe2d |
| parent 337 | cbe0c766c947 |
| child 374 | 0309a855fc66 |
| permissions | -rw-r--r-- |
| 0 | 1 |
#include "stdafx.h" |
2 |
#include "ttd.h" |
|
3 |
#include "vehicle.h" |
|
4 |
#include "engine.h" |
|
5 |
#include "command.h" |
|
6 |
#include "station.h" |
|
7 |
#include "news.h" |
|
8 |
#include "gfx.h" |
|
9 |
#include "pathfind.h" |
|
10 |
#include "player.h" |
|
|
337
cbe0c766c947
(svn r513) Merge revisions 402, 416, 417, 478, 479, 511, 512 from map to trunk
tron
parents:
241
diff
changeset
|
11 |
#include "sound.h" |
| 0 | 12 |
|
13 |
void ShowRoadVehViewWindow(Vehicle *v); |
|
14 |
||
15 |
static const uint16 _roadveh_images[63] = {
|
|
16 |
0xCD4, 0xCDC, 0xCE4, 0xCEC, 0xCF4, 0xCFC, 0xD0C, 0xD14, |
|
17 |
0xD24, 0xD1C, 0xD2C, 0xD04, 0xD1C, 0xD24, 0xD6C, 0xD74, |
|
18 |
0xD7C, 0xC14, 0xC1C, 0xC24, 0xC2C, 0xC34, 0xC3C, 0xC4C, |
|
19 |
0xC54, 0xC64, 0xC5C, 0xC6C, 0xC44, 0xC5C, 0xC64, 0xCAC, |
|
20 |
0xCB4, 0xCBC, 0xD94, 0xD9C, 0xDA4, 0xDAC, 0xDB4, 0xDBC, |
|
21 |
0xDCC, 0xDD4, 0xDE4, 0xDDC, 0xDEC, 0xDC4, 0xDDC, 0xDE4, |
|
22 |
0xE2C, 0xE34, 0xE3C, 0xC14, 0xC1C, 0xC2C, 0xC3C, 0xC4C, |
|
23 |
0xC5C, 0xC64, 0xC6C, 0xC74, 0xC84, 0xC94, 0xCA4 |
|
24 |
}; |
|
25 |
||
26 |
||
27 |
static const uint16 _roadveh_full_adder[63] = {
|
|
28 |
0, 88, 0, 0, 0, 0, 48, 48, |
|
29 |
48, 48, 0, 0, 64, 64, 0, 16, |
|
30 |
16, 0, 88, 0, 0, 0, 0, 48, |
|
31 |
48, 48, 48, 0, 0, 64, 64, 0, |
|
32 |
16, 16, 0, 88, 0, 0, 0, 0, |
|
33 |
48, 48, 48, 48, 0, 0, 64, 64, |
|
34 |
0, 16, 16, 0, 8, 8, 8, 8, |
|
35 |
0, 0, 0, 8, 8, 8, 8 |
|
36 |
}; |
|
37 |
||
38 |
static const byte _roadveh_spritenum[88] = {
|
|
39 |
0, 17, 17, 34, 51, 51, 51, 1, |
|
40 |
18, 35, 2, 19, 36, 57, 57, 57, |
|
41 |
3, 20, 37, 4, 21, 38, 5, 22, |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
42 |
|
| 0 | 43 |
39, 6, 23, 40, 7, 24, 41, 8, |
44 |
25, 42, 9, 26, 43, 10, 27, 44, |
|
45 |
11, 28, 45, 12, 29, 46, 13, 30, |
|
46 |
47, 14, 31, 48, 15, 32, 49, 16, |
|
47 |
||
48 |
33, 50, 52, 52, 52, 53, 53, 53, |
|
49 |
54, 54, 54, 55, 55, 55, 56, 56, |
|
50 |
56, 58, 58, 58, 59, 59, 59, 60, |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
51 |
60, 60, 61, 61, 61, 62, 62, 62, |
| 0 | 52 |
}; |
53 |
||
54 |
const byte _roadveh_speed[88] = {
|
|
55 |
112, 176, 224, 255, 112, 192, 240, 96, |
|
56 |
176, 224, 96, 176, 224, 96, 176, 224, |
|
57 |
96, 176, 224, 96, 176, 224, 96, 176, |
|
58 |
224, 96, 176, 224, 96, 176, 224, 96, |
|
59 |
176, 224, 96, 176, 224, 96, 176, 224, |
|
60 |
96, 176, 224, 96, 176, 224, 96, 176, |
|
61 |
224, 96, 176, 224, 96, 176, 224, 96, |
|
62 |
176, 224, 96, 176, 224, 96, 176, 224, |
|
63 |
96, 176, 224, 96, 176, 224, 96, 176, |
|
64 |
224, 96, 176, 224, 96, 176, 224, 96, |
|
65 |
176, 224, 96, 176, 224, 96, 176, 224, |
|
66 |
}; |
|
67 |
||
68 |
||
69 |
const byte _roadveh_runningcost[88] = {
|
|
70 |
91, 128, 178, 240, 91, 171, 240, 90, |
|
71 |
168, 240, 90, 168, 240, 90, 168, 240, |
|
72 |
90, 168, 240, 90, 168, 240, 90, 168, |
|
73 |
240, 90, 168, 240, 90, 168, 240, 90, |
|
74 |
168, 240, 90, 168, 240, 90, 168, 240, |
|
75 |
90, 168, 240, 90, 168, 240, 90, 168, |
|
76 |
240, 90, 168, 240, 90, 168, 240, 90, |
|
77 |
168, 240, 90, 168, 240, 90, 168, 240, |
|
78 |
90, 168, 240, 90, 168, 240, 90, 168, |
|
79 |
240, 90, 168, 240, 90, 168, 240, 90, |
|
80 |
168, 240, 90, 168, 240, 90, 168, 240, |
|
81 |
}; |
|
82 |
||
83 |
||
84 |
const byte _roadveh_capacity[88] = {
|
|
85 |
31, 35, 37, 40, 30, 35, 38, 20, |
|
86 |
25, 28, 22, 28, 30, 22, 28, 30, |
|
87 |
21, 25, 27, 14, 16, 18, 14, 16, |
|
88 |
18, 20, 25, 30, 20, 22, 24, 22, |
|
89 |
25, 27, 15, 18, 20, 12, 15, 16, |
|
90 |
17, 20, 22, 15, 18, 20, 22, 25, |
|
91 |
27, 21, 25, 27, 18, 20, 23, 17, |
|
92 |
19, 22, 17, 19, 22, 17, 19, 22, |
|
93 |
17, 19, 22, 17, 19, 22, 17, 19, |
|
94 |
22, 17, 19, 22, 17, 19, 22, 17, |
|
95 |
19, 22, 17, 19, 22, 17, 19, 22, |
|
96 |
}; |
|
97 |
||
98 |
const byte _roadveh_cargo_type[88] = {
|
|
99 |
0, 0, 0, 0, 0, 0, 0, 1, |
|
100 |
1, 1, 2, 2, 2, 2, 2, 2, |
|
101 |
3, 3, 3, 4, 4, 4, 5, 5, |
|
102 |
5, 6, 6, 6, 7, 7, 7, 8, |
|
103 |
8, 8, 9, 9, 9,10,10,10, |
|
104 |
11,11,11, 9, 9, 9, 8, 8, |
|
105 |
8, 9, 9, 9, 4, 4, 4, 1, |
|
106 |
1, 1, 1, 1, 1, 7, 7, 7, |
|
107 |
8, 8, 8, 6, 6, 6, 3, 3, |
|
108 |
3, 5, 5, 5, 4, 4, 4,11, |
|
109 |
11,11,10,10,10, 9, 9, 9, |
|
110 |
}; |
|
111 |
||
112 |
const byte _roadveh_price[88] = {
|
|
113 |
120,140,150,160,120,140,160,108, |
|
114 |
128,138,115,135,145,115,135,145, |
|
115 |
110,140,150,105,130,140,107,130, |
|
116 |
140,114,133,143,118,137,147,121, |
|
117 |
140,150,112,135,145,145,170,180, |
|
118 |
112,134,144,112,135,145,121,140, |
|
119 |
150,111,141,151,118,148,158,117, |
|
120 |
147,157,117,147,157,117,147,157, |
|
121 |
117,147,157,117,147,157,117,147, |
|
122 |
157,117,147,157,117,147,157,117, |
|
123 |
147,157,117,147,157,117,147,157, |
|
124 |
}; |
|
125 |
||
126 |
static const byte _road_engine_sounds[88] = {
|
|
127 |
23, 26, 25, 25, 60, 62, 60, 23, |
|
128 |
23, 23, 23, 23, 23, 62, 60, 62, |
|
129 |
23, 23, 23, 23, 23, 23, 23, 23, |
|
130 |
23, 23, 23, 23, 23, 23, 23, 23, |
|
131 |
23, 23, 23, 23, 23, 23, 23, 23, |
|
132 |
23, 23, 23, 23, 23, 23, 23, 23, |
|
133 |
23, 23, 23, 23, 23, 23, 23, 23, |
|
134 |
23, 23, 63, 64, 63, 64, 63, 64, |
|
135 |
63, 64, 63, 64, 63, 64, 63, 64, |
|
136 |
63, 64, 63, 64, 63, 64, 63, 64, |
|
137 |
63, 64, 63, 64, 63, 64, 63, 64, |
|
138 |
}; |
|
139 |
||
140 |
static const uint16 _road_veh_fp_ax_or[4] = {
|
|
141 |
0x100,0x200,1,2, |
|
142 |
}; |
|
143 |
||
144 |
static const uint16 _road_veh_fp_ax_and[4] = {
|
|
145 |
0x1009, 0x16, 0x520, 0x2A00 |
|
146 |
}; |
|
147 |
||
148 |
static const byte _road_reverse_table[4] = {
|
|
149 |
6, 7, 14, 15 |
|
150 |
}; |
|
151 |
||
152 |
static const uint16 _road_pf_table_3[4] = {
|
|
153 |
0x910, 0x1600, 0x2005, 0x2A |
|
154 |
}; |
|
155 |
||
156 |
int GetRoadVehImage(Vehicle *v, byte direction) |
|
157 |
{
|
|
158 |
int img = v->spritenum; |
|
159 |
int image; |
|
160 |
||
161 |
#ifdef ROADVEH_CUSTOM_SPRITES // TODO --pasky |
|
162 |
if (is_custom_sprite(img)) {
|
|
163 |
image = GetCustomVehicleSprite(v, direction); |
|
164 |
if (image) return image; |
|
165 |
img = _engine_original_sprites[v->engine_type]; |
|
166 |
} |
|
167 |
#endif |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
168 |
|
| 0 | 169 |
image = direction + _roadveh_images[img]; |
170 |
if (v->cargo_count >= (v->cargo_cap >> 1)) |
|
171 |
image += _roadveh_full_adder[img]; |
|
172 |
return image; |
|
173 |
} |
|
174 |
||
175 |
void DrawRoadVehEngine(int x, int y, int engine, uint32 image_ormod) |
|
176 |
{
|
|
177 |
DrawSprite((6 + _roadveh_images[_roadveh_spritenum[engine - ROAD_ENGINES_INDEX]]) | image_ormod, x, y); |
|
178 |
} |
|
179 |
||
180 |
void DrawRoadVehEngineInfo(int engine, int x, int y, int maxw) |
|
181 |
{
|
|
182 |
engine -= ROAD_ENGINES_INDEX; |
|
183 |
||
184 |
SET_DPARAM32(0, ((_price.roadveh_base >> 3) * _roadveh_price[engine]) >> 5); |
|
185 |
SET_DPARAM16(1, _roadveh_speed[engine] * 10 >> 5); |
|
186 |
SET_DPARAM32(2, _roadveh_runningcost[engine] * _price.roadveh_running >> 8); |
|
187 |
||
188 |
SET_DPARAM16(4, _roadveh_capacity[engine]); |
|
189 |
SET_DPARAM16(3, _cargoc.names_long_p[_roadveh_cargo_type[engine]]); |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
190 |
|
| 0 | 191 |
DrawStringMultiCenter(x, y, STR_902A_COST_SPEED_RUNNING_COST, maxw); |
192 |
} |
|
193 |
||
194 |
static int32 EstimateRoadVehCost(byte engine_type) |
|
195 |
{
|
|
196 |
return ((_price.roadveh_base >> 3) * _roadveh_price[engine_type - ROAD_ENGINES_INDEX]) >> 5; |
|
197 |
} |
|
198 |
||
199 |
int32 CmdBuildRoadVeh(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
|
200 |
{
|
|
201 |
int32 cost; |
|
202 |
Vehicle *v; |
|
203 |
byte unit_num; |
|
204 |
uint tile = TILE_FROM_XY(x,y); |
|
205 |
Engine *e; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
206 |
|
| 0 | 207 |
SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES); |
208 |
||
209 |
cost = EstimateRoadVehCost(p1); |
|
210 |
if (flags & DC_QUERY_COST) |
|
211 |
return cost; |
|
212 |
||
213 |
v = AllocateVehicle(); |
|
214 |
if (v == NULL || _ptr_to_next_order >= endof(_order_array)) |
|
215 |
return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME); |
|
216 |
||
217 |
/* find the first free roadveh id */ |
|
218 |
unit_num = GetFreeUnitNumber(VEH_Road); |
|
219 |
if (unit_num > _patches.max_roadveh) |
|
220 |
return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME); |
|
221 |
||
222 |
if (flags & DC_EXEC) {
|
|
223 |
v->unitnumber = unit_num; |
|
224 |
v->direction = 0; |
|
225 |
v->owner = _current_player; |
|
226 |
||
227 |
v->tile = tile; |
|
228 |
x = GET_TILE_X(tile)*16 + 8; |
|
229 |
y = GET_TILE_Y(tile)*16 + 8; |
|
230 |
v->x_pos = x; |
|
231 |
v->y_pos = y; |
|
232 |
v->z_pos = GetSlopeZ(x,y); |
|
233 |
v->z_height = 6; |
|
234 |
||
235 |
v->u.road.state = 254; |
|
236 |
v->vehstatus = VS_HIDDEN|VS_STOPPED|VS_DEFPAL; |
|
237 |
||
238 |
v->spritenum = _roadveh_spritenum[p1 - ROAD_ENGINES_INDEX]; |
|
239 |
v->cargo_type = _roadveh_cargo_type[p1 - ROAD_ENGINES_INDEX]; |
|
240 |
v->cargo_cap = _roadveh_capacity[p1 - ROAD_ENGINES_INDEX]; |
|
241 |
// v->cargo_count = 0; |
|
242 |
v->value = cost; |
|
243 |
// v->day_counter = 0; |
|
244 |
// v->next_order_param = v->next_order = 0; |
|
245 |
// v->load_unload_time_rem = 0; |
|
246 |
// v->progress = 0; |
|
247 |
||
248 |
// v->u.road.unk2 = 0; |
|
249 |
// v->u.road.overtaking = 0; |
|
250 |
||
251 |
v->last_station_visited = 0xFF; |
|
252 |
v->max_speed = _roadveh_speed[p1 - ROAD_ENGINES_INDEX]; |
|
253 |
v->engine_type = (byte)p1; |
|
254 |
||
255 |
e = &_engines[p1]; |
|
256 |
v->reliability = e->reliability; |
|
257 |
v->reliability_spd_dec = e->reliability_spd_dec; |
|
258 |
v->max_age = e->lifelength * 366; |
|
259 |
_new_roadveh_id = v->index; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
260 |
|
| 0 | 261 |
v->string_id = STR_SV_ROADVEH_NAME; |
262 |
*(v->schedule_ptr = _ptr_to_next_order++) = 0; |
|
263 |
||
264 |
v->service_interval = _patches.servint_roadveh; |
|
265 |
||
266 |
v->date_of_last_service = _date; |
|
267 |
v->build_year = _cur_year; |
|
268 |
||
269 |
v->type = VEH_Road; |
|
270 |
v->cur_image = 0xC15; |
|
271 |
||
272 |
VehiclePositionChanged(v); |
|
273 |
||
274 |
InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); |
|
|
164
0cbdf3c9bde1
(svn r165) -Feature: Option to sort vehicles in vehicle-list window by different criteria. Total independent sort for all types and players. Periodic resort of list every 10 TTD days. Thank you for your graphical inspiration follow and buxo (since none of you provided any code).
darkvater
parents:
159
diff
changeset
|
275 |
_vehicle_sort_dirty[VEHROAD] = true; // build a new bus/truck |
| 0 | 276 |
InvalidateWindow(WC_ROADVEH_LIST, v->owner); |
277 |
InvalidateWindow(WC_COMPANY, v->owner); |
|
278 |
} |
|
279 |
||
280 |
return cost; |
|
281 |
} |
|
282 |
||
283 |
// p1 = vehicle |
|
284 |
int32 CmdStartStopRoadVeh(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
|
285 |
{
|
|
286 |
Vehicle *v; |
|
287 |
||
288 |
v = &_vehicles[p1]; |
|
289 |
||
290 |
if (v->type != VEH_Road || !CheckOwnership(v->owner)) |
|
291 |
return CMD_ERROR; |
|
292 |
||
293 |
if (flags & DC_EXEC) {
|
|
294 |
v->vehstatus ^= VS_STOPPED; |
|
295 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, 4); |
|
296 |
InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); |
|
297 |
} |
|
298 |
||
299 |
return 0; |
|
300 |
} |
|
301 |
||
302 |
int32 CmdSellRoadVeh(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
|
303 |
{
|
|
304 |
Vehicle *v; |
|
305 |
||
306 |
SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES); |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
307 |
|
| 0 | 308 |
v = &_vehicles[p1]; |
309 |
||
310 |
if (v->type != VEH_Road || !CheckOwnership(v->owner)) |
|
311 |
return CMD_ERROR; |
|
312 |
||
313 |
if (!IsRoadDepotTile(v->tile) || v->u.road.state != 254 || !(v->vehstatus&VS_STOPPED)) |
|
314 |
return_cmd_error(STR_9013_MUST_BE_STOPPED_INSIDE); |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
315 |
|
| 0 | 316 |
if (flags & DC_EXEC) {
|
317 |
// Invalidate depot |
|
318 |
InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); |
|
|
164
0cbdf3c9bde1
(svn r165) -Feature: Option to sort vehicles in vehicle-list window by different criteria. Total independent sort for all types and players. Periodic resort of list every 10 TTD days. Thank you for your graphical inspiration follow and buxo (since none of you provided any code).
darkvater
parents:
159
diff
changeset
|
319 |
_vehicle_sort_dirty[VEHROAD] = true; // sell a bus/truck |
| 0 | 320 |
InvalidateWindow(WC_ROADVEH_LIST, v->owner); |
321 |
InvalidateWindow(WC_COMPANY, v->owner); |
|
322 |
DeleteWindowById(WC_VEHICLE_VIEW, v->index); |
|
323 |
DeleteVehicle(v); |
|
324 |
} |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
325 |
|
| 0 | 326 |
return -(int32)v->value; |
327 |
} |
|
328 |
||
329 |
typedef struct RoadFindDepotData {
|
|
330 |
uint best_length; |
|
331 |
uint tile; |
|
332 |
byte owner; |
|
333 |
} RoadFindDepotData; |
|
334 |
||
335 |
||
336 |
static const TileIndexDiff _road_find_sig_dir_mod[4] = {
|
|
337 |
TILE_XY(-1,0), |
|
338 |
TILE_XY(0,1), |
|
339 |
TILE_XY(1,0), |
|
340 |
TILE_XY(0,-1), |
|
341 |
}; |
|
342 |
||
343 |
static const byte _road_pf_directions[16] = {
|
|
344 |
0, 1, 0, 1, 2, 1, 255, 255, |
|
345 |
2, 3, 3, 2, 3, 0, 255, 255, |
|
346 |
}; |
|
347 |
||
348 |
static bool EnumRoadSignalFindDepot(uint tile, RoadFindDepotData *rfdd, int track, uint length, byte *state) |
|
349 |
{
|
|
350 |
tile += _road_find_sig_dir_mod[_road_pf_directions[track]]; |
|
351 |
||
352 |
if (IS_TILETYPE(tile, MP_STREET) && |
|
353 |
(_map5[tile] & 0xF0) == 0x20 && |
|
354 |
_map_owner[tile] == rfdd->owner) {
|
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
355 |
|
| 0 | 356 |
if (length < rfdd->best_length) {
|
357 |
rfdd->best_length = length; |
|
358 |
rfdd->tile = tile; |
|
359 |
} |
|
360 |
} |
|
361 |
return false; |
|
362 |
} |
|
363 |
||
364 |
static int FindClosestRoadDepot(Vehicle *v) |
|
365 |
{
|
|
366 |
uint tile = v->tile; |
|
367 |
int i; |
|
368 |
RoadFindDepotData rfdd; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
369 |
|
| 0 | 370 |
if (v->u.road.state == 255) { tile = GetVehicleOutOfTunnelTile(v); }
|
371 |
||
372 |
rfdd.owner = v->owner; |
|
373 |
rfdd.best_length = (uint)-1; |
|
374 |
||
375 |
/* search in all directions */ |
|
376 |
for(i=0; i!=4; i++) |
|
|
159
139cf78bfb28
(svn r160) -Codechange: made GetTileTrackStatus more readable (blathijs)
truelight
parents:
156
diff
changeset
|
377 |
FollowTrack(tile, 0x2000 | TRANSPORT_ROAD, i, (TPFEnumProc*)EnumRoadSignalFindDepot, NULL, &rfdd); |
| 0 | 378 |
|
379 |
if (rfdd.best_length == (uint)-1) |
|
380 |
return -1; |
|
381 |
||
382 |
return GetDepotByTile(rfdd.tile); |
|
383 |
} |
|
384 |
||
385 |
int32 CmdSendRoadVehToDepot(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
|
386 |
{
|
|
387 |
Vehicle *v = &_vehicles[p1]; |
|
388 |
int depot; |
|
389 |
||
390 |
if (v->type != VEH_Road || !CheckOwnership(v->owner)) |
|
391 |
return CMD_ERROR; |
|
392 |
||
393 |
if ((v->next_order & OT_MASK) == OT_GOTO_DEPOT) {
|
|
394 |
if (flags & DC_EXEC) {
|
|
395 |
if (v->next_order & OF_UNLOAD) |
|
396 |
v->cur_order_index++; |
|
397 |
v->next_order = OT_DUMMY; |
|
398 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, 4); |
|
399 |
} |
|
400 |
return 0; |
|
401 |
} |
|
402 |
||
403 |
depot = FindClosestRoadDepot(v); |
|
404 |
if (depot < 0) |
|
405 |
return_cmd_error(STR_9019_UNABLE_TO_FIND_LOCAL_DEPOT); |
|
406 |
||
407 |
if (flags & DC_EXEC) {
|
|
408 |
v->next_order = OF_NON_STOP | OF_FULL_LOAD | OT_GOTO_DEPOT; |
|
409 |
v->next_order_param = (byte)depot; |
|
410 |
v->dest_tile = _depots[depot].xy; |
|
411 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, 4); |
|
412 |
} |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
413 |
|
| 0 | 414 |
return 0; |
415 |
} |
|
416 |
||
417 |
int32 CmdTurnRoadVeh(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
|
418 |
{
|
|
419 |
Vehicle *v; |
|
420 |
||
421 |
v = &_vehicles[p1]; |
|
422 |
||
423 |
if (v->type != VEH_Road || !CheckOwnership(v->owner)) |
|
424 |
return CMD_ERROR; |
|
425 |
||
426 |
if (v->vehstatus & (VS_HIDDEN|VS_STOPPED) || |
|
427 |
v->u.road.crashed_ctr != 0 || |
|
428 |
v->breakdown_ctr != 0 || |
|
429 |
v->u.road.overtaking != 0 || |
|
430 |
v->cur_speed < 5) {
|
|
431 |
_error_message = STR_EMPTY; |
|
432 |
return CMD_ERROR; |
|
433 |
} |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
434 |
|
| 0 | 435 |
if (flags & DC_EXEC) {
|
436 |
v->u.road.reverse_ctr = 180; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
437 |
} |
| 0 | 438 |
|
439 |
return 0; |
|
440 |
} |
|
441 |
||
442 |
int32 CmdChangeRoadVehServiceInt(int x, int y, uint32 flags, uint32 p1, uint32 p2) |
|
443 |
{
|
|
444 |
Vehicle *v; |
|
445 |
||
446 |
v = &_vehicles[p1]; |
|
447 |
||
448 |
if (v->type != VEH_Road || !CheckOwnership(v->owner)) |
|
449 |
return CMD_ERROR; |
|
450 |
||
451 |
if (flags & DC_EXEC) {
|
|
452 |
v->service_interval = (uint16)p2; |
|
453 |
InvalidateWindowWidget(WC_VEHICLE_DETAILS, v->index, 7); |
|
454 |
} |
|
455 |
||
456 |
return 0; |
|
457 |
} |
|
458 |
||
459 |
||
460 |
static void MarkRoadVehDirty(Vehicle *v) |
|
461 |
{
|
|
462 |
v->cur_image = GetRoadVehImage(v, v->direction); |
|
463 |
MarkAllViewportsDirty(v->left_coord, v->top_coord, v->right_coord + 1, v->bottom_coord + 1); |
|
464 |
} |
|
465 |
||
466 |
static void UpdateRoadVehDeltaXY(Vehicle *v) |
|
467 |
{
|
|
468 |
#define MKIT(a,b,c,d) ((a&0xFF)<<24) | ((b&0xFF)<<16) | ((c&0xFF)<<8) | ((d&0xFF)<<0) |
|
469 |
static const uint32 _delta_xy_table[8] = {
|
|
470 |
MKIT(3, 3, -1, -1), |
|
471 |
MKIT(3, 7, -1, -3), |
|
472 |
MKIT(3, 3, -1, -1), |
|
473 |
MKIT(7, 3, -3, -1), |
|
474 |
MKIT(3, 3, -1, -1), |
|
475 |
MKIT(3, 7, -1, -3), |
|
476 |
MKIT(3, 3, -1, -1), |
|
477 |
MKIT(7, 3, -3, -1), |
|
478 |
}; |
|
479 |
#undef MKIT |
|
480 |
uint32 x = _delta_xy_table[v->direction]; |
|
481 |
v->x_offs = (byte)x; |
|
482 |
v->y_offs = (byte)(x>>=8); |
|
483 |
v->sprite_width = (byte)(x>>=8); |
|
484 |
v->sprite_height = (byte)(x>>=8); |
|
485 |
} |
|
486 |
||
487 |
static void ClearCrashedStation(Vehicle *v) |
|
488 |
{
|
|
489 |
uint tile = v->tile; |
|
490 |
Station *st = DEREF_STATION(_map2[tile]); |
|
491 |
byte *b, bb; |
|
492 |
||
493 |
b = (_map5[tile] >= 0x47) ? &st->bus_stop_status : &st->truck_stop_status; |
|
494 |
||
495 |
bb = *b; |
|
496 |
||
497 |
// mark station as not busy |
|
498 |
bb &= ~0x80; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
499 |
|
| 0 | 500 |
// free parking bay |
501 |
bb |= (v->u.road.state&0x02)?2:1; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
502 |
|
| 0 | 503 |
*b = bb; |
504 |
} |
|
505 |
||
506 |
static void RoadVehDelete(Vehicle *v) |
|
507 |
{
|
|
508 |
DeleteWindowById(WC_VEHICLE_VIEW, v->index); |
|
509 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
510 |
|
|
164
0cbdf3c9bde1
(svn r165) -Feature: Option to sort vehicles in vehicle-list window by different criteria. Total independent sort for all types and players. Periodic resort of list every 10 TTD days. Thank you for your graphical inspiration follow and buxo (since none of you provided any code).
darkvater
parents:
159
diff
changeset
|
511 |
_vehicle_sort_dirty[VEHROAD] = true; // delete bus/truck (eg. crash for example) |
| 0 | 512 |
InvalidateWindow(WC_ROADVEH_LIST, v->owner); |
513 |
InvalidateWindow(WC_COMPANY, v->owner); |
|
514 |
||
515 |
if(IS_TILETYPE(v->tile, MP_STATION)) |
|
516 |
ClearCrashedStation(v); |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
517 |
|
| 0 | 518 |
BeginVehicleMove(v); |
519 |
EndVehicleMove(v); |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
520 |
|
| 0 | 521 |
DeleteVehicle(v); |
522 |
} |
|
523 |
||
524 |
static byte SetRoadVehPosition(Vehicle *v, int x, int y) |
|
525 |
{
|
|
526 |
byte new_z, old_z; |
|
527 |
||
528 |
// need this hint so it returns the right z coordinate on bridges. |
|
529 |
_get_z_hint = v->z_pos; |
|
530 |
new_z = GetSlopeZ(v->x_pos=x, v->y_pos=y); |
|
531 |
_get_z_hint = 0; |
|
532 |
||
533 |
old_z = v->z_pos; |
|
534 |
v->z_pos = new_z; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
535 |
|
| 0 | 536 |
VehiclePositionChanged(v); |
537 |
EndVehicleMove(v); |
|
538 |
return old_z; |
|
539 |
} |
|
540 |
||
541 |
static void RoadVehSetRandomDirection(Vehicle *v) |
|
542 |
{
|
|
543 |
static const int8 _turn_prob[4] = { -1, 0, 0, 1 };
|
|
544 |
uint32 r = Random(); |
|
545 |
v->direction = (v->direction+_turn_prob[r&3])&7; |
|
546 |
BeginVehicleMove(v); |
|
547 |
UpdateRoadVehDeltaXY(v); |
|
548 |
v->cur_image = GetRoadVehImage(v, v->direction); |
|
549 |
SetRoadVehPosition(v, v->x_pos, v->y_pos); |
|
550 |
} |
|
551 |
||
552 |
static void RoadVehIsCrashed(Vehicle *v) |
|
553 |
{
|
|
554 |
v->u.road.crashed_ctr++; |
|
555 |
if (v->u.road.crashed_ctr == 2) {
|
|
556 |
CreateEffectVehicleRel(v,4,4,8,EV_CRASHED_SMOKE); |
|
557 |
} else if (v->u.road.crashed_ctr <= 45) {
|
|
558 |
if ((v->tick_counter&7)==0) |
|
559 |
RoadVehSetRandomDirection(v); |
|
560 |
} else if (v->u.road.crashed_ctr >= 2220) {
|
|
561 |
RoadVehDelete(v); |
|
562 |
} |
|
563 |
} |
|
564 |
||
565 |
static void *EnumCheckRoadVehCrashTrain(Vehicle *v, Vehicle *u) |
|
566 |
{
|
|
567 |
if (v->type != VEH_Train || |
|
568 |
myabs(v->z_pos - u->z_pos) > 6 || |
|
569 |
myabs(v->x_pos - u->x_pos) > 4 || |
|
570 |
myabs(v->y_pos - u->y_pos) > 4) |
|
571 |
return NULL; |
|
572 |
return v; |
|
573 |
} |
|
574 |
||
575 |
static void RoadVehCrash(Vehicle *v) |
|
576 |
{
|
|
577 |
uint16 pass; |
|
578 |
||
579 |
v->u.road.crashed_ctr++; |
|
580 |
v->vehstatus |= VS_CRASHED; |
|
581 |
||
582 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, 4); |
|
583 |
||
584 |
pass = 1; |
|
585 |
if (v->cargo_type == 0) |
|
586 |
pass += v->cargo_count; |
|
587 |
v->cargo_count = 0; |
|
588 |
SET_DPARAM16(0, pass); |
|
589 |
||
590 |
AddNewsItem(STR_9031_ROAD_VEHICLE_CRASH_DRIVER+(pass!=1), |
|
591 |
NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ACCIDENT, 0), |
|
592 |
v->index, |
|
593 |
0); |
|
594 |
||
595 |
ModifyStationRatingAround(v->tile, v->owner, -160, 22); |
|
596 |
SndPlayVehicleFx(16, v); |
|
597 |
} |
|
598 |
||
599 |
static void RoadVehCheckTrainCrash(Vehicle *v) |
|
600 |
{
|
|
601 |
uint tile; |
|
602 |
||
603 |
if (v->u.road.state == 255) |
|
604 |
return; |
|
605 |
||
606 |
tile = v->tile; |
|
607 |
||
608 |
// Make sure it's a road/rail crossing |
|
609 |
if (!IS_TILETYPE(tile, MP_STREET) || |
|
610 |
(_map5[tile] & 0xF0) != 0x10) |
|
611 |
return; |
|
612 |
||
613 |
if (VehicleFromPos(tile, v, (VehicleFromPosProc*)EnumCheckRoadVehCrashTrain) != NULL) |
|
614 |
RoadVehCrash(v); |
|
615 |
} |
|
616 |
||
617 |
static void HandleBrokenRoadVeh(Vehicle *v) |
|
618 |
{
|
|
619 |
if (v->breakdown_ctr != 1) {
|
|
620 |
v->breakdown_ctr = 1; |
|
621 |
v->cur_speed = 0; |
|
622 |
||
623 |
if (v->breakdowns_since_last_service != 255) |
|
624 |
v->breakdowns_since_last_service++; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
625 |
|
| 0 | 626 |
InvalidateWindow(WC_VEHICLE_VIEW, v->index); |
627 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
628 |
|
| 0 | 629 |
SndPlayVehicleFx((_opt.landscape != LT_CANDY) ? 0xD : 0x34, v); |
630 |
||
631 |
if (!(v->vehstatus & VS_HIDDEN)) {
|
|
632 |
Vehicle *u = CreateEffectVehicleRel(v, 4, 4, 5, EV_BREAKDOWN_SMOKE); |
|
633 |
if (u) |
|
634 |
u->u.special.unk0 = v->breakdown_delay * 2; |
|
635 |
} |
|
636 |
} |
|
637 |
||
638 |
if (!(v->tick_counter & 1)) {
|
|
639 |
if (!--v->breakdown_delay) {
|
|
640 |
v->breakdown_ctr = 0; |
|
641 |
InvalidateWindow(WC_VEHICLE_VIEW, v->index); |
|
642 |
} |
|
643 |
} |
|
644 |
} |
|
645 |
||
646 |
static void ProcessRoadVehOrder(Vehicle *v) |
|
647 |
{
|
|
648 |
uint order; |
|
649 |
Station *st; |
|
650 |
||
651 |
if ((v->next_order & OT_MASK) >= OT_GOTO_DEPOT && (v->next_order & OT_MASK) <= OT_LEAVESTATION) {
|
|
652 |
// Let a depot order in the schedule interrupt. |
|
653 |
if ((v->next_order & (OT_MASK|OF_UNLOAD)) != (OT_GOTO_DEPOT|OF_UNLOAD)) |
|
654 |
return; |
|
655 |
} |
|
656 |
||
657 |
if ((v->next_order & (OT_MASK|OF_UNLOAD|OF_FULL_LOAD)) == (OT_GOTO_DEPOT|OF_UNLOAD|OF_FULL_LOAD) && |
|
|
156
8fef5e5752d6
(svn r157) -Feature: [1009708] Percent-based service intervals. Send a vehicle to depot after it has lost X% of its reliability (mivlad)
darkvater
parents:
76
diff
changeset
|
658 |
SERVICE_INTERVAL ) {
|
| 0 | 659 |
v->cur_order_index++; |
660 |
} |
|
661 |
||
662 |
if (v->cur_order_index >= v->num_orders) |
|
663 |
v->cur_order_index = 0; |
|
664 |
||
665 |
order = v->schedule_ptr[v->cur_order_index]; |
|
666 |
||
667 |
if (order == 0) {
|
|
668 |
v->next_order = OT_NOTHING; |
|
669 |
v->dest_tile = 0; |
|
670 |
return; |
|
671 |
} |
|
672 |
||
673 |
if (order == (uint)((v->next_order | (v->next_order_param<<8)))) |
|
674 |
return; |
|
675 |
||
676 |
v->next_order = (byte)order; |
|
677 |
v->next_order_param = (byte)(order >> 8); |
|
678 |
||
679 |
v->dest_tile = 0; |
|
680 |
||
681 |
if ((order & OT_MASK) == OT_GOTO_STATION) {
|
|
682 |
if ( (byte)(order >> 8) == v->last_station_visited) |
|
683 |
v->last_station_visited = 0xFF; |
|
684 |
st = DEREF_STATION(order >> 8); |
|
685 |
v->dest_tile = v->cargo_type==CT_PASSENGERS ? st->bus_tile : st->lorry_tile; |
|
686 |
} else if ((order & OT_MASK) == OT_GOTO_DEPOT) {
|
|
687 |
v->dest_tile = _depots[order >> 8].xy; |
|
688 |
} |
|
689 |
||
690 |
InvalidateVehicleOrderWidget(v); |
|
691 |
} |
|
692 |
||
693 |
static void HandleRoadVehLoading(Vehicle *v) |
|
694 |
{
|
|
695 |
if (v->next_order == OT_NOTHING) |
|
696 |
return; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
697 |
|
| 0 | 698 |
if (v->next_order != OT_DUMMY) {
|
699 |
if ((v->next_order&OT_MASK) != OT_LOADING) |
|
700 |
return; |
|
701 |
||
702 |
if (--v->load_unload_time_rem) |
|
703 |
return; |
|
704 |
||
705 |
if (v->next_order&OF_FULL_LOAD && CanFillVehicle(v)) {
|
|
706 |
SET_EXPENSES_TYPE(EXPENSES_ROADVEH_INC); |
|
707 |
if (LoadUnloadVehicle(v)) {
|
|
708 |
InvalidateWindow(WC_ROADVEH_LIST, v->owner); |
|
709 |
MarkRoadVehDirty(v); |
|
710 |
} |
|
711 |
return; |
|
712 |
} |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
713 |
|
| 0 | 714 |
{
|
715 |
byte b = v->next_order; |
|
716 |
v->next_order = OT_LEAVESTATION; |
|
717 |
if (!(b & OF_NON_STOP)) |
|
718 |
return; |
|
719 |
} |
|
720 |
} |
|
721 |
||
722 |
v->cur_order_index++; |
|
723 |
InvalidateVehicleOrderWidget(v); |
|
724 |
} |
|
725 |
||
726 |
static void StartRoadVehSound(Vehicle *v) |
|
727 |
{
|
|
728 |
int s = _road_engine_sounds[v->engine_type - ROAD_ENGINES_INDEX]; |
|
729 |
if (s == 23 && (v->tick_counter&3) == 0) s++; |
|
730 |
SndPlayVehicleFx(s, v); |
|
731 |
} |
|
732 |
||
733 |
typedef struct RoadVehFindData {
|
|
734 |
int x,y; |
|
735 |
Vehicle *veh; |
|
736 |
byte dir; |
|
737 |
} RoadVehFindData; |
|
738 |
||
739 |
void *EnumCheckRoadVehClose(Vehicle *v, RoadVehFindData *rvf) |
|
740 |
{
|
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
741 |
static const short _dists[] = {
|
|
63
53cc59601b3c
(svn r64) Fix: Road vehicles don't get stuck any more (Truelight + Celestar
dominik
parents:
19
diff
changeset
|
742 |
-4, -8, -4, -1, 4, 8, 4, 1, |
|
53cc59601b3c
(svn r64) Fix: Road vehicles don't get stuck any more (Truelight + Celestar
dominik
parents:
19
diff
changeset
|
743 |
-4, -1, 4, 8, 4, 1, -4, -8, |
| 0 | 744 |
}; |
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
745 |
|
|
63
53cc59601b3c
(svn r64) Fix: Road vehicles don't get stuck any more (Truelight + Celestar
dominik
parents:
19
diff
changeset
|
746 |
short x_diff = v->x_pos - rvf->x; |
|
53cc59601b3c
(svn r64) Fix: Road vehicles don't get stuck any more (Truelight + Celestar
dominik
parents:
19
diff
changeset
|
747 |
short y_diff = v->y_pos - rvf->y; |
| 0 | 748 |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
749 |
if (rvf->veh == v || |
|
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
750 |
v->type != VEH_Road || |
| 0 | 751 |
v->u.road.state == 254 || |
752 |
myabs(v->z_pos - rvf->veh->z_pos) > 6 || |
|
753 |
v->direction != rvf->dir || |
|
|
63
53cc59601b3c
(svn r64) Fix: Road vehicles don't get stuck any more (Truelight + Celestar
dominik
parents:
19
diff
changeset
|
754 |
(_dists[v->direction] < 0 && (x_diff <= _dists[v->direction] || x_diff > 0)) || |
|
53cc59601b3c
(svn r64) Fix: Road vehicles don't get stuck any more (Truelight + Celestar
dominik
parents:
19
diff
changeset
|
755 |
(_dists[v->direction] > 0 && (x_diff >= _dists[v->direction] || x_diff < 0)) || |
|
53cc59601b3c
(svn r64) Fix: Road vehicles don't get stuck any more (Truelight + Celestar
dominik
parents:
19
diff
changeset
|
756 |
(_dists[v->direction+8] < 0 && (y_diff <= _dists[v->direction+8] || y_diff > 0)) || |
|
53cc59601b3c
(svn r64) Fix: Road vehicles don't get stuck any more (Truelight + Celestar
dominik
parents:
19
diff
changeset
|
757 |
(_dists[v->direction+8] > 0 && (y_diff >= _dists[v->direction+8] || y_diff < 0))) |
|
53cc59601b3c
(svn r64) Fix: Road vehicles don't get stuck any more (Truelight + Celestar
dominik
parents:
19
diff
changeset
|
758 |
return NULL; |
| 0 | 759 |
|
760 |
return v; |
|
761 |
} |
|
762 |
||
763 |
static Vehicle *RoadVehFindCloseTo(Vehicle *v, int x, int y, byte dir) |
|
764 |
{
|
|
765 |
RoadVehFindData rvf; |
|
766 |
Vehicle *u; |
|
767 |
||
768 |
if (v->u.road.reverse_ctr != 0) |
|
769 |
return NULL; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
770 |
|
| 0 | 771 |
rvf.x = x; |
772 |
rvf.y = y; |
|
773 |
rvf.dir = dir; |
|
774 |
rvf.veh = v; |
|
775 |
u = VehicleFromPos(TILE_FROM_XY(x,y), &rvf, (VehicleFromPosProc*)EnumCheckRoadVehClose); |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
776 |
|
|
63
53cc59601b3c
(svn r64) Fix: Road vehicles don't get stuck any more (Truelight + Celestar
dominik
parents:
19
diff
changeset
|
777 |
// This code protects a roadvehicle from being blocked for ever |
|
53cc59601b3c
(svn r64) Fix: Road vehicles don't get stuck any more (Truelight + Celestar
dominik
parents:
19
diff
changeset
|
778 |
// If more then 1480 / 74 days a road vehicle is blocked, it will |
|
53cc59601b3c
(svn r64) Fix: Road vehicles don't get stuck any more (Truelight + Celestar
dominik
parents:
19
diff
changeset
|
779 |
// drive just through it. The ultimate backup-code of TTD. |
|
53cc59601b3c
(svn r64) Fix: Road vehicles don't get stuck any more (Truelight + Celestar
dominik
parents:
19
diff
changeset
|
780 |
// It can be disabled. |
| 0 | 781 |
if (u == NULL) {
|
782 |
v->u.road.unk2 = 0; |
|
783 |
return NULL; |
|
784 |
} |
|
785 |
||
786 |
if (++v->u.road.unk2 > 1480) |
|
787 |
return NULL; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
788 |
|
| 0 | 789 |
return u; |
790 |
} |
|
791 |
||
792 |
static void RoadVehArrivesAt(Vehicle *v, Station *st) |
|
793 |
{
|
|
794 |
if (v->engine_type < 123) {
|
|
795 |
/* Check if station was ever visited before */ |
|
796 |
if (!(st->had_vehicle_of_type & HVOT_BUS)) {
|
|
797 |
uint32 flags; |
|
798 |
||
799 |
st->had_vehicle_of_type |= HVOT_BUS; |
|
800 |
SET_DPARAM16(0, st->index); |
|
801 |
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); |
|
802 |
AddNewsItem( |
|
803 |
STR_902F_CITIZENS_CELEBRATE_FIRST, |
|
804 |
flags, |
|
805 |
v->index, |
|
806 |
0); |
|
807 |
} |
|
808 |
} else {
|
|
809 |
/* Check if station was ever visited before */ |
|
810 |
if (!(st->had_vehicle_of_type & HVOT_TRUCK)) {
|
|
811 |
uint32 flags; |
|
812 |
||
813 |
st->had_vehicle_of_type |= HVOT_TRUCK; |
|
814 |
SET_DPARAM16(0, st->index); |
|
815 |
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); |
|
816 |
AddNewsItem( |
|
817 |
STR_9030_CITIZENS_CELEBRATE_FIRST, |
|
818 |
flags, |
|
819 |
v->index, |
|
820 |
0); |
|
821 |
} |
|
822 |
} |
|
823 |
} |
|
824 |
||
825 |
static bool RoadVehAccelerate(Vehicle *v) |
|
826 |
{
|
|
827 |
uint spd = v->cur_speed + 1 + ((v->u.road.overtaking != 0)?1:0); |
|
828 |
byte t; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
829 |
|
| 0 | 830 |
// Clamp |
831 |
spd = min(spd, v->max_speed); |
|
832 |
||
833 |
//updates statusbar only if speed have changed to save CPU time |
|
834 |
if (spd != v->cur_speed) {
|
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
835 |
v->cur_speed = spd; |
| 0 | 836 |
if (_patches.vehicle_speed) |
837 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, 4); |
|
838 |
} |
|
839 |
||
840 |
// Decrease somewhat when turning |
|
841 |
if (!(v->direction&1)) |
|
842 |
spd = spd * 3 >> 2; |
|
843 |
||
844 |
if (spd == 0) |
|
845 |
return false; |
|
846 |
||
847 |
if ((byte)++spd == 0) |
|
848 |
return true; |
|
849 |
||
850 |
v->progress = (t = v->progress) - (byte)spd; |
|
851 |
||
852 |
return (t < v->progress); |
|
853 |
} |
|
854 |
||
855 |
static byte RoadVehGetNewDirection(Vehicle *v, int x, int y) |
|
856 |
{
|
|
857 |
static const byte _roadveh_new_dir[11] = {
|
|
858 |
0, 7, 6, 0, |
|
859 |
1, 0, 5, 0, |
|
860 |
2, 3, 4 |
|
861 |
}; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
862 |
|
| 0 | 863 |
x = x - v->x_pos + 1; |
864 |
y = y - v->y_pos + 1; |
|
865 |
||
866 |
if ((uint)x > 2 || (uint)y > 2) |
|
867 |
return v->direction; |
|
868 |
return _roadveh_new_dir[y*4+x]; |
|
869 |
} |
|
870 |
||
871 |
static byte RoadVehGetSlidingDirection(Vehicle *v, int x, int y) |
|
872 |
{
|
|
873 |
byte b = RoadVehGetNewDirection(v,x,y); |
|
874 |
byte d = v->direction; |
|
875 |
if (b == d) return d; |
|
876 |
d = (d+1)&7; |
|
877 |
if (b==d) return d; |
|
878 |
d = (d-2)&7; |
|
879 |
if (b==d) return d; |
|
880 |
if (b==((d-1)&7)) return d; |
|
881 |
if (b==((d-2)&7)) return d; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
882 |
return (d+2)&7; |
| 0 | 883 |
} |
884 |
||
885 |
typedef struct OvertakeData {
|
|
886 |
Vehicle *u, *v; |
|
887 |
uint tile; |
|
888 |
byte tilebits; |
|
889 |
} OvertakeData; |
|
890 |
||
891 |
void *EnumFindVehToOvertake(Vehicle *v, OvertakeData *od) |
|
892 |
{
|
|
893 |
if (v->tile != (TileIndex)od->tile || |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
894 |
v->type != VEH_Road || |
|
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
895 |
v == od->u || |
| 0 | 896 |
v == od->v) |
897 |
return NULL; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
898 |
return v; |
| 0 | 899 |
} |
900 |
||
901 |
static bool FindRoadVehToOvertake(OvertakeData *od) |
|
902 |
{
|
|
903 |
uint32 bits; |
|
904 |
||
|
159
139cf78bfb28
(svn r160) -Codechange: made GetTileTrackStatus more readable (blathijs)
truelight
parents:
156
diff
changeset
|
905 |
bits = GetTileTrackStatus(od->tile, TRANSPORT_ROAD)&0x3F; |
| 0 | 906 |
|
907 |
if (!(od->tilebits & bits) || (bits&0x3C) || (bits & 0x3F3F0000)) |
|
908 |
return true; |
|
909 |
return VehicleFromPos(od->tile, od, (VehicleFromPosProc*)EnumFindVehToOvertake) != NULL; |
|
910 |
} |
|
911 |
||
912 |
static void RoadVehCheckOvertake(Vehicle *v, Vehicle *u) |
|
913 |
{
|
|
914 |
OvertakeData od; |
|
915 |
byte tt; |
|
916 |
||
917 |
od.v = v; |
|
918 |
od.u = u; |
|
919 |
||
920 |
if (u->max_speed >= v->max_speed && |
|
921 |
!(u->vehstatus&VS_STOPPED) && |
|
922 |
u->cur_speed != 0) |
|
923 |
return; |
|
924 |
||
925 |
if (v->direction != u->direction || !(v->direction&1)) |
|
926 |
return; |
|
927 |
||
928 |
if (v->u.road.state >= 32 || (v->u.road.state&7) > 1 ) |
|
929 |
return; |
|
930 |
||
|
159
139cf78bfb28
(svn r160) -Codechange: made GetTileTrackStatus more readable (blathijs)
truelight
parents:
156
diff
changeset
|
931 |
tt = (byte)(GetTileTrackStatus(v->tile, TRANSPORT_ROAD) & 0x3F); |
| 0 | 932 |
if ((tt & 3) == 0) |
933 |
return; |
|
934 |
if ((tt & 0x3C) != 0) |
|
935 |
return; |
|
936 |
||
937 |
if (tt == 3) {
|
|
938 |
tt = (v->direction&2)?2:1; |
|
939 |
} |
|
940 |
od.tilebits = tt; |
|
941 |
||
942 |
od.tile = v->tile; |
|
943 |
if (FindRoadVehToOvertake(&od)) |
|
944 |
return; |
|
945 |
||
946 |
od.tile = v->tile + _tileoffs_by_dir[v->direction>>1]; |
|
947 |
if (FindRoadVehToOvertake(&od)) |
|
948 |
return; |
|
949 |
||
950 |
if (od.u->cur_speed == 0 || od.u->vehstatus&VS_STOPPED) {
|
|
951 |
v->u.road.overtaking_ctr = 0x11; |
|
952 |
v->u.road.overtaking = 0x10; |
|
953 |
} else {
|
|
954 |
// if (FindRoadVehToOvertake(&od)) |
|
955 |
// return; |
|
956 |
v->u.road.overtaking_ctr = 0; |
|
957 |
v->u.road.overtaking = 0x10; |
|
958 |
} |
|
959 |
} |
|
960 |
||
961 |
static void RoadZPosAffectSpeed(Vehicle *v, byte old_z) |
|
962 |
{
|
|
963 |
if (old_z == v->z_pos) |
|
964 |
return; |
|
965 |
||
966 |
if (old_z < v->z_pos) {
|
|
967 |
v->cur_speed = v->cur_speed * 232 >> 8; |
|
968 |
} else {
|
|
969 |
uint16 spd = v->cur_speed + 2; |
|
970 |
if (spd <= v->max_speed) |
|
971 |
v->cur_speed = spd; |
|
972 |
} |
|
973 |
} |
|
974 |
||
975 |
static int PickRandomBit(uint bits) |
|
976 |
{
|
|
977 |
uint num = 0; |
|
978 |
uint b = bits; |
|
979 |
uint i; |
|
980 |
||
981 |
do {
|
|
982 |
if (b & 1) |
|
983 |
num++; |
|
984 |
} while (b >>= 1); |
|
985 |
||
986 |
num = ((uint16)Random() * num >> 16); |
|
987 |
||
988 |
for(i=0; !((bits & 1) && ((int)--num) < 0); bits>>=1,i++); |
|
989 |
return i; |
|
990 |
} |
|
991 |
||
992 |
typedef struct {
|
|
993 |
TileIndex dest; |
|
994 |
uint maxtracklen; |
|
995 |
uint mindist; |
|
996 |
} FindRoadToChooseData; |
|
997 |
||
998 |
static bool EnumRoadTrackFindDist(uint tile, FindRoadToChooseData *frd, int track, uint length, byte *state) |
|
999 |
{
|
|
1000 |
uint dist = GetTileDist(tile, frd->dest); |
|
1001 |
if (dist <= frd->mindist) {
|
|
1002 |
if (dist != frd->mindist || length < frd->maxtracklen) {
|
|
1003 |
frd->maxtracklen = length; |
|
1004 |
} |
|
1005 |
frd->mindist = dist; |
|
1006 |
} |
|
1007 |
return false; |
|
1008 |
} |
|
1009 |
||
1010 |
// Returns direction to choose |
|
1011 |
// or -1 if the direction is currently blocked |
|
1012 |
static int RoadFindPathToDest(Vehicle *v, uint tile, int direction) |
|
1013 |
{
|
|
1014 |
#define return_track(x) {best_track = x; goto found_best_track; }
|
|
1015 |
||
1016 |
uint16 signal; |
|
1017 |
uint bitmask; |
|
1018 |
uint desttile; |
|
1019 |
FindRoadToChooseData frd; |
|
1020 |
int best_track; |
|
1021 |
uint best_dist, best_maxlen; |
|
1022 |
uint i; |
|
1023 |
byte m5; |
|
1024 |
||
1025 |
{
|
|
1026 |
uint32 r; |
|
|
241
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1027 |
r = GetTileTrackStatus(tile, TRANSPORT_ROAD); |
| 0 | 1028 |
signal = (uint16)(r >> 16); |
1029 |
bitmask = (uint16)r; |
|
1030 |
} |
|
1031 |
||
|
241
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1032 |
if (IS_TILETYPE(tile, MP_STREET)) {
|
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1033 |
if ((_map5[tile]&0xF0) == 0x20 && v->owner == _map_owner[tile]) |
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1034 |
/* Road crossing */ |
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1035 |
bitmask |= _road_veh_fp_ax_or[_map5[tile]&3]; |
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1036 |
} else if (IS_TILETYPE(tile, MP_STATION)) {
|
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1037 |
if (_map_owner[tile] == OWNER_NONE || _map_owner[tile] == v->owner) {
|
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1038 |
/* Our station */ |
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1039 |
Station *st = DEREF_STATION(_map2[tile]); |
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1040 |
byte val = _map5[tile]; |
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1041 |
if (v->cargo_type != CT_PASSENGERS) {
|
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1042 |
if (IS_BYTE_INSIDE(val, 0x43, 0x47) && (_patches.roadveh_queue || st->truck_stop_status&3)) |
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1043 |
bitmask |= _road_veh_fp_ax_or[(val-0x43)&3]; |
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1044 |
} else {
|
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1045 |
if (IS_BYTE_INSIDE(val, 0x47, 0x4B) && (_patches.roadveh_queue || st->bus_stop_status&3)) |
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1046 |
bitmask |= _road_veh_fp_ax_or[(val-0x47)&3]; |
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1047 |
} |
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1048 |
} |
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1049 |
} |
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1050 |
/* The above lookups should be moved to GetTileTrackStatus in the |
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1051 |
* future, but that requires more changes to the pathfinder and other |
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1052 |
* stuff, probably even more arguments to GTTS. |
|
e6e62a5e7f52
(svn r242) -Fix: Pathfinding bug for road vehicles introduced in r160 fixed (blathijs)
darkvater
parents:
193
diff
changeset
|
1053 |
*/ |
| 0 | 1054 |
|
|
159
139cf78bfb28
(svn r160) -Codechange: made GetTileTrackStatus more readable (blathijs)
truelight
parents:
156
diff
changeset
|
1055 |
/* remove unreachable tracks */ |
| 0 | 1056 |
bitmask &= _road_veh_fp_ax_and[direction]; |
1057 |
if (bitmask == 0) {
|
|
1058 |
// reverse |
|
1059 |
return_track(_road_reverse_table[direction]); |
|
1060 |
} |
|
1061 |
||
1062 |
if (v->u.road.reverse_ctr != 0) {
|
|
1063 |
v->u.road.reverse_ctr = 0; |
|
1064 |
if (v->tile != (TileIndex)tile) {
|
|
1065 |
return_track(_road_reverse_table[direction]); |
|
1066 |
} |
|
1067 |
} |
|
1068 |
||
1069 |
desttile = v->dest_tile; |
|
1070 |
if (desttile == 0) {
|
|
1071 |
// Pick a random direction |
|
1072 |
return_track(PickRandomBit(bitmask)); |
|
1073 |
} |
|
1074 |
||
1075 |
// Only one direction to choose between? |
|
1076 |
if (!(bitmask & (bitmask - 1))) {
|
|
1077 |
return_track(FindFirstBit2x64(bitmask)); |
|
1078 |
} |
|
1079 |
||
1080 |
if (IS_TILETYPE(desttile, MP_STREET)) {
|
|
1081 |
m5 = _map5[desttile]; |
|
1082 |
if ((m5&0xF0) == 0x20) |
|
1083 |
goto do_it; |
|
1084 |
} else if (IS_TILETYPE(desttile, MP_STATION)) {
|
|
1085 |
m5 = _map5[desttile]; |
|
1086 |
if (IS_BYTE_INSIDE(m5, 0x43, 0x4B)) {
|
|
1087 |
m5 -= 0x43; |
|
1088 |
do_it:; |
|
1089 |
desttile += _tileoffs_by_dir[m5&3]; |
|
1090 |
if (desttile == tile && bitmask&_road_pf_table_3[m5&3]) {
|
|
1091 |
return_track(FindFirstBit2x64(bitmask&_road_pf_table_3[m5&3])); |
|
1092 |
} |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1093 |
} |
| 0 | 1094 |
} |
1095 |
// do pathfind |
|
1096 |
frd.dest = desttile; |
|
1097 |
||
1098 |
best_track = -1; |
|
1099 |
best_dist = (uint)-1; |
|
1100 |
best_maxlen = (uint)-1; |
|
1101 |
i = 0; |
|
1102 |
do {
|
|
1103 |
if (bitmask & 1) {
|
|
1104 |
if (best_track == -1) best_track = i; // in case we don't find the path, just pick a direction |
|
1105 |
frd.maxtracklen = (uint)-1; |
|
1106 |
frd.mindist = (uint)-1; |
|
|
159
139cf78bfb28
(svn r160) -Codechange: made GetTileTrackStatus more readable (blathijs)
truelight
parents:
156
diff
changeset
|
1107 |
FollowTrack(tile, 0x3000 | TRANSPORT_ROAD, _road_pf_directions[i], (TPFEnumProc*)EnumRoadTrackFindDist, NULL, &frd); |
| 0 | 1108 |
|
1109 |
if (frd.mindist < best_dist || (frd.mindist==best_dist && frd.maxtracklen < best_maxlen)) {
|
|
1110 |
best_dist = frd.mindist; |
|
1111 |
best_maxlen = frd.maxtracklen; |
|
1112 |
best_track = i; |
|
1113 |
} |
|
1114 |
} |
|
1115 |
} while (++i,(bitmask>>=1) != 0); |
|
1116 |
||
1117 |
found_best_track:; |
|
1118 |
||
1119 |
if (HASBIT(signal, best_track)) |
|
1120 |
return -1; |
|
1121 |
||
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1122 |
return best_track; |
| 0 | 1123 |
} |
1124 |
||
1125 |
typedef struct RoadDriveEntry {
|
|
1126 |
byte x,y; |
|
1127 |
} RoadDriveEntry; |
|
1128 |
||
1129 |
#include "table/roadveh.h" |
|
1130 |
||
1131 |
static const byte _road_veh_data_1[] = {
|
|
1132 |
20, 20, 16, 16, 0, 0, 0, 0, |
|
1133 |
19, 19, 15, 15, 0, 0, 0, 0, |
|
1134 |
16, 16, 12, 12, 0, 0, 0, 0, |
|
1135 |
15, 15, 11, 11 |
|
1136 |
}; |
|
1137 |
||
1138 |
static const byte _roadveh_data_2[4] = { 0,1,8,9 };
|
|
1139 |
||
1140 |
static void RoadVehEventHandler(Vehicle *v) |
|
1141 |
{
|
|
1142 |
GetNewVehiclePosResult gp; |
|
1143 |
byte new_dir,old_dir,old_order; |
|
1144 |
RoadDriveEntry rd; |
|
1145 |
int x,y; |
|
1146 |
Station *st; |
|
1147 |
uint32 r; |
|
1148 |
Vehicle *u; |
|
1149 |
||
1150 |
// decrease counters |
|
1151 |
v->tick_counter++; |
|
1152 |
if (v->u.road.reverse_ctr != 0) |
|
1153 |
v->u.road.reverse_ctr--; |
|
1154 |
||
1155 |
// handle crashed |
|
1156 |
if (v->u.road.crashed_ctr != 0) {
|
|
1157 |
RoadVehIsCrashed(v); |
|
1158 |
return; |
|
1159 |
} |
|
1160 |
||
1161 |
RoadVehCheckTrainCrash(v); |
|
1162 |
||
1163 |
// road vehicle has broken down? |
|
1164 |
if (v->breakdown_ctr != 0) {
|
|
1165 |
if (v->breakdown_ctr <= 2) {
|
|
1166 |
HandleBrokenRoadVeh(v); |
|
1167 |
return; |
|
1168 |
} |
|
1169 |
v->breakdown_ctr--; |
|
1170 |
} |
|
1171 |
||
1172 |
// exit if vehicle is stopped |
|
1173 |
if (v->vehstatus & VS_STOPPED) |
|
1174 |
return; |
|
1175 |
||
1176 |
ProcessRoadVehOrder(v); |
|
1177 |
HandleRoadVehLoading(v); |
|
1178 |
||
1179 |
if ((v->next_order & OT_MASK) == OT_LOADING) |
|
1180 |
return; |
|
1181 |
||
1182 |
if (v->u.road.state == 254) {
|
|
1183 |
int dir; |
|
1184 |
const RoadDriveEntry*rdp; |
|
1185 |
byte rd2; |
|
1186 |
||
1187 |
v->cur_speed = 0; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1188 |
|
| 0 | 1189 |
dir = _map5[v->tile]&3; |
1190 |
v->direction = dir*2+1; |
|
1191 |
||
1192 |
rd2 = _roadveh_data_2[dir]; |
|
1193 |
rdp = _road_drive_data[(_opt.road_side<<4) + rd2]; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1194 |
|
| 0 | 1195 |
x = GET_TILE_X(v->tile)*16 + (rdp[6].x&0xF); |
1196 |
y = GET_TILE_Y(v->tile)*16 + (rdp[6].y&0xF); |
|
1197 |
||
1198 |
if (RoadVehFindCloseTo(v,x,y,v->direction)) |
|
1199 |
return; |
|
1200 |
||
1201 |
StartRoadVehSound(v); |
|
1202 |
||
1203 |
BeginVehicleMove(v); |
|
1204 |
||
1205 |
v->vehstatus &= ~VS_HIDDEN; |
|
1206 |
v->u.road.state = rd2; |
|
1207 |
v->u.road.frame = 6; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1208 |
|
| 0 | 1209 |
v->cur_image = GetRoadVehImage(v, v->direction); |
1210 |
UpdateRoadVehDeltaXY(v); |
|
1211 |
SetRoadVehPosition(v,x,y); |
|
1212 |
||
1213 |
InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); |
|
1214 |
return; |
|
1215 |
} |
|
1216 |
||
1217 |
if (!RoadVehAccelerate(v)) |
|
1218 |
return; |
|
1219 |
||
1220 |
if (v->u.road.overtaking != 0) {
|
|
1221 |
if (++v->u.road.overtaking_ctr >= 35) |
|
1222 |
v->u.road.overtaking = 0; |
|
1223 |
} |
|
1224 |
||
1225 |
BeginVehicleMove(v); |
|
1226 |
||
1227 |
if (v->u.road.state == 255) {
|
|
1228 |
GetNewVehiclePos(v, &gp); |
|
1229 |
||
1230 |
if (RoadVehFindCloseTo(v, gp.x, gp.y, v->direction)) {
|
|
1231 |
v->cur_speed = 0; |
|
1232 |
return; |
|
1233 |
} |
|
1234 |
||
1235 |
if (IS_TILETYPE(gp.new_tile, MP_TUNNELBRIDGE) && |
|
1236 |
(_map5[gp.new_tile]&0xF0) == 0 && |
|
1237 |
(VehicleEnterTile(v, gp.new_tile, gp.x, gp.y)&4)) {
|
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1238 |
|
| 0 | 1239 |
//new_dir = RoadGetNewDirection(v, gp.x, gp.y) |
1240 |
v->cur_image = GetRoadVehImage(v, v->direction); |
|
1241 |
UpdateRoadVehDeltaXY(v); |
|
1242 |
SetRoadVehPosition(v,gp.x,gp.y); |
|
1243 |
return; |
|
1244 |
} |
|
1245 |
||
1246 |
v->x_pos = gp.x; |
|
1247 |
v->y_pos = gp.y; |
|
1248 |
VehiclePositionChanged(v); |
|
1249 |
return; |
|
1250 |
} |
|
1251 |
||
1252 |
rd = _road_drive_data[(v->u.road.state + (_opt.road_side<<4)) ^ v->u.road.overtaking][v->u.road.frame+1]; |
|
1253 |
||
1254 |
// switch to another tile |
|
1255 |
if (rd.x & 0x80) {
|
|
1256 |
uint tile = v->tile + _tileoffs_by_dir[rd.x&3]; |
|
1257 |
int dir = RoadFindPathToDest(v, tile, rd.x&3); |
|
1258 |
int tmp; |
|
1259 |
uint32 r; |
|
1260 |
byte newdir; |
|
1261 |
const RoadDriveEntry *rdp; |
|
1262 |
||
1263 |
if (dir == -1) {
|
|
1264 |
v->cur_speed = 0; |
|
1265 |
return; |
|
1266 |
} |
|
1267 |
||
1268 |
again: |
|
1269 |
if ((dir & 7) >= 6) {
|
|
1270 |
tile = v->tile; |
|
1271 |
} |
|
1272 |
||
1273 |
tmp = (dir+(_opt.road_side<<4))^v->u.road.overtaking; |
|
1274 |
rdp = _road_drive_data[tmp]; |
|
1275 |
||
1276 |
tmp &= ~0x10; |
|
1277 |
||
1278 |
x = GET_TILE_X(tile)*16 + rdp[0].x; |
|
1279 |
y = GET_TILE_Y(tile)*16 + rdp[0].y; |
|
1280 |
||
1281 |
if (RoadVehFindCloseTo(v, x, y, newdir=RoadVehGetSlidingDirection(v, x, y))) |
|
1282 |
return; |
|
1283 |
||
1284 |
r = VehicleEnterTile(v, tile, x, y); |
|
1285 |
if (r & 8) {
|
|
1286 |
if (!IS_TILETYPE(tile, MP_TUNNELBRIDGE)) {
|
|
1287 |
v->cur_speed = 0; |
|
1288 |
return; |
|
1289 |
} |
|
1290 |
dir = _road_reverse_table[rd.x&3]; |
|
1291 |
goto again; |
|
1292 |
} |
|
1293 |
||
1294 |
if (IS_BYTE_INSIDE(v->u.road.state, 0x20, 0x30) && IS_TILETYPE(v->tile, MP_STATION)) {
|
|
1295 |
if ((tmp&7) >= 6) { v->cur_speed = 0; return; }
|
|
1296 |
if (IS_BYTE_INSIDE(_map5[v->tile], 0x43, 0x4B)) {
|
|
1297 |
Station *st = DEREF_STATION(_map2[v->tile]); |
|
1298 |
byte *b; |
|
1299 |
||
1300 |
if (_map5[v->tile] >= 0x47) {
|
|
1301 |
b = &st->bus_stop_status; |
|
1302 |
} else {
|
|
1303 |
b = &st->truck_stop_status; |
|
1304 |
} |
|
1305 |
*b = (*b | ((v->u.road.state&2)?2:1)) & 0x7F; |
|
1306 |
} |
|
1307 |
} |
|
1308 |
||
1309 |
if (!(r & 4)) {
|
|
1310 |
v->tile = tile; |
|
1311 |
v->u.road.state = (byte)tmp; |
|
1312 |
v->u.road.frame = 0; |
|
1313 |
} |
|
1314 |
if (newdir != v->direction) {
|
|
1315 |
v->direction = newdir; |
|
1316 |
v->cur_speed -= v->cur_speed >> 2; |
|
1317 |
} |
|
1318 |
||
1319 |
v->cur_image = GetRoadVehImage(v, newdir); |
|
1320 |
UpdateRoadVehDeltaXY(v); |
|
1321 |
RoadZPosAffectSpeed(v, SetRoadVehPosition(v, x, y)); |
|
1322 |
return; |
|
1323 |
} |
|
1324 |
||
1325 |
if (rd.x & 0x40) {
|
|
1326 |
int dir = RoadFindPathToDest(v, v->tile, rd.x&3); |
|
1327 |
uint32 r; |
|
1328 |
int tmp; |
|
1329 |
byte newdir; |
|
1330 |
const RoadDriveEntry *rdp; |
|
1331 |
||
1332 |
if (dir == -1) {
|
|
1333 |
v->cur_speed = 0; |
|
1334 |
return; |
|
1335 |
} |
|
1336 |
||
1337 |
tmp = (_opt.road_side<<4) + dir; |
|
1338 |
rdp = _road_drive_data[tmp]; |
|
1339 |
||
1340 |
x = GET_TILE_X(v->tile)*16 + rdp[1].x; |
|
1341 |
y = GET_TILE_Y(v->tile)*16 + rdp[1].y; |
|
1342 |
||
1343 |
if (RoadVehFindCloseTo(v, x, y, newdir=RoadVehGetSlidingDirection(v, x, y))) |
|
1344 |
return; |
|
1345 |
||
1346 |
r = VehicleEnterTile(v, v->tile, x, y); |
|
1347 |
if (r & 8) {
|
|
1348 |
v->cur_speed = 0; |
|
1349 |
return; |
|
1350 |
} |
|
1351 |
||
1352 |
v->u.road.state = tmp & ~16; |
|
1353 |
v->u.road.frame = 1; |
|
1354 |
||
1355 |
if (newdir != v->direction) {
|
|
1356 |
v->direction = newdir; |
|
1357 |
v->cur_speed -= v->cur_speed >> 2; |
|
1358 |
} |
|
1359 |
||
1360 |
v->cur_image = GetRoadVehImage(v, newdir); |
|
1361 |
UpdateRoadVehDeltaXY(v); |
|
1362 |
RoadZPosAffectSpeed(v, SetRoadVehPosition(v, x, y)); |
|
1363 |
return; |
|
1364 |
} |
|
1365 |
||
1366 |
x = (v->x_pos&~15)+(rd.x&15); |
|
1367 |
y = (v->y_pos&~15)+(rd.y&15); |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1368 |
|
| 0 | 1369 |
new_dir = RoadVehGetSlidingDirection(v, x, y); |
1370 |
||
1371 |
if (!IS_BYTE_INSIDE(v->u.road.state, 0x20, 0x30) && (u=RoadVehFindCloseTo(v, x, y, new_dir)) != NULL) {
|
|
1372 |
if (v->u.road.overtaking == 0) |
|
1373 |
RoadVehCheckOvertake(v, u); |
|
1374 |
return; |
|
1375 |
} |
|
1376 |
||
1377 |
old_dir = v->direction; |
|
1378 |
if (new_dir != old_dir) {
|
|
1379 |
v->direction = new_dir; |
|
1380 |
v->cur_speed -= (v->cur_speed >> 2); |
|
1381 |
if (old_dir != v->u.road.state) {
|
|
1382 |
v->cur_image = GetRoadVehImage(v, new_dir); |
|
1383 |
UpdateRoadVehDeltaXY(v); |
|
1384 |
SetRoadVehPosition(v, v->x_pos, v->y_pos); |
|
1385 |
return; |
|
1386 |
} |
|
1387 |
} |
|
1388 |
||
1389 |
if (v->u.road.state >= 0x20 && |
|
1390 |
_road_veh_data_1[v->u.road.state - 0x20 + (_opt.road_side<<4)] == v->u.road.frame) {
|
|
1391 |
byte *b; |
|
1392 |
||
1393 |
st = DEREF_STATION(_map2[v->tile]); |
|
1394 |
b = IS_BYTE_INSIDE(_map5[v->tile], 0x43, 0x47) ? &st->truck_stop_status : &st->bus_stop_status; |
|
1395 |
||
1396 |
if ( (v->next_order&OT_MASK) != OT_LEAVESTATION && |
|
1397 |
(v->next_order&OT_MASK) != OT_GOTO_DEPOT) {
|
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1398 |
|
| 0 | 1399 |
*b &= ~0x80; |
1400 |
||
1401 |
v->last_station_visited = _map2[v->tile]; |
|
1402 |
||
1403 |
RoadVehArrivesAt(v, st); |
|
1404 |
||
1405 |
old_order = v->next_order; |
|
1406 |
v->next_order = OT_LOADING; |
|
1407 |
||
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1408 |
if ((old_order & OT_MASK) == OT_GOTO_STATION && |
| 0 | 1409 |
v->next_order_param == v->last_station_visited) {
|
1410 |
v->next_order = OT_LOADING | OF_NON_STOP | (old_order & (OF_FULL_LOAD|OF_UNLOAD)); |
|
1411 |
} |
|
1412 |
||
1413 |
SET_EXPENSES_TYPE(EXPENSES_ROADVEH_INC); |
|
1414 |
if (LoadUnloadVehicle(v)) {
|
|
1415 |
InvalidateWindow(WC_ROADVEH_LIST, v->owner); |
|
1416 |
MarkRoadVehDirty(v); |
|
1417 |
} |
|
1418 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, 4); |
|
1419 |
return; |
|
1420 |
} |
|
1421 |
||
1422 |
if ((v->next_order & OT_MASK) != OT_GOTO_DEPOT) {
|
|
1423 |
if (*b&0x80) {
|
|
1424 |
v->cur_speed = 0; |
|
1425 |
return; |
|
1426 |
} |
|
1427 |
v->next_order = 0; |
|
1428 |
} |
|
1429 |
*b |= 0x80; |
|
1430 |
||
1431 |
StartRoadVehSound(v); |
|
1432 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, 4); |
|
1433 |
} |
|
1434 |
||
1435 |
r = VehicleEnterTile(v, v->tile, x, y); |
|
1436 |
if (r & 8) {
|
|
1437 |
v->cur_speed = 0; |
|
1438 |
return; |
|
1439 |
} |
|
1440 |
||
1441 |
if ((r & 4) == 0) {
|
|
1442 |
v->u.road.frame++; |
|
1443 |
} |
|
1444 |
||
1445 |
v->cur_image = GetRoadVehImage(v, v->direction); |
|
1446 |
UpdateRoadVehDeltaXY(v); |
|
1447 |
RoadZPosAffectSpeed(v, SetRoadVehPosition(v, x, y)); |
|
1448 |
} |
|
1449 |
||
1450 |
void RoadVehEnterDepot(Vehicle *v) |
|
1451 |
{
|
|
1452 |
byte t; |
|
1453 |
||
1454 |
v->u.road.state = 254; |
|
1455 |
v->vehstatus |= VS_HIDDEN; |
|
1456 |
||
1457 |
v->date_of_last_service = _date; |
|
1458 |
v->breakdowns_since_last_service = 0; |
|
1459 |
v->reliability = _engines[v->engine_type].reliability; |
|
1460 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
|
1461 |
||
1462 |
MaybeRenewVehicle(v, EstimateRoadVehCost(v->engine_type)); |
|
1463 |
||
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1464 |
|
| 0 | 1465 |
if ((v->next_order&OT_MASK) == OT_GOTO_DEPOT) {
|
1466 |
InvalidateWindow(WC_VEHICLE_VIEW, v->index); |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1467 |
|
| 0 | 1468 |
t = v->next_order; |
1469 |
v->next_order = OT_DUMMY; |
|
1470 |
||
1471 |
// Part of the schedule? |
|
1472 |
if (t & OF_UNLOAD) { v->cur_order_index++; }
|
|
1473 |
||
1474 |
else if (t & OF_FULL_LOAD) {
|
|
1475 |
v->vehstatus |= VS_STOPPED; |
|
1476 |
if (v->owner == _local_player) {
|
|
1477 |
SET_DPARAM16(0, v->unitnumber); |
|
1478 |
AddNewsItem( |
|
1479 |
STR_9016_ROAD_VEHICLE_IS_WAITING, |
|
1480 |
NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0), |
|
1481 |
v->index, |
|
1482 |
0); |
|
1483 |
} |
|
1484 |
} |
|
1485 |
} |
|
1486 |
||
1487 |
InvalidateWindow(WC_VEHICLE_DEPOT, v->tile); |
|
1488 |
} |
|
1489 |
||
1490 |
static void AgeRoadVehCargo(Vehicle *v) |
|
1491 |
{
|
|
1492 |
if (_age_cargo_skip_counter != 0) |
|
1493 |
return; |
|
1494 |
if (v->cargo_days != 255) |
|
1495 |
v->cargo_days++; |
|
1496 |
} |
|
1497 |
||
1498 |
void RoadVeh_Tick(Vehicle *v) |
|
1499 |
{
|
|
1500 |
AgeRoadVehCargo(v); |
|
1501 |
RoadVehEventHandler(v); |
|
1502 |
} |
|
1503 |
||
1504 |
static void CheckIfRoadVehNeedsService(Vehicle *v) |
|
1505 |
{
|
|
1506 |
int i; |
|
1507 |
||
|
76
30511cbc5188
(svn r77) -Fix: [1010788] AI service interval bug (tnx truesatan)
truelight
parents:
63
diff
changeset
|
1508 |
if (_patches.servint_roadveh == 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
|
1509 |
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
|
1510 |
|
|
156
8fef5e5752d6
(svn r157) -Feature: [1009708] Percent-based service intervals. Send a vehicle to depot after it has lost X% of its reliability (mivlad)
darkvater
parents:
76
diff
changeset
|
1511 |
if (SERVICE_INTERVAL) |
| 0 | 1512 |
return; |
1513 |
||
1514 |
if (v->vehstatus & VS_STOPPED) |
|
1515 |
return; |
|
1516 |
||
|
76
30511cbc5188
(svn r77) -Fix: [1010788] AI service interval bug (tnx truesatan)
truelight
parents:
63
diff
changeset
|
1517 |
if (_patches.gotodepot && ScheduleHasDepotOrders(v->schedule_ptr)) |
| 0 | 1518 |
return; |
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1519 |
|
| 0 | 1520 |
// Don't interfere with a depot visit scheduled by the user, or a |
1521 |
// depot visit by the order list. |
|
1522 |
if ((v->next_order & OT_MASK) == OT_GOTO_DEPOT && |
|
1523 |
(v->next_order & (OF_FULL_LOAD|OF_UNLOAD)) != 0) |
|
1524 |
return; |
|
1525 |
||
1526 |
i = FindClosestRoadDepot(v); |
|
1527 |
||
1528 |
if (i < 0 || GetTileDist(v->tile, (&_depots[i])->xy) > 12) {
|
|
1529 |
if ((v->next_order & OT_MASK) == OT_GOTO_DEPOT) {
|
|
1530 |
v->next_order = OT_DUMMY; |
|
1531 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, 4); |
|
1532 |
} |
|
1533 |
return; |
|
1534 |
} |
|
1535 |
||
1536 |
if (v->next_order == (OT_GOTO_DEPOT | OF_NON_STOP) && !CHANCE16(1,20)) |
|
1537 |
return; |
|
1538 |
||
1539 |
v->next_order = OT_GOTO_DEPOT | OF_NON_STOP; |
|
1540 |
v->next_order_param = (byte)i; |
|
1541 |
v->dest_tile = (&_depots[i])->xy; |
|
|
193
0a7025304867
(svn r194) -Codechange: stripping trailing-spaces. Please keep this that way!
truelight
parents:
164
diff
changeset
|
1542 |
InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, 4); |
| 0 | 1543 |
} |
1544 |
||
1545 |
void OnNewDay_RoadVeh(Vehicle *v) |
|
1546 |
{
|
|
1547 |
int32 cost; |
|
1548 |
Station *st; |
|
1549 |
uint tile; |
|
1550 |
||
1551 |
if ((++v->day_counter & 7) == 0) |
|
1552 |
DecreaseVehicleValue(v); |
|
1553 |
||
1554 |
if (v->u.road.unk2 == 0) |
|
1555 |
CheckVehicleBreakdown(v); |
|
1556 |
||
1557 |
AgeVehicle(v); |
|
1558 |
CheckIfRoadVehNeedsService(v); |
|
1559 |
||
|
19
6080d2b6a959
(svn r20) Feature: warning when a vehicle has invalid orders (celestar)
dominik
parents:
11
diff
changeset
|
1560 |
CheckOrders(v); |
|
6080d2b6a959
(svn r20) Feature: warning when a vehicle has invalid orders (celestar)
dominik
parents:
11
diff
changeset
|
1561 |
|
| 0 | 1562 |
/* update destination */ |
1563 |
if ((v->next_order & OT_MASK) == OT_GOTO_STATION) {
|
|
1564 |
st = DEREF_STATION(v->next_order_param); |
|
1565 |
if ((tile=(v->cargo_type==CT_PASSENGERS ? st->bus_tile : st->lorry_tile)) != 0) |
|
1566 |
v->dest_tile = tile; |
|
1567 |
} |
|
1568 |
||
1569 |
if (v->vehstatus & VS_STOPPED) |
|
1570 |
return; |
|
1571 |
||
1572 |
cost = _roadveh_runningcost[v->engine_type - ROAD_ENGINES_INDEX] * _price.roadveh_running / 364; |
|
1573 |
||
1574 |
v->profit_this_year -= cost >> 8; |
|
1575 |
||
1576 |
SET_EXPENSES_TYPE(EXPENSES_ROADVEH_RUN); |
|
1577 |
SubtractMoneyFromPlayerFract(v->owner, cost); |
|
1578 |
||
1579 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
|
1580 |
InvalidateWindow(WC_ROADVEH_LIST, v->owner); |
|
1581 |
} |
|
1582 |
||
1583 |
void HandleClickOnRoadVeh(Vehicle *v) |
|
1584 |
{
|
|
1585 |
ShowRoadVehViewWindow(v); |
|
1586 |
} |
|
1587 |
||
1588 |
void RoadVehiclesYearlyLoop() |
|
1589 |
{
|
|
1590 |
Vehicle *v; |
|
1591 |
||
1592 |
FOR_ALL_VEHICLES(v) {
|
|
1593 |
if (v->type == VEH_Road) {
|
|
1594 |
v->profit_last_year = v->profit_this_year; |
|
1595 |
v->profit_this_year = 0; |
|
1596 |
InvalidateWindow(WC_VEHICLE_DETAILS, v->index); |
|
1597 |
} |
|
1598 |
} |
|
1599 |
} |
|
1600 |