1

/* $Id$ */

     2

     3

/** @file train_gui.cpp GUI for trains. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "gui.h"

     9

#include "window_gui.h"

    10

#include "gfx_func.h"

    11

#include "command_func.h"

    12

#include "vehicle_gui.h"

    13

#include "train.h"

    14

#include "newgrf_engine.h"

    15

#include "strings_func.h"

    16

#include "vehicle_func.h"

    17

#include "settings_type.h"

    18

#include "order_func.h"

    19

#include "engine_func.h"

    20

#include "engine_base.h"

    21

#include "window_func.h"

    22

    23

#include "table/sprites.h"

    24

#include "table/strings.h"

    25

    26

void CcBuildWagon(bool success, TileIndex tile, uint32 p1, uint32 p2)

    27

{

    28

	if (!success) return;

    29

    30

	/* find a locomotive in the depot. */

    31

	const Vehicle *found = NULL;

    32

	const Vehicle *v;

    33

	FOR_ALL_VEHICLES(v) {

    34

		if (v->type == VEH_TRAIN && IsFrontEngine(v) &&

    35

				v->tile == tile &&

    36

				v->u.rail.track == TRACK_BIT_DEPOT) {

    37

			if (found != NULL) return; // must be exactly one.

    38

			found = v;

    39

		}

    40

	}

    41

    42

	/* if we found a loco, */

    43

	if (found != NULL) {

    44

		found = GetLastVehicleInChain(found);

    45

		/* put the new wagon at the end of the loco. */

    46

		DoCommandP(0, _new_vehicle_id | (found->index << 16), 0, NULL, CMD_MOVE_RAIL_VEHICLE);

    47

		InvalidateWindowClassesData(WC_TRAINS_LIST, 0);

    48

	}

    49

}

    50

    51

void CcBuildLoco(bool success, TileIndex tile, uint32 p1, uint32 p2)

    52

{

    53

	if (!success) return;

    54

    55

	const Vehicle *v = GetVehicle(_new_vehicle_id);

    56

	if (tile == _backup_orders_tile) {

    57

		_backup_orders_tile = 0;

    58

		RestoreVehicleOrders(v);

    59

	}

    60

	ShowVehicleViewWindow(v);

    61

}

    62

    63

/**

    64

 * Get the number of pixels for the given wagon length.

    65

 * @param len Length measured in 1/8ths of a standard wagon.

    66

 * @return Number of pixels across.

    67

 */

    68

int WagonLengthToPixels(int len)

    69

{

    70

	return (len * _traininfo_vehicle_width) / 8;

    71

}

    72

    73

void DrawTrainImage(const Vehicle *v, int x, int y, VehicleID selection, int count, int skip)

    74

{

    75

	DrawPixelInfo tmp_dpi, *old_dpi;

    76

	int dx = -(skip * 8) / _traininfo_vehicle_width;

    77

	/* Position of highlight box */

    78

	int highlight_l = 0;

    79

	int highlight_r = 0;

    80

    81

	if (!FillDrawPixelInfo(&tmp_dpi, x - 2, y - 1, count + 1, 14)) return;

    82

    83

	count = (count * 8) / _traininfo_vehicle_width;

    84

    85

	old_dpi = _cur_dpi;

    86

	_cur_dpi = &tmp_dpi;

    87

    88

	do {

    89

		int width = v->u.rail.cached_veh_length;

    90

    91

		if (dx + width > 0) {

    92

			if (dx <= count) {

    93

				SpriteID pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v);

    94

				DrawSprite(v->GetImage(DIR_W), pal, 16 + WagonLengthToPixels(dx), 7 + (is_custom_sprite(RailVehInfo(v->engine_type)->image_index) ? _traininfo_vehicle_pitch : 0));

    95

				if (v->index == selection) {

    96

					/* Set the highlight position */

    97

					highlight_l = WagonLengthToPixels(dx) + 1;

    98

					highlight_r = WagonLengthToPixels(dx + width) + 1;

    99

				} else if (_cursor.vehchain && highlight_r != 0) {

   100

					highlight_r += WagonLengthToPixels(width);

   101

				}

   102

			}

   103

		}

   104

		dx += width;

   105

   106

		v = v->Next();

   107

	} while (dx < count && v != NULL);

   108

   109

	if (highlight_l != highlight_r) {

   110

		/* Draw the highlight. Now done after drawing all the engines, as

   111

		 * the next engine after the highlight could overlap it. */

   112

		DrawFrameRect(highlight_l, 0, highlight_r, 13, 15, FR_BORDERONLY);

   113

	}

   114

   115

	_cur_dpi = old_dpi;

   116

}

   117

   118

