1

/* $Id$ */

     2

     3

/** @file engine_gui.cpp GUI to show engine related information. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "gui.h"

     8

#include "window_gui.h"

     9

#include "gfx_func.h"

    10

#include "engine_func.h"

    11

#include "engine_base.h"

    12

#include "command_func.h"

    13

#include "economy_func.h"

    14

#include "news_func.h"

    15

#include "variables.h"

    16

#include "newgrf_engine.h"

    17

#include "strings_func.h"

    18

#include "engine_gui.h"

    19

#include "articulated_vehicles.h"

    20

    21

#include "table/strings.h"

    22

#include "table/sprites.h"

    23

    24

StringID GetEngineCategoryName(EngineID engine)

    25

{

    26

	switch (GetEngine(engine)->type) {

    27

		default: NOT_REACHED();

    28

		case VEH_ROAD:              return STR_8103_ROAD_VEHICLE;

    29

		case VEH_AIRCRAFT:          return STR_8104_AIRCRAFT;

    30

		case VEH_SHIP:              return STR_8105_SHIP;

    31

		case VEH_TRAIN:

    32

			switch (RailVehInfo(engine)->railtype) {

    33

				default: NOT_REACHED();

    34

				case RAILTYPE_RAIL:     return STR_8102_RAILROAD_LOCOMOTIVE;

    35

				case RAILTYPE_ELECTRIC: return STR_8102_RAILROAD_LOCOMOTIVE;

    36

				case RAILTYPE_MONO:     return STR_8106_MONORAIL_LOCOMOTIVE;

    37

				case RAILTYPE_MAGLEV:   return STR_8107_MAGLEV_LOCOMOTIVE;

    38

			}

    39

	}

    40

}

    41

    42

static const Widget _engine_preview_widgets[] = {

    43

{   WWT_CLOSEBOX,   RESIZE_NONE,     5,     0,    10,     0,    13, STR_00C5,                                  STR_018B_CLOSE_WINDOW},

    44

{    WWT_CAPTION,   RESIZE_NONE,     5,    11,   299,     0,    13, STR_8100_MESSAGE_FROM_VEHICLE_MANUFACTURE, STR_018C_WINDOW_TITLE_DRAG_THIS},

    45

{      WWT_PANEL,   RESIZE_NONE,     5,     0,   299,    14,   191, 0x0,                                       STR_NULL},

    46

{ WWT_PUSHTXTBTN,   RESIZE_NONE,     5,    85,   144,   172,   183, STR_00C9_NO,                               STR_NULL},

    47

{ WWT_PUSHTXTBTN,   RESIZE_NONE,     5,   155,   214,   172,   183, STR_00C8_YES,                              STR_NULL},

    48

{   WIDGETS_END},

    49

};

    50

    51

typedef void DrawEngineProc(int x, int y, EngineID engine, SpriteID pal);

    52

typedef void DrawEngineInfoProc(EngineID, int x, int y, int maxw);

    53

    54

struct DrawEngineInfo {

    55

	DrawEngineProc *engine_proc;

    56

	DrawEngineInfoProc *info_proc;

    57

};

    58

    59

static void DrawTrainEngineInfo(EngineID engine, int x, int y, int maxw);

    60

static void DrawRoadVehEngineInfo(EngineID engine, int x, int y, int maxw);

    61

static void DrawShipEngineInfo(EngineID engine, int x, int y, int maxw);

    62

static void DrawAircraftEngineInfo(EngineID engine, int x, int y, int maxw);

    63

    64

static const DrawEngineInfo _draw_engine_list[4] = {

    65

	{ DrawTrainEngine,    DrawTrainEngineInfo    },

    66

	{ DrawRoadVehEngine,  DrawRoadVehEngineInfo  },

    67

	{ DrawShipEngine,     DrawShipEngineInfo     },

    68

	{ DrawAircraftEngine, DrawAircraftEngineInfo },

    69

};

    70

    71

struct EnginePreviewWindow : Window {

    72

	EnginePreviewWindow(const WindowDesc *desc, WindowNumber window_number) : Window(desc, window_number)

    73

	{

    74

		this->FindWindowPlacementAndResize(desc);

    75

	}

    76

    77

	virtual void OnPaint()

    78

	{

    79

		this->DrawWidgets();

    80

    81

		EngineID engine = this->window_number;

    82

		SetDParam(0, GetEngineCategoryName(engine));

    83

		DrawStringMultiCenter(150, 44, STR_8101_WE_HAVE_JUST_DESIGNED_A, 296);

    84

    85

		SetDParam(0, engine);

    86

		DrawStringCentered(this->width >> 1, 80, STR_ENGINE_NAME, TC_BLACK);

    87

    88

		const DrawEngineInfo *dei = &_draw_engine_list[GetEngine(engine)->type];

    89

    90

		int width = this->width;

    91

		dei->engine_proc(width >> 1, 100, engine, 0);

    92

		dei->info_proc(engine, width >> 1, 130, width - 52);

    93

	}

    94

    95

	virtual void OnClick(Point pt, int widget)

    96

	{

    97

		switch (widget) {

    98

			case 4:

    99

				DoCommandP(0, this->window_number, 0, NULL, CMD_WANT_ENGINE_PREVIEW);

   100

				/* Fallthrough */

   101

			case 3:

   102

				delete this;

   103

				break;

   104

		}

   105

	}

   106

};

   107

   108

