OpenTTD Source 20250527-master-g808af15975
vehicle_cmd.cpp
Go to the documentation of this file.
1/*
2 * This file is part of OpenTTD.
3 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6 */
7
10#include "stdafx.h"
11#include "roadveh.h"
12#include "news_func.h"
13#include "airport.h"
14#include "command_func.h"
15#include "company_func.h"
16#include "train.h"
17#include "aircraft.h"
18#include "newgrf_text.h"
19#include "vehicle_func.h"
20#include "string_func.h"
21#include "depot_map.h"
22#include "vehiclelist.h"
23#include "engine_func.h"
25#include "autoreplace_gui.h"
26#include "group.h"
27#include "order_backup.h"
28#include "ship.h"
29#include "newgrf.h"
30#include "company_base.h"
31#include "core/random_func.hpp"
32#include "vehicle_cmd.h"
33#include "aircraft_cmd.h"
34#include "autoreplace_cmd.h"
35#include "group_cmd.h"
36#include "order_cmd.h"
37#include "roadveh_cmd.h"
38#include "train_cmd.h"
39#include "ship_cmd.h"
40#include <charconv>
41
42#include "table/strings.h"
43
44#include "safeguards.h"
45
46/* Tables used in vehicle_func.h to find the right error message for a certain vehicle type */
47const StringID _veh_build_msg_table[] = {
48 STR_ERROR_CAN_T_BUY_TRAIN,
49 STR_ERROR_CAN_T_BUY_ROAD_VEHICLE,
50 STR_ERROR_CAN_T_BUY_SHIP,
51 STR_ERROR_CAN_T_BUY_AIRCRAFT,
52};
53
54const StringID _veh_sell_msg_table[] = {
55 STR_ERROR_CAN_T_SELL_TRAIN,
56 STR_ERROR_CAN_T_SELL_ROAD_VEHICLE,
57 STR_ERROR_CAN_T_SELL_SHIP,
58 STR_ERROR_CAN_T_SELL_AIRCRAFT,
59};
60
61const StringID _veh_sell_all_msg_table[] = {
62 STR_ERROR_CAN_T_SELL_ALL_TRAIN,
63 STR_ERROR_CAN_T_SELL_ALL_ROAD_VEHICLE,
64 STR_ERROR_CAN_T_SELL_ALL_SHIP,
65 STR_ERROR_CAN_T_SELL_ALL_AIRCRAFT,
66};
67
68const StringID _veh_autoreplace_msg_table[] = {
69 STR_ERROR_CAN_T_AUTOREPLACE_TRAIN,
70 STR_ERROR_CAN_T_AUTOREPLACE_ROAD_VEHICLE,
71 STR_ERROR_CAN_T_AUTOREPLACE_SHIP,
72 STR_ERROR_CAN_T_AUTOREPLACE_AIRCRAFT,
73};
74
75const StringID _veh_refit_msg_table[] = {
76 STR_ERROR_CAN_T_REFIT_TRAIN,
77 STR_ERROR_CAN_T_REFIT_ROAD_VEHICLE,
78 STR_ERROR_CAN_T_REFIT_SHIP,
79 STR_ERROR_CAN_T_REFIT_AIRCRAFT,
80};
81
82const StringID _send_to_depot_msg_table[] = {
83 STR_ERROR_CAN_T_SEND_TRAIN_TO_DEPOT,
84 STR_ERROR_CAN_T_SEND_ROAD_VEHICLE_TO_DEPOT,
85 STR_ERROR_CAN_T_SEND_SHIP_TO_DEPOT,
86 STR_ERROR_CAN_T_SEND_AIRCRAFT_TO_HANGAR,
87};
88
89
100std::tuple<CommandCost, VehicleID, uint, uint16_t, CargoArray> CmdBuildVehicle(DoCommandFlags flags, TileIndex tile, EngineID eid, bool use_free_vehicles, CargoType cargo, ClientID client_id)
101{
102 /* Elementary check for valid location. */
103 if (!IsDepotTile(tile) || !IsTileOwner(tile, _current_company)) return { CMD_ERROR, VehicleID::Invalid(), 0, 0, {} };
104
105 VehicleType type = GetDepotVehicleType(tile);
106
107 /* Validate the engine type. */
108 if (!IsEngineBuildable(eid, type, _current_company)) return { CommandCost(STR_ERROR_RAIL_VEHICLE_NOT_AVAILABLE + type), VehicleID::Invalid(), 0, 0, {} };
109
110 /* Validate the cargo type. */
111 if (cargo >= NUM_CARGO && IsValidCargoType(cargo)) return { CMD_ERROR, VehicleID::Invalid(), 0, 0, {} };
112
113 const Engine *e = Engine::Get(eid);
115
116 /* Engines without valid cargo should not be available */
117 CargoType default_cargo = e->GetDefaultCargoType();
118 if (!IsValidCargoType(default_cargo)) return { CMD_ERROR, VehicleID::Invalid(), 0, 0, {} };
119
120 bool refitting = IsValidCargoType(cargo) && cargo != default_cargo;
121
122 /* Check whether the number of vehicles we need to build can be built according to pool space. */
123 uint num_vehicles;
124 switch (type) {
125 case VEH_TRAIN: num_vehicles = (e->u.rail.railveh_type == RAILVEH_MULTIHEAD ? 2 : 1) + CountArticulatedParts(eid, false); break;
126 case VEH_ROAD: num_vehicles = 1 + CountArticulatedParts(eid, false); break;
127 case VEH_SHIP: num_vehicles = 1; break;
128 case VEH_AIRCRAFT: num_vehicles = e->u.air.subtype & AIR_CTOL ? 2 : 3; break;
129 default: NOT_REACHED(); // Safe due to IsDepotTile()
130 }
131 if (!Vehicle::CanAllocateItem(num_vehicles)) return { CommandCost(STR_ERROR_TOO_MANY_VEHICLES_IN_GAME), VehicleID::Invalid(), 0, 0, {} };
132
133 /* Check whether we can allocate a unit number. Autoreplace does not allocate
134 * an unit number as it will (always) reuse the one of the replaced vehicle
135 * and (train) wagons don't have an unit number in any scenario. */
136 UnitID unit_num = (flags.Test(DoCommandFlag::QueryCost) || flags.Test(DoCommandFlag::AutoReplace) || (type == VEH_TRAIN && e->u.rail.railveh_type == RAILVEH_WAGON)) ? 0 : GetFreeUnitNumber(type);
137 if (unit_num == UINT16_MAX) return { CommandCost(STR_ERROR_TOO_MANY_VEHICLES_IN_GAME), VehicleID::Invalid(), 0, 0, {} };
138
139 /* If we are refitting we need to temporarily purchase the vehicle to be able to
140 * test it. */
141 DoCommandFlags subflags = flags;
143
144 /* Vehicle construction needs random bits, so we have to save the random
145 * seeds to prevent desyncs. */
146 SavedRandomSeeds saved_seeds;
147 SaveRandomSeeds(&saved_seeds);
148
149 Vehicle *v = nullptr;
150 switch (type) {
151 case VEH_TRAIN: value.AddCost(CmdBuildRailVehicle(subflags, tile, e, &v)); break;
152 case VEH_ROAD: value.AddCost(CmdBuildRoadVehicle(subflags, tile, e, &v)); break;
153 case VEH_SHIP: value.AddCost(CmdBuildShip (subflags, tile, e, &v)); break;
154 case VEH_AIRCRAFT: value.AddCost(CmdBuildAircraft (subflags, tile, e, &v)); break;
155 default: NOT_REACHED(); // Safe due to IsDepotTile()
156 }
157
158 VehicleID veh_id = VehicleID::Invalid();
159 uint refitted_capacity = 0;
160 uint16_t refitted_mail_capacity = 0;
161 CargoArray cargo_capacities{};
162 if (value.Succeeded()) {
163 if (subflags.Test(DoCommandFlag::Execute)) {
164 v->unitnumber = unit_num;
165 v->value = value.GetCost();
166 veh_id = v->index;
167 }
168
169 if (refitting) {
170 /* Refit only one vehicle. If we purchased an engine, it may have gained free wagons. */
171 CommandCost cc;
172 std::tie(cc, refitted_capacity, refitted_mail_capacity, cargo_capacities) = CmdRefitVehicle(flags, v->index, cargo, 0, false, false, 1);
173 value.AddCost(std::move(cc));
174 } else {
175 /* Fill in non-refitted capacities */
176 if (e->type == VEH_TRAIN || e->type == VEH_ROAD) {
177 cargo_capacities = GetCapacityOfArticulatedParts(eid);
178 refitted_capacity = cargo_capacities[default_cargo];
179 refitted_mail_capacity = 0;
180 } else {
181 refitted_capacity = e->GetDisplayDefaultCapacity(&refitted_mail_capacity);
182 cargo_capacities[default_cargo] = refitted_capacity;
183 CargoType mail = GetCargoTypeByLabel(CT_MAIL);
184 if (IsValidCargoType(mail)) cargo_capacities[mail] = refitted_mail_capacity;
185 }
186 }
187
188 if (flags.Test(DoCommandFlag::Execute)) {
189 if (type == VEH_TRAIN && use_free_vehicles && !flags.Test(DoCommandFlag::AutoReplace) && Train::From(v)->IsEngine()) {
190 /* Move any free wagons to the new vehicle. */
192 }
193
197 if (IsLocalCompany()) {
198 InvalidateAutoreplaceWindow(v->engine_type, v->group_id); // updates the auto replace window (must be called before incrementing num_engines)
199 }
200 }
201
202 if (subflags.Test(DoCommandFlag::Execute)) {
205
206 if (v->IsPrimaryVehicle()) {
208 if (!subflags.Test(DoCommandFlag::AutoReplace)) OrderBackup::Restore(v, client_id);
209 }
210
211 Company::Get(v->owner)->freeunits[v->type].UseID(v->unitnumber);
212 }
213
214
215 /* If we are not in DoCommandFlag::Execute undo everything */
216 if (flags != subflags) {
218 }
219 }
220
221 /* Only restore if we actually did some refitting */
222 if (flags != subflags) RestoreRandomSeeds(saved_seeds);
223
224 return { value, veh_id, refitted_capacity, refitted_mail_capacity, cargo_capacities };
225}
226
236CommandCost CmdSellVehicle(DoCommandFlags flags, VehicleID v_id, bool sell_chain, bool backup_order, ClientID client_id)
237{
238 Vehicle *v = Vehicle::GetIfValid(v_id);
239 if (v == nullptr) return CMD_ERROR;
240
241 Vehicle *front = v->First();
242
243 CommandCost ret = CheckOwnership(front->owner);
244 if (ret.Failed()) return ret;
245
246 if (front->vehstatus.Test(VehState::Crashed)) return CommandCost(STR_ERROR_VEHICLE_IS_DESTROYED);
247
248 if (!front->IsStoppedInDepot()) return CommandCost(STR_ERROR_TRAIN_MUST_BE_STOPPED_INSIDE_DEPOT + front->type);
249
250 /* Can we actually make the order backup, i.e. are there enough orders? */
251 if (backup_order && front->orders != nullptr && !front->orders->IsShared()) {
252 /* Only happens in exceptional cases when there aren't enough orders anyhow.
253 * Thus it should be safe to just drop the orders in that case. */
254 backup_order = false;
255 }
256
257 if (v->type == VEH_TRAIN) {
258 ret = CmdSellRailWagon(flags, v, sell_chain, backup_order, client_id);
259 } else {
261
262 if (flags.Test(DoCommandFlag::Execute)) {
263 if (front->IsPrimaryVehicle() && backup_order) OrderBackup::Backup(front, client_id);
264 delete front;
265 }
266 }
267
268 return ret;
269}
270
280static int GetRefitCostFactor(const Vehicle *v, EngineID engine_type, CargoType new_cargo_type, uint8_t new_subtype, bool *auto_refit_allowed)
281{
282 /* Prepare callback param with info about the new cargo type. */
283 const Engine *e = Engine::Get(engine_type);
284
285 /* Is this vehicle a NewGRF vehicle? */
286 if (e->GetGRF() != nullptr) {
287 const CargoSpec *cs = CargoSpec::Get(new_cargo_type);
288 uint32_t param1 = (cs->classes.base() << 16) | (new_subtype << 8) | e->GetGRF()->cargo_map[new_cargo_type];
289
290 uint16_t cb_res = GetVehicleCallback(CBID_VEHICLE_REFIT_COST, param1, 0, engine_type, v);
291 if (cb_res != CALLBACK_FAILED) {
292 *auto_refit_allowed = HasBit(cb_res, 14);
293 int factor = GB(cb_res, 0, 14);
294 if (factor >= 0x2000) factor -= 0x4000; // Treat as signed integer.
295 return factor;
296 }
297 }
298
299 *auto_refit_allowed = e->info.refit_cost == 0;
300 return (v == nullptr || v->cargo_type != new_cargo_type) ? e->info.refit_cost : 0;
301}
302
312static CommandCost GetRefitCost(const Vehicle *v, EngineID engine_type, CargoType new_cargo_type, uint8_t new_subtype, bool *auto_refit_allowed)
313{
314 ExpensesType expense_type;
315 const Engine *e = Engine::Get(engine_type);
316 Price base_price;
317 int cost_factor = GetRefitCostFactor(v, engine_type, new_cargo_type, new_subtype, auto_refit_allowed);
318 switch (e->type) {
319 case VEH_SHIP:
320 base_price = PR_BUILD_VEHICLE_SHIP;
321 expense_type = EXPENSES_SHIP_RUN;
322 break;
323
324 case VEH_ROAD:
325 base_price = PR_BUILD_VEHICLE_ROAD;
326 expense_type = EXPENSES_ROADVEH_RUN;
327 break;
328
329 case VEH_AIRCRAFT:
330 base_price = PR_BUILD_VEHICLE_AIRCRAFT;
331 expense_type = EXPENSES_AIRCRAFT_RUN;
332 break;
333
334 case VEH_TRAIN:
335 base_price = (e->u.rail.railveh_type == RAILVEH_WAGON) ? PR_BUILD_VEHICLE_WAGON : PR_BUILD_VEHICLE_TRAIN;
336 cost_factor <<= 1;
337 expense_type = EXPENSES_TRAIN_RUN;
338 break;
339
340 default: NOT_REACHED();
341 }
342 if (cost_factor < 0) {
343 return CommandCost(expense_type, -GetPrice(base_price, -cost_factor, e->GetGRF(), -10));
344 } else {
345 return CommandCost(expense_type, GetPrice(base_price, cost_factor, e->GetGRF(), -10));
346 }
347}
348
356
369static std::tuple<CommandCost, uint, uint16_t, CargoArray> RefitVehicle(Vehicle *v, bool only_this, uint8_t num_vehicles, CargoType new_cargo_type, uint8_t new_subtype, DoCommandFlags flags, bool auto_refit)
370{
371 CommandCost cost(v->GetExpenseType(false));
372 uint total_capacity = 0;
373 uint total_mail_capacity = 0;
374 num_vehicles = num_vehicles == 0 ? UINT8_MAX : num_vehicles;
375 CargoArray cargo_capacities{};
376
377 VehicleSet vehicles_to_refit;
378 if (!only_this) {
379 GetVehicleSet(vehicles_to_refit, v, num_vehicles);
380 /* In this case, we need to check the whole chain. */
381 v = v->First();
382 }
383
384 std::vector<RefitResult> refit_result;
385
387 uint8_t actual_subtype = new_subtype;
388 for (; v != nullptr; v = (only_this ? nullptr : v->Next())) {
389 /* Reset actual_subtype for every new vehicle */
390 if (!v->IsArticulatedPart()) actual_subtype = new_subtype;
391
392 if (v->type == VEH_TRAIN && std::ranges::find(vehicles_to_refit, v->index) == vehicles_to_refit.end() && !only_this) continue;
393
394 const Engine *e = v->GetEngine();
395 if (!e->CanCarryCargo()) continue;
396
397 /* If the vehicle is not refittable, or does not allow automatic refitting,
398 * count its capacity nevertheless if the cargo matches */
399 bool refittable = HasBit(e->info.refit_mask, new_cargo_type) && (!auto_refit || e->info.misc_flags.Test(EngineMiscFlag::AutoRefit));
400 if (!refittable && v->cargo_type != new_cargo_type) {
401 uint amount = e->DetermineCapacity(v, nullptr);
402 if (amount > 0) cargo_capacities[v->cargo_type] += amount;
403 continue;
404 }
405
406 /* Determine best fitting subtype if requested */
407 if (actual_subtype == 0xFF) {
408 actual_subtype = GetBestFittingSubType(v, v, new_cargo_type);
409 }
410
411 /* Back up the vehicle's cargo type */
412 CargoType temp_cargo_type = v->cargo_type;
413 uint8_t temp_subtype = v->cargo_subtype;
414 if (refittable) {
415 v->cargo_type = new_cargo_type;
416 v->cargo_subtype = actual_subtype;
417 }
418
419 uint16_t mail_capacity = 0;
420 uint amount = e->DetermineCapacity(v, &mail_capacity);
421 total_capacity += amount;
422 /* mail_capacity will always be zero if the vehicle is not an aircraft. */
423 total_mail_capacity += mail_capacity;
424
425 cargo_capacities[new_cargo_type] += amount;
426 CargoType mail = GetCargoTypeByLabel(CT_MAIL);
427 if (IsValidCargoType(mail)) cargo_capacities[mail] += mail_capacity;
428
429 if (!refittable) continue;
430
431 /* Restore the original cargo type */
432 v->cargo_type = temp_cargo_type;
433 v->cargo_subtype = temp_subtype;
434
435 bool auto_refit_allowed;
436 CommandCost refit_cost = GetRefitCost(v, v->engine_type, new_cargo_type, actual_subtype, &auto_refit_allowed);
437 if (auto_refit && !flags.Test(DoCommandFlag::QueryCost) && !auto_refit_allowed) {
438 /* Sorry, auto-refitting not allowed, subtract the cargo amount again from the total.
439 * When querrying cost/capacity (for example in order refit GUI), we always assume 'allowed'.
440 * It is not predictable. */
441 total_capacity -= amount;
442 total_mail_capacity -= mail_capacity;
443
444 if (v->cargo_type == new_cargo_type) {
445 /* Add the old capacity nevertheless, if the cargo matches */
446 total_capacity += v->cargo_cap;
447 if (v->type == VEH_AIRCRAFT) total_mail_capacity += v->Next()->cargo_cap;
448 }
449 continue;
450 }
451 cost.AddCost(std::move(refit_cost));
452
453 /* Record the refitting.
454 * Do not execute the refitting immediately, so DetermineCapacity and GetRefitCost do the same in test and exec run.
455 * (weird NewGRFs)
456 * Note:
457 * - If the capacity of vehicles depends on other vehicles in the chain, the actual capacity is
458 * set after RefitVehicle() via ConsistChanged() and friends. The estimation via _returned_refit_capacity will be wrong.
459 * - We have to call the refit cost callback with the pre-refit configuration of the chain because we want refit and
460 * autorefit to behave the same, and we need its result for auto_refit_allowed.
461 */
462 refit_result.emplace_back(v, amount, mail_capacity, actual_subtype);
463 }
464
465 if (flags.Test(DoCommandFlag::Execute)) {
466 /* Store the result */
467 for (RefitResult &result : refit_result) {
468 Vehicle *u = result.v;
469 u->refit_cap = (u->cargo_type == new_cargo_type) ? std::min<uint16_t>(result.capacity, u->refit_cap) : 0;
470 if (u->cargo.TotalCount() > u->refit_cap) u->cargo.Truncate(u->cargo.TotalCount() - u->refit_cap);
471 u->cargo_type = new_cargo_type;
472 u->cargo_cap = result.capacity;
473 u->cargo_subtype = result.subtype;
474 if (u->type == VEH_AIRCRAFT) {
475 Vehicle *w = u->Next();
476 assert(w != nullptr);
477 w->refit_cap = std::min<uint16_t>(w->refit_cap, result.mail_capacity);
478 w->cargo_cap = result.mail_capacity;
479 if (w->cargo.TotalCount() > w->refit_cap) w->cargo.Truncate(w->cargo.TotalCount() - w->refit_cap);
480 }
481 }
482 }
483
484 refit_result.clear();
485 return { cost, total_capacity, total_mail_capacity, cargo_capacities };
486}
487
500std::tuple<CommandCost, uint, uint16_t, CargoArray> CmdRefitVehicle(DoCommandFlags flags, VehicleID veh_id, CargoType new_cargo_type, uint8_t new_subtype, bool auto_refit, bool only_this, uint8_t num_vehicles)
501{
502 Vehicle *v = Vehicle::GetIfValid(veh_id);
503 if (v == nullptr) return { CMD_ERROR, 0, 0, {} };
504
505 /* Don't allow disasters and sparks and such to be refitted.
506 * We cannot check for IsPrimaryVehicle as autoreplace also refits in free wagon chains. */
507 if (!IsCompanyBuildableVehicleType(v->type)) return { CMD_ERROR, 0, 0, {} };
508
509 Vehicle *front = v->First();
510
511 CommandCost ret = CheckOwnership(front->owner);
512 if (ret.Failed()) return { ret, 0, 0, {} };
513
514 bool free_wagon = v->type == VEH_TRAIN && Train::From(front)->IsFreeWagon(); // used by autoreplace/renew
515
516 /* Don't allow shadows and such to be refitted. */
517 if (v != front && (v->type == VEH_SHIP || v->type == VEH_AIRCRAFT)) return { CMD_ERROR, 0, 0, {} };
518
519 /* Allow auto-refitting only during loading and normal refitting only in a depot. */
520 if (!flags.Test(DoCommandFlag::QueryCost) && // used by the refit GUI, including the order refit GUI.
521 !free_wagon && // used by autoreplace/renew
522 (!auto_refit || !front->current_order.IsType(OT_LOADING)) && // refit inside stations
523 !front->IsStoppedInDepot()) { // refit inside depots
524 return { CommandCost(STR_ERROR_TRAIN_MUST_BE_STOPPED_INSIDE_DEPOT + front->type), 0, 0, {} };
525 }
526
527 if (front->vehstatus.Test(VehState::Crashed)) return { CommandCost(STR_ERROR_VEHICLE_IS_DESTROYED), 0, 0, {} };
528
529 /* Check cargo */
530 if (new_cargo_type >= NUM_CARGO) return { CMD_ERROR, 0, 0, {} };
531
532 /* For ships and aircraft there is always only one. */
533 only_this |= front->type == VEH_SHIP || front->type == VEH_AIRCRAFT;
534
535 auto [cost, refit_capacity, mail_capacity, cargo_capacities] = RefitVehicle(v, only_this, num_vehicles, new_cargo_type, new_subtype, flags, auto_refit);
536
537 if (flags.Test(DoCommandFlag::Execute)) {
538 /* Update the cached variables */
539 switch (v->type) {
540 case VEH_TRAIN:
541 Train::From(front)->ConsistChanged(auto_refit ? CCF_AUTOREFIT : CCF_REFIT);
542 break;
543 case VEH_ROAD:
544 RoadVehUpdateCache(RoadVehicle::From(front), auto_refit);
545 if (_settings_game.vehicle.roadveh_acceleration_model != AM_ORIGINAL) RoadVehicle::From(front)->CargoChanged();
546 break;
547
548 case VEH_SHIP:
551 break;
552
553 case VEH_AIRCRAFT:
556 break;
557
558 default: NOT_REACHED();
559 }
560 front->MarkDirty();
561
562 if (!free_wagon) {
565 }
567 } else {
568 /* Always invalidate the cache; querycost might have filled it. */
570 }
571
572 return { cost, refit_capacity, mail_capacity, cargo_capacities };
573}
574
582CommandCost CmdStartStopVehicle(DoCommandFlags flags, VehicleID veh_id, bool evaluate_startstop_cb)
583{
584 /* Disable the effect of evaluate_startstop_cb, when DoCommandFlag::AutoReplace is not set */
585 if (!flags.Test(DoCommandFlag::AutoReplace)) evaluate_startstop_cb = true;
586
587 Vehicle *v = Vehicle::GetIfValid(veh_id);
588 if (v == nullptr || !v->IsPrimaryVehicle()) return CMD_ERROR;
589
591 if (ret.Failed()) return ret;
592
593 if (v->vehstatus.Test(VehState::Crashed)) return CommandCost(STR_ERROR_VEHICLE_IS_DESTROYED);
594
595 switch (v->type) {
596 case VEH_TRAIN:
597 if (v->vehstatus.Test(VehState::Stopped) && Train::From(v)->gcache.cached_power == 0) return CommandCost(STR_ERROR_TRAIN_START_NO_POWER);
598 break;
599
600 case VEH_SHIP:
601 case VEH_ROAD:
602 break;
603
604 case VEH_AIRCRAFT: {
605 Aircraft *a = Aircraft::From(v);
606 /* cannot stop airplane when in flight, or when taking off / landing */
607 if (a->state >= STARTTAKEOFF && a->state < TERM7) return CommandCost(STR_ERROR_AIRCRAFT_IS_IN_FLIGHT);
608 if (HasBit(a->flags, VAF_HELI_DIRECT_DESCENT)) return CommandCost(STR_ERROR_AIRCRAFT_IS_IN_FLIGHT);
609 break;
610 }
611
612 default: return CMD_ERROR;
613 }
614
615 if (evaluate_startstop_cb) {
616 /* Check if this vehicle can be started/stopped. Failure means 'allow'. */
617 std::array<int32_t, 1> regs100;
618 uint16_t callback = GetVehicleCallback(CBID_VEHICLE_START_STOP_CHECK, 0, 0, v->engine_type, v, regs100);
619 StringID error = STR_NULL;
620 if (callback != CALLBACK_FAILED) {
621 if (v->GetGRF()->grf_version < 8) {
622 /* 8 bit result 0xFF means 'allow' */
623 if (callback < 0x400 && GB(callback, 0, 8) != 0xFF) error = GetGRFStringID(v->GetGRFID(), GRFSTR_MISC_GRF_TEXT + callback);
624 } else {
625 if (callback < 0x400) {
626 error = GetGRFStringID(v->GetGRFID(), GRFSTR_MISC_GRF_TEXT + callback);
627 } else {
628 switch (callback) {
629 case 0x400: // allow
630 break;
631
632 case 0x40F:
633 error = GetGRFStringID(v->GetGRFID(), static_cast<GRFStringID>(regs100[0]));
634 break;
635
636 default: // unknown reason -> disallow
637 error = STR_ERROR_INCOMPATIBLE_RAIL_TYPES;
638 break;
639 }
640 }
641 }
642 }
643 if (error != STR_NULL) return CommandCost(error);
644 }
645
646 if (flags.Test(DoCommandFlag::Execute)) {
648
650 if (v->type != VEH_TRAIN) v->cur_speed = 0; // trains can stop 'slowly'
651
652 /* Unbunching data is no longer valid. */
654
655 v->MarkDirty();
660 }
661 return CommandCost();
662}
663
673CommandCost CmdMassStartStopVehicle(DoCommandFlags flags, TileIndex tile, bool do_start, bool vehicle_list_window, const VehicleListIdentifier &vli)
674{
675 VehicleList list;
676
677 if (!vli.Valid()) return CMD_ERROR;
679
680 if (vehicle_list_window) {
681 if (!GenerateVehicleSortList(&list, vli)) return CMD_ERROR;
682 } else {
683 if (!IsDepotTile(tile) || !IsTileOwner(tile, _current_company)) return CMD_ERROR;
684 /* Get the list of vehicles in the depot */
685 BuildDepotVehicleList(vli.vtype, tile, &list, nullptr);
686 }
687
688 for (const Vehicle *v : list) {
689 if (v->vehstatus.Test(VehState::Stopped) != do_start) continue;
690
691 if (!vehicle_list_window && !v->IsChainInDepot()) continue;
692
693 /* Just try and don't care if some vehicle's can't be stopped. */
694 Command<CMD_START_STOP_VEHICLE>::Do(flags, v->index, false);
695 }
696
697 return CommandCost();
698}
699
708{
709 VehicleList list;
710
712
713 if (!IsCompanyBuildableVehicleType(vehicle_type)) return CMD_ERROR;
714 if (!IsDepotTile(tile) || !IsTileOwner(tile, _current_company)) return CMD_ERROR;
715
716 /* Get the list of vehicles in the depot */
717 BuildDepotVehicleList(vehicle_type, tile, &list, &list);
718
719 CommandCost last_error = CMD_ERROR;
720 bool had_success = false;
721 for (const Vehicle *v : list) {
722 CommandCost ret = Command<CMD_SELL_VEHICLE>::Do(flags, v->index, true, false, INVALID_CLIENT_ID);
723 if (ret.Succeeded()) {
724 cost.AddCost(ret.GetCost());
725 had_success = true;
726 } else {
727 last_error = std::move(ret);
728 }
729 }
730
731 return had_success ? cost : last_error;
732}
733
742{
743 VehicleList list;
745
746 if (!IsCompanyBuildableVehicleType(vehicle_type)) return CMD_ERROR;
747 if (!IsDepotTile(tile) || !IsTileOwner(tile, _current_company)) return CMD_ERROR;
748
749 /* Get the list of vehicles in the depot */
750 BuildDepotVehicleList(vehicle_type, tile, &list, &list, true);
751
752 for (const Vehicle *v : list) {
753 /* Ensure that the vehicle completely in the depot */
754 if (!v->IsChainInDepot()) continue;
755
757
758 if (ret.Succeeded()) cost.AddCost(ret.GetCost());
759 }
760 return cost;
761}
762
768bool IsUniqueVehicleName(const std::string &name)
769{
770 for (const Vehicle *v : Vehicle::Iterate()) {
771 if (!v->name.empty() && v->name == name) return false;
772 }
773
774 return true;
775}
776
782static void CloneVehicleName(const Vehicle *src, Vehicle *dst)
783{
784 std::string buf;
785
786 /* Find the position of the first digit in the last group of digits. */
787 size_t number_position;
788 for (number_position = src->name.length(); number_position > 0; number_position--) {
789 /* The design of UTF-8 lets this work simply without having to check
790 * for UTF-8 sequences. */
791 if (src->name[number_position - 1] < '0' || src->name[number_position - 1] > '9') break;
792 }
793
794 /* Format buffer and determine starting number. */
795 long num;
796 uint8_t padding = 0;
797 if (number_position == src->name.length()) {
798 /* No digit at the end, so start at number 2. */
799 buf = src->name;
800 buf += " ";
801 number_position = buf.length();
802 num = 2;
803 } else {
804 /* Found digits, parse them and start at the next number. */
805 buf = src->name.substr(0, number_position);
806
807 auto num_str = std::string_view(src->name).substr(number_position);
808 padding = (uint8_t)num_str.length();
809
810 [[maybe_unused]] auto err = std::from_chars(num_str.data(), num_str.data() + num_str.size(), num, 10).ec;
811 assert(err == std::errc());
812 num++;
813 }
814
815 /* Check if this name is already taken. */
816 for (int max_iterations = 1000; max_iterations > 0; max_iterations--, num++) {
817 std::string new_name = fmt::format("{}{:0{}}", buf, num, padding);
818
819 /* Check the name is unique. */
820 if (IsUniqueVehicleName(new_name)) {
821 dst->name = std::move(new_name);
822 break;
823 }
824 }
825
826 /* All done. If we didn't find a name, it'll just use its default. */
827}
828
837std::tuple<CommandCost, VehicleID> CmdCloneVehicle(DoCommandFlags flags, TileIndex tile, VehicleID veh_id, bool share_orders)
838{
840
841 Vehicle *v = Vehicle::GetIfValid(veh_id);
842 if (v == nullptr || !v->IsPrimaryVehicle()) return { CMD_ERROR, VehicleID::Invalid() };
843 Vehicle *v_front = v;
844 Vehicle *w = nullptr;
845 Vehicle *w_front = nullptr;
846 Vehicle *w_rear = nullptr;
847
848 /*
849 * v_front is the front engine in the original vehicle
850 * v is the car/vehicle of the original vehicle that is currently being copied
851 * w_front is the front engine of the cloned vehicle
852 * w is the car/vehicle currently being cloned
853 * w_rear is the rear end of the cloned train. It's used to add more cars and is only used by trains
854 */
855
857 if (ret.Failed()) return { ret, VehicleID::Invalid() };
858
859 if (v->type == VEH_TRAIN && (!v->IsFrontEngine() || Train::From(v)->crash_anim_pos >= 4400)) return { CMD_ERROR, VehicleID::Invalid() };
860
861 /* check that we can allocate enough vehicles */
862 if (!flags.Test(DoCommandFlag::Execute)) {
863 int veh_counter = 0;
864 do {
865 veh_counter++;
866 } while ((v = v->Next()) != nullptr);
867
868 if (!Vehicle::CanAllocateItem(veh_counter)) {
869 return { CommandCost(STR_ERROR_TOO_MANY_VEHICLES_IN_GAME), VehicleID::Invalid() };
870 }
871 }
872
873 v = v_front;
874
875 VehicleID new_veh_id = VehicleID::Invalid();
876 do {
877 if (v->type == VEH_TRAIN && Train::From(v)->IsRearDualheaded()) {
878 /* we build the rear ends of multiheaded trains with the front ones */
879 continue;
880 }
881
882 /* In case we're building a multi headed vehicle and the maximum number of
883 * vehicles is almost reached (e.g. max trains - 1) not all vehicles would
884 * be cloned. When the non-primary engines were build they were seen as
885 * 'new' vehicles whereas they would immediately be joined with a primary
886 * engine. This caused the vehicle to be not build as 'the limit' had been
887 * reached, resulting in partially build vehicles and such. */
888 DoCommandFlags build_flags = flags;
890
891 CommandCost cost;
892 std::tie(cost, new_veh_id, std::ignore, std::ignore, std::ignore) = Command<CMD_BUILD_VEHICLE>::Do(build_flags, tile, v->engine_type, false, INVALID_CARGO, INVALID_CLIENT_ID);
893
894 if (cost.Failed()) {
895 /* Can't build a part, then sell the stuff we already made; clear up the mess */
896 if (w_front != nullptr) Command<CMD_SELL_VEHICLE>::Do(flags, w_front->index, true, false, INVALID_CLIENT_ID);
897 return { cost, VehicleID::Invalid() };
898 }
899
900 total_cost.AddCost(cost.GetCost());
901
902 if (flags.Test(DoCommandFlag::Execute)) {
903 w = Vehicle::Get(new_veh_id);
904
905 if (v->type == VEH_TRAIN && Train::From(v)->flags.Test(VehicleRailFlag::Flipped)) {
906 /* Only copy the reverse state if neither old or new vehicle implements reverse-on-build probability callback. */
907 if (!TestVehicleBuildProbability(v, v->engine_type, BuildProbabilityType::Reversed).has_value() &&
908 !TestVehicleBuildProbability(w, w->engine_type, BuildProbabilityType::Reversed).has_value()) {
910 }
911 }
912
913 if (v->type == VEH_TRAIN && !v->IsFrontEngine()) {
914 /* this s a train car
915 * add this unit to the end of the train */
916 CommandCost result = Command<CMD_MOVE_RAIL_VEHICLE>::Do(flags, w->index, w_rear->index, true);
917 if (result.Failed()) {
918 /* The train can't be joined to make the same consist as the original.
919 * Sell what we already made (clean up) and return an error. */
920 Command<CMD_SELL_VEHICLE>::Do(flags, w_front->index, true, false, INVALID_CLIENT_ID);
922 return { result, VehicleID::Invalid() }; // return error and the message returned from CMD_MOVE_RAIL_VEHICLE
923 }
924 } else {
925 /* this is a front engine or not a train. */
926 w_front = w;
928 w->SetServiceIntervalIsCustom(v->ServiceIntervalIsCustom());
929 w->SetServiceIntervalIsPercent(v->ServiceIntervalIsPercent());
930 }
931 w_rear = w; // trains needs to know the last car in the train, so they can add more in next loop
932 }
933 } while (v->type == VEH_TRAIN && (v = v->GetNextVehicle()) != nullptr);
934
935 if (flags.Test(DoCommandFlag::Execute) && v_front->type == VEH_TRAIN) {
936 /* for trains this needs to be the front engine due to the callback function */
937 new_veh_id = w_front->index;
938 }
939
940 if (flags.Test(DoCommandFlag::Execute)) {
941 /* Cloned vehicles belong to the same group */
942 Command<CMD_ADD_VEHICLE_GROUP>::Do(flags, v_front->group_id, w_front->index, false, VehicleListIdentifier{});
943 }
944
945
946 /* Take care of refitting. */
947 w = w_front;
948 v = v_front;
949
950 /* Both building and refitting are influenced by newgrf callbacks, which
951 * makes it impossible to accurately estimate the cloning costs. In
952 * particular, it is possible for engines of the same type to be built with
953 * different numbers of articulated parts, so when refitting we have to
954 * loop over real vehicles first, and then the articulated parts of those
955 * vehicles in a different loop. */
956 do {
957 do {
958 if (flags.Test(DoCommandFlag::Execute)) {
959 assert(w != nullptr);
960
961 /* Find out what's the best sub type */
962 uint8_t subtype = GetBestFittingSubType(v, w, v->cargo_type);
963 if (w->cargo_type != v->cargo_type || w->cargo_subtype != subtype) {
964 CommandCost cost = std::get<0>(Command<CMD_REFIT_VEHICLE>::Do(flags, w->index, v->cargo_type, subtype, false, true, 0));
965 if (cost.Succeeded()) total_cost.AddCost(cost.GetCost());
966 }
967
968 if (w->IsGroundVehicle() && w->HasArticulatedPart()) {
969 w = w->GetNextArticulatedPart();
970 } else {
971 break;
972 }
973 } else {
974 const Engine *e = v->GetEngine();
975 CargoType initial_cargo = (e->CanCarryCargo() ? e->GetDefaultCargoType() : INVALID_CARGO);
976
977 if (v->cargo_type != initial_cargo && IsValidCargoType(initial_cargo)) {
978 bool dummy;
979 total_cost.AddCost(GetRefitCost(nullptr, v->engine_type, v->cargo_type, v->cargo_subtype, &dummy));
980 }
981 }
982
983 if (v->IsGroundVehicle() && v->HasArticulatedPart()) {
984 v = v->GetNextArticulatedPart();
985 } else {
986 break;
987 }
988 } while (v != nullptr);
989
990 if (flags.Test(DoCommandFlag::Execute) && v->type == VEH_TRAIN) w = w->GetNextVehicle();
991 } while (v->type == VEH_TRAIN && (v = v->GetNextVehicle()) != nullptr);
992
993 if (flags.Test(DoCommandFlag::Execute)) {
994 /*
995 * Set the orders of the vehicle. Cannot do it earlier as we need
996 * the vehicle refitted before doing this, otherwise the moved
997 * cargo types might not match (passenger vs non-passenger)
998 */
999 CommandCost result = Command<CMD_CLONE_ORDER>::Do(flags, (share_orders ? CO_SHARE : CO_COPY), w_front->index, v_front->index);
1000 if (result.Failed()) {
1001 /* The vehicle has already been bought, so now it must be sold again. */
1002 Command<CMD_SELL_VEHICLE>::Do(flags, w_front->index, true, false, INVALID_CLIENT_ID);
1003 return { result, VehicleID::Invalid() };
1004 }
1005
1006 /* Now clone the vehicle's name, if it has one. */
1007 if (!v_front->name.empty()) CloneVehicleName(v_front, w_front);
1008
1009 /* Since we can't estimate the cost of cloning a vehicle accurately we must
1010 * check whether the company has enough money manually. */
1011 if (!CheckCompanyHasMoney(total_cost)) {
1012 /* The vehicle has already been bought, so now it must be sold again. */
1013 Command<CMD_SELL_VEHICLE>::Do(flags, w_front->index, true, false, INVALID_CLIENT_ID);
1014 return { total_cost, VehicleID::Invalid() };
1015 }
1016 }
1017
1018 return { total_cost, new_veh_id };
1019}
1020
1029{
1030 VehicleList list;
1031
1032 if (!GenerateVehicleSortList(&list, vli)) return CMD_ERROR;
1033
1034 /* Send all the vehicles to a depot */
1035 bool had_success = false;
1036 for (uint i = 0; i < list.size(); i++) {
1037 const Vehicle *v = list[i];
1039
1040 if (ret.Succeeded()) {
1041 had_success = true;
1042
1043 /* Return 0 if DoCommandFlag::Execute is not set this is a valid goto depot command)
1044 * In this case we know that at least one vehicle can be sent to a depot
1045 * and we will issue the command. We can now safely quit the loop, knowing
1046 * it will succeed at least once. With DoCommandFlag::Execute we really need to send them to the depot */
1047 if (!flags.Test(DoCommandFlag::Execute)) break;
1048 }
1049 }
1050
1051 return had_success ? CommandCost() : CMD_ERROR;
1052}
1053
1063{
1064 if (depot_cmd.Test(DepotCommandFlag::MassSend)) {
1065 /* Mass goto depot requested */
1066 if (!vli.Valid()) return CMD_ERROR;
1067 return SendAllVehiclesToDepot(flags, depot_cmd.Test(DepotCommandFlag::Service), vli);
1068 }
1069
1070 Vehicle *v = Vehicle::GetIfValid(veh_id);
1071 if (v == nullptr) return CMD_ERROR;
1072 if (!v->IsPrimaryVehicle()) return CMD_ERROR;
1073
1074 return v->SendToDepot(flags, depot_cmd);
1075}
1076
1084CommandCost CmdRenameVehicle(DoCommandFlags flags, VehicleID veh_id, const std::string &text)
1085{
1086 Vehicle *v = Vehicle::GetIfValid(veh_id);
1087 if (v == nullptr || !v->IsPrimaryVehicle()) return CMD_ERROR;
1088
1090 if (ret.Failed()) return ret;
1091
1092 bool reset = text.empty();
1093
1094 if (!reset) {
1096 if (!flags.Test(DoCommandFlag::AutoReplace) && !IsUniqueVehicleName(text)) return CommandCost(STR_ERROR_NAME_MUST_BE_UNIQUE);
1097 }
1098
1099 if (flags.Test(DoCommandFlag::Execute)) {
1100 if (reset) {
1101 v->name.clear();
1102 } else {
1103 v->name = text;
1104 }
1107 }
1108
1109 return CommandCost();
1110}
1111
1112
1122CommandCost CmdChangeServiceInt(DoCommandFlags flags, VehicleID veh_id, uint16_t serv_int, bool is_custom, bool is_percent)
1123{
1124 Vehicle *v = Vehicle::GetIfValid(veh_id);
1125 if (v == nullptr || !v->IsPrimaryVehicle()) return CMD_ERROR;
1126
1128 if (ret.Failed()) return ret;
1129
1130 const Company *company = Company::Get(v->owner);
1131 is_percent = is_custom ? is_percent : company->settings.vehicle.servint_ispercent;
1132
1133 if (is_custom) {
1134 if (serv_int != GetServiceIntervalClamped(serv_int, is_percent)) return CMD_ERROR;
1135 } else {
1136 serv_int = CompanyServiceInterval(company, v->type);
1137 }
1138
1139 if (flags.Test(DoCommandFlag::Execute)) {
1140 v->SetServiceInterval(serv_int);
1141 v->SetServiceIntervalIsCustom(is_custom);
1142 v->SetServiceIntervalIsPercent(is_percent);
1144 }
1145
1146 return CommandCost();
1147}
Base for aircraft.
@ VAF_HELI_DIRECT_DESCENT
The helicopter is descending directly at its destination (helipad or in front of hangar)
Definition aircraft.h:45
void UpdateAircraftCache(Aircraft *v, bool update_range=false)
Update cached values of an aircraft.
CommandCost CmdBuildAircraft(DoCommandFlags flags, TileIndex tile, const Engine *e, Vehicle **ret)
Build an aircraft.
Command definitions related to aircraft.
Various declarations for airports.
@ STARTTAKEOFF
Airplane has arrived at a runway for take-off.
Definition airport.h:74
@ TERM7
Heading for terminal 7.
Definition airport.h:82
CargoArray GetCapacityOfArticulatedParts(EngineID engine)
Get the capacity of the parts of a given engine.
uint CountArticulatedParts(EngineID engine_type, bool purchase_window)
Count the number of articulated parts of an engine.
Functions related to articulated vehicles.
Command definitions related to autoreplace.
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.
debug_inline constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
debug_inline static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
uint8_t CargoType
Cargo slots to indicate a cargo type within a game.
Definition cargo_type.h:23
bool IsValidCargoType(CargoType cargo)
Test whether cargo type is not INVALID_CARGO.
Definition cargo_type.h:106
static const CargoType NUM_CARGO
Maximum number of cargo types in a game.
Definition cargo_type.h:75
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 & Flip(Tvalue_type value)
Flip the value-th bit.
constexpr Timpl & Set()
Set all bits.
Common return value for all commands.
bool Succeeded() const
Did this command succeed?
void AddCost(const Money &cost)
Adds the given cost to the cost of the command.
Money GetCost() const
The costs as made up to this moment.
bool Failed() const
Did this command fail?
Enum-as-bit-set wrapper.
uint Truncate(uint max_move=UINT_MAX)
Truncates the cargo in this list to the given amount.
uint TotalCount() const
Returns sum of cargo, including reserved cargo.
Functions related to commands.
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
@ Execute
execute the given command
@ QueryCost
query cost only, don't build.
@ AutoReplace
autoreplace/autorenew is in progress, this shall disable vehicle limits when building,...
Definition of stuff that is very close to a company, like the company struct itself.
int CompanyServiceInterval(const Company *c, VehicleType type)
Get the service interval for the given company and vehicle type.
bool CheckCompanyHasMoney(CommandCost &cost)
Verify whether the company can pay the bill.
CommandCost CheckOwnership(Owner owner, TileIndex tile)
Check whether the current owner owns something.
CompanyID _current_company
Company currently doing an action.
Functions related to companies.
bool IsLocalCompany()
Is the current company the local company?
Map related accessors for depots.
bool IsDepotTile(Tile tile)
Is the given tile a tile with a depot on it?
Definition depot_map.h:42
VehicleType GetDepotVehicleType(Tile t)
Get the type of vehicles that can use a depot.
Definition depot_map.h:78
bool do_start
flag for starting playback of next_file at next opportunity
Definition dmusic.cpp:122
Money GetPrice(Price index, uint cost_factor, const GRFFile *grf_file, int shift)
Determine a certain price.
Definition economy.cpp:952
ExpensesType
Types of expenses.
@ EXPENSES_ROADVEH_RUN
Running costs road vehicles.
@ EXPENSES_TRAIN_RUN
Running costs trains.
@ EXPENSES_AIRCRAFT_RUN
Running costs aircraft.
@ EXPENSES_SHIP_RUN
Running costs ships.
@ EXPENSES_NEW_VEHICLES
New vehicles.
Price
Enumeration of all base prices for use with Prices.
bool IsEngineBuildable(EngineID engine, VehicleType type, CompanyID company)
Check if an engine is buildable.
Definition engine.cpp:1246
Functions related to engines.
@ AIR_CTOL
Conventional Take Off and Landing, i.e. planes.
@ AutoRefit
Automatic refitting is allowed.
@ RAILVEH_WAGON
simple wagon, not motorized
Definition engine_type.h:34
@ RAILVEH_MULTIHEAD
indicates a combination of two locomotives
Definition engine_type.h:33
Base class for groups and group functions.
Command definitions related to engine groups.
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition gfx.cpp:1535
virtual void MarkDirty()
Marks the vehicles to be redrawn and updates cached variables.
ClientID
'Unique' identifier to be given to clients
@ INVALID_CLIENT_ID
Client is not part of anything.
Base for the NewGRF implementation.
@ CBID_VEHICLE_REFIT_COST
Called to determine the cost factor for refitting a vehicle.
@ CBID_VEHICLE_START_STOP_CHECK
Called when the company (or AI) tries to start or stop a vehicle.
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
std::optional< bool > TestVehicleBuildProbability(Vehicle *v, EngineID engine, BuildProbabilityType type)
Test for vehicle build probablity type.
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.
StringID GetGRFStringID(uint32_t grfid, GRFStringID stringid)
Returns the index for this stringid associated with its grfID.
Header of Action 04 "universal holder" structure and functions.
static constexpr GRFStringID GRFSTR_MISC_GRF_TEXT
Miscellaneous GRF text range.
Functions related to news.
void DeleteVehicleNews(VehicleID vid, AdviceType advice_type=AdviceType::Invalid)
Delete news with a given advice type about a vehicle.
@ VehicleWaiting
The vehicle is waiting in the depot.
Functions related to order backups.
uint16_t GetServiceIntervalClamped(int interval, bool ispercent)
Clamp the service interval to the correct min/max.
Command definitions related to orders.
Pseudo random number generator.
void SaveRandomSeeds(SavedRandomSeeds *storage)
Saves the current seeds.
void RestoreRandomSeeds(const SavedRandomSeeds &storage)
Restores previously saved seeds.
Road vehicle states.
void RoadVehUpdateCache(RoadVehicle *v, bool same_length=false)
Update the cache of a road vehicle.
CommandCost CmdBuildRoadVehicle(DoCommandFlags flags, TileIndex tile, const Engine *e, Vehicle **ret)
Build a road vehicle.
Command definitions related to road vehicles.
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
Base for ships.
CommandCost CmdBuildShip(DoCommandFlags flags, TileIndex tile, const Engine *e, Vehicle **ret)
Build a ship.
Definition ship_cmd.cpp:888
Command definitions related to ships.
Definition of base types and functions in a cross-platform compatible way.
size_t Utf8StringLength(std::string_view str)
Get the length of an UTF-8 encoded string in number of characters and thus not the number of bytes th...
Definition string.cpp:347
Functions related to low-level strings.
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
uint8_t subtype
Type of aircraft.
Aircraft, helicopters, rotors and their shadows belong to this class.
Definition aircraft.h:72
uint8_t state
State of the airport.
Definition aircraft.h:77
uint8_t flags
Aircraft flags.
Definition aircraft.h:81
std::string name
Name of vehicle.
uint16_t service_interval
The interval for (automatic) servicing; either in days or %.
void ResetDepotUnbunching()
Resets all the data used for depot unbunching.
VehicleType type
Type of vehicle.
Class for storing amounts of cargo.
Definition cargo_type.h:113
Specification of a cargo type.
Definition cargotype.h:74
CargoClasses classes
Classes of this cargo type.
Definition cargotype.h:81
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo type.
Definition cargotype.h:137
CompanySettings settings
settings specific for each company
VehicleDefaultSettings vehicle
default settings for vehicles
EngineMiscFlags misc_flags
Miscellaneous flags.
Money GetCost() const
Return how much a new engine costs.
Definition engine.cpp:318
const GRFFile * GetGRF() const
Retrieve the NewGRF the engine is tied to.
uint DetermineCapacity(const Vehicle *v, uint16_t *mail_capacity=nullptr) const
Determines capacity of a given vehicle from scratch.
Definition engine.cpp:201
VehicleType type
Vehicle type, ie VEH_ROAD, VEH_TRAIN, etc.
Definition engine_base.h:61
uint GetDisplayDefaultCapacity(uint16_t *mail_capacity=nullptr) const
Determines the default cargo capacity of an engine for display purposes.
CargoType GetDefaultCargoType() const
Determines the default cargo type of an engine.
Definition engine_base.h:96
bool CanCarryCargo() const
Determines whether an engine can carry something.
Definition engine.cpp:168
std::array< uint8_t, NUM_CARGO > cargo_map
Inverse cargo translation table (CargoType -> local ID)
Definition newgrf.h:137
VehicleSettings vehicle
options for vehicles
static void CountVehicle(const Vehicle *v, int delta)
Update num_vehicle when adding or removing a vehicle.
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 Restore(Vehicle *v, uint32_t user)
Restore the data of this order to the given vehicle.
static void Backup(const Vehicle *v, uint32_t user)
Create an order backup for the given vehicle.
bool IsShared() const
Is this a shared order list?
Definition order_base.h:381
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition order_base.h:66
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
static Titem * Get(auto index)
Returns Titem with given index.
Tindex index
Index of this pool item.
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
static Titem * GetIfValid(auto index)
Returns Titem with given index.
Helper structure for RefitVehicle()
uint capacity
New capacity of vehicle.
Vehicle * v
Vehicle to refit.
uint mail_capacity
New mail capacity of aircraft.
uint8_t subtype
cargo subtype to refit to
Stores the state of all random number generators.
void UpdateCache()
Update the caches of this ship.
Definition ship_cmd.cpp:232
static T * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
bool servint_ispercent
service intervals are in percents
The information about a vehicle list.
Definition vehiclelist.h:32
VehicleType vtype
The vehicle type associated with this list.
Definition vehiclelist.h:34
uint8_t roadveh_acceleration_model
realistic acceleration for road vehicles
Vehicle data structure.
EngineID engine_type
The type of engine used for this vehicle.
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
Definition vehicle.cpp:718
bool IsStoppedInDepot() const
Check whether the vehicle is in the depot and stopped.
virtual ExpensesType GetExpenseType(bool income) const
Sets the expense type associated to this vehicle type.
Vehicle * GetNextArticulatedPart() const
Get the next part of an articulated engine.
VehicleCargoList cargo
The cargo this vehicle is carrying.
uint16_t cargo_cap
total capacity
CommandCost SendToDepot(DoCommandFlags flags, DepotCommandFlags command)
Send this vehicle to the depot using the given command(s).
Definition vehicle.cpp:2544
bool HasArticulatedPart() const
Check if an engine has an articulated part.
Vehicle * GetNextVehicle() const
Get the next real (non-articulated part) vehicle in the consist.
GroupID group_id
Index of group Pool array.
VehStates vehstatus
Status.
bool IsArticulatedPart() const
Check if the vehicle is an articulated part of an engine.
CargoType cargo_type
type of cargo this vehicle is carrying
debug_inline bool IsFrontEngine() const
Check if the vehicle is a front engine.
Vehicle * First() const
Get the first vehicle of this vehicle chain.
Order current_order
The current order (+ status, like: loading)
Vehicle * Next() const
Get the next vehicle of this vehicle.
const GRFFile * GetGRF() const
Retrieve the NewGRF the vehicle is tied to.
Definition vehicle.cpp:728
OrderList * orders
Pointer to the order list for this vehicle.
Money value
Value of the vehicle.
uint16_t refit_cap
Capacity left over from before last refit.
uint32_t GetGRFID() const
Retrieve the GRF ID of the NewGRF the vehicle is tied to.
Definition vehicle.cpp:738
virtual bool IsPrimaryVehicle() const
Whether this is the primary vehicle in the chain.
uint16_t cur_speed
current speed
uint8_t cargo_subtype
Used for livery refits (NewGRF variations)
debug_inline bool IsGroundVehicle() const
Check if the vehicle is a ground vehicle.
TileIndex tile
Current tile index.
void InvalidateNewGRFCacheOfChain()
Invalidates cached NewGRF variables of all vehicles in the chain (after the current vehicle)
Owner owner
Which company owns the vehicle?
UnitID unitnumber
unit number, for display purposes only
bool IsTileOwner(Tile tile, Owner owner)
Checks if a tile belongs to the given owner.
Definition tile_map.h:214
Base for the train class.
void NormalizeTrainVehInDepot(const Train *u)
Move all free vehicles in the depot to the train.
@ Flipped
Reverse the visible direction of the vehicle.
Definition train.h:28
static constexpr ConsistChangeFlags CCF_REFIT
Valid changes for refitting in a depot.
Definition train.h:55
static constexpr ConsistChangeFlags CCF_AUTOREFIT
Valid changes for autorefitting in stations.
Definition train.h:54
CommandCost CmdBuildRailVehicle(DoCommandFlags flags, TileIndex tile, const Engine *e, Vehicle **ret)
Build a railroad vehicle.
CommandCost CmdSellRailWagon(DoCommandFlags flags, Vehicle *t, bool sell_chain, bool backup_order, ClientID user)
Sell a (single) train wagon/engine.
Command definitions related to trains.
uint16_t UnitID
Type for the company global vehicle unit number.
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:3179
UnitID GetFreeUnitNumber(VehicleType type)
Get an unused unit number for a vehicle (if allowed).
Definition vehicle.cpp:1865
@ Crashed
Vehicle is crashed.
@ Stopped
Vehicle is stopped by the player.
CommandCost CmdMassStartStopVehicle(DoCommandFlags flags, TileIndex tile, bool do_start, bool vehicle_list_window, const VehicleListIdentifier &vli)
Starts or stops a lot of vehicles.
static void CloneVehicleName(const Vehicle *src, Vehicle *dst)
Clone the custom name of a vehicle, adding or incrementing a number.
bool IsUniqueVehicleName(const std::string &name)
Test if a name is unique among vehicle names.
CommandCost CmdDepotSellAllVehicles(DoCommandFlags flags, TileIndex tile, VehicleType vehicle_type)
Sells all vehicles in a depot.
std::tuple< CommandCost, VehicleID > CmdCloneVehicle(DoCommandFlags flags, TileIndex tile, VehicleID veh_id, bool share_orders)
Clone a vehicle.
CommandCost CmdChangeServiceInt(DoCommandFlags flags, VehicleID veh_id, uint16_t serv_int, bool is_custom, bool is_percent)
Change the service interval of a vehicle.
static CommandCost GetRefitCost(const Vehicle *v, EngineID engine_type, CargoType new_cargo_type, uint8_t new_subtype, bool *auto_refit_allowed)
Learn the price of refitting a certain engine.
static int GetRefitCostFactor(const Vehicle *v, EngineID engine_type, CargoType new_cargo_type, uint8_t new_subtype, bool *auto_refit_allowed)
Helper to run the refit cost callback.
CommandCost CmdSellVehicle(DoCommandFlags flags, VehicleID v_id, bool sell_chain, bool backup_order, ClientID client_id)
Sell a vehicle.
static std::tuple< CommandCost, uint, uint16_t, CargoArray > RefitVehicle(Vehicle *v, bool only_this, uint8_t num_vehicles, CargoType new_cargo_type, uint8_t new_subtype, DoCommandFlags flags, bool auto_refit)
Refits a vehicle (chain).
CommandCost CmdSendVehicleToDepot(DoCommandFlags flags, VehicleID veh_id, DepotCommandFlags depot_cmd, const VehicleListIdentifier &vli)
Send a vehicle to the depot.
static CommandCost SendAllVehiclesToDepot(DoCommandFlags flags, bool service, const VehicleListIdentifier &vli)
Send all vehicles of type to depots.
std::tuple< CommandCost, uint, uint16_t, CargoArray > CmdRefitVehicle(DoCommandFlags flags, VehicleID veh_id, CargoType new_cargo_type, uint8_t new_subtype, bool auto_refit, bool only_this, uint8_t num_vehicles)
Refits a vehicle to the specified cargo type.
CommandCost CmdRenameVehicle(DoCommandFlags flags, VehicleID veh_id, const std::string &text)
Give a custom name to your vehicle.
CommandCost CmdStartStopVehicle(DoCommandFlags flags, VehicleID veh_id, bool evaluate_startstop_cb)
Start/Stop a vehicle.
CommandCost CmdDepotMassAutoReplace(DoCommandFlags flags, TileIndex tile, VehicleType vehicle_type)
Autoreplace all vehicles in the depot.
std::tuple< CommandCost, VehicleID, uint, uint16_t, CargoArray > CmdBuildVehicle(DoCommandFlags flags, TileIndex tile, EngineID eid, bool use_free_vehicles, CargoType cargo, ClientID client_id)
Build a vehicle.
Command definitions for vehicles.
Functions related to vehicles.
uint8_t GetBestFittingSubType(Vehicle *v_from, Vehicle *v_for, CargoType dest_cargo_type)
Get the best fitting subtype when 'cloning'/'replacing' v_from with v_for.
bool IsCompanyBuildableVehicleType(VehicleType type)
Is the given vehicle type buildable by a company?
WindowClass GetWindowClassForVehicleType(VehicleType vt)
Get WindowClass for vehicle list of given vehicle type.
Definition vehicle_gui.h:97
VehicleType
Available vehicle types.
@ VEH_ROAD
Road vehicle type.
@ VEH_AIRCRAFT
Aircraft vehicle type.
@ VEH_SHIP
Ship vehicle type.
@ VEH_TRAIN
Train vehicle type.
@ MassSend
Tells that it's a mass send to depot command (type in VLW flag)
@ DontCancel
Don't cancel current goto depot command if any.
@ Service
The vehicle will leave the depot right after arrival (service only)
static const uint MAX_LENGTH_VEHICLE_NAME_CHARS
The maximum length of a vehicle name in characters including '\0'.
@ WID_VV_START_STOP
Start or stop this vehicle, and show information about the current state.
bool GenerateVehicleSortList(VehicleList *list, const VehicleListIdentifier &vli)
Generate a list of vehicles based on window type.
void BuildDepotVehicleList(VehicleType type, TileIndex tile, VehicleList *engines, VehicleList *wagons, bool individual_wagons)
Generate a list of vehicles inside a depot.
Functions and type for generating vehicle lists.
std::vector< const Vehicle * > VehicleList
A list of vehicles.
Definition vehiclelist.h:68
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition window.cpp:3173
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:3265
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:3160
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition window.cpp:3147
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:3282
@ WC_VEHICLE_DEPOT
Depot view; Window numbers:
@ WC_VEHICLE_DETAILS
Vehicle details; Window numbers:
@ WC_COMPANY
Company view; Window numbers:
@ WC_VEHICLE_VIEW
Vehicle view; Window numbers: