1

/* $Id$ */

     2

     3

/** @file engine_gui.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "table/strings.h"

     8

#include "table/sprites.h"

     9

#include "functions.h"

    10

#include "window.h"

    11

#include "gui.h"

    12

#include "viewport.h"

    13

#include "gfx.h"

    14

#include "engine.h"

    15

#include "command.h"

    16

#include "news.h"

    17

#include "variables.h"

    18

#include "newgrf_engine.h"

    19

    20

    21

static StringID GetEngineCategoryName(EngineID engine)

    22

{

    23

	switch (GetEngine(engine)->type) {

    24

		default: NOT_REACHED();

    25

		case VEH_ROAD:              return STR_8103_ROAD_VEHICLE;

    26

		case VEH_AIRCRAFT:          return STR_8104_AIRCRAFT;

    27

		case VEH_SHIP:              return STR_8105_SHIP;

    28

		case VEH_TRAIN:

    29

			switch (RailVehInfo(engine)->railtype) {

    30

				default: NOT_REACHED();

    31

				case RAILTYPE_RAIL:     return STR_8102_RAILROAD_LOCOMOTIVE;

    32

				case RAILTYPE_ELECTRIC: return STR_8102_RAILROAD_LOCOMOTIVE;

    33

				case RAILTYPE_MONO:     return STR_8106_MONORAIL_LOCOMOTIVE;

    34

				case RAILTYPE_MAGLEV:   return STR_8107_MAGLEV_LOCOMOTIVE;

    35

			}

    36

	}

    37

}

    38

    39

static const Widget _engine_preview_widgets[] = {

    40

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

    41

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

    42

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

    43

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

    44

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

    45

{   WIDGETS_END},

    46

};

    47

    48

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

    49

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

    50

    51

struct DrawEngineInfo {

    52

	DrawEngineProc *engine_proc;

    53

	DrawEngineInfoProc *info_proc;

    54

};

    55

    56

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

    57

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

    58

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

    59

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

    60

    61

static const DrawEngineInfo _draw_engine_list[4] = {

    62

	{ DrawTrainEngine,    DrawTrainEngineInfo    },

    63

	{ DrawRoadVehEngine,  DrawRoadVehEngineInfo  },

    64

	{ DrawShipEngine,     DrawShipEngineInfo     },

    65

	{ DrawAircraftEngine, DrawAircraftEngineInfo },

    66

};

    67

    68

static void EnginePreviewWndProc(Window *w, WindowEvent *e)

    69

{

    70

	switch (e->event) {

    71

	case WE_PAINT: {

    72

		EngineID engine = w->window_number;

    73

		const DrawEngineInfo* dei;

    74

		int width;

    75

    76

		DrawWindowWidgets(w);

    77

    78

		SetDParam(0, GetEngineCategoryName(engine));

    79

		DrawStringMultiCenter(150, 44, STR_8101_WE_HAVE_JUST_DESIGNED_A, 296);

    80

    81

		DrawStringCentered(w->width >> 1, 80, GetCustomEngineName(engine), 0x10);

    82

    83

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

    84

    85

		width = w->width;

    86

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

    87

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

    88

		break;

    89

	}

    90

    91

	case WE_CLICK:

    92

		switch (e->we.click.widget) {

    93

			case 4:

    94

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

    95

				/* Fallthrough */

    96

			case 3:

    97

				DeleteWindow(w);

    98

				break;

    99

		}

   100

		break;

   101

	}

   102

}

   103

   104

static const WindowDesc _engine_preview_desc = {

   105

	WDP_CENTER, WDP_CENTER, 300, 192,

   106

	WC_ENGINE_PREVIEW, WC_NONE,

   107

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   108

	_engine_preview_widgets,

   109

	EnginePreviewWndProc

   110

};

   111

   112

   113

void ShowEnginePreviewWindow(EngineID engine)

   114

{

   115

	AllocateWindowDescFront(&_engine_preview_desc, engine);

   116

}

   117

   118

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

   119