static const WindowDesc _engine_preview_desc = {

   109

	WDP_CENTER, WDP_CENTER, 300, 192, 300, 192,

   110

	WC_ENGINE_PREVIEW, WC_NONE,

   111

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   112

	_engine_preview_widgets,

   113

};

   114

   115

   116

void ShowEnginePreviewWindow(EngineID engine)

   117

{

   118

	AllocateWindowDescFront<EnginePreviewWindow>(&_engine_preview_desc, engine);

   119

}

   120

   121

static uint GetTotalCapacityOfArticulatedParts(EngineID engine, VehicleType type)

   122

{

   123

	uint total = 0;

   124

   125

	uint16 *cap = GetCapacityOfArticulatedParts(engine, type);

   126

	for (uint c = 0; c < NUM_CARGO; c++) {

   127

		total += cap[c];

   128

	}

   129

   130

	return total;

   131

}

   132

   133

static void DrawTrainEngineInfo(EngineID engine, int x, int y, int maxw)

   134

{

   135

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   136

	int multihead = (rvi->railveh_type == RAILVEH_MULTIHEAD) ? 1 : 0;

   137

   138

	SetDParam(0, (_price.build_railvehicle >> 3) * GetEngineProperty(engine, 0x17, rvi->base_cost) >> 5);

   139

	SetDParam(2, GetEngineProperty(engine, 0x09, rvi->max_speed) * 10 / 16);

   140

	SetDParam(3, GetEngineProperty(engine, 0x0B, rvi->power) << multihead);

   141

	SetDParam(1, GetEngineProperty(engine, 0x16, rvi->weight) << multihead);

   142

   143

	SetDParam(4, GetEngineProperty(engine, 0x0D, rvi->running_cost) * GetPriceByIndex(rvi->running_cost_class) >> 8 << multihead);

   144

   145

	uint capacity = GetTotalCapacityOfArticulatedParts(engine, VEH_TRAIN);

   146

	if (capacity != 0) {

   147

		SetDParam(5, rvi->cargo_type);

   148

		SetDParam(6, capacity << multihead);

   149

	} else {

   150

		SetDParam(5, CT_INVALID);

   151

	}

   152

	DrawStringMultiCenter(x, y, STR_VEHICLE_INFO_COST_WEIGHT_SPEED_POWER, maxw);

   153

}

   154

   155

static void DrawAircraftEngineInfo(EngineID engine, int x, int y, int maxw)

   156

{

   157

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

   158

	SetDParam(0, (_price.aircraft_base >> 3) * GetEngineProperty(engine, 0x0B, avi->base_cost) >> 5);

   159

	SetDParam(1, avi->max_speed * 10 / 16);

   160

	SetDParam(2, avi->passenger_capacity);

   161

	SetDParam(3, avi->mail_capacity);

   162

	SetDParam(4, GetEngineProperty(engine, 0x0E, avi->running_cost) * _price.aircraft_running >> 8);

   163

   164

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

   165

}

   166

   167

