OpenTTD Source 20261112-master-gbcbec5e63f
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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
6 */
7
9
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 "vehicle_func.h"
29#include "vehicle_gui.h"
30#include "autoreplace_func.h"
31#include "autoreplace_gui.h"
32#include "station_base.h"
33#include "station_func.h"
34#include "ai/ai.hpp"
35#include "depot_func.h"
36#include "network/network.h"
37#include "core/pool_func.hpp"
38#include "economy_base.h"
40#include "roadstop_base.h"
41#include "core/random_func.hpp"
42#include "core/backup_type.hpp"
44#include "order_backup.h"
45#include "sound_func.h"
46#include "effectvehicle_func.h"
47#include "effectvehicle_base.h"
48#include "vehiclelist.h"
49#include "bridge_map.h"
50#include "tunnel_map.h"
51#include "depot_map.h"
52#include "gamelog.h"
53#include "linkgraph/refresh.h"
54#include "framerate_type.h"
55#include "autoreplace_cmd.h"
56#include "misc_cmd.h"
57#include "train_cmd.h"
58#include "vehicle_cmd.h"
59#include "newgrf_roadstop.h"
60#include "script/api/script_event_types.hpp"
61#include "timer/timer.h"
65
66#include "table/strings.h"
67
68#include "safeguards.h"
69
72static const uint GEN_HASHX_BITS = 6;
73static const uint GEN_HASHY_BITS = 6;
75
78static const uint GEN_HASHX_BUCKET_BITS = 7;
79static const uint GEN_HASHY_BUCKET_BITS = 6;
81
82/* Compute hash for vehicle coord */
83static inline uint GetViewportHashX(int x)
84{
85 return GB(x, GEN_HASHX_BUCKET_BITS + ZOOM_BASE_SHIFT, GEN_HASHX_BITS);
86}
87
88static inline uint GetViewportHashY(int y)
89{
90 return GB(y, GEN_HASHY_BUCKET_BITS + ZOOM_BASE_SHIFT, GEN_HASHY_BITS) << GEN_HASHX_BITS;
91}
92
93static inline uint GetViewportHash(int x, int y)
94{
95 return GetViewportHashX(x) + GetViewportHashY(y);
96}
97
100static const uint GEN_HASHX_SIZE = 1 << (GEN_HASHX_BUCKET_BITS + GEN_HASHX_BITS + ZOOM_BASE_SHIFT);
101static const uint GEN_HASHY_SIZE = 1 << (GEN_HASHY_BUCKET_BITS + GEN_HASHY_BITS + ZOOM_BASE_SHIFT);
103
106static const uint GEN_HASHX_INC = 1;
107static const uint GEN_HASHY_INC = 1 << GEN_HASHX_BITS;
109
112static const uint GEN_HASHX_MASK = (1 << GEN_HASHX_BITS) - 1;
113static const uint GEN_HASHY_MASK = ((1 << GEN_HASHY_BITS) - 1) << GEN_HASHX_BITS;
115
119
120
121
125void VehicleSpriteSeq::GetBounds(Rect *bounds) const
126{
127 bounds->left = bounds->top = bounds->right = bounds->bottom = 0;
128 for (uint i = 0; i < this->count; ++i) {
129 const Sprite *spr = GetSprite(this->seq[i].sprite, SpriteType::Normal);
130 if (i == 0) {
131 bounds->left = spr->x_offs;
132 bounds->top = spr->y_offs;
133 bounds->right = spr->width + spr->x_offs - 1;
134 bounds->bottom = spr->height + spr->y_offs - 1;
135 } else {
136 if (spr->x_offs < bounds->left) bounds->left = spr->x_offs;
137 if (spr->y_offs < bounds->top) bounds->top = spr->y_offs;
138 int right = spr->width + spr->x_offs - 1;
139 int bottom = spr->height + spr->y_offs - 1;
140 if (right > bounds->right) bounds->right = right;
141 if (bottom > bounds->bottom) bounds->bottom = bottom;
142 }
143 }
144}
145
153void VehicleSpriteSeq::Draw(int x, int y, PaletteID default_pal, bool force_pal) const
154{
155 for (uint i = 0; i < this->count; ++i) {
156 PaletteID pal = force_pal || !this->seq[i].pal ? default_pal : this->seq[i].pal;
157 DrawSprite(this->seq[i].sprite, pal, x, y);
158 }
159}
160
167bool Vehicle::NeedsAutorenewing(const Company *c, bool use_renew_setting) const
168{
169 /* We can always generate the Company pointer when we have the vehicle.
170 * However this takes time and since the Company pointer is often present
171 * when this function is called then it's faster to pass the pointer as an
172 * argument rather than finding it again. */
173 assert(c == Company::Get(this->owner));
174
175 if (use_renew_setting && !c->settings.engine_renew) return false;
176 if (this->age - this->max_age < (c->settings.engine_renew_months * 30)) return false;
177
178 /* Only engines need renewing */
179 if (this->type == VehicleType::Train && !Train::From(this)->IsEngine()) return false;
180
181 return true;
182}
183
190{
191 assert(v != nullptr);
192 SetWindowDirty(WindowClass::VehicleDetails, v->index); // ensure that last service date and reliability are updated
193
194 do {
199 /* Prevent vehicles from breaking down directly after exiting the depot. */
200 v->breakdown_chance /= 4;
201 if (_settings_game.difficulty.vehicle_breakdowns == VehicleBreakdowns::Reduced) v->breakdown_chance = 0; // on reduced breakdown
202 v = v->Next();
203 } while (v != nullptr && v->HasEngineType());
204}
205
213{
214 /* Stopped or crashed vehicles will not move, as such making unmovable
215 * vehicles to go for service is lame. */
216 if (this->vehstatus.Any({VehState::Stopped, VehState::Crashed})) return false;
217
218 /* Are we ready for the next service cycle? */
219 const Company *c = Company::Get(this->owner);
220
221 /* Service intervals can be measured in different units, which we handle individually. */
222 if (this->ServiceIntervalIsPercent()) {
223 /* Service interval is in percents. */
224 if (this->reliability >= this->GetEngine()->reliability * (100 - this->GetServiceInterval()) / 100) return false;
226 /* Service interval is in minutes. */
227 if (this->date_of_last_service + (this->GetServiceInterval() * EconomyTime::DAYS_IN_ECONOMY_MONTH) >= TimerGameEconomy::date) return false;
228 } else {
229 /* Service interval is in days. */
230 if (this->date_of_last_service + this->GetServiceInterval() >= TimerGameEconomy::date) return false;
231 }
232
233 /* If we're servicing anyway, because we have not disabled servicing when
234 * there are no breakdowns or we are playing with breakdowns, bail out. */
235 if (!_settings_game.order.no_servicing_if_no_breakdowns ||
236 _settings_game.difficulty.vehicle_breakdowns != VehicleBreakdowns::None) {
237 return true;
238 }
239
240 /* Test whether there is some pending autoreplace.
241 * Note: We do this after the service-interval test.
242 * There are a lot more reasons for autoreplace to fail than we can test here reasonably. */
243 bool pending_replace = false;
244 Money needed_money = c->settings.engine_renew_money;
245 if (needed_money > GetAvailableMoney(c->index)) return false;
246
247 for (const Vehicle *v = this; v != nullptr; v = (v->type == VehicleType::Train) ? Train::From(v)->GetNextUnit() : nullptr) {
248 bool replace_when_old = false;
249 EngineID new_engine = EngineReplacementForCompany(c, v->engine_type, v->group_id, &replace_when_old);
250
251 /* Check engine availability */
252 if (new_engine == EngineID::Invalid() || !Engine::Get(new_engine)->company_avail.Test(v->owner)) continue;
253 /* Is the vehicle old if we are not always replacing? */
254 if (replace_when_old && !v->NeedsAutorenewing(c, false)) continue;
255
256 /* Check refittability */
257 CargoTypes available_cargo_types, union_mask;
258 GetArticulatedRefitMasks(new_engine, true, &union_mask, &available_cargo_types);
259 /* Is there anything to refit? */
260 if (union_mask.Any()) {
263 if (!HasAtMostOneBit(cargo_mask.base())) {
264 CargoTypes new_engine_default_cargoes = GetCargoTypesOfArticulatedParts(new_engine);
265 if ((cargo_mask & new_engine_default_cargoes) != cargo_mask) {
266 /* We cannot refit to mixed cargoes in an automated way */
267 continue;
268 }
269 /* engine_type is already a mixed cargo type which matches the incoming vehicle by default, no refit required */
270 } else {
271 /* Did the old vehicle carry anything? */
273 /* We can't refit the vehicle to carry the cargo we want */
274 if (!available_cargo_types.Test(cargo_type)) continue;
275 }
276 }
277 }
278
279 /* Check money.
280 * We want 2*(the price of the new vehicle) without looking at the value of the vehicle we are going to sell. */
281 pending_replace = true;
282 needed_money += 2 * Engine::Get(new_engine)->GetCost();
283 if (needed_money > GetAvailableMoney(c->index)) return false;
284 }
285
286 return pending_replace;
287}
288
295{
296 if (this->HasDepotOrder()) return false;
297 if (this->current_order.IsType(OT_LOADING)) return false;
298 if (this->current_order.IsType(OT_GOTO_DEPOT) && !this->current_order.GetDepotOrderType().Test(OrderDepotTypeFlag::Service)) return false;
299 return NeedsServicing();
300}
301
303{
304 assert(!this->vehstatus.Test(VehState::Crashed));
305 assert(this->Previous() == nullptr); // IsPrimaryVehicle fails for free-wagon-chains
306
307 uint pass = 0;
308 /* Stop the vehicle. */
309 if (this->IsPrimaryVehicle()) this->vehstatus.Set(VehState::Stopped);
310 /* crash all wagons, and count passengers */
311 for (Vehicle *v = this; v != nullptr; v = v->Next()) {
312 /* We do not transfer reserver cargo back, so TotalCount() instead of StoredCount() */
313 if (IsCargoInClass(v->cargo_type, CargoClass::Passengers)) pass += v->cargo.TotalCount();
314 v->vehstatus.Set(VehState::Crashed);
315 v->MarkAllViewportsDirty();
316 }
317
318 /* Dirty some windows */
320 SetWindowWidgetDirty(WindowClass::VehicleView, this->index, WID_VV_START_STOP);
321 SetWindowDirty(WindowClass::VehicleDetails, this->index);
322 SetWindowDirty(WindowClass::VehicleDepot, this->GetMovingFront()->tile);
323
324 delete this->cargo_payment;
325 assert(this->cargo_payment == nullptr); // cleared by ~CargoPayment
326
327 return RandomRange(pass + 1); // Randomise deceased passengers.
328}
329
330
339void ShowNewGrfVehicleError(EngineID engine, StringID part1, StringID part2, GRFBug bug_type, bool critical)
340{
341 const Engine *e = Engine::Get(engine);
342 GRFConfig *grfconfig = GetGRFConfig(e->GetGRFID());
343
344 /* Missing GRF. Nothing useful can be done in this situation. */
345 if (grfconfig == nullptr) return;
346
347 if (!grfconfig->grf_bugs.Test(bug_type)) {
348 grfconfig->grf_bugs.Set(bug_type);
349 ShowErrorMessage(GetEncodedString(part1, grfconfig->GetName()),
350 GetEncodedString(part2, std::monostate{}, engine), WarningLevel::Critical);
351 if (!_networking) Command<Commands::Pause>::Do(DoCommandFlag::Execute, critical ? PauseMode::Error : PauseMode::Normal, true);
352 }
353
354 /* debug output */
356
357 Debug(Facility::Grf, Severity::Critical, "{}", StrMakeValid(GetString(part2, std::monostate{}, engine)));
358}
359
366{
367 /* show a warning once for each engine in whole game and once for each GRF after each game load */
368 const Engine *engine = u->GetEngine();
369 GrfID grfid = engine->grf_prop.grfid;
370 GRFConfig *grfconfig = GetGRFConfig(grfid);
371 if (_gamelog.GRFBugReverse(grfid, engine->grf_prop.local_id) || !grfconfig->grf_bugs.Test(GRFBug::VehLength)) {
372 ShowNewGrfVehicleError(u->engine_type, STR_NEWGRF_BROKEN, STR_NEWGRF_BROKEN_VEHICLE_LENGTH, GRFBug::VehLength, true);
373 }
374}
375
382{
383 this->type = type;
384 this->coord.left = INVALID_COORD;
385 this->sprite_cache.old_coord.left = INVALID_COORD;
386 this->group_id = DEFAULT_GROUP;
387 this->fill_percent_te_id = INVALID_TE_ID;
388 this->first = this;
389 this->last = this;
390 this->colourmap = PAL_NONE;
391 this->cargo_age_counter = 1;
392 this->last_station_visited = StationID::Invalid();
393 this->last_loading_station = StationID::Invalid();
394}
395
400constexpr uint TILE_HASH_BITS = 7;
401constexpr uint TILE_HASH_SIZE = 1 << TILE_HASH_BITS;
402constexpr uint TILE_HASH_MASK = TILE_HASH_SIZE - 1;
403constexpr uint TOTAL_TILE_HASH_SIZE = 1 << (TILE_HASH_BITS * 2);
405
410constexpr uint TILE_HASH_RES = 0;
411
417static inline uint GetTileHash1D(uint p)
418{
419 return GB(p, TILE_HASH_RES, TILE_HASH_BITS);
420}
421
427static inline uint IncTileHash1D(uint h)
428{
429 return (h + 1) & TILE_HASH_MASK;
430}
431
438static inline uint ComposeTileHash(uint hx, uint hy)
439{
440 return hx | hy << TILE_HASH_BITS;
441}
442
449static inline uint GetTileHash(uint x, uint y)
450{
452}
453
454static std::array<Vehicle *, TOTAL_TILE_HASH_SIZE> _vehicle_tile_hash{};
455
463VehiclesNearTileXY::Iterator::Iterator(int32_t x, int32_t y, uint max_dist)
464{
465 /* There are no negative tile coordinates */
466 this->pos_rect.left = std::max<int>(0, x - max_dist);
467 this->pos_rect.right = std::max<int>(0, x + max_dist);
468 this->pos_rect.top = std::max<int>(0, y - max_dist);
469 this->pos_rect.bottom = std::max<int>(0, y + max_dist);
470
471 if (2 * max_dist < TILE_HASH_MASK * TILE_SIZE) {
472 /* Hash area to scan */
473 this->hxmin = this->hx = GetTileHash1D(this->pos_rect.left / TILE_SIZE);
474 this->hxmax = GetTileHash1D(this->pos_rect.right / TILE_SIZE);
475 this->hymin = this->hy = GetTileHash1D(this->pos_rect.top / TILE_SIZE);
476 this->hymax = GetTileHash1D(this->pos_rect.bottom / TILE_SIZE);
477 } else {
478 /* Scan all */
479 this->hxmin = this->hx = 0;
480 this->hxmax = TILE_HASH_MASK;
481 this->hymin = this->hy = 0;
482 this->hymax = TILE_HASH_MASK;
483 }
484
485 this->current_veh = _vehicle_tile_hash[ComposeTileHash(this->hx, this->hy)];
486 this->SkipEmptyBuckets();
487 this->SkipFalseMatches();
488}
489
494{
495 assert(this->current_veh != nullptr);
496 this->current_veh = this->current_veh->hash_tile_next;
497 this->SkipEmptyBuckets();
498}
499
504{
505 while (this->current_veh == nullptr) {
506 if (this->hx != this->hxmax) {
507 this->hx = IncTileHash1D(this->hx);
508 } else if (this->hy != this->hymax) {
509 this->hx = this->hxmin;
510 this->hy = IncTileHash1D(this->hy);
511 } else {
512 return;
513 }
514 this->current_veh = _vehicle_tile_hash[ComposeTileHash(this->hx, this->hy)];
515 }
516}
517
522{
523 while (this->current_veh != nullptr && !this->pos_rect.Contains({this->current_veh->x_pos, this->current_veh->y_pos})) this->Increment();
524}
525
532{
533 this->current = _vehicle_tile_hash[GetTileHash(TileX(tile), TileY(tile))];
534 this->SkipFalseMatches();
535}
536
542{
543 this->current = this->current->hash_tile_next;
544}
545
550{
551 while (this->current != nullptr && this->current->tile != this->tile) this->Increment();
552}
553
560{
561 int z = GetTileMaxPixelZ(tile);
562
563 /* Value v is not safe in MP games, however, it is used to generate a local
564 * error message only (which may be different for different machines).
565 * Such a message does not affect MP synchronisation.
566 */
567 for (const Vehicle *v : VehiclesOnTile(tile)) {
568 if (v->type == VehicleType::Disaster || (v->type == VehicleType::Aircraft && v->subtype == AIR_SHADOW)) continue;
569 if (v->z_pos > z) continue;
570
571 return CommandCost(STR_ERROR_TRAIN_IN_THE_WAY + to_underlying(v->type));
572 }
573 return CommandCost();
574}
575
584{
585 for (TileIndex t : {tile, endtile}) {
586 /* Value v is not safe in MP games, however, it is used to generate a local
587 * error message only (which may be different for different machines).
588 * Such a message does not affect MP synchronisation.
589 */
590 for (const Vehicle *v : VehiclesOnTile(t)) {
591 if (v->type != VehicleType::Train && v->type != VehicleType::Road && v->type != VehicleType::Ship) continue;
592 if (v == ignore) continue;
593 return CommandCost(STR_ERROR_TRAIN_IN_THE_WAY + to_underlying(v->type));
594 }
595 }
596 return CommandCost();
597}
598
608{
609 /* Value v is not safe in MP games, however, it is used to generate a local
610 * error message only (which may be different for different machines).
611 * Such a message does not affect MP synchronisation.
612 */
613 for (const Vehicle *v : VehiclesOnTile(tile)) {
614 if (v->type != VehicleType::Train) continue;
615
616 const Train *t = Train::From(v);
617 if ((t->track != track_bits) && !TracksOverlap(t->track | track_bits)) continue;
618
619 return CommandCost(STR_ERROR_TRAIN_IN_THE_WAY + to_underlying(v->type));
620 }
621 return CommandCost();
622}
623
624static void UpdateVehicleTileHash(Vehicle *v, bool remove)
625{
626 Vehicle **old_hash = v->hash_tile_current;
627 Vehicle **new_hash;
628
629 if (remove) {
630 new_hash = nullptr;
631 } else {
632 new_hash = &_vehicle_tile_hash[GetTileHash(TileX(v->tile), TileY(v->tile))];
633 }
634
635 if (old_hash == new_hash) return;
636
637 /* Remove from the old position in the hash table */
638 if (old_hash != nullptr) {
641 }
642
643 /* Insert vehicle at beginning of the new position in the hash table */
644 if (new_hash != nullptr) {
645 v->hash_tile_next = *new_hash;
646 if (v->hash_tile_next != nullptr) v->hash_tile_next->hash_tile_prev = &v->hash_tile_next;
647 v->hash_tile_prev = new_hash;
648 *new_hash = v;
649 }
650
651 /* Remember current hash position */
652 v->hash_tile_current = new_hash;
653}
654
655static std::array<Vehicle *, 1 << (GEN_HASHX_BITS + GEN_HASHY_BITS)> _vehicle_viewport_hash{};
656
657static void UpdateVehicleViewportHash(Vehicle *v, int x, int y, int old_x, int old_y)
658{
659 Vehicle **old_hash, **new_hash;
660
661 new_hash = (x == INVALID_COORD) ? nullptr : &_vehicle_viewport_hash[GetViewportHash(x, y)];
662 old_hash = (old_x == INVALID_COORD) ? nullptr : &_vehicle_viewport_hash[GetViewportHash(old_x, old_y)];
663
664 if (old_hash == new_hash) return;
665
666 /* remove from hash table? */
667 if (old_hash != nullptr) {
670 }
671
672 /* insert into hash table? */
673 if (new_hash != nullptr) {
674 v->hash_viewport_next = *new_hash;
676 v->hash_viewport_prev = new_hash;
677 *new_hash = v;
678 }
679}
680
681void ResetVehicleHash()
682{
683 for (Vehicle *v : Vehicle::Iterate()) { v->hash_tile_current = nullptr; }
684 _vehicle_viewport_hash.fill(nullptr);
685 _vehicle_tile_hash.fill(nullptr);
686}
687
688void ResetVehicleColourMap()
689{
690 for (Vehicle *v : Vehicle::Iterate()) { v->colourmap = PAL_NONE; }
691}
692
697using AutoreplaceMap = std::map<VehicleID, bool>;
698static AutoreplaceMap _vehicles_to_autoreplace;
699
700void InitializeVehicles()
701{
702 _vehicles_to_autoreplace.clear();
703 ResetVehicleHash();
704}
705
706uint CountVehiclesInChain(const Vehicle *v)
707{
708 uint count = 0;
709 do count++; while ((v = v->Next()) != nullptr);
710 return count;
711}
712
718{
719 switch (this->type) {
720 case VehicleType::Aircraft: return Aircraft::From(this)->IsNormalAircraft(); // don't count plane shadows and helicopter rotors
722 return !this->IsArticulatedPart() && // tenders and other articulated parts
723 !Train::From(this)->IsRearDualheaded(); // rear parts of multiheaded engines
725 case VehicleType::Ship: return true;
726 default: return false; // Only count company buildable vehicles
727 }
728}
729
735{
736 switch (this->type) {
740 case VehicleType::Ship: return true;
741 default: return false;
742 }
743}
744
751{
752 return Engine::Get(this->engine_type);
753}
754
761{
762 return this->GetEngine()->GetGRF();
763}
764
771{
772 return this->GetEngine()->GetGRFID();
773}
774
781{
782 this->date_of_last_service = std::max(this->date_of_last_service + interval, TimerGameEconomy::Date(0));
783 /* date_of_last_service_newgrf is not updated here as it must stay stable
784 * for vehicles outside of a depot. */
785}
786
795{
796 if (path_found) {
797 /* Route found, is the vehicle marked with "lost" flag? */
798 if (!this->vehicle_flags.Test(VehicleFlag::PathfinderLost)) return;
799
800 /* Clear the flag as the PF's problem was solved. */
802 SetWindowWidgetDirty(WindowClass::VehicleView, this->index, WID_VV_START_STOP);
804 /* Delete the news item. */
806 return;
807 }
808
809 /* Were we already lost? */
810 if (this->vehicle_flags.Test(VehicleFlag::PathfinderLost)) return;
811
812 /* It is first time the problem occurred, set the "lost" flag. */
814 SetWindowWidgetDirty(WindowClass::VehicleView, this->index, WID_VV_START_STOP);
816
817 /* Unbunching data is no longer valid. */
818 this->ResetDepotUnbunching();
819
820 /* Notify user about the event. */
821 AI::NewEvent(this->owner, new ScriptEventVehicleLost(this->index));
822 if (_settings_client.gui.lost_vehicle_warn && this->owner == _local_company) {
823 AddVehicleAdviceNewsItem(AdviceType::VehicleLost, GetEncodedString(STR_NEWS_VEHICLE_IS_LOST, this->index), this->index);
824 }
825}
826
829{
830 if (CleaningPool()) return;
831
834 st->loading_vehicles.remove(this);
835
837 this->CancelReservation(StationID::Invalid(), st);
838 delete this->cargo_payment;
839 assert(this->cargo_payment == nullptr); // cleared by ~CargoPayment
840 }
841
842 if (this->IsEngineCountable()) {
844 if (this->IsPrimaryVehicle()) GroupStatistics::CountVehicle(this, -1);
846
849 }
850
851 Company::Get(this->owner)->freeunits[this->type].ReleaseID(this->unitnumber);
852
853 if (this->type == VehicleType::Aircraft && this->IsPrimaryVehicle()) {
854 Aircraft *a = Aircraft::From(this);
856 if (st != nullptr) {
857 const auto &layout = st->airport.GetFTA()->layout;
858 st->airport.blocks.Reset(layout[a->previous_pos].blocks | layout[a->pos].blocks);
859 }
860 }
861
862
863 if (this->type == VehicleType::Road && this->IsPrimaryVehicle()) {
865 if (!v->vehstatus.Test(VehState::Crashed) && IsInsideMM(v->state, RVSB_IN_DT_ROAD_STOP, RVSB_IN_DT_ROAD_STOP_END)) {
866 /* Leave the drive through roadstop, when you have not already left it. */
868 }
869
870 if (v->disaster_vehicle != VehicleID::Invalid()) ReleaseDisasterVehicle(v->disaster_vehicle);
871 }
872
873 if (this->Previous() == nullptr) {
874 InvalidateWindowData(WindowClass::VehicleDepot, this->tile);
875 }
876
877 if (this->IsPrimaryVehicle()) {
878 CloseWindowById(WindowClass::VehicleView, this->index);
879 CloseWindowById(WindowClass::VehicleOrders, this->index);
880 CloseWindowById(WindowClass::VehicleRefit, this->index);
881 CloseWindowById(WindowClass::VehicleDetails, this->index);
882 CloseWindowById(WindowClass::VehicleTimetable, this->index);
883 SetWindowDirty(WindowClass::Company, this->owner);
885 }
887
888 this->cargo.Truncate();
891
892 StopGlobalFollowVehicle(this);
893}
894
896{
897 if (CleaningPool()) {
898 this->cargo.OnCleanPool();
899 return;
900 }
901
902 /* sometimes, eg. for disaster vehicles, when company bankrupts, when removing crashed/flooded vehicles,
903 * it may happen that vehicle chain is deleted when visible */
904 if (!this->vehstatus.Test(VehState::Hidden)) this->MarkAllViewportsDirty();
905
906 Vehicle *v = this->Next();
907 this->SetNext(nullptr);
908
909 delete v;
910
911 UpdateVehicleTileHash(this, true);
912 UpdateVehicleViewportHash(this, INVALID_COORD, 0, this->sprite_cache.old_coord.left, this->sprite_cache.old_coord.top);
913 if (this->type != VehicleType::Effect) {
916 }
917}
918
924{
925 /* Vehicle should stop in the depot if it was in 'stopping' state */
926 _vehicles_to_autoreplace[v->index] = !v->vehstatus.Test(VehState::Stopped);
927
928 /* We ALWAYS set the stopped state. Even when the vehicle does not plan on
929 * stopping in the depot, so we stop it to ensure that it will not reserve
930 * the path out of the depot before we might autoreplace it to a different
931 * engine. The new engine would not own the reserved path we store that we
932 * stopped the vehicle, so autoreplace can start it again */
934}
935
940{
941 if (_game_mode != GameMode::Normal) return;
942
943 /* Run the calendar day proc for every DAY_TICKS vehicle starting at TimerGameCalendar::date_fract. */
945 Vehicle *v = Vehicle::Get(i);
946 if (v == nullptr) continue;
947 v->OnNewCalendarDay();
948 }
949}
950
957{
958 if (_game_mode != GameMode::Normal) return;
959
960 /* Run the economy day proc for every DAY_TICKS vehicle starting at TimerGameEconomy::date_fract. */
962 Vehicle *v = Vehicle::Get(i);
963 if (v == nullptr) continue;
964
965 /* Call the 32-day callback if needed */
966 if ((v->day_counter & 0x1F) == 0 && v->HasEngineType()) {
967 uint16_t callback = GetVehicleCallback(CBID_VEHICLE_32DAY_CALLBACK, 0, 0, v->engine_type, v);
968 if (callback != CALLBACK_FAILED) {
969 if (HasBit(callback, 0)) {
970 TriggerVehicleRandomisation(v, VehicleRandomTrigger::Callback32); // Trigger vehicle trigger 10
971 }
972
973 /* After a vehicle trigger, the graphics and properties of the vehicle could change.
974 * Note: MarkDirty also invalidates the palette, which is the meaning of bit 1. So, nothing special there. */
975 if (callback != 0) v->First()->MarkDirty();
976
977 if (callback & ~3) ErrorUnknownCallbackResult(v->GetGRFID(), CBID_VEHICLE_32DAY_CALLBACK, callback);
978 }
979 }
980
981 /* This is called once per day for each vehicle, but not in the first tick of the day */
982 v->OnNewEconomyDay();
983 }
984}
985
986void CallVehicleTicks()
987{
988 _vehicles_to_autoreplace.clear();
989
991
992 {
993 PerformanceMeasurer framerate(PerformanceElement::GameLoopEconomy);
995 }
1000
1001 for (Vehicle *v : Vehicle::Iterate()) {
1002 [[maybe_unused]] VehicleID vehicle_index = v->index;
1003
1004 /* Vehicle could be deleted in this tick */
1005 if (!v->Tick()) {
1006 assert(Vehicle::Get(vehicle_index) == nullptr);
1007 continue;
1008 }
1009
1010 assert(Vehicle::Get(vehicle_index) == v);
1011
1012 switch (v->type) {
1013 default: break;
1014
1015 case VehicleType::Train:
1016 case VehicleType::Road:
1018 case VehicleType::Ship: {
1019 Vehicle *front = v->First();
1020
1021 if (v->vcache.cached_cargo_age_period != 0) {
1023 if (--v->cargo_age_counter == 0) {
1024 v->cargo.AgeCargo();
1026 }
1027 }
1028
1029 /* Do not play any sound when crashed */
1030 if (front->vehstatus.Test(VehState::Crashed)) continue;
1031
1032 /* Do not play any sound when in depot or tunnel */
1033 if (v->vehstatus.Test(VehState::Hidden)) continue;
1034
1035 /* Do not play any sound when stopped */
1036 if (front->vehstatus.Test(VehState::Stopped) && (front->type != VehicleType::Train || front->cur_speed == 0)) continue;
1037
1038 /* Update motion counter for animation purposes. */
1039 v->motion_counter += front->cur_speed;
1040
1041 /* Check vehicle type specifics */
1042 switch (v->type) {
1043 case VehicleType::Train:
1044 if (!Train::From(v)->IsEngine()) continue;
1045 break;
1046
1047 case VehicleType::Road:
1048 if (!RoadVehicle::From(v)->IsFrontEngine()) continue;
1049 break;
1050
1052 if (!Aircraft::From(v)->IsNormalAircraft()) continue;
1053 break;
1054
1055 default:
1056 break;
1057 }
1058
1059 /* Play a running sound if the motion counter passes 256 (Do we not skip sounds?) */
1061
1062 /* Play an alternating running sound every 16 ticks */
1063 if (GB(v->tick_counter, 0, 4) == 0) {
1064 /* Play running sound when speed > 0 and not braking */
1065 bool running = (front->cur_speed > 0) && !front->vehstatus.Any({VehState::Stopped, VehState::TrainSlowing});
1067 }
1068
1069 break;
1070 }
1071 }
1072 }
1073
1074 for (auto &it : _vehicles_to_autoreplace) {
1075 Vehicle *v = Vehicle::Get(it.first);
1076 /* Autoreplace needs the current company set as the vehicle owner */
1077 AutoRestoreBackup cur_company(_current_company, v->owner);
1078
1079 /* Start vehicle if we stopped them in VehicleEnteredDepotThisTick()
1080 * We need to stop them between VehicleEnteredDepotThisTick() and here or we risk that
1081 * they are already leaving the depot again before being replaced. */
1082 if (it.second) v->vehstatus.Reset(VehState::Stopped);
1083
1084 /* Store the position of the effect as the vehicle pointer will become invalid later */
1085 int x = v->x_pos;
1086 int y = v->y_pos;
1087 int z = v->z_pos;
1088
1091 CommandCost res = Command<Commands::AutoreplaceVehicle>::Do(DoCommandFlag::Execute, v->index);
1093
1094 if (!IsLocalCompany()) continue;
1095
1096 if (res.Succeeded()) {
1097 ShowCostOrIncomeAnimation(x, y, z, res.GetCost());
1098 continue;
1099 }
1100
1101 StringID error_message = res.GetErrorMessage();
1102 if (error_message == STR_ERROR_AUTOREPLACE_NOTHING_TO_DO || error_message == INVALID_STRING_ID) continue;
1103
1104 if (error_message == STR_ERROR_NOT_ENOUGH_CASH_REQUIRES_CURRENCY) error_message = STR_ERROR_AUTOREPLACE_MONEY_LIMIT;
1105
1106 EncodedString headline;
1107 if (error_message == STR_ERROR_TRAIN_TOO_LONG_AFTER_REPLACEMENT) {
1108 headline = GetEncodedString(error_message, v->index);
1109 } else {
1110 headline = GetEncodedString(STR_NEWS_VEHICLE_AUTORENEW_FAILED, v->index, error_message, std::monostate{});
1111 }
1112
1113 AddVehicleAdviceNewsItem(AdviceType::AutorenewFailed, std::move(headline), v->index);
1114 }
1115}
1116
1121static void DoDrawVehicle(const Vehicle *v)
1122{
1123 PaletteID pal = PAL_NONE;
1124
1126
1127 /* Check whether the vehicle shall be transparent due to the game state */
1128 bool shadowed = v->vehstatus.Test(VehState::Shadow);
1129
1130 if (v->type == VehicleType::Effect) {
1131 /* Check whether the vehicle shall be transparent/invisible due to GUI settings.
1132 * However, transparent smoke and bubbles look weird, so always hide them. */
1134 if (to != TransparencyOption::Invalid && (IsTransparencySet(to) || IsInvisibilitySet(to))) return;
1135 }
1136
1138 for (uint i = 0; i < v->sprite_cache.sprite_seq.count; ++i) {
1139 PaletteID pal2 = v->sprite_cache.sprite_seq.seq[i].pal;
1140 if (!pal2 || v->vehstatus.Test(VehState::Crashed)) pal2 = pal;
1141 AddSortableSpriteToDraw(v->sprite_cache.sprite_seq.seq[i].sprite, pal2, v->x_pos, v->y_pos, v->z_pos, v->bounds, shadowed);
1142 }
1144}
1145
1151{
1152 /* The bounding rectangle */
1153 const int l = dpi->left;
1154 const int r = dpi->left + dpi->width;
1155 const int t = dpi->top;
1156 const int b = dpi->top + dpi->height;
1157
1158 /* Border size of MAX_VEHICLE_PIXEL_xy */
1159 const int xb = MAX_VEHICLE_PIXEL_X * ZOOM_BASE;
1160 const int yb = MAX_VEHICLE_PIXEL_Y * ZOOM_BASE;
1161
1162 /* The hash area to scan */
1163 uint xl, xu, yl, yu;
1164
1165 if (static_cast<uint>(dpi->width + xb) < GEN_HASHX_SIZE) {
1166 xl = GetViewportHashX(l - xb);
1167 xu = GetViewportHashX(r);
1168 } else {
1169 /* scan whole hash row */
1170 xl = 0;
1171 xu = GEN_HASHX_MASK;
1172 }
1173
1174 if (static_cast<uint>(dpi->height + yb) < GEN_HASHY_SIZE) {
1175 yl = GetViewportHashY(t - yb);
1176 yu = GetViewportHashY(b);
1177 } else {
1178 /* scan whole column */
1179 yl = 0;
1180 yu = GEN_HASHY_MASK;
1181 }
1182
1183 for (uint y = yl;; y = (y + GEN_HASHY_INC) & GEN_HASHY_MASK) {
1184 for (uint x = xl;; x = (x + GEN_HASHX_INC) & GEN_HASHX_MASK) {
1185 const Vehicle *v = _vehicle_viewport_hash[x + y]; // already masked & 0xFFF
1186
1187 while (v != nullptr) {
1188
1189 if (!v->vehstatus.Test(VehState::Hidden) &&
1190 l <= v->coord.right + xb &&
1191 t <= v->coord.bottom + yb &&
1192 r >= v->coord.left - xb &&
1193 b >= v->coord.top - yb)
1194 {
1195 /*
1196 * This vehicle can potentially be drawn as part of this viewport and
1197 * needs to be revalidated, as the sprite may not be correct.
1198 */
1200 VehicleSpriteSeq seq;
1202
1203 if (seq.IsValid() && v->sprite_cache.sprite_seq != seq) {
1204 v->sprite_cache.sprite_seq = seq;
1205 /*
1206 * A sprite change may also result in a bounding box change,
1207 * so we need to update the bounding box again before we
1208 * check to see if the vehicle should be drawn. Note that
1209 * we can't interfere with the viewport hash at this point,
1210 * so we keep the original hash on the assumption there will
1211 * not be a significant change in the top and left coordinates
1212 * of the vehicle.
1213 */
1215
1216 }
1217
1219 }
1220
1221 if (l <= v->coord.right &&
1222 t <= v->coord.bottom &&
1223 r >= v->coord.left &&
1224 b >= v->coord.top) DoDrawVehicle(v);
1225 }
1226
1227 v = v->hash_viewport_next;
1228 }
1229
1230 if (x == xu) break;
1231 }
1232
1233 if (y == yu) break;
1234 }
1235}
1236
1244Vehicle *CheckClickOnVehicle(const Viewport &vp, int x, int y)
1245{
1246 Vehicle *found = nullptr;
1247 uint dist, best_dist = UINT_MAX;
1248
1249 x -= vp.left;
1250 y -= vp.top;
1251 if (!IsInsideMM(x, 0, vp.width) || !IsInsideMM(y, 0, vp.height)) return nullptr;
1252
1253 x = ScaleByZoom(x, vp.zoom) + vp.virtual_left;
1254 y = ScaleByZoom(y, vp.zoom) + vp.virtual_top;
1255
1256 /* Border size of MAX_VEHICLE_PIXEL_xy */
1257 const int xb = MAX_VEHICLE_PIXEL_X * ZOOM_BASE;
1258 const int yb = MAX_VEHICLE_PIXEL_Y * ZOOM_BASE;
1259
1260 /* The hash area to scan */
1261 uint xl = GetViewportHashX(x - xb);
1262 uint xu = GetViewportHashX(x);
1263 uint yl = GetViewportHashY(y - yb);
1264 uint yu = GetViewportHashY(y);
1265
1266 for (uint hy = yl;; hy = (hy + GEN_HASHY_INC) & GEN_HASHY_MASK) {
1267 for (uint hx = xl;; hx = (hx + GEN_HASHX_INC) & GEN_HASHX_MASK) {
1268 Vehicle *v = _vehicle_viewport_hash[hx + hy]; // already masked & 0xFFF
1269
1270 while (v != nullptr) {
1271 if (!v->vehstatus.Any({VehState::Hidden, VehState::Unclickable}) &&
1272 x >= v->coord.left && x <= v->coord.right &&
1273 y >= v->coord.top && y <= v->coord.bottom) {
1274
1275 dist = std::max(
1276 abs(((v->coord.left + v->coord.right) >> 1) - x),
1277 abs(((v->coord.top + v->coord.bottom) >> 1) - y)
1278 );
1279
1280 if (dist < best_dist) {
1281 found = v;
1282 best_dist = dist;
1283 }
1284 }
1285 v = v->hash_viewport_next;
1286 }
1287 if (hx == xu) break;
1288 }
1289 if (hy == yu) break;
1290 }
1291
1292 return found;
1293}
1294
1300{
1301 v->value -= v->value >> 8;
1302 SetWindowDirty(WindowClass::VehicleDetails, v->index);
1303}
1304
1305static const uint8_t _breakdown_chance[64] = {
1306 3, 3, 3, 3, 3, 3, 3, 3,
1307 4, 4, 5, 5, 6, 6, 7, 7,
1308 8, 8, 9, 9, 10, 10, 11, 11,
1309 12, 13, 13, 13, 13, 14, 15, 16,
1310 17, 19, 21, 25, 28, 31, 34, 37,
1311 40, 44, 48, 52, 56, 60, 64, 68,
1312 72, 80, 90, 100, 110, 120, 130, 140,
1313 150, 170, 190, 210, 230, 250, 250, 250,
1314};
1315
1321{
1322 /* Vehicles in the menu don't break down. */
1323 if (_game_mode == GameMode::Menu) return;
1324
1325 /* If both breakdowns and automatic servicing are disabled, we don't decrease reliability or break down. */
1326 if (_settings_game.difficulty.vehicle_breakdowns == VehicleBreakdowns::None && _settings_game.order.no_servicing_if_no_breakdowns) return;
1327
1328 /* With Reduced breakdowns, vehicles (un)loading at stations don't lose reliability. */
1329 if (_settings_game.difficulty.vehicle_breakdowns == VehicleBreakdowns::Reduced && v->current_order.IsType(OT_LOADING)) return;
1330
1331 /* Decrease reliability. */
1332 int rel_old = v->reliability;
1333 v->reliability = Clamp(rel_old - v->reliability_spd_dec, 0, Engine::Get(v->engine_type)->reliability);
1334 if ((rel_old >> 8) != (v->reliability >> 8)) SetWindowDirty(WindowClass::VehicleDetails, v->index);
1335
1336 /* Some vehicles lose reliability but won't break down. */
1337 /* Breakdowns are disabled. */
1338 if (_settings_game.difficulty.vehicle_breakdowns == VehicleBreakdowns::None) return;
1339 /* The vehicle is already broken down. */
1340 if (v->breakdown_ctr != 0) return;
1341 /* The vehicle is stopped or going very slow. */
1342 if (v->cur_speed < 5) return;
1343 /* The vehicle has been manually stopped. */
1344 if (v->vehstatus.Test(VehState::Stopped)) return;
1345
1346 /* Time to consider breaking down. */
1347
1348 uint32_t r = Random();
1349
1350 /* Increase chance of failure. */
1351 int chance = v->breakdown_chance + 1;
1352 if (Chance16I(1, 25, r)) chance += 25;
1354
1355 /* Calculate reliability value to use in comparison. */
1356 int rel = v->reliability;
1357 if (v->type == VehicleType::Ship) rel += 0x6666;
1358
1359 /* Reduce the chance if the player has chosen the Reduced setting. */
1360 if (_settings_game.difficulty.vehicle_breakdowns == VehicleBreakdowns::Reduced) rel += 0x6666;
1361
1362 /* Check the random chance and inform the vehicle of the result. */
1363 if (_breakdown_chance[ClampTo<uint16_t>(rel) >> 10] <= v->breakdown_chance) {
1364 v->breakdown_ctr = GB(r, 16, 6) + 0x3F;
1365 v->breakdown_delay = GB(r, 24, 7) + 0x80;
1366 v->breakdown_chance = 0;
1367 }
1368}
1369
1377{
1378 /* Possible states for Vehicle::breakdown_ctr
1379 * 0 - vehicle is running normally
1380 * 1 - vehicle is currently broken down
1381 * 2 - vehicle is going to break down now
1382 * >2 - vehicle is counting down to the actual breakdown event */
1383 switch (this->breakdown_ctr) {
1384 case 0:
1385 return false;
1386
1387 case 2:
1388 this->breakdown_ctr = 1;
1389
1390 if (this->breakdowns_since_last_service != 255) {
1392 }
1393
1394 if (this->type == VehicleType::Aircraft) {
1395 /* Aircraft just need this flag, the rest is handled elsewhere */
1397 } else {
1398 this->cur_speed = 0;
1399
1401 bool train_or_ship = this->type == VehicleType::Train || this->type == VehicleType::Ship;
1402 SndPlayVehicleFx((_settings_game.game_creation.landscape != LandscapeType::Toyland) ?
1405 }
1406
1407 if (!this->vehstatus.Test(VehState::Hidden) && !EngInfo(this->engine_type)->misc_flags.Test(EngineMiscFlag::NoBreakdownSmoke)) {
1409 if (u != nullptr) u->animation_state = this->breakdown_delay * 2;
1410 }
1411 }
1412
1413 this->MarkDirty(); // Update graphics after speed is zeroed
1414 SetWindowDirty(WindowClass::VehicleView, this->index);
1415 SetWindowDirty(WindowClass::VehicleDetails, this->index);
1416
1417 [[fallthrough]];
1418 case 1:
1419 /* Aircraft breakdowns end only when arriving at the airport */
1420 if (this->type == VehicleType::Aircraft) return false;
1421
1422 /* For trains this function is called twice per tick, so decrease v->breakdown_delay at half the rate */
1423 if ((this->tick_counter & (this->type == VehicleType::Train ? 3 : 1)) == 0) {
1424 if (--this->breakdown_delay == 0) {
1425 this->breakdown_ctr = 0;
1426 this->MarkDirty();
1427 SetWindowDirty(WindowClass::VehicleView, this->index);
1428 }
1429 }
1430 return true;
1431
1432 default:
1433 if (!this->current_order.IsType(OT_LOADING)) this->breakdown_ctr--;
1434 return false;
1435 }
1436}
1437
1449
1455{
1456 if (v->age < CalendarTime::MAX_DATE) v->age++;
1457
1458 if (!v->IsPrimaryVehicle() && (v->type != VehicleType::Train || !Train::From(v)->IsEngine())) return;
1459
1460 auto age = v->age - v->max_age;
1461 for (int32_t i = 0; i <= 4; i++) {
1463 v->reliability_spd_dec <<= 1;
1464 break;
1465 }
1466 }
1467
1468 SetWindowDirty(WindowClass::VehicleDetails, v->index);
1469
1470 /* Don't warn if warnings are disabled */
1471 if (!_settings_client.gui.old_vehicle_warn) return;
1472
1473 /* Don't warn about vehicles which are non-primary (e.g., part of an articulated vehicle), don't belong to us, are crashed, or are stopped */
1474 if (v->Previous() != nullptr || v->owner != _local_company || v->vehstatus.Any({VehState::Crashed, VehState::Stopped})) return;
1475
1476 const Company *c = Company::Get(v->owner);
1477 /* Don't warn if a renew is active */
1478 if (c->settings.engine_renew && v->GetEngine()->company_avail.Any()) return;
1479 /* Don't warn if a replacement is active */
1481
1482 StringID str;
1484 str = STR_NEWS_VEHICLE_IS_GETTING_OLD;
1486 str = STR_NEWS_VEHICLE_IS_GETTING_VERY_OLD;
1488 str = STR_NEWS_VEHICLE_IS_GETTING_VERY_OLD_AND;
1489 } else {
1490 return;
1491 }
1492
1494}
1495
1505uint8_t CalcPercentVehicleFilled(const Vehicle *front, StringID *colour)
1506{
1507 int count = 0;
1508 int max = 0;
1509 int cars = 0;
1510 int unloading = 0;
1511 bool loading = false;
1512
1513 bool is_loading = front->current_order.IsType(OT_LOADING);
1514
1515 /* The station may be nullptr when the (colour) string does not need to be set. */
1517 assert(colour == nullptr || (st != nullptr && is_loading));
1518
1519 bool order_no_load = is_loading && front->current_order.GetLoadType() == OrderLoadType::NoLoad;
1520 bool order_full_load = is_loading && front->current_order.IsFullLoadOrder();
1521
1522 /* Count up max and used */
1523 for (const Vehicle *v = front; v != nullptr; v = v->Next()) {
1524 count += v->cargo.StoredCount();
1525 max += v->cargo_cap;
1526 if (v->cargo_cap != 0 && colour != nullptr) {
1527 unloading += v->vehicle_flags.Test(VehicleFlag::CargoUnloading) ? 1 : 0;
1528 loading |= !order_no_load &&
1529 (order_full_load || st->goods[v->cargo_type].HasRating()) &&
1531 cars++;
1532 }
1533 }
1534
1535 if (colour != nullptr) {
1536 if (unloading == 0 && loading) {
1537 *colour = STR_PERCENT_UP;
1538 } else if (unloading == 0 && !loading) {
1539 *colour = STR_PERCENT_NONE;
1540 } else if (cars == unloading || !loading) {
1541 *colour = STR_PERCENT_DOWN;
1542 } else {
1543 *colour = STR_PERCENT_UP_DOWN;
1544 }
1545 }
1546
1547 /* Train without capacity */
1548 if (max == 0) return 100;
1549
1550 /* Return the percentage */
1551 if (count * 2 < max) {
1552 /* Less than 50%; round up, so that 0% means really empty. */
1553 return CeilDiv(count * 100, max);
1554 } else {
1555 /* More than 50%; round down, so that 100% means really full. */
1556 return (count * 100) / max;
1557 }
1558}
1559
1565{
1566 /* Always work with the front of the vehicle */
1567 assert(v == v->First());
1568
1569 switch (v->type) {
1570 case VehicleType::Train: {
1571 Train *t = Train::From(v);
1572 SetWindowClassesDirty(WindowClass::TrainList);
1573 /* Clear path reservation */
1574 SetDepotReservation(t->tile, false);
1575 if (_settings_client.gui.show_track_reservation) MarkTileDirtyByTile(t->tile);
1576
1578 t->wait_counter = 0;
1582 break;
1583 }
1584
1585 case VehicleType::Road:
1586 SetWindowClassesDirty(WindowClass::RoadVehicleList);
1587 break;
1588
1589 case VehicleType::Ship: {
1590 SetWindowClassesDirty(WindowClass::ShipList);
1591 Ship *ship = Ship::From(v);
1592 ship->state = Track::Depot;
1593 ship->UpdateCache();
1594 ship->UpdateViewport(true, true);
1595 SetWindowDirty(WindowClass::VehicleDepot, v->tile);
1596 break;
1597 }
1598
1600 SetWindowClassesDirty(WindowClass::AircraftList);
1602 break;
1603 default: NOT_REACHED();
1604 }
1605 if (v->type != VehicleType::Train) {
1606 /* Trains update the vehicle list when the first unit enters the depot and calls VehicleEnterDepot() when the last unit enters.
1607 * 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 */
1608 InvalidateWindowData(WindowClass::VehicleDepot, v->tile);
1609 }
1610 SetWindowDirty(WindowClass::VehicleDepot, v->tile);
1611
1613 v->cur_speed = 0;
1614
1616
1617 /* Store that the vehicle entered a depot this tick */
1619
1620 /* After a vehicle trigger, the graphics and properties of the vehicle could change. */
1621 TriggerVehicleRandomisation(v, VehicleRandomTrigger::Depot);
1622 v->MarkDirty();
1623
1624 InvalidateWindowData(WindowClass::VehicleView, v->index);
1625
1626 if (v->current_order.IsType(OT_GOTO_DEPOT)) {
1627 const Order *real_order = v->GetOrder(v->cur_real_order_index);
1628
1629 /* Test whether we are heading for this depot. If not, do nothing.
1630 * Note: The target depot for nearest-/manual-depot-orders is only updated on junctions, but we want to accept every depot. */
1632 real_order != nullptr && !real_order->GetDepotActionType().Test(OrderDepotActionFlag::NearestDepot) &&
1634 /* We are heading for another depot, keep driving. */
1635 return;
1636 }
1637
1638 if (v->current_order.IsRefit()) {
1639 AutoRestoreBackup cur_company(_current_company, v->owner);
1640 CommandCost cost = ExtractCommandCost(Command<Commands::RefitVehicle>::Do(DoCommandFlag::Execute, v->index, v->current_order.GetRefitCargo(), 0xFF, false, false, 0));
1641
1642 if (cost.Failed()) {
1643 _vehicles_to_autoreplace[v->index] = false;
1644 if (v->owner == _local_company) {
1645 /* Notify the user that we stopped the vehicle */
1646 AddVehicleAdviceNewsItem(AdviceType::RefitFailed, GetEncodedString(STR_NEWS_ORDER_REFIT_FAILED, v->index), v->index);
1647 }
1648 } else if (cost.GetCost() != 0) {
1649 v->profit_this_year -= cost.GetCost() << 8;
1650 if (v->owner == _local_company) {
1652 }
1653 }
1654 }
1655
1657 /* Part of orders */
1659 UpdateVehicleTimetable(v, true);
1661 }
1663 /* Vehicles are always stopped on entering depots. Do not restart this one. */
1664 _vehicles_to_autoreplace[v->index] = false;
1665 /* Invalidate last_loading_station. As the link from the station
1666 * before the stop to the station after the stop can't be predicted
1667 * we shouldn't construct it when the vehicle visits the next stop. */
1668 v->last_loading_station = StationID::Invalid();
1669
1670 /* Clear unbunching data. */
1672
1673 /* Announce that the vehicle is waiting to players and AIs. */
1674 if (v->owner == _local_company) {
1675 AddVehicleAdviceNewsItem(AdviceType::VehicleWaiting, GetEncodedString(STR_NEWS_TRAIN_IS_WAITING + to_underlying(v->type), v->index), v->index);
1676 }
1677 AI::NewEvent(v->owner, new ScriptEventVehicleWaitingInDepot(v->index));
1678 }
1679
1680 /* If we've entered our unbunching depot, record the round trip duration. */
1683 if (v->round_trip_time == 0) {
1684 /* This might be our first round trip. */
1685 v->round_trip_time = measured_round_trip;
1686 } else {
1687 /* If we have a previous trip, smooth the effects of outlier trip calculations caused by jams or other interference. */
1688 v->round_trip_time = Clamp(measured_round_trip, (v->round_trip_time / 2), ClampTo<TimerGameTick::Ticks>(v->round_trip_time * 2));
1689 }
1690 }
1691
1693 }
1694}
1695
1696
1702{
1703 UpdateVehicleTileHash(this, false);
1704}
1705
1710void Vehicle::UpdateBoundingBoxCoordinates(bool update_cache) const
1711{
1712 Rect new_coord;
1713 this->sprite_cache.sprite_seq.GetBounds(&new_coord);
1714
1715 /* z-bounds are not used. */
1716 Point pt = RemapCoords(this->x_pos + this->bounds.origin.x + this->bounds.offset.x, this->y_pos + this->bounds.origin.y + this->bounds.offset.y, this->z_pos);
1717 new_coord.left += pt.x;
1718 new_coord.top += pt.y;
1719 new_coord.right += pt.x + 2 * ZOOM_BASE;
1720 new_coord.bottom += pt.y + 2 * ZOOM_BASE;
1721
1722 extern bool _draw_bounding_boxes;
1723 if (_draw_bounding_boxes) {
1724 int x = this->x_pos + this->bounds.origin.x;
1725 int y = this->y_pos + this->bounds.origin.y;
1726 int z = this->z_pos + this->bounds.origin.z;
1727 new_coord.left = std::min(new_coord.left, RemapCoords(x + bounds.extent.x, y, z).x);
1728 new_coord.right = std::max(new_coord.right, RemapCoords(x, y + bounds.extent.y, z).x + 1);
1729 new_coord.top = std::min(new_coord.top, RemapCoords(x, y, z + bounds.extent.z).y);
1730 new_coord.bottom = std::max(new_coord.bottom, RemapCoords(x + bounds.extent.x, y + bounds.extent.y, z).y + 1);
1731 }
1732
1733 if (update_cache) {
1734 /*
1735 * If the old coordinates are invalid, set the cache to the new coordinates for correct
1736 * behaviour the next time the coordinate cache is checked.
1737 */
1738 this->sprite_cache.old_coord = this->coord.left == INVALID_COORD ? new_coord : this->coord;
1739 }
1740 else {
1741 /* Extend the bounds of the existing cached bounding box so the next dirty window is correct */
1742 this->sprite_cache.old_coord.left = std::min(this->sprite_cache.old_coord.left, this->coord.left);
1743 this->sprite_cache.old_coord.top = std::min(this->sprite_cache.old_coord.top, this->coord.top);
1744 this->sprite_cache.old_coord.right = std::max(this->sprite_cache.old_coord.right, this->coord.right);
1745 this->sprite_cache.old_coord.bottom = std::max(this->sprite_cache.old_coord.bottom, this->coord.bottom);
1746 }
1747
1748 this->coord = new_coord;
1749}
1750
1756{
1757 /* If the existing cache is invalid we should ignore it, as it will be set to the current coords by UpdateBoundingBoxCoordinates */
1758 bool ignore_cached_coords = this->sprite_cache.old_coord.left == INVALID_COORD;
1759
1760 this->UpdateBoundingBoxCoordinates(true);
1761
1762 if (ignore_cached_coords) {
1763 UpdateVehicleViewportHash(this, this->coord.left, this->coord.top, INVALID_COORD, INVALID_COORD);
1764 } else {
1765 UpdateVehicleViewportHash(this, this->coord.left, this->coord.top, this->sprite_cache.old_coord.left, this->sprite_cache.old_coord.top);
1766 }
1767
1768 if (dirty) {
1769 if (ignore_cached_coords) {
1770 this->sprite_cache.is_viewport_candidate = this->MarkAllViewportsDirty();
1771 } else {
1772 this->sprite_cache.is_viewport_candidate = ::MarkAllViewportsDirty(
1773 std::min(this->sprite_cache.old_coord.left, this->coord.left),
1774 std::min(this->sprite_cache.old_coord.top, this->coord.top),
1775 std::max(this->sprite_cache.old_coord.right, this->coord.right),
1776 std::max(this->sprite_cache.old_coord.bottom, this->coord.bottom));
1777 }
1778 }
1779}
1780
1785{
1786 if (this->type != VehicleType::Effect) this->UpdatePosition();
1787 this->UpdateViewport(true);
1788}
1789
1795{
1796 return ::MarkAllViewportsDirty(this->coord.left, this->coord.top, this->coord.right, this->coord.bottom);
1797}
1798
1805{
1806 static constexpr DirectionIndexArray<Coord2D<int8_t>> delta_coord{{{
1807 {-1, -1}, // N
1808 {-1, 0}, // NE
1809 {-1, 1}, // E
1810 {0, 1}, // SE
1811 {1, 1}, // S
1812 {1, 0}, // SW
1813 {1, -1}, // W
1814 {0, -1}, // NW
1815 }}};
1816
1817 const Coord2D<int8_t> &coord = delta_coord[v->GetMovingDirection()];
1818 int x = v->x_pos + coord.x;
1819 int y = v->y_pos + coord.y;
1820
1822 gp.x = x;
1823 gp.y = y;
1824 gp.old_tile = v->tile;
1825 gp.new_tile = TileVirtXY(x, y);
1826 return gp;
1827}
1828
1829static const Direction _new_direction_table[] = {
1833};
1834
1835Direction GetDirectionTowards(const Vehicle *v, int x, int y)
1836{
1837 int i = 0;
1838
1839 if (y >= v->y_pos) {
1840 if (y != v->y_pos) i += 3;
1841 i += 3;
1842 }
1843
1844 if (x >= v->x_pos) {
1845 if (x != v->x_pos) i++;
1846 i++;
1847 }
1848
1849 Direction dir = v->GetMovingDirection();
1850
1851 DirDiff dirdiff = DirDifference(_new_direction_table[i], dir);
1852 if (dirdiff == DirDiff::Same) return dir;
1853 return ChangeDir(dir, LimitDirDiff(dirdiff));
1854}
1855
1866{
1867 return _tile_type_procs[GetTileType(tile)]->vehicle_enter_tile_proc(v, tile, x, y);
1868}
1869
1876{
1877 for (auto it = std::begin(this->used_bitmap); it != std::end(this->used_bitmap); ++it) {
1878 BitmapStorage available = ~(*it);
1879 if (available == 0) continue;
1880 return static_cast<UnitID>(std::distance(std::begin(this->used_bitmap), it) * BITMAP_SIZE + FindFirstBit(available) + 1);
1881 }
1882 return static_cast<UnitID>(this->used_bitmap.size() * BITMAP_SIZE + 1);
1883}
1884
1891{
1892 if (index == 0 || index == UINT16_MAX) return index;
1893
1894 index--;
1895
1896 size_t slot = index / BITMAP_SIZE;
1897 if (slot >= this->used_bitmap.size()) this->used_bitmap.resize(slot + 1);
1898 SetBit(this->used_bitmap[index / BITMAP_SIZE], index % BITMAP_SIZE);
1899
1900 return index + 1;
1901}
1902
1908{
1909 if (index == 0 || index == UINT16_MAX) return;
1910
1911 index--;
1912
1913 assert(index / BITMAP_SIZE < this->used_bitmap.size());
1914 ClrBit(this->used_bitmap[index / BITMAP_SIZE], index % BITMAP_SIZE);
1915}
1916
1923{
1924 /* Check whether it is allowed to build another vehicle. */
1925 uint max_veh;
1926 switch (type) {
1927 case VehicleType::Train: max_veh = _settings_game.vehicle.max_trains; break;
1928 case VehicleType::Road: max_veh = _settings_game.vehicle.max_roadveh; break;
1929 case VehicleType::Ship: max_veh = _settings_game.vehicle.max_ships; break;
1930 case VehicleType::Aircraft: max_veh = _settings_game.vehicle.max_aircraft; break;
1931 default: NOT_REACHED();
1932 }
1933
1935 if (c->group_all[type].num_vehicle >= max_veh) return UINT16_MAX; // Currently already at the limit, no room to make a new one.
1936
1937 return c->freeunits[type].NextID();
1938}
1939
1940
1951{
1952 assert(IsCompanyBuildableVehicleType(type));
1953
1954 if (!Company::IsValidID(_local_company)) return false;
1955
1956 UnitID max;
1957 switch (type) {
1958 case VehicleType::Train:
1959 if (!HasAnyRailTypesAvail(_local_company)) return false;
1960 max = _settings_game.vehicle.max_trains;
1961 break;
1962 case VehicleType::Road:
1963 if (!HasAnyRoadTypesAvail(_local_company, subtype)) return false;
1964 max = _settings_game.vehicle.max_roadveh;
1965 break;
1966 case VehicleType::Ship: max = _settings_game.vehicle.max_ships; break;
1967 case VehicleType::Aircraft: max = _settings_game.vehicle.max_aircraft; break;
1968 default: NOT_REACHED();
1969 }
1970
1971 /* We can build vehicle infrastructure when we may build the vehicle type */
1972 if (max > 0) {
1973 /* Can we actually build the vehicle type? */
1974 for (const Engine *e : Engine::IterateType(type)) {
1975 if (type == VehicleType::Road && GetRoadTramType(e->VehInfo<RoadVehicleInfo>().roadtype) != subtype) continue;
1976 if (e->company_avail.Test(_local_company)) return true;
1977 }
1978 return false;
1979 }
1980
1981 /* We should be able to build infrastructure when we have the actual vehicle type */
1982 for (const Vehicle *v : Vehicle::Iterate()) {
1983 if (v->type == VehicleType::Road && GetRoadTramType(RoadVehicle::From(v)->roadtype) != subtype) continue;
1984 if (v->owner == _local_company && v->type == type) return true;
1985 }
1986
1987 return false;
1988}
1989
1990
1998LiveryScheme GetEngineLiveryScheme(EngineID engine_type, EngineID parent_engine_type, const Vehicle *v)
1999{
2000 CargoType cargo_type = v == nullptr ? INVALID_CARGO : v->cargo_type;
2001 const Engine *e = Engine::Get(engine_type);
2002 switch (e->type) {
2003 default: NOT_REACHED();
2004 case VehicleType::Train:
2005 if (v != nullptr && parent_engine_type != EngineID::Invalid() && (UsesWagonOverride(v) || (v->IsArticulatedPart() && e->VehInfo<RailVehicleInfo>().railveh_type != RailVehicleType::Wagon))) {
2006 /* Wagonoverrides use the colour scheme of the front engine.
2007 * Articulated parts use the colour scheme of the first part. (Not supported for articulated wagons) */
2008 engine_type = parent_engine_type;
2009 e = Engine::Get(engine_type);
2010 /* Note: Luckily cargo_type is not needed for engines */
2011 }
2012
2013 if (!IsValidCargoType(cargo_type)) cargo_type = e->GetDefaultCargoType();
2014 if (!IsValidCargoType(cargo_type)) cargo_type = GetCargoTypeByLabel(CT_GOODS); // The vehicle does not carry anything, let's pick some freight cargo
2015 assert(IsValidCargoType(cargo_type));
2017 if (!CargoSpec::Get(cargo_type)->is_freight) {
2018 if (parent_engine_type == EngineID::Invalid()) {
2020 } else {
2021 bool is_mu = EngInfo(parent_engine_type)->misc_flags.Test(EngineMiscFlag::RailIsMU);
2022 switch (RailVehInfo(parent_engine_type)->engclass) {
2023 default: NOT_REACHED();
2029 }
2030 }
2031 } else {
2033 }
2034 } else {
2035 bool is_mu = e->info.misc_flags.Test(EngineMiscFlag::RailIsMU);
2036
2037 switch (e->VehInfo<RailVehicleInfo>().engclass) {
2038 default: NOT_REACHED();
2044 }
2045 }
2046
2047 case VehicleType::Road:
2048 /* Always use the livery of the front */
2049 if (v != nullptr && parent_engine_type != EngineID::Invalid()) {
2050 engine_type = parent_engine_type;
2051 e = Engine::Get(engine_type);
2052 cargo_type = v->First()->cargo_type;
2053 }
2054 if (!IsValidCargoType(cargo_type)) cargo_type = e->GetDefaultCargoType();
2055 if (!IsValidCargoType(cargo_type)) cargo_type = GetCargoTypeByLabel(CT_GOODS); // The vehicle does not carry anything, let's pick some freight cargo
2056 assert(IsValidCargoType(cargo_type));
2057
2058 /* Important: Use Tram Flag of front part. Luckily engine_type refers to the front part here. */
2060 /* Tram */
2062 } else {
2063 /* Bus or truck */
2065 }
2066
2067 case VehicleType::Ship:
2068 if (!IsValidCargoType(cargo_type)) cargo_type = e->GetDefaultCargoType();
2069 if (!IsValidCargoType(cargo_type)) cargo_type = GetCargoTypeByLabel(CT_GOODS); // The vehicle does not carry anything, let's pick some freight cargo
2070 assert(IsValidCargoType(cargo_type));
2072
2074 switch (e->VehInfo<AircraftVehicleInfo>().subtype) {
2075 case AIR_HELI: return LiveryScheme::Helicopter;
2077 case AIR_CTOL | AIR_FAST: return LiveryScheme::LargePlane;
2078 default: NOT_REACHED();
2079 }
2080 }
2081}
2082
2092const Livery *GetEngineLivery(EngineID engine_type, CompanyID company, EngineID parent_engine_type, const Vehicle *v, uint8_t livery_setting)
2093{
2094 const Company *c = Company::Get(company);
2096
2097 if (livery_setting == LIT_ALL || (livery_setting == LIT_COMPANY && company == _local_company)) {
2098 if (v != nullptr) {
2099 const Group *g = Group::GetIfValid(v->First()->group_id);
2100 if (g != nullptr) {
2101 /* Traverse parents until we find a livery or reach the top */
2102 while (!g->livery.in_use.Any({Livery::Flag::Primary, Livery::Flag::Secondary}) && g->parent != GroupID::Invalid()) {
2103 g = Group::Get(g->parent);
2104 }
2105 if (g->livery.in_use.Any({Livery::Flag::Primary, Livery::Flag::Secondary})) return &g->livery;
2106 }
2107 }
2108
2109 /* The default livery is always available for use, but its in_use flag determines
2110 * whether any _other_ liveries are in use. */
2111 if (c->livery[LiveryScheme::Default].in_use.Any({Livery::Flag::Primary, Livery::Flag::Secondary})) {
2112 /* Determine the livery scheme to use */
2113 scheme = GetEngineLiveryScheme(engine_type, parent_engine_type, v);
2114 }
2115 }
2116
2117 return &c->livery[scheme];
2118}
2119
2120
2121static PaletteID GetEngineColourMap(EngineID engine_type, CompanyID company, EngineID parent_engine_type, const Vehicle *v)
2122{
2123 PaletteID map = (v != nullptr) ? v->colourmap : PAL_NONE;
2124
2125 /* Return cached value if any */
2126 if (map != PAL_NONE) return map;
2127
2128 const Engine *e = Engine::Get(engine_type);
2129
2130 /* Check if we should use the colour map callback */
2132 uint16_t callback = GetVehicleCallback(CBID_VEHICLE_COLOUR_MAPPING, 0, 0, engine_type, v);
2133 /* Failure means "use the default two-colour" */
2134 if (callback != CALLBACK_FAILED) {
2135 static_assert(PAL_NONE == 0); // Returning 0x4000 (resp. 0xC000) coincidences with default value (PAL_NONE)
2136 map = GB(callback, 0, 14);
2137 /* If bit 14 is set, then the company colours are applied to the
2138 * map else it's returned as-is. */
2139 if (!HasBit(callback, 14)) {
2140 /* Update cache */
2141 if (v != nullptr) const_cast<Vehicle *>(v)->colourmap = map;
2142 return map;
2143 }
2144 }
2145 }
2146
2147 bool twocc = e->info.misc_flags.Test(EngineMiscFlag::Uses2CC);
2148
2149 if (map == PAL_NONE) map = twocc ? (PaletteID)SPR_2CCMAP_BASE : (PaletteID)PALETTE_RECOLOUR_START;
2150
2151 /* Spectator has news shown too, but has invalid company ID - as well as dedicated server */
2152 if (!Company::IsValidID(company)) return map;
2153
2154 const Livery *livery = GetEngineLivery(engine_type, company, parent_engine_type, v, _settings_client.gui.liveries);
2155
2156 map += livery->GetRecolourOffset(twocc);
2157
2158 /* Update cache */
2159 if (v != nullptr) const_cast<Vehicle *>(v)->colourmap = map;
2160 return map;
2161}
2162
2169PaletteID GetEnginePalette(EngineID engine_type, CompanyID company)
2170{
2171 return GetEngineColourMap(engine_type, company, EngineID::Invalid(), nullptr);
2172}
2173
2180{
2181 if (v->IsGroundVehicle()) {
2182 return GetEngineColourMap(v->engine_type, v->owner, v->GetGroundVehicleCache()->first_engine, v);
2183 }
2184
2185 return GetEngineColourMap(v->engine_type, v->owner, EngineID::Invalid(), v);
2186}
2187
2192{
2193 if (this->IsGroundVehicle()) {
2194 GroundVehicleFlags &gv_flags = this->GetGroundVehicleFlags();
2196 /* Do not delete orders, only skip them */
2199 InvalidateVehicleOrder(this, 0);
2200 return;
2201 }
2202 }
2203
2204 auto orders = this->Orders();
2206 while (cur != INVALID_VEH_ORDER_ID) {
2207 if (this->cur_implicit_order_index == this->cur_real_order_index) break;
2208
2209 if (orders[cur].IsType(OT_IMPLICIT)) {
2211 /* DeleteOrder does various magic with order_indices, so resync 'order' with 'cur_implicit_order_index' */
2212 } else {
2213 /* Skip non-implicit orders, e.g. service-orders */
2214 if (cur < this->orders->GetNext(cur)) {
2216 } else {
2217 /* Wrapped around. */
2218 this->cur_implicit_order_index = 0;
2219 }
2220 cur = this->orders->GetNext(cur);
2221 }
2222 }
2223}
2224
2230{
2232
2234 if (this->current_order.IsType(OT_GOTO_STATION) &&
2235 this->current_order.GetDestination() == this->last_station_visited) {
2237
2238 /* Now both order indices point to the destination station, and we can start loading */
2239 this->current_order.MakeLoading(true);
2240 UpdateVehicleTimetable(this, true);
2241
2242 /* Furthermore add the Non Stop flag to mark that this station
2243 * is the actual destination of the vehicle, which is (for example)
2244 * necessary to be known for HandleTrainLoading to determine
2245 * whether the train is lost or not; not marking a train lost
2246 * that arrives at random stations is bad. */
2248
2249 } else {
2250 /* We weren't scheduled to stop here. Insert an implicit order
2251 * to show that we are stopping here.
2252 * While only groundvehicles have implicit orders, e.g. aircraft might still enter
2253 * the 'wrong' terminal when skipping orders etc. */
2254 Order *in_list = this->GetOrder(this->cur_implicit_order_index);
2255 if (this->IsGroundVehicle() &&
2256 (in_list == nullptr || !in_list->IsType(OT_IMPLICIT) ||
2257 in_list->GetDestination() != this->last_station_visited)) {
2258 bool suppress_implicit_orders = this->GetGroundVehicleFlags().Test(GroundVehicleFlag::SuppressImplicitOrders);
2259 /* Do not create consecutive duplicates of implicit orders */
2260 const Order *prev_order = this->cur_implicit_order_index > 0 ? this->GetOrder(this->cur_implicit_order_index - 1) : (this->GetNumOrders() > 1 ? this->GetLastOrder() : nullptr);
2261 if (prev_order == nullptr ||
2262 (!prev_order->IsType(OT_IMPLICIT) && !prev_order->IsType(OT_GOTO_STATION)) ||
2263 prev_order->GetDestination() != this->last_station_visited) {
2264
2265 /* Prefer deleting implicit orders instead of inserting new ones,
2266 * so test whether the right order follows later. In case of only
2267 * implicit orders treat the last order in the list like an
2268 * explicit one, except if the overall number of orders surpasses
2269 * IMPLICIT_ORDER_ONLY_CAP. */
2270 int target_index = this->cur_implicit_order_index;
2271 bool found = false;
2272 while (target_index != this->cur_real_order_index || this->GetNumManualOrders() == 0) {
2273 const Order *order = this->GetOrder(target_index);
2274 if (order == nullptr) break; // No orders.
2275 if (order->IsType(OT_IMPLICIT) && order->GetDestination() == this->last_station_visited) {
2276 found = true;
2277 break;
2278 }
2279 target_index++;
2280 if (target_index >= this->orders->GetNumOrders()) {
2281 if (this->GetNumManualOrders() == 0 &&
2283 break;
2284 }
2285 target_index = 0;
2286 }
2287 if (target_index == this->cur_implicit_order_index) break; // Avoid infinite loop.
2288 }
2289
2290 if (found) {
2291 if (suppress_implicit_orders) {
2292 /* Skip to the found order */
2293 this->cur_implicit_order_index = target_index;
2294 InvalidateVehicleOrder(this, 0);
2295 } else {
2296 /* Delete all implicit orders up to the station we just reached */
2297 const Order *order = this->GetOrder(this->cur_implicit_order_index);
2298 while (!order->IsType(OT_IMPLICIT) || order->GetDestination() != this->last_station_visited) {
2299 if (order->IsType(OT_IMPLICIT)) {
2301 } else {
2302 /* Skip non-implicit orders, e.g. service-orders */
2304 }
2305 order = this->GetOrder(this->cur_implicit_order_index);
2306
2307 /* Wrapped around. */
2308 if (order == nullptr) {
2309 this->cur_implicit_order_index = 0;
2310 order = this->GetOrder(this->cur_implicit_order_index);
2311 }
2312 assert(order != nullptr);
2313 }
2314 }
2315 } else if (!suppress_implicit_orders &&
2316 (this->orders == nullptr ? OrderList::CanAllocateItem() : this->orders->GetNumOrders() < MAX_VEH_ORDER_ID)) {
2317 /* Insert new implicit order */
2318 Order implicit_order{};
2319 implicit_order.MakeImplicit(this->last_station_visited);
2320 InsertOrder(this, std::move(implicit_order), this->cur_implicit_order_index);
2322
2323 /* InsertOrder disabled creation of implicit orders for all vehicles with the same implicit order.
2324 * Reenable it for this vehicle */
2326 }
2327 }
2328 }
2329 this->current_order.MakeLoading(false);
2330 }
2331
2332 if (this->last_loading_station != StationID::Invalid() &&
2334 (this->current_order.GetLoadType() != OrderLoadType::NoLoad ||
2335 this->current_order.GetUnloadType() != OrderUnloadType::NoUnload)) {
2336 IncreaseStats(Station::Get(this->last_loading_station), this, this->last_station_visited, travel_time);
2337 }
2338
2339 PrepareUnload(this);
2340
2342 SetWindowWidgetDirty(WindowClass::VehicleView, this->index, WID_VV_START_STOP);
2343 SetWindowDirty(WindowClass::VehicleDetails, this->index);
2344 SetWindowDirty(WindowClass::StationView, this->last_station_visited);
2345
2347 this->cur_speed = 0;
2348 this->MarkDirty();
2349}
2350
2358{
2359 for (Vehicle *v = this; v != nullptr; v = v->next) {
2361 if (cargo.ActionCount(VehicleCargoList::MoveToAction::Load) > 0) {
2362 Debug(Facility::Misc, Severity::Error, "cancelling cargo reservation");
2363 cargo.Return(UINT_MAX, &st->goods[v->cargo_type].GetOrCreateData().cargo, next, v->tile);
2364 }
2365 cargo.KeepAll();
2366 }
2367}
2368
2374{
2375 assert(this->current_order.IsType(OT_LOADING));
2376
2377 delete this->cargo_payment;
2378 assert(this->cargo_payment == nullptr); // cleared by ~CargoPayment
2379
2380 /* Only update the timetable if the vehicle was supposed to stop here. */
2381 if (this->current_order.GetNonStopType().Any()) UpdateVehicleTimetable(this, false);
2382
2383 if (this->current_order.GetLoadType() != OrderLoadType::NoLoad ||
2384 this->current_order.GetUnloadType() != OrderUnloadType::NoUnload) {
2385 if (this->current_order.CanLeaveWithCargo(this->last_loading_station != StationID::Invalid())) {
2386 /* Refresh next hop stats to make sure we've done that at least once
2387 * during the stop and that refit_cap == cargo_cap for each vehicle in
2388 * the consist. */
2389 this->ResetRefitCaps();
2390 LinkRefresher::Run(this);
2391
2392 /* if the vehicle could load here or could stop with cargo loaded set the last loading station */
2395 } else {
2396 /* if the vehicle couldn't load and had to unload or transfer everything
2397 * set the last loading station to invalid as it will leave empty. */
2398 this->last_loading_station = StationID::Invalid();
2399 }
2400 }
2401
2402 this->current_order.MakeLeaveStation();
2404 this->CancelReservation(StationID::Invalid(), st);
2405 st->loading_vehicles.remove(this);
2406
2409
2410 if (this->type == VehicleType::Train && !this->vehstatus.Test(VehState::Crashed)) {
2411 /* Trigger station animation (trains only) */
2412 TileIndex tile = this->GetMovingFront()->tile;
2415 TriggerStationAnimation(st, tile, StationAnimationTrigger::VehicleDeparts);
2416 }
2417
2419 }
2420 if (this->type == VehicleType::Road && !this->vehstatus.Test(VehState::Crashed)) {
2421 /* Trigger road stop animation */
2422 if (IsStationRoadStopTile(this->tile)) {
2424 TriggerRoadStopAnimation(st, this->tile, StationAnimationTrigger::VehicleDeparts);
2425 }
2426 }
2427
2428
2429 this->MarkDirty();
2430}
2431
2436{
2437 for (Vehicle *v = this; v != nullptr; v = v->Next()) v->refit_cap = v->cargo_cap;
2438}
2439
2444{
2445 Company::Get(this->owner)->freeunits[this->type].ReleaseID(this->unitnumber);
2446 this->unitnumber = 0;
2447}
2448
2455{
2456 switch (this->current_order.GetType()) {
2457 case OT_LOADING: {
2458 TimerGameTick::Ticks wait_time = std::max(this->current_order.GetTimetabledWait() - this->lateness_counter, 0);
2459
2460 /* Not the first call for this tick, or still loading */
2461 if (mode || !this->vehicle_flags.Test(VehicleFlag::LoadingFinished) || this->current_order_time < wait_time) return;
2462
2463 this->PlayLeaveStationSound();
2464
2465 this->LeaveStation();
2466
2467 /* Only advance to next order if we just loaded at the current one */
2468 const Order *order = this->GetOrder(this->cur_implicit_order_index);
2469 if (order == nullptr ||
2470 (!order->IsType(OT_IMPLICIT) && !order->IsType(OT_GOTO_STATION)) ||
2471 order->GetDestination() != this->last_station_visited) {
2472 return;
2473 }
2474 break;
2475 }
2476
2477 case OT_DUMMY: break;
2478
2479 default: return;
2480 }
2481
2483}
2484
2490{
2491 return std::ranges::any_of(this->Orders(), [](const Order &o) {
2492 return o.IsType(OT_GOTO_STATION) && o.IsFullLoadOrder();
2493 });
2494}
2495
2501{
2502 return std::ranges::any_of(this->Orders(), [](const Order &o) { return o.IsType(OT_CONDITIONAL); });
2503}
2504
2510{
2511 return std::ranges::any_of(this->Orders(), [](const Order &o) {
2512 return o.IsType(OT_GOTO_DEPOT) && o.GetDepotActionType().Test(OrderDepotActionFlag::Unbunch);
2513 });
2514}
2515
2522{
2523 /* If we are headed for the first order, we must wrap around back to the last order. */
2524 bool is_first_order = (v->GetOrder(v->cur_implicit_order_index) == v->GetFirstOrder());
2525 const Order *previous_order = (is_first_order) ? v->GetLastOrder() : v->GetOrder(v->cur_implicit_order_index - 1);
2526
2527 if (previous_order == nullptr || !previous_order->IsType(OT_GOTO_DEPOT)) return false;
2528 return previous_order->GetDepotActionType().Test(OrderDepotActionFlag::Unbunch);
2529}
2530
2535{
2536 /* Don't do anything if this is not our unbunching order. */
2537 if (!PreviousOrderIsUnbunching(this)) return;
2538
2539 /* Set the start point for this round trip time. */
2541
2542 /* Tell the timetable we are now "on time." */
2543 this->lateness_counter = 0;
2544 SetWindowDirty(WindowClass::VehicleTimetable, this->index);
2545
2546 /* Find the average travel time of vehicles that we share orders with. */
2547 int num_vehicles = 0;
2548 TimerGameTick::Ticks total_travel_time = 0;
2549
2550 Vehicle *u = this->FirstShared();
2551 for (; u != nullptr; u = u->NextShared()) {
2552 /* Ignore vehicles that are manually stopped or crashed. */
2553 if (u->vehstatus.Any({VehState::Stopped, VehState::Crashed})) continue;
2554
2555 num_vehicles++;
2556 total_travel_time += u->round_trip_time;
2557 }
2558
2559 /* Make sure we cannot divide by 0. */
2560 num_vehicles = std::max(num_vehicles, 1);
2561
2562 /* Calculate the separation by finding the average travel time, then calculating equal separation (minimum 1 tick) between vehicles. */
2563 TimerGameTick::Ticks separation = std::max((total_travel_time / num_vehicles / num_vehicles), 1);
2564 TimerGameTick::TickCounter next_departure = TimerGameTick::counter + separation;
2565
2566 /* Set the departure time of all vehicles that we share orders with. */
2567 u = this->FirstShared();
2568 for (; u != nullptr; u = u->NextShared()) {
2569 /* Ignore vehicles that are manually stopped or crashed. */
2570 if (u->vehstatus.Any({VehState::Stopped, VehState::Crashed})) continue;
2571
2572 u->depot_unbunching_next_departure = next_departure;
2573 InvalidateWindowData(WindowClass::VehicleView, u->index);
2574 }
2575}
2576
2582{
2583 assert(this->IsInDepot());
2584
2585 /* Don't bother if there are no vehicles sharing orders. */
2586 if (!this->IsOrderListShared()) return false;
2587
2588 /* Don't do anything if there aren't enough orders. */
2589 if (this->GetNumOrders() <= 1) return false;
2590
2591 /* Don't do anything if this is not our unbunching order. */
2592 if (!PreviousOrderIsUnbunching(this)) return false;
2593
2595};
2596
2604{
2605 CommandCost ret = CheckOwnership(this->owner);
2606 if (ret.Failed()) return ret;
2607
2608 if (this->vehstatus.Test(VehState::Crashed)) return CMD_ERROR;
2609 if (this->IsStoppedInDepot()) return CMD_ERROR;
2610
2611 /* No matter why we're headed to the depot, unbunching data is no longer valid. */
2613
2614 if (this->current_order.IsType(OT_GOTO_DEPOT)) {
2615 bool halt_in_depot = this->current_order.GetDepotActionType().Test(OrderDepotActionFlag::Halt);
2616 if (command.Test(DepotCommandFlag::Service) == halt_in_depot) {
2617 /* We called with a different DEPOT_SERVICE setting.
2618 * Now we change the setting to apply the new one and let the vehicle head for the same depot.
2619 * Note: the if is (true for requesting service == true for ordered to stop in depot) */
2620 if (flags.Test(DoCommandFlag::Execute)) {
2621 this->current_order.SetDepotOrderType({});
2622 this->current_order.SetDepotActionType(halt_in_depot ? OrderDepotActionFlags{} : OrderDepotActionFlag::Halt);
2623 InvalidateWindowData(WindowClass::VehicleView, this->index);
2624 }
2625 return CommandCost();
2626 }
2627
2628 if (command.Test(DepotCommandFlag::DontCancel)) return CMD_ERROR; // Requested no cancellation of depot orders
2629 if (flags.Test(DoCommandFlag::Execute)) {
2630 /* If the orders to 'goto depot' are in the orders list (forced servicing),
2631 * then skip to the next order; effectively cancelling this forced service */
2632 if (this->current_order.GetDepotOrderType().Test(OrderDepotTypeFlag::PartOfOrders)) this->IncrementRealOrderIndex();
2633
2634 if (this->IsGroundVehicle()) {
2636 }
2637
2638 this->current_order.MakeDummy();
2639 InvalidateWindowData(WindowClass::VehicleView, this->index);
2640 }
2641 return CommandCost();
2642 }
2643
2644 ClosestDepot closest_depot = this->FindClosestDepot();
2645 static constexpr VehicleTypeIndexArray<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_UNABLE_TO_FIND_LOCAL_HANGAR};
2646 if (!closest_depot.found) return CommandCost(no_depot[this->type]);
2647
2648 if (flags.Test(DoCommandFlag::Execute)) {
2649 if (this->current_order.IsType(OT_LOADING)) this->LeaveStation();
2650
2651 if (this->IsGroundVehicle() && this->GetNumManualOrders() > 0) {
2653 }
2654
2655 this->SetDestTile(closest_depot.location);
2656 this->current_order.MakeGoToDepot(closest_depot.destination.ToDepotID(), {});
2657 if (!command.Test(DepotCommandFlag::Service)) this->current_order.SetDepotActionType(OrderDepotActionFlag::Halt);
2658 InvalidateWindowData(WindowClass::VehicleView, this->index);
2659
2660 /* If there is no depot in front and the train is not already reversing, reverse automatically (trains only) */
2661 if (this->type == VehicleType::Train && (closest_depot.reverse ^ Train::From(this)->flags.Test(VehicleRailFlag::Reversing))) {
2662 Command<Commands::ReverseTrainDirection>::Do(DoCommandFlag::Execute, this->index, false);
2663 }
2664
2665 if (this->type == VehicleType::Aircraft) {
2666 Aircraft *a = Aircraft::From(this);
2667 if (a->state == FLYING && a->targetairport != closest_depot.destination) {
2668 /* The aircraft is now heading for a different hangar than the next in the orders */
2670 }
2671 }
2672 }
2673
2674 return CommandCost();
2675
2676}
2677
2682void Vehicle::UpdateVisualEffect(bool allow_power_change)
2683{
2684 bool powered_before = HasBit(this->vcache.cached_vis_effect, VE_DISABLE_WAGON_POWER);
2685 const Engine *e = this->GetEngine();
2686
2687 /* Evaluate properties */
2688 uint8_t visual_effect;
2689 switch (e->type) {
2690 case VehicleType::Train: visual_effect = e->VehInfo<RailVehicleInfo>().visual_effect; break;
2691 case VehicleType::Road: visual_effect = e->VehInfo<RoadVehicleInfo>().visual_effect; break;
2692 case VehicleType::Ship: visual_effect = e->VehInfo<ShipVehicleInfo>().visual_effect; break;
2693 default: visual_effect = 1 << VE_DISABLE_EFFECT; break;
2694 }
2695
2696 /* Check powered wagon / visual effect callback */
2698 uint16_t callback = GetVehicleCallback(CBID_VEHICLE_VISUAL_EFFECT, 0, 0, this->engine_type, this);
2699
2700 if (callback != CALLBACK_FAILED) {
2701 if (callback >= 0x100 && e->GetGRF()->grf_version >= 8) ErrorUnknownCallbackResult(e->GetGRFID(), CBID_VEHICLE_VISUAL_EFFECT, callback);
2702
2703 callback = GB(callback, 0, 8);
2704 /* Avoid accidentally setting 'visual_effect' to the default value
2705 * Since bit 6 (disable effects) is set anyways, we can safely erase some bits. */
2706 if (callback == VE_DEFAULT) {
2707 assert(HasBit(callback, VE_DISABLE_EFFECT));
2708 SB(callback, VE_TYPE_START, VE_TYPE_COUNT, 0);
2709 }
2710 visual_effect = callback;
2711 }
2712 }
2713
2714 /* Apply default values */
2715 if (visual_effect == VE_DEFAULT ||
2716 (!HasBit(visual_effect, VE_DISABLE_EFFECT) && GB(visual_effect, VE_TYPE_START, VE_TYPE_COUNT) == VE_TYPE_DEFAULT)) {
2717 /* Only train engines have default effects.
2718 * Note: This is independent of whether the engine is a front engine or articulated part or whatever. */
2720 if (visual_effect == VE_DEFAULT) {
2721 visual_effect = 1 << VE_DISABLE_EFFECT;
2722 } else {
2723 SetBit(visual_effect, VE_DISABLE_EFFECT);
2724 }
2725 } else {
2726 if (visual_effect == VE_DEFAULT) {
2727 /* Also set the offset */
2728 visual_effect = (VE_OFFSET_CENTRE - (e->VehInfo<RailVehicleInfo>().engclass == EngineClass::Steam ? 4 : 0)) << VE_OFFSET_START;
2729 }
2731 }
2732 }
2733
2734 this->vcache.cached_vis_effect = visual_effect;
2735
2736 if (!allow_power_change && powered_before != HasBit(this->vcache.cached_vis_effect, VE_DISABLE_WAGON_POWER)) {
2737 ToggleBit(this->vcache.cached_vis_effect, VE_DISABLE_WAGON_POWER);
2738 ShowNewGrfVehicleError(this->engine_type, STR_NEWGRF_BROKEN, STR_NEWGRF_BROKEN_POWERED_WAGON, GRFBug::VehPoweredWagon, false);
2739 }
2740}
2741
2744 1, 1, 1, 0, -1, -1, -1, 0
2745};
2746
2752{
2753 std::array<int32_t, 4> regs100;
2754 uint16_t callback = GetVehicleCallback(CBID_VEHICLE_SPAWN_VISUAL_EFFECT, 0, Random(), v->engine_type, v, regs100);
2755 if (callback == CALLBACK_FAILED) return;
2756
2757 uint count = GB(callback, 0, 2);
2758 assert(count <= std::size(regs100));
2759 bool auto_center = HasBit(callback, 13);
2760 bool auto_rotate = !HasBit(callback, 14);
2761
2762 int8_t l_center = 0;
2763 if (auto_center) {
2764 /* For road vehicles: Compute offset from vehicle position to vehicle center */
2765 if (v->type == VehicleType::Road) l_center = -(int)(VEHICLE_LENGTH - RoadVehicle::From(v)->gcache.cached_veh_length) / 2;
2766 } else {
2767 /* For trains: Compute offset from vehicle position to sprite position */
2769 }
2770
2771 Direction l_dir = v->direction;
2772 if ((v->type == VehicleType::Train && Train::From(v)->flags.Test(VehicleRailFlag::Flipped))
2773 || (v->type == VehicleType::Ship && Ship::From(v)->flags.Test(VehicleShipFlag::SecondEndFacingForward))) l_dir = ReverseDir(l_dir);
2774 Direction t_dir = ChangeDir(l_dir, DirDiff::Right90);
2775
2776 int8_t x_center = _vehicle_smoke_pos[l_dir] * l_center;
2777 int8_t y_center = _vehicle_smoke_pos[t_dir] * l_center;
2778
2779 for (uint i = 0; i < count; i++) {
2780 int32_t reg = regs100[i];
2781 uint type = GB(reg, 0, 8);
2782 int8_t x = GB(reg, 8, 8);
2783 int8_t y = GB(reg, 16, 8);
2784 int8_t z = GB(reg, 24, 8);
2785
2786 if (auto_rotate) {
2787 int8_t l = x;
2788 int8_t t = y;
2789 x = _vehicle_smoke_pos[l_dir] * l + _vehicle_smoke_pos[t_dir] * t;
2790 y = _vehicle_smoke_pos[t_dir] * l - _vehicle_smoke_pos[l_dir] * t;
2791 }
2792
2793 if (type >= 0xF0) {
2794 switch (type) {
2795 case 0xF1: CreateEffectVehicleRel(v, x_center + x, y_center + y, z, EV_STEAM_SMOKE); break;
2796 case 0xF2: CreateEffectVehicleRel(v, x_center + x, y_center + y, z, EV_DIESEL_SMOKE); break;
2797 case 0xF3: CreateEffectVehicleRel(v, x_center + x, y_center + y, z, EV_ELECTRIC_SPARK); break;
2798 case 0xFA: CreateEffectVehicleRel(v, x_center + x, y_center + y, z, EV_BREAKDOWN_SMOKE_AIRCRAFT); break;
2799 default: break;
2800 }
2801 }
2802 }
2803}
2804
2810static bool IsBridgeAboveVehicle(const Vehicle *v)
2811{
2812 if (IsBridgeTile(v->tile)) {
2813 /* If the vehicle is 'on' a bridge tile, check the real position of the vehicle. If it's different then the
2814 * vehicle is on the middle of the bridge, which cannot have a bridge above. */
2815 TileIndex tile = TileVirtXY(v->x_pos, v->y_pos);
2816 if (tile != v->tile) return false;
2817 }
2818 return IsBridgeAbove(v->tile);
2819}
2820
2821
2831
2837{
2838 assert(this->IsPrimaryVehicle());
2839 bool sound = false;
2840
2841 /* Do not show any smoke when:
2842 * - vehicle smoke is disabled by the player
2843 * - the vehicle is slowing down or stopped (by the player)
2844 * - the vehicle is moving very slowly
2845 */
2846 if (_settings_game.vehicle.smoke_amount == 0 ||
2847 this->vehstatus.Any({VehState::TrainSlowing, VehState::Stopped}) ||
2848 this->cur_speed < 2) {
2849 return;
2850 }
2851
2852 /* Use the speed as limited by underground and orders. */
2853 uint max_speed = this->GetCurrentMaxSpeed();
2854
2855 if (this->type == VehicleType::Train) {
2856 const Train *t = Train::From(this);
2857 const Train *moving_front = t->GetMovingFront();
2858 /* For trains, do not show any smoke when:
2859 * - the train is reversing
2860 * - is entering a station with an order to stop there and its speed is equal to maximum station entering speed
2861 */
2863 (IsRailStationTile(moving_front->tile) && t->IsFrontEngine() && t->current_order.ShouldStopAtStation(t, GetStationIndex(moving_front->tile)) &&
2864 t->cur_speed >= max_speed)) {
2865 return;
2866 }
2867 }
2868
2869 const Vehicle *v = this;
2870
2871 do {
2875 if (advanced) {
2876 effect_offset = VE_OFFSET_CENTRE;
2877 effect_model = static_cast<VisualEffectSpawnModel>(GB(v->vcache.cached_vis_effect, 0, VE_ADVANCED_EFFECT));
2878 if (effect_model >= VisualEffectSpawnModel::End) effect_model = VisualEffectSpawnModel::None; // unknown spawning model
2879 } else {
2881 assert(to_underlying(effect_model) != to_underlying(VE_TYPE_DEFAULT)); // should have been resolved by UpdateVisualEffect
2885 }
2886
2887 /* Show no smoke when:
2888 * - Smoke has been disabled for this vehicle
2889 * - The vehicle is not visible
2890 * - The vehicle is under a bridge
2891 * - The vehicle is on a depot tile
2892 * - The vehicle is on a tunnel tile
2893 * - The vehicle is a train engine that is currently unpowered */
2894 if (effect_model == VisualEffectSpawnModel::None ||
2897 IsDepotTile(v->tile) ||
2898 IsTunnelTile(v->tile) ||
2899 (v->type == VehicleType::Train &&
2900 !HasPowerOnRail(Train::From(v)->railtypes, GetTileRailType(v->tile)))) {
2901 continue;
2902 }
2903
2904 EffectVehicleType evt = EV_END;
2905 switch (effect_model) {
2907 /* Steam smoke - amount is gradually falling until vehicle reaches its maximum speed, after that it's normal.
2908 * Details: while vehicle's current speed is gradually increasing, steam plumes' density decreases by one third each
2909 * third of its maximum speed spectrum. Steam emission finally normalises at very close to vehicle's maximum speed.
2910 * REGULATION:
2911 * - instead of 1, 4 / 2^smoke_amount (max. 2) is used to provide sufficient regulation to steam puffs' amount. */
2912 if (GB(v->tick_counter, 0, ((4 >> _settings_game.vehicle.smoke_amount) + ((this->cur_speed * 3) / max_speed))) == 0) {
2913 evt = EV_STEAM_SMOKE;
2914 }
2915 break;
2916
2918 /* Diesel smoke - thicker when vehicle is starting, gradually subsiding till it reaches its maximum speed
2919 * when smoke emission stops.
2920 * Details: Vehicle's (max.) speed spectrum is divided into 32 parts. When max. speed is reached, chance for smoke
2921 * emission erodes by 32 (1/4). For trains, power and weight come in handy too to either increase smoke emission in
2922 * 6 steps (1000HP each) if the power is low or decrease smoke emission in 6 steps (512 tonnes each) if the train
2923 * isn't overweight. Power and weight contributions are expressed in a way that neither extreme power, nor
2924 * extreme weight can ruin the balance (e.g. FreightWagonMultiplier) in the formula. When the vehicle reaches
2925 * maximum speed no diesel_smoke is emitted.
2926 * REGULATION:
2927 * - up to which speed a diesel vehicle is emitting smoke (with reduced/small setting only until 1/2 of max_speed),
2928 * - in Chance16 - the last value is 512 / 2^smoke_amount (max. smoke when 128 = smoke_amount of 2). */
2929 int power_weight_effect = 0;
2930 if (v->type == VehicleType::Train) {
2931 power_weight_effect = (32 >> (Train::From(this)->gcache.cached_power >> 10)) - (32 >> (Train::From(this)->gcache.cached_weight >> 9));
2932 }
2933 if (this->cur_speed < (max_speed >> (2 >> _settings_game.vehicle.smoke_amount)) &&
2934 Chance16((64 - ((this->cur_speed << 5) / max_speed) + power_weight_effect), (512 >> _settings_game.vehicle.smoke_amount))) {
2935 evt = EV_DIESEL_SMOKE;
2936 }
2937 break;
2938 }
2939
2941 /* Electric train's spark - more often occurs when train is departing (more load)
2942 * Details: Electric locomotives are usually at least twice as powerful as their diesel counterparts, so spark
2943 * emissions are kept simple. Only when starting, creating huge force are sparks more likely to happen, but when
2944 * reaching its max. speed, quarter by quarter of it, chance decreases until the usual 2,22% at train's top speed.
2945 * REGULATION:
2946 * - in Chance16 the last value is 360 / 2^smoke_amount (max. sparks when 90 = smoke_amount of 2). */
2947 if (GB(v->tick_counter, 0, 2) == 0 &&
2948 Chance16((6 - ((this->cur_speed << 2) / max_speed)), (360 >> _settings_game.vehicle.smoke_amount))) {
2949 evt = EV_ELECTRIC_SPARK;
2950 }
2951 break;
2952
2953 default:
2954 NOT_REACHED();
2955 }
2956
2957 if (evt != EV_END && advanced) {
2958 sound = true;
2960 } else if (evt != EV_END) {
2961 sound = true;
2962
2963 /* The effect offset is relative to a point 4 units behind the vehicle's
2964 * front (which is the center of an 8/8 vehicle). Shorter vehicles need a
2965 * correction factor. */
2966 if (v->type == VehicleType::Train) effect_offset += (VEHICLE_LENGTH - Train::From(v)->gcache.cached_veh_length) / 2;
2967
2968 int x = _vehicle_smoke_pos[v->direction] * effect_offset;
2969 int y = _vehicle_smoke_pos[ChangeDir(v->direction, DirDiff::Right90)] * effect_offset;
2970
2971 if ((v->type == VehicleType::Train && Train::From(v)->flags.Test(VehicleRailFlag::Flipped))
2973 x = -x;
2974 y = -y;
2975 }
2976
2977 CreateEffectVehicleRel(v, x, y, 10, evt);
2978 }
2979 } while ((v = v->Next()) != nullptr);
2980
2982}
2983
2989{
2990 assert(this != next);
2991
2992 if (this->next != nullptr) {
2993 /* We had an old next vehicle. Update the first and previous pointers */
2994 for (Vehicle *v = this->next; v != nullptr; v = v->Next()) {
2995 v->first = this->next;
2996 }
2997 this->next->previous = nullptr;
2998 }
2999
3000 this->next = next;
3001
3002 if (this->next != nullptr) {
3003 /* A new next vehicle. Update the first and previous pointers */
3004 if (this->next->previous != nullptr) this->next->previous->next = nullptr;
3005 this->next->previous = this;
3006 for (Vehicle *v = this->next; v != nullptr; v = v->Next()) {
3007 v->first = this->first;
3008 }
3009 }
3010
3011 /* Update last vehicle of the entire chain. */
3012 Vehicle *new_last = this;
3013 while (new_last->Next() != nullptr) new_last = new_last->Next();
3014 for (Vehicle *v = this->first; v!= nullptr; v = v->Next()) {
3015 v->last = new_last;
3016 }
3017}
3018
3025{
3026 assert(this->previous_shared == nullptr && this->next_shared == nullptr);
3027
3028 if (shared_chain->orders == nullptr) {
3029 assert(shared_chain->previous_shared == nullptr);
3030 assert(shared_chain->next_shared == nullptr);
3031 this->orders = shared_chain->orders = OrderList::Create(shared_chain);
3032 }
3033
3034 this->next_shared = shared_chain->next_shared;
3035 this->previous_shared = shared_chain;
3036
3037 shared_chain->next_shared = this;
3038
3039 if (this->next_shared != nullptr) this->next_shared->previous_shared = this;
3040
3041 shared_chain->orders->AddVehicle(this);
3042}
3043
3048{
3049 /* Remember if we were first and the old window number before RemoveVehicle()
3050 * as this changes first if needed. */
3051 bool were_first = (this->FirstShared() == this);
3053
3054 this->orders->RemoveVehicle(this);
3055
3056 if (!were_first) {
3057 /* We are not the first shared one, so only relink our previous one. */
3058 this->previous_shared->next_shared = this->NextShared();
3059 }
3060
3061 if (this->next_shared != nullptr) this->next_shared->previous_shared = this->previous_shared;
3062
3063
3064 if (this->orders->GetNumVehicles() == 1) {
3065 /* When there is only one vehicle, remove the shared order list window. */
3068 } else if (were_first) {
3069 /* If we were the first one, update to the new first one.
3070 * Note: FirstShared() is already the new first */
3071 InvalidateWindowData(GetWindowClassForVehicleType(this->type), vli.ToWindowNumber(), this->FirstShared()->index.base() | (1U << 31));
3072 }
3073
3074 this->next_shared = nullptr;
3075 this->previous_shared = nullptr;
3076}
3077
3079static const IntervalTimer<TimerGameEconomy> _economy_vehicles_yearly({TimerGameEconomy::Trigger::Year, TimerGameEconomy::Priority::Vehicle}, [](auto)
3080{
3081 for (Vehicle *v : Vehicle::Iterate()) {
3082 if (v->IsPrimaryVehicle()) {
3083 /* show warning if vehicle is not generating enough income last 2 years (corresponds to a red icon in the vehicle list) */
3084 Money profit = v->GetDisplayProfitThisYear();
3085 if (v->economy_age >= VEHICLE_PROFIT_MIN_AGE && profit < 0) {
3088 GetEncodedString(TimerGameEconomy::UsingWallclockUnits() ? STR_NEWS_VEHICLE_UNPROFITABLE_PERIOD : STR_NEWS_VEHICLE_UNPROFITABLE_YEAR, v->index, profit),
3089 v->index);
3090 }
3091 AI::NewEvent(v->owner, new ScriptEventVehicleUnprofitable(v->index));
3092 }
3093
3095 v->profit_this_year = 0;
3096 SetWindowDirty(WindowClass::VehicleDetails, v->index);
3097 }
3098 }
3100 SetWindowClassesDirty(WindowClass::TrainList);
3101 SetWindowClassesDirty(WindowClass::ShipList);
3102 SetWindowClassesDirty(WindowClass::RoadVehicleList);
3103 SetWindowClassesDirty(WindowClass::AircraftList);
3104});
3105
3115bool CanVehicleUseStation(EngineID engine_type, const Station *st)
3116{
3117 const Engine *e = Engine::GetIfValid(engine_type);
3118 assert(e != nullptr);
3119
3120 switch (e->type) {
3121 case VehicleType::Train:
3123
3124 case VehicleType::Road:
3125 /* For road vehicles we need the vehicle to know whether it can actually
3126 * use the station, but if it doesn't have facilities for RVs it is
3127 * certainly not possible that the station can be used. */
3129
3130 case VehicleType::Ship:
3132
3136
3137 default:
3138 return false;
3139 }
3140}
3141
3148bool CanVehicleUseStation(const Vehicle *v, const Station *st)
3149{
3150 if (v->type == VehicleType::Road) return st->GetPrimaryRoadStop(RoadVehicle::From(v)) != nullptr;
3151
3152 return CanVehicleUseStation(v->engine_type, st);
3153}
3154
3162{
3163 switch (v->type) {
3164 case VehicleType::Train:
3165 return STR_ERROR_NO_RAIL_STATION;
3166
3167 case VehicleType::Road: {
3168 const RoadVehicle *rv = RoadVehicle::From(v);
3169 RoadStop *rs = st->GetPrimaryRoadStop(rv->IsBus() ? RoadStopType::Bus : RoadStopType::Truck);
3170
3171 StringID err = rv->IsBus() ? STR_ERROR_NO_BUS_STATION : STR_ERROR_NO_TRUCK_STATION;
3172
3173 for (; rs != nullptr; rs = rs->next) {
3174 /* Articulated vehicles cannot use bay road stops, only drive-through. Make sure the vehicle can actually use this bay stop */
3176 err = STR_ERROR_NO_STOP_ARTICULATED_VEHICLE;
3177 continue;
3178 }
3179
3180 /* Bay stop errors take precedence, but otherwise the vehicle may not be compatible with the roadtype/tramtype of this station tile.
3181 * We give bay stop errors precedence because they are usually a bus sent to a tram station or vice versa. */
3182 if (!HasTileAnyRoadType(rs->xy, rv->compatible_roadtypes) && err != STR_ERROR_NO_STOP_ARTICULATED_VEHICLE) {
3183 err = RoadTypeIsRoad(rv->roadtype) ? STR_ERROR_NO_STOP_COMPATIBLE_ROAD_TYPE : STR_ERROR_NO_STOP_COMPATIBLE_TRAM_TYPE;
3184 continue;
3185 }
3186 }
3187
3188 return err;
3189 }
3190
3191 case VehicleType::Ship:
3192 return STR_ERROR_NO_DOCK;
3193
3195 if (!st->facilities.Test(StationFacility::Airport)) return STR_ERROR_NO_AIRPORT;
3196 if (v->GetEngine()->VehInfo<AircraftVehicleInfo>().subtype & AIR_CTOL) {
3197 return STR_ERROR_AIRPORT_NO_PLANES;
3198 } else {
3199 return STR_ERROR_AIRPORT_NO_HELICOPTERS;
3200 }
3201
3202 default:
3203 return INVALID_STRING_ID;
3204 }
3205}
3206
3213{
3214 assert(this->IsGroundVehicle());
3215 if (this->type == VehicleType::Train) {
3216 return &Train::From(this)->gcache;
3217 } else {
3218 return &RoadVehicle::From(this)->gcache;
3219 }
3220}
3221
3228{
3229 assert(this->IsGroundVehicle());
3230 if (this->type == VehicleType::Train) {
3231 return &Train::From(this)->gcache;
3232 } else {
3233 return &RoadVehicle::From(this)->gcache;
3234 }
3235}
3236
3243{
3244 assert(this->IsGroundVehicle());
3245 if (this->type == VehicleType::Train) {
3246 return Train::From(this)->gv_flags;
3247 } else {
3248 return RoadVehicle::From(this)->gv_flags;
3249 }
3250}
3251
3258{
3259 assert(this->IsGroundVehicle());
3260 if (this->type == VehicleType::Train) {
3261 return Train::From(this)->gv_flags;
3262 } else {
3263 return RoadVehicle::From(this)->gv_flags;
3264 }
3265}
3266
3275void GetVehicleSet(VehicleSet &set, Vehicle *v, uint8_t num_vehicles)
3276{
3277 if (v->type == VehicleType::Train) {
3278 Train *u = Train::From(v);
3279 /* Only include whole vehicles, so start with the first articulated part */
3280 u = u->GetFirstEnginePart();
3281
3282 /* Include num_vehicles vehicles, not counting articulated parts */
3283 for (; u != nullptr && num_vehicles > 0; num_vehicles--) {
3284 do {
3285 /* Include current vehicle in the selection. */
3286 include(set, u->index);
3287
3288 /* If the vehicle is multiheaded, add the other part too. */
3289 if (u->IsMultiheaded()) include(set, u->other_multiheaded_part->index);
3290
3291 u = u->Next();
3292 } while (u != nullptr && u->IsArticulatedPart());
3293 }
3294 }
3295}
3296
3302{
3303 uint32_t max_weight = 0;
3304
3305 for (const Vehicle *u = this; u != nullptr; u = u->Next()) {
3306 max_weight += u->GetMaxWeight();
3307 }
3308
3309 return max_weight;
3310}
3311
3317{
3318 uint32_t max_weight = GetDisplayMaxWeight();
3319 if (max_weight == 0) return 0;
3320 return GetGroundVehicleCache()->cached_power * 10u / max_weight;
3321}
3322
3330{
3331 while (true) {
3332 if (v1 == nullptr && v2 == nullptr) return true;
3333 if (v1 == nullptr || v2 == nullptr) return false;
3334 if (v1->GetEngine() != v2->GetEngine()) return false;
3335 v1 = v1->GetNextVehicle();
3336 v2 = v2->GetNextVehicle();
3337 }
3338}
3339
3347{
3348 return std::ranges::equal(v1->Orders(), v2->Orders(), [](const Order &o1, const Order &o2) { return o1.Equals(o2); });
3349}
3350
3358{
3359 return v1->FirstShared() == v2->FirstShared();
3360}
3361
3363struct VehicleSubcoordData : Coord2D<uint8_t> {
3365};
3366
3372 {{{ // NE
3373 {{15, 8}, Direction::NE}, // TRACK_X
3374 {}, // TRACK_Y
3375 {}, // TRACK_UPPER
3376 {{15, 8}, Direction::E}, // TRACK_LOWER
3377 {{15, 7}, Direction::N}, // TRACK_LEFT
3378 {}, // TRACK_RIGHT
3379 }}},
3380 {{{ // SE
3381 {}, // TRACK_X
3382 {{8, 0}, Direction::SE}, // TRACK_Y
3383 {{7, 0}, Direction::E}, // TRACK_UPPER
3384 {}, // TRACK_LOWER
3385 {{8, 0}, Direction::S}, // TRACK_LEFT
3386 {}, // TRACK_RIGHT
3387 }}},
3388 {{{ // SW
3389 {{0, 8}, Direction::SW}, // TRACK_X
3390 {}, // TRACK_Y
3391 {{0, 7}, Direction::W}, // TRACK_UPPER
3392 {}, // TRACK_LOWER
3393 {}, // TRACK_LEFT
3394 {{0, 8}, Direction::S}, // TRACK_RIGHT
3395 }}},
3396 {{{ // NW
3397 {}, // TRACK_X
3398 {{8, 15}, Direction::NW}, // TRACK_Y
3399 {}, // TRACK_UPPER
3400 {{8, 15}, Direction::W}, // TRACK_LOWER
3401 {}, // TRACK_LEFT
3402 {{7, 15}, Direction::N}, // TRACK_RIGHT
3403 }}},
3404}}};
3405
3414{
3415 const VehicleSubcoordData &b = _vehicle_subcoord[enterdir][track];
3416 gp.x = (gp.x & ~TILE_UNIT_MASK) | b.x;
3417 gp.y = (gp.y & ~TILE_UNIT_MASK) | b.y;
3418 return b.dir;
3419}
Base functions for all AIs.
Base for aircraft.
void AircraftNextAirportPos_and_Order(Aircraft *v)
Set the right pos when heading to other airports after takeoff.
Station * GetTargetAirportIfValid(const Aircraft *v)
Returns aircraft's target station if v->target_airport is a valid station with airport.
@ AIR_SHADOW
shadow of the aircraft
Definition aircraft.h:31
void HandleAircraftEnterHangar(Aircraft *v)
Handle Aircraft specific tasks when an Aircraft enters a hangar.
@ FLYING
Vehicle is flying in the air.
Definition airport.h:78
@ None
Tile is not animated.
CargoTypes GetCargoTypesOfArticulatedVehicle(const Vehicle *v, CargoType *cargo_type)
Get cargo mask of all cargoes carried by an articulated vehicle.
void GetArticulatedRefitMasks(EngineID engine, bool include_initial_cargo_type, CargoTypes *union_mask, CargoTypes *intersection_mask)
Merges the refit_masks of all articulated parts.
CargoTypes GetCargoTypesOfArticulatedParts(EngineID engine)
Get the cargo mask of the parts of a given engine.
Functions related to articulated vehicles.
Command definitions related to autoreplace.
Functions related to autoreplacing.
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.
bool EngineHasReplacementForCompany(const Company *c, EngineID engine, GroupID group)
Check if a company has a replacement set up for the given engine.
void InvalidateAutoreplaceWindow(EngineID e, GroupID id_g)
Rebuild the left autoreplace list if an engine is removed or added.
Functions related to the autoreplace GUIs.
Class for backupping variables and making sure they are restored later.
@ PathfinderLost
Vehicle's pathfinder is lost.
@ StopLoading
Don't load anymore during the next load cycle.
@ LoadingFinished
Vehicle has finished loading.
@ CargoUnloading
Vehicle is unloading cargo.
@ End
We are looking for this amount of GRFs.
constexpr T SB(T &x, const uint8_t s, const uint8_t n, const U d)
Set n bits in x starting at bit s to d.
static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
constexpr uint8_t FindFirstBit(T x)
Search the first set bit in a value.
constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr bool HasAtMostOneBit(T value)
Test whether value has at most 1 bit set.
constexpr T ToggleBit(T &x, const uint8_t y)
Toggles a bit in a variable.
constexpr T ClrBit(T &x, const uint8_t y)
Clears a bit in a variable.
Map accessor functions for bridges.
bool IsBridgeTile(Tile t)
checks if there is a bridge on this tile
Definition bridge_map.h:35
bool IsBridgeAbove(Tile t)
checks if a bridge is set above the ground of this tile
Definition bridge_map.h:45
static constexpr CargoType INVALID_CARGO
Invalid marker for cargoes.
Definition cargo_type.h:83
bool IsValidCargoType(CargoType cargo)
Test whether cargo type is not INVALID_CARGO.
Definition cargo_type.h:112
EnumBitSet< CargoType, uint64_t > CargoTypes
Bitset of CargoType elements.
Definition cargo_type.h:115
static constexpr CargoLabel CT_GOODS
Cargo label for goods.
Definition cargo_type.h:37
CargoType
Cargo slots to indicate a cargo type within a game.
Definition cargo_type.h:22
CargoType GetCargoTypeByLabel(CargoLabel label)
Get cargo assigned to a label.
Definition cargotype.h:268
@ Passengers
Passengers.
Definition cargotype.h:50
bool IsCargoInClass(CargoType cargo, CargoClasses cc)
Does a given cargo have any cargo class from cc.
Definition cargotype.h:288
static void NewEvent(CompanyID company, ScriptEvent *event)
Queue a new event for an AI.
Definition ai_core.cpp:231
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
constexpr Tstorage base() const noexcept
Retrieve the raw value behind this bit set.
constexpr Timpl & Reset()
Reset all bits.
constexpr Timpl & Set()
Set all bits.
constexpr bool Any(const Timpl &other) const
Test if any of the given values are set.
Common return value for all commands.
bool Succeeded() const
Did this command succeed?
Money GetCost() const
The costs as made up to this moment.
bool Failed() const
Did this command fail?
StringID GetErrorMessage() const
Returns the error message of a command.
static constexpr int DAYS_IN_ECONOMY_MONTH
Days in an economy month, when in wallclock timekeeping mode.
const GRFFile * GetGRF() const
Retrieve the NewGRF the engine is tied to.
static Pool::IterateWrapperFiltered< Engine, EngineTypeFilter > IterateType(VehicleType vt, size_t from=0)
Returns an iterable ensemble of all valid engines of the given type.
CargoGRFFileProps grf_prop
Link to NewGRF.
Definition engine_base.h:73
GrfID GetGRFID() const
Retrieve the GRF ID of the NewGRF the engine is tied to.
Definition engine.cpp:185
CompanyMask company_avail
Bit for each company whether the engine is available for that company.
Definition engine_base.h:42
VehicleType type
Vehicle type, ie VehicleType::Road, VehicleType::Train, etc.
Definition engine_base.h:64
CargoType GetDefaultCargoType() const
Determines the default cargo type of an engine.
Definition engine_base.h:96
uint16_t reliability
Current reliability of the engine.
Definition engine_base.h:51
UnitID UseID(UnitID index)
Use a unit number.
Definition vehicle.cpp:1890
void ReleaseID(UnitID index)
Release a unit number.
Definition vehicle.cpp:1907
UnitID NextID() const
Find first unused unit number.
Definition vehicle.cpp:1875
An interval timer will fire every interval, and will continue to fire until it is deleted.
Definition timer.h:76
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
static void Reset(PerformanceElement elem)
Store the previous accumulator value and reset for a new cycle of accumulating measurements.
static constexpr TimerGameTick::Ticks DAY_TICKS
1 day is 74 ticks; TimerGameCalendar::date_fract used to be uint16_t and incremented by 885.
static Date date
Current date in days (day counter).
static DateFract date_fract
Fractional part of the day.
static constexpr TimerGame< struct Economy >::Date MAX_DATE
static Date date
Current date in days (day counter).
static bool UsingWallclockUnits(bool newgame=false)
Check if we are using wallclock units.
static DateFract date_fract
Fractional part of the day.
uint64_t TickCounter
The type that the tick counter is stored in.
static TickCounter counter
Monotonic counter, in ticks, since start of game.
int32_t Ticks
The type to store ticks in.
StrongType::Typedef< int32_t, struct YearTag< struct Calendar >, StrongType::Compare, StrongType::Integer > Year
static constexpr Date DateAtStartOfYear(Year year)
StrongType::Typedef< int32_t, DateTag< struct Economy >, StrongType::Compare, StrongType::Integer > Date
CargoList that is used for vehicles.
void AgeCargo()
Ages the all cargo in this list.
uint StoredCount() const
Returns sum of cargo on board the vehicle (ie not only reserved).
void SkipEmptyBuckets()
Advance the internal state until we reach a non-empty bucket, or the end.
Definition vehicle.cpp:503
Iterator(int32_t x, int32_t y, uint max_dist)
Iterator constructor.
Definition vehicle.cpp:463
void Increment()
Advance the internal state to the next potential vehicle.
Definition vehicle.cpp:493
void SkipFalseMatches()
Advance the internal state until it reaches a vehicle within the search area.
Definition vehicle.cpp:521
Iterator(TileIndex tile)
Iterator constructor.
Definition vehicle.cpp:531
void Increment()
Advance the internal state to the next potential vehicle.
Definition vehicle.cpp:541
void SkipFalseMatches()
Advance the internal state until it reaches a vehicle on the correct tile or the end.
Definition vehicle.cpp:549
Iterate over all vehicles on a tile.
Functions related to commands.
CommandCost & ExtractCommandCost(Tret &ret)
Extract the CommandCost from a command proc result.
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
@ Execute
execute the given command
EnumBitSet< DoCommandFlag, uint16_t > DoCommandFlags
Bitset of DoCommandFlag elements.
static void SubtractMoneyFromCompany(Company *c, const CommandCost &cost)
Deduct costs of a command from the money of a company.
CommandCost CheckOwnership(Owner owner, TileIndex tile)
Check whether the current owner owns something.
Money GetAvailableMoney(CompanyID company)
Get the amount of money that a company has available, or INT64_MAX if there is no such valid company.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
CompanyID _current_company
Company currently doing an action.
Functions related to companies.
bool IsLocalCompany()
Is the current company the local company?
Some simple functions to help with accessing containers.
bool include(Container &container, typename Container::const_reference &item)
Helper function to append an item to a container if it is not already contained.
#define Debug(facility, severity, format_string,...)
Output a line of debugging information.
Definition debug.h:36
@ Misc
Misc message facility.
Definition debug_type.h:32
@ Grf
Grf message facility.
Definition debug_type.h:30
@ Critical
Critical, user should know about this.
Definition debug_type.h:15
@ Error
Error, but we are recovering.
Definition debug_type.h:16
Functions related to depots.
void DeleteDepotHighlightOfVehicle(const Vehicle *v)
Removes the highlight of a vehicle in a depot window.
Map related accessors for depots.
bool IsDepotTile(Tile tile)
Is the given tile a tile with a depot on it?
Definition depot_map.h:45
DirDiff DirDifference(Direction d0, Direction d1)
Calculate the difference between two directions.
Direction ReverseDir(Direction d)
Return the reverse of a direction.
Direction ChangeDir(Direction d, DirDiff delta)
Change a direction by a given difference.
DirDiff LimitDirDiff(DirDiff d)
Limit a direction difference to up to 45 degrees.
DirDiff
Enumeration for the difference between two directions.
@ Same
Both directions faces to the same direction.
@ Right90
Angle of 90 degrees right.
EnumIndexArray< T, DiagDirection, DiagDirection::End > DiagDirectionIndexArray
Array with DiagDirection as index.
Direction
Defines the 8 directions on the map.
@ Invalid
Flag for an invalid direction.
@ SW
Southwest.
@ NW
Northwest.
@ NE
Northeast.
@ SE
Southeast.
EnumIndexArray< T, Direction, Direction::End > DirectionIndexArray
Array with Direction as index.
DiagDirection
Enumeration for diagonal directions.
@ Invalid
Flag for an invalid DiagDirection.
void LoadUnloadStation(Station *st)
Load/unload the vehicles in this station according to the order they entered.
Definition economy.cpp:1929
void PrepareUnload(Vehicle *front_v)
Prepare the vehicle to be unloaded.
Definition economy.cpp:1256
Base classes related to the economy.
@ NewVehicles
New vehicles.
EffectVehicle * CreateEffectVehicleRel(const Vehicle *v, int x, int y, int z, EffectVehicleType type)
Create an effect vehicle above a particular vehicle.
Base class for all effect vehicles.
Functions related to effect vehicles.
EffectVehicleType
Effect vehicle types.
@ EV_BREAKDOWN_SMOKE
Smoke of broken vehicles except aircraft.
@ EV_STEAM_SMOKE
Smoke of steam engines.
@ EV_DIESEL_SMOKE
Smoke of diesel engines.
@ EV_BREAKDOWN_SMOKE_AIRCRAFT
Smoke of broken aircraft.
@ EV_ELECTRIC_SPARK
Sparks of electric engines.
@ AIR_CTOL
Conventional Take Off and Landing, i.e. planes.
@ RoadIsTram
Road vehicle is a tram/light rail vehicle.
@ NoBreakdownSmoke
Do not show black smoke during a breakdown.
@ Uses2CC
Vehicle uses two company colours.
@ RailIsMU
Rail vehicle is a multiple-unit (DMU/EMU).
@ VE_TYPE_DEFAULT
Use default from engine class.
Definition engine_type.h:60
@ VE_TYPE_COUNT
Number of bits used for the effect type.
Definition engine_type.h:59
@ VE_OFFSET_CENTRE
Value of offset corresponding to a position above the centre of the vehicle.
Definition engine_type.h:56
@ VE_TYPE_ELECTRIC
Electric sparks.
Definition engine_type.h:63
@ VE_TYPE_START
First bit used for the type of effect.
Definition engine_type.h:58
@ VE_OFFSET_COUNT
Number of bits used for the offset.
Definition engine_type.h:55
@ VE_ADVANCED_EFFECT
Flag for advanced effects.
Definition engine_type.h:66
@ VE_DISABLE_EFFECT
Flag to disable visual effect.
Definition engine_type.h:65
@ VE_TYPE_STEAM
Steam plumes.
Definition engine_type.h:61
@ VE_TYPE_DIESEL
Diesel fumes.
Definition engine_type.h:62
@ VE_DEFAULT
Default value to indicate that visual effect should be based on engine class.
Definition engine_type.h:69
@ VE_OFFSET_START
First bit that contains the offset (0 = front, 8 = centre, 15 = rear).
Definition engine_type.h:54
@ VE_DISABLE_WAGON_POWER
Flag to disable wagon power.
Definition engine_type.h:67
PoolID< uint16_t, struct EngineIDTag, 64000, 0xFFFF > EngineID
Unique identification number of an engine.
Definition engine_type.h:25
@ Maglev
Maglev engine.
Definition engine_type.h:42
@ Steam
Steam rail engine.
Definition engine_type.h:38
@ Diesel
Diesel rail engine.
Definition engine_type.h:39
@ Electric
Electric rail engine.
Definition engine_type.h:40
@ Monorail
Mono rail engine.
Definition engine_type.h:41
@ Wagon
simple wagon, not motorized
Definition engine_type.h:33
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23).
Definition enum_type.hpp:21
Functions related to errors.
@ Critical
Critical errors, the MessageBox is shown in all cases.
Definition error.h:25
void ShowErrorMessage(EncodedString &&summary_msg, int x, int y, CommandCost &cc)
Display an error message in a window.
Types for recording game performance data.
@ GameLoopRoadVehicles
Time spend processing road vehicles.
@ GameLoopShips
Time spent processing ships.
@ GameLoopAircraft
Time spent processing aircraft.
@ GameLoopTrains
Time spent processing trains.
@ GameLoopEconomy
Time spent processing cargo movement.
Gamelog _gamelog
Gamelog instance.
Definition gamelog.cpp:30
Functions to be called to log fundamental changes to the game.
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:1032
@ Normal
The most basic (normal) sprite.
Definition gfx_type.h:405
uint32_t PaletteID
The number of the palette.
Definition gfx_type.h:18
@ Company
Destination is a company.
Definition goal_type.h:56
@ Next
Next button.
Definition goal_type.h:35
@ Previous
Previous button.
Definition goal_type.h:34
bool MarkAllViewportsDirty(int left, int top, int right, int bottom)
Mark all viewports that display an area as dirty (in need of repaint).
void MarkTilesDirty(bool cargo_change) const
Marks the tiles of the station as dirty.
Definition station.cpp:250
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
virtual void MarkDirty()
Marks the vehicles to be redrawn and updates cached variables.
void DeleteGroupHighlightOfVehicle(const Vehicle *v)
Removes the highlight of a vehicle in a group window.
Functions/definitions that have something to do with groups.
static constexpr GroupID DEFAULT_GROUP
Ungrouped vehicles are in this group.
Definition group_type.h:18
const EnumIndexArray< const TileTypeProcs *, TileType, TileType::MaxSize > _tile_type_procs
Tile callback functions for each type of tile.
Definition landscape.cpp:71
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:81
@ Toyland
Landscape with funky industries and vehicles.
static const uint8_t LIT_ALL
Show the liveries of all companies.
Definition livery.h:19
LiveryScheme
List of different livery schemes.
Definition livery.h:22
@ PassengerTram
Passenger trams.
Definition livery.h:55
@ SmallPlane
Small aeroplanes.
Definition livery.h:51
@ PassengerWagonMaglev
Passenger wagons attached to maglev engines.
Definition livery.h:38
@ Helicopter
Helicopters.
Definition livery.h:50
@ PassengerWagonElectric
Passenger wagons attached to electric engines.
Definition livery.h:36
@ Maglev
Maglev engines.
Definition livery.h:31
@ Steam
Steam engines.
Definition livery.h:27
@ PassengerShip
Passenger ships.
Definition livery.h:46
@ EMU
EMUs and their passenger wagons.
Definition livery.h:33
@ Bus
Buses.
Definition livery.h:42
@ Truck
Trucks.
Definition livery.h:43
@ Diesel
Diesel engines.
Definition livery.h:28
@ Default
Default scheme.
Definition livery.h:24
@ PassengerWagonDiesel
Passenger wagons attached to diesel engines.
Definition livery.h:35
@ FreightShip
Freight ships.
Definition livery.h:47
@ Electric
Electric engines.
Definition livery.h:29
@ PassengerWagonMonorail
Passenger wagons attached to monorail engines.
Definition livery.h:37
@ Monorail
Monorail engines.
Definition livery.h:30
@ FreightTram
Freight trams.
Definition livery.h:56
@ PassengerWagonSteam
Passenger wagons attached to steam engines.
Definition livery.h:34
@ LargePlane
Large aeroplanes.
Definition livery.h:52
@ FreightWagon
Freight wagons.
Definition livery.h:39
@ DMU
DMUs and their passenger wagons.
Definition livery.h:32
static const uint8_t LIT_COMPANY
Show the liveries of your own company.
Definition livery.h:18
#define Point
Macro that prevents name conflicts between included headers.
static TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
Definition map_func.h:407
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition map_func.h:429
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition map_func.h:419
constexpr bool IsInsideMM(const size_t x, const size_t min, const size_t max) noexcept
Checks if a value is in an interval.
constexpr T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition math_func.hpp:23
constexpr uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition math_func.hpp:79
constexpr To ClampTo(From value)
Clamp the given value down to lie within the requested type.
Miscellaneous command definitions.
void HideFillingPercent(TextEffectID *te_id)
Hide vehicle loading indicators.
Definition misc_gui.cpp:582
void ShowCostOrIncomeAnimation(int x, int y, int z, Money cost)
Display animated income or costs on the map.
Definition misc_gui.cpp:508
bool _networking
are we in networking mode?
Definition network.cpp:63
Basic functions/variables used all over the place.
GrfSpecFeature GetGrfSpecFeature(VehicleType type)
Get the GrfSpecFeature associated with a VehicleType.
Definition newgrf.cpp:1889
@ VisualEffect
Visual effects and wagon power (trains, road vehicles and ships).
@ ColourRemap
Change colour mapping of vehicle.
@ CBID_VEHICLE_SPAWN_VISUAL_EFFECT
Called to spawn visual effects for vehicles.
@ CBID_VEHICLE_COLOUR_MAPPING
Called to determine if a specific colour map should be used for a vehicle instead of the default live...
@ CBID_VEHICLE_32DAY_CALLBACK
Called for every vehicle every 32 days (not all on same date though).
@ CBID_VEHICLE_VISUAL_EFFECT
Visual effects and wagon power.
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
void ErrorUnknownCallbackResult(GrfID grfid, uint16_t cbid, uint16_t cb_res)
Record that a NewGRF returned an unknown/invalid callback result.
GRFConfig * GetGRFConfig(GrfID grfid, uint32_t mask)
Retrieve a NewGRF from the current config by its grfid.
GRFBug
Encountered GRF bugs.
@ VehPoweredWagon
Powered wagon changed poweredness state when not inside a depot.
@ VehLength
Length of rail vehicle changes when not inside a depot.
Functions/types related to NewGRF debugging.
void DeleteNewGRFInspectWindow(GrfSpecFeature feature, uint index)
Delete inspect window for a given feature and index.
bool UsesWagonOverride(const Vehicle *v)
Check if a wagon is currently using a wagon override.
uint16_t GetVehicleCallback(CallbackID callback, uint32_t param1, uint32_t param2, EngineID engine, const Vehicle *v, std::span< int32_t > regs100)
Evaluate a newgrf callback for vehicles.
void TriggerRoadStopRandomisation(BaseStation *st, TileIndex tile, StationRandomTrigger trigger, CargoType cargo_type)
Trigger road stop randomisation.
NewGRF definitions and structures for road stops.
bool PlayVehicleSound(const Vehicle *v, VehicleSoundEvent event, bool force)
Checks whether a NewGRF wants to play a different vehicle sound effect.
Functions related to NewGRF provided sounds.
@ VisualEffect
Vehicle visual effect (steam, diesel smoke or electric spark) is shown.
@ Breakdown
Vehicle breaking down.
@ Stopped16
Every 16 ticks while the vehicle is stopped (speed == 0).
@ Running16
Every 16 ticks while the vehicle is running (speed > 0).
@ Running
Vehicle running normally.
void TriggerStationRandomisation(BaseStation *st, TileIndex trigger_tile, StationRandomTrigger trigger, CargoType cargo_type)
Trigger station randomisation.
Header file for NewGRF stations.
Label< struct GrfIDTag > GrfID
The unique identifier of a NewGRF.
Definition newgrf_type.h:17
Functions related to news.
void AddVehicleAdviceNewsItem(AdviceType advice_type, EncodedString &&headline, VehicleID vehicle)
Adds a vehicle-advice news item.
Definition news_func.h:43
void DeleteVehicleNews(VehicleID vid, AdviceType advice_type=AdviceType::Invalid)
Delete news with a given advice type about a vehicle.
@ Vehicle
Vehicle news item. (new engine available).
Definition news_type.h:84
@ VehicleLost
The vehicle has become lost.
Definition news_type.h:60
@ VehicleWaiting
The vehicle is waiting in the depot.
Definition news_type.h:63
@ AutorenewFailed
Autorenew or autoreplace failed.
Definition news_type.h:56
@ VehicleOld
The vehicle is starting to get old.
Definition news_type.h:61
@ VehicleUnprofitable
The vehicle is costing you money.
Definition news_type.h:62
@ RefitFailed
The refit order failed to execute.
Definition news_type.h:58
@ Error
A game paused because a (critical) error.
Definition openttd.h:75
@ Normal
A game normally paused.
Definition openttd.h:72
@ Normal
Playing a game.
Definition openttd.h:20
@ Menu
In the main menu.
Definition openttd.h:19
Functions related to order backups.
void InsertOrder(Vehicle *v, Order &&new_o, VehicleOrderID sel_ord)
Insert a new order but skip the validation.
void DeleteOrder(Vehicle *v, VehicleOrderID sel_ord)
Delete an order but skip the parameter validation.
void InvalidateVehicleOrder(const Vehicle *v, int data)
Updates the widgets of a vehicle which contains the order-data.
void DeleteVehicleOrders(Vehicle *v, bool keep_orderlist, bool reset_order_indices)
Delete all orders from a vehicle.
@ NoUnload
Totally no unloading will be done.
Definition order_type.h:71
@ NonStop
The vehicle will not stop at any stations it passes except the destination, aka non-stop.
Definition order_type.h:88
@ GoVia
The vehicle will stop at any station it passes except the destination, aka via.
Definition order_type.h:89
EnumBitSet< OrderDepotActionFlag, uint8_t > OrderDepotActionFlags
Bitset of OrderDepotActionFlag elements.
Definition order_type.h:126
uint8_t VehicleOrderID
The index of an order within its current vehicle (not pool related).
Definition order_type.h:18
@ NoLoad
Do not load anything.
Definition order_type.h:81
static const VehicleOrderID MAX_VEH_ORDER_ID
Last valid VehicleOrderID.
Definition order_type.h:41
@ Halt
Service the vehicle and then halt it.
Definition order_type.h:120
@ NearestDepot
Send the vehicle to the nearest depot.
Definition order_type.h:121
@ Unbunch
Service the vehicle and then unbunch it.
Definition order_type.h:122
@ PartOfOrders
This depot order is because of a regular order.
Definition order_type.h:110
@ Service
This depot order is because of the servicing limit.
Definition order_type.h:109
static const VehicleOrderID INVALID_VEH_ORDER_ID
Invalid vehicle order index (sentinel).
Definition order_type.h:39
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:47
Some methods of Pool are placed here in order to reduce compilation time and binary size.
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don't get linker errors.
bool HasAnyRailTypesAvail(const CompanyID company)
Test if any buildable railtype is available for a company.
Definition rail.cpp:80
RailType GetTileRailType(Tile tile)
Return the rail type of tile, or INVALID_RAILTYPE if this is no rail tile.
Definition rail.cpp:39
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:396
void SetDepotReservation(Tile t, bool b)
Set the reservation state of the depot.
Definition rail_map.h:268
Pseudo random number generator.
uint32_t RandomRange(uint32_t limit, const std::source_location location=std::source_location::current())
Pick a random number between 0 and limit - 1, inclusive.
bool Chance16I(const uint32_t a, const uint32_t b, const uint32_t r)
Checks if a given randomize-number is below a given probability.
bool Chance16(const uint32_t a, const uint32_t b, const std::source_location location=std::source_location::current())
Flips a coin with given probability.
Declaration of link refreshing utility.
bool HasAnyRoadTypesAvail(CompanyID company, RoadTramType rtt)
Test if any buildable RoadType is available for a company.
Definition road.cpp:152
bool HasTileAnyRoadType(Tile t, RoadTypes rts)
Check if a tile has one of the specified road types.
Definition road_map.h:232
RoadTramType
The different types of road type.
Definition road_type.h:38
Base class for roadstops.
Road vehicle states.
@ RVSB_IN_DT_ROAD_STOP
The vehicle is in a drive-through road stop.
Definition roadveh.h:51
A number of safeguards to prevent using unsafe methods.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition settings.cpp:61
ClientSettings _settings_client
The current settings for this game.
Definition settings.cpp:60
Base for ships.
@ SecondEndFacingForward
Whether the other end is facing forward. Only applies to dual-ended ships.
Definition ship.h:31
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:655
Functions related to sound.
@ SND_3A_BREAKDOWN_TRAIN_SHIP_TOYLAND
58 == 0x3A Breakdown: train or ship (toyland)
Definition sound_type.h:105
@ SND_10_BREAKDOWN_TRAIN_SHIP
14 == 0x0E Breakdown: train or ship (non-toyland)
Definition sound_type.h:61
@ SND_0F_BREAKDOWN_ROADVEHICLE
13 == 0x0D Breakdown: road vehicle (non-toyland)
Definition sound_type.h:60
@ SND_35_BREAKDOWN_ROADVEHICLE_TOYLAND
53 == 0x35 Breakdown: road vehicle (toyland)
Definition sound_type.h:100
Functions to cache sprites in memory.
static const PaletteID PALETTE_RECOLOUR_START
First recolour sprite for company colours.
Definition sprites.h:1763
static const PaletteID PALETTE_CRASH
Recolour sprite greying of crashed vehicles.
Definition sprites.h:1794
Base classes/functions for stations.
void IncreaseStats(Station *st, CargoType cargo, StationID next_station_id, uint capacity, uint usage, uint32_t time, EdgeUpdateModes modes)
Increase capacity for a link stat given by station cargo and next hop.
Functions related to stations.
bool IsStationRoadStopTile(Tile t)
Is tile t a road stop station?
bool IsBayRoadStopTile(Tile t)
Is tile t a bay (non-drive through) road stop station?
bool IsRailStationTile(Tile t)
Is this tile a station tile and a rail station?
StationID GetStationIndex(Tile t)
Get StationID from a tile.
Definition station_map.h:26
RoadStopType GetRoadStopType(Tile t)
Get the road stop type of this tile.
Definition station_map.h:54
@ Bus
A standard stop for buses.
@ Truck
A standard stop for trucks.
@ Dock
Station with a dock.
@ TruckStop
Station with truck stops.
@ Train
Station with train station.
@ Airport
Station with an airport.
@ BusStop
Station with bus stops.
@ VehicleDeparts
Trigger platform when train leaves.
@ VehicleDeparts
Trigger platform when train leaves.
Definition of base types and functions in a cross-platform compatible way.
static void StrMakeValid(Builder &builder, StringConsumer &consumer, StringValidationSettings settings)
Copies the valid (UTF-8) characters from consumer to the builder.
Definition string.cpp:118
EncodedString GetEncodedString(StringID str)
Encode a string with no parameters into an encoded string.
Definition strings.cpp:89
std::string GetString(StringID string)
Resolve the given StringID into a std::string with formatting but no parameters.
Definition strings.cpp:423
Functions related to OTTD's strings.
StrongType::Typedef< uint32_t, struct StringIDTag, StrongType::Compare, StrongType::Integer > StringID
Numeric value that represents a string, independent of the selected language.
static constexpr StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames).
Information about a aircraft vehicle.
uint8_t subtype
Type of aircraft.
Aircraft, helicopters, rotors and their shadows belong to this class.
Definition aircraft.h:75
uint8_t pos
Next desired position of the aircraft.
Definition aircraft.h:77
uint8_t state
State of the airport.
Definition aircraft.h:80
bool IsNormalAircraft() const
Check if the aircraft type is a normal flying device; eg not a rotor or a shadow.
Definition aircraft.h:123
uint8_t previous_pos
Previous desired position of the aircraft.
Definition aircraft.h:78
StationID targetairport
Airport to go to next.
Definition aircraft.h:79
@ Airplanes
Can planes land on this airport type?
Definition airport.h:165
@ Helicopters
Can helicopters land on this airport type?
Definition airport.h:166
std::vector< AirportFTA > layout
state machine for airport
Definition airport.h:195
Flags flags
Flags for this airport type.
Definition airport.h:198
AirportBlocks blocks
stores which blocks on the airport are taken. was 16 bit earlier on, then 32
const AirportFTAClass * GetFTA() const
Get the finite-state machine for this airport or the finite-state machine for the dummy airport in ca...
Class to backup a specific variable and restore it upon destruction of this object to prevent stack v...
TimerGameTick::TickCounter depot_unbunching_next_departure
When the vehicle will next try to leave its unbunching depot.
VehicleOrderID cur_real_order_index
The index to the current real (non-implicit) order.
TimerGameTick::Ticks round_trip_time
How many ticks for a single circumnavigation of the orders.
VehicleFlags vehicle_flags
Used for gradual loading and other miscellaneous things (.
TimerGameTick::TickCounter depot_unbunching_last_departure
When the vehicle last left its unbunching depot.
VehicleOrderID cur_implicit_order_index
The index to the current implicit order.
TimerGameTick::Ticks lateness_counter
How many ticks late (or early if negative) this vehicle is.
void ResetDepotUnbunching()
Resets all the data used for depot unbunching.
StationFacilities facilities
The facilities that this station has.
VehicleType type
Type of vehicle.
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo type.
Definition cargotype.h:140
GUISettings gui
settings related to the GUI
Structure to return information about the closest depot location, and whether it could be found.
DestinationID destination
The DestinationID as used for orders.
CompanySettings settings
settings specific for each company
uint32_t engine_renew_money
minimum amount of money before autorenew is used
int16_t engine_renew_months
months before/after the maximum vehicle age a vehicle should be renewed
bool engine_renew
is autorenew enabled
VehicleTypeIndexArray< GroupStatistics > group_all
NOSAVE: Statistics for the ALL_GROUP group.
A coordinate with two dimensions.
T y
Y coordinate.
T x
X coordinate.
Data about how and where to blit pixels.
Definition gfx_type.h:157
A special vehicle is one of the following:
TransparencyOption GetTransparencyOption() const
Determines the transparency option affecting the effect.
uint16_t animation_state
State primarily used to change the graphics/behaviour.
EngineMiscFlags misc_flags
Miscellaneous flags.
VehicleCallbackMasks callback_mask
Bitmask of vehicle callbacks that have to be called.
Information about GRF, used in the game and (part of it) in savegames.
GRFBugs grf_bugs
NOSAVE: bugs in this GRF in this run,.
std::string GetName() const
Get the name of this grf.
GrfID grfid
grfid that introduced this entity.
uint16_t local_id
id defined by the grf file for this entity
Dynamic data of a loaded NewGRF.
Definition newgrf.h:126
uint8_t grf_version
GRF version (See https://newgrf-specs.tt-wiki.net/wiki/Version_numbers#GRF_version).
Definition newgrf.h:129
bool vehicle_income_warn
if a vehicle isn't generating income, show a warning
uint8_t liveries
options for displaying company liveries, 0=none, 1=self, 2=all
Position information of a vehicle after it moved.
TileIndex new_tile
Tile of the vehicle after moving.
int y
x and y position of the vehicle after moving
TileIndex old_tile
Current tile of the vehicle.
Cached, frequently calculated values.
EngineID first_engine
Cached EngineID of the front vehicle. EngineID::Invalid() for the front vehicle itself.
uint32_t cached_power
Total power of the consist (valid only for the first engine).
uint8_t cached_veh_length
Length of this vehicle in units of 1/VEHICLE_LENGTH of normal length. It is cached because this can b...
GroundVehicleCache gcache
Cache of often calculated values.
bool IsRearDualheaded() const
Tell if we are dealing with the rear end of a multiheaded engine.
bool IsMultiheaded() const
Check if the vehicle is a multiheaded engine.
GroundVehicleFlags gv_flags
static void CountVehicle(const Vehicle *v, int delta)
Update num_vehicle when adding or removing a vehicle.
static void VehicleReachedMinAge(const Vehicle *v)
Add a vehicle to the profit sum of its group.
static void CountEngine(const Vehicle *v, int delta)
Update num_engines when adding/removing an engine.
static void UpdateAutoreplace(CompanyID company)
Update autoreplace_defined and autoreplace_finished of all statistics of a company.
static void UpdateProfits()
Recompute the profits for all groups.
Group data.
Definition group.h:76
Livery livery
Custom colour scheme for vehicles in this group.
Definition group.h:82
GroupID parent
Parent group.
Definition group.h:88
Information about a particular livery.
Definition livery.h:82
Flags in_use
Livery flags.
Definition livery.h:92
uint8_t GetRecolourOffset(bool use_secondary=true) const
Get offset for recolour palette.
Definition livery.h:101
bool revalidate_before_draw
We need to do a GetImage() and check bounds before drawing this sprite.
VehicleSpriteSeq sprite_seq
Vehicle appearance.
static void ClearVehicle(const Vehicle *v)
Clear/update the (clone) vehicle from an order backup.
void AddVehicle(Vehicle *v)
Adds the given vehicle to this shared order list.
Definition order_base.h:521
If you change this, keep in mind that it is also saved in 2 other places:
Definition order_base.h:33
OrderDepotTypeFlags GetDepotOrderType() const
What caused us going to the depot?
Definition order_base.h:169
DestinationID GetDestination() const
Gets the destination of this order.
Definition order_base.h:99
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition order_base.h:66
CargoType GetRefitCargo() const
Get the cargo to to refit to.
Definition order_base.h:127
bool IsFullLoadOrder() const
Is this order a OrderLoadType::FullLoad or OrderLoadType::FullLoadAny?
Definition order_base.h:135
void MakeDummy()
Makes this order a Dummy order.
OrderLoadType GetLoadType() const
How must the consist be loaded?
Definition order_base.h:145
OrderDepotActionFlags GetDepotActionType() const
What are we going to do when in the depot.
Definition order_base.h:175
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...
void MakeImplicit(StationID destination)
Makes this order an implicit order.
bool IsRefit() const
Is this order a refit order.
Definition order_base.h:113
static Pool::IterateWrapper< Vehicle > Iterate(size_t from=0)
static Company * Get(auto index)
static Group * GetIfValid(auto index)
Information about a rail vehicle.
Definition engine_type.h:73
RailVehicleType railveh_type
Type of rail vehicle.
Definition engine_type.h:75
EngineClass engclass
Class of engine for this vehicle.
Definition engine_type.h:85
Specification of a rectangle with absolute coordinates of all edges.
A Stop for a Road Vehicle.
void Leave(RoadVehicle *rv)
Leave the road stop.
Definition roadstop.cpp:203
RoadStop * next
Next stop of the given type at this station.
TileIndex xy
Position on the map.
static RoadStop * GetByTile(TileIndex tile, RoadStopType type)
Find a roadstop at given tile.
Definition roadstop.cpp:253
Information about a road vehicle.
RoadType roadtype
Road type.
Buses, trucks and trams belong to this class.
Definition roadveh.h:105
uint8_t state
Definition roadveh.h:107
RoadTypes compatible_roadtypes
NOSAVE: Roadtypes this consist is powered on.
Definition roadveh.h:117
bool IsBus() const
Check whether a roadvehicle is a bus.
RoadType roadtype
NOSAVE: Roadtype of this vehicle.
Definition roadveh.h:115
VehicleID disaster_vehicle
NOSAVE: Disaster vehicle targetting this vehicle.
Definition roadveh.h:116
Information about a ship vehicle.
Definition engine_type.h:98
All ships have this type.
Definition ship.h:39
TrackBits state
The "track" the ship is following.
Definition ship.h:41
void UpdateCache()
Update the caches of this ship.
Definition ship_cmd.cpp:236
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
static Station * Get(auto index)
static Station * GetIfValid(auto index)
T * GetMovingFront() const
Get the moving front of the vehicle chain.
T * Next() const
Get next vehicle in the chain.
static Train * From(Vehicle *v)
void UpdateViewport(bool force_update, bool update_delta)
Update vehicle sprite- and position caches.
T * GetFirstEnginePart()
Get the first part of an articulated engine.
Data structure describing a sprite.
uint16_t width
Width of the sprite.
uint16_t height
Height of the sprite.
int16_t y_offs
Number of pixels to shift the sprite downwards.
int16_t x_offs
Number of pixels to shift the sprite to the right.
Station data structure.
std::array< GoodsEntry, NUM_CARGO > goods
Goods at this station.
Airport airport
Tile area the airport covers.
'Train' is either a loco or a wagon.
Definition train.h:97
Train * GetNextUnit() const
Get the next real (non-articulated part and non rear part of dualheaded engine) vehicle in the consis...
Definition train.h:156
Train * other_multiheaded_part
Link between the two ends of a multiheaded engine.
Definition train.h:105
TrainForceProceeding force_proceed
How the train should behave when it encounters next obstacle.
Definition train.h:111
TrackBits track
On which track the train currently is.
Definition train.h:110
VehicleRailFlags flags
Which flags has this train currently set.
Definition train.h:98
void ConsistChanged(ConsistChangeFlags allowed_changes)
Recalculates the cached stuff of a train.
uint16_t wait_counter
Ticks waiting in front of a signal, ticks being stuck or a counter for forced proceeding through sign...
Definition train.h:100
uint8_t cached_vis_effect
Visual effect to show (see VisualEffect).
uint16_t cached_cargo_age_period
Number of ticks before carried cargo is aged.
The information about a vehicle list.
Definition vehiclelist.h:32
WindowNumber ToWindowNumber() const
Pack a VehicleListIdentifier in 32 bits so it can be used as unique WindowNumber.
Sprite sequence for a vehicle part.
bool IsValid() const
Check whether the sequence contains any sprites.
void GetBounds(Rect *bounds) const
Determine shared bounds of all sprites.
Definition vehicle.cpp:125
void Draw(int x, int y, PaletteID default_pal, bool force_pal) const
Draw the sprite sequence.
Definition vehicle.cpp:153
Vehicle sub-coordinate data for moving into a new tile.
Definition vehicle.cpp:3363
Direction dir
new direction.
Definition vehicle.cpp:3364
Vehicle data structure.
Money GetDisplayProfitThisYear() const
Gets the profit vehicle had this year.
CargoPayment * cargo_payment
The cargo payment we're currently in.
EngineID engine_type
The type of engine used for this vehicle.
uint16_t cargo_age_counter
Ticks till cargo is aged next.
int32_t z_pos
z coordinate.
Vehicle * last
NOSAVE: pointer for the last vehicle in the chain.
Direction direction
facing
void ShiftDates(TimerGameEconomy::Date interval)
Shift all dates by given interval.
Definition vehicle.cpp:780
const Order * GetLastOrder() const
Returns the last order of a vehicle, or nullptr if it doesn't exists.
TimerGameEconomy::Date economy_age
Age in economy days.
bool IsOrderListShared() const
Check if we share our orders with another vehicle.
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
Definition vehicle.cpp:750
Direction GetMovingDirection() const
Get the moving direction of this vehicle chain.
void IncrementRealOrderIndex()
Advanced cur_real_order_index to the next real order, keeps care of the wrap-around and invalidates t...
virtual uint Crash(bool flooded=false)
Crash the (whole) vehicle chain.
Definition vehicle.cpp:302
bool IsStoppedInDepot() const
Check whether the vehicle is in the depot and stopped.
Order * GetOrder(int index) const
Returns order 'index' of a vehicle or nullptr when it doesn't exists.
bool HasDepotOrder() const
Checks if a vehicle has a depot in its order list.
void LeaveStation()
Perform all actions when leaving a station.
Definition vehicle.cpp:2373
void AddToShared(Vehicle *shared_chain)
Adds this vehicle to a shared vehicle chain.
Definition vehicle.cpp:3024
VehicleCargoList cargo
The cargo this vehicle is carrying.
Vehicle ** hash_tile_prev
NOSAVE: Previous vehicle in the tile location hash.
bool HasUnbunchingOrder() const
Check if the current vehicle has an unbunching order.
Definition vehicle.cpp:2509
TimerGameEconomy::Date date_of_last_service
Last economy date the vehicle had a service at a depot.
uint16_t cargo_cap
total capacity
StationID last_loading_station
Last station the vehicle has stopped at and could possibly leave from with any cargo loaded.
VehicleOrderID GetNumOrders() const
Get the number of orders this vehicle has.
const Order * GetFirstOrder() const
Get the first order of the vehicles order list.
CommandCost SendToDepot(DoCommandFlags flags, DepotCommandFlags command)
Send this vehicle to the depot using the given command(s).
Definition vehicle.cpp:2603
void ReleaseUnitNumber()
Release the vehicle's unit number.
Definition vehicle.cpp:2443
virtual void SetDestTile(TileIndex tile)
Set the destination of this vehicle.
void UpdateBoundingBoxCoordinates(bool update_cache) const
Update the bounding box co-ordinates of the vehicle.
Definition vehicle.cpp:1710
uint8_t day_counter
Increased by one for each day.
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:2454
Money profit_this_year
Profit this year << 8, low 8 bits are fract.
bool HasArticulatedPart() const
Check if an engine has an articulated part.
SpriteID colourmap
NOSAVE: cached colour mapping.
uint8_t breakdown_ctr
Counter for managing breakdown events.
uint8_t breakdown_delay
Counter for managing breakdown length.
Vehicle * GetNextVehicle() const
Get the next real (non-articulated part) vehicle in the consist.
GroupID group_id
Index of group Pool array.
void IncrementImplicitOrderIndex()
Increments cur_implicit_order_index, keeps care of the wrap-around and invalidates the GUI.
bool IsGroundVehicle() const
Check if the vehicle is a ground vehicle.
VehStates vehstatus
Status.
TimerGameCalendar::Date date_of_last_service_newgrf
Last calendar date the vehicle had a service at a depot, unchanged by the date cheat to protect again...
Vehicle * first
NOSAVE: pointer to the first vehicle in the chain.
void CancelReservation(StationID next, Station *st)
Return all reserved cargo packets to the station and reset all packets staged for transfer.
Definition vehicle.cpp:2357
Money profit_last_year
Profit last year << 8, low 8 bits are fract.
bool IsEngineCountable() const
Check if a vehicle is counted in num_engines in each company struct.
Definition vehicle.cpp:717
bool IsArticulatedPart() const
Check if the vehicle is an articulated part of an engine.
bool NeedsAutorenewing(const Company *c, bool use_renew_setting=true) const
Function to tell if a vehicle needs to be autorenewed.
Definition vehicle.cpp:167
void UpdateVisualEffect(bool allow_power_change=true)
Update the cached visual effect.
Definition vehicle.cpp:2682
void LeaveUnbunchingDepot()
Leave an unbunching depot and calculate the next departure time for shared order vehicles.
Definition vehicle.cpp:2534
CargoType cargo_type
type of cargo this vehicle is carrying
Vehicle * previous_shared
NOSAVE: pointer to the previous vehicle in the shared order chain.
VehicleOrderID GetNumManualOrders() const
Get the number of manually added orders this vehicle has.
Vehicle * First() const
Get the first vehicle of this vehicle chain.
int8_t trip_occupancy
NOSAVE: Occupancy of vehicle of the current trip (updated after leaving a station).
Order current_order
The current order (+ status, like: loading).
Vehicle(VehicleID index, VehicleType type=VehicleType::Invalid)
Vehicle constructor.
Definition vehicle.cpp:381
void PreDestructor()
Destroy all stuff that (still) needs the virtual functions to work properly.
Definition vehicle.cpp:828
TimerGameTick::TickCounter last_loading_tick
Last TimerGameTick::counter tick that the vehicle has stopped at a station and could possibly leave w...
void HandlePathfindingResult(bool path_found)
Handle the pathfinding result, especially the lost status.
Definition vehicle.cpp:794
Vehicle * Next() const
Get the next vehicle of this vehicle.
int32_t y_pos
y coordinate.
int32_t x_pos
x coordinate.
const GRFFile * GetGRF() const
Retrieve the NewGRF the vehicle is tied to.
Definition vehicle.cpp:760
OrderList * orders
Pointer to the order list for this vehicle.
uint32_t GetDisplayMinPowerToWeight() const
Calculates the minimum power-to-weight ratio using the maximum weight of the ground vehicle.
Definition vehicle.cpp:3316
Vehicle * GetMovingFront() const
Get the moving front of the vehicle chain.
virtual ClosestDepot FindClosestDepot()
Find the closest depot for this vehicle and tell us the location, DestinationID and whether we should...
void UpdateViewport(bool dirty)
Update the vehicle on the viewport, updating the right hash and setting the new coordinates.
Definition vehicle.cpp:1755
Money value
Value of the vehicle.
bool MarkAllViewportsDirty() const
Marks viewports dirty where the vehicle's image is.
Definition vehicle.cpp:1794
uint16_t refit_cap
Capacity left over from before last refit.
VehicleCache vcache
Cache of often used vehicle values.
uint32_t motion_counter
counter to occasionally play a vehicle sound.
SpriteBounds bounds
Bounding box of vehicle.
GroundVehicleCache * GetGroundVehicleCache()
Access the ground vehicle cache of the vehicle.
Definition vehicle.cpp:3212
virtual void OnNewEconomyDay()
Calls the new economy day handler of the vehicle.
Vehicle ** hash_tile_current
NOSAVE: Cache of the current hash chain.
virtual void OnNewCalendarDay()
Calls the new calendar day handler of the vehicle.
Vehicle * NextShared() const
Get the next vehicle of the shared vehicle chain.
virtual int GetCurrentMaxSpeed() const
Calculates the maximum speed of the vehicle under its current conditions.
bool HasFullLoadOrder() const
Check if the current vehicle has a full load order.
Definition vehicle.cpp:2489
virtual bool IsPrimaryVehicle() const
Whether this is the primary vehicle in the chain.
void BeginLoading()
Prepare everything to begin the loading when arriving at a station.
Definition vehicle.cpp:2229
Vehicle * hash_tile_next
NOSAVE: Next vehicle in the tile location hash.
uint16_t cur_speed
current speed
Vehicle * previous
NOSAVE: pointer to the previous vehicle in the chain.
~Vehicle() override
We want to 'destruct' the right class.
Definition vehicle.cpp:895
bool IsFrontEngine() const
Check if the vehicle is a front engine.
bool HasEngineType() const
Check whether Vehicle::engine_type has any meaning.
Definition vehicle.cpp:734
TimerGameCalendar::Date age
Age in calendar days.
bool IsWaitingForUnbunching() const
Check whether a vehicle inside a depot is waiting for unbunching.
Definition vehicle.cpp:2581
TextEffectID fill_percent_te_id
a text-effect id to a loading indicator object
void SetNext(Vehicle *next)
Set the next vehicle of this vehicle.
Definition vehicle.cpp:2988
uint8_t breakdowns_since_last_service
Counter for the amount of breakdowns.
Vehicle * next
pointer to the next vehicle in the chain
TimerGameCalendar::Date max_age
Maximum age.
MutableSpriteCache sprite_cache
Cache of sprites and values related to recalculating them, see MutableSpriteCache.
uint16_t reliability
Reliability.
uint32_t GetDisplayMaxWeight() const
Calculates the maximum weight of the ground vehicle when loaded.
Definition vehicle.cpp:3301
Vehicle * FirstShared() const
Get the first vehicle of this vehicle chain.
void RemoveFromShared()
Removes the vehicle from the shared order list.
Definition vehicle.cpp:3047
bool HandleBreakdown()
Handle all of the aspects of a vehicle breakdown This includes adding smoke and sounds,...
Definition vehicle.cpp:1376
void UpdatePositionAndViewport()
Update the position of the vehicle, and update the viewport.
Definition vehicle.cpp:1784
Vehicle * Previous() const
Get the previous vehicle of this vehicle.
virtual void PlayLeaveStationSound(bool force=false) const
Play the sound associated with leaving the station.
Rect coord
NOSAVE: Graphical bounding box of the vehicle, i.e. what to redraw on moves.
uint16_t reliability_spd_dec
Reliability decrease speed.
uint8_t tick_counter
Increased by one for each tick.
virtual bool IsInDepot() const
Check whether the vehicle is in the depot.
TileIndex tile
Current tile index.
virtual bool Tick()
Calls the tick handler of the vehicle.
TileIndex dest_tile
Heading for this tile.
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:212
bool HasConditionalOrder() const
Check if the current vehicle has a conditional order.
Definition vehicle.cpp:2500
void UpdatePosition()
Update the position of the vehicle.
Definition vehicle.cpp:1701
GroundVehicleFlags & GetGroundVehicleFlags()
Access the ground vehicle flags of the vehicle.
Definition vehicle.cpp:3242
StationID last_station_visited
The last station we stopped at.
void ResetRefitCaps()
Reset all refit_cap in the consist to cargo_cap.
Definition vehicle.cpp:2435
uint8_t breakdown_chance
Current chance of breakdowns.
void ShowVisualEffect() const
Draw visual effects (smoke and/or sparks) for a vehicle chain.
Definition vehicle.cpp:2836
Owner owner
Which company owns the vehicle?
UnitID unitnumber
unit number, for display purposes only
Vehicle * next_shared
pointer to the next vehicle that shares the order
bool NeedsAutomaticServicing() const
Checks if the current order should be interrupted for a service-in-depot order.
Definition vehicle.cpp:294
void DeleteUnreachedImplicitOrders()
Delete all implicit orders which were not reached.
Definition vehicle.cpp:2191
Vehicle ** hash_viewport_prev
NOSAVE: Previous vehicle in the visual location hash.
virtual void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const
Gets the sprite to show for the given direction.
Vehicle * hash_viewport_next
NOSAVE: Next vehicle in the visual location hash.
GrfID GetGRFID() const
Retrieve the GRF ID of the NewGRF the vehicle is tied to.
Definition vehicle.cpp:770
Data structure for viewport, display of a part of the world.
int top
Screen coordinate top edge of the viewport.
int width
Screen width of the viewport.
ZoomLevel zoom
The zoom level of the viewport.
int virtual_top
Virtual top coordinate.
int virtual_left
Virtual left coordinate.
int left
Screen coordinate left edge of the viewport.
int height
Screen height of the viewport.
VehicleEnterTileStates VehicleEnterTile(Vehicle *v, TileIndex tile, int x, int y)
Call the tile callback function for a vehicle entering a tile.
Definition vehicle.cpp:1865
EnumBitSet< VehicleEnterTileState, uint8_t > VehicleEnterTileStates
Bitset of VehicleEnterTileState elements.
Definition tile_cmd.h:31
static bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
int GetTileMaxPixelZ(TileIndex tile)
Get top height of the tile.
Definition tile_map.h:312
static TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
Definition tile_map.h:96
static constexpr uint TILE_UNIT_MASK
For masking in/out the inner-tile world coordinate units.
Definition tile_type.h:16
static constexpr int MAX_VEHICLE_PIXEL_Y
Maximum height of a vehicle in pixels in ZOOM_BASE.
Definition tile_type.h:22
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > > TileIndex
The index/ID of a Tile.
Definition tile_type.h:92
static constexpr uint TILE_SIZE
Tile size in world coordinates.
Definition tile_type.h:15
static constexpr int MAX_VEHICLE_PIXEL_X
Maximum width of a vehicle in pixels in ZOOM_BASE.
Definition tile_type.h:21
@ Station
A tile of a station or airport.
Definition tile_type.h:54
Definition of Interval and OneShot timers.
Definition of the game-calendar-timer.
Definition of the game-economy-timer.
Definition of the tick-based game-timer.
Functions related to time tabling.
void UpdateVehicleTimetable(Vehicle *v, bool travelling)
Update the timetable for the vehicle.
bool TracksOverlap(TrackBits bits)
Checks if the given tracks overlap, ie form a crossing.
Definition track_func.h:540
EnumBitSet< Track, uint8_t > TrackBits
Bitset of Track elements.
Definition track_type.h:43
Track
These are used to specify a single track.
Definition track_type.h:19
@ Depot
Special flag indicating a vehicle is inside a depot.
Definition track_type.h:30
Base for the train class.
@ Reversed
Used for vehicle var 0xFE bit 8 (toggled each time the train is reversed, accurate for first vehicle ...
Definition train.h:31
@ LeavingStation
Train is just leaving a station.
Definition train.h:33
@ Reversing
Train is slowing down to reverse.
Definition train.h:26
@ Flipped
Reverse the visible direction of the vehicle.
Definition train.h:28
@ TFP_NONE
Normal operation.
Definition train.h:40
static constexpr ConsistChangeFlags CCF_ARRANGE
Valid changes for arranging the consist in a depot.
Definition train.h:57
Command definitions related to trains.
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...
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...
TransparencyOption
Transparency option bits: which position in _transparency_opt stands for which transparency.
@ Invalid
Invalid transparency option.
uint16_t UnitID
Type for the company global vehicle unit number.
Map accessors for tunnels.
bool IsTunnelTile(Tile t)
Is this a tunnel (entrance)?
Definition tunnel_map.h:34
void ShowNewGrfVehicleError(EngineID engine, StringID part1, StringID part2, GRFBug bug_type, bool critical)
Displays a "NewGrf Bug" error message for a engine, and pauses the game if not networking.
Definition vehicle.cpp:339
constexpr uint TILE_HASH_MASK
Definition vehicle.cpp:402
static uint GetTileHash(uint x, uint y)
Compute hash for tile coordinate.
Definition vehicle.cpp:449
static const uint GEN_HASHX_MASK
Definition vehicle.cpp:112
static const uint GEN_HASHY_MASK
Definition vehicle.cpp:113
static void VehicleEnteredDepotThisTick(Vehicle *v)
Adds a vehicle to the list of vehicles that visited a depot this tick.
Definition vehicle.cpp:923
static void SpawnAdvancedVisualEffect(const Vehicle *v)
Call CBID_VEHICLE_SPAWN_VISUAL_EFFECT and spawn requested effects.
Definition vehicle.cpp:2751
constexpr uint TOTAL_TILE_HASH_SIZE
Definition vehicle.cpp:403
static const uint GEN_HASHY_INC
Definition vehicle.cpp:107
static uint GetTileHash1D(uint p)
Compute hash for 1D tile coordinate.
Definition vehicle.cpp:417
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:365
static constexpr DirectionIndexArray< int8_t > _vehicle_smoke_pos
Vehicle smoke effect position offsets.
Definition vehicle.cpp:2743
static const uint GEN_HASHY_BITS
Definition vehicle.cpp:73
VehiclePool _vehicle_pool("Vehicle")
The pool with all our precious vehicles.
void VehicleServiceInDepot(Vehicle *v)
Service a vehicle and all subsequent vehicles in the consist.
Definition vehicle.cpp:189
static const IntervalTimer< TimerGameEconomy > _economy_vehicles_yearly({TimerGameEconomy::Trigger::Year, TimerGameEconomy::Priority::Vehicle}, [](auto) { for(Vehicle *v :Vehicle::Iterate()) { if(v->IsPrimaryVehicle()) { Money profit=v->GetDisplayProfitThisYear();if(v->economy_age >=VEHICLE_PROFIT_MIN_AGE &&profit< 0) { if(_settings_client.gui.vehicle_income_warn &&v->owner==_local_company) { AddVehicleAdviceNewsItem(AdviceType::VehicleUnprofitable, GetEncodedString(TimerGameEconomy::UsingWallclockUnits() ? STR_NEWS_VEHICLE_UNPROFITABLE_PERIOD :STR_NEWS_VEHICLE_UNPROFITABLE_YEAR, v->index, profit), v->index);} AI::NewEvent(v->owner, new ScriptEventVehicleUnprofitable(v->index));} v->profit_last_year=v->profit_this_year;v->profit_this_year=0;SetWindowDirty(WindowClass::VehicleDetails, v->index);} } GroupStatistics::UpdateProfits();SetWindowClassesDirty(WindowClass::TrainList);SetWindowClassesDirty(WindowClass::ShipList);SetWindowClassesDirty(WindowClass::RoadVehicleList);SetWindowClassesDirty(WindowClass::AircraftList);})
Yearly callback for vehicles.
static const uint GEN_HASHY_BUCKET_BITS
Definition vehicle.cpp:79
static void RunEconomyVehicleDayProc()
Increases the day counter for all vehicles and calls 1-day and 32-day handlers.
Definition vehicle.cpp:956
constexpr uint TILE_HASH_SIZE
Definition vehicle.cpp:401
static const uint GEN_HASHY_SIZE
Definition vehicle.cpp:101
constexpr uint TILE_HASH_BITS
Definition vehicle.cpp:400
static uint ComposeTileHash(uint hx, uint hy)
Compose two 1D hashes into 2D hash.
Definition vehicle.cpp:438
static constexpr DiagDirectionIndexArray< TrackIndexArray< VehicleSubcoordData > > _vehicle_subcoord
Table of subtile coordinates and direction for each combination of chosen track and tile enter direct...
Definition vehicle.cpp:3371
static const uint GEN_HASHX_BUCKET_BITS
Definition vehicle.cpp:78
VisualEffectSpawnModel
Models for spawning visual effects.
Definition vehicle.cpp:2823
@ Steam
Steam model.
Definition vehicle.cpp:2825
@ None
No visual effect.
Definition vehicle.cpp:2824
@ Diesel
Diesel model.
Definition vehicle.cpp:2826
@ Electric
Electric model.
Definition vehicle.cpp:2827
static uint IncTileHash1D(uint h)
Increment 1D hash to next bucket.
Definition vehicle.cpp:427
bool CanVehicleUseStation(EngineID engine_type, const Station *st)
Can this station be used by the given engine type?
Definition vehicle.cpp:3115
static const uint GEN_HASHX_BITS
Definition vehicle.cpp:72
Vehicle * CheckClickOnVehicle(const Viewport &vp, int x, int y)
Find the vehicle close to the clicked coordinates.
Definition vehicle.cpp:1244
static const uint GEN_HASHX_INC
Definition vehicle.cpp:106
static const uint GEN_HASHX_SIZE
Definition vehicle.cpp:100
std::map< VehicleID, bool > AutoreplaceMap
List of vehicles that should check for autoreplace this tick.
Definition vehicle.cpp:697
static bool IsBridgeAboveVehicle(const Vehicle *v)
Test if a bridge is above a vehicle.
Definition vehicle.cpp:2810
constexpr uint TILE_HASH_RES
Resolution of the hash, 0 = 1*1 tile, 1 = 2*2 tiles, 2 = 4*4 tiles, etc.
Definition vehicle.cpp:410
static bool PreviousOrderIsUnbunching(const Vehicle *v)
Check if the previous order is a depot unbunching order.
Definition vehicle.cpp:2521
static void DoDrawVehicle(const Vehicle *v)
Add vehicle sprite for drawing to the screen.
Definition vehicle.cpp:1121
@ Crashed
Vehicle is crashed.
@ Shadow
Vehicle is a shadow vehicle.
@ AircraftBroken
Aircraft is broken down.
@ Hidden
Vehicle is not visible.
@ DefaultPalette
Use default vehicle palette.
@ Stopped
Vehicle is stopped by the player.
Pool< Vehicle, VehicleID, 512 > VehiclePool
A vehicle pool for a little over 1 million vehicles.
static const int32_t INVALID_COORD
Sentinel for an invalid coordinate.
Command definitions for vehicles.
Functions related to vehicles.
void ShowNewGrfVehicleError(EngineID engine, StringID part1, StringID part2, GRFBug bug_type, bool critical)
Displays a "NewGrf Bug" error message for a engine, and pauses the game if not networking.
Definition vehicle.cpp:339
CommandCost EnsureNoVehicleOnGround(TileIndex tile)
Ensure there is no vehicle at the ground at the given position.
Definition vehicle.cpp:559
bool VehiclesHaveSameEngineList(const Vehicle *v1, const Vehicle *v2)
Checks if two vehicle chains have the same list of engines.
Definition vehicle.cpp:3329
bool VehiclesHaveSameOrderList(const Vehicle *v1, const Vehicle *v2)
Checks if two vehicles have the same list of orders.
Definition vehicle.cpp:3346
SpriteID GetEnginePalette(EngineID engine_type, CompanyID company)
Get the colour map for an engine.
Definition vehicle.cpp:2169
void VehicleEnterDepot(Vehicle *v)
Vehicle entirely entered the depot, update its status, orders, vehicle windows, service it,...
Definition vehicle.cpp:1564
static const TimerGameEconomy::Date VEHICLE_PROFIT_MIN_AGE
Only vehicles older than this have a meaningful profit.
void GetVehicleSet(VehicleSet &set, Vehicle *v, uint8_t num_vehicles)
Calculates the set of vehicles that will be affected by a given selection.
Definition vehicle.cpp:3275
UnitID GetFreeUnitNumber(VehicleType type)
Get an unused unit number for a vehicle (if allowed).
Definition vehicle.cpp:1922
void RunVehicleCalendarDayProc()
Age all vehicles, spreading out the action using the current TimerGameCalendar::date_fract.
Definition vehicle.cpp:939
bool VehiclesHaveSameSharedOrderList(const Vehicle *v1, const Vehicle *v2)
Checks if two vehicles have the same shared list of orders.
Definition vehicle.cpp:3357
void VehicleServiceInDepot(Vehicle *v)
Service a vehicle and all subsequent vehicles in the consist.
Definition vehicle.cpp:189
CommandCost EnsureNoTrainOnTrackBits(TileIndex tile, TrackBits track_bits)
Tests if a vehicle interacts with the specified track bits.
Definition vehicle.cpp:607
LiveryScheme GetEngineLiveryScheme(EngineID engine_type, EngineID parent_engine_type, const Vehicle *v)
Determines the LiveryScheme for a vehicle.
Definition vehicle.cpp:1998
void CheckVehicleBreakdown(Vehicle *v)
Periodic check for a vehicle to maybe break down.
Definition vehicle.cpp:1320
void ViewportAddVehicles(DrawPixelInfo *dpi)
Add the vehicle sprites that should be drawn at a part of the screen.
Definition vehicle.cpp:1150
GetNewVehiclePosResult GetNewVehiclePos(const Vehicle *v)
Get position information of a vehicle when moving one pixel in the direction it is facing.
Definition vehicle.cpp:1804
StringID GetVehicleCannotUseStationReason(const Vehicle *v, const Station *st)
Get reason string why this station can't be used by the given vehicle.
Definition vehicle.cpp:3161
void ReleaseDisasterVehicle(VehicleID vehicle)
Notify disasters that we are about to delete a vehicle.
void DecreaseVehicleValue(Vehicle *v)
Decrease the value of a vehicle.
Definition vehicle.cpp:1299
void EconomyAgeVehicle(Vehicle *v)
Update economy age of a vehicle.
Definition vehicle.cpp:1442
const struct Livery * GetEngineLivery(EngineID engine_type, CompanyID company, EngineID parent_engine_type, const Vehicle *v, uint8_t livery_setting)
Determines the livery for a vehicle.
Definition vehicle.cpp:2092
CommandCost TunnelBridgeIsFree(TileIndex tile, TileIndex endtile, const Vehicle *ignore=nullptr)
Finds vehicle in tunnel / bridge.
Definition vehicle.cpp:583
void AgeVehicle(Vehicle *v)
Update age of a vehicle.
Definition vehicle.cpp:1454
Direction VehicleEnterTileCoordinates(GetNewVehiclePosResult &gp, DiagDirection enterdir, Track track)
Lookup new subposition coordinates and direction to use when entering a new tile, applying the subcoo...
Definition vehicle.cpp:3413
SpriteID GetVehiclePalette(const Vehicle *v)
Get the colour map for a vehicle.
Definition vehicle.cpp:2179
uint8_t CalcPercentVehicleFilled(const Vehicle *v, StringID *colour)
Calculates how full a vehicle is.
Definition vehicle.cpp:1505
bool IsCompanyBuildableVehicleType(VehicleType type)
Is the given vehicle type buildable by a company?
bool CanBuildVehicleInfrastructure(VehicleType type, RoadTramType subtype=RoadTramType::Invalid)
Check whether we can build infrastructure for the given vehicle type.
Definition vehicle.cpp:1950
Functions related to the vehicle's GUIs.
@ VIWD_MODIFY_ORDERS
Other order modifications.
Definition vehicle_gui.h:35
WindowClass GetWindowClassForVehicleType(VehicleType vt)
Get WindowClass for vehicle list of given vehicle type.
Definition vehicle_gui.h:96
EnumBitSet< DepotCommandFlag, uint8_t > DepotCommandFlags
Bitset of DepotCommandFlag elements.
@ OnMap
Vehicle drawn in viewport.
PoolID< uint32_t, struct VehicleIDTag, 0xFF000, 0xFFFFF > VehicleID
The type all our vehicle IDs have.
VehicleType
Available vehicle types.
@ Ship
Ship vehicle type.
@ Effect
Effect vehicle type (smoke, explosions, sparks, bubbles).
@ Aircraft
Aircraft vehicle type.
@ Road
Road vehicle type.
@ Disaster
Disaster vehicle type.
@ Train
Train vehicle type.
@ Callback32
All vehicles in consist: 32 day callback requested rerandomisation.
@ Depot
Front vehicle only: Consist arrived in depot.
@ DontCancel
Don't cancel current goto depot command if any.
@ Service
The vehicle will leave the depot right after arrival (service only).
EnumBitSet< GroundVehicleFlag, uint16_t > GroundVehicleFlags
Bitset of GroundVehicleFlag elements.
EnumIndexArray< T, VehicleType, Tend > VehicleTypeIndexArray
Array with VehicleType as index.
@ SuppressImplicitOrders
Disable insertion and removal of automatic orders until the vehicle completes the real order.
static const uint VEHICLE_LENGTH
The length of a vehicle in tile units.
@ WID_VV_START_STOP
Start or stop this vehicle, and show information about the current state.
Functions and type for generating vehicle lists.
@ VehicleSharedOrders
Index is the first vehicle of the shared orders.
Definition vehiclelist.h:24
void StartSpriteCombine()
Starts a block of sprites, which are "combined" into a single bounding box.
Definition viewport.cpp:766
void AddSortableSpriteToDraw(SpriteID image, PaletteID pal, int x, int y, int z, const SpriteBounds &bounds, bool transparent, const SubSprite *sub)
Draw a (transparent) sprite at given coordinates with a given bounding box.
Definition viewport.cpp:665
void EndSpriteCombine()
Terminates a block of sprites started by StartSpriteCombine.
Definition viewport.cpp:776
Functions related to (drawing on) viewports.
void CloseWindowById(WindowClass cls, WindowNumber number, bool force, int data)
Close a window by its class and window number (if it is open).
Definition window.cpp:1242
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting).
Definition window.cpp:3285
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:3377
void SetWindowWidgetDirty(WindowClass cls, WindowNumber number, WidgetID widget_index)
Mark a particular widget in a particular window as dirty (in need of repainting).
Definition window.cpp:3271
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting).
Definition window.cpp:3255
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:3395
@ Station
station encountered (could be a target next time)
Definition yapf_type.hpp:26
Functions related to zooming.
int ScaleByZoom(int value, ZoomLevel zoom)
Scale by zoom level, usually shift left (when zoom > ZoomLevel::Min) When shifting right,...
Definition zoom_func.h:22