{

   120

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   121

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

   122

   123

	SetDParam(0, (_eco->GetPrice(CEconomy::BUILD_RAILVEHICLE) >> 3) * rvi->base_cost >> 5);

   124

	SetDParam(2, rvi->max_speed * 10 / 16);

   125

	SetDParam(3, rvi->power << multihead);

   126

	SetDParam(1, rvi->weight << multihead);

   127

   128

	uint32 cost_class;

   129

	switch (rvi->running_cost_class)

   130

	{

   131

		default:

   132

		case 0: cost_class = _eco->GetPrice(CEconomy::RUNNING_RAIL0); break;

   133

		case 1: cost_class = _eco->GetPrice(CEconomy::RUNNING_RAIL1); break;

   134

		case 2: cost_class = _eco->GetPrice(CEconomy::RUNNING_RAIL2); break;

   135

	}

   136

	SetDParam(4, rvi->running_cost_base * cost_class >> 8 << multihead);

   137

   138

	if (rvi->capacity != 0) {

   139

		SetDParam(5, rvi->cargo_type);

   140

		SetDParam(6, rvi->capacity << multihead);

   141

	} else {

   142

		SetDParam(5, CT_INVALID);

   143

	}

   144

	DrawStringMultiCenter(x, y, STR_VEHICLE_INFO_COST_WEIGHT_SPEED_POWER, maxw);

   145

}

   146

   147

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

   148

{

   149

	const AircraftVehicleInfo *avi = AircraftVehInfo(engine);

   150

	SetDParam(0, (_eco->GetPrice(CEconomy::AIRCRAFT_BASE) >> 3) * avi->base_cost >> 5);

   151

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

   152

	SetDParam(2, avi->passenger_capacity);

   153

	SetDParam(3, avi->mail_capacity);

   154

	SetDParam(4, avi->running_cost * _eco->GetPrice(CEconomy::AIRCRAFT_RUNNING) >> 8);

   155

   156

	DrawStringMultiCenter(x, y, STR_A02E_COST_MAX_SPEED_CAPACITY, maxw);

   157

}

   158

   159

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

   160

{

   161

	const RoadVehicleInfo *rvi = RoadVehInfo(engine);

   162

   163

	SetDParam(0, (_eco->GetPrice(CEconomy::ROADVEH_BASE) >> 3) * rvi->base_cost >> 5);

   164

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

   165

	SetDParam(2, rvi->running_cost * _eco->GetPrice(CEconomy::ROADVEH_RUNNING) >> 8);

   166

	SetDParam(3, rvi->cargo_type);

   167

	SetDParam(4, rvi->capacity);

   168

   169

	DrawStringMultiCenter(x, y, STR_902A_COST_SPEED_RUNNING_COST, maxw);

   170

}

   171

   172

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

   173

{

   174

	const ShipVehicleInfo *svi = ShipVehInfo(engine);

   175

	SetDParam(0, svi->base_cost * (_eco->GetPrice(CEconomy::SHIP_BASE) >> 3) >> 5);

   176

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

   177

	SetDParam(2, svi->cargo_type);

   178

	SetDParam(3, svi->capacity);

   179

	SetDParam(4, svi->running_cost * _eco->GetPrice(CEconomy::SHIP_RUNNING) >> 8);

   180

	DrawStringMultiCenter(x, y, STR_982E_COST_MAX_SPEED_CAPACITY, maxw);

   181

}

   182

   183

   184

StringID GetNewsStringNewVehicleAvail(const NewsItem *ni)

   185

{

   186

	EngineID engine = ni->string_id;

   187

	SetDParam(0, GetEngineCategoryName(engine));

   188

	SetDParam(1, GetCustomEngineName(engine));

   189

	return STR_NEW_VEHICLE_NOW_AVAILABLE_WITH_TYPE;

   190

}

   191

   192

void DrawNewsNewVehicleAvail(Window *w)

   193

{

   194

	DrawNewsBorder(w);

   195

   196

	EngineID engine = WP(w, news_d).ni->string_id;

   197

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

   198

   199

	SetDParam(0, GetEngineCategoryName(engine));

   200

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

   201

   202

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

   203

   204

	SetDParam(0, GetCustomEngineName(engine));

   205

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

   206

   207

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

   208

	GfxFillRect(25, 56, w->width - 56, 112, PALETTE_TO_STRUCT_GREY | (1 << USE_COLORTABLE));

   209

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

   210

}