static void TrainDetailsCargoTab(const Vehicle *v, int x, int y)

   119

{

   120

	if (v->cargo_cap != 0) {

   121

		StringID str = STR_8812_EMPTY;

   122

   123

		if (!v->cargo.Empty()) {

   124

			SetDParam(0, v->cargo_type);

   125

			SetDParam(1, v->cargo.Count());

   126

			SetDParam(2, v->cargo.Source());

   127

			SetDParam(3, _settings_game.vehicle.freight_trains);

   128

			str = FreightWagonMult(v->cargo_type) > 1 ? STR_FROM_MULT : STR_8813_FROM;

   129

		}

   130

		DrawString(x, y, str, TC_FROMSTRING);

   131

	}

   132

}

   133

   134

static void TrainDetailsInfoTab(const Vehicle *v, int x, int y)

   135

{

   136

	if (RailVehInfo(v->engine_type)->railveh_type == RAILVEH_WAGON) {

   137

		SetDParam(0, v->engine_type);

   138

		SetDParam(1, v->value);

   139

		DrawString(x, y, STR_882D_VALUE, TC_BLACK);

   140

	} else {

   141

		SetDParam(0, v->engine_type);

   142

		SetDParam(1, v->build_year);

   143

		SetDParam(2, v->value);

   144

		DrawString(x, y, STR_882C_BUILT_VALUE, TC_BLACK);

   145

	}

   146

}

   147

   148

static void TrainDetailsCapacityTab(const Vehicle *v, int x, int y)

   149

{

   150

	if (v->cargo_cap != 0) {

   151

		SetDParam(0, v->cargo_type);

   152

		SetDParam(1, v->cargo_cap);

   153

		SetDParam(2, _settings_game.vehicle.freight_trains);

   154

		DrawString(x, y, FreightWagonMult(v->cargo_type) > 1 ? STR_CAPACITY_MULT : STR_013F_CAPACITY, TC_FROMSTRING);

   155

	}

   156

}

   157

   158

int GetTrainDetailsWndVScroll(VehicleID veh_id, byte det_tab)

   159

{

   160

	AcceptedCargo act_cargo;

   161

	AcceptedCargo max_cargo;

   162

	int num = 0;

   163

   164

	if (det_tab == 3) { // Total cargo tab

   165

		memset(max_cargo, 0, sizeof(max_cargo));

   166

		memset(act_cargo, 0, sizeof(act_cargo));

   167

   168

		for (const Vehicle *v = GetVehicle(veh_id) ; v != NULL ; v = v->Next()) {

   169

			act_cargo[v->cargo_type] += v->cargo.Count();

   170

			max_cargo[v->cargo_type] += v->cargo_cap;

   171

		}

   172

   173

		/* Set scroll-amount seperately from counting, as to not compute num double

   174

		 * for more carriages of the same type

   175

		 */

   176

		for (CargoID i = 0; i < NUM_CARGO; i++) {

   177

			if (max_cargo[i] > 0) num++; // only count carriages that the train has

   178

		}

   179

		num++; // needs one more because first line is description string

   180

	} else {

   181

		for (const Vehicle *v = GetVehicle(veh_id) ; v != NULL ; v = v->Next()) {

   182

			if (!IsArticulatedPart(v) || v->cargo_cap != 0) num++;

   183

		}

   184

	}

   185

   186

	return num;

   187

}

   188

   189

