OpenTTD Source: src/articulated_vehicles.cpp Source File

OpenTTD Source 13.2.1

articulated_vehicles.cpp
Go to the documentation of this file.
1 /*
2 * This file is part of OpenTTD.
3 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6 */
7
10 #include "stdafx.h"
11 #include "train.h"
12 #include "roadveh.h"
13 #include "vehicle_func.h"
14 #include "engine_func.h"
15 #include "company_func.h"
16 #include "newgrf.h"
17
18 #include "table/strings.h"
19
20 #include "safeguards.h"
21
22 static const uint MAX_ARTICULATED_PARTS = 100;
23
32 static EngineID GetNextArticulatedPart(uint index, EngineID front_type, Vehicle *front = nullptr, bool *mirrored = nullptr)
33 {
34 assert(front == nullptr || front->engine_type == front_type);
35
36 const Engine *front_engine = Engine::Get(front_type);
37
38 uint16 callback = GetVehicleCallback(CBID_VEHICLE_ARTIC_ENGINE, index, 0, front_type, front);
39 if (callback == CALLBACK_FAILED) return INVALID_ENGINE;
40
41 if (front_engine->GetGRF()->grf_version < 8) {
42 /* 8 bits, bit 7 for mirroring */
43 callback = GB(callback, 0, 8);
44 if (callback == 0xFF) return INVALID_ENGINE;
45 if (mirrored != nullptr) *mirrored = HasBit(callback, 7);
46 callback = GB(callback, 0, 7);
47 } else {
48 /* 15 bits, bit 14 for mirroring */
49 if (callback == 0x7FFF) return INVALID_ENGINE;
50 if (mirrored != nullptr) *mirrored = HasBit(callback, 14);
51 callback = GB(callback, 0, 14);
52 }
53
54 return GetNewEngineID(front_engine->GetGRF(), front_engine->type, callback);
55 }
56
62 bool IsArticulatedEngine(EngineID engine_type)
63 {
64 return HasBit(EngInfo(engine_type)->callback_mask, CBM_VEHICLE_ARTIC_ENGINE);
65 }
66
73 uint CountArticulatedParts(EngineID engine_type, bool purchase_window)
74 {
75 if (!HasBit(EngInfo(engine_type)->callback_mask, CBM_VEHICLE_ARTIC_ENGINE)) return 0;
76
77 /* If we can't allocate a vehicle now, we can't allocate it in the command
78 * either, so it doesn't matter how many articulated parts there are. */
79 if (!Vehicle::CanAllocateItem()) return 0;
80
81 Vehicle *v = nullptr;
82 if (!purchase_window) {
83 v = new Vehicle();
84 v->engine_type = engine_type;
85 v->owner = _current_company;
86 }
87
88 uint i;
89 for (i = 1; i < MAX_ARTICULATED_PARTS; i++) {
90 if (GetNextArticulatedPart(i, engine_type, v) == INVALID_ENGINE) break;
91 }
92
93 delete v;
94
95 return i - 1;
96 }
97
98
105 static inline uint16 GetVehicleDefaultCapacity(EngineID engine, CargoID *cargo_type)
106 {
107 const Engine *e = Engine::Get(engine);
108 CargoID cargo = (e->CanCarryCargo() ? e->GetDefaultCargoType() : (CargoID)CT_INVALID);
109 if (cargo_type != nullptr) *cargo_type = cargo;
110 if (cargo == CT_INVALID) return 0;
111 return e->GetDisplayDefaultCapacity();
112 }
113
120 static inline CargoTypes GetAvailableVehicleCargoTypes(EngineID engine, bool include_initial_cargo_type)
121 {
122 const Engine *e = Engine::Get(engine);
123 if (!e->CanCarryCargo()) return 0;
124
125 CargoTypes cargoes = e->info.refit_mask;
126
127 if (include_initial_cargo_type) {
128 SetBit(cargoes, e->GetDefaultCargoType());
129 }
130
131 return cargoes;
132 }
133
139 CargoArray GetCapacityOfArticulatedParts(EngineID engine)
140 {
141 CargoArray capacity;
142 const Engine *e = Engine::Get(engine);
143
144 CargoID cargo_type;
145 uint16 cargo_capacity = GetVehicleDefaultCapacity(engine, &cargo_type);
146 if (cargo_type < NUM_CARGO) capacity[cargo_type] = cargo_capacity;
147
148 if (!e->IsGroundVehicle()) return capacity;
149
150 if (!HasBit(e->info.callback_mask, CBM_VEHICLE_ARTIC_ENGINE)) return capacity;
151
152 for (uint i = 1; i < MAX_ARTICULATED_PARTS; i++) {
153 EngineID artic_engine = GetNextArticulatedPart(i, engine);
154 if (artic_engine == INVALID_ENGINE) break;
155
156 cargo_capacity = GetVehicleDefaultCapacity(artic_engine, &cargo_type);
157 if (cargo_type < NUM_CARGO) capacity[cargo_type] += cargo_capacity;
158 }
159
160 return capacity;
161 }
162
168 bool IsArticulatedVehicleRefittable(EngineID engine)
169 {
170 if (IsEngineRefittable(engine)) return true;
171
172 const Engine *e = Engine::Get(engine);
173 if (!e->IsGroundVehicle()) return false;
174
175 if (!HasBit(e->info.callback_mask, CBM_VEHICLE_ARTIC_ENGINE)) return false;
176
177 for (uint i = 1; i < MAX_ARTICULATED_PARTS; i++) {
178 EngineID artic_engine = GetNextArticulatedPart(i, engine);
179 if (artic_engine == INVALID_ENGINE) break;
180
181 if (IsEngineRefittable(artic_engine)) return true;
182 }
183
184 return false;
185 }
186
194 void GetArticulatedRefitMasks(EngineID engine, bool include_initial_cargo_type, CargoTypes *union_mask, CargoTypes *intersection_mask)
195 {
196 const Engine *e = Engine::Get(engine);
197 CargoTypes veh_cargoes = GetAvailableVehicleCargoTypes(engine, include_initial_cargo_type);
198 *union_mask = veh_cargoes;
199 *intersection_mask = (veh_cargoes != 0) ? veh_cargoes : ALL_CARGOTYPES;
200
201 if (!e->IsGroundVehicle()) return;
202 if (!HasBit(e->info.callback_mask, CBM_VEHICLE_ARTIC_ENGINE)) return;
203
204 for (uint i = 1; i < MAX_ARTICULATED_PARTS; i++) {
205 EngineID artic_engine = GetNextArticulatedPart(i, engine);
206 if (artic_engine == INVALID_ENGINE) break;
207
208 veh_cargoes = GetAvailableVehicleCargoTypes(artic_engine, include_initial_cargo_type);
209 *union_mask |= veh_cargoes;
210 if (veh_cargoes != 0) *intersection_mask &= veh_cargoes;
211 }
212 }
213
220 CargoTypes GetUnionOfArticulatedRefitMasks(EngineID engine, bool include_initial_cargo_type)
221 {
222 CargoTypes union_mask, intersection_mask;
223 GetArticulatedRefitMasks(engine, include_initial_cargo_type, &union_mask, &intersection_mask);
224 return union_mask;
225 }
226
233 CargoTypes GetIntersectionOfArticulatedRefitMasks(EngineID engine, bool include_initial_cargo_type)
234 {
235 CargoTypes union_mask, intersection_mask;
236 GetArticulatedRefitMasks(engine, include_initial_cargo_type, &union_mask, &intersection_mask);
237 return intersection_mask;
238 }
239
240
248 bool IsArticulatedVehicleCarryingDifferentCargoes(const Vehicle *v, CargoID *cargo_type)
249 {
250 CargoID first_cargo = CT_INVALID;
251
252 do {
253 if (v->cargo_type != CT_INVALID && v->GetEngine()->CanCarryCargo()) {
254 if (first_cargo == CT_INVALID) first_cargo = v->cargo_type;
255 if (first_cargo != v->cargo_type) {
256 if (cargo_type != nullptr) *cargo_type = CT_INVALID;
257 return true;
258 }
259 }
260
261 v = v->HasArticulatedPart() ? v->GetNextArticulatedPart() : nullptr;
262 } while (v != nullptr);
263
264 if (cargo_type != nullptr) *cargo_type = first_cargo;
265 return false;
266 }
267
276 void CheckConsistencyOfArticulatedVehicle(const Vehicle *v)
277 {
278 const Engine *engine = v->GetEngine();
279
280 CargoTypes purchase_refit_union, purchase_refit_intersection;
281 GetArticulatedRefitMasks(v->engine_type, true, &purchase_refit_union, &purchase_refit_intersection);
282 CargoArray purchase_default_capacity = GetCapacityOfArticulatedParts(v->engine_type);
283
284 CargoTypes real_refit_union = 0;
285 CargoTypes real_refit_intersection = ALL_CARGOTYPES;
286 CargoArray real_default_capacity;
287
288 do {
289 CargoTypes refit_mask = GetAvailableVehicleCargoTypes(v->engine_type, true);
290 real_refit_union |= refit_mask;
291 if (refit_mask != 0) real_refit_intersection &= refit_mask;
292
293 assert(v->cargo_type < NUM_CARGO);
294 real_default_capacity[v->cargo_type] += v->cargo_cap;
295
296 v = v->HasArticulatedPart() ? v->GetNextArticulatedPart() : nullptr;
297 } while (v != nullptr);
298
299 /* Check whether the vehicle carries more cargoes than expected */
300 bool carries_more = false;
301 for (CargoID cid = 0; cid < NUM_CARGO; cid++) {
302 if (real_default_capacity[cid] != 0 && purchase_default_capacity[cid] == 0) {
303 carries_more = true;
304 break;
305 }
306 }
307
308 /* show a warning once for each GRF after each game load */
309 if (real_refit_union != purchase_refit_union || real_refit_intersection != purchase_refit_intersection || carries_more) {
310 ShowNewGrfVehicleError(engine->index, STR_NEWGRF_BUGGY, STR_NEWGRF_BUGGY_ARTICULATED_CARGO, GBUG_VEH_REFIT, false);
311 }
312 }
313
318 void AddArticulatedParts(Vehicle *first)
319 {
320 VehicleType type = first->type;
321 if (!HasBit(EngInfo(first->engine_type)->callback_mask, CBM_VEHICLE_ARTIC_ENGINE)) return;
322
323 Vehicle *v = first;
324 for (uint i = 1; i < MAX_ARTICULATED_PARTS; i++) {
325 bool flip_image;
326 EngineID engine_type = GetNextArticulatedPart(i, first->engine_type, first, &flip_image);
327 if (engine_type == INVALID_ENGINE) return;
328
329 /* In the (very rare) case the GRF reported wrong number of articulated parts
330 * and we run out of available vehicles, bail out. */
331 if (!Vehicle::CanAllocateItem()) return;
332
333 GroundVehicleCache *gcache = v->GetGroundVehicleCache();
334 gcache->first_engine = v->engine_type; // Needs to be set before first callback
335
336 const Engine *e_artic = Engine::Get(engine_type);
337 switch (type) {
338 default: NOT_REACHED();
339
340 case VEH_TRAIN: {
341 Train *front = Train::From(first);
342 Train *t = new Train();
343 v->SetNext(t);
344 v = t;
345
346 t->subtype = 0;
347 t->track = front->track;
348 t->railtype = front->railtype;
349
350 t->spritenum = e_artic->u.rail.image_index;
351 if (e_artic->CanCarryCargo()) {
352 t->cargo_type = e_artic->GetDefaultCargoType();
353 t->cargo_cap = e_artic->u.rail.capacity; // Callback 36 is called when the consist is finished
354 } else {
355 t->cargo_type = front->cargo_type; // Needed for livery selection
356 t->cargo_cap = 0;
357 }
358 t->refit_cap = 0;
359
360 t->SetArticulatedPart();
361 break;
362 }
363
364 case VEH_ROAD: {
365 RoadVehicle *front = RoadVehicle::From(first);
366 RoadVehicle *rv = new RoadVehicle();
367 v->SetNext(rv);
368 v = rv;
369
370 rv->subtype = 0;
371 gcache->cached_veh_length = VEHICLE_LENGTH; // Callback is called when the consist is finished
372 rv->state = RVSB_IN_DEPOT;
373
374 rv->roadtype = front->roadtype;
375 rv->compatible_roadtypes = front->compatible_roadtypes;
376
377 rv->spritenum = e_artic->u.road.image_index;
378 if (e_artic->CanCarryCargo()) {
379 rv->cargo_type = e_artic->GetDefaultCargoType();
380 rv->cargo_cap = e_artic->u.road.capacity; // Callback 36 is called when the consist is finished
381 } else {
382 rv->cargo_type = front->cargo_type; // Needed for livery selection
383 rv->cargo_cap = 0;
384 }
385 rv->refit_cap = 0;
386
387 rv->SetArticulatedPart();
388 break;
389 }
390 }
391
392 /* get common values from first engine */
393 v->direction = first->direction;
394 v->owner = first->owner;
395 v->tile = first->tile;
396 v->x_pos = first->x_pos;
397 v->y_pos = first->y_pos;
398 v->z_pos = first->z_pos;
399 v->date_of_last_service = first->date_of_last_service;
400 v->build_year = first->build_year;
401 v->vehstatus = first->vehstatus & ~VS_STOPPED;
402
403 v->cargo_subtype = 0;
404 v->max_age = 0;
405 v->engine_type = engine_type;
406 v->value = 0;
407 v->sprite_cache.sprite_seq.Set(SPR_IMG_QUERY);
408 v->random_bits = VehicleRandomBits();
409
410 if (flip_image) v->spritenum++;
411
412 v->UpdatePosition();
413 }
414 }
RoadVehicle
Buses, trucks and trams belong to this class.
Definition: roadveh.h:107
Vehicle::GetGroundVehicleCache
GroundVehicleCache * GetGroundVehicleCache()
Access the ground vehicle cache of the vehicle.
Definition: vehicle.cpp:2906
Engine::GetDisplayDefaultCapacity
uint GetDisplayDefaultCapacity(uint16 *mail_capacity=nullptr) const
Determines the default cargo capacity of an engine for display purposes.
Definition: engine_base.h:115
INVALID_ENGINE
static const EngineID INVALID_ENGINE
Constant denoting an invalid engine.
Definition: engine_type.h:203
RoadVehicle::state
byte state
Definition: roadveh.h:109
Pool::PoolItem<&_engine_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:337
Vehicle::y_pos
int32 y_pos
y coordinate.
Definition: vehicle_base.h:284
MutableSpriteCache::sprite_seq
VehicleSpriteSeq sprite_seq
Vehicle appearance.
Definition: vehicle_base.h:197
GB
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
Definition: bitmath_func.hpp:32
Vehicle::value
Money value
Value of the vehicle.
Definition: vehicle_base.h:256
Vehicle::x_pos
int32 x_pos
x coordinate.
Definition: vehicle_base.h:283
train.h
GBUG_VEH_REFIT
@ GBUG_VEH_REFIT
Articulated vehicles carry different cargoes resp. are differently refittable than specified in purch...
Definition: newgrf_config.h:45
CBID_VEHICLE_ARTIC_ENGINE
@ CBID_VEHICLE_ARTIC_ENGINE
Builds articulated engines for trains and RVs.
Definition: newgrf_callbacks.h:51
GroundVehicleCache::first_engine
EngineID first_engine
Cached EngineID of the front vehicle. INVALID_ENGINE for the front vehicle itself.
Definition: ground_vehicle.hpp:43
CheckConsistencyOfArticulatedVehicle
void CheckConsistencyOfArticulatedVehicle(const Vehicle *v)
Checks whether the specs of freshly build articulated vehicles are consistent with the information sp...
Definition: articulated_vehicles.cpp:276
GetAvailableVehicleCargoTypes
static CargoTypes GetAvailableVehicleCargoTypes(EngineID engine, bool include_initial_cargo_type)
Returns all cargoes a vehicle can carry.
Definition: articulated_vehicles.cpp:120
Vehicle::z_pos
int32 z_pos
z coordinate.
Definition: vehicle_base.h:285
VehicleSpriteSeq::Set
void Set(SpriteID sprite)
Assign a single sprite to the sequence.
Definition: vehicle_base.h:165
GetArticulatedRefitMasks
void GetArticulatedRefitMasks(EngineID engine, bool include_initial_cargo_type, CargoTypes *union_mask, CargoTypes *intersection_mask)
Merges the refit_masks of all articulated parts.
Definition: articulated_vehicles.cpp:194
GetCapacityOfArticulatedParts
CargoArray GetCapacityOfArticulatedParts(EngineID engine)
Get the capacity of the parts of a given engine.
Definition: articulated_vehicles.cpp:139
Vehicle::random_bits
byte random_bits
Bits used for determining which randomized variational spritegroups to use when drawing.
Definition: vehicle_base.h:313
Vehicle::vehstatus
byte vehstatus
Status.
Definition: vehicle_base.h:332
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:235
Vehicle::SetNext
void SetNext(Vehicle *next)
Set the next vehicle of this vehicle.
Definition: vehicle.cpp:2741
AddArticulatedParts
void AddArticulatedParts(Vehicle *first)
Add the remaining articulated parts to the given vehicle.
Definition: articulated_vehicles.cpp:318
CargoArray
Class for storing amounts of cargo.
Definition: cargo_type.h:82
HasBit
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103
Vehicle::GetNextArticulatedPart
Vehicle * GetNextArticulatedPart() const
Get the next part of an articulated engine.
Definition: vehicle_base.h:941
RoadVehicle::roadtype
RoadType roadtype
Roadtype of this vehicle.
Definition: roadveh.h:117
Engine
Definition: engine_base.h:36
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:224
Engine::GetDefaultCargoType
CargoID GetDefaultCargoType() const
Determines the default cargo type of an engine.
Definition: engine_base.h:95
Vehicle::owner
Owner owner
Which company owns the vehicle?
Definition: vehicle_base.h:288
GetVehicleCallback
uint16 GetVehicleCallback(CallbackID callback, uint32 param1, uint32 param2, EngineID engine, const Vehicle *v)
Evaluate a newgrf callback for vehicles.
Definition: newgrf_engine.cpp:1162
CBM_VEHICLE_ARTIC_ENGINE
@ CBM_VEHICLE_ARTIC_ENGINE
Add articulated engines (trains and road vehicles)
Definition: newgrf_callbacks.h:296
CountArticulatedParts
uint CountArticulatedParts(EngineID engine_type, bool purchase_window)
Count the number of articulated parts of an engine.
Definition: articulated_vehicles.cpp:73
Engine::GetGRF
const GRFFile * GetGRF() const
Retrieve the NewGRF the engine is tied to.
Definition: engine_base.h:154
EngineID
uint16 EngineID
Unique identification number of an engine.
Definition: engine_type.h:21
GroundVehicleCache
Cached, frequently calculated values.
Definition: ground_vehicle.hpp:29
GetUnionOfArticulatedRefitMasks
CargoTypes GetUnionOfArticulatedRefitMasks(EngineID engine, bool include_initial_cargo_type)
Ors the refit_masks of all articulated parts.
Definition: articulated_vehicles.cpp:220
Vehicle::tile
TileIndex tile
Current tile index.
Definition: vehicle_base.h:245
Vehicle::engine_type
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:302
GroundVehicleCache::cached_veh_length
uint8 cached_veh_length
Length of this vehicle in units of 1/VEHICLE_LENGTH of normal length. It is cached because this can b...
Definition: ground_vehicle.hpp:44
Vehicle::max_age
Date max_age
Maximum age.
Definition: vehicle_base.h:274
VS_STOPPED
@ VS_STOPPED
Vehicle is stopped by the player.
Definition: vehicle_base.h:35
GetIntersectionOfArticulatedRefitMasks
CargoTypes GetIntersectionOfArticulatedRefitMasks(EngineID engine, bool include_initial_cargo_type)
Ands the refit_masks of all articulated parts.
Definition: articulated_vehicles.cpp:233
IsArticulatedVehicleCarryingDifferentCargoes
bool IsArticulatedVehicleCarryingDifferentCargoes(const Vehicle *v, CargoID *cargo_type)
Tests if all parts of an articulated vehicle are refitted to the same cargo.
Definition: articulated_vehicles.cpp:248
Vehicle::GetEngine
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
Definition: vehicle.cpp:741
safeguards.h
Train
'Train' is either a loco or a wagon.
Definition: train.h:89
EngineInfo::callback_mask
uint16 callback_mask
Bitmask of vehicle callbacks that have to be called.
Definition: engine_type.h:154
RoadVehicle::compatible_roadtypes
RoadTypes compatible_roadtypes
Roadtypes this consist is powered on.
Definition: roadveh.h:118
GetNewEngineID
EngineID GetNewEngineID(const GRFFile *file, VehicleType type, uint16 internal_id)
Return the ID of a new engine.
Definition: newgrf.cpp:701
stdafx.h
ShowNewGrfVehicleError
void ShowNewGrfVehicleError(EngineID engine, StringID part1, StringID part2, GRFBugs bug_type, bool critical)
Displays a "NewGrf Bug" error message for a engine, and pauses the game if not networking.
Definition: vehicle.cpp:297
Vehicle::sprite_cache
MutableSpriteCache sprite_cache
Cache of sprites and values related to recalculating them, see MutableSpriteCache.
Definition: vehicle_base.h:347
VehicleType
VehicleType
Available vehicle types.
Definition: vehicle_type.h:21
IsArticulatedVehicleRefittable
bool IsArticulatedVehicleRefittable(EngineID engine)
Checks whether any of the articulated parts is refittable.
Definition: articulated_vehicles.cpp:168
Vehicle::direction
Direction direction
facing
Definition: vehicle_base.h:286
Engine::IsGroundVehicle
bool IsGroundVehicle() const
Check if the engine is a ground vehicle.
Definition: engine_base.h:144
CALLBACK_FAILED
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
Definition: newgrf_callbacks.h:408
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:47
vehicle_func.h
VEHICLE_LENGTH
static const uint VEHICLE_LENGTH
The length of a vehicle in tile units.
Definition: vehicle_type.h:77
Vehicle::cargo_cap
uint16 cargo_cap
total capacity
Definition: vehicle_base.h:322
Engine::CanCarryCargo
bool CanCarryCargo() const
Determines whether an engine can carry something.
Definition: engine.cpp:164
SpecializedVehicle< Train, Type >::From
static Train * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Definition: vehicle_base.h:1183
GroundVehicle::SetArticulatedPart
void SetArticulatedPart()
Set a vehicle to be an articulated part.
Definition: ground_vehicle.hpp:259
VehicleRandomBits
byte VehicleRandomBits()
Get a value for a vehicle's random_bits.
Definition: vehicle.cpp:363
newgrf.h
NUM_CARGO
@ NUM_CARGO
Maximal number of cargo types in a game.
Definition: cargo_type.h:65
Vehicle::HasArticulatedPart
bool HasArticulatedPart() const
Check if an engine has an articulated part.
Definition: vehicle_base.h:931
Vehicle::build_year
Year build_year
Year the vehicle has been built.
Definition: vehicle_base.h:272
Pool::PoolItem<&_vehicle_pool >::CanAllocateItem
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
Definition: pool_type.hpp:307
company_func.h
Vehicle::subtype
byte subtype
subtype (Filled with values from AircraftSubType/DisasterSubType/EffectVehicleType/GroundVehicleSubty...
Definition: vehicle_base.h:342
SetBit
static T SetBit(T &x, const uint8 y)
Set a bit in a variable.
Definition: bitmath_func.hpp:121
GetNextArticulatedPart
static EngineID GetNextArticulatedPart(uint index, EngineID front_type, Vehicle *front=nullptr, bool *mirrored=nullptr)
Determines the next articulated part to attach.
Definition: articulated_vehicles.cpp:32
IsArticulatedEngine
bool IsArticulatedEngine(EngineID engine_type)
Does a NewGRF report that this should be an articulated vehicle?
Definition: articulated_vehicles.cpp:62
CargoID
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:20
Vehicle::cargo_type
CargoID cargo_type
type of cargo this vehicle is carrying
Definition: vehicle_base.h:320
Vehicle::spritenum
byte spritenum
currently displayed sprite index 0xfd == custom sprite, 0xfe == custom second head sprite 0xff == res...
Definition: vehicle_base.h:294
Vehicle::cargo_subtype
byte cargo_subtype
Used for livery refits (NewGRF variations)
Definition: vehicle_base.h:321
IsEngineRefittable
bool IsEngineRefittable(EngineID engine)
Check if an engine is refittable.
Definition: engine.cpp:1209
VEH_TRAIN
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
RailVehicleInfo::capacity
byte capacity
Cargo capacity of vehicle; For multiheaded engines the capacity of each single engine.
Definition: engine_type.h:54
BaseVehicle::type
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:52
Vehicle::UpdatePosition
void UpdatePosition()
Update the position of the vehicle.
Definition: vehicle.cpp:1610
GetVehicleDefaultCapacity
static uint16 GetVehicleDefaultCapacity(EngineID engine, CargoID *cargo_type)
Returns the default (non-refitted) capacity of a specific EngineID.
Definition: articulated_vehicles.cpp:105
CT_INVALID
@ CT_INVALID
Invalid cargo type.
Definition: cargo_type.h:69
MAX_ARTICULATED_PARTS
static const uint MAX_ARTICULATED_PARTS
Maximum of articulated parts per vehicle, i.e. when to abort calling the articulated vehicle callback...
Definition: articulated_vehicles.cpp:22
RVSB_IN_DEPOT
@ RVSB_IN_DEPOT
The vehicle is in a depot.
Definition: roadveh.h:39
Engine::type
VehicleType type
Vehicle type, ie VEH_ROAD, VEH_TRAIN, etc.
Definition: engine_base.h:55
Vehicle::refit_cap
uint16 refit_cap
Capacity left over from before last refit.
Definition: vehicle_base.h:323
Vehicle::date_of_last_service
Date date_of_last_service
Last date the vehicle had a service at a depot.
Definition: vehicle_base.h:275
engine_func.h
roadveh.h