OpenTTD: src/train_gui.cpp Source File

OpenTTD

- Main Page
- Related Pages
- Modules
- Namespaces
- Data Structures
- Files

- File List
- Globals

train_gui.cpp
Go to the documentation of this file.
1 /* $Id: train_gui.cpp 27629 2016-08-15 18:33:29Z frosch $ */
2
3 /*
4 * This file is part of OpenTTD.
5 * 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.
6 * 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.
7 * 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/>.
8 */
9
12 #include "stdafx.h"
13 #include "window_gui.h"
14 #include "command_func.h"
15 #include "train.h"
16 #include "strings_func.h"
17 #include "vehicle_func.h"
18 #include "zoom_func.h"
19
20 #include "table/strings.h"
21
22 #include "safeguards.h"
23
31 void CcBuildWagon(const CommandCost &result, TileIndex tile, uint32 p1, uint32 p2)
32 {
33 if (result.Failed()) return;
34
35 /* find a locomotive in the depot. */
36 const Vehicle *found = NULL;
37 const Train *t;
38 FOR_ALL_TRAINS(t) {
39 if (t->IsFrontEngine() && t->tile == tile && t->IsStoppedInDepot()) {
40 if (found != NULL) return; // must be exactly one.
41 found = t;
42 }
43 }
44
45 /* if we found a loco, */
46 if (found != NULL) {
47 found = found->Last();
48 /* put the new wagon at the end of the loco. */
49 DoCommandP(0, _new_vehicle_id, found->index, CMD_MOVE_RAIL_VEHICLE);
50 InvalidateWindowClassesData(WC_TRAINS_LIST, 0);
51 }
52 }
53
62 static int HighlightDragPosition(int px, int max_width, VehicleID selection, bool chain)
63 {
64 bool rtl = _current_text_dir == TD_RTL;
65
66 assert(selection != INVALID_VEHICLE);
67 int dragged_width = WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT;
68 for (Train *t = Train::Get(selection); t != NULL; t = chain ? t->Next() : (t->HasArticulatedPart() ? t->GetNextArticulatedPart() : NULL)) {
69 dragged_width += t->GetDisplayImageWidth(NULL);
70 }
71
72 int drag_hlight_left = rtl ? max(px -dragged_width, 0) : px;
73 int drag_hlight_right = rtl ? px : min(px + dragged_width, max_width);
74 int drag_hlight_width = max(drag_hlight_right - drag_hlight_left, 0);
75
76 if (drag_hlight_width > 0) {
77 GfxFillRect(drag_hlight_left + WD_FRAMERECT_LEFT, WD_FRAMERECT_TOP + 1,
78 drag_hlight_right - WD_FRAMERECT_RIGHT, ScaleGUITrad(13) - WD_FRAMERECT_BOTTOM, _colour_gradient[COLOUR_GREY][7]);
79 }
80
81 return drag_hlight_width;
82 }
83
94 void DrawTrainImage(const Train *v, int left, int right, int y, VehicleID selection, EngineImageType image_type, int skip, VehicleID drag_dest)
95 {
96 bool rtl = _current_text_dir == TD_RTL;
97 Direction dir = rtl ? DIR_E : DIR_W;
98
99 DrawPixelInfo tmp_dpi, *old_dpi;
100 /* Position of highlight box */
101 int highlight_l = 0;
102 int highlight_r = 0;
103 int max_width = right - left + 1;
104 int height = ScaleGUITrad(14);
105
106 if (!FillDrawPixelInfo(&tmp_dpi, left, y, max_width, height)) return;
107
108 old_dpi = _cur_dpi;
109 _cur_dpi = &tmp_dpi;
110
111 int px = rtl ? max_width + skip : -skip;
112 bool sel_articulated = false;
113 bool dragging = (drag_dest != INVALID_VEHICLE);
114 bool drag_at_end_of_train = (drag_dest == v->index); // Head index is used to mark dragging at end of train.
115 for (; v != NULL && (rtl ? px > 0 : px < max_width); v = v->Next()) {
116 if (dragging && !drag_at_end_of_train && drag_dest == v->index) {
117 /* Highlight the drag-and-drop destination inside the train. */
118 int drag_hlight_width = HighlightDragPosition(px, max_width, selection, _cursor.vehchain);
119 px += rtl ? -drag_hlight_width : drag_hlight_width;
120 }
121
122 Point offset;
123 int width = Train::From(v)->GetDisplayImageWidth(&offset);
124
125 if (rtl ? px + width > 0 : px - width < max_width) {
126 PaletteID pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v);
127 DrawSprite(v->GetImage(dir, image_type), pal, px + (rtl ? -offset.x : offset.x), height / 2 + offset.y);
128 }
129
130 if (!v->IsArticulatedPart()) sel_articulated = false;
131
132 if (v->index == selection) {
133 /* Set the highlight position */
134 highlight_l = rtl ? px - width : px;
135 highlight_r = rtl ? px - 1 : px + width - 1;
136 sel_articulated = true;
137 } else if ((_cursor.vehchain && highlight_r != 0) || sel_articulated) {
138 if (rtl) {
139 highlight_l -= width;
140 } else {
141 highlight_r += width;
142 }
143 }
144
145 px += rtl ? -width : width;
146 }
147
148 if (dragging && drag_at_end_of_train) {
149 /* Highlight the drag-and-drop destination at the end of the train. */
150 HighlightDragPosition(px, max_width, selection, _cursor.vehchain);
151 }
152
153 if (highlight_l != highlight_r) {
154 /* Draw the highlight. Now done after drawing all the engines, as
155 * the next engine after the highlight could overlap it. */
156 DrawFrameRect(highlight_l, 0, highlight_r, height - 1, COLOUR_WHITE, FR_BORDERONLY);
157 }
158
159 _cur_dpi = old_dpi;
160 }
161
163 struct CargoSummaryItem {
164 CargoID cargo;
165 StringID subtype;
166 uint capacity;
167 uint amount;
168 StationID source;
169
171 inline bool operator != (const CargoSummaryItem &other) const
172 {
173 return this->cargo != other.cargo || this->subtype != other.subtype;
174 }
175 };
176
177 static const uint TRAIN_DETAILS_MIN_INDENT = 32;
178 static const uint TRAIN_DETAILS_MAX_INDENT = 72;
179
181 typedef SmallVector<CargoSummaryItem, 2> CargoSummary;
183 static CargoSummary _cargo_summary;
184
193 static void TrainDetailsCargoTab(const CargoSummaryItem *item, int left, int right, int y)
194 {
195 StringID str;
196 if (item->amount > 0) {
197 SetDParam(0, item->cargo);
198 SetDParam(1, item->amount);
199 SetDParam(2, item->source);
200 SetDParam(3, _settings_game.vehicle.freight_trains);
201 str = FreightWagonMult(item->cargo) > 1 ? STR_VEHICLE_DETAILS_CARGO_FROM_MULT : STR_VEHICLE_DETAILS_CARGO_FROM;
202 } else {
203 SetDParam(0, STR_QUANTITY_N_A);
204 str = item->cargo == INVALID_CARGO ? STR_LTBLUE_STRING : STR_VEHICLE_DETAILS_CARGO_EMPTY;
205 }
206
207 DrawString(left, right, y, str);
208 }
209
218 static void TrainDetailsInfoTab(const Vehicle *v, int left, int right, int y)
219 {
220 if (RailVehInfo(v->engine_type)->railveh_type == RAILVEH_WAGON) {
221 SetDParam(0, v->engine_type);
222 SetDParam(1, v->value);
223 DrawString(left, right, y, STR_VEHICLE_DETAILS_TRAIN_WAGON_VALUE);
224 } else {
225 SetDParam(0, v->engine_type);
226 SetDParam(1, v->build_year);
227 SetDParam(2, v->value);
228 DrawString(left, right, y, STR_VEHICLE_DETAILS_TRAIN_ENGINE_BUILT_AND_VALUE);
229 }
230 }
231
240 static void TrainDetailsCapacityTab(const CargoSummaryItem *item, int left, int right, int y)
241 {
242 StringID str;
243 if (item->cargo != INVALID_CARGO) {
244 SetDParam(0, item->cargo);
245 SetDParam(1, item->capacity);
246 SetDParam(4, item->subtype);
247 SetDParam(5, _settings_game.vehicle.freight_trains);
248 str = FreightWagonMult(item->cargo) > 1 ? STR_VEHICLE_INFO_CAPACITY_MULT : STR_VEHICLE_INFO_CAPACITY;
249 } else {
250 /* Draw subtype only */
251 SetDParam(0, item->subtype);
252 str = STR_VEHICLE_INFO_NO_CAPACITY;
253 }
254 DrawString(left, right, y, str);
255 }
256
262 static void GetCargoSummaryOfArticulatedVehicle(const Train *v, CargoSummary *summary)
263 {
264 summary->Clear();
265 do {
266 if (!v->GetEngine()->CanCarryCargo()) continue;
267
268 CargoSummaryItem new_item;
269 new_item.cargo = v->cargo_cap > 0 ? v->cargo_type : INVALID_CARGO;
270 new_item.subtype = GetCargoSubtypeText(v);
271 if (new_item.cargo == INVALID_CARGO && new_item.subtype == STR_EMPTY) continue;
272
273 CargoSummaryItem *item = summary->Find(new_item);
274 if (item == summary->End()) {
275 item = summary->Append();
276 item->cargo = new_item.cargo;
277 item->subtype = new_item.subtype;
278 item->capacity = 0;
279 item->amount = 0;
280 item->source = INVALID_STATION;
281 }
282
283 item->capacity += v->cargo_cap;
284 item->amount += v->cargo.StoredCount();
285 if (item->source == INVALID_STATION) item->source = v->cargo.Source();
286 } while ((v = v->Next()) != NULL && v->IsArticulatedPart());
287 }
288
294 static uint GetLengthOfArticulatedVehicle(const Train *v)
295 {
296 uint length = 0;
297
298 do {
299 length += v->GetDisplayImageWidth();
300 } while ((v = v->Next()) != NULL && v->IsArticulatedPart());
301
302 return length;
303 }
304
311 int GetTrainDetailsWndVScroll(VehicleID veh_id, TrainDetailsWindowTabs det_tab)
312 {
313 int num = 0;
314
315 if (det_tab == TDW_TAB_TOTALS) { // Total cargo tab
316 CargoArray act_cargo;
317 CargoArray max_cargo;
318 for (const Vehicle *v = Vehicle::Get(veh_id); v != NULL; v = v->Next()) {
319 act_cargo[v->cargo_type] += v->cargo.StoredCount();
320 max_cargo[v->cargo_type] += v->cargo_cap;
321 }
322
323 /* Set scroll-amount separately from counting, as to not compute num double
324 * for more carriages of the same type
325 */
326 for (CargoID i = 0; i < NUM_CARGO; i++) {
327 if (max_cargo[i] > 0) num++; // only count carriages that the train has
328 }
329 num++; // needs one more because first line is description string
330 } else {
331 for (const Train *v = Train::Get(veh_id); v != NULL; v = v->GetNextVehicle()) {
332 GetCargoSummaryOfArticulatedVehicle(v, &_cargo_summary);
333 num += max(1u, _cargo_summary.Length());
334
335 uint length = GetLengthOfArticulatedVehicle(v);
336 if (length > TRAIN_DETAILS_MAX_INDENT) num++;
337 }
338 }
339
340 return num;
341 }
342
354 void DrawTrainDetails(const Train *v, int left, int right, int y, int vscroll_pos, uint16 vscroll_cap, TrainDetailsWindowTabs det_tab)
355 {
356 /* get rid of awkward offset */
357 y -= WD_MATRIX_TOP;
358
359 int sprite_height = ScaleGUITrad(GetVehicleHeight(VEH_TRAIN));
360 int line_height = max(sprite_height, WD_MATRIX_TOP + FONT_HEIGHT_NORMAL + WD_MATRIX_BOTTOM);
361 int sprite_y_offset = line_height / 2;
362 int text_y_offset = (line_height - FONT_HEIGHT_NORMAL) / 2;
363
364 /* draw the first 3 details tabs */
365 if (det_tab != TDW_TAB_TOTALS) {
366 bool rtl = _current_text_dir == TD_RTL;
367 Direction dir = rtl ? DIR_E : DIR_W;
368 int x = rtl ? right : left;
369 for (; v != NULL && vscroll_pos > -vscroll_cap; v = v->GetNextVehicle()) {
370 GetCargoSummaryOfArticulatedVehicle(v, &_cargo_summary);
371
372 /* Draw sprites */
373 uint dx = 0;
374 int px = x;
375 const Train *u = v;
376 do {
377 Point offset;
378 int width = u->GetDisplayImageWidth(&offset);
379 if (vscroll_pos <= 0 && vscroll_pos > -vscroll_cap) {
380 int pitch = 0;
381 const Engine *e = Engine::Get(v->engine_type);
382 if (e->GetGRF() != NULL) {
383 pitch = ScaleGUITrad(e->GetGRF()->traininfo_vehicle_pitch);
384 }
385 PaletteID pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v);
386 DrawSprite(u->GetImage(dir, EIT_IN_DETAILS), pal, px + (rtl ? -offset.x : offset.x), y - line_height * vscroll_pos + sprite_y_offset + pitch);
387 }
388 px += rtl ? -width : width;
389 dx += width;
390 u = u->Next();
391 } while (u != NULL && u->IsArticulatedPart());
392
393 bool separate_sprite_row = (dx > (uint)ScaleGUITrad(TRAIN_DETAILS_MAX_INDENT));
394 if (separate_sprite_row) {
395 vscroll_pos--;
396 dx = 0;
397 }
398
399 uint num_lines = max(1u, _cargo_summary.Length());
400 for (uint i = 0; i < num_lines; i++) {
401 int sprite_width = max<int>(dx, ScaleGUITrad(TRAIN_DETAILS_MIN_INDENT)) + 3;
402 int data_left = left + (rtl ? 0 : sprite_width);
403 int data_right = right - (rtl ? sprite_width : 0);
404 if (vscroll_pos <= 0 && vscroll_pos > -vscroll_cap) {
405 int py = y - line_height * vscroll_pos + text_y_offset;
406 if (i > 0 || separate_sprite_row) {
407 if (vscroll_pos != 0) GfxFillRect(left, py - WD_MATRIX_TOP - 1, right, py - WD_MATRIX_TOP, _colour_gradient[COLOUR_GREY][5]);
408 }
409 switch (det_tab) {
410 case TDW_TAB_CARGO:
411 if (i < _cargo_summary.Length()) {
412 TrainDetailsCargoTab(&_cargo_summary[i], data_left, data_right, py);
413 } else {
414 DrawString(data_left, data_right, py, STR_QUANTITY_N_A, TC_LIGHT_BLUE);
415 }
416 break;
417
418 case TDW_TAB_INFO:
419 if (i == 0) TrainDetailsInfoTab(v, data_left, data_right, py);
420 break;
421
422 case TDW_TAB_CAPACITY:
423 if (i < _cargo_summary.Length()) {
424 TrainDetailsCapacityTab(&_cargo_summary[i], data_left, data_right, py);
425 } else {
426 SetDParam(0, STR_EMPTY);
427 DrawString(data_left, data_right, py, STR_VEHICLE_INFO_NO_CAPACITY);
428 }
429 break;
430
431 default: NOT_REACHED();
432 }
433 }
434 vscroll_pos--;
435 }
436 }
437 } else {
438 CargoArray act_cargo;
439 CargoArray max_cargo;
440 Money feeder_share = 0;
441
442 for (const Vehicle *u = v; u != NULL; u = u->Next()) {
443 act_cargo[u->cargo_type] += u->cargo.StoredCount();
444 max_cargo[u->cargo_type] += u->cargo_cap;
445 feeder_share += u->cargo.FeederShare();
446 }
447
448 /* draw total cargo tab */
449 DrawString(left, right, y + text_y_offset, STR_VEHICLE_DETAILS_TRAIN_TOTAL_CAPACITY_TEXT);
450 y += line_height;
451
452 for (CargoID i = 0; i < NUM_CARGO; i++) {
453 if (max_cargo[i] > 0 && --vscroll_pos < 0 && vscroll_pos > -vscroll_cap) {
454 SetDParam(0, i); // {CARGO} #1
455 SetDParam(1, act_cargo[i]); // {CARGO} #2
456 SetDParam(2, i); // {SHORTCARGO} #1
457 SetDParam(3, max_cargo[i]); // {SHORTCARGO} #2
458 SetDParam(4, _settings_game.vehicle.freight_trains);
459 DrawString(left, right, y + text_y_offset, FreightWagonMult(i) > 1 ? STR_VEHICLE_DETAILS_TRAIN_TOTAL_CAPACITY_MULT : STR_VEHICLE_DETAILS_TRAIN_TOTAL_CAPACITY);
460 y += line_height;
461 }
462 }
463 SetDParam(0, feeder_share);
464 DrawString(left, right, y + text_y_offset, STR_VEHICLE_INFO_FEEDER_CARGO_VALUE);
465 }
466 }