OpenTTD

roadveh_cmd.cpp
Go to the documentation of this file.
1 /* $Id: roadveh_cmd.cpp 27814 2017-03-20 18:16:23Z peter1138 $ */
2
3 /*
4 * This file is part of OpenTTD.
5 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
6 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
7 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
8 */
9
12 #include "stdafx.h"
13 #include "roadveh.h"
14 #include "command_func.h"
15 #include "news_func.h"
16 #include "pathfinder/npf/npf_func.h"
17 #include "station_base.h"
18 #include "company_func.h"
19 #include "articulated_vehicles.h"
20 #include "newgrf_sound.h"
21 #include "pathfinder/yapf/yapf.h"
22 #include "strings_func.h"
23 #include "tunnelbridge_map.h"
24 #include "date_func.h"
25 #include "vehicle_func.h"
26 #include "sound_func.h"
27 #include "ai/ai.hpp"
28 #include "game/game.hpp"
29 #include "depot_map.h"
30 #include "effectvehicle_func.h"
31 #include "roadstop_base.h"
32 #include "spritecache.h"
33 #include "core/random_func.hpp"
34 #include "company_base.h"
35 #include "core/backup_type.hpp"
36 #include "newgrf.h"
37 #include "zoom_func.h"
38
39 #include "table/strings.h"
40
41 #include "safeguards.h"
42
43 static const uint16 _roadveh_images[] = {
44 0xCD4, 0xCDC, 0xCE4, 0xCEC, 0xCF4, 0xCFC, 0xD0C, 0xD14,
45 0xD24, 0xD1C, 0xD2C, 0xD04, 0xD1C, 0xD24, 0xD6C, 0xD74,
46 0xD7C, 0xC14, 0xC1C, 0xC24, 0xC2C, 0xC34, 0xC3C, 0xC4C,
47 0xC54, 0xC64, 0xC5C, 0xC6C, 0xC44, 0xC5C, 0xC64, 0xCAC,
48 0xCB4, 0xCBC, 0xD94, 0xD9C, 0xDA4, 0xDAC, 0xDB4, 0xDBC,
49 0xDCC, 0xDD4, 0xDE4, 0xDDC, 0xDEC, 0xDC4, 0xDDC, 0xDE4,
50 0xE2C, 0xE34, 0xE3C, 0xC14, 0xC1C, 0xC2C, 0xC3C, 0xC4C,
51 0xC5C, 0xC64, 0xC6C, 0xC74, 0xC84, 0xC94, 0xCA4
52 };
53
54 static const uint16 _roadveh_full_adder[] = {
55 0, 88, 0, 0, 0, 0, 48, 48,
56 48, 48, 0, 0, 64, 64, 0, 16,
57 16, 0, 88, 0, 0, 0, 0, 48,
58 48, 48, 48, 0, 0, 64, 64, 0,
59 16, 16, 0, 88, 0, 0, 0, 0,
60 48, 48, 48, 48, 0, 0, 64, 64,
61 0, 16, 16, 0, 8, 8, 8, 8,
62 0, 0, 0, 8, 8, 8, 8
63 };
64 assert_compile(lengthof(_roadveh_images) == lengthof(_roadveh_full_adder));
65
66 template <>
67 bool IsValidImageIndex<VEH_ROAD>(uint8 image_index)
68 {
69 return image_index < lengthof(_roadveh_images);
70 }
71
72 static const Trackdir _road_reverse_table[DIAGDIR_END] = {
73 TRACKDIR_RVREV_NE, TRACKDIR_RVREV_SE, TRACKDIR_RVREV_SW, TRACKDIR_RVREV_NW
74 };
75
80 bool RoadVehicle::IsBus() const
81 {
82 assert(this->IsFrontEngine());
83 return IsCargoInClass(this->cargo_type, CC_PASSENGERS);
84 }
85
91 int RoadVehicle::GetDisplayImageWidth(Point *offset) const
92 {
93 int reference_width = ROADVEHINFO_DEFAULT_VEHICLE_WIDTH;
94
95 if (offset != NULL) {
96 offset->x = ScaleGUITrad(reference_width) / 2;
97 offset->y = 0;
98 }
99 return ScaleGUITrad(this->gcache.cached_veh_length * reference_width / VEHICLE_LENGTH);
100 }
101
102 static void GetRoadVehIcon(EngineID engine, EngineImageType image_type, VehicleSpriteSeq *result)
103 {
104 const Engine *e = Engine::Get(engine);
105 uint8 spritenum = e->u.road.image_index;
106
107 if (is_custom_sprite(spritenum)) {
108 GetCustomVehicleIcon(engine, DIR_W, image_type, result);
109 if (result->IsValid()) return;
110
111 spritenum = e->original_image_index;
112 }
113
114 assert(IsValidImageIndex<VEH_ROAD>(spritenum));
115 result->Set(DIR_W + _roadveh_images[spritenum]);
116 }
117
118 void RoadVehicle::GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const
119 {
120 uint8 spritenum = this->spritenum;
121
122 if (is_custom_sprite(spritenum)) {
123 GetCustomVehicleSprite(this, (Direction)(direction + 4 * IS_CUSTOM_SECONDHEAD_SPRITE(spritenum)), image_type, result);
124 if (result->IsValid()) return;
125
126 spritenum = this->GetEngine()->original_image_index;
127 }
128
129 assert(IsValidImageIndex<VEH_ROAD>(spritenum));
130 SpriteID sprite = direction + _roadveh_images[spritenum];
131
132 if (this->cargo.StoredCount() >= this->cargo_cap / 2U) sprite += _roadveh_full_adder[spritenum];
133
134 result->Set(sprite);
135 }
136
146 void DrawRoadVehEngine(int left, int right, int preferred_x, int y, EngineID engine, PaletteID pal, EngineImageType image_type)
147 {
148 VehicleSpriteSeq seq;
149 GetRoadVehIcon(engine, image_type, &seq);
150
151 Rect rect;
152 seq.GetBounds(&rect);
153 preferred_x = Clamp(preferred_x,
154 left - UnScaleGUI(rect.left),
155 right - UnScaleGUI(rect.right));
156
157 seq.Draw(preferred_x, y, pal, pal == PALETTE_CRASH);
158 }
159
169 void GetRoadVehSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
170 {
171 VehicleSpriteSeq seq;
172 GetRoadVehIcon(engine, image_type, &seq);
173
174 Rect rect;
175 seq.GetBounds(&rect);
176
177 width = UnScaleGUI(rect.right - rect.left + 1);
178 height = UnScaleGUI(rect.bottom - rect.top + 1);
179 xoffs = UnScaleGUI(rect.left);
180 yoffs = UnScaleGUI(rect.top);
181 }
182
188 static uint GetRoadVehLength(const RoadVehicle *v)
189 {
190 const Engine *e = v->GetEngine();
191 uint length = VEHICLE_LENGTH;
192
193 uint16 veh_len = CALLBACK_FAILED;
194 if (e->GetGRF() != NULL && e->GetGRF()->grf_version >= 8) {
195 /* Use callback 36 */
196 veh_len = GetVehicleProperty(v, PROP_ROADVEH_SHORTEN_FACTOR, CALLBACK_FAILED);
197 if (veh_len != CALLBACK_FAILED && veh_len >= VEHICLE_LENGTH) ErrorUnknownCallbackResult(e->GetGRFID(), CBID_VEHICLE_LENGTH, veh_len);
198 } else {
199 /* Use callback 11 */
200 veh_len = GetVehicleCallback(CBID_VEHICLE_LENGTH, 0, 0, v->engine_type, v);
201 }
202 if (veh_len == CALLBACK_FAILED) veh_len = e->u.road.shorten_factor;
203 if (veh_len != 0) {
204 length -= Clamp(veh_len, 0, VEHICLE_LENGTH - 1);
205 }
206
207 return length;
208 }
209
216 void RoadVehUpdateCache(RoadVehicle *v, bool same_length)
217 {
218 assert(v->type == VEH_ROAD);
219 assert(v->IsFrontEngine());
220
221 v->InvalidateNewGRFCacheOfChain();
222
223 v->gcache.cached_total_length = 0;
224
225 for (RoadVehicle *u = v; u != NULL; u = u->Next()) {
226 /* Check the v->first cache. */
227 assert(u->First() == v);
228
229 /* Update the 'first engine' */
230 u->gcache.first_engine = (v == u) ? INVALID_ENGINE : v->engine_type;
231
232 /* Update the length of the vehicle. */
233 uint veh_len = GetRoadVehLength(u);
234 /* Verify length hasn't changed. */
235 if (same_length && veh_len != u->gcache.cached_veh_length) VehicleLengthChanged(u);
236
237 u->gcache.cached_veh_length = veh_len;
238 v->gcache.cached_total_length += u->gcache.cached_veh_length;
239
240 /* Update visual effect */
241 u->UpdateVisualEffect();
242
243 /* Update cargo aging period. */
244 u->vcache.cached_cargo_age_period = GetVehicleProperty(u, PROP_ROADVEH_CARGO_AGE_PERIOD, EngInfo(u->engine_type)->cargo_age_period);
245 }
246
247 uint max_speed = GetVehicleProperty(v, PROP_ROADVEH_SPEED, 0);
248 v->vcache.cached_max_speed = (max_speed != 0) ? max_speed * 4 : RoadVehInfo(v->engine_type)->max_speed;
249 }
250
260 CommandCost CmdBuildRoadVehicle(TileIndex tile, DoCommandFlag flags, const Engine *e, uint16 data, Vehicle **ret)
261 {
262 if (HasTileRoadType(tile, ROADTYPE_TRAM) != HasBit(e->info.misc_flags, EF_ROAD_TRAM)) return_cmd_error(STR_ERROR_DEPOT_WRONG_DEPOT_TYPE);
263
264 if (flags & DC_EXEC) {
265 const RoadVehicleInfo *rvi = &e->u.road;
266
267 RoadVehicle *v = new RoadVehicle();
268 *ret = v;
269 v->direction = DiagDirToDir(GetRoadDepotDirection(tile));
270 v->owner = _current_company;
271
272 v->tile = tile;
273 int x = TileX(tile) * TILE_SIZE + TILE_SIZE / 2;
274 int y = TileY(tile) * TILE_SIZE + TILE_SIZE / 2;
275 v->x_pos = x;
276 v->y_pos = y;
277 v->z_pos = GetSlopePixelZ(x, y);
278
279 v->state = RVSB_IN_DEPOT;
280 v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;
281
282 v->spritenum = rvi->image_index;
283 v->cargo_type = e->GetDefaultCargoType();
284 v->cargo_cap = rvi->capacity;
285 v->refit_cap = 0;
286
287 v->last_station_visited = INVALID_STATION;
288 v->last_loading_station = INVALID_STATION;
289 v->engine_type = e->index;
290 v->gcache.first_engine = INVALID_ENGINE; // needs to be set before first callback
291
292 v->reliability = e->reliability;
293 v->reliability_spd_dec = e->reliability_spd_dec;
294 v->max_age = e->GetLifeLengthInDays();
295 _new_vehicle_id = v->index;
296
297 v->SetServiceInterval(Company::Get(v->owner)->settings.vehicle.servint_roadveh);
298
299 v->date_of_last_service = _date;
300 v->build_year = _cur_year;
301
302 v->sprite_seq.Set(SPR_IMG_QUERY);
303 v->random_bits = VehicleRandomBits();
304 v->SetFrontEngine();
305
306 v->roadtype = HasBit(e->info.misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD;
307 v->compatible_roadtypes = RoadTypeToRoadTypes(v->roadtype);
308 v->gcache.cached_veh_length = VEHICLE_LENGTH;
309
310 if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) SetBit(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE);
311 v->SetServiceIntervalIsPercent(Company::Get(_current_company)->settings.vehicle.servint_ispercent);
312
313 AddArticulatedParts(v);
314 v->InvalidateNewGRFCacheOfChain();
315
316 /* Call various callbacks after the whole consist has been constructed */
317 for (RoadVehicle *u = v; u != NULL; u = u->Next()) {
318 u->cargo_cap = u->GetEngine()->DetermineCapacity(u);
319 u->refit_cap = 0;
320 v->InvalidateNewGRFCache();
321 u->InvalidateNewGRFCache();
322 }
323 RoadVehUpdateCache(v);
324 /* Initialize cached values for realistic acceleration. */
325 if (_settings_game.vehicle.roadveh_acceleration_model != AM_ORIGINAL) v->CargoChanged();
326
327 v->UpdatePosition();
328
329 CheckConsistencyOfArticulatedVehicle(v);
330 }
331
332 return CommandCost();
333 }
334
335 static FindDepotData FindClosestRoadDepot(const RoadVehicle *v, int max_distance)
336 {
337 if (IsRoadDepotTile(v->tile)) return FindDepotData(v->tile, 0);
338
339 switch (_settings_game.pf.pathfinder_for_roadvehs) {
340 case VPF_NPF: return NPFRoadVehicleFindNearestDepot(v, max_distance);
341 case VPF_YAPF: return YapfRoadVehicleFindNearestDepot(v, max_distance);
342
343 default: NOT_REACHED();
344 }
345 }
346
347 bool RoadVehicle::FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse)
348 {
349 FindDepotData rfdd = FindClosestRoadDepot(this, 0);
350 if (rfdd.best_length == UINT_MAX) return false;
351
352 if (location != NULL) *location = rfdd.tile;
353 if (destination != NULL) *destination = GetDepotIndex(rfdd.tile);
354
355 return true;
356 }
357
367 CommandCost CmdTurnRoadVeh(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
368 {
369 RoadVehicle *v = RoadVehicle::GetIfValid(p1);
370 if (v == NULL) return CMD_ERROR;
371
372 if (!v->IsPrimaryVehicle()) return CMD_ERROR;
373
374 CommandCost ret = CheckOwnership(v->owner);
375 if (ret.Failed()) return ret;
376
377 if ((v->vehstatus & VS_STOPPED) ||
378 (v->vehstatus & VS_CRASHED) ||
379 v->breakdown_ctr != 0 ||
380 v->overtaking != 0 ||
381 v->state == RVSB_WORMHOLE ||
382 v->IsInDepot() ||
383 v->current_order.IsType(OT_LOADING)) {
384 return CMD_ERROR;
385 }
386
387 if (IsNormalRoadTile(v->tile) && GetDisallowedRoadDirections(v->tile) != DRD_NONE) return CMD_ERROR;
388
389 if (IsTileType(v->tile, MP_TUNNELBRIDGE) && DirToDiagDir(v->direction) == GetTunnelBridgeDirection(v->tile)) return CMD_ERROR;
390
391 if (flags & DC_EXEC) v->reverse_ctr = 180;
392
393 return CommandCost();
394 }
395
396
397 void RoadVehicle::MarkDirty()
398 {
399 for (RoadVehicle *v = this; v != NULL; v = v->Next()) {
400 v->colourmap = PAL_NONE;
401 v->UpdateViewport(true, false);
402 }
403 this->CargoChanged();
404 }
405
406 void RoadVehicle::UpdateDeltaXY(Direction direction)
407 {
408 static const int8 _delta_xy_table[8][10] = {
409 /* y_extent, x_extent, y_offs, x_offs, y_bb_offs, x_bb_offs, y_extent_shorten, x_extent_shorten, y_bb_offs_shorten, x_bb_offs_shorten */
410 {3, 3, -1, -1, 0, 0, -1, -1, -1, -1}, // N
411 {3, 7, -1, -3, 0, -1, 0, -1, 0, 0}, // NE
412 {3, 3, -1, -1, 0, 0, 1, -1, 1, -1}, // E
413 {7, 3, -3, -1, -1, 0, 0, 0, 1, 0}, // SE
414 {3, 3, -1, -1, 0, 0, 1, 1, 1, 1}, // S
415 {3, 7, -1, -3, 0, -1, 0, 0, 0, 1}, // SW
416 {3, 3, -1, -1, 0, 0, -1, 1, -1, 1}, // W
417 {7, 3, -3, -1, -1, 0, -1, 0, 0, 0}, // NW
418 };
419
420 int shorten = VEHICLE_LENGTH - this->gcache.cached_veh_length;
421 if (!IsDiagonalDirection(direction)) shorten >>= 1;
422
423 const int8 *bb = _delta_xy_table[direction];
424 this->x_bb_offs = bb[5] + bb[9] * shorten;
425 this->y_bb_offs = bb[4] + bb[8] * shorten;;
426 this->x_offs = bb[3];
427 this->y_offs = bb[2];
428 this->x_extent = bb[1] + bb[7] * shorten;
429 this->y_extent = bb[0] + bb[6] * shorten;
430 this->z_extent = 6;
431 }
432
437 inline int RoadVehicle::GetCurrentMaxSpeed() const
438 {
439 int max_speed = this->vcache.cached_max_speed;
440
441 /* Limit speed to 50% while reversing, 75% in curves. */
442 for (const RoadVehicle *u = this; u != NULL; u = u->Next()) {
443 if (_settings_game.vehicle.roadveh_acceleration_model == AM_REALISTIC) {
444 if (this->state <= RVSB_TRACKDIR_MASK && IsReversingRoadTrackdir((Trackdir)this->state)) {
445 max_speed = this->vcache.cached_max_speed / 2;
446 break;
447 } else if ((u->direction & 1) == 0) {
448 max_speed = this->vcache.cached_max_speed * 3 / 4;
449 }
450 }
451
452 /* Vehicle is on the middle part of a bridge. */
453 if (u->state == RVSB_WORMHOLE && !(u->vehstatus & VS_HIDDEN)) {
454 max_speed = min(max_speed, GetBridgeSpec(GetBridgeType(u->tile))->speed * 2);
455 }
456 }
457
458 return min(max_speed, this->current_order.GetMaxSpeed() * 2);
459 }
460
465 static void DeleteLastRoadVeh(RoadVehicle *v)
466 {
467 RoadVehicle *first = v->First();
468 Vehicle *u = v;
469 for (; v->Next() != NULL; v = v->Next()) u = v;
470 u->SetNext(NULL);
471 v->last_station_visited = first->last_station_visited; // for PreDestructor
472
473 /* Only leave the road stop when we're really gone. */
474 if (IsInsideMM(v->state, RVSB_IN_ROAD_STOP, RVSB_IN_ROAD_STOP_END)) RoadStop::GetByTile(v->tile, GetRoadStopType(v->tile))->Leave(v);
475
476 delete v;
477 }
478
479 static void RoadVehSetRandomDirection(RoadVehicle *v)
480 {
481 static const DirDiff delta[] = {
482 DIRDIFF_45LEFT, DIRDIFF_SAME, DIRDIFF_SAME, DIRDIFF_45RIGHT
483 };
484
485 do {
486 uint32 r = Random();
487
488 v->direction = ChangeDir(v->direction, delta[r & 3]);
489 v->UpdateViewport(true, true);
490 } while ((v = v->Next()) != NULL);
491 }
492
498 static bool RoadVehIsCrashed(RoadVehicle *v)
499 {
500 v->crashed_ctr++;
501 if (v->crashed_ctr == 2) {
502 CreateEffectVehicleRel(v, 4, 4, 8, EV_EXPLOSION_LARGE);
503 } else if (v->crashed_ctr <= 45) {
504 if ((v->tick_counter & 7) == 0) RoadVehSetRandomDirection(v);
505 } else if (v->crashed_ctr >= 2220 && !(v->tick_counter & 0x1F)) {
506 bool ret = v->Next() != NULL;
507 DeleteLastRoadVeh(v);
508 return ret;
509 }
510
511 return true;
512 }
513
520 static Vehicle *EnumCheckRoadVehCrashTrain(Vehicle *v, void *data)
521 {
522 const Vehicle *u = (Vehicle*)data;
523
524 return (v->type == VEH_TRAIN &&
525 abs(v->z_pos - u->z_pos) <= 6 &&
526 abs(v->x_pos - u->x_pos) <= 4 &&
527 abs(v->y_pos - u->y_pos) <= 4) ? v : NULL;
528 }
529
530 uint RoadVehicle::Crash(bool flooded)
531 {
532 uint pass = this->GroundVehicleBase::Crash(flooded);
533 if (this->IsFrontEngine()) {
534 pass += 1; // driver
535
536 /* If we're in a drive through road stop we ought to leave it */
537 if (IsInsideMM(this->state, RVSB_IN_DT_ROAD_STOP, RVSB_IN_DT_ROAD_STOP_END)) {
538 RoadStop::GetByTile(this->tile, GetRoadStopType(this->tile))->Leave(this);
539 }
540 }
541 this->crashed_ctr = flooded ? 2000 : 1; // max 2220, disappear pretty fast when flooded
542 return pass;
543 }
544
545 static void RoadVehCrash(RoadVehicle *v)
546 {
547 uint pass = v->Crash();
548
549 AI::NewEvent(v->owner, new ScriptEventVehicleCrashed(v->index, v->tile, ScriptEventVehicleCrashed::CRASH_RV_LEVEL_CROSSING));
550 Game::NewEvent(new ScriptEventVehicleCrashed(v->index, v->tile, ScriptEventVehicleCrashed::CRASH_RV_LEVEL_CROSSING));
551
552 SetDParam(0, pass);
553 AddVehicleNewsItem(
554 (pass == 1) ?
555 STR_NEWS_ROAD_VEHICLE_CRASH_DRIVER : STR_NEWS_ROAD_VEHICLE_CRASH,
556 NT_ACCIDENT,
557 v->index
558 );
559
560 ModifyStationRatingAround(v->tile, v->owner, -160, 22);
561 if (_settings_client.sound.disaster) SndPlayVehicleFx(SND_12_EXPLOSION, v);
562 }
563
564 static bool RoadVehCheckTrainCrash(RoadVehicle *v)
565 {
566 for (RoadVehicle *u = v; u != NULL; u = u->Next()) {
567 if (u->state == RVSB_WORMHOLE) continue;
568
569 TileIndex tile = u->tile;
570
571 if (!IsLevelCrossingTile(tile)) continue;
572
573 if (HasVehicleOnPosXY(v->x_pos, v->y_pos, u, EnumCheckRoadVehCrashTrain)) {
574 RoadVehCrash(v);
575 return true;
576 }
577 }
578
579 return false;
580 }
581
582 TileIndex RoadVehicle::GetOrderStationLocation(StationID station)
583 {
584 if (station == this->last_station_visited) this->last_station_visited = INVALID_STATION;
585
586 const Station *st = Station::Get(station);
587 if (!CanVehicleUseStation(this, st)) {
588 /* There is no stop left at the station, so don't even TRY to go there */
589 this->IncrementRealOrderIndex();
590 return 0;
591 }
592
593 return st->xy;
594 }
595
596 static void StartRoadVehSound(const RoadVehicle *v)
597 {
598 if (!PlayVehicleSound(v, VSE_START)) {
599 SoundID s = RoadVehInfo(v->engine_type)->sfx;
600 if (s == SND_19_BUS_START_PULL_AWAY && (v->tick_counter & 3) == 0) {
601 s = SND_1A_BUS_START_PULL_AWAY_WITH_HORN;
602 }
603 SndPlayVehicleFx(s, v);
604 }
605 }
606
607 struct RoadVehFindData {
608 int x;
609 int y;
610 const Vehicle *veh;
611 Vehicle *best;
612 uint best_diff;
613 Direction dir;
614 };
615
616 static Vehicle *EnumCheckRoadVehClose(Vehicle *v, void *data)
617 {
618 static const int8 dist_x[] = { -4, -8, -4, -1, 4, 8, 4, 1 };
619 static const int8 dist_y[] = { -4, -1, 4, 8, 4, 1, -4, -8 };
620
621 RoadVehFindData *rvf = (RoadVehFindData*)data;
622
623 short x_diff = v->x_pos - rvf->x;
624 short y_diff = v->y_pos - rvf->y;
625
626 if (v->type == VEH_ROAD &&
627 !v->IsInDepot() &&
628 abs(v->z_pos - rvf->veh->z_pos) < 6 &&
629 v->direction == rvf->dir &&
630 rvf->veh->First() != v->First() &&
631 (dist_x[v->direction] >= 0 || (x_diff > dist_x[v->direction] && x_diff <= 0)) &&
632 (dist_x[v->direction] <= 0 || (x_diff < dist_x[v->direction] && x_diff >= 0)) &&
633 (dist_y[v->direction] >= 0 || (y_diff > dist_y[v->direction] && y_diff <= 0)) &&
634 (dist_y[v->direction] <= 0 || (y_diff < dist_y[v->direction] && y_diff >= 0))) {
635 uint diff = abs(x_diff) + abs(y_diff);
636
637 if (diff < rvf->best_diff || (diff == rvf->best_diff && v->index < rvf->best->index)) {
638 rvf->best = v;
639 rvf->best_diff = diff;
640 }
641 }
642
643 return NULL;
644 }
645
646 static RoadVehicle *RoadVehFindCloseTo(RoadVehicle *v, int x, int y, Direction dir, bool update_blocked_ctr = true)
647 {
648 RoadVehFindData rvf;
649 RoadVehicle *front = v->First();
650
651 if (front->reverse_ctr != 0) return NULL;
652
653 rvf.x = x;
654 rvf.y = y;
655 rvf.dir = dir;
656 rvf.veh = v;
657 rvf.best_diff = UINT_MAX;
658
659 if (front->state == RVSB_WORMHOLE) {
660 FindVehicleOnPos(v->tile, &rvf, EnumCheckRoadVehClose);
661 FindVehicleOnPos(GetOtherTunnelBridgeEnd(v->tile), &rvf, EnumCheckRoadVehClose);
662 } else {
663 FindVehicleOnPosXY(x, y, &rvf, EnumCheckRoadVehClose);
664 }
665
666 /* This code protects a roadvehicle from being blocked for ever
667 * If more than 1480 / 74 days a road vehicle is blocked, it will
668 * drive just through it. The ultimate backup-code of TTD.
669 * It can be disabled. */
670 if (rvf.best_diff == UINT_MAX) {
671 front->blocked_ctr = 0;
672 return NULL;
673 }
674
675 if (update_blocked_ctr && ++front->blocked_ctr > 1480) return NULL;
676
677 return RoadVehicle::From(rvf.best);
678 }
679
685 static void RoadVehArrivesAt(const RoadVehicle *v, Station *st)
686 {
687 if (v->IsBus()) {
688 /* Check if station was ever visited before */
689 if (!(st->had_vehicle_of_type & HVOT_BUS)) {
690 st->had_vehicle_of_type |= HVOT_BUS;
691 SetDParam(0, st->index);
692 AddVehicleNewsItem(
693 v->roadtype == ROADTYPE_ROAD ? STR_NEWS_FIRST_BUS_ARRIVAL : STR_NEWS_FIRST_PASSENGER_TRAM_ARRIVAL,
694 (v->owner == _local_company) ? NT_ARRIVAL_COMPANY : NT_ARRIVAL_OTHER,
695 v->index,
696 st->index
697 );
698 AI::NewEvent(v->owner, new ScriptEventStationFirstVehicle(st->index, v->index));
699 Game::NewEvent(new ScriptEventStationFirstVehicle(st->index, v->index));
700 }
701 } else {
702 /* Check if station was ever visited before */
703 if (!(st->had_vehicle_of_type & HVOT_TRUCK)) {
704 st->had_vehicle_of_type |= HVOT_TRUCK;
705 SetDParam(0, st->index);
706 AddVehicleNewsItem(
707 v->roadtype == ROADTYPE_ROAD ? STR_NEWS_FIRST_TRUCK_ARRIVAL : STR_NEWS_FIRST_CARGO_TRAM_ARRIVAL,
708 (v->owner == _local_company) ? NT_ARRIVAL_COMPANY : NT_ARRIVAL_OTHER,
709 v->index,
710 st->index
711 );
712 AI::NewEvent(v->owner, new ScriptEventStationFirstVehicle(st->index, v->index));
713 Game::NewEvent(new ScriptEventStationFirstVehicle(st->index, v->index));
714 }
715 }
716 }
717
725 int RoadVehicle::UpdateSpeed()
726 {
727 switch (_settings_game.vehicle.roadveh_acceleration_model) {
728 default: NOT_REACHED();
729 case AM_ORIGINAL:
730 return this->DoUpdateSpeed(this->overtaking != 0 ? 512 : 256, 0, this->GetCurrentMaxSpeed());
731
732 case AM_REALISTIC:
733 return this->DoUpdateSpeed(this->GetAcceleration() + (this->overtaking != 0 ? 256 : 0), this->GetAccelerationStatus() == AS_BRAKE ? 0 : 4, this->GetCurrentMaxSpeed());
734 }
735 }
736
737 static Direction RoadVehGetNewDirection(const RoadVehicle *v, int x, int y)
738 {
739 static const Direction _roadveh_new_dir[] = {
740 DIR_N , DIR_NW, DIR_W , INVALID_DIR,
741 DIR_NE, DIR_N , DIR_SW, INVALID_DIR,
742 DIR_E , DIR_SE, DIR_S
743 };
744
745 x = x - v->x_pos + 1;
746 y = y - v->y_pos + 1;
747
748 if ((uint)x > 2 || (uint)y > 2) return v->direction;
749 return _roadveh_new_dir[y * 4 + x];
750 }
751
752 static Direction RoadVehGetSlidingDirection(const RoadVehicle *v, int x, int y)
753 {
754 Direction new_dir = RoadVehGetNewDirection(v, x, y);
755 Direction old_dir = v->direction;
756 DirDiff delta;
757
758 if (new_dir == old_dir) return old_dir;
759 delta = (DirDifference(new_dir, old_dir) > DIRDIFF_REVERSE ? DIRDIFF_45LEFT : DIRDIFF_45RIGHT);
760 return ChangeDir(old_dir, delta);
761 }
762
763 struct OvertakeData {
764 const RoadVehicle *u;
765 const RoadVehicle *v;
766 TileIndex tile;
767 Trackdir trackdir;
768 };
769
770 static Vehicle *EnumFindVehBlockingOvertake(Vehicle *v, void *data)
771 {
772 const OvertakeData *od = (OvertakeData*)data;
773
774 return (v->type == VEH_ROAD && v->First() == v && v != od->u && v != od->v) ? v : NULL;
775 }
776
783 static bool CheckRoadBlockedForOvertaking(OvertakeData *od)
784 {
785 TrackStatus ts = GetTileTrackStatus(od->tile, TRANSPORT_ROAD, od->v->compatible_roadtypes);
786 TrackdirBits trackdirbits = TrackStatusToTrackdirBits(ts);
787 TrackdirBits red_signals = TrackStatusToRedSignals(ts); // barred level crossing
788 TrackBits trackbits = TrackdirBitsToTrackBits(trackdirbits);
789
790 /* Track does not continue along overtaking direction || track has junction || levelcrossing is barred */
791 if (!HasBit(trackdirbits, od->trackdir) || (trackbits & ~TRACK_BIT_CROSS) || (red_signals != TRACKDIR_BIT_NONE)) return true;
792
793 /* Are there more vehicles on the tile except the two vehicles involved in overtaking */
794 return HasVehicleOnPos(od->tile, od, EnumFindVehBlockingOvertake);
795 }
796
797 static void RoadVehCheckOvertake(RoadVehicle *v, RoadVehicle *u)
798 {
799 OvertakeData od;
800
801 od.v = v;
802 od.u = u;
803
804 /* Trams can't overtake other trams */
805 if (v->roadtype == ROADTYPE_TRAM) return;
806
807 /* Don't overtake in stations */
808 if (IsTileType(v->tile, MP_STATION) || IsTileType(u->tile, MP_STATION)) return;
809
810 /* For now, articulated road vehicles can't overtake anything. */
811 if (v->HasArticulatedPart()) return;
812
813 /* Vehicles are not driving in same direction || direction is not a diagonal direction */
814 if (v->direction != u->direction || !(v->direction & 1)) return;
815
816 /* Check if vehicle is in a road stop, depot, tunnel or bridge or not on a straight road */
817 if (v->state >= RVSB_IN_ROAD_STOP || !IsStraightRoadTrackdir((Trackdir)(v->state & RVSB_TRACKDIR_MASK))) return;
818
819 /* Can't overtake a vehicle that is moving faster than us. If the vehicle in front is
820 * accelerating, take the maximum speed for the comparison, else the current speed.
821 * Original acceleration always accelerates, so always use the maximum speed. */
822 int u_speed = (_settings_game.vehicle.roadveh_acceleration_model == AM_ORIGINAL || u->GetAcceleration() > 0) ? u->GetCurrentMaxSpeed() : u->cur_speed;
823 if (u_speed >= v->GetCurrentMaxSpeed() &&
824 !(u->vehstatus & VS_STOPPED) &&
825 u->cur_speed != 0) {
826 return;
827 }
828
829 od.trackdir = DiagDirToDiagTrackdir(DirToDiagDir(v->direction));
830
831 /* Are the current and the next tile suitable for overtaking?
832 * - Does the track continue along od.trackdir
833 * - No junctions
834 * - No barred levelcrossing
835 * - No other vehicles in the way
836 */
837 od.tile = v->tile;
838 if (CheckRoadBlockedForOvertaking(&od)) return;
839
840 od.tile = v->tile + TileOffsByDiagDir(DirToDiagDir(v->direction));
841 if (CheckRoadBlockedForOvertaking(&od)) return;
842
843 /* When the vehicle in front of us is stopped we may only take
844 * half the time to pass it than when the vehicle is moving. */
845 v->overtaking_ctr = (od.u->cur_speed == 0 || (od.u->vehstatus & VS_STOPPED)) ? RV_OVERTAKE_TIMEOUT / 2 : 0;
846 v->overtaking = RVSB_DRIVE_SIDE;
847 }
848
849 static void RoadZPosAffectSpeed(RoadVehicle *v, int old_z)
850 {
851 if (old_z == v->z_pos || _settings_game.vehicle.roadveh_acceleration_model != AM_ORIGINAL) return;
852
853 if (old_z < v->z_pos) {
854 v->cur_speed = v->cur_speed * 232 / 256; // slow down by ~10%
855 } else {
856 uint16 spd = v->cur_speed + 2;
857 if (spd <= v->vcache.cached_max_speed) v->cur_speed = spd;
858 }
859 }
860
861 static int PickRandomBit(uint bits)
862 {
863 uint i;
864 uint num = RandomRange(CountBits(bits));
865
866 for (i = 0; !(bits & 1) || (int)--num >= 0; bits >>= 1, i++) {}
867 return i;
868 }
869
878 static Trackdir RoadFindPathToDest(RoadVehicle *v, TileIndex tile, DiagDirection enterdir)
879 {
880 #define return_track(x) { best_track = (Trackdir)x; goto found_best_track; }
881
882 TileIndex desttile;
883 Trackdir best_track;
884 bool path_found = true;
885
886 TrackStatus ts = GetTileTrackStatus(tile, TRANSPORT_ROAD, v->compatible_roadtypes);
887 TrackdirBits red_signals = TrackStatusToRedSignals(ts); // crossing
888 TrackdirBits trackdirs = TrackStatusToTrackdirBits(ts);
889
890 if (IsTileType(tile, MP_ROAD)) {
891 if (IsRoadDepot(tile) && (!IsTileOwner(tile, v->owner) || GetRoadDepotDirection(tile) == enterdir || (GetRoadTypes(tile) & v->compatible_roadtypes) == 0)) {
892 /* Road depot owned by another company or with the wrong orientation */
893 trackdirs = TRACKDIR_BIT_NONE;
894 }
895 } else if (IsTileType(tile, MP_STATION) && IsStandardRoadStopTile(tile)) {
896 /* Standard road stop (drive-through stops are treated as normal road) */
897
898 if (!IsTileOwner(tile, v->owner) || GetRoadStopDir(tile) == enterdir || v->HasArticulatedPart()) {
899 /* different station owner or wrong orientation or the vehicle has articulated parts */
900 trackdirs = TRACKDIR_BIT_NONE;
901 } else {
902 /* Our station */
903 RoadStopType rstype = v->IsBus() ? ROADSTOP_BUS : ROADSTOP_TRUCK;
904
905 if (GetRoadStopType(tile) != rstype) {
906 /* Wrong station type */
907 trackdirs = TRACKDIR_BIT_NONE;
908 } else {
909 /* Proper station type, check if there is free loading bay */
910 if (!_settings_game.pf.roadveh_queue && IsStandardRoadStopTile(tile) &&
911 !RoadStop::GetByTile(tile, rstype)->HasFreeBay()) {
912 /* Station is full and RV queuing is off */
913 trackdirs = TRACKDIR_BIT_NONE;
914 }
915 }
916 }
917 }
918 /* The above lookups should be moved to GetTileTrackStatus in the
919 * future, but that requires more changes to the pathfinder and other
920 * stuff, probably even more arguments to GTTS.
921 */
922
923 /* Remove tracks unreachable from the enter dir */
924 trackdirs &= DiagdirReachesTrackdirs(enterdir);
925 if (trackdirs == TRACKDIR_BIT_NONE) {
926 /* No reachable tracks, so we'll reverse */
927 return_track(_road_reverse_table[enterdir]);
928 }
929
930 if (v->reverse_ctr != 0) {
931 bool reverse = true;
932 if (v->roadtype == ROADTYPE_TRAM) {
933 /* Trams may only reverse on a tile if it contains at least the straight
934 * trackbits or when it is a valid turning tile (i.e. one roadbit) */
935 RoadBits rb = GetAnyRoadBits(tile, ROADTYPE_TRAM);
936 RoadBits straight = AxisToRoadBits(DiagDirToAxis(enterdir));
937 reverse = ((rb & straight) == straight) ||
938 (rb == DiagDirToRoadBits(enterdir));
939 }
940 if (reverse) {
941 v->reverse_ctr = 0;
942 if (v->tile != tile) {
943 return_track(_road_reverse_table[enterdir]);
944 }
945 }
946 }
947
948 desttile = v->dest_tile;
949 if (desttile == 0) {
950 /* We've got no destination, pick a random track */
951 return_track(PickRandomBit(trackdirs));
952 }
953
954 /* Only one track to choose between? */
955 if (KillFirstBit(trackdirs) == TRACKDIR_BIT_NONE) {
956 return_track(FindFirstBit2x64(trackdirs));
957 }
958
959 switch (_settings_game.pf.pathfinder_for_roadvehs) {
960 case VPF_NPF: best_track = NPFRoadVehicleChooseTrack(v, tile, enterdir, trackdirs, path_found); break;
961 case VPF_YAPF: best_track = YapfRoadVehicleChooseTrack(v, tile, enterdir, trackdirs, path_found); break;
962
963 default: NOT_REACHED();
964 }
965 v->HandlePathfindingResult(path_found);
966
967 found_best_track:;
968
969 if (HasBit(red_signals, best_track)) return INVALID_TRACKDIR;
970
971 return best_track;
972 }
973
974 struct RoadDriveEntry {
975 byte x, y;
976 };
977
978 #include "table/roadveh_movement.h"
979
980 static bool RoadVehLeaveDepot(RoadVehicle *v, bool first)
981 {
982 /* Don't leave unless v and following wagons are in the depot. */
983 for (const RoadVehicle *u = v; u != NULL; u = u->Next()) {
984 if (u->state != RVSB_IN_DEPOT || u->tile != v->tile) return false;
985 }
986
987 DiagDirection dir = GetRoadDepotDirection(v->tile);
988 v->direction = DiagDirToDir(dir);
989
990 Trackdir tdir = DiagDirToDiagTrackdir(dir);
991 const RoadDriveEntry *rdp = _road_drive_data[v->roadtype][(_settings_game.vehicle.road_side << RVS_DRIVE_SIDE) + tdir];
992
993 int x = TileX(v->tile) * TILE_SIZE + (rdp[RVC_DEPOT_START_FRAME].x & 0xF);
994 int y = TileY(v->tile) * TILE_SIZE + (rdp[RVC_DEPOT_START_FRAME].y & 0xF);
995
996 if (first) {
997 /* We are leaving a depot, but have to go to the exact same one; re-enter */
998 if (v->current_order.IsType(OT_GOTO_DEPOT) && v->tile == v->dest_tile) {
999 VehicleEnterDepot(v);
1000 return true;
1001 }
1002
1003 if (RoadVehFindCloseTo(v, x, y, v->direction, false) != NULL) return true;
1004
1005 VehicleServiceInDepot(v);
1006
1007 StartRoadVehSound(v);
1008
1009 /* Vehicle is about to leave a depot */
1010 v->cur_speed = 0;
1011 }
1012
1013 v->vehstatus &= ~VS_HIDDEN;
1014 v->state = tdir;
1015 v->frame = RVC_DEPOT_START_FRAME;
1016
1017 v->x_pos = x;
1018 v->y_pos = y;
1019 v->UpdatePosition();
1020 v->UpdateInclination(true, true);
1021
1022 InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
1023
1024 return true;
1025 }
1026
1027 static Trackdir FollowPreviousRoadVehicle(const RoadVehicle *v, const RoadVehicle *prev, TileIndex tile, DiagDirection entry_dir, bool already_reversed)
1028 {
1029 if (prev->tile == v->tile && !already_reversed) {
1030 /* If the previous vehicle is on the same tile as this vehicle is
1031 * then it must have reversed. */
1032 return _road_reverse_table[entry_dir];
1033 }
1034
1035 byte prev_state = prev->state;
1036 Trackdir dir;
1037
1038 if (prev_state == RVSB_WORMHOLE || prev_state == RVSB_IN_DEPOT) {
1039 DiagDirection diag_dir = INVALID_DIAGDIR;
1040
1041 if (IsTileType(tile, MP_TUNNELBRIDGE)) {
1042 diag_dir = GetTunnelBridgeDirection(tile);
1043 } else if (IsRoadDepotTile(tile)) {
1044 diag_dir = ReverseDiagDir(GetRoadDepotDirection(tile));
1045 }
1046
1047 if (diag_dir == INVALID_DIAGDIR) return INVALID_TRACKDIR;
1048 dir = DiagDirToDiagTrackdir(diag_dir);
1049 } else {
1050 if (already_reversed && prev->tile != tile) {
1051 /*
1052 * The vehicle has reversed, but did not go straight back.
1053 * It immediately turn onto another tile. This means that
1054 * the roadstate of the previous vehicle cannot be used
1055 * as the direction we have to go with this vehicle.
1056 *
1057 * Next table is build in the following way:
1058 * - first row for when the vehicle in front went to the northern or
1059 * western tile, second for southern and eastern.
1060 * - columns represent the entry direction.
1061 * - cell values are determined by the Trackdir one has to take from
1062 * the entry dir (column) to the tile in north or south by only
1063 * going over the trackdirs used for turning 90 degrees, i.e.
1064 * TRACKDIR_{UPPER,RIGHT,LOWER,LEFT}_{N,E,S,W}.
1065 */
1066 static const Trackdir reversed_turn_lookup[2][DIAGDIR_END] = {
1067 { TRACKDIR_UPPER_W, TRACKDIR_RIGHT_N, TRACKDIR_LEFT_N, TRACKDIR_UPPER_E },
1068 { TRACKDIR_RIGHT_S, TRACKDIR_LOWER_W, TRACKDIR_LOWER_E, TRACKDIR_LEFT_S }};
1069 dir = reversed_turn_lookup[prev->tile < tile ? 0 : 1][ReverseDiagDir(entry_dir)];
1070 } else if (HasBit(prev_state, RVS_IN_DT_ROAD_STOP)) {
1071 dir = (Trackdir)(prev_state & RVSB_ROAD_STOP_TRACKDIR_MASK);
1072 } else if (prev_state < TRACKDIR_END) {
1073 dir = (Trackdir)prev_state;
1074 } else {
1075 return INVALID_TRACKDIR;
1076 }
1077 }
1078
1079 /* Do some sanity checking. */
1080 static const RoadBits required_roadbits[] = {
1081 ROAD_X, ROAD_Y, ROAD_NW | ROAD_NE, ROAD_SW | ROAD_SE,
1082 ROAD_NW | ROAD_SW, ROAD_NE | ROAD_SE, ROAD_X, ROAD_Y
1083 };
1084 RoadBits required = required_roadbits[dir & 0x07];
1085
1086 if ((required & GetAnyRoadBits(tile, v->roadtype, true)) == ROAD_NONE) {
1087 dir = INVALID_TRACKDIR;
1088 }
1089
1090 return dir;
1091 }
1092
1100 static bool CanBuildTramTrackOnTile(CompanyID c, TileIndex t, RoadBits r)
1101 {
1102 /* The 'current' company is not necessarily the owner of the vehicle. */
1103 Backup<CompanyByte> cur_company(_current_company, c, FILE_LINE);
1104
1105 CommandCost ret = DoCommand(t, ROADTYPE_TRAM << 4 | r, 0, DC_NO_WATER, CMD_BUILD_ROAD);
1106
1107 cur_company.Restore();
1108 return ret.Succeeded();
1109 }
1110
1111 bool IndividualRoadVehicleController(RoadVehicle *v, const RoadVehicle *prev)
1112 {
1113 if (v->overtaking != 0) {
1114 if (IsTileType(v->tile, MP_STATION)) {
1115 /* Force us to be not overtaking! */
1116 v->overtaking = 0;
1117 } else if (++v->overtaking_ctr >= RV_OVERTAKE_TIMEOUT) {
1118 /* If overtaking just aborts at a random moment, we can have a out-of-bound problem,
1119 * if the vehicle started a corner. To protect that, only allow an abort of
1120 * overtake if we are on straight roads */
1121 if (v->state < RVSB_IN_ROAD_STOP && IsStraightRoadTrackdir((Trackdir)v->state)) {
1122 v->overtaking = 0;
1123 }
1124 }
1125 }
1126
1127 /* If this vehicle is in a depot and we've reached this point it must be
1128 * one of the articulated parts. It will stay in the depot until activated
1129 * by the previous vehicle in the chain when it gets to the right place. */
1130 if (v->IsInDepot()) return true;
1131
1132 if (v->state == RVSB_WORMHOLE) {
1133 /* Vehicle is entering a depot or is on a bridge or in a tunnel */
1134 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
1135
1136 if (v->IsFrontEngine()) {
1137 const Vehicle *u = RoadVehFindCloseTo(v, gp.x, gp.y, v->direction);
1138 if (u != NULL) {
1139 v->cur_speed = u->First()->cur_speed;
1140 return false;
1141 }
1142 }
1143
1144 if (IsTileType(gp.new_tile, MP_TUNNELBRIDGE) && HasBit(VehicleEnterTile(v, gp.new_tile, gp.x, gp.y), VETS_ENTERED_WORMHOLE)) {
1145 /* Vehicle has just entered a bridge or tunnel */
1146 v->x_pos = gp.x;
1147 v->y_pos = gp.y;
1148 v->UpdatePosition();
1149 v->UpdateInclination(true, true);
1150 return true;
1151 }
1152
1153 v->x_pos = gp.x;
1154 v->y_pos = gp.y;
1155 v->UpdatePosition();
1156 if ((v->vehstatus & VS_HIDDEN) == 0) v->Vehicle::UpdateViewport(true);
1157 return true;
1158 }
1159
1160 /* Get move position data for next frame.
1161 * For a drive-through road stop use 'straight road' move data.
1162 * In this case v->state is masked to give the road stop entry direction. */
1163 RoadDriveEntry rd = _road_drive_data[v->roadtype][(
1164 (HasBit(v->state, RVS_IN_DT_ROAD_STOP) ? v->state & RVSB_ROAD_STOP_TRACKDIR_MASK : v->state) +
1165 (_settings_game.vehicle.road_side << RVS_DRIVE_SIDE)) ^ v->overtaking][v->frame + 1];
1166
1167 if (rd.x & RDE_NEXT_TILE) {
1168 TileIndex tile = v->tile + TileOffsByDiagDir((DiagDirection)(rd.x & 3));
1169 Trackdir dir;
1170
1171 if (v->IsFrontEngine()) {
1172 /* If this is the front engine, look for the right path. */
1173 dir = RoadFindPathToDest(v, tile, (DiagDirection)(rd.x & 3));
1174 } else {
1175 dir = FollowPreviousRoadVehicle(v, prev, tile, (DiagDirection)(rd.x & 3), false);
1176 }
1177
1178 if (dir == INVALID_TRACKDIR) {
1179 if (!v->IsFrontEngine()) error("Disconnecting road vehicle.");
1180 v->cur_speed = 0;
1181 return false;
1182 }
1183
1184 again:
1185 uint start_frame = RVC_DEFAULT_START_FRAME;
1186 if (IsReversingRoadTrackdir(dir)) {
1187 /* When turning around we can't be overtaking. */
1188 v->overtaking = 0;
1189
1190 /* Turning around */
1191 if (v->roadtype == ROADTYPE_TRAM) {
1192 /* Determine the road bits the tram needs to be able to turn around
1193 * using the 'big' corner loop. */
1194 RoadBits needed;
1195 switch (dir) {
1196 default: NOT_REACHED();
1197 case TRACKDIR_RVREV_NE: needed = ROAD_SW; break;
1198 case TRACKDIR_RVREV_SE: needed = ROAD_NW; break;
1199 case TRACKDIR_RVREV_SW: needed = ROAD_NE; break;
1200 case TRACKDIR_RVREV_NW: needed = ROAD_SE; break;
1201 }
1202 if ((v->Previous() != NULL && v->Previous()->tile == tile) ||
1203 (v->IsFrontEngine() && IsNormalRoadTile(tile) && !HasRoadWorks(tile) &&
1204 (needed & GetRoadBits(tile, ROADTYPE_TRAM)) != ROAD_NONE)) {
1205 /*
1206 * Taking the 'big' corner for trams only happens when:
1207 * - The previous vehicle in this (articulated) tram chain is
1208 * already on the 'next' tile, we just follow them regardless of
1209 * anything. When it is NOT on the 'next' tile, the tram started
1210 * doing a reversing turn when the piece of tram track on the next
1211 * tile did not exist yet. Do not use the big tram loop as that is
1212 * going to cause the tram to split up.
1213 * - Or the front of the tram can drive over the next tile.
1214 */
1215 } else if (!v->IsFrontEngine() || !CanBuildTramTrackOnTile(v->owner, tile, needed) || ((~needed & GetAnyRoadBits(v->tile, ROADTYPE_TRAM, false)) == ROAD_NONE)) {
1216 /*
1217 * Taking the 'small' corner for trams only happens when:
1218 * - We are not the from vehicle of an articulated tram.
1219 * - Or when the company cannot build on the next tile.
1220 *
1221 * The 'small' corner means that the vehicle is on the end of a
1222 * tram track and needs to start turning there. To do this properly
1223 * the tram needs to start at an offset in the tram turning 'code'
1224 * for 'big' corners. It furthermore does not go to the next tile,
1225 * so that needs to be fixed too.
1226 */
1227 tile = v->tile;
1228 start_frame = RVC_TURN_AROUND_START_FRAME_SHORT_TRAM;
1229 } else {
1230 /* The company can build on the next tile, so wait till (s)he does. */
1231 v->cur_speed = 0;
1232 return false;
1233 }
1234 } else if (IsNormalRoadTile(v->tile) && GetDisallowedRoadDirections(v->tile) != DRD_NONE) {
1235 v->cur_speed = 0;
1236 return false;
1237 } else {
1238 tile = v->tile;
1239 }
1240 }
1241
1242 /* Get position data for first frame on the new tile */
1243 const RoadDriveEntry *rdp = _road_drive_data[v->roadtype][(dir + (_settings_game.vehicle.road_side << RVS_DRIVE_SIDE)) ^ v->overtaking];
1244
1245 int x = TileX(tile) * TILE_SIZE + rdp[start_frame].x;
1246 int y = TileY(tile) * TILE_SIZE + rdp[start_frame].y;
1247
1248 Direction new_dir = RoadVehGetSlidingDirection(v, x, y);
1249 if (v->IsFrontEngine()) {
1250 Vehicle *u = RoadVehFindCloseTo(v, x, y, new_dir);
1251 if (u != NULL) {
1252 v->cur_speed = u->First()->cur_speed;
1253 return false;
1254 }
1255 }
1256
1257 uint32 r = VehicleEnterTile(v, tile, x, y);
1258 if (HasBit(r, VETS_CANNOT_ENTER)) {
1259 if (!IsTileType(tile, MP_TUNNELBRIDGE)) {
1260 v->cur_speed = 0;
1261 return false;
1262 }
1263 /* Try an about turn to re-enter the previous tile */
1264 dir = _road_reverse_table[rd.x & 3];
1265 goto again;
1266 }
1267
1268 if (IsInsideMM(v->state, RVSB_IN_ROAD_STOP, RVSB_IN_DT_ROAD_STOP_END) && IsTileType(v->tile, MP_STATION)) {
1269 if (IsReversingRoadTrackdir(dir) && IsInsideMM(v->state, RVSB_IN_ROAD_STOP, RVSB_IN_ROAD_STOP_END)) {
1270 /* New direction is trying to turn vehicle around.
1271 * We can't turn at the exit of a road stop so wait.*/
1272 v->cur_speed = 0;
1273 return false;
1274 }
1275
1276 /* If we are a drive through road stop and the next tile is of
1277 * the same road stop and the next tile isn't this one (i.e. we
1278 * are not reversing), then keep the reservation and state.
1279 * This way we will not be shortly unregister from the road
1280 * stop. It also makes it possible to load when on the edge of
1281 * two road stops; otherwise you could get vehicles that should
1282 * be loading but are not actually loading. */
1283 if (IsDriveThroughStopTile(v->tile) &&
1284 RoadStop::IsDriveThroughRoadStopContinuation(v->tile, tile) &&
1285 v->tile != tile) {
1286 /* So, keep 'our' state */
1287 dir = (Trackdir)v->state;
1288 } else if (IsRoadStop(v->tile)) {
1289 /* We're not continuing our drive through road stop, so leave. */
1290 RoadStop::GetByTile(v->tile, GetRoadStopType(v->tile))->Leave(v);
1291 }
1292 }
1293
1294 if (!HasBit(r, VETS_ENTERED_WORMHOLE)) {
1295 v->tile = tile;
1296 v->state = (byte)dir;
1297 v->frame = start_frame;
1298 }
1299 if (new_dir != v->direction) {
1300 v->direction = new_dir;
1301 if (_settings_game.vehicle.roadveh_acceleration_model == AM_ORIGINAL) v->cur_speed -= v->cur_speed >> 2;
1302 }
1303 v->x_pos = x;
1304 v->y_pos = y;
1305 v->UpdatePosition();
1306 RoadZPosAffectSpeed(v, v->UpdateInclination(true, true));
1307 return true;
1308 }
1309
1310 if (rd.x & RDE_TURNED) {
1311 /* Vehicle has finished turning around, it will now head back onto the same tile */
1312 Trackdir dir;
1313 uint turn_around_start_frame = RVC_TURN_AROUND_START_FRAME;
1314
1315 if (v->roadtype == ROADTYPE_TRAM && !IsRoadDepotTile(v->tile) && HasExactlyOneBit(GetAnyRoadBits(v->tile, ROADTYPE_TRAM, true))) {
1316 /*
1317 * The tram is turning around with one tram 'roadbit'. This means that
1318 * it is using the 'big' corner 'drive data'. However, to support the
1319 * trams to take a small corner, there is a 'turned' marker in the middle
1320 * of the turning 'drive data'. When the tram took the long corner, we
1321 * will still use the 'big' corner drive data, but we advance it one
1322 * frame. We furthermore set the driving direction so the turning is
1323 * going to be properly shown.
1324 */
1325 turn_around_start_frame = RVC_START_FRAME_AFTER_LONG_TRAM;
1326 switch (rd.x & 0x3) {
1327 default: NOT_REACHED();
1328 case DIAGDIR_NW: dir = TRACKDIR_RVREV_SE; break;
1329 case DIAGDIR_NE: dir = TRACKDIR_RVREV_SW; break;
1330 case DIAGDIR_SE: dir = TRACKDIR_RVREV_NW; break;
1331 case DIAGDIR_SW: dir = TRACKDIR_RVREV_NE; break;
1332 }
1333 } else {
1334 if (v->IsFrontEngine()) {
1335 /* If this is the front engine, look for the right path. */
1336 dir = RoadFindPathToDest(v, v->tile, (DiagDirection)(rd.x & 3));
1337 } else {
1338 dir = FollowPreviousRoadVehicle(v, prev, v->tile, (DiagDirection)(rd.x & 3), true);
1339 }
1340 }
1341
1342 if (dir == INVALID_TRACKDIR) {
1343 v->cur_speed = 0;
1344 return false;
1345 }
1346
1347 const RoadDriveEntry *rdp = _road_drive_data[v->roadtype][(_settings_game.vehicle.road_side << RVS_DRIVE_SIDE) + dir];
1348
1349 int x = TileX(v->tile) * TILE_SIZE + rdp[turn_around_start_frame].x;
1350 int y = TileY(v->tile) * TILE_SIZE + rdp[turn_around_start_frame].y;
1351
1352 Direction new_dir = RoadVehGetSlidingDirection(v, x, y);
1353 if (v->IsFrontEngine() && RoadVehFindCloseTo(v, x, y, new_dir) != NULL) return false;
1354
1355 uint32 r = VehicleEnterTile(v, v->tile, x, y);
1356 if (HasBit(r, VETS_CANNOT_ENTER)) {
1357 v->cur_speed = 0;
1358 return false;
1359 }
1360
1361 v->state = dir;
1362 v->frame = turn_around_start_frame;
1363
1364 if (new_dir != v->direction) {
1365 v->direction = new_dir;
1366 if (_settings_game.vehicle.roadveh_acceleration_model == AM_ORIGINAL) v->cur_speed -= v->cur_speed >> 2;
1367 }
1368
1369 v->x_pos = x;
1370 v->y_pos = y;
1371 v->UpdatePosition();
1372 RoadZPosAffectSpeed(v, v->UpdateInclination(true, true));
1373 return true;
1374 }
1375
1376 /* This vehicle is not in a wormhole and it hasn't entered a new tile. If
1377 * it's on a depot tile, check if it's time to activate the next vehicle in
1378 * the chain yet. */
1379 if (v->Next() != NULL && IsRoadDepotTile(v->tile)) {
1380 if (v->frame == v->gcache.cached_veh_length + RVC_DEPOT_START_FRAME) {
1381 RoadVehLeaveDepot(v->Next(), false);
1382 }
1383 }
1384
1385 /* Calculate new position for the vehicle */
1386 int x = (v->x_pos & ~15) + (rd.x & 15);
1387 int y = (v->y_pos & ~15) + (rd.y & 15);
1388
1389 Direction new_dir = RoadVehGetSlidingDirection(v, x, y);
1390
1391 if (v->IsFrontEngine() && !IsInsideMM(v->state, RVSB_IN_ROAD_STOP, RVSB_IN_ROAD_STOP_END)) {
1392 /* Vehicle is not in a road stop.
1393 * Check for another vehicle to overtake */
1394 RoadVehicle *u = RoadVehFindCloseTo(v, x, y, new_dir);
1395
1396 if (u != NULL) {
1397 u = u->First();
1398 /* There is a vehicle in front overtake it if possible */
1399 if (v->overtaking == 0) RoadVehCheckOvertake(v, u);
1400 if (v->overtaking == 0) v->cur_speed = u->cur_speed;
1401
1402 /* In case an RV is stopped in a road stop, why not try to load? */
1403 if (v->cur_speed == 0 && IsInsideMM(v->state, RVSB_IN_DT_ROAD_STOP, RVSB_IN_DT_ROAD_STOP_END) &&
1404 v->current_order.ShouldStopAtStation(v, GetStationIndex(v->tile)) &&
1405 v->owner == GetTileOwner(v->tile) && !v->current_order.IsType(OT_LEAVESTATION) &&
1406 GetRoadStopType(v->tile) == (v->IsBus() ? ROADSTOP_BUS : ROADSTOP_TRUCK)) {
1407 Station *st = Station::GetByTile(v->tile);
1408 v->last_station_visited = st->index;
1409 RoadVehArrivesAt(v, st);
1410 v->BeginLoading();
1411 }
1412 return false;
1413 }
1414 }
1415
1416 Direction old_dir = v->direction;
1417 if (new_dir != old_dir) {
1418 v->direction = new_dir;
1419 if (_settings_game.vehicle.roadveh_acceleration_model == AM_ORIGINAL) v->cur_speed -= v->cur_speed >> 2;
1420
1421 /* Delay the vehicle in curves by making it require one additional frame per turning direction (two in total).
1422 * A vehicle has to spend at least 9 frames on a tile, so the following articulated part can follow.
1423 * (The following part may only be one tile behind, and the front part is moved before the following ones.)
1424 * The short (inner) curve has 8 frames, this elongates it to 10. */
1425 v->UpdateInclination(false, true);
1426 return true;
1427 }
1428
1429 /* If the vehicle is in a normal road stop and the frame equals the stop frame OR
1430 * if the vehicle is in a drive-through road stop and this is the destination station
1431 * and it's the correct type of stop (bus or truck) and the frame equals the stop frame...
1432 * (the station test and stop type test ensure that other vehicles, using the road stop as
1433 * a through route, do not stop) */
1434 if (v->IsFrontEngine() && ((IsInsideMM(v->state, RVSB_IN_ROAD_STOP, RVSB_IN_ROAD_STOP_END) &&
1435 _road_stop_stop_frame[v->state - RVSB_IN_ROAD_STOP + (_settings_game.vehicle.road_side << RVS_DRIVE_SIDE)] == v->frame) ||
1436 (IsInsideMM(v->state, RVSB_IN_DT_ROAD_STOP, RVSB_IN_DT_ROAD_STOP_END) &&
1437 v->current_order.ShouldStopAtStation(v, GetStationIndex(v->tile)) &&
1438 v->owner == GetTileOwner(v->tile) &&
1439 GetRoadStopType(v->tile) == (v->IsBus() ? ROADSTOP_BUS : ROADSTOP_TRUCK) &&
1440 v->frame == RVC_DRIVE_THROUGH_STOP_FRAME))) {
1441
1442 RoadStop *rs = RoadStop::GetByTile(v->tile, GetRoadStopType(v->tile));
1443 Station *st = Station::GetByTile(v->tile);
1444
1445 /* Vehicle is at the stop position (at a bay) in a road stop.
1446 * Note, if vehicle is loading/unloading it has already been handled,
1447 * so if we get here the vehicle has just arrived or is just ready to leave. */
1448 if (!HasBit(v->state, RVS_ENTERED_STOP)) {
1449 /* Vehicle has arrived at a bay in a road stop */
1450
1451 if (IsDriveThroughStopTile(v->tile)) {
1452 TileIndex next_tile = TILE_ADD(v->tile, TileOffsByDir(v->direction));
1453
1454 /* Check if next inline bay is free and has compatible road. */
1455 if (RoadStop::IsDriveThroughRoadStopContinuation(v->tile, next_tile) && (GetRoadTypes(next_tile) & v->compatible_roadtypes) != 0) {
1456 v->frame++;
1457 v->x_pos = x;
1458 v->y_pos = y;
1459 v->UpdatePosition();
1460 RoadZPosAffectSpeed(v, v->UpdateInclination(true, false));
1461 return true;
1462 }
1463 }
1464
1465 rs->SetEntranceBusy(false);
1466 SetBit(v->state, RVS_ENTERED_STOP);
1467
1468 v->last_station_visited = st->index;
1469
1470 if (IsDriveThroughStopTile(v->tile) || (v->current_order.IsType(OT_GOTO_STATION) && v->current_order.GetDestination() == st->index)) {
1471 RoadVehArrivesAt(v, st);
1472 v->BeginLoading();
1473 return false;
1474 }
1475 } else {
1476 /* Vehicle is ready to leave a bay in a road stop */
1477 if (rs->IsEntranceBusy()) {
1478 /* Road stop entrance is busy, so wait as there is nowhere else to go */
1479 v->cur_speed = 0;
1480 return false;
1481 }
1482 if (v->current_order.IsType(OT_LEAVESTATION)) v->current_order.Free();
1483 }
1484
1485 if (IsStandardRoadStopTile(v->tile)) rs->SetEntranceBusy(true);
1486
1487 StartRoadVehSound(v);
1488 SetWindowWidgetDirty(WC_VEHICLE_VIEW, v->index, WID_VV_START_STOP);
1489 }
1490
1491 /* Check tile position conditions - i.e. stop position in depot,
1492 * entry onto bridge or into tunnel */
1493 uint32 r = VehicleEnterTile(v, v->tile, x, y);
1494 if (HasBit(r, VETS_CANNOT_ENTER)) {
1495 v->cur_speed = 0;
1496 return false;
1497 }
1498
1499 if (v->current_order.IsType(OT_LEAVESTATION) && IsDriveThroughStopTile(v->tile)) {
1500 v->current_order.Free();
1501 }
1502
1503 /* Move to next frame unless vehicle arrived at a stop position
1504 * in a depot or entered a tunnel/bridge */
1505 if (!HasBit(r, VETS_ENTERED_WORMHOLE)) v->frame++;
1506 v->x_pos = x;
1507 v->y_pos = y;
1508 v->UpdatePosition();
1509 RoadZPosAffectSpeed(v, v->UpdateInclination(false, true));
1510 return true;
1511 }
1512
1513 static bool RoadVehController(RoadVehicle *v)
1514 {
1515 /* decrease counters */
1516 v->current_order_time++;
1517 if (v->reverse_ctr != 0) v->reverse_ctr--;
1518
1519 /* handle crashed */
1520 if (v->vehstatus & VS_CRASHED || RoadVehCheckTrainCrash(v)) {
1521 return RoadVehIsCrashed(v);
1522 }
1523
1524 /* road vehicle has broken down? */
1525 if (v->HandleBreakdown()) return true;
1526 if (v->vehstatus & VS_STOPPED) return true;
1527
1528 ProcessOrders(v);
1529 v->HandleLoading();
1530
1531 if (v->current_order.IsType(OT_LOADING)) return true;
1532
1533 if (v->IsInDepot() && RoadVehLeaveDepot(v, true)) return true;
1534
1535 v->ShowVisualEffect();
1536
1537 /* Check how far the vehicle needs to proceed */
1538 int j = v->UpdateSpeed();
1539
1540 int adv_spd = v->GetAdvanceDistance();
1541 bool blocked = false;
1542 while (j >= adv_spd) {
1543 j -= adv_spd;
1544
1545 RoadVehicle *u = v;
1546 for (RoadVehicle *prev = NULL; u != NULL; prev = u, u = u->Next()) {
1547 if (!IndividualRoadVehicleController(u, prev)) {
1548 blocked = true;
1549 break;
1550 }
1551 }
1552 if (blocked) break;
1553
1554 /* Determine distance to next map position */
1555 adv_spd = v->GetAdvanceDistance();
1556
1557 /* Test for a collision, but only if another movement will occur. */
1558 if (j >= adv_spd && RoadVehCheckTrainCrash(v)) break;
1559 }
1560
1561 v->SetLastSpeed();
1562
1563 for (RoadVehicle *u = v; u != NULL; u = u->Next()) {
1564 if ((u->vehstatus & VS_HIDDEN) != 0) continue;
1565
1566 u->UpdateViewport(false, false);
1567 }
1568
1569 /* If movement is blocked, set 'progress' to its maximum, so the roadvehicle does
1570 * not accelerate again before it can actually move. I.e. make sure it tries to advance again
1571 * on next tick to discover whether it is still blocked. */
1572 if (v->progress == 0) v->progress = blocked ? adv_spd - 1 : j;
1573
1574 return true;
1575 }
1576
1577 Money RoadVehicle::GetRunningCost() const
1578 {
1579 const Engine *e = this->GetEngine();
1580 if (e->u.road.running_cost_class == INVALID_PRICE) return 0;
1581
1582 uint cost_factor = GetVehicleProperty(this, PROP_ROADVEH_RUNNING_COST_FACTOR, e->u.road.running_cost);
1583 if (cost_factor == 0) return 0;
1584
1585 return GetPrice(e->u.road.running_cost_class, cost_factor, e->GetGRF());
1586 }
1587
1588 bool RoadVehicle::Tick()
1589 {
1590 this->tick_counter++;
1591
1592 if (this->IsFrontEngine()) {
1593 if (!(this->vehstatus & VS_STOPPED)) this->running_ticks++;
1594 return RoadVehController(this);
1595 }
1596
1597 return true;
1598 }
1599
1600 static void CheckIfRoadVehNeedsService(RoadVehicle *v)
1601 {
1602 /* If we already got a slot at a stop, use that FIRST, and go to a depot later */
1603 if (Company::Get(v->owner)->settings.vehicle.servint_roadveh == 0 || !v->NeedsAutomaticServicing()) return;
1604 if (v->IsChainInDepot()) {
1605 VehicleServiceInDepot(v);
1606 return;
1607 }
1608
1609 uint max_penalty;
1610 switch (_settings_game.pf.pathfinder_for_roadvehs) {
1611 case VPF_NPF: max_penalty = _settings_game.pf.npf.maximum_go_to_depot_penalty; break;
1612 case VPF_YAPF: max_penalty = _settings_game.pf.yapf.maximum_go_to_depot_penalty; break;
1613 default: NOT_REACHED();
1614 }
1615
1616 FindDepotData rfdd = FindClosestRoadDepot(v, max_penalty);
1617 /* Only go to the depot if it is not too far out of our way. */
1618 if (rfdd.best_length == UINT_MAX || rfdd.best_length > max_penalty) {
1619 if (v->current_order.IsType(OT_GOTO_DEPOT)) {
1620 /* If we were already heading for a depot but it has
1621 * suddenly moved farther away, we continue our normal
1622 * schedule? */
1623 v->current_order.MakeDummy();
1624 SetWindowWidgetDirty(WC_VEHICLE_VIEW, v->index, WID_VV_START_STOP);
1625 }
1626 return;
1627 }
1628
1629 DepotID depot = GetDepotIndex(rfdd.tile);
1630
1631 if (v->current_order.IsType(OT_GOTO_DEPOT) &&
1632 v->current_order.GetNonStopType() & ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS &&
1633 !Chance16(1, 20)) {
1634 return;
1635 }
1636
1637 SetBit(v->gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS);
1638 v->current_order.MakeGoToDepot(depot, ODTFB_SERVICE);
1639 v->dest_tile = rfdd.tile;
1640 SetWindowWidgetDirty(WC_VEHICLE_VIEW, v->index, WID_VV_START_STOP);
1641 }
1642
1643 void RoadVehicle::OnNewDay()
1644 {
1645 AgeVehicle(this);
1646
1647 if (!this->IsFrontEngine()) return;
1648
1649 if ((++this->day_counter & 7) == 0) DecreaseVehicleValue(this);
1650 if (this->blocked_ctr == 0) CheckVehicleBreakdown(this);
1651
1652 CheckIfRoadVehNeedsService(this);
1653
1654 CheckOrders(this);
1655
1656 if (this->running_ticks == 0) return;
1657
1658 CommandCost cost(EXPENSES_ROADVEH_RUN, this->GetRunningCost() * this->running_ticks / (DAYS_IN_YEAR * DAY_TICKS));
1659
1660 this->profit_this_year -= cost.GetCost();
1661 this->running_ticks = 0;
1662
1663 SubtractMoneyFromCompanyFract(this->owner, cost);
1664
1665 SetWindowDirty(WC_VEHICLE_DETAILS, this->index);
1666 SetWindowClassesDirty(WC_ROADVEH_LIST);
1667 }
1668
1669 Trackdir RoadVehicle::GetVehicleTrackdir() const
1670 {
1671 if (this->vehstatus & VS_CRASHED) return INVALID_TRACKDIR;
1672
1673 if (this->IsInDepot()) {
1674 /* We'll assume the road vehicle is facing outwards */
1675 return DiagDirToDiagTrackdir(GetRoadDepotDirection(this->tile));
1676 }
1677
1678 if (IsStandardRoadStopTile(this->tile)) {
1679 /* We'll assume the road vehicle is facing outwards */
1680 return DiagDirToDiagTrackdir(GetRoadStopDir(this->tile)); // Road vehicle in a station
1681 }
1682
1683 /* Drive through road stops / wormholes (tunnels) */
1684 if (this->state > RVSB_TRACKDIR_MASK) return DiagDirToDiagTrackdir(DirToDiagDir(this->direction));
1685
1686 /* If vehicle's state is a valid track direction (vehicle is not turning around) return it,
1687 * otherwise transform it into a valid track direction */
1688 return (Trackdir)((IsReversingRoadTrackdir((Trackdir)this->state)) ? (this->state - 6) : this->state);
1689 }
INVALID_DIR
Flag for an invalid direction.
Definition: direction_type.h:37
strings_func.h
Functions related to OTTD&#39;s strings.
roadveh.h
Road vehicle states.
HasVehicleOnPos
bool HasVehicleOnPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
Checks whether a vehicle is on a specific location.
Definition: vehicle.cpp:512
DrawRoadVehEngine
void DrawRoadVehEngine(int left, int right, int preferred_x, int y, EngineID engine, PaletteID pal, EngineImageType image_type)
Draw a road vehicle engine.
Definition: roadveh_cmd.cpp:146
GameSettings::vehicle
VehicleSettings vehicle
options for vehicles
Definition: settings_type.h:552
ENGINE_EXCLUSIVE_PREVIEW
This vehicle is in the exclusive preview stage, either being used or being offered to a company...
Definition: engine_type.h:169
Engine::reliability
uint16 reliability
Current reliability of the engine.
Definition: engine_base.h:27
Vehicle::max_age
Date max_age
Maximum age.
Definition: vehicle_base.h:259
PaletteID
uint32 PaletteID
The number of the palette.
Definition: gfx_type.h:20
VS_STOPPED
Vehicle is stopped by the player.
Definition: vehicle_base.h:33
NT_ARRIVAL_OTHER
First vehicle arrived for competitor.
Definition: news_type.h:38
Vehicle::cargo
VehicleCargoList cargo
The cargo this vehicle is carrying.
Definition: vehicle_base.h:309
RoadVehicle::state
byte state
Definition: roadveh.h:89
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:77
Game::NewEvent
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition: game_core.cpp:134
company_base.h
Definition of stuff that is very close to a company, like the company struct itself.
IsDiagonalDirection
static bool IsDiagonalDirection(Direction dir)
Checks if a given Direction is diagonal.
Definition: direction_func.h:275
DepotID
uint16 DepotID
Type for the unique identifier of depots.
Definition: depot_type.h:15
PROP_ROADVEH_SHORTEN_FACTOR
Shorter vehicles.
Definition: newgrf_properties.h:42
EnumCheckRoadVehCrashTrain
static Vehicle * EnumCheckRoadVehCrashTrain(Vehicle *v, void *data)
Check routine whether a road and a train vehicle have collided.
Definition: roadveh_cmd.cpp:520
GroundVehicle< RoadVehicle, VEH_ROAD >::GetAcceleration
int GetAcceleration() const
Calculates the acceleration of the vehicle under its current conditions.
Definition: ground_vehicle.cpp:107
DecreaseVehicleValue
void DecreaseVehicleValue(Vehicle *v)
Decrease the value of a vehicle.
Definition: vehicle.cpp:1195
DAYS_IN_YEAR
static const int DAYS_IN_YEAR
days per year
Definition: date_type.h:31
CALLBACK_FAILED
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
Definition: newgrf_callbacks.h:406
RoadStop::IsEntranceBusy
bool IsEntranceBusy() const
Checks whether the entrance of the road stop is occupied by a vehicle.
Definition: roadstop_base.h:105
ROADSTOP_TRUCK
A standard stop for trucks.
Definition: station_type.h:49
RoadVehicle::Tick
bool Tick()
Calls the tick handler of the vehicle.
Definition: roadveh_cmd.cpp:1588
Vehicle::ShowVisualEffect
void ShowVisualEffect() const
Draw visual effects (smoke and/or sparks) for a vehicle chain.
Definition: vehicle.cpp:2481
SetWindowDirty
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition: window.cpp:3120
DirToDiagDir
static DiagDirection DirToDiagDir(Direction dir)
Convert a Direction to a DiagDirection.
Definition: direction_func.h:168
RDE_TURNED
static const uint RDE_TURNED
We just finished turning.
Definition: roadveh.h:63
Vehicle::direction
DirectionByte direction
facing
Definition: vehicle_base.h:271
roadstop_base.h
Base class for roadstops.
UnScaleGUI
static int UnScaleGUI(int value)
Short-hand to apply GUI zoom level.
Definition: zoom_func.h:72
IsReversingRoadTrackdir
static bool IsReversingRoadTrackdir(Trackdir dir)
Checks whether the trackdir means that we are reversing.
Definition: track_func.h:661
VPF_YAPF
Yet Another PathFinder.
Definition: vehicle_type.h:63
NPFSettings::maximum_go_to_depot_penalty
uint32 maximum_go_to_depot_penalty
What is the maximum penalty that may be endured for going to a depot.
Definition: settings_type.h:353
DIR_E
East.
Definition: direction_type.h:30
CheckOrders
void CheckOrders(const Vehicle *v)
Check the orders of a vehicle, to see if there are invalid orders and stuff.
Definition: order_cmd.cpp:1762
GroundVehicle::SetFrontEngine
void SetFrontEngine()
Set front engine state.
Definition: ground_vehicle.hpp:251
RoadFindPathToDest
static Trackdir RoadFindPathToDest(RoadVehicle *v, TileIndex tile, DiagDirection enterdir)
Returns direction to for a road vehicle to take or INVALID_TRACKDIR if the direction is currently blo...
Definition: roadveh_cmd.cpp:878
GetRoadStopType
static RoadStopType GetRoadStopType(TileIndex t)
Get the road stop type of this tile.
Definition: station_map.h:57
INVALID_DIAGDIR
Flag for an invalid DiagDirection.
Definition: direction_type.h:87
RVSB_DRIVE_SIDE
The vehicle is at the opposite side of the road.
Definition: roadveh.h:55
Pool::PoolItem<&_engine_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:246
date_func.h
Functions related to dates.
IsInsideMM
static bool IsInsideMM(const T x, const uint min, const uint max)
Checks if a value is in an interval.
Definition: math_func.hpp:266
DIRDIFF_45LEFT
Angle of 45 degrees left.
Definition: direction_type.h:71
GroundVehicle< RoadVehicle, VEH_ROAD >::DoUpdateSpeed
uint DoUpdateSpeed(uint accel, int min_speed, int max_speed)
Update the speed of the vehicle.
Definition: ground_vehicle.hpp:365
RoadVehicle::GetCurrentMaxSpeed
int GetCurrentMaxSpeed() const
Calculates the maximum speed of the vehicle under its current conditions.
Definition: roadveh_cmd.cpp:437
ROADTYPE_ROAD
Basic road type.
Definition: road_type.h:24
VS_DEFPAL
Use default vehicle palette.
Definition: vehicle_base.h:35
TRACKDIR_END
Used for iterations.
Definition: track_type.h:92
RVS_IN_DT_ROAD_STOP
The vehicle is in a drive-through road stop.
Definition: roadveh.h:47
AddArticulatedParts
void AddArticulatedParts(Vehicle *first)
Add the remaining articulated parts to the given vehicle.
Definition: articulated_vehicles.cpp:355
SetBit
static T SetBit(T &x, const uint8 y)
Set a bit in a variable.
Definition: bitmath_func.hpp:123
RoadVehicle::GetAccelerationStatus
AccelStatus GetAccelerationStatus() const
Checks the current acceleration status of this vehicle.
Definition: roadveh.h:203
RoadStop::Leave
void Leave(RoadVehicle *rv)
Leave the road stop.
Definition: roadstop.cpp:218
Vehicle::cur_speed
uint16 cur_speed
current speed
Definition: vehicle_base.h:293
MP_ROAD
A tile with road (or tram tracks)
Definition: tile_type.h:45
CMD_ERROR
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
Definition: command_func.h:25
ScaleGUITrad
static int ScaleGUITrad(int value)
Scale traditional pixel dimensions to GUI zoom level.
Definition: zoom_func.h:82
WC_VEHICLE_DEPOT
Depot view; Window numbers:
Definition: window_type.h:346
TRACKDIR_RIGHT_N
Right track and direction to north.
Definition: track_type.h:89
ROAD_X
Full road along the x-axis (south-west + north-east)
Definition: road_type.h:61
Vehicle::spritenum
byte spritenum
currently displayed sprite index 0xfd == custom sprite, 0xfe == custom second head sprite 0xff == res...
Definition: vehicle_base.h:279
DIRDIFF_SAME
Both directions faces to the same direction.
Definition: direction_type.h:66
Vehicle::last_loading_station
StationID last_loading_station
Last station the vehicle has stopped at and could possibly leave from with any cargo loaded...
Definition: vehicle_base.h:303
Vehicle::dest_tile
TileIndex dest_tile
Heading for this tile.
Definition: vehicle_base.h:237
RoadVehicle::RoadVehicle
RoadVehicle()
We don&#39;t want GCC to zero our struct! It already is zeroed and has an index!
Definition: roadveh.h:101
IsRoadStop
static bool IsRoadStop(TileIndex t)
Is the station at t a road station?
Definition: station_map.h:203
PathfinderSettings::npf
NPFSettings npf
pathfinder settings for the new pathfinder
Definition: settings_type.h:432
vehicle_func.h
Functions related to vehicles.
CanBuildTramTrackOnTile
static bool CanBuildTramTrackOnTile(CompanyID c, TileIndex t, RoadBits r)
Can a tram track build without destruction on the given tile?
Definition: roadveh_cmd.cpp:1100
Vehicle::IncrementRealOrderIndex
void IncrementRealOrderIndex()
Advanced cur_real_order_index to the next real order, keeps care of the wrap-around and invalidates t...
Definition: vehicle_base.h:823
BaseConsist::current_order_time
uint32 current_order_time
How many ticks have passed since this order started.
Definition: base_consist.h:23
RDE_NEXT_TILE
static const uint RDE_NEXT_TILE
State information about the Road Vehicle controller.
Definition: roadveh.h:62
TileX
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:207
VehicleEnterDepot
void VehicleEnterDepot(Vehicle *v)
Vehicle entirely entered the depot, update its status, orders, vehicle windows, service it...
Definition: vehicle.cpp:1426
VehicleSpriteSeq::Draw
void Draw(int x, int y, PaletteID default_pal, bool force_pal) const
Draw the sprite sequence.
Definition: vehicle.cpp:127
ROAD_SW
South-west part.
Definition: road_type.h:58
ROADSTOP_BUS
A standard stop for buses.
Definition: station_type.h:48
GameSettings::pf
PathfinderSettings pf
settings for all pathfinders
Definition: settings_type.h:550
RVS_DRIVE_SIDE
Only used when retrieving move data.
Definition: roadveh.h:45
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:212
RoadTypeToRoadTypes
static RoadTypes RoadTypeToRoadTypes(RoadType rt)
Maps a RoadType to the corresponding RoadTypes value.
Definition: road_func.h:56
HasTileRoadType
static bool HasTileRoadType(TileIndex t, RoadType rt)
Check if a tile has a specific road type.
Definition: road_map.h:188
GetRoadVehLength
static uint GetRoadVehLength(const RoadVehicle *v)
Get length of a road vehicle.
Definition: roadveh_cmd.cpp:188
VehicleSpriteSeq::Set
void Set(SpriteID sprite)
Assign a single sprite to the sequence.
Definition: vehicle_base.h:163
WID_VV_START_STOP
Start or stop this vehicle, and show information about the current state.
Definition: vehicle_widget.h:19
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:147
GetRoadBits
static RoadBits GetRoadBits(TileIndex t, RoadType rt)
Get the present road bits for a specific road type.
Definition: road_map.h:111
DIAGDIR_NE
Northeast, upper right on your monitor.
Definition: direction_type.h:82
DAY_TICKS
static const int DAY_TICKS
1 day is 74 ticks; _date_fract used to be uint16 and incremented by 885.
Definition: date_type.h:30
BridgeSpec::speed
uint16 speed
maximum travel speed (1 unit = 1/1.6 mph = 1 km-ish/h)
Definition: bridge.h:48
Vehicle::SetNext
void SetNext(Vehicle *next)
Set the next vehicle of this vehicle.
Definition: vehicle.cpp:2631
SpecializedVehicle::First
T * First() const
Get the first vehicle in the chain.
Definition: vehicle_base.h:1010
SpecializedVehicle::UpdateViewport
void UpdateViewport(bool force_update, bool update_delta)
Update vehicle sprite- and position caches.
Definition: vehicle_base.h:1135
CMD_BUILD_ROAD
build a "half" road
Definition: command_type.h:203
Vehicle::last_station_visited
StationID last_station_visited
The last station we stopped at.
Definition: vehicle_base.h:302
Vehicle::reliability_spd_dec
uint16 reliability_spd_dec
Reliability decrease speed.
Definition: vehicle_base.h:262
GetRoadDepotDirection
static DiagDirection GetRoadDepotDirection(TileIndex t)
Get the direction of the exit of a road depot.
Definition: road_map.h:534
CommandCost::GetCost
Money GetCost() const
The costs as made up to this moment.
Definition: command_type.h:84
Vehicle::HandlePathfindingResult
void HandlePathfindingResult(bool path_found)
Handle the pathfinding result, especially the lost status.
Definition: vehicle.cpp:775
GroundVehicle::CargoChanged
void CargoChanged()
Recalculates the cached weight of a vehicle and its parts.
Definition: ground_vehicle.cpp:81
CommandCost
Common return value for all commands.
Definition: command_type.h:25
NPFRoadVehicleFindNearestDepot
FindDepotData NPFRoadVehicleFindNearestDepot(const RoadVehicle *v, int max_penalty)
Used when user sends road vehicle to the nearest depot or if road vehicle needs servicing using NPF...
Definition: npf.cpp:1114
DiagdirReachesTrackdirs
static TrackdirBits DiagdirReachesTrackdirs(DiagDirection diagdir)
Returns all trackdirs that can be reached when entering a tile from a given (diagonal) direction...
Definition: track_func.h:543
IsStandardRoadStopTile
static bool IsStandardRoadStopTile(TileIndex t)
Is tile t a standard (non-drive through) road stop station?
Definition: station_map.h:224
HasExactlyOneBit
static bool HasExactlyOneBit(T value)
Test whether value has exactly 1 bit set.
Definition: bitmath_func.hpp:276
IsDriveThroughStopTile
static bool IsDriveThroughStopTile(TileIndex t)
Is tile t a drive through road stop station?
Definition: station_map.h:234
Vehicle::vehstatus
byte vehstatus
Status.
Definition: vehicle_base.h:317
EngineImageType
EngineImageType
Visualisation contexts of vehicles and engines.
Definition: vehicle_type.h:87
Engine::flags
byte flags
Flags of the engine.
Definition: engine_base.h:35
_cur_year
Year _cur_year
Current year, starting at 0.
Definition: date.cpp:26
VehicleCargoList::StoredCount
uint StoredCount() const
Returns sum of cargo on board the vehicle (ie not only reserved).
Definition: cargopacket.h:366
RoadVehicle::overtaking
byte overtaking
Set to RVSB_DRIVE_SIDE when overtaking, otherwise 0.
Definition: roadveh.h:92
SpecializedVehicle< RoadVehicle, Type >::From
static RoadVehicle * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Definition: vehicle_base.h:1113
VehicleCache::cached_max_speed
uint16 cached_max_speed
Maximum speed of the consist (minimum of the max speed of all vehicles in the consist).
Definition: vehicle_base.h:123
Vehicle::NeedsAutomaticServicing
bool NeedsAutomaticServicing() const
Checks if the current order should be interrupted for a service-in-depot order.
Definition: vehicle.cpp:252
Vehicle::GetEngine
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
Definition: vehicle.cpp:743
Engine::GetDefaultCargoType
CargoID GetDefaultCargoType() const
Determines the default cargo type of an engine.
Definition: engine_base.h:81
TILE_SIZE
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:15
yapf.h
Entry point for OpenTTD to YAPF.
VehicleRandomBits
byte VehicleRandomBits()
Get a value for a vehicle&#39;s random_bits.
Definition: vehicle.cpp:362
GetPrice
Money GetPrice(Price index, uint cost_factor, const GRFFile *grf_file, int shift)
Determine a certain price.
Definition: economy.cpp:958
RandomRange
static uint32 RandomRange(uint32 limit)
Pick a random number between 0 and limit - 1, inclusive.
Definition: random_func.hpp:83
RoadStopType
RoadStopType
Types of RoadStops.
Definition: station_type.h:47
Vehicle::sprite_seq
VehicleSpriteSeq sprite_seq
Vehicle appearance.
Definition: vehicle_base.h:280
Direction
Direction
Defines the 8 directions on the map.
Definition: direction_type.h:26
EV_EXPLOSION_LARGE
Various explosions.
Definition: effectvehicle_func.h:24
IsStraightRoadTrackdir
static bool IsStraightRoadTrackdir(Trackdir dir)
Checks whether the given trackdir is a straight road.
Definition: track_func.h:672
Vehicle::x_bb_offs
int8 x_bb_offs
x offset of vehicle bounding box
Definition: vehicle_base.h:284
Engine::GetGRFID
uint32 GetGRFID() const
Retrieve the GRF ID of the NewGRF the engine is tied to.
Definition: engine.cpp:162
HasRoadWorks
static bool HasRoadWorks(TileIndex t)
Check if a tile has road works.
Definition: road_map.h:482
DIR_SE
Southeast.
Definition: direction_type.h:31
GroundVehicleCache::first_engine
EngineID first_engine
Cached EngineID of the front vehicle. INVALID_ENGINE for the front vehicle itself.
Definition: ground_vehicle.hpp:45
Backup
Class to backup a specific variable and restore it later.
Definition: backup_type.hpp:23
_local_company
CompanyByte _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:46
random_func.hpp
Pseudo random number generator.
DIR_NE
Northeast.
Definition: direction_type.h:29
Vehicle::y_bb_offs
int8 y_bb_offs
y offset of vehicle bounding box
Definition: vehicle_base.h:285
DIRDIFF_45RIGHT
Angle of 45 degrees right.
Definition: direction_type.h:67
Vehicle::breakdown_ctr
byte breakdown_ctr
Counter for managing breakdown events.
Definition: vehicle_base.h:263
TrackBits
TrackBits
Bitfield corresponding to Track.
Definition: track_type.h:41
RoadVehicle
Buses, trucks and trams belong to this class.
Definition: roadveh.h:88
Order::ShouldStopAtStation
bool ShouldStopAtStation(const Vehicle *v, StationID station) const
Check whether the given vehicle should stop at the given station based on this order and the non-stop...
Definition: order_cmd.cpp:2259
CmdBuildRoadVehicle
CommandCost CmdBuildRoadVehicle(TileIndex tile, DoCommandFlag flags, const Engine *e, uint16 data, Vehicle **ret)
Build a road vehicle.
Definition: roadveh_cmd.cpp:260
Vehicle::cargo_cap
uint16 cargo_cap
total capacity
Definition: vehicle_base.h:307
VehicleLengthChanged
void VehicleLengthChanged(const Vehicle *u)
Logs a bug in GRF and shows a warning message if this is for the first time this happened.
Definition: vehicle.cpp:330
IsTileOwner
static bool IsTileOwner(TileIndex tile, Owner owner)
Checks if a tile belongs to the given owner.
Definition: tile_map.h:207
TRACKDIR_RVREV_NE
(Road vehicle) reverse direction north-east
Definition: track_type.h:82
depot_map.h
Map related accessors for depots.
RoadVehIsCrashed
static bool RoadVehIsCrashed(RoadVehicle *v)
Road vehicle chain has crashed.
Definition: roadveh_cmd.cpp:498
DiagDirToRoadBits
static RoadBits DiagDirToRoadBits(DiagDirection d)
Create the road-part which belongs to the given DiagDirection.
Definition: road_func.h:144
VS_CRASHED
Vehicle is crashed.
Definition: vehicle_base.h:39
VF_BUILT_AS_PROTOTYPE
Vehicle is a prototype (accepted as exclusive preview).
Definition: vehicle_base.h:46
DRD_NONE
None of the directions are disallowed.
Definition: road_map.h:256
TileOffsByDiagDir
static TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition: map_func.h:343
Engine::reliability_spd_dec
uint16 reliability_spd_dec
Speed of reliability decay between services (per day).
Definition: engine_base.h:28
SubtractMoneyFromCompanyFract
void SubtractMoneyFromCompanyFract(CompanyID company, CommandCost cst)
Subtract money from a company, including the money fraction.
Definition: company_cmd.cpp:252
IsTileType
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a give tiletype.
Definition: tile_map.h:143
GetNewVehiclePosResult::y
int y
x and y position of the vehicle after moving
Definition: vehicle_func.h:78
DoCommand
CommandCost DoCommand(const CommandContainer *container, DoCommandFlag flags)
Shorthand for calling the long DoCommand with a container.
Definition: command.cpp:436
AgeVehicle
void AgeVehicle(Vehicle *v)
Update age of a vehicle.
Definition: vehicle.cpp:1320
VehicleSpriteSeq::IsValid
bool IsValid() const
Check whether the sequence contains any sprites.
Definition: vehicle_base.h:147
DIR_W
West.
Definition: direction_type.h:34
RoadVehicle::UpdateSpeed
int UpdateSpeed()
This function looks at the vehicle and updates its speed (cur_speed and subspeed) variables...
Definition: roadveh_cmd.cpp:725
ClientSettings::sound
SoundSettings sound
sound effect settings
Definition: settings_type.h:564
PathfinderSettings::yapf
YAPFSettings yapf
pathfinder settings for the yet another pathfinder
Definition: settings_type.h:433
HasVehicleOnPosXY
bool HasVehicleOnPosXY(int x, int y, void *data, VehicleFromPosProc *proc)
Checks whether a vehicle in on a specific location.
Definition: vehicle.cpp:453
Order::MakeDummy
void MakeDummy()
Makes this order a Dummy order.
Definition: order_cmd.cpp:134
VehicleSettings::road_side
byte road_side
the side of the road vehicles drive on
Definition: settings_type.h:464
Vehicle::y_offs
int8 y_offs
y offset for vehicle sprite
Definition: vehicle_base.h:287
RoadVehicle::OnNewDay
void OnNewDay()
Calls the new day handler of the vehicle.
Definition: roadveh_cmd.cpp:1643
AS_BRAKE
We want to stop.
Definition: ground_vehicle.hpp:24
DIR_N
North.
Definition: direction_type.h:28
GetRoadStopDir
static DiagDirection GetRoadStopDir(TileIndex t)
Gets the direction the road stop entrance points towards.
Definition: station_map.h:258
PROP_ROADVEH_RUNNING_COST_FACTOR
Yearly runningcost.
Definition: newgrf_properties.h:34
Order::IsType
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition: order_base.h:63
RVSB_WORMHOLE
The vehicle is in a tunnel and/or bridge.
Definition: roadveh.h:40
GetTileOwner
static Owner GetTileOwner(TileIndex tile)
Returns the owner of a tile.
Definition: tile_map.h:171
ReverseDiagDir
static DiagDirection ReverseDiagDir(DiagDirection d)
Returns the reverse direction of the given DiagDirection.
Definition: direction_func.h:120
DoCommandFlag
DoCommandFlag
List of flags for a command.
Definition: command_type.h:340
DIAGDIR_SE
Southeast.
Definition: direction_type.h:83
DIAGDIR_SW
Southwest.
Definition: direction_type.h:84
SpecializedVehicle::Next
T * Next() const
Get next vehicle in the chain.
Definition: vehicle_base.h:1028
GetRoadVehSpriteSize
void GetRoadVehSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
Get the size of the sprite of a road vehicle sprite heading west (used for lists).
Definition: roadveh_cmd.cpp:169
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:76
VETS_ENTERED_WORMHOLE
The vehicle either entered a bridge, tunnel or depot tile (this includes the last tile of the bridge/...
Definition: tile_cmd.h:24
CommandCost::Succeeded
bool Succeeded() const
Did this command succeed?
Definition: command_type.h:152
stdafx.h
Definition of base types and functions in a cross-platform compatible way.
RoadStop::SetEntranceBusy
void SetEntranceBusy(bool busy)
Makes an entrance occupied or free.
Definition: roadstop_base.h:114
GetBridgeSpec
static const BridgeSpec * GetBridgeSpec(BridgeType i)
Get the specification of a bridge type.
Definition: bridge.h:67
RoadVehicle::GetVehicleTrackdir
Trackdir GetVehicleTrackdir() const
Returns the Trackdir on which the vehicle is currently located.
Definition: roadveh_cmd.cpp:1669
VEHICLE_LENGTH
static const uint VEHICLE_LENGTH
The length of a vehicle in tile units.
Definition: vehicle_type.h:78
safeguards.h
A number of safeguards to prevent using unsafe methods.
Vehicle::x_extent
byte x_extent
x-extent of vehicle bounding box
Definition: vehicle_base.h:281
ROADTYPE_TRAM
Trams.
Definition: road_type.h:25
FindDepotData::best_length
uint best_length
The distance towards the depot in penalty, or UINT_MAX if not found.
Definition: pathfinder_type.h:48
Vehicle::InvalidateNewGRFCacheOfChain
void InvalidateNewGRFCacheOfChain()
Invalidates cached NewGRF variables of all vehicles in the chain (after the current vehicle) ...
Definition: vehicle_base.h:461
ProcessOrders
bool ProcessOrders(Vehicle *v)
Handle the orders of a vehicle and determine the next place to go to if needed.
Definition: order_cmd.cpp:2160
PROP_ROADVEH_SPEED
Max. speed: 1 unit = 1/0.8 mph = 2 km-ish/h.
Definition: newgrf_properties.h:39
DirDiff
DirDiff
Enumeration for the difference between two directions.
Definition: direction_type.h:65
Vehicle::z_extent
byte z_extent
z-extent of vehicle bounding box
Definition: vehicle_base.h:283
RoadBits
RoadBits
Enumeration for the road parts on a tile.
Definition: road_type.h:55
IsRoadDepotTile
static bool IsRoadDepotTile(TileIndex t)
Return whether a tile is a road depot tile.
Definition: road_map.h:99
Trackdir
Trackdir
Enumeration for tracks and directions.
Definition: track_type.h:74
VSE_START
Vehicle starting, i.e. leaving, the station.
Definition: newgrf_sound.h:21
DIAGDIR_END
Used for iterations.
Definition: direction_type.h:86
GroundVehicle::gv_flags
uint16 gv_flags
Definition: ground_vehicle.hpp:83
RVSB_IN_DEPOT
The vehicle is in a depot.
Definition: roadveh.h:39
TrackStatusToRedSignals
static TrackdirBits TrackStatusToRedSignals(TrackStatus ts)
Returns the red-signal-information of a TrackStatus.
Definition: track_func.h:364
Vehicle::cargo_type
CargoID cargo_type
type of cargo this vehicle is carrying
Definition: vehicle_base.h:305
ROAD_NONE
No road-part is build.
Definition: road_type.h:56
TRACKDIR_RVREV_SW
(Road vehicle) reverse direction south-west
Definition: track_type.h:90
WC_VEHICLE_VIEW
Vehicle view; Window numbers:
Definition: window_type.h:334
HVOT_BUS
Station has seen a bus.
Definition: station_type.h:69
Vehicle::IsFrontEngine
bool IsFrontEngine() const
Check if the vehicle is a front engine.
Definition: vehicle_base.h:882
DC_NO_WATER
don&#39;t allow building on water
Definition: command_type.h:345
CmdTurnRoadVeh
CommandCost CmdTurnRoadVeh(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
Turn a roadvehicle around.
Definition: roadveh_cmd.cpp:367
EngineInfo::misc_flags
byte misc_flags
Miscellaneous flags.
Definition: engine_type.h:142
FindVehicleOnPos
void FindVehicleOnPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
Find a vehicle from a specific location.
Definition: vehicle.cpp:497
Vehicle::tile
TileIndex tile
Current tile index.
Definition: vehicle_base.h:230
RoadVehFindData
Definition: roadveh_cmd.cpp:607
ROAD_NE
North-east part.
Definition: road_type.h:60
WC_ROADVEH_LIST
Road vehicle list; Window numbers:
Definition: window_type.h:309
VPF_NPF
New PathFinder.
Definition: vehicle_type.h:62
CheckOwnership
CommandCost CheckOwnership(Owner owner, TileIndex tile)
Check whether the current owner owns something.
Definition: company_cmd.cpp:310
npf_func.h
Functions to access the new pathfinder.
DIAGDIR_NW
Northwest.
Definition: direction_type.h:85
Vehicle::HasArticulatedPart
bool HasArticulatedPart() const
Check if an engine has an articulated part.
Definition: vehicle_base.h:900
DiagDirToDiagTrackdir
static Trackdir DiagDirToDiagTrackdir(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal trackdir that runs in that direction.
Definition: track_func.h:525
CanVehicleUseStation
bool CanVehicleUseStation(EngineID engine_type, const Station *st)
Can this station be used by the given engine type?
Definition: vehicle.cpp:2752
VehicleEnterTile
VehicleEnterTileStatus VehicleEnterTile(Vehicle *v, TileIndex tile, int x, int y)
Call the tile callback function for a vehicle entering a tile.
Definition: vehicle.cpp:1662
Vehicle::IsInDepot
virtual bool IsInDepot() const
Check whether the vehicle is in the depot.
Definition: vehicle_base.h:505
HVOT_TRUCK
Station has seen a truck.
Definition: station_type.h:70
_road_stop_stop_frame
const byte _road_stop_stop_frame[]
Table of road stop stop frames, when to stop at a road stop.
DirDifference
static DirDiff DirDifference(Direction d0, Direction d1)
Calculate the difference between two directions.
Definition: direction_func.h:70
YapfRoadVehicleChooseTrack
Trackdir YapfRoadVehicleChooseTrack(const RoadVehicle *v, TileIndex tile, DiagDirection enterdir, TrackdirBits trackdirs, bool &path_found)
Finds the best path for given road vehicle using YAPF.
Definition: yapf_road.cpp:488
ChangeDir
static Direction ChangeDir(Direction d, DirDiff delta)
Change a direction by a given difference.
Definition: direction_func.h:106
Vehicle::x_offs
int8 x_offs
x offset for vehicle sprite
Definition: vehicle_base.h:286
VehicleSpriteSeq
Sprite sequence for a vehicle part.
Definition: vehicle_base.h:130
DiagDirection
DiagDirection
Enumeration for diagonal directions.
Definition: direction_type.h:80
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: depend.cpp:42
VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
RoadVehicle::Crash
uint Crash(bool flooded=false)
Crash the (whole) vehicle chain.
Definition: roadveh_cmd.cpp:530
min
static T min(const T a, const T b)
Returns the minimum of two values.
Definition: math_func.hpp:42
GetAnyRoadBits
RoadBits GetAnyRoadBits(TileIndex tile, RoadType rt, bool straight_tunnel_bridge_entrance)
Returns the RoadBits on an arbitrary tile Special behaviour:
Definition: road_map.cpp:35
IsCargoInClass
static bool IsCargoInClass(CargoID c, CargoClass cc)
Does cargo c have cargo class cc?
Definition: cargotype.h:150
Vehicle::refit_cap
uint16 refit_cap
Capacity left over from before last refit.
Definition: vehicle_base.h:308
Vehicle::random_bits
byte random_bits
Bits used for determining which randomized variational spritegroups to use when drawing.
Definition: vehicle_base.h:299
sound_func.h
Functions related to sound.
Vehicle::reliability
uint16 reliability
Reliability.
Definition: vehicle_base.h:261
GetTunnelBridgeDirection
static DiagDirection GetTunnelBridgeDirection(TileIndex t)
Get the direction pointing to the other end.
Definition: tunnelbridge_map.h:28
PathfinderSettings::roadveh_queue
bool roadveh_queue
buggy road vehicle queueing
Definition: settings_type.h:420
spritecache.h
Functions to cache sprites in memory.
RoadVehicle::FindClosestDepot
bool FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse)
Find the closest depot for this vehicle and tell us the location, DestinationID and whether we should...
Definition: roadveh_cmd.cpp:347
Vehicle::First
Vehicle * First() const
Get the first vehicle of this vehicle chain.
Definition: vehicle_base.h:595
RoadVehicle::GetDisplayImageWidth
int GetDisplayImageWidth(Point *offset=NULL) const
Get the width of a road vehicle image in the GUI.
Definition: roadveh_cmd.cpp:91
CommandCost::Failed
bool Failed() const
Did this command fail?
Definition: command_type.h:161
Vehicle::tick_counter
byte tick_counter
Increased by one for each tick.
Definition: vehicle_base.h:314
CreateEffectVehicleRel
EffectVehicle * CreateEffectVehicleRel(const Vehicle *v, int x, int y, int z, EffectVehicleType type)
Create an effect vehicle above a particular vehicle.
Definition: effectvehicle.cpp:640
RoadVehicle::crashed_ctr
uint16 crashed_ctr
Animation counter when the vehicle has crashed.
Definition: roadveh.h:94
TRACKDIR_RVREV_SE
(Road vehicle) reverse direction south-east
Definition: track_type.h:83
NPFRoadVehicleChooseTrack
Trackdir NPFRoadVehicleChooseTrack(const RoadVehicle *v, TileIndex tile, DiagDirection enterdir, TrackdirBits trackdirs, bool &path_found)
Finds the best path for given road vehicle using NPF.
Definition: npf.cpp:1131
GetDepotIndex
static DepotID GetDepotIndex(TileIndex t)
Get the index of which depot is attached to the tile.
Definition: depot_map.h:54
Vehicle::build_year
Year build_year
Year the vehicle has been built.
Definition: vehicle_base.h:257
PlayVehicleSound
bool PlayVehicleSound(const Vehicle *v, VehicleSoundEvent event)
Checks whether a NewGRF wants to play a different vehicle sound effect.
Definition: newgrf_sound.cpp:187
Engine
Definition: engine_base.h:23
return_cmd_error
#define return_cmd_error(errcode)
Returns from a function with a specific StringID as error.
Definition: command_func.h:35
TRACKDIR_LEFT_N
Left track and direction to north.
Definition: track_type.h:88
GetTileTrackStatus
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition: landscape.cpp:509
RoadVehicle::IsInDepot
bool IsInDepot() const
Check whether the vehicle is in the depot.
Definition: roadveh.h:116
AI::NewEvent
static void NewEvent(CompanyID company, ScriptEvent *event)
Queue a new event for an AI.
Definition: ai_core.cpp:233
Clamp
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition: math_func.hpp:139
ROAD_NW
North-west part.
Definition: road_type.h:57
RoadVehicle::MarkDirty
void MarkDirty()
Marks the vehicles to be redrawn and updates cached variables.
Definition: roadveh_cmd.cpp:397
Chance16
static bool Chance16(const uint a, const uint b)
Flips a coin with given probability.
Definition: random_func.hpp:133
ROAD_SE
South-east part.
Definition: road_type.h:59
DeleteLastRoadVeh
static void DeleteLastRoadVeh(RoadVehicle *v)
Delete last vehicle of a chain road vehicles.
Definition: roadveh_cmd.cpp:465
FindDepotData::tile
TileIndex tile
The tile of the depot.
Definition: pathfinder_type.h:47
TRACKDIR_UPPER_W
Upper track and direction to west.
Definition: track_type.h:86
GetBridgeType
static BridgeType GetBridgeType(TileIndex t)
Determines the type of bridge on a tile.
Definition: bridge_map.h:56
RoadDriveEntry
Definition: roadveh_cmd.cpp:974
RV_OVERTAKE_TIMEOUT
static const byte RV_OVERTAKE_TIMEOUT
The number of ticks a vehicle has for overtaking.
Definition: roadveh.h:80
RVSB_IN_DT_ROAD_STOP
The vehicle is in a drive-through road stop.
Definition: roadveh.h:52
DiagDirToAxis
static Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
Definition: direction_func.h:216
TRACK_BIT_CROSS
X-Y-axis cross.
Definition: track_type.h:49
GetOtherTunnelBridgeEnd
static TileIndex GetOtherTunnelBridgeEnd(TileIndex t)
Determines type of the wormhole and returns its other end.
Definition: tunnelbridge_map.h:80
DC_EXEC
execute the given command
Definition: command_type.h:342
TRACKDIR_LOWER_E
Lower track and direction to east.
Definition: track_type.h:79
INVALID_ENGINE
static const EngineID INVALID_ENGINE
Constant denoting an invalid engine.
Definition: engine_type.h:174
company_func.h
Functions related to companies.
GetNewVehiclePos
GetNewVehiclePosResult GetNewVehiclePos(const Vehicle *v)
Get position information of a vehicle when moving one pixel in the direction it is facing...
Definition: vehicle.cpp:1608
Vehicle::UpdatePosition
void UpdatePosition()
Update the position of the vehicle.
Definition: vehicle.cpp:1547
GetStationIndex
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
Definition: station_map.h:29
CheckConsistencyOfArticulatedVehicle
void CheckConsistencyOfArticulatedVehicle(const Vehicle *v)
Checks whether the specs of freshly build articulated vehicles are consistent with the information sp...
Definition: articulated_vehicles.cpp:313
KillFirstBit
static T KillFirstBit(T value)
Clear the first bit in an integer.
Definition: bitmath_func.hpp:241
RoadVehicle::IsBus
bool IsBus() const
Check whether a roadvehicle is a bus.
Definition: roadveh_cmd.cpp:80
articulated_vehicles.h
Functions related to articulated vehicles.
ErrorUnknownCallbackResult
void ErrorUnknownCallbackResult(uint32 grfid, uint16 cbid, uint16 cb_res)
Record that a NewGRF returned an unknown/invalid callback result.
Definition: newgrf_commons.cpp:518
IsNormalRoadTile
static bool IsNormalRoadTile(TileIndex t)
Return whether a tile is a normal road tile.
Definition: road_map.h:57
RoadVehicleInfo
Information about a road vehicle.
Definition: engine_type.h:112
EXPENSES_ROADVEH_RUN
Running costs road vehicles.
Definition: economy_type.h:154
SpecializedVehicle::Previous
T * Previous() const
Get previous vehicle in the chain.
Definition: vehicle_base.h:1034
MP_TUNNELBRIDGE
Tunnel entry/exit and bridge heads.
Definition: tile_type.h:52
Order::GetDestination
DestinationID GetDestination() const
Gets the destination of this order.
Definition: order_base.h:96
Engine::GetGRF
const GRFFile * GetGRF() const
Retrieve the NewGRF the engine is tied to.
Definition: engine_base.h:140
VehicleServiceInDepot
void VehicleServiceInDepot(Vehicle *v)
Service a vehicle and all subsequent vehicles in the consist.
Definition: vehicle.cpp:163
RVSB_ROAD_STOP_TRACKDIR_MASK
Only bits 0 and 3 are used to encode the trackdir for road stops.
Definition: roadveh.h:58
TRACKDIR_LEFT_S
Left track and direction to south.
Definition: track_type.h:80
SetWindowWidgetDirty
void SetWindowWidgetDirty(WindowClass cls, WindowNumber number, byte widget_index)
Mark a particular widget in a particular window as dirty (in need of repainting)
Definition: window.cpp:3134
Order::MakeGoToDepot
void MakeGoToDepot(DepotID destination, OrderDepotTypeFlags order, OrderNonStopFlags non_stop_type=ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS, OrderDepotActionFlags action=ODATF_SERVICE_ONLY, CargoID cargo=CT_NO_REFIT)
Makes this order a Go To Depot order.
Definition: order_cmd.cpp:91
Vehicle::HandleBreakdown
bool HandleBreakdown()
Handle all of the aspects of a vehicle breakdown This includes adding smoke and sounds, and ending the breakdown when appropriate.
Definition: vehicle.cpp:1254
SpriteID
uint32 SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:19
EngineID
uint16 EngineID
Unique identification number of an engine.
Definition: engine_type.h:22
_current_company
CompanyByte _current_company
Company currently doing an action.
Definition: company_cmd.cpp:47
TileIndex
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:80
PALETTE_CRASH
static const PaletteID PALETTE_CRASH
Recolour sprite greying of crashed vehicles.
Definition: sprites.h:1569
Vehicle::GetAdvanceDistance
uint GetAdvanceDistance()
Determines the vehicle "progress" needed for moving a step.
Definition: vehicle_base.h:415
TRACKDIR_RIGHT_S
Right track and direction to south.
Definition: track_type.h:81
FindDepotData
Helper container to find a depot.
Definition: pathfinder_type.h:46
Vehicle::BeginLoading
void BeginLoading()
Prepare everything to begin the loading when arriving at a station.
Definition: vehicle.cpp:2005
Vehicle::date_of_last_service
Date date_of_last_service
Last date the vehicle had a service at a depot.
Definition: vehicle_base.h:260
GetNewVehiclePosResult
Position information of a vehicle after it moved.
Definition: vehicle_func.h:77
IsLevelCrossingTile
static bool IsLevelCrossingTile(TileIndex t)
Return whether a tile is a level crossing tile.
Definition: road_map.h:78
NT_ARRIVAL_COMPANY
First vehicle arrived for company.
Definition: news_type.h:37
FindVehicleOnPosXY
void FindVehicleOnPosXY(int x, int y, void *data, VehicleFromPosProc *proc)
Find a vehicle from a specific location.
Definition: vehicle.cpp:437
TileY
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:217
RVS_ENTERED_STOP
Only set when a vehicle has entered the stop.
Definition: roadveh.h:44
Order::Free
void Free()
&#39;Free&#39; the order
Definition: order_cmd.cpp:64
error
void CDECL error(const char *s,...)
Error handling for fatal non-user errors.
Definition: openttd.cpp:110
Vehicle::owner
OwnerByte owner
Which company owns the vehicle?
Definition: vehicle_base.h:273
RoadVehUpdateCache
void RoadVehUpdateCache(RoadVehicle *v, bool same_length)
Update the cache of a road vehicle.
Definition: roadveh_cmd.cpp:216
abs
static T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition: math_func.hpp:83
BaseStation::xy
TileIndex xy
Base tile of the station.
Definition: base_station_base.h:55
TRACKDIR_LOWER_W
Lower track and direction to west.
Definition: track_type.h:87
GroundVehicleCache::cached_total_length
uint16 cached_total_length
Length of the whole vehicle (valid only for the first engine).
Definition: ground_vehicle.hpp:44
zoom_func.h
Functions related to zooming.
OvertakeData
Definition: roadveh_cmd.cpp:763
MP_STATION
A tile of a station.
Definition: tile_type.h:48
FindFirstBit2x64
static uint8 FindFirstBit2x64(const int value)
Finds the position of the first non-zero bit in an integer.
Definition: bitmath_func.hpp:218
SpecializedStation< Station, false >::GetByTile
static Station * GetByTile(TileIndex tile)
Get the station belonging to a specific tile.
Definition: base_station_base.h:225
RoadVehicle::GetRunningCost
Money GetRunningCost() const
Gets the running cost of a vehicle.
Definition: roadveh_cmd.cpp:1577
SoundSettings::disaster
bool disaster
Play disaster and accident sounds.
Definition: settings_type.h:179
RoadVehicle::GetOrderStationLocation
TileIndex GetOrderStationLocation(StationID station)
Determine the location for the station where the vehicle goes to next.
Definition: roadveh_cmd.cpp:582
TRANSPORT_ROAD
Transport by road vehicle.
Definition: transport_type.h:30
PROP_ROADVEH_CARGO_AGE_PERIOD
Number of ticks before carried cargo is aged.
Definition: newgrf_properties.h:41
ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS
The vehicle will not stop at any stations it passes except the destination.
Definition: order_type.h:80
RVSB_IN_ROAD_STOP
The vehicle is in a road stop.
Definition: roadveh.h:50
TileOffsByDir
static TileIndexDiff TileOffsByDir(Direction dir)
Convert a Direction to a TileIndexDiff.
Definition: map_func.h:357
Vehicle::z_pos
int32 z_pos
z coordinate.
Definition: vehicle_base.h:270
VS_HIDDEN
Vehicle is not visible.
Definition: vehicle_base.h:32
WC_VEHICLE_DETAILS
Vehicle details; Window numbers:
Definition: window_type.h:195
CountBits
static uint CountBits(T value)
Counts the number of set bits in a variable.
Definition: bitmath_func.hpp:253
TrackdirBits
TrackdirBits
Enumeration of bitmasks for the TrackDirs.
Definition: track_type.h:106
game.hpp
Base functions for all Games.
command_func.h
Functions related to commands.
Point
Coordinates of a point in 2D.
Definition: geometry_type.hpp:28
RoadStop
A Stop for a Road Vehicle.
Definition: roadstop_base.h:24
NT_ACCIDENT
An accident or disaster has occurred.
Definition: news_type.h:39
RoadStop::IsDriveThroughRoadStopContinuation
static bool IsDriveThroughRoadStopContinuation(TileIndex rs, TileIndex next)
Checks whether the &#39;next&#39; tile is still part of the road same drive through stop &#39;rs&#39; in the same dir...
Definition: roadstop.cpp:307
YAPFSettings::maximum_go_to_depot_penalty
uint32 maximum_go_to_depot_penalty
What is the maximum penalty that may be endured for going to a depot.
Definition: settings_type.h:377
RoadVehicleInfo::shorten_factor
byte shorten_factor
length on main map for this type is 8 - shorten_factor
Definition: engine_type.h:125
CheckRoadBlockedForOvertaking
static bool CheckRoadBlockedForOvertaking(OvertakeData *od)
Check if overtaking is possible on a piece of track.
Definition: roadveh_cmd.cpp:783
RVSB_TRACKDIR_MASK
The mask used to extract track dirs.
Definition: roadveh.h:57
tunnelbridge_map.h
Functions that have tunnels and bridges in common.
GetVehicleCallback
uint16 GetVehicleCallback(CallbackID callback, uint32 param1, uint32 param2, EngineID engine, const Vehicle *v)
Evaluate a newgrf callback for vehicles.
Definition: newgrf_engine.cpp:1067
GetDisallowedRoadDirections
static DisallowedRoadDirections GetDisallowedRoadDirections(TileIndex t)
Gets the disallowed directions.
Definition: road_map.h:271
GetRoadTypes
static RoadTypes GetRoadTypes(TileIndex t)
Get the present road types of a tile.
Definition: road_map.h:166
GroundVehicle::SetLastSpeed
void SetLastSpeed()
Update the GUI variant of the current speed of the vehicle.
Definition: ground_vehicle.hpp:343
GroundVehicleCache::cached_veh_length
uint8 cached_veh_length
Length of this vehicle in units of 1/VEHICLE_LENGTH of normal length. It is cached because this can b...
Definition: ground_vehicle.hpp:46
Engine::original_image_index
uint8 original_image_index
Original vehicle image index, thus the image index of the overridden vehicle.
Definition: engine_base.h:41
VehicleSettings::roadveh_acceleration_model
uint8 roadveh_acceleration_model
realistic acceleration for road vehicles
Definition: settings_type.h:450
Vehicle::running_ticks
byte running_ticks
Number of ticks this vehicle was not stopped this day.
Definition: vehicle_base.h:315
DIR_NW
Northwest.
Definition: direction_type.h:35
Vehicle::y_extent
byte y_extent
y-extent of vehicle bounding box
Definition: vehicle_base.h:282
TRACKDIR_UPPER_E
Upper track and direction to east.
Definition: track_type.h:78
Vehicle::engine_type
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:288
DIR_S
South.
Definition: direction_type.h:32
TRACKDIR_RVREV_NW
(Road vehicle) reverse direction north-west
Definition: track_type.h:91
CC_PASSENGERS
Passengers.
Definition: cargotype.h:40
Vehicle::x_pos
int32 x_pos
x coordinate.
Definition: vehicle_base.h:268
BaseConsist::vehicle_flags
uint16 vehicle_flags
Used for gradual loading and other miscellaneous things (.
Definition: base_consist.h:32
HasBit
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:105
newgrf_sound.h
Functions related to NewGRF provided sounds.
Backup::Restore
void Restore()
Restore the variable.
Definition: backup_type.hpp:114
ai.hpp
Base functions for all AIs.
RoadVehicle::UpdateDeltaXY
void UpdateDeltaXY(Direction direction)
Updates the x and y offsets and the size of the sprite used for this vehicle.
Definition: roadveh_cmd.cpp:406
Vehicle::progress
byte progress
The percentage (if divided by 256) this vehicle already crossed the tile unit.
Definition: vehicle_base.h:297
VETS_CANNOT_ENTER
The vehicle cannot enter the tile.
Definition: tile_cmd.h:25
TRACKDIR_BIT_NONE
No track build.
Definition: track_type.h:107
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition: geometry_type.hpp:40
ROAD_Y
Full road along the y-axis (north-west + south-east)
Definition: road_type.h:62
Vehicle::y_pos
int32 y_pos
y coordinate.
Definition: vehicle_base.h:269
Order::GetMaxSpeed
uint16 GetMaxSpeed() const
Get the maxmimum speed in km-ish/h a vehicle is allowed to reach on the way to the destination...
Definition: order_base.h:194
RoadVehicle::IsPrimaryVehicle
bool IsPrimaryVehicle() const
Whether this is the primary vehicle in the chain.
Definition: roadveh.h:110
EF_ROAD_TRAM
Road vehicle is a tram/light rail vehicle.
Definition: engine_type.h:154
TrackdirBitsToTrackBits
static TrackBits TrackdirBitsToTrackBits(TrackdirBits bits)
Discards all directional information from a TrackdirBits value.
Definition: track_func.h:318
Owner
Owner
Enum for all companies/owners.
Definition: company_type.h:20
INVALID_TRACKDIR
Flag for an invalid trackdir.
Definition: track_type.h:93
GroundVehicle::Crash
uint Crash(bool flooded)
Common code executed for crashed ground vehicles.
Definition: ground_vehicle.hpp:102
CBID_VEHICLE_LENGTH
Vehicle length, returns the amount of 1/8&#39;s the vehicle is shorter for trains and RVs...
Definition: newgrf_callbacks.h:35
RoadVehArrivesAt
static void RoadVehArrivesAt(const RoadVehicle *v, Station *st)
A road vehicle arrives at a station.
Definition: roadveh_cmd.cpp:685
DIRDIFF_REVERSE
One direction is the opposite of the other one.
Definition: direction_type.h:69
YapfRoadVehicleFindNearestDepot
FindDepotData YapfRoadVehicleFindNearestDepot(const RoadVehicle *v, int max_penalty)
Used when user sends road vehicle to the nearest depot or if road vehicle needs servicing using YAPF...
Definition: yapf_road.cpp:503
TILE_ADD
#define TILE_ADD(x, y)
Adds to tiles together.
Definition: map_func.h:246
GroundVehicle::UpdateInclination
int UpdateInclination(bool new_tile, bool update_delta)
Checks if the vehicle is in a slope and sets the required flags in that case.
Definition: ground_vehicle.hpp:234
Vehicle::profit_this_year
Money profit_this_year
Profit this year << 8, low 8 bits are fract.
Definition: vehicle_base.h:239
SetWindowClassesDirty
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition: window.cpp:3148
news_func.h
Functions related to news.
station_base.h
Base classes/functions for stations.
Vehicle::vcache
VehicleCache vcache
Cache of often used vehicle values.
Definition: vehicle_base.h:330
SpecializedStation< Station, false >::Get
static Station * Get(size_t index)
Gets station with given index.
Definition: base_station_base.h:206
_date
Date _date
Current date in days (day counter)
Definition: date.cpp:28
GetNewVehiclePosResult::new_tile
TileIndex new_tile
Tile of the vehicle after moving.
Definition: vehicle_func.h:80
Vehicle::first
Vehicle * first
NOSAVE: pointer to the first vehicle in the chain.
Definition: vehicle_base.h:219
DIR_SW
Southwest.
Definition: direction_type.h:33
roadveh_movement.h
Data about how a road vehicle must drive on a tile.
ODTFB_SERVICE
This depot order is because of the servicing limit.
Definition: order_type.h:101
BaseVehicle::type
VehicleTypeByte type
Type of vehicle.
Definition: vehicle_type.h:54
Vehicle::HandleLoading
void HandleLoading(bool mode=false)
Handle the loading of the vehicle; when not it skips through dummy orders and does nothing in all oth...
Definition: vehicle.cpp:2214
TrackStatusToTrackdirBits
static TrackdirBits TrackStatusToTrackdirBits(TrackStatus ts)
Returns the present-trackdir-information of a TrackStatus.
Definition: track_func.h:340
RoadVehicle::GetImage
void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const
Gets the sprite to show for the given direction.
Definition: roadveh_cmd.cpp:118
backup_type.hpp
Class for backupping variables and making sure they are restored later.
Station
Station data structure.
Definition: station_base.h:446
effectvehicle_func.h
Functions related to effect vehicles.
Order::GetNonStopType
OrderNonStopFlags GetNonStopType() const
At which stations must we stop?
Definition: order_base.h:133
IsRoadDepot
static bool IsRoadDepot(TileIndex t)
Return whether a tile is a road depot.
Definition: road_map.h:89
Vehicle::InvalidateNewGRFCache
void InvalidateNewGRFCache()
Invalidates cached NewGRF variables.
Definition: vehicle_base.h:452
GVF_SUPPRESS_IMPLICIT_ORDERS
Disable insertion and removal of automatic orders until the vehicle completes the real order...
Definition: ground_vehicle.hpp:56
AxisToRoadBits
static RoadBits AxisToRoadBits(Axis a)
Create the road-part which belongs to the given Axis.
Definition: road_func.h:159
VehicleSpriteSeq::GetBounds
void GetBounds(Rect *bounds) const
Determine shared bounds of all sprites.
Definition: vehicle.cpp:99
OverflowSafeInt< int64, INT64_MAX, INT64_MIN >
Engine::GetLifeLengthInDays
Date GetLifeLengthInDays() const
Returns the vehicle&#39;s (not model&#39;s!) life length in days.
Definition: engine.cpp:446
Vehicle::day_counter
byte day_counter
Increased by one for each day.
Definition: vehicle_base.h:313
Vehicle::current_order
Order current_order
The current order (+ status, like: loading)
Definition: vehicle_base.h:318
DiagDirToDir
static Direction DiagDirToDir(DiagDirection dir)
Convert a DiagDirection to a Direction.
Definition: direction_func.h:184
RoadStop::GetByTile
static RoadStop * GetByTile(TileIndex tile, RoadStopType type)
Find a roadstop at given tile.
Definition: roadstop.cpp:268
InvalidateWindowData
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
Definition: window.cpp:3220
GroundVehicle< RoadVehicle, VEH_ROAD >::gcache
GroundVehicleCache gcache
Cache of often calculated values.
Definition: ground_vehicle.hpp:82
RoadVehicle::overtaking_ctr
byte overtaking_ctr
The length of the current overtake attempt.
Definition: roadveh.h:93
Vehicle::colourmap
SpriteID colourmap
NOSAVE: cached colour mapping.
Definition: vehicle_base.h:254
SpecializedVehicle< RoadVehicle, Type >::GetIfValid
static RoadVehicle * GetIfValid(size_t index)
Returns vehicle if the index is a valid index for this vehicle type.
Definition: vehicle_base.h:1103
VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
PathfinderSettings::pathfinder_for_roadvehs
uint8 pathfinder_for_roadvehs
the pathfinder to use for roadvehicles
Definition: settings_type.h:416
SetDParam
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings_func.h:201
GroundVehicle::IsChainInDepot
bool IsChainInDepot() const
Check whether the whole vehicle chain is in the depot.
Definition: ground_vehicle.cpp:192
AddVehicleNewsItem
static void AddVehicleNewsItem(StringID string, NewsType type, VehicleID vehicle, StationID station=INVALID_STATION)
Adds a newsitem referencing a vehicle.
Definition: news_func.h:32
newgrf.h
Base for the NewGRF implementation.