OpenTTD Source  20241124-master-g9399a92a4f
train_gui.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 "window_gui.h"
12 #include "command_func.h"
13 #include "train.h"
14 #include "strings_func.h"
15 #include "vehicle_func.h"
16 #include "zoom_func.h"
17 #include "train_cmd.h"
18 
19 #include "table/strings.h"
20 
21 #include "safeguards.h"
22 
29 void CcBuildWagon(Commands, const CommandCost &result, VehicleID new_veh_id, uint, uint16_t, CargoArray, TileIndex tile, EngineID, bool, CargoID, ClientID)
30 {
31  if (result.Failed()) return;
32 
33  /* find a locomotive in the depot. */
34  const Vehicle *found = nullptr;
35  for (const Train *t : Train::Iterate()) {
36  if (t->IsFrontEngine() && t->tile == tile && t->IsStoppedInDepot()) {
37  if (found != nullptr) return; // must be exactly one.
38  found = t;
39  }
40  }
41 
42  /* if we found a loco, */
43  if (found != nullptr) {
44  found = found->Last();
45  /* put the new wagon at the end of the loco. */
46  Command<CMD_MOVE_RAIL_VEHICLE>::Post(found->tile, new_veh_id, found->index, false);
48  }
49 }
50 
60 static int HighlightDragPosition(int px, int max_width, int y, VehicleID selection, bool chain)
61 {
62  bool rtl = _current_text_dir == TD_RTL;
63 
64  assert(selection != INVALID_VEHICLE);
65  int dragged_width = 0;
66  for (Train *t = Train::Get(selection); t != nullptr; t = chain ? t->Next() : (t->HasArticulatedPart() ? t->GetNextArticulatedPart() : nullptr)) {
67  dragged_width += t->GetDisplayImageWidth(nullptr);
68  }
69 
70  int drag_hlight_left = rtl ? std::max(px - dragged_width + 1, 0) : px;
71  int drag_hlight_right = rtl ? px : std::min(px + dragged_width, max_width) - 1;
72  int drag_hlight_width = std::max(drag_hlight_right - drag_hlight_left + 1, 0);
73 
74  if (drag_hlight_width > 0) {
75  int height = ScaleSpriteTrad(12);
76  int top = y - height / 2;
77  Rect r = {drag_hlight_left, top, drag_hlight_right, top + height - 1};
78  /* Sprite-scaling is used here as the area is from sprite size */
79  GfxFillRect(r.Shrink(ScaleSpriteTrad(1)), GetColourGradient(COLOUR_GREY, SHADE_LIGHTEST));
80  }
81 
82  return drag_hlight_width;
83 }
84 
93 void DrawTrainImage(const Train *v, const Rect &r, VehicleID selection, EngineImageType image_type, int skip, VehicleID drag_dest)
94 {
95  bool rtl = _current_text_dir == TD_RTL;
96  Direction dir = rtl ? DIR_E : DIR_W;
97 
98  DrawPixelInfo tmp_dpi;
99  /* Position of highlight box */
100  int highlight_l = 0;
101  int highlight_r = 0;
102  int max_width = r.Width();
103 
104  if (!FillDrawPixelInfo(&tmp_dpi, r)) return;
105 
106  {
107  AutoRestoreBackup dpi_backup(_cur_dpi, &tmp_dpi);
108 
109  bool do_overlays = ShowCargoIconOverlay();
110  /* List of overlays, only used if cargo icon overlays are enabled. */
111  static std::vector<CargoIconOverlay> overlays;
112 
113  int px = rtl ? max_width + skip : -skip;
114  int y = r.Height() / 2;
115  bool sel_articulated = false;
116  bool dragging = (drag_dest != INVALID_VEHICLE);
117  bool drag_at_end_of_train = (drag_dest == v->index); // Head index is used to mark dragging at end of train.
118  for (; v != nullptr && (rtl ? px > 0 : px < max_width); v = v->Next()) {
119  if (dragging && !drag_at_end_of_train && drag_dest == v->index) {
120  /* Highlight the drag-and-drop destination inside the train. */
121  int drag_hlight_width = HighlightDragPosition(px, max_width, y, selection, _cursor.vehchain);
122  px += rtl ? -drag_hlight_width : drag_hlight_width;
123  }
124 
125  Point offset;
126  int width = Train::From(v)->GetDisplayImageWidth(&offset);
127 
128  if (rtl ? px + width > 0 : px - width < max_width) {
130  VehicleSpriteSeq seq;
131  v->GetImage(dir, image_type, &seq);
132  seq.Draw(px + (rtl ? -offset.x : offset.x), y + offset.y, pal, (v->vehstatus & VS_CRASHED) != 0);
133  }
134 
135  if (!v->IsArticulatedPart()) sel_articulated = false;
136 
137  if (v->index == selection) {
138  /* Set the highlight position */
139  highlight_l = rtl ? px - width : px;
140  highlight_r = rtl ? px - 1 : px + width - 1;
141  sel_articulated = true;
142  } else if ((_cursor.vehchain && highlight_r != 0) || sel_articulated) {
143  if (rtl) {
144  highlight_l -= width;
145  } else {
146  highlight_r += width;
147  }
148  }
149 
150  if (do_overlays) AddCargoIconOverlay(overlays, px, width, v);
151  px += rtl ? -width : width;
152  }
153 
154  if (do_overlays) {
155  DrawCargoIconOverlays(overlays, y);
156  overlays.clear();
157  }
158 
159  if (dragging && drag_at_end_of_train) {
160  /* Highlight the drag-and-drop destination at the end of the train. */
161  HighlightDragPosition(px, max_width, y, selection, _cursor.vehchain);
162  }
163  }
164 
165  if (highlight_l != highlight_r) {
166  /* Draw the highlight. Now done after drawing all the engines, as
167  * the next engine after the highlight could overlap it. */
168  int height = ScaleSpriteTrad(12);
169  Rect hr = {highlight_l, 0, highlight_r, height - 1};
170  DrawFrameRect(hr.Translate(r.left, CenterBounds(r.top, r.bottom, height)).Expand(WidgetDimensions::scaled.bevel), COLOUR_WHITE, FR_BORDERONLY);
171  }
172 }
173 
178  uint capacity;
179  uint amount;
180  StationID source;
181 
183  inline bool operator != (const CargoSummaryItem &other) const
184  {
185  return this->cargo != other.cargo || this->subtype != other.subtype;
186  }
187 
189  inline bool operator == (const CargoSummaryItem &other) const
190  {
191  return !(this->cargo != other.cargo);
192  }
193 };
194 
195 static const uint TRAIN_DETAILS_MIN_INDENT = 32;
196 static const uint TRAIN_DETAILS_MAX_INDENT = 72;
197 
199 typedef std::vector<CargoSummaryItem> CargoSummary;
202 
211 static void TrainDetailsCargoTab(const CargoSummaryItem *item, int left, int right, int y)
212 {
213  StringID str;
214  if (item->amount > 0) {
215  SetDParam(0, item->cargo);
216  SetDParam(1, item->amount);
217  SetDParam(2, item->source);
219  str = FreightWagonMult(item->cargo) > 1 ? STR_VEHICLE_DETAILS_CARGO_FROM_MULT : STR_VEHICLE_DETAILS_CARGO_FROM;
220  } else {
221  str = !IsValidCargoID(item->cargo) ? STR_QUANTITY_N_A : STR_VEHICLE_DETAILS_CARGO_EMPTY;
222  }
223 
224  DrawString(left, right, y, str, TC_LIGHT_BLUE);
225 }
226 
235 static void TrainDetailsInfoTab(const Vehicle *v, int left, int right, int y)
236 {
237  if (RailVehInfo(v->engine_type)->railveh_type == RAILVEH_WAGON) {
239  SetDParam(1, v->value);
240  DrawString(left, right, y, STR_VEHICLE_DETAILS_TRAIN_WAGON_VALUE);
241  } else {
243  SetDParam(1, v->build_year);
244  SetDParam(2, v->value);
245  DrawString(left, right, y, STR_VEHICLE_DETAILS_TRAIN_ENGINE_BUILT_AND_VALUE);
246  }
247 }
248 
257 static void TrainDetailsCapacityTab(const CargoSummaryItem *item, int left, int right, int y)
258 {
259  StringID str;
260  if (IsValidCargoID(item->cargo)) {
261  SetDParam(0, item->cargo);
262  SetDParam(1, item->capacity);
263  SetDParam(4, item->subtype);
265  str = FreightWagonMult(item->cargo) > 1 ? STR_VEHICLE_INFO_CAPACITY_MULT : STR_VEHICLE_INFO_CAPACITY;
266  } else {
267  /* Draw subtype only */
268  SetDParam(0, item->subtype);
269  str = STR_VEHICLE_INFO_NO_CAPACITY;
270  }
271  DrawString(left, right, y, str);
272 }
273 
280 {
281  summary.clear();
282  do {
283  if (!v->GetEngine()->CanCarryCargo()) continue;
284 
285  CargoSummaryItem new_item;
286  new_item.cargo = v->cargo_cap > 0 ? v->cargo_type : INVALID_CARGO;
287  new_item.subtype = GetCargoSubtypeText(v);
288  if (!IsValidCargoID(new_item.cargo) && new_item.subtype == STR_EMPTY) continue;
289 
290  auto item = std::find(std::begin(summary), std::end(summary), new_item);
291  if (item == std::end(summary)) {
292  item = summary.emplace(std::end(summary));
293  item->cargo = new_item.cargo;
294  item->subtype = new_item.subtype;
295  item->capacity = 0;
296  item->amount = 0;
297  item->source = INVALID_STATION;
298  }
299 
300  item->capacity += v->cargo_cap;
301  item->amount += v->cargo.StoredCount();
302  if (item->source == INVALID_STATION) item->source = v->cargo.GetFirstStation();
303  } while ((v = v->Next()) != nullptr && v->IsArticulatedPart());
304 }
305 
312 {
313  uint length = 0;
314 
315  do {
316  length += v->GetDisplayImageWidth();
317  } while ((v = v->Next()) != nullptr && v->IsArticulatedPart());
318 
319  return length;
320 }
321 
329 {
330  int num = 0;
331 
332  if (det_tab == TDW_TAB_TOTALS) { // Total cargo tab
333  CargoArray max_cargo{};
334  for (const Vehicle *v = Vehicle::Get(veh_id); v != nullptr; v = v->Next()) {
335  max_cargo[v->cargo_type] += v->cargo_cap;
336  }
337 
338  num = max_cargo.GetCount();
339  num++; // needs one more because first line is description string
340  } else {
341  for (const Train *v = Train::Get(veh_id); v != nullptr; v = v->GetNextVehicle()) {
343  num += std::max(1u, (unsigned)_cargo_summary.size());
344 
345  uint length = GetLengthOfArticulatedVehicle(v);
346  if (length > (uint)ScaleSpriteTrad(TRAIN_DETAILS_MAX_INDENT)) num++;
347  }
348  }
349 
350  return num;
351 }
352 
362 void DrawTrainDetails(const Train *v, const Rect &r, int vscroll_pos, uint16_t vscroll_cap, TrainDetailsWindowTabs det_tab)
363 {
364  bool rtl = _current_text_dir == TD_RTL;
365  int line_height = r.Height();
366  int sprite_y_offset = line_height / 2;
367  int text_y_offset = (line_height - GetCharacterHeight(FS_NORMAL)) / 2;
368 
369  /* draw the first 3 details tabs */
370  if (det_tab != TDW_TAB_TOTALS) {
371  Direction dir = rtl ? DIR_E : DIR_W;
372  int x = rtl ? r.right : r.left;
373  for (; v != nullptr && vscroll_pos > -vscroll_cap; v = v->GetNextVehicle()) {
375 
376  /* Draw sprites */
377  uint dx = 0;
378  int px = x;
379  const Train *u = v;
380  do {
381  Point offset;
382  int width = u->GetDisplayImageWidth(&offset);
383  if (vscroll_pos <= 0 && vscroll_pos > -vscroll_cap) {
384  int pitch = 0;
385  const Engine *e = Engine::Get(v->engine_type);
386  if (e->GetGRF() != nullptr) {
388  }
390  VehicleSpriteSeq seq;
391  u->GetImage(dir, EIT_IN_DETAILS, &seq);
392  seq.Draw(px + (rtl ? -offset.x : offset.x), r.top - line_height * vscroll_pos + sprite_y_offset + pitch, pal, (v->vehstatus & VS_CRASHED) != 0);
393  }
394  px += rtl ? -width : width;
395  dx += width;
396  u = u->Next();
397  } while (u != nullptr && u->IsArticulatedPart());
398 
399  bool separate_sprite_row = (dx > (uint)ScaleSpriteTrad(TRAIN_DETAILS_MAX_INDENT));
400  if (separate_sprite_row) {
401  vscroll_pos--;
402  dx = 0;
403  }
404 
405  int sprite_width = std::max<int>(dx, ScaleSpriteTrad(TRAIN_DETAILS_MIN_INDENT)) + WidgetDimensions::scaled.hsep_normal;
406  Rect dr = r.Indent(sprite_width, rtl);
407  uint num_lines = std::max(1u, (unsigned)_cargo_summary.size());
408  for (uint i = 0; i < num_lines; i++) {
409  if (vscroll_pos <= 0 && vscroll_pos > -vscroll_cap) {
410  int py = r.top - line_height * vscroll_pos + text_y_offset;
411  if (i > 0 || separate_sprite_row) {
412  if (vscroll_pos != 0) GfxFillRect(r.left, py - WidgetDimensions::scaled.matrix.top - 1, r.right, py - WidgetDimensions::scaled.matrix.top, GetColourGradient(COLOUR_GREY, SHADE_LIGHT));
413  }
414  switch (det_tab) {
415  case TDW_TAB_CARGO:
416  if (i < _cargo_summary.size()) {
417  TrainDetailsCargoTab(&_cargo_summary[i], dr.left, dr.right, py);
418  } else {
419  DrawString(dr.left, dr.right, py, STR_QUANTITY_N_A, TC_LIGHT_BLUE);
420  }
421  break;
422 
423  case TDW_TAB_INFO:
424  if (i == 0) TrainDetailsInfoTab(v, dr.left, dr.right, py);
425  break;
426 
427  case TDW_TAB_CAPACITY:
428  if (i < _cargo_summary.size()) {
429  TrainDetailsCapacityTab(&_cargo_summary[i], dr.left, dr.right, py);
430  } else {
431  SetDParam(0, STR_EMPTY);
432  DrawString(dr.left, dr.right, py, STR_VEHICLE_INFO_NO_CAPACITY);
433  }
434  break;
435 
436  default: NOT_REACHED();
437  }
438  }
439  vscroll_pos--;
440  }
441  }
442  } else {
443  int y = r.top;
444  CargoArray act_cargo{};
445  CargoArray max_cargo{};
446  Money feeder_share = 0;
447 
448  for (const Vehicle *u = v; u != nullptr; u = u->Next()) {
449  act_cargo[u->cargo_type] += u->cargo.StoredCount();
450  max_cargo[u->cargo_type] += u->cargo_cap;
451  feeder_share += u->cargo.GetFeederShare();
452  }
453 
454  /* draw total cargo tab */
455  DrawString(r.left, r.right, y + text_y_offset, STR_VEHICLE_DETAILS_TRAIN_TOTAL_CAPACITY_TEXT);
456  y += line_height;
457 
458  /* Indent the total cargo capacity details */
459  Rect ir = r.Indent(WidgetDimensions::scaled.hsep_indent, rtl);
460  for (const CargoSpec *cs : _sorted_cargo_specs) {
461  CargoID cid = cs->Index();
462  if (max_cargo[cid] > 0 && --vscroll_pos < 0 && vscroll_pos > -vscroll_cap) {
463  SetDParam(0, cid); // {CARGO} #1
464  SetDParam(1, act_cargo[cid]); // {CARGO} #2
465  SetDParam(2, cid); // {SHORTCARGO} #1
466  SetDParam(3, max_cargo[cid]); // {SHORTCARGO} #2
468  DrawString(ir.left, ir.right, y + text_y_offset, FreightWagonMult(cid) > 1 ? STR_VEHICLE_DETAILS_TRAIN_TOTAL_CAPACITY_MULT : STR_VEHICLE_DETAILS_TRAIN_TOTAL_CAPACITY);
469  y += line_height;
470  }
471  }
472  SetDParam(0, feeder_share);
473  DrawString(r.left, r.right, y + text_y_offset, STR_VEHICLE_INFO_FEEDER_CARGO_VALUE);
474  }
475 }
uint8_t CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:22
bool IsValidCargoID(CargoID t)
Test whether cargo type is not INVALID_CARGO.
Definition: cargo_type.h:107
std::vector< const CargoSpec * > _sorted_cargo_specs
Cargo specifications sorted alphabetically by name.
Definition: cargotype.cpp:183
Common return value for all commands.
Definition: command_type.h:23
bool Failed() const
Did this command fail?
Definition: command_type.h:171
StationID GetFirstStation() const
Returns the first station of the first cargo packet in this list.
Definition: cargopacket.h:405
uint StoredCount() const
Returns sum of cargo on board the vehicle (ie not only reserved).
Definition: cargopacket.h:434
static WidgetDimensions scaled
Widget dimensions scaled for current zoom level.
Definition: window_gui.h:68
RectPadding matrix
Padding of WWT_MATRIX items.
Definition: window_gui.h:44
int hsep_normal
Normal horizontal spacing.
Definition: window_gui.h:63
RectPadding bevel
Bevel thickness, affected by "scaled bevels" game option.
Definition: window_gui.h:40
Functions related to commands.
Commands
List of commands.
Definition: command_type.h:187
Direction
Defines the 8 directions on the map.
@ DIR_W
West.
@ DIR_E
East.
uint16_t EngineID
Unique identification number of an engine.
Definition: engine_type.h:21
uint64_t PackEngineNameDParam(EngineID engine_id, EngineNameContext context, uint32_t extra_data=0)
Combine an engine ID and a name context to an engine name dparam.
Definition: engine_type.h:203
@ VehicleDetails
Name is shown in the vehicle details GUI.
Definition: engine_type.h:196
@ RAILVEH_WAGON
simple wagon, not motorized
Definition: engine_type.h:29
int GetCharacterHeight(FontSize size)
Get height of a character for a given font size.
Definition: fontcache.cpp:77
int DrawString(int left, int right, int top, std::string_view str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
Draw string, possibly truncated to make it fit in its allocated space.
Definition: gfx.cpp:657
void GfxFillRect(int left, int top, int right, int bottom, int colour, FillRectMode mode)
Applies a certain FillRectMode-operation to a rectangle [left, right] x [top, bottom] on the screen.
Definition: gfx.cpp:114
bool FillDrawPixelInfo(DrawPixelInfo *n, int left, int top, int width, int height)
Set up a clipping area for only drawing into a certain area.
Definition: gfx.cpp:1548
int CenterBounds(int min, int max, int size)
Determine where to draw a centred object inside a widget.
Definition: gfx_func.h:166
@ FS_NORMAL
Index of the normal font in the font tables.
Definition: gfx_type.h:209
uint32_t PaletteID
The number of the palette.
Definition: gfx_type.h:19
ClientID
'Unique' identifier to be given to clients
Definition: network_type.h:49
uint8_t GetColourGradient(Colours colour, ColourShade shade)
Get colour gradient palette index.
Definition: palette.cpp:314
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:57
static const PaletteID PALETTE_CRASH
Recolour sprite greying of crashed vehicles.
Definition: sprites.h:1605
Definition of base types and functions in a cross-platform compatible way.
void SetDParam(size_t n, uint64_t v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings.cpp:104
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition: strings.cpp:56
Functions related to OTTD's strings.
@ TD_RTL
Text is written right-to-left by default.
Definition: strings_type.h:24
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
Class to backup a specific variable and restore it upon destruction of this object to prevent stack v...
Class for storing amounts of cargo.
Definition: cargo_type.h:114
uint GetCount() const
Get the amount of cargos that have an amount.
Definition: cargo_type.h:129
Specification of a cargo type.
Definition: cargotype.h:71
Helper struct for the cargo details information.
Definition: train_gui.cpp:175
StringID subtype
STR_EMPTY if none.
Definition: train_gui.cpp:177
bool operator==(const CargoSummaryItem &other) const
Used by std::find() and similar functions.
Definition: train_gui.cpp:189
uint amount
Amount that is carried.
Definition: train_gui.cpp:179
uint capacity
Amount that can be carried.
Definition: train_gui.cpp:178
StationID source
One of the source stations.
Definition: train_gui.cpp:180
bool operator!=(const CargoSummaryItem &other) const
Used by CargoSummary::Find() and similar functions.
Definition: train_gui.cpp:183
CargoID cargo
The cargo that is carried.
Definition: train_gui.cpp:176
bool vehchain
vehicle chain is dragged
Definition: gfx_type.h:150
Data about how and where to blit pixels.
Definition: gfx_type.h:157
const GRFFile * GetGRF() const
Retrieve the NewGRF the engine is tied to.
Definition: engine_base.h:171
bool CanCarryCargo() const
Determines whether an engine can carry something.
Definition: engine.cpp:168
int traininfo_vehicle_pitch
Vertical offset for drawing train images in depot GUI and vehicle details.
Definition: newgrf.h:146
VehicleSettings vehicle
options for vehicles
Coordinates of a point in 2D.
Tindex index
Index of this pool item.
Definition: pool_type.hpp:238
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:339
Specification of a rectangle with absolute coordinates of all edges.
int Width() const
Get width of Rect.
Rect Shrink(int s) const
Copy and shrink Rect by s pixels.
Rect Indent(int indent, bool end) const
Copy Rect and indent it from its position.
int Height() const
Get height of Rect.
Rect Translate(int x, int y) const
Copy and translate Rect by x,y pixels.
Rect Expand(int s) const
Copy and expand Rect by s pixels.
static T * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
T * GetNextVehicle() const
Get the next real (non-articulated part) vehicle in the consist.
T * Next() const
Get next vehicle in the chain.
static Pool::IterateWrapper< T > Iterate(size_t from=0)
Returns an iterable ensemble of all valid vehicles of type T.
static T * Get(size_t index)
Gets vehicle with given index.
'Train' is either a loco or a wagon.
Definition: train.h:89
void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const override
Get the sprite to display the train.
Definition: train_cmd.cpp:494
int GetDisplayImageWidth(Point *offset=nullptr) const
Get the width of a train vehicle image in the GUI.
Definition: train_cmd.cpp:460
uint8_t freight_trains
value to multiply the weight of cargo by
Sprite sequence for a vehicle part.
Definition: vehicle_base.h:135
void Draw(int x, int y, PaletteID default_pal, bool force_pal) const
Draw the sprite sequence.
Definition: vehicle.cpp:131
Vehicle data structure.
Definition: vehicle_base.h:244
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:323
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
Definition: vehicle.cpp:747
VehicleCargoList cargo
The cargo this vehicle is carrying.
Definition: vehicle_base.h:341
uint16_t cargo_cap
total capacity
Definition: vehicle_base.h:344
bool IsArticulatedPart() const
Check if the vehicle is an articulated part of an engine.
Definition: vehicle_base.h:954
Vehicle * Last()
Get the last vehicle of this vehicle chain.
Definition: vehicle_base.h:651
CargoID cargo_type
type of cargo this vehicle is carrying
Definition: vehicle_base.h:342
Money value
Value of the vehicle.
Definition: vehicle_base.h:275
uint8_t vehstatus
Status.
Definition: vehicle_base.h:354
TileIndex tile
Current tile index.
Definition: vehicle_base.h:264
TimerGameCalendar::Year build_year
Year the vehicle has been built.
Definition: vehicle_base.h:291
Base for the train class.
uint8_t FreightWagonMult(CargoID cargo)
Return the cargo weight multiplier to use for a rail vehicle.
Definition: train_cmd.cpp:69
Command definitions related to trains.
void DrawTrainImage(const Train *v, const Rect &r, VehicleID selection, EngineImageType image_type, int skip, VehicleID drag_dest)
Draws an image of a whole train.
Definition: train_gui.cpp:93
void CcBuildWagon(Commands, const CommandCost &result, VehicleID new_veh_id, uint, uint16_t, CargoArray, TileIndex tile, EngineID, bool, CargoID, ClientID)
Callback for building wagons.
Definition: train_gui.cpp:29
static int HighlightDragPosition(int px, int max_width, int y, VehicleID selection, bool chain)
Highlight the position where a rail vehicle is dragged over by drawing a light gray background.
Definition: train_gui.cpp:60
static void TrainDetailsInfoTab(const Vehicle *v, int left, int right, int y)
Draw the details info tab for the given vehicle at the given position.
Definition: train_gui.cpp:235
static void TrainDetailsCapacityTab(const CargoSummaryItem *item, int left, int right, int y)
Draw the details capacity tab for the given vehicle at the given position.
Definition: train_gui.cpp:257
static uint GetLengthOfArticulatedVehicle(const Train *v)
Get the length of an articulated vehicle.
Definition: train_gui.cpp:311
void DrawTrainDetails(const Train *v, const Rect &r, int vscroll_pos, uint16_t vscroll_cap, TrainDetailsWindowTabs det_tab)
Draw the details for the given vehicle at the given position.
Definition: train_gui.cpp:362
static void GetCargoSummaryOfArticulatedVehicle(const Train *v, CargoSummary &summary)
Collects the cargo transported.
Definition: train_gui.cpp:279
static const uint TRAIN_DETAILS_MAX_INDENT
Maximum indent level in the train details window; wider than this and we start on a new line.
Definition: train_gui.cpp:196
std::vector< CargoSummaryItem > CargoSummary
Container for the cargo summary information.
Definition: train_gui.cpp:199
int GetTrainDetailsWndVScroll(VehicleID veh_id, TrainDetailsWindowTabs det_tab)
Determines the number of lines in the train details window.
Definition: train_gui.cpp:328
static CargoSummary _cargo_summary
Reused container of cargo details.
Definition: train_gui.cpp:201
static const uint TRAIN_DETAILS_MIN_INDENT
Minimum indent level in the train details window.
Definition: train_gui.cpp:195
static void TrainDetailsCargoTab(const CargoSummaryItem *item, int left, int right, int y)
Draw the details cargo tab for the given vehicle at the given position.
Definition: train_gui.cpp:211
PaletteID GetVehiclePalette(const Vehicle *v)
Get the colour map for a vehicle.
Definition: vehicle.cpp:2152
@ VS_CRASHED
Vehicle is crashed.
Definition: vehicle_base.h:40
Functions related to vehicles.
StringID GetCargoSubtypeText(const Vehicle *v)
Get the cargo subtype text from NewGRF for the vehicle details window.
void DrawCargoIconOverlays(std::span< const CargoIconOverlay > overlays, int y)
Draw a list of cargo icon overlays.
void AddCargoIconOverlay(std::vector< CargoIconOverlay > &overlays, int x, int width, const Vehicle *v)
Add a cargo icon to the list of overlays.
bool ShowCargoIconOverlay()
Test if cargo icon overlays should be drawn.
TrainDetailsWindowTabs
The tabs in the train details window.
Definition: vehicle_gui.h:25
@ TDW_TAB_CAPACITY
Tab with cargo capacity of the vehicles.
Definition: vehicle_gui.h:28
@ TDW_TAB_TOTALS
Tab with sum of total cargo transported.
Definition: vehicle_gui.h:29
@ TDW_TAB_INFO
Tab with name and value of the vehicles.
Definition: vehicle_gui.h:27
@ TDW_TAB_CARGO
Tab with cargo carried by the vehicles.
Definition: vehicle_gui.h:26
EngineImageType
Visualisation contexts of vehicles and engines.
Definition: vehicle_type.h:78
@ EIT_IN_DETAILS
Vehicle drawn in vehicle details, refit window, ...
Definition: vehicle_type.h:81
uint32_t VehicleID
The type all our vehicle IDs have.
Definition: vehicle_type.h:16
static const VehicleID INVALID_VEHICLE
Constant representing a non-existing vehicle.
Definition: vehicle_type.h:54
void DrawFrameRect(int left, int top, int right, int bottom, Colours colour, FrameFlags flags)
Draw frame rectangle.
Definition: widget.cpp:281
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:3228
Functions, definitions and such used only by the GUI.
@ FR_BORDERONLY
Draw border only, no background.
Definition: window_gui.h:27
@ WC_TRAINS_LIST
Trains list; Window numbers:
Definition: window_type.h:308
Functions related to zooming.
int ScaleSpriteTrad(int value)
Scale traditional pixel dimensions to GUI zoom level, for drawing sprites.
Definition: zoom_func.h:107