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