OpenTTD Source  12.0-beta2
vehicle.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of OpenTTD.
3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6  */
7 
10 #include "stdafx.h"
11 #include "error.h"
12 #include "roadveh.h"
13 #include "ship.h"
14 #include "spritecache.h"
15 #include "timetable.h"
16 #include "viewport_func.h"
17 #include "news_func.h"
18 #include "command_func.h"
19 #include "company_func.h"
20 #include "train.h"
21 #include "aircraft.h"
22 #include "newgrf_debug.h"
23 #include "newgrf_sound.h"
24 #include "newgrf_station.h"
25 #include "group_gui.h"
26 #include "strings_func.h"
27 #include "zoom_func.h"
28 #include "date_func.h"
29 #include "vehicle_func.h"
30 #include "autoreplace_func.h"
31 #include "autoreplace_gui.h"
32 #include "station_base.h"
33 #include "ai/ai.hpp"
34 #include "depot_func.h"
35 #include "network/network.h"
36 #include "core/pool_func.hpp"
37 #include "economy_base.h"
38 #include "articulated_vehicles.h"
39 #include "roadstop_base.h"
40 #include "core/random_func.hpp"
41 #include "core/backup_type.hpp"
42 #include "order_backup.h"
43 #include "sound_func.h"
44 #include "effectvehicle_func.h"
45 #include "effectvehicle_base.h"
46 #include "vehiclelist.h"
47 #include "bridge_map.h"
48 #include "tunnel_map.h"
49 #include "depot_map.h"
50 #include "gamelog.h"
51 #include "linkgraph/linkgraph.h"
52 #include "linkgraph/refresh.h"
53 #include "framerate_type.h"
54 
55 #include "table/strings.h"
56 
57 #include "safeguards.h"
58 
59 /* Number of bits in the hash to use from each vehicle coord */
60 static const uint GEN_HASHX_BITS = 6;
61 static const uint GEN_HASHY_BITS = 6;
62 
63 /* Size of each hash bucket */
64 static const uint GEN_HASHX_BUCKET_BITS = 7;
65 static const uint GEN_HASHY_BUCKET_BITS = 6;
66 
67 /* Compute hash for vehicle coord */
68 #define GEN_HASHX(x) GB((x), GEN_HASHX_BUCKET_BITS + ZOOM_LVL_SHIFT, GEN_HASHX_BITS)
69 #define GEN_HASHY(y) (GB((y), GEN_HASHY_BUCKET_BITS + ZOOM_LVL_SHIFT, GEN_HASHY_BITS) << GEN_HASHX_BITS)
70 #define GEN_HASH(x, y) (GEN_HASHY(y) + GEN_HASHX(x))
71 
72 /* Maximum size until hash repeats */
73 static const int GEN_HASHX_SIZE = 1 << (GEN_HASHX_BUCKET_BITS + GEN_HASHX_BITS + ZOOM_LVL_SHIFT);
74 static const int GEN_HASHY_SIZE = 1 << (GEN_HASHY_BUCKET_BITS + GEN_HASHY_BITS + ZOOM_LVL_SHIFT);
75 
76 /* Increments to reach next bucket in hash table */
77 static const int GEN_HASHX_INC = 1;
78 static const int GEN_HASHY_INC = 1 << GEN_HASHX_BITS;
79 
80 /* Mask to wrap-around buckets */
81 static const uint GEN_HASHX_MASK = (1 << GEN_HASHX_BITS) - 1;
82 static const uint GEN_HASHY_MASK = ((1 << GEN_HASHY_BITS) - 1) << GEN_HASHX_BITS;
83 
84 VehicleID _new_vehicle_id;
87 
88 
90 VehiclePool _vehicle_pool("Vehicle");
92 
93 
94 
98 void VehicleSpriteSeq::GetBounds(Rect *bounds) const
99 {
100  bounds->left = bounds->top = bounds->right = bounds->bottom = 0;
101  for (uint i = 0; i < this->count; ++i) {
102  const Sprite *spr = GetSprite(this->seq[i].sprite, ST_NORMAL);
103  if (i == 0) {
104  bounds->left = spr->x_offs;
105  bounds->top = spr->y_offs;
106  bounds->right = spr->width + spr->x_offs - 1;
107  bounds->bottom = spr->height + spr->y_offs - 1;
108  } else {
109  if (spr->x_offs < bounds->left) bounds->left = spr->x_offs;
110  if (spr->y_offs < bounds->top) bounds->top = spr->y_offs;
111  int right = spr->width + spr->x_offs - 1;
112  int bottom = spr->height + spr->y_offs - 1;
113  if (right > bounds->right) bounds->right = right;
114  if (bottom > bounds->bottom) bounds->bottom = bottom;
115  }
116  }
117 }
118 
126 void VehicleSpriteSeq::Draw(int x, int y, PaletteID default_pal, bool force_pal) const
127 {
128  for (uint i = 0; i < this->count; ++i) {
129  PaletteID pal = force_pal || !this->seq[i].pal ? default_pal : this->seq[i].pal;
130  DrawSprite(this->seq[i].sprite, pal, x, y);
131  }
132 }
133 
140 bool Vehicle::NeedsAutorenewing(const Company *c, bool use_renew_setting) const
141 {
142  /* We can always generate the Company pointer when we have the vehicle.
143  * However this takes time and since the Company pointer is often present
144  * when this function is called then it's faster to pass the pointer as an
145  * argument rather than finding it again. */
146  assert(c == Company::Get(this->owner));
147 
148  if (use_renew_setting && !c->settings.engine_renew) return false;
149  if (this->age - this->max_age < (c->settings.engine_renew_months * 30)) return false;
150 
151  /* Only engines need renewing */
152  if (this->type == VEH_TRAIN && !Train::From(this)->IsEngine()) return false;
153 
154  return true;
155 }
156 
163 {
164  assert(v != nullptr);
165  SetWindowDirty(WC_VEHICLE_DETAILS, v->index); // ensure that last service date and reliability are updated
166 
167  do {
170  v->reliability = v->GetEngine()->reliability;
171  /* Prevent vehicles from breaking down directly after exiting the depot. */
172  v->breakdown_chance /= 4;
173  if (_settings_game.difficulty.vehicle_breakdowns == 1) v->breakdown_chance = 0; // on reduced breakdown
174  v = v->Next();
175  } while (v != nullptr && v->HasEngineType());
176 }
177 
185 {
186  /* Stopped or crashed vehicles will not move, as such making unmovable
187  * vehicles to go for service is lame. */
188  if (this->vehstatus & (VS_STOPPED | VS_CRASHED)) return false;
189 
190  /* Are we ready for the next service cycle? */
191  const Company *c = Company::Get(this->owner);
192  if (this->ServiceIntervalIsPercent() ?
193  (this->reliability >= this->GetEngine()->reliability * (100 - this->GetServiceInterval()) / 100) :
194  (this->date_of_last_service + this->GetServiceInterval() >= _date)) {
195  return false;
196  }
197 
198  /* If we're servicing anyway, because we have not disabled servicing when
199  * there are no breakdowns or we are playing with breakdowns, bail out. */
202  return true;
203  }
204 
205  /* Test whether there is some pending autoreplace.
206  * Note: We do this after the service-interval test.
207  * There are a lot more reasons for autoreplace to fail than we can test here reasonably. */
208  bool pending_replace = false;
209  Money needed_money = c->settings.engine_renew_money;
210  if (needed_money > c->money) return false;
211 
212  for (const Vehicle *v = this; v != nullptr; v = (v->type == VEH_TRAIN) ? Train::From(v)->GetNextUnit() : nullptr) {
213  bool replace_when_old = false;
214  EngineID new_engine = EngineReplacementForCompany(c, v->engine_type, v->group_id, &replace_when_old);
215 
216  /* Check engine availability */
217  if (new_engine == INVALID_ENGINE || !HasBit(Engine::Get(new_engine)->company_avail, v->owner)) continue;
218  /* Is the vehicle old if we are not always replacing? */
219  if (replace_when_old && !v->NeedsAutorenewing(c, false)) continue;
220 
221  /* Check refittability */
222  CargoTypes available_cargo_types, union_mask;
223  GetArticulatedRefitMasks(new_engine, true, &union_mask, &available_cargo_types);
224  /* Is there anything to refit? */
225  if (union_mask != 0) {
227  /* We cannot refit to mixed cargoes in an automated way */
229 
230  /* Did the old vehicle carry anything? */
231  if (cargo_type != CT_INVALID) {
232  /* We can't refit the vehicle to carry the cargo we want */
233  if (!HasBit(available_cargo_types, cargo_type)) continue;
234  }
235  }
236 
237  /* Check money.
238  * We want 2*(the price of the new vehicle) without looking at the value of the vehicle we are going to sell. */
239  pending_replace = true;
240  needed_money += 2 * Engine::Get(new_engine)->GetCost();
241  if (needed_money > c->money) return false;
242  }
243 
244  return pending_replace;
245 }
246 
253 {
254  if (this->HasDepotOrder()) return false;
255  if (this->current_order.IsType(OT_LOADING)) return false;
256  if (this->current_order.IsType(OT_GOTO_DEPOT) && this->current_order.GetDepotOrderType() != ODTFB_SERVICE) return false;
257  return NeedsServicing();
258 }
259 
260 uint Vehicle::Crash(bool flooded)
261 {
262  assert((this->vehstatus & VS_CRASHED) == 0);
263  assert(this->Previous() == nullptr); // IsPrimaryVehicle fails for free-wagon-chains
264 
265  uint pass = 0;
266  /* Stop the vehicle. */
267  if (this->IsPrimaryVehicle()) this->vehstatus |= VS_STOPPED;
268  /* crash all wagons, and count passengers */
269  for (Vehicle *v = this; v != nullptr; v = v->Next()) {
270  /* We do not transfer reserver cargo back, so TotalCount() instead of StoredCount() */
271  if (IsCargoInClass(v->cargo_type, CC_PASSENGERS)) pass += v->cargo.TotalCount();
272  v->vehstatus |= VS_CRASHED;
273  v->MarkAllViewportsDirty();
274  }
275 
276  /* Dirty some windows */
281 
282  delete this->cargo_payment;
283  assert(this->cargo_payment == nullptr); // cleared by ~CargoPayment
284 
285  return RandomRange(pass + 1); // Randomise deceased passengers.
286 }
287 
288 
297 void ShowNewGrfVehicleError(EngineID engine, StringID part1, StringID part2, GRFBugs bug_type, bool critical)
298 {
299  const Engine *e = Engine::Get(engine);
300  GRFConfig *grfconfig = GetGRFConfig(e->GetGRFID());
301 
302  /* Missing GRF. Nothing useful can be done in this situation. */
303  if (grfconfig == nullptr) return;
304 
305  if (!HasBit(grfconfig->grf_bugs, bug_type)) {
306  SetBit(grfconfig->grf_bugs, bug_type);
307  SetDParamStr(0, grfconfig->GetName());
308  SetDParam(1, engine);
309  ShowErrorMessage(part1, part2, WL_CRITICAL);
311  }
312 
313  /* debug output */
314  char buffer[512];
315 
316  SetDParamStr(0, grfconfig->GetName());
317  GetString(buffer, part1, lastof(buffer));
318  Debug(grf, 0, "{}", buffer + 3);
319 
320  SetDParam(1, engine);
321  GetString(buffer, part2, lastof(buffer));
322  Debug(grf, 0, "{}", buffer + 3);
323 }
324 
331 {
332  /* show a warning once for each engine in whole game and once for each GRF after each game load */
333  const Engine *engine = u->GetEngine();
334  uint32 grfid = engine->grf_prop.grffile->grfid;
335  GRFConfig *grfconfig = GetGRFConfig(grfid);
336  if (GamelogGRFBugReverse(grfid, engine->grf_prop.local_id) || !HasBit(grfconfig->grf_bugs, GBUG_VEH_LENGTH)) {
337  ShowNewGrfVehicleError(u->engine_type, STR_NEWGRF_BROKEN, STR_NEWGRF_BROKEN_VEHICLE_LENGTH, GBUG_VEH_LENGTH, true);
338  }
339 }
340 
346 {
347  this->type = type;
348  this->coord.left = INVALID_COORD;
349  this->sprite_cache.old_coord.left = INVALID_COORD;
350  this->group_id = DEFAULT_GROUP;
351  this->fill_percent_te_id = INVALID_TE_ID;
352  this->first = this;
353  this->colourmap = PAL_NONE;
354  this->cargo_age_counter = 1;
355  this->last_station_visited = INVALID_STATION;
356  this->last_loading_station = INVALID_STATION;
357 }
358 
364 {
365  return GB(Random(), 0, 8);
366 }
367 
368 /* Size of the hash, 6 = 64 x 64, 7 = 128 x 128. Larger sizes will (in theory) reduce hash
369  * lookup times at the expense of memory usage. */
370 const int HASH_BITS = 7;
371 const int HASH_SIZE = 1 << HASH_BITS;
372 const int HASH_MASK = HASH_SIZE - 1;
373 const int TOTAL_HASH_SIZE = 1 << (HASH_BITS * 2);
374 const int TOTAL_HASH_MASK = TOTAL_HASH_SIZE - 1;
375 
376 /* Resolution of the hash, 0 = 1*1 tile, 1 = 2*2 tiles, 2 = 4*4 tiles, etc.
377  * Profiling results show that 0 is fastest. */
378 const int HASH_RES = 0;
379 
380 static Vehicle *_vehicle_tile_hash[TOTAL_HASH_SIZE];
381 
382 static Vehicle *VehicleFromTileHash(int xl, int yl, int xu, int yu, void *data, VehicleFromPosProc *proc, bool find_first)
383 {
384  for (int y = yl; ; y = (y + (1 << HASH_BITS)) & (HASH_MASK << HASH_BITS)) {
385  for (int x = xl; ; x = (x + 1) & HASH_MASK) {
386  Vehicle *v = _vehicle_tile_hash[(x + y) & TOTAL_HASH_MASK];
387  for (; v != nullptr; v = v->hash_tile_next) {
388  Vehicle *a = proc(v, data);
389  if (find_first && a != nullptr) return a;
390  }
391  if (x == xu) break;
392  }
393  if (y == yu) break;
394  }
395 
396  return nullptr;
397 }
398 
399 
411 static Vehicle *VehicleFromPosXY(int x, int y, void *data, VehicleFromPosProc *proc, bool find_first)
412 {
413  const int COLL_DIST = 6;
414 
415  /* Hash area to scan is from xl,yl to xu,yu */
416  int xl = GB((x - COLL_DIST) / TILE_SIZE, HASH_RES, HASH_BITS);
417  int xu = GB((x + COLL_DIST) / TILE_SIZE, HASH_RES, HASH_BITS);
418  int yl = GB((y - COLL_DIST) / TILE_SIZE, HASH_RES, HASH_BITS) << HASH_BITS;
419  int yu = GB((y + COLL_DIST) / TILE_SIZE, HASH_RES, HASH_BITS) << HASH_BITS;
420 
421  return VehicleFromTileHash(xl, yl, xu, yu, data, proc, find_first);
422 }
423 
438 void FindVehicleOnPosXY(int x, int y, void *data, VehicleFromPosProc *proc)
439 {
440  VehicleFromPosXY(x, y, data, proc, false);
441 }
442 
454 bool HasVehicleOnPosXY(int x, int y, void *data, VehicleFromPosProc *proc)
455 {
456  return VehicleFromPosXY(x, y, data, proc, true) != nullptr;
457 }
458 
469 static Vehicle *VehicleFromPos(TileIndex tile, void *data, VehicleFromPosProc *proc, bool find_first)
470 {
471  int x = GB(TileX(tile), HASH_RES, HASH_BITS);
472  int y = GB(TileY(tile), HASH_RES, HASH_BITS) << HASH_BITS;
473 
474  Vehicle *v = _vehicle_tile_hash[(x + y) & TOTAL_HASH_MASK];
475  for (; v != nullptr; v = v->hash_tile_next) {
476  if (v->tile != tile) continue;
477 
478  Vehicle *a = proc(v, data);
479  if (find_first && a != nullptr) return a;
480  }
481 
482  return nullptr;
483 }
484 
498 void FindVehicleOnPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
499 {
500  VehicleFromPos(tile, data, proc, false);
501 }
502 
513 bool HasVehicleOnPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
514 {
515  return VehicleFromPos(tile, data, proc, true) != nullptr;
516 }
517 
524 static Vehicle *EnsureNoVehicleProcZ(Vehicle *v, void *data)
525 {
526  int z = *(int*)data;
527 
528  if (v->type == VEH_DISASTER || (v->type == VEH_AIRCRAFT && v->subtype == AIR_SHADOW)) return nullptr;
529  if (v->z_pos > z) return nullptr;
530 
531  return v;
532 }
533 
540 {
541  int z = GetTileMaxPixelZ(tile);
542 
543  /* Value v is not safe in MP games, however, it is used to generate a local
544  * error message only (which may be different for different machines).
545  * Such a message does not affect MP synchronisation.
546  */
547  Vehicle *v = VehicleFromPos(tile, &z, &EnsureNoVehicleProcZ, true);
548  if (v != nullptr) return_cmd_error(STR_ERROR_TRAIN_IN_THE_WAY + v->type);
549  return CommandCost();
550 }
551 
554 {
555  if (v->type != VEH_TRAIN && v->type != VEH_ROAD && v->type != VEH_SHIP) return nullptr;
556  if (v == (const Vehicle *)data) return nullptr;
557 
558  return v;
559 }
560 
569 {
570  /* Value v is not safe in MP games, however, it is used to generate a local
571  * error message only (which may be different for different machines).
572  * Such a message does not affect MP synchronisation.
573  */
574  Vehicle *v = VehicleFromPos(tile, const_cast<Vehicle *>(ignore), &GetVehicleTunnelBridgeProc, true);
575  if (v == nullptr) v = VehicleFromPos(endtile, const_cast<Vehicle *>(ignore), &GetVehicleTunnelBridgeProc, true);
576 
577  if (v != nullptr) return_cmd_error(STR_ERROR_TRAIN_IN_THE_WAY + v->type);
578  return CommandCost();
579 }
580 
581 static Vehicle *EnsureNoTrainOnTrackProc(Vehicle *v, void *data)
582 {
583  TrackBits rail_bits = *(TrackBits *)data;
584 
585  if (v->type != VEH_TRAIN) return nullptr;
586 
587  Train *t = Train::From(v);
588  if ((t->track != rail_bits) && !TracksOverlap(t->track | rail_bits)) return nullptr;
589 
590  return v;
591 }
592 
602 {
603  /* Value v is not safe in MP games, however, it is used to generate a local
604  * error message only (which may be different for different machines).
605  * Such a message does not affect MP synchronisation.
606  */
607  Vehicle *v = VehicleFromPos(tile, &track_bits, &EnsureNoTrainOnTrackProc, true);
608  if (v != nullptr) return_cmd_error(STR_ERROR_TRAIN_IN_THE_WAY + v->type);
609  return CommandCost();
610 }
611 
612 static void UpdateVehicleTileHash(Vehicle *v, bool remove)
613 {
614  Vehicle **old_hash = v->hash_tile_current;
615  Vehicle **new_hash;
616 
617  if (remove) {
618  new_hash = nullptr;
619  } else {
620  int x = GB(TileX(v->tile), HASH_RES, HASH_BITS);
621  int y = GB(TileY(v->tile), HASH_RES, HASH_BITS) << HASH_BITS;
622  new_hash = &_vehicle_tile_hash[(x + y) & TOTAL_HASH_MASK];
623  }
624 
625  if (old_hash == new_hash) return;
626 
627  /* Remove from the old position in the hash table */
628  if (old_hash != nullptr) {
629  if (v->hash_tile_next != nullptr) v->hash_tile_next->hash_tile_prev = v->hash_tile_prev;
631  }
632 
633  /* Insert vehicle at beginning of the new position in the hash table */
634  if (new_hash != nullptr) {
635  v->hash_tile_next = *new_hash;
636  if (v->hash_tile_next != nullptr) v->hash_tile_next->hash_tile_prev = &v->hash_tile_next;
637  v->hash_tile_prev = new_hash;
638  *new_hash = v;
639  }
640 
641  /* Remember current hash position */
642  v->hash_tile_current = new_hash;
643 }
644 
645 static Vehicle *_vehicle_viewport_hash[1 << (GEN_HASHX_BITS + GEN_HASHY_BITS)];
646 
647 static void UpdateVehicleViewportHash(Vehicle *v, int x, int y, int old_x, int old_y)
648 {
649  Vehicle **old_hash, **new_hash;
650 
651  new_hash = (x == INVALID_COORD) ? nullptr : &_vehicle_viewport_hash[GEN_HASH(x, y)];
652  old_hash = (old_x == INVALID_COORD) ? nullptr : &_vehicle_viewport_hash[GEN_HASH(old_x, old_y)];
653 
654  if (old_hash == new_hash) return;
655 
656  /* remove from hash table? */
657  if (old_hash != nullptr) {
660  }
661 
662  /* insert into hash table? */
663  if (new_hash != nullptr) {
664  v->hash_viewport_next = *new_hash;
666  v->hash_viewport_prev = new_hash;
667  *new_hash = v;
668  }
669 }
670 
671 void ResetVehicleHash()
672 {
673  for (Vehicle *v : Vehicle::Iterate()) { v->hash_tile_current = nullptr; }
674  memset(_vehicle_viewport_hash, 0, sizeof(_vehicle_viewport_hash));
675  memset(_vehicle_tile_hash, 0, sizeof(_vehicle_tile_hash));
676 }
677 
678 void ResetVehicleColourMap()
679 {
680  for (Vehicle *v : Vehicle::Iterate()) { v->colourmap = PAL_NONE; }
681 }
682 
688 static AutoreplaceMap _vehicles_to_autoreplace;
689 
690 void InitializeVehicles()
691 {
692  _vehicles_to_autoreplace.clear();
693  _vehicles_to_autoreplace.shrink_to_fit();
694  ResetVehicleHash();
695 }
696 
697 uint CountVehiclesInChain(const Vehicle *v)
698 {
699  uint count = 0;
700  do count++; while ((v = v->Next()) != nullptr);
701  return count;
702 }
703 
709 {
710  switch (this->type) {
711  case VEH_AIRCRAFT: return Aircraft::From(this)->IsNormalAircraft(); // don't count plane shadows and helicopter rotors
712  case VEH_TRAIN:
713  return !this->IsArticulatedPart() && // tenders and other articulated parts
714  !Train::From(this)->IsRearDualheaded(); // rear parts of multiheaded engines
715  case VEH_ROAD: return RoadVehicle::From(this)->IsFrontEngine();
716  case VEH_SHIP: return true;
717  default: return false; // Only count company buildable vehicles
718  }
719 }
720 
726 {
727  switch (this->type) {
728  case VEH_AIRCRAFT: return Aircraft::From(this)->IsNormalAircraft();
729  case VEH_TRAIN:
730  case VEH_ROAD:
731  case VEH_SHIP: return true;
732  default: return false;
733  }
734 }
735 
742 {
743  return Engine::Get(this->engine_type);
744 }
745 
751 const GRFFile *Vehicle::GetGRF() const
752 {
753  return this->GetEngine()->GetGRF();
754 }
755 
761 uint32 Vehicle::GetGRFID() const
762 {
763  return this->GetEngine()->GetGRFID();
764 }
765 
773 void Vehicle::HandlePathfindingResult(bool path_found)
774 {
775  if (path_found) {
776  /* Route found, is the vehicle marked with "lost" flag? */
777  if (!HasBit(this->vehicle_flags, VF_PATHFINDER_LOST)) return;
778 
779  /* Clear the flag as the PF's problem was solved. */
781  /* Delete the news item. */
782  DeleteVehicleNews(this->index, STR_NEWS_VEHICLE_IS_LOST);
783  return;
784  }
785 
786  /* Were we already lost? */
787  if (HasBit(this->vehicle_flags, VF_PATHFINDER_LOST)) return;
788 
789  /* It is first time the problem occurred, set the "lost" flag. */
791  /* Notify user about the event. */
792  AI::NewEvent(this->owner, new ScriptEventVehicleLost(this->index));
793  if (_settings_client.gui.lost_vehicle_warn && this->owner == _local_company) {
794  SetDParam(0, this->index);
795  AddVehicleAdviceNewsItem(STR_NEWS_VEHICLE_IS_LOST, this->index);
796  }
797 }
798 
801 {
802  if (CleaningPool()) return;
803 
806  st->loading_vehicles.remove(this);
807 
809  this->CancelReservation(INVALID_STATION, st);
810  delete this->cargo_payment;
811  assert(this->cargo_payment == nullptr); // cleared by ~CargoPayment
812  }
813 
814  if (this->IsEngineCountable()) {
816  if (this->IsPrimaryVehicle()) GroupStatistics::CountVehicle(this, -1);
818 
821  }
822 
823  if (this->type == VEH_AIRCRAFT && this->IsPrimaryVehicle()) {
824  Aircraft *a = Aircraft::From(this);
826  if (st != nullptr) {
827  const AirportFTA *layout = st->airport.GetFTA()->layout;
828  CLRBITS(st->airport.flags, layout[a->previous_pos].block | layout[a->pos].block);
829  }
830  }
831 
832 
833  if (this->type == VEH_ROAD && this->IsPrimaryVehicle()) {
834  RoadVehicle *v = RoadVehicle::From(this);
835  if (!(v->vehstatus & VS_CRASHED) && IsInsideMM(v->state, RVSB_IN_DT_ROAD_STOP, RVSB_IN_DT_ROAD_STOP_END)) {
836  /* Leave the drive through roadstop, when you have not already left it. */
838  }
839  }
840 
841  if (this->Previous() == nullptr) {
843  }
844 
845  if (this->IsPrimaryVehicle()) {
853  }
855 
856  this->cargo.Truncate();
857  DeleteVehicleOrders(this);
859 
860  extern void StopGlobalFollowVehicle(const Vehicle *v);
861  StopGlobalFollowVehicle(this);
862 
864 }
865 
867 {
868  if (CleaningPool()) {
869  this->cargo.OnCleanPool();
870  return;
871  }
872 
873  /* sometimes, eg. for disaster vehicles, when company bankrupts, when removing crashed/flooded vehicles,
874  * it may happen that vehicle chain is deleted when visible */
875  if (!(this->vehstatus & VS_HIDDEN)) this->MarkAllViewportsDirty();
876 
877  Vehicle *v = this->Next();
878  this->SetNext(nullptr);
879 
880  delete v;
881 
882  UpdateVehicleTileHash(this, true);
883  UpdateVehicleViewportHash(this, INVALID_COORD, 0, this->sprite_cache.old_coord.left, this->sprite_cache.old_coord.top);
886 }
887 
893 {
894  /* Vehicle should stop in the depot if it was in 'stopping' state */
895  _vehicles_to_autoreplace[v] = !(v->vehstatus & VS_STOPPED);
896 
897  /* We ALWAYS set the stopped state. Even when the vehicle does not plan on
898  * stopping in the depot, so we stop it to ensure that it will not reserve
899  * the path out of the depot before we might autoreplace it to a different
900  * engine. The new engine would not own the reserved path we store that we
901  * stopped the vehicle, so autoreplace can start it again */
902  v->vehstatus |= VS_STOPPED;
903 }
904 
910 static void RunVehicleDayProc()
911 {
912  if (_game_mode != GM_NORMAL) return;
913 
914  /* Run the day_proc for every DAY_TICKS vehicle starting at _date_fract. */
915  for (size_t i = _date_fract; i < Vehicle::GetPoolSize(); i += DAY_TICKS) {
916  Vehicle *v = Vehicle::Get(i);
917  if (v == nullptr) continue;
918 
919  /* Call the 32-day callback if needed */
920  if ((v->day_counter & 0x1F) == 0 && v->HasEngineType()) {
921  uint16 callback = GetVehicleCallback(CBID_VEHICLE_32DAY_CALLBACK, 0, 0, v->engine_type, v);
922  if (callback != CALLBACK_FAILED) {
923  if (HasBit(callback, 0)) {
924  TriggerVehicle(v, VEHICLE_TRIGGER_CALLBACK_32); // Trigger vehicle trigger 10
925  }
926 
927  /* After a vehicle trigger, the graphics and properties of the vehicle could change.
928  * Note: MarkDirty also invalidates the palette, which is the meaning of bit 1. So, nothing special there. */
929  if (callback != 0) v->First()->MarkDirty();
930 
931  if (callback & ~3) ErrorUnknownCallbackResult(v->GetGRFID(), CBID_VEHICLE_32DAY_CALLBACK, callback);
932  }
933  }
934 
935  /* This is called once per day for each vehicle, but not in the first tick of the day */
936  v->OnNewDay();
937  }
938 }
939 
940 void CallVehicleTicks()
941 {
942  _vehicles_to_autoreplace.clear();
943 
945 
946  {
948  for (Station *st : Station::Iterate()) LoadUnloadStation(st);
949  }
954 
955  for (Vehicle *v : Vehicle::Iterate()) {
956  [[maybe_unused]] size_t vehicle_index = v->index;
957 
958  /* Vehicle could be deleted in this tick */
959  if (!v->Tick()) {
960  assert(Vehicle::Get(vehicle_index) == nullptr);
961  continue;
962  }
963 
964  assert(Vehicle::Get(vehicle_index) == v);
965 
966  switch (v->type) {
967  default: break;
968 
969  case VEH_TRAIN:
970  case VEH_ROAD:
971  case VEH_AIRCRAFT:
972  case VEH_SHIP: {
973  Vehicle *front = v->First();
974 
975  if (v->vcache.cached_cargo_age_period != 0) {
977  if (--v->cargo_age_counter == 0) {
978  v->cargo.AgeCargo();
980  }
981  }
982 
983  /* Do not play any sound when crashed */
984  if (front->vehstatus & VS_CRASHED) continue;
985 
986  /* Do not play any sound when in depot or tunnel */
987  if (v->vehstatus & VS_HIDDEN) continue;
988 
989  /* Do not play any sound when stopped */
990  if ((front->vehstatus & VS_STOPPED) && (front->type != VEH_TRAIN || front->cur_speed == 0)) continue;
991 
992  /* Check vehicle type specifics */
993  switch (v->type) {
994  case VEH_TRAIN:
995  if (Train::From(v)->IsWagon()) continue;
996  break;
997 
998  case VEH_ROAD:
999  if (!RoadVehicle::From(v)->IsFrontEngine()) continue;
1000  break;
1001 
1002  case VEH_AIRCRAFT:
1003  if (!Aircraft::From(v)->IsNormalAircraft()) continue;
1004  break;
1005 
1006  default:
1007  break;
1008  }
1009 
1010  v->motion_counter += front->cur_speed;
1011  /* Play a running sound if the motion counter passes 256 (Do we not skip sounds?) */
1012  if (GB(v->motion_counter, 0, 8) < front->cur_speed) PlayVehicleSound(v, VSE_RUNNING);
1013 
1014  /* Play an alternating running sound every 16 ticks */
1015  if (GB(v->tick_counter, 0, 4) == 0) {
1016  /* Play running sound when speed > 0 and not braking */
1017  bool running = (front->cur_speed > 0) && !(front->vehstatus & (VS_STOPPED | VS_TRAIN_SLOWING));
1019  }
1020 
1021  break;
1022  }
1023  }
1024  }
1025 
1026  Backup<CompanyID> cur_company(_current_company, FILE_LINE);
1027  for (auto &it : _vehicles_to_autoreplace) {
1028  Vehicle *v = it.first;
1029  /* Autoreplace needs the current company set as the vehicle owner */
1030  cur_company.Change(v->owner);
1031 
1032  /* Start vehicle if we stopped them in VehicleEnteredDepotThisTick()
1033  * We need to stop them between VehicleEnteredDepotThisTick() and here or we risk that
1034  * they are already leaving the depot again before being replaced. */
1035  if (it.second) v->vehstatus &= ~VS_STOPPED;
1036 
1037  /* Store the position of the effect as the vehicle pointer will become invalid later */
1038  int x = v->x_pos;
1039  int y = v->y_pos;
1040  int z = v->z_pos;
1041 
1046 
1047  if (!IsLocalCompany()) continue;
1048 
1049  if (res.Succeeded() && res.GetCost() != 0) {
1050  ShowCostOrIncomeAnimation(x, y, z, res.GetCost());
1051  continue;
1052  }
1053 
1054  StringID error_message = res.GetErrorMessage();
1055  if (error_message == STR_ERROR_AUTOREPLACE_NOTHING_TO_DO || error_message == INVALID_STRING_ID) continue;
1056 
1057  if (error_message == STR_ERROR_NOT_ENOUGH_CASH_REQUIRES_CURRENCY) error_message = STR_ERROR_AUTOREPLACE_MONEY_LIMIT;
1058 
1059  StringID message;
1060  if (error_message == STR_ERROR_TRAIN_TOO_LONG_AFTER_REPLACEMENT) {
1061  message = error_message;
1062  } else {
1063  message = STR_NEWS_VEHICLE_AUTORENEW_FAILED;
1064  }
1065 
1066  SetDParam(0, v->index);
1067  SetDParam(1, error_message);
1068  AddVehicleAdviceNewsItem(message, v->index);
1069  }
1070 
1071  cur_company.Restore();
1072 }
1073 
1078 static void DoDrawVehicle(const Vehicle *v)
1079 {
1080  PaletteID pal = PAL_NONE;
1081 
1083 
1084  /* Check whether the vehicle shall be transparent due to the game state */
1085  bool shadowed = (v->vehstatus & VS_SHADOW) != 0;
1086 
1087  if (v->type == VEH_EFFECT) {
1088  /* Check whether the vehicle shall be transparent/invisible due to GUI settings.
1089  * However, transparent smoke and bubbles look weird, so always hide them. */
1091  if (to != TO_INVALID && (IsTransparencySet(to) || IsInvisibilitySet(to))) return;
1092  }
1093 
1095  for (uint i = 0; i < v->sprite_cache.sprite_seq.count; ++i) {
1096  PaletteID pal2 = v->sprite_cache.sprite_seq.seq[i].pal;
1097  if (!pal2 || (v->vehstatus & VS_CRASHED)) pal2 = pal;
1098  AddSortableSpriteToDraw(v->sprite_cache.sprite_seq.seq[i].sprite, pal2, v->x_pos + v->x_offs, v->y_pos + v->y_offs,
1099  v->x_extent, v->y_extent, v->z_extent, v->z_pos, shadowed, v->x_bb_offs, v->y_bb_offs);
1100  }
1101  EndSpriteCombine();
1102 }
1103 
1109 {
1110  /* The bounding rectangle */
1111  const int l = dpi->left;
1112  const int r = dpi->left + dpi->width;
1113  const int t = dpi->top;
1114  const int b = dpi->top + dpi->height;
1115 
1116  /* Border size of MAX_VEHICLE_PIXEL_xy */
1117  const int xb = MAX_VEHICLE_PIXEL_X * ZOOM_LVL_BASE;
1118  const int yb = MAX_VEHICLE_PIXEL_Y * ZOOM_LVL_BASE;
1119 
1120  /* The hash area to scan */
1121  int xl, xu, yl, yu;
1122 
1123  if (dpi->width + xb < GEN_HASHX_SIZE) {
1124  xl = GEN_HASHX(l - xb);
1125  xu = GEN_HASHX(r);
1126  } else {
1127  /* scan whole hash row */
1128  xl = 0;
1129  xu = GEN_HASHX_MASK;
1130  }
1131 
1132  if (dpi->height + yb < GEN_HASHY_SIZE) {
1133  yl = GEN_HASHY(t - yb);
1134  yu = GEN_HASHY(b);
1135  } else {
1136  /* scan whole column */
1137  yl = 0;
1138  yu = GEN_HASHY_MASK;
1139  }
1140 
1141  for (int y = yl;; y = (y + GEN_HASHY_INC) & GEN_HASHY_MASK) {
1142  for (int x = xl;; x = (x + GEN_HASHX_INC) & GEN_HASHX_MASK) {
1143  const Vehicle *v = _vehicle_viewport_hash[x + y]; // already masked & 0xFFF
1144 
1145  while (v != nullptr) {
1146 
1147  if (!(v->vehstatus & VS_HIDDEN) &&
1148  l <= v->coord.right + xb &&
1149  t <= v->coord.bottom + yb &&
1150  r >= v->coord.left - xb &&
1151  b >= v->coord.top - yb)
1152  {
1153  /*
1154  * This vehicle can potentially be drawn as part of this viewport and
1155  * needs to be revalidated, as the sprite may not be correct.
1156  */
1158  VehicleSpriteSeq seq;
1159  v->GetImage(v->direction, EIT_ON_MAP, &seq);
1160 
1161  if (seq.IsValid() && v->sprite_cache.sprite_seq != seq) {
1162  v->sprite_cache.sprite_seq = seq;
1163  /*
1164  * A sprite change may also result in a bounding box change,
1165  * so we need to update the bounding box again before we
1166  * check to see if the vehicle should be drawn. Note that
1167  * we can't interfere with the viewport hash at this point,
1168  * so we keep the original hash on the assumption there will
1169  * not be a significant change in the top and left coordinates
1170  * of the vehicle.
1171  */
1172  v->UpdateBoundingBoxCoordinates(false);
1173 
1174  }
1175 
1177  }
1178 
1179  if (l <= v->coord.right &&
1180  t <= v->coord.bottom &&
1181  r >= v->coord.left &&
1182  b >= v->coord.top) DoDrawVehicle(v);
1183  }
1184 
1185  v = v->hash_viewport_next;
1186  }
1187 
1188  if (x == xu) break;
1189  }
1190 
1191  if (y == yu) break;
1192  }
1193 }
1194 
1202 Vehicle *CheckClickOnVehicle(const Viewport *vp, int x, int y)
1203 {
1204  Vehicle *found = nullptr;
1205  uint dist, best_dist = UINT_MAX;
1206 
1207  if ((uint)(x -= vp->left) >= (uint)vp->width || (uint)(y -= vp->top) >= (uint)vp->height) return nullptr;
1208 
1209  x = ScaleByZoom(x, vp->zoom) + vp->virtual_left;
1210  y = ScaleByZoom(y, vp->zoom) + vp->virtual_top;
1211 
1212  for (Vehicle *v : Vehicle::Iterate()) {
1213  if ((v->vehstatus & (VS_HIDDEN | VS_UNCLICKABLE)) == 0 &&
1214  x >= v->coord.left && x <= v->coord.right &&
1215  y >= v->coord.top && y <= v->coord.bottom) {
1216 
1217  dist = std::max(
1218  abs(((v->coord.left + v->coord.right) >> 1) - x),
1219  abs(((v->coord.top + v->coord.bottom) >> 1) - y)
1220  );
1221 
1222  if (dist < best_dist) {
1223  found = v;
1224  best_dist = dist;
1225  }
1226  }
1227  }
1228 
1229  return found;
1230 }
1231 
1237 {
1238  v->value -= v->value >> 8;
1240 }
1241 
1242 static const byte _breakdown_chance[64] = {
1243  3, 3, 3, 3, 3, 3, 3, 3,
1244  4, 4, 5, 5, 6, 6, 7, 7,
1245  8, 8, 9, 9, 10, 10, 11, 11,
1246  12, 13, 13, 13, 13, 14, 15, 16,
1247  17, 19, 21, 25, 28, 31, 34, 37,
1248  40, 44, 48, 52, 56, 60, 64, 68,
1249  72, 80, 90, 100, 110, 120, 130, 140,
1250  150, 170, 190, 210, 230, 250, 250, 250,
1251 };
1252 
1253 void CheckVehicleBreakdown(Vehicle *v)
1254 {
1255  int rel, rel_old;
1256 
1257  /* decrease reliability */
1260  v->reliability = rel = std::max((rel_old = v->reliability) - v->reliability_spd_dec, 0);
1261  if ((rel_old >> 8) != (rel >> 8)) SetWindowDirty(WC_VEHICLE_DETAILS, v->index);
1262  }
1263 
1264  if (v->breakdown_ctr != 0 || (v->vehstatus & VS_STOPPED) ||
1266  v->cur_speed < 5 || _game_mode == GM_MENU) {
1267  return;
1268  }
1269 
1270  uint32 r = Random();
1271 
1272  /* increase chance of failure */
1273  int chance = v->breakdown_chance + 1;
1274  if (Chance16I(1, 25, r)) chance += 25;
1275  v->breakdown_chance = std::min(255, chance);
1276 
1277  /* calculate reliability value to use in comparison */
1278  rel = v->reliability;
1279  if (v->type == VEH_SHIP) rel += 0x6666;
1280 
1281  /* reduced breakdowns? */
1282  if (_settings_game.difficulty.vehicle_breakdowns == 1) rel += 0x6666;
1283 
1284  /* check if to break down */
1285  if (_breakdown_chance[(uint)std::min(rel, 0xffff) >> 10] <= v->breakdown_chance) {
1286  v->breakdown_ctr = GB(r, 16, 6) + 0x3F;
1287  v->breakdown_delay = GB(r, 24, 7) + 0x80;
1288  v->breakdown_chance = 0;
1289  }
1290 }
1291 
1299 {
1300  /* Possible states for Vehicle::breakdown_ctr
1301  * 0 - vehicle is running normally
1302  * 1 - vehicle is currently broken down
1303  * 2 - vehicle is going to break down now
1304  * >2 - vehicle is counting down to the actual breakdown event */
1305  switch (this->breakdown_ctr) {
1306  case 0:
1307  return false;
1308 
1309  case 2:
1310  this->breakdown_ctr = 1;
1311 
1312  if (this->breakdowns_since_last_service != 255) {
1314  }
1315 
1316  if (this->type == VEH_AIRCRAFT) {
1317  /* Aircraft just need this flag, the rest is handled elsewhere */
1318  this->vehstatus |= VS_AIRCRAFT_BROKEN;
1319  } else {
1320  this->cur_speed = 0;
1321 
1322  if (!PlayVehicleSound(this, VSE_BREAKDOWN)) {
1323  bool train_or_ship = this->type == VEH_TRAIN || this->type == VEH_SHIP;
1324  SndPlayVehicleFx((_settings_game.game_creation.landscape != LT_TOYLAND) ?
1327  }
1328 
1329  if (!(this->vehstatus & VS_HIDDEN) && !HasBit(EngInfo(this->engine_type)->misc_flags, EF_NO_BREAKDOWN_SMOKE)) {
1331  if (u != nullptr) u->animation_state = this->breakdown_delay * 2;
1332  }
1333  }
1334 
1335  this->MarkDirty(); // Update graphics after speed is zeroed
1338 
1339  FALLTHROUGH;
1340  case 1:
1341  /* Aircraft breakdowns end only when arriving at the airport */
1342  if (this->type == VEH_AIRCRAFT) return false;
1343 
1344  /* For trains this function is called twice per tick, so decrease v->breakdown_delay at half the rate */
1345  if ((this->tick_counter & (this->type == VEH_TRAIN ? 3 : 1)) == 0) {
1346  if (--this->breakdown_delay == 0) {
1347  this->breakdown_ctr = 0;
1348  this->MarkDirty();
1350  }
1351  }
1352  return true;
1353 
1354  default:
1355  if (!this->current_order.IsType(OT_LOADING)) this->breakdown_ctr--;
1356  return false;
1357  }
1358 }
1359 
1365 {
1366  if (v->age < MAX_DAY) {
1367  v->age++;
1369  }
1370 
1371  if (!v->IsPrimaryVehicle() && (v->type != VEH_TRAIN || !Train::From(v)->IsEngine())) return;
1372 
1373  int age = v->age - v->max_age;
1374  if (age == DAYS_IN_LEAP_YEAR * 0 || age == DAYS_IN_LEAP_YEAR * 1 ||
1375  age == DAYS_IN_LEAP_YEAR * 2 || age == DAYS_IN_LEAP_YEAR * 3 || age == DAYS_IN_LEAP_YEAR * 4) {
1376  v->reliability_spd_dec <<= 1;
1377  }
1378 
1380 
1381  /* Don't warn about non-primary or not ours vehicles or vehicles that are crashed */
1382  if (v->Previous() != nullptr || v->owner != _local_company || (v->vehstatus & VS_CRASHED) != 0) return;
1383 
1384  const Company *c = Company::Get(v->owner);
1385  /* Don't warn if a renew is active */
1386  if (c->settings.engine_renew && v->GetEngine()->company_avail != 0) return;
1387  /* Don't warn if a replacement is active */
1388  if (EngineHasReplacementForCompany(c, v->engine_type, v->group_id)) return;
1389 
1390  StringID str;
1391  if (age == -DAYS_IN_LEAP_YEAR) {
1392  str = STR_NEWS_VEHICLE_IS_GETTING_OLD;
1393  } else if (age == 0) {
1394  str = STR_NEWS_VEHICLE_IS_GETTING_VERY_OLD;
1395  } else if (age > 0 && (age % DAYS_IN_LEAP_YEAR) == 0) {
1396  str = STR_NEWS_VEHICLE_IS_GETTING_VERY_OLD_AND;
1397  } else {
1398  return;
1399  }
1400 
1401  SetDParam(0, v->index);
1403 }
1404 
1414 uint8 CalcPercentVehicleFilled(const Vehicle *front, StringID *colour)
1415 {
1416  int count = 0;
1417  int max = 0;
1418  int cars = 0;
1419  int unloading = 0;
1420  bool loading = false;
1421 
1422  bool is_loading = front->current_order.IsType(OT_LOADING);
1423 
1424  /* The station may be nullptr when the (colour) string does not need to be set. */
1425  const Station *st = Station::GetIfValid(front->last_station_visited);
1426  assert(colour == nullptr || (st != nullptr && is_loading));
1427 
1428  bool order_no_load = is_loading && (front->current_order.GetLoadType() & OLFB_NO_LOAD);
1429  bool order_full_load = is_loading && (front->current_order.GetLoadType() & OLFB_FULL_LOAD);
1430 
1431  /* Count up max and used */
1432  for (const Vehicle *v = front; v != nullptr; v = v->Next()) {
1433  count += v->cargo.StoredCount();
1434  max += v->cargo_cap;
1435  if (v->cargo_cap != 0 && colour != nullptr) {
1436  unloading += HasBit(v->vehicle_flags, VF_CARGO_UNLOADING) ? 1 : 0;
1437  loading |= !order_no_load &&
1438  (order_full_load || st->goods[v->cargo_type].HasRating()) &&
1440  cars++;
1441  }
1442  }
1443 
1444  if (colour != nullptr) {
1445  if (unloading == 0 && loading) {
1446  *colour = STR_PERCENT_UP;
1447  } else if (unloading == 0 && !loading) {
1448  *colour = STR_PERCENT_NONE;
1449  } else if (cars == unloading || !loading) {
1450  *colour = STR_PERCENT_DOWN;
1451  } else {
1452  *colour = STR_PERCENT_UP_DOWN;
1453  }
1454  }
1455 
1456  /* Train without capacity */
1457  if (max == 0) return 100;
1458 
1459  /* Return the percentage */
1460  if (count * 2 < max) {
1461  /* Less than 50%; round up, so that 0% means really empty. */
1462  return CeilDiv(count * 100, max);
1463  } else {
1464  /* More than 50%; round down, so that 100% means really full. */
1465  return (count * 100) / max;
1466  }
1467 }
1468 
1474 {
1475  /* Always work with the front of the vehicle */
1476  assert(v == v->First());
1477 
1478  switch (v->type) {
1479  case VEH_TRAIN: {
1480  Train *t = Train::From(v);
1482  /* Clear path reservation */
1483  SetDepotReservation(t->tile, false);
1485 
1487  t->wait_counter = 0;
1488  t->force_proceed = TFP_NONE;
1489  ClrBit(t->flags, VRF_TOGGLE_REVERSE);
1491  break;
1492  }
1493 
1494  case VEH_ROAD:
1496  break;
1497 
1498  case VEH_SHIP: {
1500  Ship *ship = Ship::From(v);
1501  ship->state = TRACK_BIT_DEPOT;
1502  ship->UpdateCache();
1503  ship->UpdateViewport(true, true);
1505  break;
1506  }
1507 
1508  case VEH_AIRCRAFT:
1511  break;
1512  default: NOT_REACHED();
1513  }
1515 
1516  if (v->type != VEH_TRAIN) {
1517  /* Trains update the vehicle list when the first unit enters the depot and calls VehicleEnterDepot() when the last unit enters.
1518  * We only increase the number of vehicles when the first one enters, so we will not need to search for more vehicles in the depot */
1520  }
1522 
1523  v->vehstatus |= VS_HIDDEN;
1524  v->cur_speed = 0;
1525 
1527 
1528  /* After a vehicle trigger, the graphics and properties of the vehicle could change. */
1529  TriggerVehicle(v, VEHICLE_TRIGGER_DEPOT);
1530  v->MarkDirty();
1531 
1533 
1534  if (v->current_order.IsType(OT_GOTO_DEPOT)) {
1536 
1537  const Order *real_order = v->GetOrder(v->cur_real_order_index);
1538 
1539  /* Test whether we are heading for this depot. If not, do nothing.
1540  * Note: The target depot for nearest-/manual-depot-orders is only updated on junctions, but we want to accept every depot. */
1542  real_order != nullptr && !(real_order->GetDepotActionType() & ODATFB_NEAREST_DEPOT) &&
1543  (v->type == VEH_AIRCRAFT ? v->current_order.GetDestination() != GetStationIndex(v->tile) : v->dest_tile != v->tile)) {
1544  /* We are heading for another depot, keep driving. */
1545  return;
1546  }
1547 
1548  if (v->current_order.IsRefit()) {
1549  Backup<CompanyID> cur_company(_current_company, v->owner, FILE_LINE);
1550  CommandCost cost = DoCommand(v->tile, v->index, v->current_order.GetRefitCargo() | 0xFF << 8, DC_EXEC, GetCmdRefitVeh(v));
1551  cur_company.Restore();
1552 
1553  if (cost.Failed()) {
1554  _vehicles_to_autoreplace[v] = false;
1555  if (v->owner == _local_company) {
1556  /* Notify the user that we stopped the vehicle */
1557  SetDParam(0, v->index);
1558  AddVehicleAdviceNewsItem(STR_NEWS_ORDER_REFIT_FAILED, v->index);
1559  }
1560  } else if (cost.GetCost() != 0) {
1561  v->profit_this_year -= cost.GetCost() << 8;
1562  if (v->owner == _local_company) {
1563  ShowCostOrIncomeAnimation(v->x_pos, v->y_pos, v->z_pos, cost.GetCost());
1564  }
1565  }
1566  }
1567 
1569  /* Part of orders */
1571  UpdateVehicleTimetable(v, true);
1573  }
1575  /* Vehicles are always stopped on entering depots. Do not restart this one. */
1576  _vehicles_to_autoreplace[v] = false;
1577  /* Invalidate last_loading_station. As the link from the station
1578  * before the stop to the station after the stop can't be predicted
1579  * we shouldn't construct it when the vehicle visits the next stop. */
1580  v->last_loading_station = INVALID_STATION;
1581  if (v->owner == _local_company) {
1582  SetDParam(0, v->index);
1583  AddVehicleAdviceNewsItem(STR_NEWS_TRAIN_IS_WAITING + v->type, v->index);
1584  }
1585  AI::NewEvent(v->owner, new ScriptEventVehicleWaitingInDepot(v->index));
1586  }
1587  v->current_order.MakeDummy();
1588  }
1589 }
1590 
1591 
1597 {
1598  UpdateVehicleTileHash(this, false);
1599 }
1600 
1605 void Vehicle::UpdateBoundingBoxCoordinates(bool update_cache) const
1606 {
1607  Rect new_coord;
1608  this->sprite_cache.sprite_seq.GetBounds(&new_coord);
1609 
1610  Point pt = RemapCoords(this->x_pos + this->x_offs, this->y_pos + this->y_offs, this->z_pos);
1611  new_coord.left += pt.x;
1612  new_coord.top += pt.y;
1613  new_coord.right += pt.x + 2 * ZOOM_LVL_BASE;
1614  new_coord.bottom += pt.y + 2 * ZOOM_LVL_BASE;
1615 
1616  if (update_cache) {
1617  /*
1618  * If the old coordinates are invalid, set the cache to the new coordinates for correct
1619  * behaviour the next time the coordinate cache is checked.
1620  */
1621  this->sprite_cache.old_coord = this->coord.left == INVALID_COORD ? new_coord : this->coord;
1622  }
1623  else {
1624  /* Extend the bounds of the existing cached bounding box so the next dirty window is correct */
1625  this->sprite_cache.old_coord.left = std::min(this->sprite_cache.old_coord.left, this->coord.left);
1626  this->sprite_cache.old_coord.top = std::min(this->sprite_cache.old_coord.top, this->coord.top);
1627  this->sprite_cache.old_coord.right = std::max(this->sprite_cache.old_coord.right, this->coord.right);
1628  this->sprite_cache.old_coord.bottom = std::max(this->sprite_cache.old_coord.bottom, this->coord.bottom);
1629  }
1630 
1631  this->coord = new_coord;
1632 }
1633 
1638 void Vehicle::UpdateViewport(bool dirty)
1639 {
1640  /* If the existing cache is invalid we should ignore it, as it will be set to the current coords by UpdateBoundingBoxCoordinates */
1641  bool ignore_cached_coords = this->sprite_cache.old_coord.left == INVALID_COORD;
1642 
1643  this->UpdateBoundingBoxCoordinates(true);
1644 
1645  if (ignore_cached_coords) {
1646  UpdateVehicleViewportHash(this, this->coord.left, this->coord.top, INVALID_COORD, INVALID_COORD);
1647  } else {
1648  UpdateVehicleViewportHash(this, this->coord.left, this->coord.top, this->sprite_cache.old_coord.left, this->sprite_cache.old_coord.top);
1649  }
1650 
1651  if (dirty) {
1652  if (ignore_cached_coords) {
1654  } else {
1656  std::min(this->sprite_cache.old_coord.left, this->coord.left),
1657  std::min(this->sprite_cache.old_coord.top, this->coord.top),
1658  std::max(this->sprite_cache.old_coord.right, this->coord.right),
1659  std::max(this->sprite_cache.old_coord.bottom, this->coord.bottom));
1660  }
1661  }
1662 }
1663 
1668 {
1669  this->UpdatePosition();
1670  this->UpdateViewport(true);
1671 }
1672 
1678 {
1679  return ::MarkAllViewportsDirty(this->coord.left, this->coord.top, this->coord.right, this->coord.bottom);
1680 }
1681 
1688 {
1689  static const int8 _delta_coord[16] = {
1690  -1,-1,-1, 0, 1, 1, 1, 0, /* x */
1691  -1, 0, 1, 1, 1, 0,-1,-1, /* y */
1692  };
1693 
1694  int x = v->x_pos + _delta_coord[v->direction];
1695  int y = v->y_pos + _delta_coord[v->direction + 8];
1696 
1698  gp.x = x;
1699  gp.y = y;
1700  gp.old_tile = v->tile;
1701  gp.new_tile = TileVirtXY(x, y);
1702  return gp;
1703 }
1704 
1705 static const Direction _new_direction_table[] = {
1706  DIR_N, DIR_NW, DIR_W,
1707  DIR_NE, DIR_SE, DIR_SW,
1708  DIR_E, DIR_SE, DIR_S
1709 };
1710 
1711 Direction GetDirectionTowards(const Vehicle *v, int x, int y)
1712 {
1713  int i = 0;
1714 
1715  if (y >= v->y_pos) {
1716  if (y != v->y_pos) i += 3;
1717  i += 3;
1718  }
1719 
1720  if (x >= v->x_pos) {
1721  if (x != v->x_pos) i++;
1722  i++;
1723  }
1724 
1725  Direction dir = v->direction;
1726 
1727  DirDiff dirdiff = DirDifference(_new_direction_table[i], dir);
1728  if (dirdiff == DIRDIFF_SAME) return dir;
1729  return ChangeDir(dir, dirdiff > DIRDIFF_REVERSE ? DIRDIFF_45LEFT : DIRDIFF_45RIGHT);
1730 }
1731 
1742 {
1743  return _tile_type_procs[GetTileType(tile)]->vehicle_enter_tile_proc(v, tile, x, y);
1744 }
1745 
1753 FreeUnitIDGenerator::FreeUnitIDGenerator(VehicleType type, CompanyID owner) : cache(nullptr), maxid(0), curid(0)
1754 {
1755  /* Find maximum */
1756  for (const Vehicle *v : Vehicle::Iterate()) {
1757  if (v->type == type && v->owner == owner) {
1758  this->maxid = std::max<UnitID>(this->maxid, v->unitnumber);
1759  }
1760  }
1761 
1762  if (this->maxid == 0) return;
1763 
1764  /* Reserving 'maxid + 2' because we need:
1765  * - space for the last item (with v->unitnumber == maxid)
1766  * - one free slot working as loop terminator in FreeUnitIDGenerator::NextID() */
1767  this->cache = CallocT<bool>(this->maxid + 2);
1768 
1769  /* Fill the cache */
1770  for (const Vehicle *v : Vehicle::Iterate()) {
1771  if (v->type == type && v->owner == owner) {
1772  this->cache[v->unitnumber] = true;
1773  }
1774  }
1775 }
1776 
1779 {
1780  if (this->maxid <= this->curid) return ++this->curid;
1781 
1782  while (this->cache[++this->curid]) { } // it will stop, we reserved more space than needed
1783 
1784  return this->curid;
1785 }
1786 
1793 {
1794  /* Check whether it is allowed to build another vehicle. */
1795  uint max_veh;
1796  switch (type) {
1797  case VEH_TRAIN: max_veh = _settings_game.vehicle.max_trains; break;
1798  case VEH_ROAD: max_veh = _settings_game.vehicle.max_roadveh; break;
1799  case VEH_SHIP: max_veh = _settings_game.vehicle.max_ships; break;
1800  case VEH_AIRCRAFT: max_veh = _settings_game.vehicle.max_aircraft; break;
1801  default: NOT_REACHED();
1802  }
1803 
1805  if (c->group_all[type].num_vehicle >= max_veh) return UINT16_MAX; // Currently already at the limit, no room to make a new one.
1806 
1808 
1809  return gen.NextID();
1810 }
1811 
1812 
1822 {
1823  assert(IsCompanyBuildableVehicleType(type));
1824 
1825  if (!Company::IsValidID(_local_company)) return false;
1826 
1827  UnitID max;
1828  switch (type) {
1829  case VEH_TRAIN:
1830  if (!HasAnyRailtypesAvail(_local_company)) return false;
1832  break;
1833  case VEH_ROAD:
1834  if (!HasAnyRoadTypesAvail(_local_company, (RoadTramType)subtype)) return false;
1836  break;
1837  case VEH_SHIP: max = _settings_game.vehicle.max_ships; break;
1838  case VEH_AIRCRAFT: max = _settings_game.vehicle.max_aircraft; break;
1839  default: NOT_REACHED();
1840  }
1841 
1842  /* We can build vehicle infrastructure when we may build the vehicle type */
1843  if (max > 0) {
1844  /* Can we actually build the vehicle type? */
1845  for (const Engine *e : Engine::IterateType(type)) {
1846  if (type == VEH_ROAD && GetRoadTramType(e->u.road.roadtype) != (RoadTramType)subtype) continue;
1847  if (HasBit(e->company_avail, _local_company)) return true;
1848  }
1849  return false;
1850  }
1851 
1852  /* We should be able to build infrastructure when we have the actual vehicle type */
1853  for (const Vehicle *v : Vehicle::Iterate()) {
1854  if (v->type == VEH_ROAD && GetRoadTramType(RoadVehicle::From(v)->roadtype) != (RoadTramType)subtype) continue;
1855  if (v->owner == _local_company && v->type == type) return true;
1856  }
1857 
1858  return false;
1859 }
1860 
1861 
1869 LiveryScheme GetEngineLiveryScheme(EngineID engine_type, EngineID parent_engine_type, const Vehicle *v)
1870 {
1871  CargoID cargo_type = v == nullptr ? (CargoID)CT_INVALID : v->cargo_type;
1872  const Engine *e = Engine::Get(engine_type);
1873  switch (e->type) {
1874  default: NOT_REACHED();
1875  case VEH_TRAIN:
1876  if (v != nullptr && parent_engine_type != INVALID_ENGINE && (UsesWagonOverride(v) || (v->IsArticulatedPart() && e->u.rail.railveh_type != RAILVEH_WAGON))) {
1877  /* Wagonoverrides use the colour scheme of the front engine.
1878  * Articulated parts use the colour scheme of the first part. (Not supported for articulated wagons) */
1879  engine_type = parent_engine_type;
1880  e = Engine::Get(engine_type);
1881  /* Note: Luckily cargo_type is not needed for engines */
1882  }
1883 
1884  if (cargo_type == CT_INVALID) cargo_type = e->GetDefaultCargoType();
1885  if (cargo_type == CT_INVALID) cargo_type = CT_GOODS; // The vehicle does not carry anything, let's pick some freight cargo
1886  if (e->u.rail.railveh_type == RAILVEH_WAGON) {
1887  if (!CargoSpec::Get(cargo_type)->is_freight) {
1888  if (parent_engine_type == INVALID_ENGINE) {
1889  return LS_PASSENGER_WAGON_STEAM;
1890  } else {
1891  bool is_mu = HasBit(EngInfo(parent_engine_type)->misc_flags, EF_RAIL_IS_MU);
1892  switch (RailVehInfo(parent_engine_type)->engclass) {
1893  default: NOT_REACHED();
1894  case EC_STEAM: return LS_PASSENGER_WAGON_STEAM;
1895  case EC_DIESEL: return is_mu ? LS_DMU : LS_PASSENGER_WAGON_DIESEL;
1896  case EC_ELECTRIC: return is_mu ? LS_EMU : LS_PASSENGER_WAGON_ELECTRIC;
1897  case EC_MONORAIL: return LS_PASSENGER_WAGON_MONORAIL;
1898  case EC_MAGLEV: return LS_PASSENGER_WAGON_MAGLEV;
1899  }
1900  }
1901  } else {
1902  return LS_FREIGHT_WAGON;
1903  }
1904  } else {
1905  bool is_mu = HasBit(e->info.misc_flags, EF_RAIL_IS_MU);
1906 
1907  switch (e->u.rail.engclass) {
1908  default: NOT_REACHED();
1909  case EC_STEAM: return LS_STEAM;
1910  case EC_DIESEL: return is_mu ? LS_DMU : LS_DIESEL;
1911  case EC_ELECTRIC: return is_mu ? LS_EMU : LS_ELECTRIC;
1912  case EC_MONORAIL: return LS_MONORAIL;
1913  case EC_MAGLEV: return LS_MAGLEV;
1914  }
1915  }
1916 
1917  case VEH_ROAD:
1918  /* Always use the livery of the front */
1919  if (v != nullptr && parent_engine_type != INVALID_ENGINE) {
1920  engine_type = parent_engine_type;
1921  e = Engine::Get(engine_type);
1922  cargo_type = v->First()->cargo_type;
1923  }
1924  if (cargo_type == CT_INVALID) cargo_type = e->GetDefaultCargoType();
1925  if (cargo_type == CT_INVALID) cargo_type = CT_GOODS; // The vehicle does not carry anything, let's pick some freight cargo
1926 
1927  /* Important: Use Tram Flag of front part. Luckily engine_type refers to the front part here. */
1928  if (HasBit(e->info.misc_flags, EF_ROAD_TRAM)) {
1929  /* Tram */
1930  return IsCargoInClass(cargo_type, CC_PASSENGERS) ? LS_PASSENGER_TRAM : LS_FREIGHT_TRAM;
1931  } else {
1932  /* Bus or truck */
1933  return IsCargoInClass(cargo_type, CC_PASSENGERS) ? LS_BUS : LS_TRUCK;
1934  }
1935 
1936  case VEH_SHIP:
1937  if (cargo_type == CT_INVALID) cargo_type = e->GetDefaultCargoType();
1938  if (cargo_type == CT_INVALID) cargo_type = CT_GOODS; // The vehicle does not carry anything, let's pick some freight cargo
1939  return IsCargoInClass(cargo_type, CC_PASSENGERS) ? LS_PASSENGER_SHIP : LS_FREIGHT_SHIP;
1940 
1941  case VEH_AIRCRAFT:
1942  switch (e->u.air.subtype) {
1943  case AIR_HELI: return LS_HELICOPTER;
1944  case AIR_CTOL: return LS_SMALL_PLANE;
1945  case AIR_CTOL | AIR_FAST: return LS_LARGE_PLANE;
1946  default: NOT_REACHED();
1947  }
1948  }
1949 }
1950 
1960 const Livery *GetEngineLivery(EngineID engine_type, CompanyID company, EngineID parent_engine_type, const Vehicle *v, byte livery_setting)
1961 {
1962  const Company *c = Company::Get(company);
1963  LiveryScheme scheme = LS_DEFAULT;
1964 
1965  if (livery_setting == LIT_ALL || (livery_setting == LIT_COMPANY && company == _local_company)) {
1966  if (v != nullptr) {
1967  const Group *g = Group::GetIfValid(v->First()->group_id);
1968  if (g != nullptr) {
1969  /* Traverse parents until we find a livery or reach the top */
1970  while (g->livery.in_use == 0 && g->parent != INVALID_GROUP) {
1971  g = Group::Get(g->parent);
1972  }
1973  if (g->livery.in_use != 0) return &g->livery;
1974  }
1975  }
1976 
1977  /* The default livery is always available for use, but its in_use flag determines
1978  * whether any _other_ liveries are in use. */
1979  if (c->livery[LS_DEFAULT].in_use != 0) {
1980  /* Determine the livery scheme to use */
1981  scheme = GetEngineLiveryScheme(engine_type, parent_engine_type, v);
1982  }
1983  }
1984 
1985  return &c->livery[scheme];
1986 }
1987 
1988 
1989 static PaletteID GetEngineColourMap(EngineID engine_type, CompanyID company, EngineID parent_engine_type, const Vehicle *v)
1990 {
1991  PaletteID map = (v != nullptr) ? v->colourmap : PAL_NONE;
1992 
1993  /* Return cached value if any */
1994  if (map != PAL_NONE) return map;
1995 
1996  const Engine *e = Engine::Get(engine_type);
1997 
1998  /* Check if we should use the colour map callback */
2000  uint16 callback = GetVehicleCallback(CBID_VEHICLE_COLOUR_MAPPING, 0, 0, engine_type, v);
2001  /* Failure means "use the default two-colour" */
2002  if (callback != CALLBACK_FAILED) {
2003  static_assert(PAL_NONE == 0); // Returning 0x4000 (resp. 0xC000) coincidences with default value (PAL_NONE)
2004  map = GB(callback, 0, 14);
2005  /* If bit 14 is set, then the company colours are applied to the
2006  * map else it's returned as-is. */
2007  if (!HasBit(callback, 14)) {
2008  /* Update cache */
2009  if (v != nullptr) const_cast<Vehicle *>(v)->colourmap = map;
2010  return map;
2011  }
2012  }
2013  }
2014 
2015  bool twocc = HasBit(e->info.misc_flags, EF_USES_2CC);
2016 
2017  if (map == PAL_NONE) map = twocc ? (PaletteID)SPR_2CCMAP_BASE : (PaletteID)PALETTE_RECOLOUR_START;
2018 
2019  /* Spectator has news shown too, but has invalid company ID - as well as dedicated server */
2020  if (!Company::IsValidID(company)) return map;
2021 
2022  const Livery *livery = GetEngineLivery(engine_type, company, parent_engine_type, v, _settings_client.gui.liveries);
2023 
2024  map += livery->colour1;
2025  if (twocc) map += livery->colour2 * 16;
2026 
2027  /* Update cache */
2028  if (v != nullptr) const_cast<Vehicle *>(v)->colourmap = map;
2029  return map;
2030 }
2031 
2039 {
2040  return GetEngineColourMap(engine_type, company, INVALID_ENGINE, nullptr);
2041 }
2042 
2049 {
2050  if (v->IsGroundVehicle()) {
2051  return GetEngineColourMap(v->engine_type, v->owner, v->GetGroundVehicleCache()->first_engine, v);
2052  }
2053 
2054  return GetEngineColourMap(v->engine_type, v->owner, INVALID_ENGINE, v);
2055 }
2056 
2061 {
2062  if (this->IsGroundVehicle()) {
2063  uint16 &gv_flags = this->GetGroundVehicleFlags();
2064  if (HasBit(gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS)) {
2065  /* Do not delete orders, only skip them */
2068  InvalidateVehicleOrder(this, 0);
2069  return;
2070  }
2071  }
2072 
2073  const Order *order = this->GetOrder(this->cur_implicit_order_index);
2074  while (order != nullptr) {
2075  if (this->cur_implicit_order_index == this->cur_real_order_index) break;
2076 
2077  if (order->IsType(OT_IMPLICIT)) {
2079  /* DeleteOrder does various magic with order_indices, so resync 'order' with 'cur_implicit_order_index' */
2080  order = this->GetOrder(this->cur_implicit_order_index);
2081  } else {
2082  /* Skip non-implicit orders, e.g. service-orders */
2083  order = order->next;
2084  this->cur_implicit_order_index++;
2085  }
2086 
2087  /* Wrap around */
2088  if (order == nullptr) {
2089  order = this->GetOrder(0);
2090  this->cur_implicit_order_index = 0;
2091  }
2092  }
2093 }
2094 
2100 {
2101  assert(IsTileType(this->tile, MP_STATION) || this->type == VEH_SHIP);
2102 
2103  uint32 travel_time = this->current_order_time;
2104  if (this->current_order.IsType(OT_GOTO_STATION) &&
2105  this->current_order.GetDestination() == this->last_station_visited) {
2107 
2108  /* Now both order indices point to the destination station, and we can start loading */
2109  this->current_order.MakeLoading(true);
2110  UpdateVehicleTimetable(this, true);
2111 
2112  /* Furthermore add the Non Stop flag to mark that this station
2113  * is the actual destination of the vehicle, which is (for example)
2114  * necessary to be known for HandleTrainLoading to determine
2115  * whether the train is lost or not; not marking a train lost
2116  * that arrives at random stations is bad. */
2118 
2119  } else {
2120  /* We weren't scheduled to stop here. Insert an implicit order
2121  * to show that we are stopping here.
2122  * While only groundvehicles have implicit orders, e.g. aircraft might still enter
2123  * the 'wrong' terminal when skipping orders etc. */
2124  Order *in_list = this->GetOrder(this->cur_implicit_order_index);
2125  if (this->IsGroundVehicle() &&
2126  (in_list == nullptr || !in_list->IsType(OT_IMPLICIT) ||
2127  in_list->GetDestination() != this->last_station_visited)) {
2128  bool suppress_implicit_orders = HasBit(this->GetGroundVehicleFlags(), GVF_SUPPRESS_IMPLICIT_ORDERS);
2129  /* Do not create consecutive duplicates of implicit orders */
2130  Order *prev_order = this->cur_implicit_order_index > 0 ? this->GetOrder(this->cur_implicit_order_index - 1) : (this->GetNumOrders() > 1 ? this->GetLastOrder() : nullptr);
2131  if (prev_order == nullptr ||
2132  (!prev_order->IsType(OT_IMPLICIT) && !prev_order->IsType(OT_GOTO_STATION)) ||
2133  prev_order->GetDestination() != this->last_station_visited) {
2134 
2135  /* Prefer deleting implicit orders instead of inserting new ones,
2136  * so test whether the right order follows later. In case of only
2137  * implicit orders treat the last order in the list like an
2138  * explicit one, except if the overall number of orders surpasses
2139  * IMPLICIT_ORDER_ONLY_CAP. */
2140  int target_index = this->cur_implicit_order_index;
2141  bool found = false;
2142  while (target_index != this->cur_real_order_index || this->GetNumManualOrders() == 0) {
2143  const Order *order = this->GetOrder(target_index);
2144  if (order == nullptr) break; // No orders.
2145  if (order->IsType(OT_IMPLICIT) && order->GetDestination() == this->last_station_visited) {
2146  found = true;
2147  break;
2148  }
2149  target_index++;
2150  if (target_index >= this->orders.list->GetNumOrders()) {
2151  if (this->GetNumManualOrders() == 0 &&
2153  break;
2154  }
2155  target_index = 0;
2156  }
2157  if (target_index == this->cur_implicit_order_index) break; // Avoid infinite loop.
2158  }
2159 
2160  if (found) {
2161  if (suppress_implicit_orders) {
2162  /* Skip to the found order */
2163  this->cur_implicit_order_index = target_index;
2164  InvalidateVehicleOrder(this, 0);
2165  } else {
2166  /* Delete all implicit orders up to the station we just reached */
2167  const Order *order = this->GetOrder(this->cur_implicit_order_index);
2168  while (!order->IsType(OT_IMPLICIT) || order->GetDestination() != this->last_station_visited) {
2169  if (order->IsType(OT_IMPLICIT)) {
2171  /* DeleteOrder does various magic with order_indices, so resync 'order' with 'cur_implicit_order_index' */
2172  order = this->GetOrder(this->cur_implicit_order_index);
2173  } else {
2174  /* Skip non-implicit orders, e.g. service-orders */
2175  order = order->next;
2176  this->cur_implicit_order_index++;
2177  }
2178 
2179  /* Wrap around */
2180  if (order == nullptr) {
2181  order = this->GetOrder(0);
2182  this->cur_implicit_order_index = 0;
2183  }
2184  assert(order != nullptr);
2185  }
2186  }
2187  } else if (!suppress_implicit_orders &&
2188  ((this->orders.list == nullptr ? OrderList::CanAllocateItem() : this->orders.list->GetNumOrders() < MAX_VEH_ORDER_ID)) &&
2190  /* Insert new implicit order */
2191  Order *implicit_order = new Order();
2192  implicit_order->MakeImplicit(this->last_station_visited);
2193  InsertOrder(this, implicit_order, this->cur_implicit_order_index);
2194  if (this->cur_implicit_order_index > 0) --this->cur_implicit_order_index;
2195 
2196  /* InsertOrder disabled creation of implicit orders for all vehicles with the same implicit order.
2197  * Reenable it for this vehicle */
2198  uint16 &gv_flags = this->GetGroundVehicleFlags();
2200  }
2201  }
2202  }
2203  this->current_order.MakeLoading(false);
2204  }
2205 
2206  if (this->last_loading_station != INVALID_STATION &&
2207  this->last_loading_station != this->last_station_visited &&
2208  ((this->current_order.GetLoadType() & OLFB_NO_LOAD) == 0 ||
2209  (this->current_order.GetUnloadType() & OUFB_NO_UNLOAD) == 0)) {
2210  IncreaseStats(Station::Get(this->last_loading_station), this, this->last_station_visited, travel_time);
2211  }
2212 
2213  PrepareUnload(this);
2214 
2219 
2221  this->cur_speed = 0;
2222  this->MarkDirty();
2223 }
2224 
2230 void Vehicle::CancelReservation(StationID next, Station *st)
2231 {
2232  for (Vehicle *v = this; v != nullptr; v = v->next) {
2235  Debug(misc, 1, "cancelling cargo reservation");
2236  cargo.Return(UINT_MAX, &st->goods[v->cargo_type].cargo, next);
2238  }
2239  cargo.KeepAll();
2240  }
2241 }
2242 
2248 {
2249  assert(this->current_order.IsType(OT_LOADING));
2250 
2251  delete this->cargo_payment;
2252  assert(this->cargo_payment == nullptr); // cleared by ~CargoPayment
2253 
2254  /* Only update the timetable if the vehicle was supposed to stop here. */
2256 
2257  if ((this->current_order.GetLoadType() & OLFB_NO_LOAD) == 0 ||
2258  (this->current_order.GetUnloadType() & OUFB_NO_UNLOAD) == 0) {
2259  if (this->current_order.CanLeaveWithCargo(this->last_loading_station != INVALID_STATION)) {
2260  /* Refresh next hop stats to make sure we've done that at least once
2261  * during the stop and that refit_cap == cargo_cap for each vehicle in
2262  * the consist. */
2263  this->ResetRefitCaps();
2264  LinkRefresher::Run(this);
2265 
2266  /* if the vehicle could load here or could stop with cargo loaded set the last loading station */
2268  } else {
2269  /* if the vehicle couldn't load and had to unload or transfer everything
2270  * set the last loading station to invalid as it will leave empty. */
2271  this->last_loading_station = INVALID_STATION;
2272  }
2273  }
2274 
2277  this->CancelReservation(INVALID_STATION, st);
2278  st->loading_vehicles.remove(this);
2279 
2281  trip_occupancy = CalcPercentVehicleFilled(this, nullptr);
2282 
2283  if (this->type == VEH_TRAIN && !(this->vehstatus & VS_CRASHED)) {
2284  /* Trigger station animation (trains only) */
2285  if (IsTileType(this->tile, MP_STATION)) {
2287  TriggerStationAnimation(st, this->tile, SAT_TRAIN_DEPARTS);
2288  }
2289 
2290  SetBit(Train::From(this)->flags, VRF_LEAVING_STATION);
2291  }
2292 
2293  this->MarkDirty();
2294 }
2295 
2300 {
2301  for (Vehicle *v = this; v != nullptr; v = v->Next()) v->refit_cap = v->cargo_cap;
2302 }
2303 
2309 void Vehicle::HandleLoading(bool mode)
2310 {
2311  switch (this->current_order.GetType()) {
2312  case OT_LOADING: {
2313  uint wait_time = std::max(this->current_order.GetTimetabledWait() - this->lateness_counter, 0);
2314 
2315  /* Not the first call for this tick, or still loading */
2316  if (mode || !HasBit(this->vehicle_flags, VF_LOADING_FINISHED) || this->current_order_time < wait_time) return;
2317 
2318  this->PlayLeaveStationSound();
2319 
2320  this->LeaveStation();
2321 
2322  /* Only advance to next order if we just loaded at the current one */
2323  const Order *order = this->GetOrder(this->cur_implicit_order_index);
2324  if (order == nullptr ||
2325  (!order->IsType(OT_IMPLICIT) && !order->IsType(OT_GOTO_STATION)) ||
2326  order->GetDestination() != this->last_station_visited) {
2327  return;
2328  }
2329  break;
2330  }
2331 
2332  case OT_DUMMY: break;
2333 
2334  default: return;
2335  }
2336 
2338 }
2339 
2345 {
2346  for (const Vehicle *v = this; v != nullptr; v = v->Next()) {
2347  if (v->cargo_cap == 0) continue;
2348  std::pair<CargoID, uint> *pair = capacities.Find(v->cargo_type);
2349  if (pair == capacities.End()) {
2350  capacities.push_back({v->cargo_type, v->cargo_cap - v->cargo.StoredCount()});
2351  } else {
2352  pair->second += v->cargo_cap - v->cargo.StoredCount();
2353  }
2354  }
2355 }
2356 
2357 uint Vehicle::GetConsistTotalCapacity() const
2358 {
2359  uint result = 0;
2360  for (const Vehicle *v = this; v != nullptr; v = v->Next()) {
2361  result += v->cargo_cap;
2362  }
2363  return result;
2364 }
2365 
2373 {
2374  CommandCost ret = CheckOwnership(this->owner);
2375  if (ret.Failed()) return ret;
2376 
2377  if (this->vehstatus & VS_CRASHED) return CMD_ERROR;
2378  if (this->IsStoppedInDepot()) return CMD_ERROR;
2379 
2380  if (this->current_order.IsType(OT_GOTO_DEPOT)) {
2381  bool halt_in_depot = (this->current_order.GetDepotActionType() & ODATFB_HALT) != 0;
2382  if (!!(command & DEPOT_SERVICE) == halt_in_depot) {
2383  /* We called with a different DEPOT_SERVICE setting.
2384  * Now we change the setting to apply the new one and let the vehicle head for the same depot.
2385  * Note: the if is (true for requesting service == true for ordered to stop in depot) */
2386  if (flags & DC_EXEC) {
2390  }
2391  return CommandCost();
2392  }
2393 
2394  if (command & DEPOT_DONT_CANCEL) return CMD_ERROR; // Requested no cancellation of depot orders
2395  if (flags & DC_EXEC) {
2396  /* If the orders to 'goto depot' are in the orders list (forced servicing),
2397  * then skip to the next order; effectively cancelling this forced service */
2399 
2400  if (this->IsGroundVehicle()) {
2401  uint16 &gv_flags = this->GetGroundVehicleFlags();
2403  }
2404 
2405  this->current_order.MakeDummy();
2407  }
2408  return CommandCost();
2409  }
2410 
2411  TileIndex location;
2412  DestinationID destination;
2413  bool reverse;
2414  static const StringID no_depot[] = {STR_ERROR_UNABLE_TO_FIND_ROUTE_TO, STR_ERROR_UNABLE_TO_FIND_LOCAL_DEPOT, STR_ERROR_UNABLE_TO_FIND_LOCAL_DEPOT, STR_ERROR_CAN_T_SEND_AIRCRAFT_TO_HANGAR};
2415  if (!this->FindClosestDepot(&location, &destination, &reverse)) return_cmd_error(no_depot[this->type]);
2416 
2417  if (flags & DC_EXEC) {
2418  if (this->current_order.IsType(OT_LOADING)) this->LeaveStation();
2419 
2420  if (this->IsGroundVehicle() && this->GetNumManualOrders() > 0) {
2421  uint16 &gv_flags = this->GetGroundVehicleFlags();
2423  }
2424 
2425  this->SetDestTile(location);
2426  this->current_order.MakeGoToDepot(destination, ODTF_MANUAL);
2427  if (!(command & DEPOT_SERVICE)) this->current_order.SetDepotActionType(ODATFB_HALT);
2429 
2430  /* If there is no depot in front and the train is not already reversing, reverse automatically (trains only) */
2431  if (this->type == VEH_TRAIN && (reverse ^ HasBit(Train::From(this)->flags, VRF_REVERSING))) {
2432  DoCommand(this->tile, this->index, 0, DC_EXEC, CMD_REVERSE_TRAIN_DIRECTION);
2433  }
2434 
2435  if (this->type == VEH_AIRCRAFT) {
2436  Aircraft *a = Aircraft::From(this);
2437  if (a->state == FLYING && a->targetairport != destination) {
2438  /* The aircraft is now heading for a different hangar than the next in the orders */
2441  }
2442  }
2443  }
2444 
2445  return CommandCost();
2446 
2447 }
2448 
2453 void Vehicle::UpdateVisualEffect(bool allow_power_change)
2454 {
2455  bool powered_before = HasBit(this->vcache.cached_vis_effect, VE_DISABLE_WAGON_POWER);
2456  const Engine *e = this->GetEngine();
2457 
2458  /* Evaluate properties */
2459  byte visual_effect;
2460  switch (e->type) {
2461  case VEH_TRAIN: visual_effect = e->u.rail.visual_effect; break;
2462  case VEH_ROAD: visual_effect = e->u.road.visual_effect; break;
2463  case VEH_SHIP: visual_effect = e->u.ship.visual_effect; break;
2464  default: visual_effect = 1 << VE_DISABLE_EFFECT; break;
2465  }
2466 
2467  /* Check powered wagon / visual effect callback */
2469  uint16 callback = GetVehicleCallback(CBID_VEHICLE_VISUAL_EFFECT, 0, 0, this->engine_type, this);
2470 
2471  if (callback != CALLBACK_FAILED) {
2472  if (callback >= 0x100 && e->GetGRF()->grf_version >= 8) ErrorUnknownCallbackResult(e->GetGRFID(), CBID_VEHICLE_VISUAL_EFFECT, callback);
2473 
2474  callback = GB(callback, 0, 8);
2475  /* Avoid accidentally setting 'visual_effect' to the default value
2476  * Since bit 6 (disable effects) is set anyways, we can safely erase some bits. */
2477  if (callback == VE_DEFAULT) {
2478  assert(HasBit(callback, VE_DISABLE_EFFECT));
2479  SB(callback, VE_TYPE_START, VE_TYPE_COUNT, 0);
2480  }
2481  visual_effect = callback;
2482  }
2483  }
2484 
2485  /* Apply default values */
2486  if (visual_effect == VE_DEFAULT ||
2487  (!HasBit(visual_effect, VE_DISABLE_EFFECT) && GB(visual_effect, VE_TYPE_START, VE_TYPE_COUNT) == VE_TYPE_DEFAULT)) {
2488  /* Only train engines have default effects.
2489  * Note: This is independent of whether the engine is a front engine or articulated part or whatever. */
2490  if (e->type != VEH_TRAIN || e->u.rail.railveh_type == RAILVEH_WAGON || !IsInsideMM(e->u.rail.engclass, EC_STEAM, EC_MONORAIL)) {
2491  if (visual_effect == VE_DEFAULT) {
2492  visual_effect = 1 << VE_DISABLE_EFFECT;
2493  } else {
2494  SetBit(visual_effect, VE_DISABLE_EFFECT);
2495  }
2496  } else {
2497  if (visual_effect == VE_DEFAULT) {
2498  /* Also set the offset */
2499  visual_effect = (VE_OFFSET_CENTRE - (e->u.rail.engclass == EC_STEAM ? 4 : 0)) << VE_OFFSET_START;
2500  }
2501  SB(visual_effect, VE_TYPE_START, VE_TYPE_COUNT, e->u.rail.engclass - EC_STEAM + VE_TYPE_STEAM);
2502  }
2503  }
2504 
2505  this->vcache.cached_vis_effect = visual_effect;
2506 
2507  if (!allow_power_change && powered_before != HasBit(this->vcache.cached_vis_effect, VE_DISABLE_WAGON_POWER)) {
2509  ShowNewGrfVehicleError(this->engine_type, STR_NEWGRF_BROKEN, STR_NEWGRF_BROKEN_POWERED_WAGON, GBUG_VEH_POWERED_WAGON, false);
2510  }
2511 }
2512 
2513 static const int8 _vehicle_smoke_pos[8] = {
2514  1, 1, 1, 0, -1, -1, -1, 0
2515 };
2516 
2521 static void SpawnAdvancedVisualEffect(const Vehicle *v)
2522 {
2523  uint16 callback = GetVehicleCallback(CBID_VEHICLE_SPAWN_VISUAL_EFFECT, 0, Random(), v->engine_type, v);
2524  if (callback == CALLBACK_FAILED) return;
2525 
2526  uint count = GB(callback, 0, 2);
2527  bool auto_center = HasBit(callback, 13);
2528  bool auto_rotate = !HasBit(callback, 14);
2529 
2530  int8 l_center = 0;
2531  if (auto_center) {
2532  /* For road vehicles: Compute offset from vehicle position to vehicle center */
2533  if (v->type == VEH_ROAD) l_center = -(int)(VEHICLE_LENGTH - RoadVehicle::From(v)->gcache.cached_veh_length) / 2;
2534  } else {
2535  /* For trains: Compute offset from vehicle position to sprite position */
2536  if (v->type == VEH_TRAIN) l_center = (VEHICLE_LENGTH - Train::From(v)->gcache.cached_veh_length) / 2;
2537  }
2538 
2539  Direction l_dir = v->direction;
2540  if (v->type == VEH_TRAIN && HasBit(Train::From(v)->flags, VRF_REVERSE_DIRECTION)) l_dir = ReverseDir(l_dir);
2541  Direction t_dir = ChangeDir(l_dir, DIRDIFF_90RIGHT);
2542 
2543  int8 x_center = _vehicle_smoke_pos[l_dir] * l_center;
2544  int8 y_center = _vehicle_smoke_pos[t_dir] * l_center;
2545 
2546  for (uint i = 0; i < count; i++) {
2547  uint32 reg = GetRegister(0x100 + i);
2548  uint type = GB(reg, 0, 8);
2549  int8 x = GB(reg, 8, 8);
2550  int8 y = GB(reg, 16, 8);
2551  int8 z = GB(reg, 24, 8);
2552 
2553  if (auto_rotate) {
2554  int8 l = x;
2555  int8 t = y;
2556  x = _vehicle_smoke_pos[l_dir] * l + _vehicle_smoke_pos[t_dir] * t;
2557  y = _vehicle_smoke_pos[t_dir] * l - _vehicle_smoke_pos[l_dir] * t;
2558  }
2559 
2560  if (type >= 0xF0) {
2561  switch (type) {
2562  case 0xF1: CreateEffectVehicleRel(v, x_center + x, y_center + y, z, EV_STEAM_SMOKE); break;
2563  case 0xF2: CreateEffectVehicleRel(v, x_center + x, y_center + y, z, EV_DIESEL_SMOKE); break;
2564  case 0xF3: CreateEffectVehicleRel(v, x_center + x, y_center + y, z, EV_ELECTRIC_SPARK); break;
2565  case 0xFA: CreateEffectVehicleRel(v, x_center + x, y_center + y, z, EV_BREAKDOWN_SMOKE_AIRCRAFT); break;
2566  default: break;
2567  }
2568  }
2569  }
2570 }
2571 
2577 {
2578  assert(this->IsPrimaryVehicle());
2579  bool sound = false;
2580 
2581  /* Do not show any smoke when:
2582  * - vehicle smoke is disabled by the player
2583  * - the vehicle is slowing down or stopped (by the player)
2584  * - the vehicle is moving very slowly
2585  */
2586  if (_settings_game.vehicle.smoke_amount == 0 ||
2587  this->vehstatus & (VS_TRAIN_SLOWING | VS_STOPPED) ||
2588  this->cur_speed < 2) {
2589  return;
2590  }
2591 
2592  /* Use the speed as limited by underground and orders. */
2593  uint max_speed = this->GetCurrentMaxSpeed();
2594 
2595  if (this->type == VEH_TRAIN) {
2596  const Train *t = Train::From(this);
2597  /* For trains, do not show any smoke when:
2598  * - the train is reversing
2599  * - is entering a station with an order to stop there and its speed is equal to maximum station entering speed
2600  */
2601  if (HasBit(t->flags, VRF_REVERSING) ||
2603  t->cur_speed >= max_speed)) {
2604  return;
2605  }
2606  }
2607 
2608  const Vehicle *v = this;
2609 
2610  do {
2611  bool advanced = HasBit(v->vcache.cached_vis_effect, VE_ADVANCED_EFFECT);
2613  VisualEffectSpawnModel effect_model = VESM_NONE;
2614  if (advanced) {
2615  effect_offset = VE_OFFSET_CENTRE;
2617  if (effect_model >= VESM_END) effect_model = VESM_NONE; // unknown spawning model
2618  } else {
2620  assert(effect_model != (VisualEffectSpawnModel)VE_TYPE_DEFAULT); // should have been resolved by UpdateVisualEffect
2621  static_assert((uint)VESM_STEAM == (uint)VE_TYPE_STEAM);
2622  static_assert((uint)VESM_DIESEL == (uint)VE_TYPE_DIESEL);
2623  static_assert((uint)VESM_ELECTRIC == (uint)VE_TYPE_ELECTRIC);
2624  }
2625 
2626  /* Show no smoke when:
2627  * - Smoke has been disabled for this vehicle
2628  * - The vehicle is not visible
2629  * - The vehicle is under a bridge
2630  * - The vehicle is on a depot tile
2631  * - The vehicle is on a tunnel tile
2632  * - The vehicle is a train engine that is currently unpowered */
2633  if (effect_model == VESM_NONE ||
2634  v->vehstatus & VS_HIDDEN ||
2635  IsBridgeAbove(v->tile) ||
2636  IsDepotTile(v->tile) ||
2637  IsTunnelTile(v->tile) ||
2638  (v->type == VEH_TRAIN &&
2639  !HasPowerOnRail(Train::From(v)->railtype, GetTileRailType(v->tile)))) {
2640  continue;
2641  }
2642 
2643  EffectVehicleType evt = EV_END;
2644  switch (effect_model) {
2645  case VESM_STEAM:
2646  /* Steam smoke - amount is gradually falling until vehicle reaches its maximum speed, after that it's normal.
2647  * Details: while vehicle's current speed is gradually increasing, steam plumes' density decreases by one third each
2648  * third of its maximum speed spectrum. Steam emission finally normalises at very close to vehicle's maximum speed.
2649  * REGULATION:
2650  * - instead of 1, 4 / 2^smoke_amount (max. 2) is used to provide sufficient regulation to steam puffs' amount. */
2651  if (GB(v->tick_counter, 0, ((4 >> _settings_game.vehicle.smoke_amount) + ((this->cur_speed * 3) / max_speed))) == 0) {
2652  evt = EV_STEAM_SMOKE;
2653  }
2654  break;
2655 
2656  case VESM_DIESEL: {
2657  /* Diesel smoke - thicker when vehicle is starting, gradually subsiding till it reaches its maximum speed
2658  * when smoke emission stops.
2659  * Details: Vehicle's (max.) speed spectrum is divided into 32 parts. When max. speed is reached, chance for smoke
2660  * emission erodes by 32 (1/4). For trains, power and weight come in handy too to either increase smoke emission in
2661  * 6 steps (1000HP each) if the power is low or decrease smoke emission in 6 steps (512 tonnes each) if the train
2662  * isn't overweight. Power and weight contributions are expressed in a way that neither extreme power, nor
2663  * extreme weight can ruin the balance (e.g. FreightWagonMultiplier) in the formula. When the vehicle reaches
2664  * maximum speed no diesel_smoke is emitted.
2665  * REGULATION:
2666  * - up to which speed a diesel vehicle is emitting smoke (with reduced/small setting only until 1/2 of max_speed),
2667  * - in Chance16 - the last value is 512 / 2^smoke_amount (max. smoke when 128 = smoke_amount of 2). */
2668  int power_weight_effect = 0;
2669  if (v->type == VEH_TRAIN) {
2670  power_weight_effect = (32 >> (Train::From(this)->gcache.cached_power >> 10)) - (32 >> (Train::From(this)->gcache.cached_weight >> 9));
2671  }
2672  if (this->cur_speed < (max_speed >> (2 >> _settings_game.vehicle.smoke_amount)) &&
2673  Chance16((64 - ((this->cur_speed << 5) / max_speed) + power_weight_effect), (512 >> _settings_game.vehicle.smoke_amount))) {
2674  evt = EV_DIESEL_SMOKE;
2675  }
2676  break;
2677  }
2678 
2679  case VESM_ELECTRIC:
2680  /* Electric train's spark - more often occurs when train is departing (more load)
2681  * Details: Electric locomotives are usually at least twice as powerful as their diesel counterparts, so spark
2682  * emissions are kept simple. Only when starting, creating huge force are sparks more likely to happen, but when
2683  * reaching its max. speed, quarter by quarter of it, chance decreases until the usual 2,22% at train's top speed.
2684  * REGULATION:
2685  * - in Chance16 the last value is 360 / 2^smoke_amount (max. sparks when 90 = smoke_amount of 2). */
2686  if (GB(v->tick_counter, 0, 2) == 0 &&
2687  Chance16((6 - ((this->cur_speed << 2) / max_speed)), (360 >> _settings_game.vehicle.smoke_amount))) {
2688  evt = EV_ELECTRIC_SPARK;
2689  }
2690  break;
2691 
2692  default:
2693  NOT_REACHED();
2694  }
2695 
2696  if (evt != EV_END && advanced) {
2697  sound = true;
2699  } else if (evt != EV_END) {
2700  sound = true;
2701 
2702  /* The effect offset is relative to a point 4 units behind the vehicle's
2703  * front (which is the center of an 8/8 vehicle). Shorter vehicles need a
2704  * correction factor. */
2705  if (v->type == VEH_TRAIN) effect_offset += (VEHICLE_LENGTH - Train::From(v)->gcache.cached_veh_length) / 2;
2706 
2707  int x = _vehicle_smoke_pos[v->direction] * effect_offset;
2708  int y = _vehicle_smoke_pos[(v->direction + 2) % 8] * effect_offset;
2709 
2710  if (v->type == VEH_TRAIN && HasBit(Train::From(v)->flags, VRF_REVERSE_DIRECTION)) {
2711  x = -x;
2712  y = -y;
2713  }
2714 
2715  CreateEffectVehicleRel(v, x, y, 10, evt);
2716  }
2717  } while ((v = v->Next()) != nullptr);
2718 
2719  if (sound) PlayVehicleSound(this, VSE_VISUAL_EFFECT);
2720 }
2721 
2727 {
2728  assert(this != next);
2729 
2730  if (this->next != nullptr) {
2731  /* We had an old next vehicle. Update the first and previous pointers */
2732  for (Vehicle *v = this->next; v != nullptr; v = v->Next()) {
2733  v->first = this->next;
2734  }
2735  this->next->previous = nullptr;
2736  }
2737 
2738  this->next = next;
2739 
2740  if (this->next != nullptr) {
2741  /* A new next vehicle. Update the first and previous pointers */
2742  if (this->next->previous != nullptr) this->next->previous->next = nullptr;
2743  this->next->previous = this;
2744  for (Vehicle *v = this->next; v != nullptr; v = v->Next()) {
2745  v->first = this->first;
2746  }
2747  }
2748 }
2749 
2755 void Vehicle::AddToShared(Vehicle *shared_chain)
2756 {
2757  assert(this->previous_shared == nullptr && this->next_shared == nullptr);
2758 
2759  if (shared_chain->orders.list == nullptr) {
2760  assert(shared_chain->previous_shared == nullptr);
2761  assert(shared_chain->next_shared == nullptr);
2762  this->orders.list = shared_chain->orders.list = new OrderList(nullptr, shared_chain);
2763  }
2764 
2765  this->next_shared = shared_chain->next_shared;
2766  this->previous_shared = shared_chain;
2767 
2768  shared_chain->next_shared = this;
2769 
2770  if (this->next_shared != nullptr) this->next_shared->previous_shared = this;
2771 
2772  shared_chain->orders.list->AddVehicle(this);
2773 }
2774 
2779 {
2780  /* Remember if we were first and the old window number before RemoveVehicle()
2781  * as this changes first if needed. */
2782  bool were_first = (this->FirstShared() == this);
2783  VehicleListIdentifier vli(VL_SHARED_ORDERS, this->type, this->owner, this->FirstShared()->index);
2784 
2785  this->orders.list->RemoveVehicle(this);
2786 
2787  if (!were_first) {
2788  /* We are not the first shared one, so only relink our previous one. */
2789  this->previous_shared->next_shared = this->NextShared();
2790  }
2791 
2792  if (this->next_shared != nullptr) this->next_shared->previous_shared = this->previous_shared;
2793 
2794 
2795  if (this->orders.list->GetNumVehicles() == 1) {
2796  /* When there is only one vehicle, remove the shared order list window. */
2799  } else if (were_first) {
2800  /* If we were the first one, update to the new first one.
2801  * Note: FirstShared() is already the new first */
2802  InvalidateWindowData(GetWindowClassForVehicleType(this->type), vli.Pack(), this->FirstShared()->index | (1U << 31));
2803  }
2804 
2805  this->next_shared = nullptr;
2806  this->previous_shared = nullptr;
2807 }
2808 
2809 void VehiclesYearlyLoop()
2810 {
2811  for (Vehicle *v : Vehicle::Iterate()) {
2812  if (v->IsPrimaryVehicle()) {
2813  /* show warning if vehicle is not generating enough income last 2 years (corresponds to a red icon in the vehicle list) */
2814  Money profit = v->GetDisplayProfitThisYear();
2815  if (v->age >= 730 && profit < 0) {
2817  SetDParam(0, v->index);
2818  SetDParam(1, profit);
2819  AddVehicleAdviceNewsItem(STR_NEWS_VEHICLE_IS_UNPROFITABLE, v->index);
2820  }
2821  AI::NewEvent(v->owner, new ScriptEventVehicleUnprofitable(v->index));
2822  }
2823 
2825  v->profit_this_year = 0;
2827  }
2828  }
2834 }
2835 
2836 
2846 bool CanVehicleUseStation(EngineID engine_type, const Station *st)
2847 {
2848  const Engine *e = Engine::GetIfValid(engine_type);
2849  assert(e != nullptr);
2850 
2851  switch (e->type) {
2852  case VEH_TRAIN:
2853  return (st->facilities & FACIL_TRAIN) != 0;
2854 
2855  case VEH_ROAD:
2856  /* For road vehicles we need the vehicle to know whether it can actually
2857  * use the station, but if it doesn't have facilities for RVs it is
2858  * certainly not possible that the station can be used. */
2859  return (st->facilities & (FACIL_BUS_STOP | FACIL_TRUCK_STOP)) != 0;
2860 
2861  case VEH_SHIP:
2862  return (st->facilities & FACIL_DOCK) != 0;
2863 
2864  case VEH_AIRCRAFT:
2865  return (st->facilities & FACIL_AIRPORT) != 0 &&
2867 
2868  default:
2869  return false;
2870  }
2871 }
2872 
2879 bool CanVehicleUseStation(const Vehicle *v, const Station *st)
2880 {
2881  if (v->type == VEH_ROAD) return st->GetPrimaryRoadStop(RoadVehicle::From(v)) != nullptr;
2882 
2883  return CanVehicleUseStation(v->engine_type, st);
2884 }
2885 
2892 {
2893  assert(this->IsGroundVehicle());
2894  if (this->type == VEH_TRAIN) {
2895  return &Train::From(this)->gcache;
2896  } else {
2897  return &RoadVehicle::From(this)->gcache;
2898  }
2899 }
2900 
2907 {
2908  assert(this->IsGroundVehicle());
2909  if (this->type == VEH_TRAIN) {
2910  return &Train::From(this)->gcache;
2911  } else {
2912  return &RoadVehicle::From(this)->gcache;
2913  }
2914 }
2915 
2922 {
2923  assert(this->IsGroundVehicle());
2924  if (this->type == VEH_TRAIN) {
2925  return Train::From(this)->gv_flags;
2926  } else {
2927  return RoadVehicle::From(this)->gv_flags;
2928  }
2929 }
2930 
2936 const uint16 &Vehicle::GetGroundVehicleFlags() const
2937 {
2938  assert(this->IsGroundVehicle());
2939  if (this->type == VEH_TRAIN) {
2940  return Train::From(this)->gv_flags;
2941  } else {
2942  return RoadVehicle::From(this)->gv_flags;
2943  }
2944 }
2945 
2954 void GetVehicleSet(VehicleSet &set, Vehicle *v, uint8 num_vehicles)
2955 {
2956  if (v->type == VEH_TRAIN) {
2957  Train *u = Train::From(v);
2958  /* Only include whole vehicles, so start with the first articulated part */
2959  u = u->GetFirstEnginePart();
2960 
2961  /* Include num_vehicles vehicles, not counting articulated parts */
2962  for (; u != nullptr && num_vehicles > 0; num_vehicles--) {
2963  do {
2964  /* Include current vehicle in the selection. */
2965  include(set, u->index);
2966 
2967  /* If the vehicle is multiheaded, add the other part too. */
2968  if (u->IsMultiheaded()) include(set, u->other_multiheaded_part->index);
2969 
2970  u = u->Next();
2971  } while (u != nullptr && u->IsArticulatedPart());
2972  }
2973  }
2974 }
VEH_AIRCRAFT
@ VEH_AIRCRAFT
Aircraft vehicle type.
Definition: vehicle_type.h:27
GUISettings::lost_vehicle_warn
bool lost_vehicle_warn
if a vehicle can't find its destination, show a warning
Definition: settings_type.h:105
RoadVehicle
Buses, trucks and trams belong to this class.
Definition: roadveh.h:107
Vehicle::GetGroundVehicleCache
GroundVehicleCache * GetGroundVehicleCache()
Access the ground vehicle cache of the vehicle.
Definition: vehicle.cpp:2891
DeleteNewGRFInspectWindow
void DeleteNewGRFInspectWindow(GrfSpecFeature feature, uint index)
Delete inspect window for a given feature and index.
Definition: newgrf_debug_gui.cpp:734
VRF_TOGGLE_REVERSE
@ VRF_TOGGLE_REVERSE
Used for vehicle var 0xFE bit 8 (toggled each time the train is reversed, accurate for first vehicle ...
Definition: train.h:31
IsTunnelTile
static bool IsTunnelTile(TileIndex t)
Is this a tunnel (entrance)?
Definition: tunnel_map.h:34
BaseStation::facilities
StationFacility facilities
The facilities that this station has.
Definition: base_station_base.h:63
Aircraft::targetairport
StationID targetairport
Airport to go to next.
Definition: aircraft.h:78
BaseConsist::cur_implicit_order_index
VehicleOrderID cur_implicit_order_index
The index to the current implicit order.
Definition: base_consist.h:29
INVALID_ENGINE
static const EngineID INVALID_ENGINE
Constant denoting an invalid engine.
Definition: engine_type.h:175
IsCompanyBuildableVehicleType
static bool IsCompanyBuildableVehicleType(VehicleType type)
Is the given vehicle type buildable by a company?
Definition: vehicle_func.h:89
PlayVehicleSound
bool PlayVehicleSound(const Vehicle *v, VehicleSoundEvent event)
Checks whether a NewGRF wants to play a different vehicle sound effect.
Definition: newgrf_sound.cpp:186
tunnel_map.h
Order::IsRefit
bool IsRefit() const
Is this order a refit order.
Definition: order_base.h:111
VehicleSettings::max_aircraft
UnitID max_aircraft
max planes in game per company
Definition: settings_type.h:486
WC_ROADVEH_LIST
@ WC_ROADVEH_LIST
Road vehicle list; Window numbers:
Definition: window_type.h:306
Engine::GetGRFID
uint32 GetGRFID() const
Retrieve the GRF ID of the NewGRF the engine is tied to.
Definition: engine.cpp:147
MutableSpriteCache::is_viewport_candidate
bool is_viewport_candidate
This vehicle can potentially be drawn on a viewport.
Definition: vehicle_base.h:193
TileIndex
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:83
VehicleCargoList::StoredCount
uint StoredCount() const
Returns sum of cargo on board the vehicle (ie not only reserved).
Definition: cargopacket.h:352
RoadVehicle::state
byte state
Definition: roadveh.h:109
GetEngineLivery
const Livery * GetEngineLivery(EngineID engine_type, CompanyID company, EngineID parent_engine_type, const Vehicle *v, byte livery_setting)
Determines the livery for a vehicle.
Definition: vehicle.cpp:1960
DIR_SW
@ DIR_SW
Southwest.
Definition: direction_type.h:31
InvalidateWindowData
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
Definition: window.cpp:3218
Order::MakeDummy
void MakeDummy()
Makes this order a Dummy order.
Definition: order_cmd.cpp:132
sound_func.h
UpdateVehicleTimetable
void UpdateVehicleTimetable(Vehicle *v, bool travelling)
Update the timetable for the vehicle.
Definition: timetable_cmd.cpp:372
Station::goods
GoodsEntry goods[NUM_CARGO]
Goods at this station.
Definition: station_base.h:476
EV_ELECTRIC_SPARK
@ EV_ELECTRIC_SPARK
Sparcs of electric engines.
Definition: effectvehicle_func.h:20
DIRDIFF_REVERSE
@ DIRDIFF_REVERSE
One direction is the opposite of the other one.
Definition: direction_type.h:66
VE_OFFSET_COUNT
@ VE_OFFSET_COUNT
Number of bits used for the offset.
Definition: vehicle_base.h:79
AircraftNextAirportPos_and_Order
void AircraftNextAirportPos_and_Order(Aircraft *v)
set the right pos when heading to other airports after takeoff
Definition: aircraft_cmd.cpp:1431
Engine::IterateType
static Pool::IterateWrapperFiltered< Engine, EngineTypeFilter > IterateType(VehicleType vt, size_t from=0)
Returns an iterable ensemble of all valid engines of the given type.
Definition: engine_base.h:161
VE_DISABLE_EFFECT
@ VE_DISABLE_EFFECT
Flag to disable visual effect.
Definition: vehicle_base.h:89
newgrf_station.h
Chance16
static bool Chance16(const uint a, const uint b)
Flips a coin with given probability.
Definition: random_func.hpp:131
DoCommand
CommandCost DoCommand(const CommandContainer *container, DoCommandFlag flags)
Shorthand for calling the long DoCommand with a container.
Definition: command.cpp:450
CMD_REVERSE_TRAIN_DIRECTION
@ CMD_REVERSE_TRAIN_DIRECTION
turn a train around
Definition: command_type.h:222
Order::IsType
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition: order_base.h:64
Vehicle::PreDestructor
void PreDestructor()
Destroy all stuff that (still) needs the virtual functions to work properly.
Definition: vehicle.cpp:800
Pool::PoolItem<&_company_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:337
PrepareUnload
void PrepareUnload(Vehicle *front_v)
Prepare the vehicle to be unloaded.
Definition: economy.cpp:1250
Direction
Direction
Defines the 8 directions on the map.
Definition: direction_type.h:24
Order::GetTimetabledWait
uint16 GetTimetabledWait() const
Get the time in ticks a vehicle should wait at the destination or 0 if it's not timetabled.
Definition: order_base.h:182
Vehicle::y_pos
int32 y_pos
y coordinate.
Definition: vehicle_base.h:281
CargoList::OnCleanPool
void OnCleanPool()
Empty the cargo list, but don't free the cargo packets; the cargo packets are cleaned by CargoPacket'...
Definition: cargopacket.cpp:167
SetWindowDirty
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition: window.cpp:3120
MutableSpriteCache::sprite_seq
VehicleSpriteSeq sprite_seq
Vehicle appearance.
Definition: vehicle_base.h:194
GroupStatistics::CountEngine
static void CountEngine(const Vehicle *v, int delta)
Update num_engines when adding/removing an engine.
Definition: group_cmd.cpp:156
Company::group_all
GroupStatistics group_all[VEH_COMPANY_END]
NOSAVE: Statistics for the ALL_GROUP group.
Definition: company_base.h:125
GB
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
Definition: bitmath_func.hpp:32
Vehicle::GetNumManualOrders
VehicleOrderID GetNumManualOrders() const
Get the number of manually added orders this vehicle has.
Definition: vehicle_base.h:706
Vehicle::value
Money value
Value of the vehicle.
Definition: vehicle_base.h:253
Vehicle::x_pos
int32 x_pos
x coordinate.
Definition: vehicle_base.h:280
DIRDIFF_45LEFT
@ DIRDIFF_45LEFT
Angle of 45 degrees left.
Definition: direction_type.h:68
train.h
AircraftVehicleInfo::subtype
byte subtype
Type of aircraft.
Definition: engine_type.h:102
ChangeDir
static Direction ChangeDir(Direction d, DirDiff delta)
Change a direction by a given difference.
Definition: direction_func.h:104
command_func.h
DIR_SE
@ DIR_SE
Southeast.
Definition: direction_type.h:29
_tile_type_procs
const TileTypeProcs *const _tile_type_procs[16]
Tile callback functions for each type of tile.
Definition: landscape.cpp:61
Vehicle::HasEngineType
bool HasEngineType() const
Check whether Vehicle::engine_type has any meaning.
Definition: vehicle.cpp:725
Pool::PoolItem<&_group_pool >::GetIfValid
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:348
CMD_ERROR
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
Definition: command_func.h:23
ODTFB_SERVICE
@ ODTFB_SERVICE
This depot order is because of the servicing limit.
Definition: order_type.h:95
EffectVehicle::animation_state
uint16 animation_state
State primarily used to change the graphics/behaviour.
Definition: effectvehicle_base.h:25
GBUG_VEH_POWERED_WAGON
@ GBUG_VEH_POWERED_WAGON
Powered wagon changed poweredness state when not inside a depot.
Definition: newgrf_config.h:46
Vehicle::GetGroundVehicleFlags
uint16 & GetGroundVehicleFlags()
Access the ground vehicle flags of the vehicle.
Definition: vehicle.cpp:2921
Vehicle::IsEngineCountable
bool IsEngineCountable() const
Check if a vehicle is counted in num_engines in each company struct.
Definition: vehicle.cpp:708
CBID_VEHICLE_VISUAL_EFFECT
@ CBID_VEHICLE_VISUAL_EFFECT
Visual effects and wagon power.
Definition: newgrf_callbacks.h:30
VehicleListIdentifier
The information about a vehicle list.
Definition: vehiclelist.h:29
Vehicle::Previous
Vehicle * Previous() const
Get the previous vehicle of this vehicle.
Definition: vehicle_base.h:601
HasVehicleOnPos
bool HasVehicleOnPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
Checks whether a vehicle is on a specific location.
Definition: vehicle.cpp:513
GameCreationSettings::landscape
byte landscape
the landscape we're currently in
Definition: settings_type.h:320
GVF_SUPPRESS_IMPLICIT_ORDERS
@ GVF_SUPPRESS_IMPLICIT_ORDERS
Disable insertion and removal of automatic orders until the vehicle completes the real order.
Definition: ground_vehicle.hpp:54
GroundVehicleCache::first_engine
EngineID first_engine
Cached EngineID of the front vehicle. INVALID_ENGINE for the front vehicle itself.
Definition: ground_vehicle.hpp:43
Backup
Class to backup a specific variable and restore it later.
Definition: backup_type.hpp:21
Order::MakeLoading
void MakeLoading(bool ordered)
Makes this order a Loading order.
Definition: order_cmd.cpp:114
Order::MakeLeaveStation
void MakeLeaveStation()
Makes this order a Leave Station order.
Definition: order_cmd.cpp:123
Vehicle::LeaveStation
void LeaveStation()
Perform all actions when leaving a station.
Definition: vehicle.cpp:2247
IsWagon
static bool IsWagon(EngineID index)
Determine whether an engine type is a wagon (and not a loco).
Definition: engine.cpp:553
IsTransparencySet
static bool IsTransparencySet(TransparencyOption to)
Check if the transparency option bit is set and if we aren't in the game menu (there's never transpar...
Definition: transparency.h:48
Vehicle::Next
Vehicle * Next() const
Get the next vehicle of this vehicle.
Definition: vehicle_base.h:594
SpecializedVehicle::Next
T * Next() const
Get next vehicle in the chain.
Definition: vehicle_base.h:1079
FACIL_TRUCK_STOP
@ FACIL_TRUCK_STOP
Station with truck stops.
Definition: station_type.h:53
DIRDIFF_SAME
@ DIRDIFF_SAME
Both directions faces to the same direction.
Definition: direction_type.h:63
Vehicle::y_extent
byte y_extent
y-extent of vehicle bounding box
Definition: vehicle_base.h:293
OLFB_FULL_LOAD
@ OLFB_FULL_LOAD
Full load all cargoes of the consist.
Definition: order_type.h:64
UnitID
uint16 UnitID
Type for the company global vehicle unit number.
Definition: transport_type.h:16
Station
Station data structure.
Definition: station_base.h:447
Order::GetDestination
DestinationID GetDestination() const
Gets the destination of this order.
Definition: order_base.h:97
Viewport::width
int width
Screen width of the viewport.
Definition: viewport_type.h:25
economy_base.h
Vehicle::NeedsAutomaticServicing
bool NeedsAutomaticServicing() const
Checks if the current order should be interrupted for a service-in-depot order.
Definition: vehicle.cpp:252
Vehicle::z_pos
int32 z_pos
z coordinate.
Definition: vehicle_base.h:282
_date_fract
DateFract _date_fract
Fractional part of the day.
Definition: date.cpp:29
SpawnAdvancedVisualEffect
static void SpawnAdvancedVisualEffect(const Vehicle *v)
Call CBID_VEHICLE_SPAWN_VISUAL_EFFECT and spawn requested effects.
Definition: vehicle.cpp:2521
GetArticulatedRefitMasks
void GetArticulatedRefitMasks(EngineID engine, bool include_initial_cargo_type, CargoTypes *union_mask, CargoTypes *intersection_mask)
Merges the refit_masks of all articulated parts.
Definition: articulated_vehicles.cpp:229
Engine::company_avail
CompanyMask company_avail
Bit for each company whether the engine is available for that company.
Definition: engine_base.h:43
DIR_NW
@ DIR_NW
Northwest.
Definition: direction_type.h:33
RemapCoords
static Point RemapCoords(int x, int y, int z)
Map 3D world or tile coordinate to equivalent 2D coordinate as used in the viewports and smallmap.
Definition: landscape.h:82
IMPLICIT_ORDER_ONLY_CAP
static const uint IMPLICIT_ORDER_ONLY_CAP
Maximum number of orders in implicit-only lists before we start searching harder for duplicates.
Definition: order_type.h:32
vehiclelist.h
GetVehicleSet
void GetVehicleSet(VehicleSet &set, Vehicle *v, uint8 num_vehicles)
Calculates the set of vehicles that will be affected by a given selection.
Definition: vehicle.cpp:2954
FreeUnitIDGenerator::curid
UnitID curid
last ID returned; 0 if none
Definition: vehicle_base.h:1240
Viewport::height
int height
Screen height of the viewport.
Definition: viewport_type.h:26
EC_STEAM
@ EC_STEAM
Steam rail engine.
Definition: engine_type.h:34
Vehicle::vehstatus
byte vehstatus
Status.
Definition: vehicle_base.h:328
group_gui.h
VE_DEFAULT
@ VE_DEFAULT
Default value to indicate that visual effect should be based on engine class.
Definition: vehicle_base.h:93
Group::parent
GroupID parent
Parent group.
Definition: group.h:83
VS_DEFPAL
@ VS_DEFPAL
Use default vehicle palette.
Definition: vehicle_base.h:34
depot_func.h
VSE_BREAKDOWN
@ VSE_BREAKDOWN
Vehicle breaking down.
Definition: newgrf_sound.h:21
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:235
Vehicle::SetNext
void SetNext(Vehicle *next)
Set the next vehicle of this vehicle.
Definition: vehicle.cpp:2726
CargoSpec::Get
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo ID.
Definition: cargotype.h:119
Vehicle::Crash
virtual uint Crash(bool flooded=false)
Crash the (whole) vehicle chain.
Definition: vehicle.cpp:260
MAX_VEHICLE_PIXEL_Y
static const int MAX_VEHICLE_PIXEL_Y
Maximum height of a vehicle in pixels in #ZOOM_LVL_BASE.
Definition: tile_type.h:20
HasPowerOnRail
static bool HasPowerOnRail(RailType enginetype, RailType tiletype)
Checks if an engine of the given RailType got power on a tile with a given RailType.
Definition: rail.h:332
Viewport::top
int top
Screen coordinate top edge of the viewport.
Definition: viewport_type.h:24
PFE_GL_ROADVEHS
@ PFE_GL_ROADVEHS
Time spend processing road vehicles.
Definition: framerate_type.h:52
PalSpriteID::sprite
SpriteID sprite
The 'real' sprite.
Definition: gfx_type.h:23
Vehicle::group_id
GroupID group_id
Index of group Pool array.
Definition: vehicle_base.h:337
EngineReplacementForCompany
static EngineID EngineReplacementForCompany(const Company *c, EngineID engine, GroupID group, bool *replace_when_old=nullptr)
Retrieve the engine replacement for the given company and original engine type.
Definition: autoreplace_func.h:39
Vehicle::Vehicle
Vehicle(VehicleType type=VEH_INVALID)
Vehicle constructor.
Definition: vehicle.cpp:345
EF_NO_BREAKDOWN_SMOKE
@ EF_NO_BREAKDOWN_SMOKE
Do not show black smoke during a breakdown.
Definition: engine_type.h:161
DeleteVehicleNews
void DeleteVehicleNews(VehicleID vid, StringID news)
Delete a news item type about a vehicle.
Definition: news_gui.cpp:905
GameSettings::difficulty
DifficultySettings difficulty
settings related to the difficulty
Definition: settings_type.h:575
HasBit
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103
GroupStatistics::CountVehicle
static void CountVehicle(const Vehicle *v, int delta)
Update num_vehicle when adding or removing a vehicle.
Definition: group_cmd.cpp:133
ship.h
_returned_mail_refit_capacity
uint16 _returned_mail_refit_capacity
Stores the mail capacity after a refit operation (Aircraft only).
Definition: vehicle.cpp:86
PerformanceMeasurer
RAII class for measuring simple elements of performance.
Definition: framerate_type.h:92
include
bool include(std::vector< T > &vec, const T &item)
Helper function to append an item to a vector if it is not already contained Consider using std::set,...
Definition: smallvec_type.hpp:27
ClrBit
static T ClrBit(T &x, const uint8 y)
Clears a bit in a variable.
Definition: bitmath_func.hpp:151
GetRoadStopType
static RoadStopType GetRoadStopType(TileIndex t)
Get the road stop type of this tile.
Definition: station_map.h:56
HideFillingPercent
void HideFillingPercent(TextEffectID *te_id)
Hide vehicle loading indicators.
Definition: misc_gui.cpp:648
VE_TYPE_ELECTRIC
@ VE_TYPE_ELECTRIC
Electric sparks.
Definition: vehicle_base.h:87
Sprite::height
uint16 height
Height of the sprite.
Definition: spritecache.h:18
TracksOverlap
static bool TracksOverlap(TrackBits bits)
Checks if the given tracks overlap, ie form a crossing.
Definition: track_func.h:644
Vehicle::next
Vehicle * next
pointer to the next vehicle in the chain
Definition: vehicle_base.h:226
ODTF_MANUAL
@ ODTF_MANUAL
Manually initiated order.
Definition: order_type.h:94
Vehicle::GetGRF
const GRFFile * GetGRF() const
Retrieve the NewGRF the vehicle is tied to.
Definition: vehicle.cpp:751
RoadStop::GetByTile
static RoadStop * GetByTile(TileIndex tile, RoadStopType type)
Find a roadstop at given tile.
Definition: roadstop.cpp:266
VF_LOADING_FINISHED
@ VF_LOADING_FINISHED
Vehicle has finished loading.
Definition: vehicle_base.h:43
zoom_func.h
autoreplace_gui.h
aircraft.h
Group::livery
Livery livery
Custom colour scheme for vehicles in this group.
Definition: group.h:78
Sprite::x_offs
int16 x_offs
Number of pixels to shift the sprite to the right.
Definition: spritecache.h:20
TILE_SIZE
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:13
UpdateSignalsOnSegment
SigSegState UpdateSignalsOnSegment(TileIndex tile, DiagDirection side, Owner owner)
Update signals, starting at one side of a tile Will check tile next to this at opposite side too.
Definition: signal.cpp:636
SpecializedStation< Station, false >::Get
static Station * Get(size_t index)
Gets station with given index.
Definition: base_station_base.h:219
EV_STEAM_SMOKE
@ EV_STEAM_SMOKE
Smoke of steam engines.
Definition: effectvehicle_func.h:18
DirDifference
static DirDiff DirDifference(Direction d0, Direction d1)
Calculate the difference between two directions.
Definition: direction_func.h:68
Vehicle::~Vehicle
virtual ~Vehicle()
We want to 'destruct' the right class.
Definition: vehicle.cpp:866
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:52
GetRegister
static uint32 GetRegister(uint i)
Gets the value of a so-called newgrf "register".
Definition: newgrf_spritegroup.h:29
VehicleEnterDepot
void VehicleEnterDepot(Vehicle *v)
Vehicle entirely entered the depot, update its status, orders, vehicle windows, service it,...
Definition: vehicle.cpp:1473
VehicleLengthChanged
void VehicleLengthChanged(const Vehicle *u)
Logs a bug in GRF and shows a warning message if this is for the first time this happened.
Definition: vehicle.cpp:330
SpecializedStation< Station, false >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index is a valid index for station of this type.
Definition: base_station_base.h:210
WC_VEHICLE_TIMETABLE
@ WC_VEHICLE_TIMETABLE
Vehicle timetable; Window numbers:
Definition: window_type.h:216
VE_TYPE_COUNT
@ VE_TYPE_COUNT
Number of bits used for the effect type.
Definition: vehicle_base.h:83
newgrf_debug.h
TileY
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:215
Vehicle::GetConsistFreeCapacities
void GetConsistFreeCapacities(SmallMap< CargoID, uint > &capacities) const
Get a map of cargoes and free capacities in the consist.
Definition: vehicle.cpp:2344
ST_NORMAL
@ ST_NORMAL
The most basic (normal) sprite.
Definition: gfx_type.h:302
effectvehicle_base.h
GroundVehicle::IsRearDualheaded
bool IsRearDualheaded() const
Tell if we are dealing with the rear end of a multiheaded engine.
Definition: ground_vehicle.hpp:334
VS_TRAIN_SLOWING
@ VS_TRAIN_SLOWING
Train is slowing down.
Definition: vehicle_base.h:35
RandomRange
static uint32 RandomRange(uint32 limit)
Pick a random number between 0 and limit - 1, inclusive.
Definition: random_func.hpp:81
SND_3A_BREAKDOWN_TRAIN_SHIP_TOYLAND
@ SND_3A_BREAKDOWN_TRAIN_SHIP_TOYLAND
58 == 0x3A Breakdown: train or ship (toyland)
Definition: sound_type.h:97
Chance16I
static bool Chance16I(const uint a, const uint b, const uint32 r)
Checks if a given randomize-number is below a given probability.
Definition: random_func.hpp:112
WC_COMPANY
@ WC_COMPANY
Company view; Window numbers:
Definition: window_type.h:361
WC_STATION_VIEW
@ WC_STATION_VIEW
Station view; Window numbers:
Definition: window_type.h:337
DIR_W
@ DIR_W
West.
Definition: direction_type.h:32
OrderBackup::ClearVehicle
static void ClearVehicle(const Vehicle *v)
Clear/update the (clone) vehicle from an order backup.
Definition: order_backup.cpp:228
Vehicle::orders
union Vehicle::@49 orders
The orders currently assigned to the vehicle.
Engine
Definition: engine_base.h:27
MAX_VEHICLE_PIXEL_X
static const int MAX_VEHICLE_PIXEL_X
Maximum width of a vehicle in pixels in #ZOOM_LVL_BASE.
Definition: tile_type.h:19
MAX_DAY
#define MAX_DAY
The number of days till the last day.
Definition: date_type.h:98
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
CC_PASSENGERS
@ CC_PASSENGERS
Passengers.
Definition: cargotype.h:41
Vehicle::cur_speed
uint16 cur_speed
current speed
Definition: vehicle_base.h:304
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:221
Vehicle::IsPrimaryVehicle
virtual bool IsPrimaryVehicle() const
Whether this is the primary vehicle in the chain.
Definition: vehicle_base.h:446
Vehicle::IsGroundVehicle
bool IsGroundVehicle() const
Check if the vehicle is a ground vehicle.
Definition: vehicle_base.h:484
VehicleSpriteSeq::Draw
void Draw(int x, int y, PaletteID default_pal, bool force_pal) const
Draw the sprite sequence.
Definition: vehicle.cpp:126
Viewport::virtual_top
int virtual_top
Virtual top coordinate.
Definition: viewport_type.h:29
Vehicle::owner
Owner owner
Which company owns the vehicle?
Definition: vehicle_base.h:285
gamelog.h
Owner
Owner
Enum for all companies/owners.
Definition: company_type.h:18
VehicleCache::cached_cargo_age_period
uint16 cached_cargo_age_period
Number of ticks before carried cargo is aged.
Definition: vehicle_base.h:123
GetVehicleCallback
uint16 GetVehicleCallback(CallbackID callback, uint32 param1, uint32 param2, EngineID engine, const Vehicle *v)
Evaluate a newgrf callback for vehicles.
Definition: newgrf_engine.cpp:1155
DC_EXEC
@ DC_EXEC
execute the given command
Definition: command_type.h:348
VSE_VISUAL_EFFECT
@ VSE_VISUAL_EFFECT
Vehicle visual effect (steam, diesel smoke or electric spark) is shown.
Definition: newgrf_sound.h:24
DIR_N
@ DIR_N
North.
Definition: direction_type.h:26
GetEnginePalette
PaletteID GetEnginePalette(EngineID engine_type, CompanyID company)
Get the colour map for an engine.
Definition: vehicle.cpp:2038
CommandCost::GetErrorMessage
StringID GetErrorMessage() const
Returns the error message of a command.
Definition: command_type.h:140
IsLocalCompany
static bool IsLocalCompany()
Is the current company the local company?
Definition: company_func.h:43
DeleteVehicleOrders
void DeleteVehicleOrders(Vehicle *v, bool keep_orderlist, bool reset_order_indices)
Delete all orders from a vehicle.
Definition: order_cmd.cpp:1890
GetTargetAirportIfValid
Station * GetTargetAirportIfValid(const Aircraft *v)
Returns aircraft's target station if v->target_airport is a valid station with airport.
Definition: aircraft_cmd.cpp:2125
SetDParam
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings_func.h:196
VS_AIRCRAFT_BROKEN
@ VS_AIRCRAFT_BROKEN
Aircraft is broken down.
Definition: vehicle_base.h:37
DoCommandFlag
DoCommandFlag
List of flags for a command.
Definition: command_type.h:346
VehicleServiceInDepot
void VehicleServiceInDepot(Vehicle *v)
Service a vehicle and all subsequent vehicles in the consist.
Definition: vehicle.cpp:162
VE_OFFSET_START
@ VE_OFFSET_START
First bit that contains the offset (0 = front, 8 = centre, 15 = rear)
Definition: vehicle_base.h:78
EnsureNoVehicleOnGround
CommandCost EnsureNoVehicleOnGround(TileIndex tile)
Ensure there is no vehicle at the ground at the given position.
Definition: vehicle.cpp:539
Vehicle::breakdowns_since_last_service
byte breakdowns_since_last_service
Counter for the amount of breakdowns.
Definition: vehicle_base.h:277
AIR_SHADOW
@ AIR_SHADOW
shadow of the aircraft
Definition: aircraft.h:33
RVSB_IN_DT_ROAD_STOP
@ RVSB_IN_DT_ROAD_STOP
The vehicle is in a drive-through road stop.
Definition: roadveh.h:52
GRFBugs
GRFBugs
Encountered GRF bugs.
Definition: newgrf_config.h:43
CommandCost::Succeeded
bool Succeeded() const
Did this command succeed?
Definition: command_type.h:150
SND_35_BREAKDOWN_ROADVEHICLE_TOYLAND
@ SND_35_BREAKDOWN_ROADVEHICLE_TOYLAND
53 == 0x35 Breakdown: road vehicle (toyland)
Definition: sound_type.h:92
TileX
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:205
HandleAircraftEnterHangar
void HandleAircraftEnterHangar(Aircraft *v)
Handle Aircraft specific tasks when an Aircraft enters a hangar.
Definition: aircraft_cmd.cpp:561
GUISettings::vehicle_income_warn
bool vehicle_income_warn
if a vehicle isn't generating income, show a warning
Definition: settings_type.h:107
GroupStatistics::num_vehicle
uint16 num_vehicle
Number of vehicles.
Definition: group.h:26
SmallMap
Implementation of simple mapping class.
Definition: smallmap_type.hpp:26
ShowErrorMessage
void ShowErrorMessage(StringID summary_msg, StringID detailed_msg, WarningLevel wl, int x=0, int y=0, const GRFFile *textref_stack_grffile=nullptr, uint textref_stack_size=0, const uint32 *textref_stack=nullptr)
Display an error message in a window.
Definition: error_gui.cpp:383
IsDepotTile
static bool IsDepotTile(TileIndex tile)
Is the given tile a tile with a depot on it?
Definition: depot_map.h:41
GameSettings::game_creation
GameCreationSettings game_creation
settings used during the creation of a game (map)
Definition: settings_type.h:576
CheckClickOnVehicle
Vehicle * CheckClickOnVehicle(const Viewport *vp, int x, int y)
Find the vehicle close to the clicked coordinates.
Definition: vehicle.cpp:1202
Vehicle::IsArticulatedPart
bool IsArticulatedPart() const
Check if the vehicle is an articulated part of an engine.
Definition: vehicle_base.h:906
effectvehicle_func.h
SpecializedStation< Station, false >::Iterate
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
Returns an iterable ensemble of all valid stations of type T.
Definition: base_station_base.h:270
Airport::GetFTA
const AirportFTAClass * GetFTA() const
Get the finite-state machine for this airport or the finite-state machine for the dummy airport in ca...
Definition: station_base.h:329
ai.hpp
Order::MakeGoToDepot
void MakeGoToDepot(DepotID destination, OrderDepotTypeFlags order, OrderNonStopFlags non_stop_type=ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS, OrderDepotActionFlags action=ODATF_SERVICE_ONLY, CargoID cargo=CT_NO_REFIT)
Makes this order a Go To Depot order.
Definition: order_cmd.cpp:89
PFE_GL_TRAINS
@ PFE_GL_TRAINS
Time spent processing trains.
Definition: framerate_type.h:51
EC_ELECTRIC
@ EC_ELECTRIC
Electric rail engine.
Definition: engine_type.h:36
Order::GetType
OrderType GetType() const
Get the type of order of this order.
Definition: order_base.h:70
IsInsideMM
static bool IsInsideMM(const T x, const size_t min, const size_t max)
Checks if a value is in an interval.
Definition: math_func.hpp:204
VehicleCargoList
CargoList that is used for vehicles.
Definition: cargopacket.h:269
Aircraft
Aircraft, helicopters, rotors and their shadows belong to this class.
Definition: aircraft.h:74
InsertOrder
void InsertOrder(Vehicle *v, Order *new_o, VehicleOrderID sel_ord)
Insert a new order but skip the validation.
Definition: order_cmd.cpp:927
Ship::UpdateCache
void UpdateCache()
Update the caches of this ship.
Definition: ship_cmd.cpp:202
VF_STOP_LOADING
@ VF_STOP_LOADING
Don't load anymore during the next load cycle.
Definition: vehicle_base.h:49
VE_TYPE_DIESEL
@ VE_TYPE_DIESEL
Diesel fumes.
Definition: vehicle_base.h:86
ONSF_NO_STOP_AT_ANY_STATION
@ ONSF_NO_STOP_AT_ANY_STATION
The vehicle will not stop at any stations it passes including the destination.
Definition: order_type.h:76
GetGrfSpecFeature
GrfSpecFeature GetGrfSpecFeature(TileIndex tile)
Get the GrfSpecFeature associated with the tile.
Definition: newgrf_debug_gui.cpp:768
Engine::GetGRF
const GRFFile * GetGRF() const
Retrieve the NewGRF the engine is tied to.
Definition: engine_base.h:142
GoodsEntry::cargo
StationCargoList cargo
The cargo packets of cargo waiting in this station.
Definition: station_base.h:252
ShipVehicleInfo::visual_effect
byte visual_effect
Bitstuffed NewGRF visual effect data.
Definition: engine_type.h:74
VESM_STEAM
@ VESM_STEAM
Steam model.
Definition: vehicle_base.h:99
Group
Group data.
Definition: group.h:72
SetWindowWidgetDirty
void SetWindowWidgetDirty(WindowClass cls, WindowNumber number, byte widget_index)
Mark a particular widget in a particular window as dirty (in need of repainting)
Definition: window.cpp:3133
EC_MAGLEV
@ EC_MAGLEV
Maglev engine.
Definition: engine_type.h:38
SND_10_BREAKDOWN_TRAIN_SHIP
@ SND_10_BREAKDOWN_TRAIN_SHIP
14 == 0x0E Breakdown: train or ship (non-toyland)
Definition: sound_type.h:53
VRF_LEAVING_STATION
@ VRF_LEAVING_STATION
Train is just leaving a station.
Definition: train.h:33
GameSettings::order
OrderSettings order
settings related to orders
Definition: settings_type.h:583
Pool::PoolItem<&_vehicle_pool >::GetPoolSize
static size_t GetPoolSize()
Returns first unused index.
Definition: pool_type.hpp:358
Order::GetNonStopType
OrderNonStopFlags GetNonStopType() const
At which stations must we stop?
Definition: order_base.h:134
Vehicle::BeginLoading
void BeginLoading()
Prepare everything to begin the loading when arriving at a station.
Definition: vehicle.cpp:2099
FACIL_BUS_STOP
@ FACIL_BUS_STOP
Station with bus stops.
Definition: station_type.h:54
GRFConfig::grf_bugs
uint32 grf_bugs
NOSAVE: bugs in this GRF in this run,.
Definition: newgrf_config.h:175
RailVehicleInfo::visual_effect
byte visual_effect
Bitstuffed NewGRF visual effect data.
Definition: engine_type.h:57
Vehicle::breakdown_ctr
byte breakdown_ctr
Counter for managing breakdown events.
Definition: vehicle_base.h:275
VS_HIDDEN
@ VS_HIDDEN
Vehicle is not visible.
Definition: vehicle_base.h:31
EngineID
uint16 EngineID
Unique identification number of an engine.
Definition: engine_type.h:21
Vehicle::UpdateVisualEffect
void UpdateVisualEffect(bool allow_power_change=true)
Update the cached visual effect.
Definition: vehicle.cpp:2453
Viewport
Data structure for viewport, display of a part of the world.
Definition: viewport_type.h:22
RailVehicleInfo::engclass
EngineClass engclass
Class of engine for this vehicle.
Definition: engine_type.h:52
CheckOwnership
CommandCost CheckOwnership(Owner owner, TileIndex tile)
Check whether the current owner owns something.
Definition: company_cmd.cpp:311
VehicleSpriteSeq::IsValid
bool IsValid() const
Check whether the sequence contains any sprites.
Definition: vehicle_base.h:146
Vehicle::dest_tile
TileIndex dest_tile
Heading for this tile.
Definition: vehicle_base.h:249
Vehicle::HandlePathfindingResult
void HandlePathfindingResult(bool path_found)
Handle the pathfinding result, especially the lost status.
Definition: vehicle.cpp:773
Vehicle::GetDisplayProfitThisYear
Money GetDisplayProfitThisYear() const
Gets the profit vehicle had this year.
Definition: vehicle_base.h:579
return_cmd_error
#define return_cmd_error(errcode)
Returns from a function with a specific StringID as error.
Definition: command_func.h:33
VE_TYPE_START
@ VE_TYPE_START
First bit used for the type of effect.
Definition: vehicle_base.h:82
TO_INVALID
@ TO_INVALID
Invalid transparency option.
Definition: transparency.h:33
GroundVehicleCache
Cached, frequently calculated values.
Definition: ground_vehicle.hpp:29
INVALID_GROUP
static const GroupID INVALID_GROUP
Sentinel for invalid groups.
Definition: group_type.h:18
CompanySettings::engine_renew
bool engine_renew
is autorenew enabled
Definition: settings_type.h:566
Order::GetRefitCargo
CargoID GetRefitCargo() const
Get the cargo to to refit to.
Definition: order_base.h:125
timetable.h
AI::NewEvent
static void NewEvent(CompanyID company, ScriptEvent *event)
Queue a new event for an AI.
Definition: ai_core.cpp:234
CalcPercentVehicleFilled
uint8 CalcPercentVehicleFilled(const Vehicle *front, StringID *colour)
Calculates how full a vehicle is.
Definition: vehicle.cpp:1414
CommandCost
Common return value for all commands.
Definition: command_type.h:23
ONSF_STOP_EVERYWHERE
@ ONSF_STOP_EVERYWHERE
The vehicle will stop at any station it passes and the destination.
Definition: order_type.h:73
_date
Date _date
Current date in days (day counter)
Definition: date.cpp:28
Vehicle::UpdateBoundingBoxCoordinates
void UpdateBoundingBoxCoordinates(bool update_cache) const
Update the bounding box co-ordinates of the vehicle.
Definition: vehicle.cpp:1605
VehicleCargoList::Truncate
uint Truncate(uint max_move=UINT_MAX)
Truncates the cargo in this list to the given amount.
Definition: cargopacket.cpp:654
Vehicle::GetCurrentMaxSpeed
virtual int GetCurrentMaxSpeed() const
Calculates the maximum speed of the vehicle under its current conditions.
Definition: vehicle_base.h:505
WC_VEHICLE_VIEW
@ WC_VEHICLE_VIEW
Vehicle view; Window numbers:
Definition: window_type.h:331
FreeUnitIDGenerator::NextID
UnitID NextID()
Returns next free UnitID.
Definition: vehicle.cpp:1778
Vehicle::AddToShared
void AddToShared(Vehicle *shared_chain)
Adds this vehicle to a shared vehicle chain.
Definition: vehicle.cpp:2755
GRFConfig
Information about GRF, used in the game and (part of it) in savegames.
Definition: newgrf_config.h:155
LIT_ALL
static const byte LIT_ALL
Show the liveries of all companies.
Definition: livery.h:17
CMD_PAUSE
@ CMD_PAUSE
pause the game
Definition: command_type.h:256
VehicleCargoList::AgeCargo
void AgeCargo()
Ages the all cargo in this list.
Definition: cargopacket.cpp:381
EngineInfo::callback_mask
byte callback_mask
Bitmask of vehicle callbacks that have to be called.
Definition: engine_type.h:144
DIR_E
@ DIR_E
East.
Definition: direction_type.h:28
Viewport::virtual_left
int virtual_left
Virtual left coordinate.
Definition: viewport_type.h:28
Vehicle::RemoveFromShared
void RemoveFromShared()
Removes the vehicle from the shared order list.
Definition: vehicle.cpp:2778
VF_CARGO_UNLOADING
@ VF_CARGO_UNLOADING
Vehicle is unloading cargo.
Definition: vehicle_base.h:44
VehicleSettings::max_ships
UnitID max_ships
max ships in game per company
Definition: settings_type.h:487
roadstop_base.h
EV_BREAKDOWN_SMOKE_AIRCRAFT
@ EV_BREAKDOWN_SMOKE_AIRCRAFT
Smoke of broken aircraft.
Definition: effectvehicle_func.h:27
GoodsEntry::HasRating
bool HasRating() const
Does this cargo have a rating at this station?
Definition: station_base.h:270
Vehicle::tile
TileIndex tile
Current tile index.
Definition: vehicle_base.h:242
Vehicle::CancelReservation
void CancelReservation(StationID next, Station *st)
Return all reserved cargo packets to the station and reset all packets staged for transfer.
Definition: vehicle.cpp:2230
EIT_ON_MAP
@ EIT_ON_MAP
Vehicle drawn in viewport.
Definition: vehicle_type.h:86
Station::MarkTilesDirty
void MarkTilesDirty(bool cargo_change) const
Marks the tiles of the station as dirty.
Definition: station.cpp:217
Viewport::left
int left
Screen coordinate left edge of the viewport.
Definition: viewport_type.h:23
Vehicle::engine_type
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:299
HasAnyRailtypesAvail
bool HasAnyRailtypesAvail(const CompanyID company)
Test if any buildable railtype is available for a company.
Definition: rail.cpp:196
DoDrawVehicle
static void DoDrawVehicle(const Vehicle *v)
Add vehicle sprite for drawing to the screen.
Definition: vehicle.cpp:1078
GroundVehicleCache::cached_veh_length
uint8 cached_veh_length
Length of this vehicle in units of 1/VEHICLE_LENGTH of normal length. It is cached because this can b...
Definition: ground_vehicle.hpp:44
VS_CRASHED
@ VS_CRASHED
Vehicle is crashed.
Definition: vehicle_base.h:38
VehicleSpriteSeq
Sprite sequence for a vehicle part.
Definition: vehicle_base.h:129
SB
static T SB(T &x, const uint8 s, const uint8 n, const U d)
Set n bits in x starting at bit s to d.
Definition: bitmath_func.hpp:58
RoadVehicleInfo::visual_effect
byte visual_effect
Bitstuffed NewGRF visual effect data.
Definition: engine_type.h:124
Vehicle::last_station_visited
StationID last_station_visited
The last station we stopped at.
Definition: vehicle_base.h:313
CompanyProperties::money
Money money
Money owned by the company.
Definition: company_base.h:66
GetFreeUnitNumber
UnitID GetFreeUnitNumber(VehicleType type)
Get an unused unit number for a vehicle (if allowed).
Definition: vehicle.cpp:1792
PFE_GL_SHIPS
@ PFE_GL_SHIPS
Time spent processing ships.
Definition: framerate_type.h:53
EF_USES_2CC
@ EF_USES_2CC
Vehicle uses two company colours.
Definition: engine_type.h:156
Vehicle::cargo
VehicleCargoList cargo
The cargo this vehicle is carrying.
Definition: vehicle_base.h:320
CBID_VEHICLE_SPAWN_VISUAL_EFFECT
@ CBID_VEHICLE_SPAWN_VISUAL_EFFECT
Called to spawn visual effects for vehicles.
Definition: newgrf_callbacks.h:281
CommandCost::Failed
bool Failed() const
Did this command fail?
Definition: command_type.h:159
Vehicle::hash_tile_current
Vehicle ** hash_tile_current
NOSAVE: Cache of the current hash chain.
Definition: vehicle_base.h:264
CCF_ARRANGE
@ CCF_ARRANGE
Valid changes for arranging the consist in a depot.
Definition: train.h:52
Vehicle::current_order
Order current_order
The current order (+ status, like: loading)
Definition: vehicle_base.h:329
IsInvisibilitySet
static bool IsInvisibilitySet(TransparencyOption to)
Check if the invisibility option bit is set and if we aren't in the game menu (there's never transpar...
Definition: transparency.h:59
IncreaseStats
void IncreaseStats(Station *st, CargoID cargo, StationID next_station_id, uint capacity, uint usage, uint32 time, EdgeUpdateMode mode)
Increase capacity for a link stat given by station cargo and next hop.
Definition: station_cmd.cpp:3740
Vehicle::max_age
Date max_age
Maximum age.
Definition: vehicle_base.h:271
Station::airport
Airport airport
Tile area the airport covers.
Definition: station_base.h:461
HasAnyRoadTypesAvail
bool HasAnyRoadTypesAvail(CompanyID company, RoadTramType rtt)
Test if any buildable RoadType is available for a company.
Definition: road.cpp:132
GroundVehicle::gcache
GroundVehicleCache gcache
Cache of often calculated values.
Definition: ground_vehicle.hpp:80
EC_DIESEL
@ EC_DIESEL
Diesel rail engine.
Definition: engine_type.h:35
AirportFTAClass::layout
struct AirportFTA * layout
state machine for airport
Definition: airport.h:177
DIR_NE
@ DIR_NE
Northeast.
Definition: direction_type.h:27
VEH_EFFECT
@ VEH_EFFECT
Effect vehicle type (smoke, explosions, sparks, bubbles)
Definition: vehicle_type.h:31
EndSpriteCombine
void EndSpriteCombine()
Terminates a block of sprites started by StartSpriteCombine.
Definition: viewport.cpp:771
VehicleListIdentifier::Pack
uint32 Pack() const
Pack a VehicleListIdentifier in a single uint32.
Definition: vehiclelist.cpp:21
CompanySettings::engine_renew_months
int16 engine_renew_months
months before/after the maximum vehicle age a vehicle should be renewed
Definition: settings_type.h:567
AirportFTAClass::flags
Flags flags
Flags for this airport type.
Definition: airport.h:180
LIT_COMPANY
static const byte LIT_COMPANY
Show the liveries of your own company.
Definition: livery.h:16
Vehicle::IsFrontEngine
bool IsFrontEngine() const
Check if the vehicle is a front engine.
Definition: vehicle_base.h:897
DeleteOrder
void DeleteOrder(Vehicle *v, VehicleOrderID sel_ord)
Delete an order but skip the parameter validation.
Definition: order_cmd.cpp:1054
Vehicle::GetLastOrder
Order * GetLastOrder() const
Returns the last order of a vehicle, or nullptr if it doesn't exists.
Definition: vehicle_base.h:883
ODATFB_NEAREST_DEPOT
@ ODATFB_NEAREST_DEPOT
Send the vehicle to the nearest depot.
Definition: order_type.h:105
FreeUnitIDGenerator
Generates sequence of free UnitID numbers.
Definition: vehicle_base.h:1237
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:53
VehicleFromPos
static Vehicle * VehicleFromPos(TileIndex tile, void *data, VehicleFromPosProc *proc, bool find_first)
Helper function for FindVehicleOnPos/HasVehicleOnPos.
Definition: vehicle.cpp:469
Livery::in_use
byte in_use
Bit 0 set if this livery should override the default livery first colour, Bit 1 for the second colour...
Definition: livery.h:79
CompanyProperties::settings
CompanySettings settings
settings specific for each company
Definition: company_base.h:104
WC_VEHICLE_DETAILS
@ WC_VEHICLE_DETAILS
Vehicle details; Window numbers:
Definition: window_type.h:192
AirportFTA
Internal structure used in openttd - Finite sTate mAchine --> FTA.
Definition: airport.h:190
CompanySettings::engine_renew_money
uint32 engine_renew_money
minimum amount of money before autorenew is used
Definition: settings_type.h:568
VS_STOPPED
@ VS_STOPPED
Vehicle is stopped by the player.
Definition: vehicle_base.h:32
Vehicle::trip_occupancy
int8 trip_occupancy
NOSAVE: Occupancy of vehicle of the current trip (updated after leaving a station).
Definition: vehicle_base.h:322
Vehicle::GetGRFID
uint32 GetGRFID() const
Retrieve the GRF ID of the NewGRF the vehicle is tied to.
Definition: vehicle.cpp:761
IsArticulatedVehicleCarryingDifferentCargoes
bool IsArticulatedVehicleCarryingDifferentCargoes(const Vehicle *v, CargoID *cargo_type)
Tests if all parts of an articulated vehicle are refitted to the same cargo.
Definition: articulated_vehicles.cpp:283
Vehicle::ShowVisualEffect
void ShowVisualEffect() const
Draw visual effects (smoke and/or sparks) for a vehicle chain.
Definition: vehicle.cpp:2576
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:46
Vehicle::GetEngine
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
Definition: vehicle.cpp:741
VisualEffectSpawnModel
VisualEffectSpawnModel
Models for spawning visual effects.
Definition: vehicle_base.h:97
safeguards.h
GroupStatistics::UpdateAutoreplace
static void UpdateAutoreplace(CompanyID company)
Update autoreplace_defined and autoreplace_finished of all statistics of a company.
Definition: group_cmd.cpp:204
VehicleFromPosXY
static Vehicle * VehicleFromPosXY(int x, int y, void *data, VehicleFromPosProc *proc, bool find_first)
Helper function for FindVehicleOnPos/HasVehicleOnPos.
Definition: vehicle.cpp:411
GetNewVehiclePosResult::new_tile
TileIndex new_tile
Tile of the vehicle after moving.
Definition: vehicle_func.h:78
EF_RAIL_IS_MU
@ EF_RAIL_IS_MU
Rail vehicle is a multiple-unit (DMU/EMU)
Definition: engine_type.h:157
Sprite::width
uint16 width
Width of the sprite.
Definition: spritecache.h:19
Vehicle::ResetRefitCaps
void ResetRefitCaps()
Reset all refit_cap in the consist to cargo_cap.
Definition: vehicle.cpp:2299
Vehicle::reliability_spd_dec
uint16 reliability_spd_dec
Reliability decrease speed.
Definition: vehicle_base.h:274
Vehicle::UpdateViewport
void UpdateViewport(bool dirty)
Update the vehicle on the viewport, updating the right hash and setting the new coordinates.
Definition: vehicle.cpp:1638
Vehicle::last_loading_station
StationID last_loading_station
Last station the vehicle has stopped at and could possibly leave from with any cargo loaded.
Definition: vehicle_base.h:314
Train
'Train' is either a loco or a wagon.
Definition: train.h:86
Airport::flags
uint64 flags
stores which blocks on the airport are taken. was 16 bit earlier on, then 32
Definition: station_base.h:305
CommandCost::GetCost
Money GetCost() const
The costs as made up to this moment.
Definition: command_type.h:82
DEFAULT_GROUP
static const GroupID DEFAULT_GROUP
Ungrouped vehicles are in this group.
Definition: group_type.h:17
VehicleCargoList::SetTransferLoadPlace
void SetTransferLoadPlace(TileIndex xy)
Sets loaded_at_xy to the current station for all cargo to be transferred.
Definition: cargopacket.cpp:400
Vehicle::previous_shared
Vehicle * previous_shared
NOSAVE: pointer to the previous vehicle in the shared order chain.
Definition: vehicle_base.h:231
DeleteDepotHighlightOfVehicle
void DeleteDepotHighlightOfVehicle(const Vehicle *v)
Removes the highlight of a vehicle in a depot window.
Definition: depot_gui.cpp:1123
WC_SHIPS_LIST
@ WC_SHIPS_LIST
Ships list; Window numbers:
Definition: window_type.h:312
DIR_S
@ DIR_S
South.
Definition: direction_type.h:30
DepotCommand
DepotCommand
Flags to add to p1 for goto depot commands.
Definition: vehicle_type.h:65
Vehicle::profit_this_year
Money profit_this_year
Profit this year << 8, low 8 bits are fract.
Definition: vehicle_base.h:251
ODTFB_PART_OF_ORDERS
@ ODTFB_PART_OF_ORDERS
This depot order is because of a regular order.
Definition: order_type.h:96
_networking
bool _networking
are we in networking mode?
Definition: network.cpp:56
StartSpriteCombine
void StartSpriteCombine()
Starts a block of sprites, which are "combined" into a single bounding box.
Definition: viewport.cpp:761
VRF_REVERSE_DIRECTION
@ VRF_REVERSE_DIRECTION
Reverse the visible direction of the vehicle.
Definition: train.h:28
INVALID_DIAGDIR
@ INVALID_DIAGDIR
Flag for an invalid DiagDirection.
Definition: direction_type.h:84
DrawSprite
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
Draw a sprite, not in a viewport.
Definition: gfx.cpp:1041
Vehicle::MarkAllViewportsDirty
bool MarkAllViewportsDirty() const
Marks viewports dirty where the vehicle's image is.
Definition: vehicle.cpp:1677
Vehicle::PlayLeaveStationSound
virtual void PlayLeaveStationSound() const
Play the sound associated with leaving the station.
Definition: vehicle_base.h:441
VehicleCargoList::KeepAll
void KeepAll()
Marks all cargo in the vehicle as to be kept.
Definition: cargopacket.h:408
GroupStatistics::VehicleReachedProfitAge
static void VehicleReachedProfitAge(const Vehicle *v)
Add a vehicle to the profit sum of its group.
Definition: group_cmd.cpp:166
SRT_TRAIN_DEPARTS
@ SRT_TRAIN_DEPARTS
Trigger platform when train leaves.
Definition: newgrf_station.h:107
VehicleCache::cached_vis_effect
byte cached_vis_effect
Visual effect to show (see VisualEffect)
Definition: vehicle_base.h:125
Vehicle::FindClosestDepot
virtual bool FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse)
Find the closest depot for this vehicle and tell us the location, DestinationID and whether we should...
Definition: vehicle_base.h:763
Point
Coordinates of a point in 2D.
Definition: geometry_type.hpp:21
error.h
DirDiff
DirDiff
Enumeration for the difference between two directions.
Definition: direction_type.h:62
WC_TRAINS_LIST
@ WC_TRAINS_LIST
Trains list; Window numbers:
Definition: window_type.h:300
Vehicle::HandleLoading
void HandleLoading(bool mode=false)
Handle the loading of the vehicle; when not it skips through dummy orders and does nothing in all oth...
Definition: vehicle.cpp:2309
PFE_GL_AIRCRAFT
@ PFE_GL_AIRCRAFT
Time spent processing aircraft.
Definition: framerate_type.h:54
FACIL_DOCK
@ FACIL_DOCK
Station with a dock.
Definition: station_type.h:56
CreateEffectVehicleRel
EffectVehicle * CreateEffectVehicleRel(const Vehicle *v, int x, int y, int z, EffectVehicleType type)
Create an effect vehicle above a particular vehicle.
Definition: effectvehicle.cpp:638
Vehicle::HasDepotOrder
bool HasDepotOrder() const
Checks if a vehicle has a depot in its order list.
Definition: order_cmd.cpp:1872
DAYS_IN_LEAP_YEAR
static const int DAYS_IN_LEAP_YEAR
sometimes, you need one day more...
Definition: date_type.h:30
date_func.h
IsRailStationTile
static bool IsRailStationTile(TileIndex t)
Is this tile a station tile and a rail station?
Definition: station_map.h:102
GUISettings::show_track_reservation
bool show_track_reservation
highlight reserved tracks.
Definition: settings_type.h:155
stdafx.h
ShowNewGrfVehicleError
void ShowNewGrfVehicleError(EngineID engine, StringID part1, StringID part2, GRFBugs bug_type, bool critical)
Displays a "NewGrf Bug" error message for a engine, and pauses the game if not networking.
Definition: vehicle.cpp:297
ShowCostOrIncomeAnimation
void ShowCostOrIncomeAnimation(int x, int y, int z, Money cost)
Display animated income or costs on the map.
Definition: misc_gui.cpp:573
BaseConsist::vehicle_flags
uint16 vehicle_flags
Used for gradual loading and other miscellaneous things (.
Definition: base_consist.h:31
Vehicle::SendToDepot
CommandCost SendToDepot(DoCommandFlag flags, DepotCommand command)
Send this vehicle to the depot using the given command(s).
Definition: vehicle.cpp:2372
WID_VV_START_STOP
@ WID_VV_START_STOP
Start or stop this vehicle, and show information about the current state.
Definition: vehicle_widget.h:17
Vehicle::sprite_cache
MutableSpriteCache sprite_cache
Cache of sprites and values related to recalculating them, see MutableSpriteCache.
Definition: vehicle_base.h:343
VehicleType
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
RoadStop::Leave
void Leave(RoadVehicle *rv)
Leave the road stop.
Definition: roadstop.cpp:216
VE_TYPE_DEFAULT
@ VE_TYPE_DEFAULT
Use default from engine class.
Definition: vehicle_base.h:84
EngineInfo::misc_flags
byte misc_flags
Miscellaneous flags.
Definition: engine_type.h:143
Vehicle::y_offs
int8 y_offs
y offset for vehicle sprite
Definition: vehicle_base.h:298
viewport_func.h
Vehicle::colourmap
SpriteID colourmap
NOSAVE: cached colour mapping.
Definition: vehicle_base.h:266
GetVehicleTunnelBridgeProc
static Vehicle * GetVehicleTunnelBridgeProc(Vehicle *v, void *data)
Procedure called for every vehicle found in tunnel/bridge in the hash map.
Definition: vehicle.cpp:553
CanBuildVehicleInfrastructure
bool CanBuildVehicleInfrastructure(VehicleType type, byte subtype)
Check whether we can build infrastructure for the given vehicle type.
Definition: vehicle.cpp:1821
bridge_map.h
IsTileType
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
VESM_DIESEL
@ VESM_DIESEL
Diesel model.
Definition: vehicle_base.h:100
RAILVEH_WAGON
@ RAILVEH_WAGON
simple wagon, not motorized
Definition: engine_type.h:29
SetDepotReservation
static void SetDepotReservation(TileIndex t, bool b)
Set the reservation state of the depot.
Definition: rail_map.h:270
ODATFB_HALT
@ ODATFB_HALT
Service the vehicle and then halt it.
Definition: order_type.h:104
WC_VEHICLE_REFIT
@ WC_VEHICLE_REFIT
Vehicle refit; Window numbers:
Definition: window_type.h:198
_returned_refit_capacity
uint _returned_refit_capacity
Stores the capacity after a refit operation.
Definition: vehicle.cpp:85
Vehicle::IncrementRealOrderIndex
void IncrementRealOrderIndex()
Advanced cur_real_order_index to the next real order, keeps care of the wrap-around and invalidates t...
Definition: vehicle_base.h:838
AddSortableSpriteToDraw
void AddSortableSpriteToDraw(SpriteID image, PaletteID pal, int x, int y, int w, int h, int dz, int z, bool transparent, int bb_offset_x, int bb_offset_y, int bb_offset_z, const SubSprite *sub)
Draw a (transparent) sprite at given coordinates with a given bounding box.
Definition: viewport.cpp:665
DifficultySettings::vehicle_breakdowns
byte vehicle_breakdowns
likelihood of vehicles breaking down
Definition: settings_type.h:81
Vehicle::direction
Direction direction
facing
Definition: vehicle_base.h:283
FreeUnitIDGenerator::cache
bool * cache
array of occupied unit id numbers
Definition: vehicle_base.h:1238
TRACK_BIT_DEPOT
@ TRACK_BIT_DEPOT
Bitflag for a depot.
Definition: track_type.h:56
MarkAllViewportsDirty
bool MarkAllViewportsDirty(int left, int top, int right, int bottom)
Mark all viewports that display an area as dirty (in need of repaint).
Definition: viewport.cpp:1952
Vehicle::list
OrderList * list
Pointer to the order list for this vehicle.
Definition: vehicle_base.h:332
VehicleEnteredDepotThisTick
void VehicleEnteredDepotThisTick(Vehicle *v)
Adds a vehicle to the list of vehicles that visited a depot this tick.
Definition: vehicle.cpp:892
BaseConsist::cur_real_order_index
VehicleOrderID cur_real_order_index
The index to the current real (non-implicit) order.
Definition: base_consist.h:28
CBID_VEHICLE_COLOUR_MAPPING
@ CBID_VEHICLE_COLOUR_MAPPING
Called to determine if a specific colour map should be used for a vehicle instead of the default live...
Definition: newgrf_callbacks.h:126
GetWindowClassForVehicleType
static WindowClass GetWindowClassForVehicleType(VehicleType vt)
Get WindowClass for vehicle list of given vehicle type.
Definition: vehicle_gui.h:91
RunVehicleDayProc
static void RunVehicleDayProc()
Increases the day counter for all vehicles and calls 1-day and 32-day handlers.
Definition: vehicle.cpp:910
Vehicle::next_shared
Vehicle * next_shared
pointer to the next vehicle that shares the order
Definition: vehicle_base.h:230
spritecache.h
ReverseDir
static Direction ReverseDir(Direction d)
Return the reverse of a direction.
Definition: direction_func.h:54
Vehicle::FirstShared
Vehicle * FirstShared() const
Get the first vehicle of this vehicle chain.
Definition: vehicle_base.h:688
Vehicle::x_extent
byte x_extent
x-extent of vehicle bounding box
Definition: vehicle_base.h:292
Train::wait_counter
uint16 wait_counter
Ticks waiting in front of a signal, ticks being stuck or a counter for forced proceeding through sign...
Definition: train.h:101
CALLBACK_FAILED
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
Definition: newgrf_callbacks.h:404
StringID
uint32 StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
Vehicle::vcache
VehicleCache vcache
Cache of often used vehicle values.
Definition: vehicle_base.h:341
Ship
All ships have this type.
Definition: ship.h:26
PALETTE_RECOLOUR_START
static const PaletteID PALETTE_RECOLOUR_START
First recolour sprite for company colours.
Definition: sprites.h:1569
TransparencyOption
TransparencyOption
Transparency option bits: which position in _transparency_opt stands for which transparency.
Definition: transparency.h:22
LoadUnloadStation
void LoadUnloadStation(Station *st)
Load/unload the vehicles in this station according to the order they entered.
Definition: economy.cpp:1918
Vehicle::motion_counter
uint32 motion_counter
counter to occasionally play a vehicle sound.
Definition: vehicle_base.h:307
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:47
vehicle_func.h
DEPOT_SERVICE
@ DEPOT_SERVICE
The vehicle will leave the depot right after arrival (service only)
Definition: vehicle_type.h:66
station_base.h
newgrf_sound.h
VESM_NONE
@ VESM_NONE
No visual effect.
Definition: vehicle_base.h:98
MutableSpriteCache::revalidate_before_draw
bool revalidate_before_draw
We need to do a GetImage() and check bounds before drawing this sprite.
Definition: vehicle_base.h:191
VEHICLE_LENGTH
static const uint VEHICLE_LENGTH
The length of a vehicle in tile units.
Definition: vehicle_type.h:76
DeleteGroupHighlightOfVehicle
void DeleteGroupHighlightOfVehicle(const Vehicle *v)
Removes the highlight of a vehicle in a group window.
Definition: group_gui.cpp:1169
PALETTE_CRASH
static const PaletteID PALETTE_CRASH
Recolour sprite greying of crashed vehicles.
Definition: sprites.h:1600
Pool::PoolItem<&_vehicle_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:386
strings_func.h
Vehicle::hash_viewport_next
Vehicle * hash_viewport_next
NOSAVE: Next vehicle in the visual location hash.
Definition: vehicle_base.h:259
Pool
Base class for all pools.
Definition: pool_type.hpp:81
Vehicle::First
Vehicle * First() const
Get the first vehicle of this vehicle chain.
Definition: vehicle_base.h:607
OrderSettings::no_servicing_if_no_breakdowns
bool no_servicing_if_no_breakdowns
don't send vehicles to depot when breakdowns are disabled
Definition: settings_type.h:470
ScaleByZoom
static int ScaleByZoom(int value, ZoomLevel zoom)
Scale by zoom level, usually shift left (when zoom > ZOOM_LVL_NORMAL) When shifting right,...
Definition: zoom_func.h:22
Vehicle::cargo_age_counter
uint16 cargo_age_counter
Ticks till cargo is aged next.
Definition: vehicle_base.h:321
Vehicle::tick_counter
byte tick_counter
Increased by one for each tick.
Definition: vehicle_base.h:325
EnsureNoTrainOnTrackBits
CommandCost EnsureNoTrainOnTrackBits(TileIndex tile, TrackBits track_bits)
Tests if a vehicle interacts with the specified track bits.
Definition: vehicle.cpp:601
Vehicle::cargo_cap
uint16 cargo_cap
total capacity
Definition: vehicle_base.h:318
GroundVehicleCache::cached_power
uint32 cached_power
Total power of the consist (valid only for the first engine).
Definition: ground_vehicle.hpp:38
PFE_GL_ECONOMY
@ PFE_GL_ECONOMY
Time spent processing cargo movement.
Definition: framerate_type.h:50
VehicleSettings::max_trains
UnitID max_trains
max trains in game per company
Definition: settings_type.h:484
refresh.h
Vehicle::IncrementImplicitOrderIndex
void IncrementImplicitOrderIndex()
Increments cur_implicit_order_index, keeps care of the wrap-around and invalidates the GUI.
Definition: vehicle_base.h:814
Vehicle::x_offs
int8 x_offs
x offset for vehicle sprite
Definition: vehicle_base.h:297
CBM_VEHICLE_VISUAL_EFFECT
@ CBM_VEHICLE_VISUAL_EFFECT
Visual effects and wagon power (trains, road vehicles and ships)
Definition: newgrf_callbacks.h:289
Backup::Restore
void Restore()
Restore the variable.
Definition: backup_type.hpp:112
GroupStatistics::UpdateProfits
static void UpdateProfits()
Recompute the profits for all groups.
Definition: group_cmd.cpp:180
FACIL_TRAIN
@ FACIL_TRAIN
Station with train station.
Definition: station_type.h:52
SpecializedVehicle< Train, Type >::From
static Train * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Definition: vehicle_base.h:1164
OrderList::AddVehicle
void AddVehicle(Vehicle *v)
Adds the given vehicle to this shared order list.
Definition: order_base.h:357
DIRDIFF_45RIGHT
@ DIRDIFF_45RIGHT
Angle of 45 degrees right.
Definition: direction_type.h:64
GetVehiclePalette
PaletteID GetVehiclePalette(const Vehicle *v)
Get the colour map for a vehicle.
Definition: vehicle.cpp:2048
Train::ConsistChanged
void ConsistChanged(ConsistChangeFlags allowed_changes)
Recalculates the cached stuff of a train.
Definition: train_cmd.cpp:106
Vehicle::z_extent
byte z_extent
z-extent of vehicle bounding box
Definition: vehicle_base.h:294
VehicleRandomBits
byte VehicleRandomBits()
Get a value for a vehicle's random_bits.
Definition: vehicle.cpp:363
OUFB_NO_UNLOAD
@ OUFB_NO_UNLOAD
Totally no unloading will be done.
Definition: order_type.h:56
PaletteID
uint32 PaletteID
The number of the palette.
Definition: gfx_type.h:18
FreeUnitIDGenerator::maxid
UnitID maxid
maximum ID at the moment of constructor call
Definition: vehicle_base.h:1239
framerate_type.h
InvalidateWindowClassesData
void InvalidateWindowClassesData(WindowClass cls, int data, bool gui_scope)
Mark window data of all windows of a given class as invalid (in need of re-computing) Note that by de...
Definition: window.cpp:3235
EffectVehicleType
EffectVehicleType
Effect vehicle types.
Definition: effectvehicle_func.h:16
Aircraft::IsNormalAircraft
bool IsNormalAircraft() const
Check if the aircraft type is a normal flying device; eg not a rotor or a shadow.
Definition: aircraft.h:121
OrderList
Shared order list linking together the linked list of orders and the list of vehicles sharing this or...
Definition: order_base.h:253
GroundVehicle::IsEngine
bool IsEngine() const
Check if a vehicle is an engine (can be first in a consist).
Definition: ground_vehicle.hpp:316
CMD_AUTOREPLACE_VEHICLE
@ CMD_AUTOREPLACE_VEHICLE
replace/renew a vehicle while it is in a depot
Definition: command_type.h:317
SAT_TRAIN_DEPARTS
@ SAT_TRAIN_DEPARTS
Trigger platform when train leaves.
Definition: newgrf_animation_type.h:31
Vehicle::cargo_payment
CargoPayment * cargo_payment
The cargo payment we're currently in.
Definition: vehicle_base.h:255
Pool::PoolItem<&_vehicle_pool >::CleaningPool
static bool CleaningPool()
Returns current state of pool cleaning - yes or no.
Definition: pool_type.hpp:316
GetEngineLiveryScheme
LiveryScheme GetEngineLiveryScheme(EngineID engine_type, EngineID parent_engine_type, const Vehicle *v)
Determines the LiveryScheme for a vehicle.
Definition: vehicle.cpp:1869
BaseConsist::current_order_time
uint32 current_order_time
How many ticks have passed since this order started.
Definition: base_consist.h:22
MarkTileDirtyByTile
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
Definition: viewport.cpp:1987
Vehicle::NextShared
Vehicle * NextShared() const
Get the next vehicle of the shared vehicle chain.
Definition: vehicle_base.h:676
ReleaseDisastersTargetingVehicle
void ReleaseDisastersTargetingVehicle(VehicleID vehicle)
Notify disasters that we are about to delete a vehicle.
Definition: disaster_vehicle.cpp:953
PM_PAUSED_NORMAL
@ PM_PAUSED_NORMAL
A game normally paused.
Definition: openttd.h:62
CargoList< VehicleCargoList, CargoPacketList >::MTA_LOAD
@ MTA_LOAD
Load the cargo from the station.
Definition: cargopacket.h:218
Ship::state
TrackBits state
The "track" the ship is following.
Definition: ship.h:27
GetNewVehiclePosResult
Position information of a vehicle after it moved.
Definition: vehicle_func.h:75
WC_VEHICLE_DEPOT
@ WC_VEHICLE_DEPOT
Depot view; Window numbers:
Definition: window_type.h:343
VE_DISABLE_WAGON_POWER
@ VE_DISABLE_WAGON_POWER
Flag to disable wagon power.
Definition: vehicle_base.h:91
MP_STATION
@ MP_STATION
A tile of a station.
Definition: tile_type.h:51
Vehicle::age
Date age
Age in days.
Definition: vehicle_base.h:270
GetStationIndex
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
Definition: station_map.h:28
Aircraft::previous_pos
byte previous_pos
Previous desired position of the aircraft.
Definition: aircraft.h:77
FindVehicleOnPos
void FindVehicleOnPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
Find a vehicle from a specific location.
Definition: vehicle.cpp:498
Pool::PoolItem<&_orderlist_pool >::CanAllocateItem
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
Definition: pool_type.hpp:307
UsesWagonOverride
bool UsesWagonOverride(const Vehicle *v)
Check if a wagon is currently using a wagon override.
Definition: newgrf_engine.cpp:1140
Vehicle::profit_last_year
Money profit_last_year
Profit last year << 8, low 8 bits are fract.
Definition: vehicle_base.h:252
Vehicle::breakdown_chance
byte breakdown_chance
Current chance of breakdowns.
Definition: vehicle_base.h:278
EV_DIESEL_SMOKE
@ EV_DIESEL_SMOKE
Smoke of diesel engines.
Definition: effectvehicle_func.h:19
linkgraph.h
Sprite::y_offs
int16 y_offs
Number of pixels to shift the sprite downwards.
Definition: spritecache.h:21
Order::SetDepotOrderType
void SetDepotOrderType(OrderDepotTypeFlags depot_order_type)
Set the cause to go to the depot.
Definition: order_base.h:159
GroundVehicle::gv_flags
uint16 gv_flags
Definition: ground_vehicle.hpp:81
DIRDIFF_90RIGHT
@ DIRDIFF_90RIGHT
Angle of 90 degrees right.
Definition: direction_type.h:65
BaseStation::xy
TileIndex xy
Base tile of the station.
Definition: base_station_base.h:53
Vehicle::unitnumber
UnitID unitnumber
unit number, for display purposes only
Definition: vehicle_base.h:302
depot_map.h
GetTileMaxPixelZ
static int GetTileMaxPixelZ(TileIndex tile)
Get top height of the tile.
Definition: tile_map.h:304
EffectVehicle
A special vehicle is one of the following:
Definition: effectvehicle_base.h:24
MAX_VEH_ORDER_ID
static const VehicleOrderID MAX_VEH_ORDER_ID
Last valid VehicleOrderID.
Definition: order_type.h:23
Order::SetDepotActionType
void SetDepotActionType(OrderDepotActionFlags depot_service_type)
Set what we are going to do in the depot.
Definition: order_base.h:161
company_func.h
VehicleSettings::max_roadveh
UnitID max_roadveh
max trucks in game per company
Definition: settings_type.h:485
GetNewVehiclePosResult::old_tile
TileIndex old_tile
Current tile of the vehicle.
Definition: vehicle_func.h:77
VE_ADVANCED_EFFECT
@ VE_ADVANCED_EFFECT
Flag for advanced effects.
Definition: vehicle_base.h:90
Vehicle::x_bb_offs
int8 x_bb_offs
x offset of vehicle bounding box
Definition: vehicle_base.h:295
EXPENSES_NEW_VEHICLES
@ EXPENSES_NEW_VEHICLES
New vehicles.
Definition: economy_type.h:159
Vehicle::hash_viewport_prev
Vehicle ** hash_viewport_prev
NOSAVE: Previous vehicle in the visual location hash.
Definition: vehicle_base.h:260
INSTANTIATE_POOL_METHODS
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don't get linker errors.
Definition: pool_func.hpp:224
VEH_DISASTER
@ VEH_DISASTER
Disaster vehicle type.
Definition: vehicle_type.h:32
abs
static T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition: math_func.hpp:21
Vehicle::breakdown_delay
byte breakdown_delay
Counter for managing breakdown length.
Definition: vehicle_base.h:276
Order::ShouldStopAtStation
bool ShouldStopAtStation(const Vehicle *v, StationID station) const
Check whether the given vehicle should stop at the given station based on this order and the non-stop...
Definition: order_cmd.cpp:2229
TriggerStationRandomisation
void TriggerStationRandomisation(Station *st, TileIndex trigger_tile, StationRandomTrigger trigger, CargoID cargo_type)
Trigger station randomisation.
Definition: newgrf_station.cpp:964
VehicleID
uint32 VehicleID
The type all our vehicle IDs have.
Definition: vehicle_type.h:16
AirportFTA::block
uint64 block
64 bit blocks (st->airport.flags), should be enough for the most complex airports
Definition: airport.h:192
InvalidateAutoreplaceWindow
void InvalidateAutoreplaceWindow(EngineID e, GroupID id_g)
Rebuild the left autoreplace list if an engine is removed or added.
Definition: autoreplace_gui.cpp:49
Vehicle::coord
Rect coord
NOSAVE: Graphical bounding box of the vehicle, i.e. what to redraw on moves.
Definition: vehicle_base.h:257
Vehicle::NeedsServicing
bool NeedsServicing() const
Check if the vehicle needs to go to a depot in near future (if a opportunity presents itself) for ser...
Definition: vehicle.cpp:184
Order::GetDepotOrderType
OrderDepotTypeFlags GetDepotOrderType() const
What caused us going to the depot?
Definition: order_base.h:138
Aircraft::pos
byte pos
Next desired position of the aircraft.
Definition: aircraft.h:76
network.h
AddVehicleAdviceNewsItem
static void AddVehicleAdviceNewsItem(StringID string, VehicleID vehicle)
Adds a vehicle-advice news item.
Definition: news_func.h:40
AIR_CTOL
@ AIR_CTOL
Conventional Take Off and Landing, i.e. planes.
Definition: engine_type.h:93
TrackBits
TrackBits
Bitfield corresponding to Track.
Definition: track_type.h:38
Vehicle::subtype
byte subtype
subtype (Filled with values from AircraftSubType/DisasterSubType/EffectVehicleType/GroundVehicleSubty...
Definition: vehicle_base.h:338
SmallMap::Find
std::vector< Pair >::const_iterator Find(const T &key) const
Finds given key in this map.
Definition: smallmap_type.hpp:41
Vehicle::day_counter
byte day_counter
Increased by one for each day.
Definition: vehicle_base.h:324
VS_UNCLICKABLE
@ VS_UNCLICKABLE
Vehicle is not clickable by the user (shadow vehicles).
Definition: vehicle_base.h:33
FindVehicleOnPosXY
void FindVehicleOnPosXY(int x, int y, void *data, VehicleFromPosProc *proc)
Find a vehicle from a specific location.
Definition: vehicle.cpp:438
ToggleBit
static T ToggleBit(T &x, const uint8 y)
Toggles a bit in a variable.
Definition: bitmath_func.hpp:181
Debug
#define Debug(name, level, format_string,...)
Ouptut a line of debugging information.
Definition: debug.h:37
SetBit
static T SetBit(T &x, const uint8 y)
Set a bit in a variable.
Definition: bitmath_func.hpp:121
HasVehicleOnPosXY
bool HasVehicleOnPosXY(int x, int y, void *data, VehicleFromPosProc *proc)
Checks whether a vehicle in on a specific location.
Definition: vehicle.cpp:454
LinkRefresher::Run
static void Run(Vehicle *v, bool allow_merge=true, bool is_full_loading=false)
Refresh all links the given vehicle will visit.
Definition: refresh.cpp:26
Viewport::zoom
ZoomLevel zoom
The zoom level of the viewport.
Definition: viewport_type.h:33
random_func.hpp
Vehicle::NeedsAutorenewing
bool NeedsAutorenewing(const Company *c, bool use_renew_setting=true) const
Function to tell if a vehicle needs to be autorenewed.
Definition: vehicle.cpp:140
VF_PATHFINDER_LOST
@ VF_PATHFINDER_LOST
Vehicle's pathfinder is lost.
Definition: vehicle_base.h:50
AgeVehicle
void AgeVehicle(Vehicle *v)
Update age of a vehicle.
Definition: vehicle.cpp:1364
SpecializedStation< Station, false >::GetIfValid
static Station * GetIfValid(size_t index)
Returns station if the index is a valid index for this station type.
Definition: base_station_base.h:228
OverflowSafeInt< int64 >
CargoID
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:20
_vehicle_pool
VehiclePool _vehicle_pool("Vehicle")
The pool with all our precious vehicles.
Vehicle::IsStoppedInDepot
bool IsStoppedInDepot() const
Check whether the vehicle is in the depot and stopped.
Definition: vehicle_base.h:529
CloseWindowById
void CloseWindowById(WindowClass cls, WindowNumber number, bool force)
Close a window by its class and window number (if it is open).
Definition: window.cpp:1176
VehicleCargoList::ActionCount
uint ActionCount(MoveToAction action) const
Returns the amount of cargo designated for a given purpose.
Definition: cargopacket.h:342
CBID_VEHICLE_32DAY_CALLBACK
@ CBID_VEHICLE_32DAY_CALLBACK
Called for every vehicle every 32 days (not all on same date though).
Definition: newgrf_callbacks.h:144
Vehicle::previous
Vehicle * previous
NOSAVE: pointer to the previous vehicle in the chain.
Definition: vehicle_base.h:227
GetTileRailType
RailType GetTileRailType(TileIndex tile)
Return the rail type of tile, or INVALID_RAILTYPE if this is no rail tile.
Definition: rail.cpp:155
LiveryScheme
LiveryScheme
List of different livery schemes.
Definition: livery.h:20
Vehicle::cargo_type
CargoID cargo_type
type of cargo this vehicle is carrying
Definition: vehicle_base.h:316
PerformanceAccumulator::Reset
static void Reset(PerformanceElement elem)
Store the previous accumulator value and reset for a new cycle of accumulating measurements.
Definition: framerate_gui.cpp:305
ODATF_SERVICE_ONLY
@ ODATF_SERVICE_ONLY
Only service the vehicle.
Definition: order_type.h:103
Engine::grf_prop
GRFFilePropsBase< NUM_CARGO+2 > grf_prop
Properties related the the grf file.
Definition: engine_base.h:64
EnsureNoVehicleProcZ
static Vehicle * EnsureNoVehicleProcZ(Vehicle *v, void *data)
Callback that returns 'real' vehicles lower or at height *(int*)data .
Definition: vehicle.cpp:524
VSE_RUNNING
@ VSE_RUNNING
Vehicle running normally.
Definition: newgrf_sound.h:22
Train::GetNextUnit
Train * GetNextUnit() const
Get the next real (non-articulated part and non rear part of dualheaded engine) vehicle in the consis...
Definition: train.h:144
FreeUnitIDGenerator::FreeUnitIDGenerator
FreeUnitIDGenerator(VehicleType type, CompanyID owner)
Initializes the structure.
Definition: vehicle.cpp:1753
Vehicle::OnNewDay
virtual void OnNewDay()
Calls the new day handler of the vehicle.
Definition: vehicle_base.h:546
EF_ROAD_TRAM
@ EF_ROAD_TRAM
Road vehicle is a tram/light rail vehicle.
Definition: engine_type.h:155
CeilDiv
static uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
Definition: math_func.hpp:254
GRFFilePropsBase::local_id
uint16 local_id
id defined by the grf file for this entity
Definition: newgrf_commons.h:319
PalSpriteID::pal
PaletteID pal
The palette (use PAL_NONE) if not needed)
Definition: gfx_type.h:24
Aircraft::state
byte state
State of the airport.
Definition: aircraft.h:79
articulated_vehicles.h
GameSettings::vehicle
VehicleSettings vehicle
options for vehicles
Definition: settings_type.h:584
ErrorUnknownCallbackResult
void ErrorUnknownCallbackResult(uint32 grfid, uint16 cbid, uint16 cb_res)
Record that a NewGRF returned an unknown/invalid callback result.
Definition: newgrf_commons.cpp:516
TFP_NONE
@ TFP_NONE
Normal operation.
Definition: train.h:38
VehicleSettings::smoke_amount
uint8 smoke_amount
amount of smoke/sparks locomotives produce
Definition: settings_type.h:477
GetTileType
static TileType GetTileType(TileIndex tile)
Get the tiletype of a given tile.
Definition: tile_map.h:96
CBM_VEHICLE_COLOUR_REMAP
@ CBM_VEHICLE_COLOUR_REMAP
Change colour mapping of vehicle.
Definition: newgrf_callbacks.h:295
VEH_TRAIN
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
Pool::PoolItem<&_company_pool >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:326
Vehicle::GetOrder
Order * GetOrder(int index) const
Returns order 'index' of a vehicle or nullptr when it doesn't exists.
Definition: vehicle_base.h:874
BaseVehicle::type
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:52
SubtractMoneyFromCompany
void SubtractMoneyFromCompany(const CommandCost &cost)
Subtract money from the _current_company, if the company is valid.
Definition: company_cmd.cpp:243
AirportFTAClass::HELICOPTERS
@ HELICOPTERS
Can helicopters land on this airport type?
Definition: airport.h:148
Vehicle::Tick
virtual bool Tick()
Calls the tick handler of the vehicle.
Definition: vehicle_base.h:541
Vehicle::UpdatePositionAndViewport
void UpdatePositionAndViewport()
Update the position of the vehicle, and update the viewport.
Definition: vehicle.cpp:1667
GRFFilePropsBase::grffile
const struct GRFFile * grffile
grf file that introduced this entity
Definition: newgrf_commons.h:320
FACIL_AIRPORT
@ FACIL_AIRPORT
Station with an airport.
Definition: station_type.h:55
Vehicle::reliability
uint16 reliability
Reliability.
Definition: vehicle_base.h:273
VIWD_MODIFY_ORDERS
@ VIWD_MODIFY_ORDERS
Other order modifications.
Definition: vehicle_gui.h:33
Vehicle::UpdatePosition
void UpdatePosition()
Update the position of the vehicle.
Definition: vehicle.cpp:1596
autoreplace_func.h
Vehicle::hash_tile_prev
Vehicle ** hash_tile_prev
NOSAVE: Previous vehicle in the tile location hash.
Definition: vehicle_base.h:263
CanVehicleUseStation
bool CanVehicleUseStation(EngineID engine_type, const Station *st)
Can this station be used by the given engine type?
Definition: vehicle.cpp:2846
pool_func.hpp
Vehicle::HandleBreakdown
bool HandleBreakdown()
Handle all of the aspects of a vehicle breakdown This includes adding smoke and sounds,...
Definition: vehicle.cpp:1298
DecreaseVehicleValue
void DecreaseVehicleValue(Vehicle *v)
Decrease the value of a vehicle.
Definition: vehicle.cpp:1236
Vehicle::y_bb_offs
int8 y_bb_offs
y offset of vehicle bounding box
Definition: vehicle_base.h:296
GetNewVehiclePosResult::y
int y
x and y position of the vehicle after moving
Definition: vehicle_func.h:76
order_backup.h
CT_INVALID
@ CT_INVALID
Invalid cargo type.
Definition: cargo_type.h:69
IsCargoInClass
static bool IsCargoInClass(CargoID c, CargoClass cc)
Does cargo c have cargo class cc?
Definition: cargotype.h:194
GUISettings::liveries
byte liveries
options for displaying company liveries, 0=none, 1=self, 2=all
Definition: settings_type.h:120
Order::CanLeaveWithCargo
bool CanLeaveWithCargo(bool has_cargo) const
A vehicle can leave the current station with cargo if:
Definition: order_cmd.cpp:2253
VehicleCargoList::Return
uint Return(uint max_move, StationCargoList *dest, StationID next_station)
Returns reserved cargo to the station and removes it from the cache.
Definition: cargopacket.cpp:604
VEH_SHIP
@ VEH_SHIP
Ship vehicle type.
Definition: vehicle_type.h:26
VESM_ELECTRIC
@ VESM_ELECTRIC
Electric model.
Definition: vehicle_base.h:101
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition: geometry_type.hpp:47
PM_PAUSED_ERROR
@ PM_PAUSED_ERROR
A game paused because a (critical) error.
Definition: openttd.h:65
Company
Definition: company_base.h:115
VSE_STOPPED_16
@ VSE_STOPPED_16
Every 16 ticks while the vehicle is stopped (speed == 0).
Definition: newgrf_sound.h:26
AirportFTAClass::AIRPLANES
@ AIRPLANES
Can planes land on this airport type?
Definition: airport.h:147
Vehicle::GetNumOrders
VehicleOrderID GetNumOrders() const
Get the number of orders this vehicle has.
Definition: vehicle_base.h:700
InvalidateVehicleOrder
void InvalidateVehicleOrder(const Vehicle *v, int data)
Updates the widgets of a vehicle which contains the order-data.
Definition: order_cmd.cpp:250
SetWindowClassesDirty
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition: window.cpp:3146
VehicleSpriteSeq::GetBounds
void GetBounds(Rect *bounds) const
Determine shared bounds of all sprites.
Definition: vehicle.cpp:98
Order::GetDepotActionType
OrderDepotActionFlags GetDepotActionType() const
What are we going to do when in the depot.
Definition: order_base.h:140
WC_AIRCRAFT_LIST
@ WC_AIRCRAFT_LIST
Aircraft list; Window numbers:
Definition: window_type.h:318
Vehicle::hash_tile_next
Vehicle * hash_tile_next
NOSAVE: Next vehicle in the tile location hash.
Definition: vehicle_base.h:262
Sprite
Data structure describing a sprite.
Definition: spritecache.h:17
AutoreplaceMap
SmallMap< Vehicle *, bool > AutoreplaceMap
List of vehicles that should check for autoreplace this tick.
Definition: vehicle.cpp:687
CLRBITS
#define CLRBITS(x, y)
Clears several bits in a variable.
Definition: bitmath_func.hpp:166
EngineHasReplacementForCompany
static bool EngineHasReplacementForCompany(const Company *c, EngineID engine, GroupID group)
Check if a company has a replacement set up for the given engine.
Definition: autoreplace_func.h:51
lastof
#define lastof(x)
Get the last element of an fixed size array.
Definition: stdafx.h:394
Vehicle::DeleteUnreachedImplicitOrders
void DeleteUnreachedImplicitOrders()
Delete all implicit orders which were not reached.
Definition: vehicle.cpp:2060
Vehicle::first
Vehicle * first
NOSAVE: pointer to the first vehicle in the chain.
Definition: vehicle_base.h:228
GBUG_VEH_LENGTH
@ GBUG_VEH_LENGTH
Length of rail vehicle changes when not inside a depot.
Definition: newgrf_config.h:44
Order::next
Order * next
Pointer to next order. If nullptr, end of list.
Definition: order_base.h:52
SpecializedVehicle::UpdateViewport
void UpdateViewport(bool force_update, bool update_delta)
Update vehicle sprite- and position caches.
Definition: vehicle_base.h:1186
Vehicle::fill_percent_te_id
TextEffectID fill_percent_te_id
a text-effect id to a loading indicator object
Definition: vehicle_base.h:301
Order
Definition: order_base.h:33
VS_SHADOW
@ VS_SHADOW
Vehicle is a shadow vehicle.
Definition: vehicle_base.h:36
Livery
Information about a particular livery.
Definition: livery.h:78
GroundVehicleCache::cached_weight
uint32 cached_weight
Total weight of the consist (valid only for the first engine).
Definition: ground_vehicle.hpp:31
EffectVehicle::GetTransparencyOption
TransparencyOption GetTransparencyOption() const
Determines the transparency option affecting the effect.
Definition: effectvehicle.cpp:661
INVALID_COORD
static const int32 INVALID_COORD
Sentinel for an invalid coordinate.
Definition: vehicle_base.h:1250
MutableSpriteCache::old_coord
Rect old_coord
Co-ordinates from the last valid bounding box.
Definition: vehicle_base.h:192
DAY_TICKS
static const int DAY_TICKS
1 day is 74 ticks; _date_fract used to be uint16 and incremented by 885.
Definition: date_type.h:28
ViewportAddVehicles
void ViewportAddVehicles(DrawPixelInfo *dpi)
Add the vehicle sprites that should be drawn at a part of the screen.
Definition: vehicle.cpp:1108
VE_OFFSET_CENTRE
@ VE_OFFSET_CENTRE
Value of offset corresponding to a position above the centre of the vehicle.
Definition: vehicle_base.h:80
Order::SetNonStopType
void SetNonStopType(OrderNonStopFlags non_stop_type)
Set whether we must stop at stations or not.
Definition: order_base.h:155
VehicleEnterTileStatus
VehicleEnterTileStatus
The returned bits of VehicleEnterTile.
Definition: tile_cmd.h:20
GetGRFConfig
GRFConfig * GetGRFConfig(uint32 grfid, uint32 mask)
Retrieve a NewGRF from the current config by its grfid.
Definition: newgrf_config.cpp:762
Order::MakeImplicit
void MakeImplicit(StationID destination)
Makes this order an implicit order.
Definition: order_cmd.cpp:153
SpecializedVehicle::GetFirstEnginePart
T * GetFirstEnginePart()
Get the first part of an articulated engine.
Definition: vehicle_base.h:1105
FLYING
@ FLYING
Vehicle is flying in the air.
Definition: airport.h:75
VE_TYPE_STEAM
@ VE_TYPE_STEAM
Steam plumes.
Definition: vehicle_base.h:85
SetDParamStr
void SetDParamStr(uint n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
Definition: strings.cpp:296
TunnelBridgeIsFree
CommandCost TunnelBridgeIsFree(TileIndex tile, TileIndex endtile, const Vehicle *ignore)
Finds vehicle in tunnel / bridge.
Definition: vehicle.cpp:568
EV_BREAKDOWN_SMOKE
@ EV_BREAKDOWN_SMOKE
Smoke of broken vehicles except aircraft.
Definition: effectvehicle_func.h:23
INVALID_STRING_ID
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Definition: strings_type.h:17
Vehicle::MarkDirty
virtual void MarkDirty()
Marks the vehicles to be redrawn and updates cached variables.
Definition: vehicle_base.h:377
WC_VEHICLE_ORDERS
@ WC_VEHICLE_ORDERS
Vehicle orders; Window numbers:
Definition: window_type.h:204
GRFFile
Dynamic data of a loaded NewGRF.
Definition: newgrf.h:105
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition: settings_type.h:593
Engine::reliability
uint16 reliability
Current reliability of the engine.
Definition: engine_base.h:31
WL_CRITICAL
@ WL_CRITICAL
Critical errors, the MessageBox is shown in all cases.
Definition: error.h:25
Engine::type
VehicleType type
Vehicle type, ie VEH_ROAD, VEH_TRAIN, etc.
Definition: engine_base.h:46
SND_0F_BREAKDOWN_ROADVEHICLE
@ SND_0F_BREAKDOWN_ROADVEHICLE
13 == 0x0D Breakdown: road vehicle (non-toyland)
Definition: sound_type.h:52
Vehicle::refit_cap
uint16 refit_cap
Capacity left over from before last refit.
Definition: vehicle_base.h:319
GroundVehicle::IsMultiheaded
bool IsMultiheaded() const
Check if the vehicle is a multiheaded engine.
Definition: ground_vehicle.hpp:328
OLFB_NO_LOAD
@ OLFB_NO_LOAD
Do not load anything.
Definition: order_type.h:66
Vehicle::date_of_last_service
Date date_of_last_service
Last date the vehicle had a service at a depot.
Definition: vehicle_base.h:272
GetNewVehiclePos
GetNewVehiclePosResult GetNewVehiclePos(const Vehicle *v)
Get position information of a vehicle when moving one pixel in the direction it is facing.
Definition: vehicle.cpp:1687
GRFConfig::GetName
const char * GetName() const
Get the name of this grf.
Definition: newgrf_config.cpp:105
DrawPixelInfo
Data about how and where to blit pixels.
Definition: gfx_type.h:155
VEHICLE_PROFIT_MIN_AGE
static const int VEHICLE_PROFIT_MIN_AGE
Only vehicles older than this have a meaningful profit.
Definition: vehicle_func.h:27
Order::GetLoadType
OrderLoadFlags GetLoadType() const
How must the consist be loaded?
Definition: order_base.h:130
VehicleEnterTile
VehicleEnterTileStatus VehicleEnterTile(Vehicle *v, TileIndex tile, int x, int y)
Call the tile callback function for a vehicle entering a tile.
Definition: vehicle.cpp:1741
TileVirtXY
static TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
Definition: map_func.h:194
news_func.h
EC_MONORAIL
@ EC_MONORAIL
Mono rail engine.
Definition: engine_type.h:37
IsBridgeAbove
static bool IsBridgeAbove(TileIndex t)
checks if a bridge is set above the ground of this tile
Definition: bridge_map.h:45
VSE_RUNNING_16
@ VSE_RUNNING_16
Every 16 ticks while the vehicle is running (speed > 0).
Definition: newgrf_sound.h:25
roadveh.h
Livery::colour2
byte colour2
Second colour, for vehicles with 2CC support.
Definition: livery.h:81
GamelogGRFBugReverse
bool GamelogGRFBugReverse(uint32 grfid, uint16 internal_id)
Logs GRF bug - rail vehicle has different length after reversing.
Definition: gamelog.cpp:569
Livery::colour1
byte colour1
First colour, for all vehicles.
Definition: livery.h:80
TileTypeProcs::vehicle_enter_tile_proc
VehicleEnterTileProc * vehicle_enter_tile_proc
Called when a vehicle enters a tile.
Definition: tile_cmd.h:157
DEPOT_DONT_CANCEL
@ DEPOT_DONT_CANCEL
Don't cancel current goto depot command if any.
Definition: vehicle_type.h:68
backup_type.hpp
Vehicle::GetImage
virtual void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const
Gets the sprite to show for the given direction.
Definition: vehicle_base.h:455