static void DrawRoadVehEngineInfo(EngineID engine, int x, int y, int maxw)

   168

{

   169

	const RoadVehicleInfo *rvi = RoadVehInfo(engine);

   170

   171

	SetDParam(0, (_price.roadveh_base >> 3) * GetEngineProperty(engine, 0x11, rvi->base_cost) >> 5);

   172

	SetDParam(1, rvi->max_speed * 10 / 32);

   173

	SetDParam(2, rvi->running_cost * GetPriceByIndex(rvi->running_cost_class) >> 8);

   174

	SetDParam(3, rvi->cargo_type);

   175

	SetDParam(4, GetTotalCapacityOfArticulatedParts(engine, VEH_ROAD));

   176

   177

	DrawStringMultiCenter(x, y, STR_902A_COST_SPEED_RUNNING_COST, maxw);

   178

}

   179

   180

static void DrawShipEngineInfo(EngineID engine, int x, int y, int maxw)

   181

{

   182

	const ShipVehicleInfo *svi = ShipVehInfo(engine);

   183

	SetDParam(0, GetEngineProperty(engine, 0x0A, svi->base_cost) * (_price.ship_base >> 3) >> 5);

   184

	SetDParam(1, GetEngineProperty(engine, 0x0B, svi->max_speed) * 10 / 32);

   185

	SetDParam(2, svi->cargo_type);

   186

	SetDParam(3, GetEngineProperty(engine, 0x0D, svi->capacity));

   187

	SetDParam(4, GetEngineProperty(engine, 0x0F, svi->running_cost) * _price.ship_running >> 8);

   188

	DrawStringMultiCenter(x, y, STR_982E_COST_MAX_SPEED_CAPACITY, maxw);

   189

}

   190

   191

void DrawNewsNewVehicleAvail(Window *w, const NewsItem *ni)

   192

{

   193

	EngineID engine = ni->data_a;

   194

	const DrawEngineInfo *dei = &_draw_engine_list[GetEngine(engine)->type];

   195

   196

	SetDParam(0, GetEngineCategoryName(engine));

   197

	DrawStringMultiCenter(w->width >> 1, 20, STR_NEW_VEHICLE_NOW_AVAILABLE, w->width - 2);

   198

   199

	GfxFillRect(25, 56, w->width - 25, w->height - 2, 10);

   200

   201

	SetDParam(0, engine);

   202

	DrawStringMultiCenter(w->width >> 1, 57, STR_NEW_VEHICLE_TYPE, w->width - 2);

   203

   204

	dei->engine_proc(w->width >> 1, 88, engine, 0);

   205

	GfxFillRect(25, 56, w->width - 56, 112, PALETTE_TO_STRUCT_GREY, FILLRECT_RECOLOR);

   206

	dei->info_proc(engine, w->width >> 1, 129, w->width - 52);

   207

}

   208

   209

   210

/** Sort all items using qsort() and given 'CompareItems' function

   211

 * @param el list to be sorted

   212

 * @param compare function for evaluation of the quicksort

   213

 */

   214

void EngList_Sort(GUIEngineList *el, EngList_SortTypeFunction compare)

   215

{

   216

	uint size = el->Length();

   217

	/* out-of-bounds access at the next line for size == 0 (even with operator[] at some systems)

   218

	 * generally, do not sort if there are less than 2 items */

   219

	if (size < 2) return;

   220

	qsort(el->Begin(), size, sizeof(*el->Begin()), compare); // MorphOS doesn't know vector::at(int) ...

   221

}

   222

   223

/** Sort selected range of items (on indices @ <begin, begin+num_items-1>)

   224

 * @param el list to be sorted

   225

 * @param compare function for evaluation of the quicksort

   226

 * @param begin start of sorting

   227

 * @param num_items count of items to be sorted

   228

 */

   229

void EngList_SortPartial(GUIEngineList *el, EngList_SortTypeFunction compare, uint begin, uint num_items)

   230

{

   231

	if (num_items < 2) return;

   232

	assert(begin < el->Length());

   233

	assert(begin + num_items <= el->Length());

   234

	qsort(el->Get(begin), num_items, sizeof(*el->Begin()), compare);

   235

}

   236