void DrawTrainDetails(const Vehicle *v, int x, int y, int vscroll_pos, uint16 vscroll_cap, byte det_tab)

   190

{

   191

	/* draw the first 3 details tabs */

   192

	if (det_tab != 3) {

   193

		const Vehicle *u = v;

   194

		x = 1;

   195

		for (;;) {

   196

			if (--vscroll_pos < 0 && vscroll_pos >= -vscroll_cap) {

   197

				int dx = 0;

   198

   199

				u = v;

   200

				do {

   201

					SpriteID pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v);

   202

					DrawSprite(u->GetImage(DIR_W), pal, x + WagonLengthToPixels(4 + dx), y + 6 + (is_custom_sprite(RailVehInfo(u->engine_type)->image_index) ? _traininfo_vehicle_pitch : 0));

   203

					dx += u->u.rail.cached_veh_length;

   204

					u = u->Next();

   205

				} while (u != NULL && IsArticulatedPart(u) && u->cargo_cap == 0);

   206

   207

				int px = x + WagonLengthToPixels(dx) + 2;

   208

				int py = y + 2;

   209

				switch (det_tab) {

   210

					default: NOT_REACHED();

   211

					case 0: TrainDetailsCargoTab(   v, px, py); break;

   212

					case 1:

   213

						/* Only show name and value for the 'real' part */

   214

						if (!IsArticulatedPart(v)) {

   215

							TrainDetailsInfoTab(v, px, py);

   216

						}

   217

						break;

   218

					case 2: TrainDetailsCapacityTab(v, px, py); break;

   219

				}

   220

				y += 14;

   221

   222

				v = u;

   223

			} else {

   224

				/* Move to the next line */

   225

				do {

   226

					v = v->Next();

   227

				} while (v != NULL && IsArticulatedPart(v) && v->cargo_cap == 0);

   228

			}

   229

			if (v == NULL) return;

   230

		}

   231

	} else {

   232

		AcceptedCargo act_cargo;

   233

		AcceptedCargo max_cargo;

   234

   235

		memset(max_cargo, 0, sizeof(max_cargo));

   236

		memset(act_cargo, 0, sizeof(act_cargo));

   237

   238

		for (const Vehicle *u = v; u != NULL ; u = u->Next()) {

   239

			act_cargo[u->cargo_type] += u->cargo.Count();

   240

			max_cargo[u->cargo_type] += u->cargo_cap;

   241

		}

   242

   243

		/* draw total cargo tab */

   244

		DrawString(x, y + 2, STR_TOTAL_CAPACITY_TEXT, TC_FROMSTRING);

   245

		for (CargoID i = 0; i < NUM_CARGO; i++) {

   246

			if (max_cargo[i] > 0 && --vscroll_pos < 0 && vscroll_pos > -vscroll_cap) {

   247

				y += 14;

   248

				SetDParam(0, i);            // {CARGO} #1

   249

				SetDParam(1, act_cargo[i]); // {CARGO} #2

   250

				SetDParam(2, i);            // {SHORTCARGO} #1

   251

				SetDParam(3, max_cargo[i]); // {SHORTCARGO} #2

   252

				SetDParam(4, _settings_game.vehicle.freight_trains);

   253

				DrawString(x, y + 2, FreightWagonMult(i) > 1 ? STR_TOTAL_CAPACITY_MULT : STR_TOTAL_CAPACITY, TC_FROMSTRING);

   254

			}

   255

		}

   256

		SetDParam(0, v->cargo.FeederShare());

   257

		DrawString(x, y + 15, STR_FEEDER_CARGO_VALUE, TC_FROMSTRING);

   258

	}

   259

}