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