1

/* $Id$ */

     2

     3

/** @file bridge_gui.cpp Graphical user interface for bridge construction */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "gui.h"

     8

#include "window_gui.h"

     9

#include "command_func.h"

    10

#include "economy_func.h"

    11

#include "variables.h"

    12

#include "bridge.h"

    13

#include "strings_func.h"

    14

#include "window_func.h"

    15

#include "sound_func.h"

    16

#include "map_func.h"

    17

#include "viewport_func.h"

    18

#include "gfx_func.h"

    19

#include "tunnelbridge.h"

    20

#include "sortlist_type.h"

    21

#include "widgets/dropdown_func.h"

    22

    23

#include "table/strings.h"

    24

    25

/**

    26

 * Carriage for the data we need if we want to build a bridge

    27

 */

    28

struct BuildBridgeData {

    29

	BridgeType index;

    30

	const BridgeSpec *spec;

    31

	Money cost;

    32

};

    33

    34

typedef GUIList<BuildBridgeData> GUIBridgeList;

    35

    36

/**

    37

 * Callback executed after a build Bridge CMD has been called

    38

 *

    39

 * @param scucess True if the build succeded

    40

 * @param tile The tile where the command has been executed

    41

 * @param p1 not used

    42

 * @param p2 not used

    43

 */

    44

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

    45

{

    46

	if (success) SndPlayTileFx(SND_27_BLACKSMITH_ANVIL, tile);

    47

}

    48

    49

/* Names of the build bridge selection window */

    50

enum BuildBridgeSelectionWidgets {

    51

	BBSW_CLOSEBOX = 0,

    52

	BBSW_CAPTION,

    53

	BBSW_DROPDOWN_ORDER,

    54

	BBSW_DROPDOWN_CRITERIA,

    55

	BBSW_BRIDGE_LIST,

    56

	BBSW_SCROLLBAR,

    57

	BBSW_RESIZEBOX

    58

};

    59

    60

class BuildBridgeWindow : public Window {

    61

private:

    62

	/* Runtime saved values */

    63

	static uint16 last_size;

    64

	static Listing last_sorting;

    65

    66

	/* Constants for sorting the bridges */

    67

	static const StringID sorter_names[];

    68

	static GUIBridgeList::SortFunction *const sorter_funcs[];

    69

    70

	/* Internal variables */

    71

	TileIndex start_tile;

    72

	TileIndex end_tile;

    73

	uint32 type;

    74

	GUIBridgeList *bridges;

    75

    76

	/** Sort the bridges by their index */

    77

	static int CDECL BridgeIndexSorter(const BuildBridgeData *a, const BuildBridgeData *b)

    78

	{

    79

		return a->index - b->index;

    80

	}

    81

    82

	/** Sort the bridges by their price */

    83

	static int CDECL BridgePriceSorter(const BuildBridgeData *a, const BuildBridgeData *b)

    84

	{

    85

		return a->cost - b->cost;

    86

	}

    87

    88

	/** Sort the bridges by their maximum speed */

    89

	static int CDECL BridgeSpeedSorter(const BuildBridgeData *a, const BuildBridgeData *b)

    90

	{

    91

		return a->spec->speed - b->spec->speed;

    92

	}

    93

    94

	void BuildBridge(uint8 i)

    95

	{

    96

		DoCommandP(this->end_tile, this->start_tile, this->type | this->bridges->Get(i)->index,

    97

				CcBuildBridge, CMD_BUILD_BRIDGE | CMD_MSG(STR_5015_CAN_T_BUILD_BRIDGE_HERE));

    98

	}

    99

   100

	/** Sort the builable bridges */

   101

	void SortBridgeList()

   102

	{

   103

		this->bridges->Sort();

   104

   105

		/* Display the current sort variant */

   106

		this->widget[BBSW_DROPDOWN_CRITERIA].data = this->sorter_names[this->bridges->SortType()];

   107

   108

		/* Set the modified widgets dirty */

   109

		this->InvalidateWidget(BBSW_DROPDOWN_CRITERIA);

   110

		this->InvalidateWidget(BBSW_BRIDGE_LIST);

   111

	}

   112

   113

public:

   114

	BuildBridgeWindow(const WindowDesc *desc, TileIndex start, TileIndex end, uint32 br_type, GUIBridgeList *bl) : Window(desc),

   115

		start_tile(start),

   116

		end_tile(end),

   117

		type(br_type),

   118

		bridges(bl)

   119

	{

   120

		this->bridges->SetListing(this->last_sorting);

   121

		this->bridges->SetSortFuncs(this->sorter_funcs);

   122

		this->bridges->NeedResort();

   123

		this->SortBridgeList();

   124

   125

		/* Change the data, or the caption of the gui. Set it to road or rail, accordingly */

   126

		this->widget[BBSW_CAPTION].data = (GB(this->type, 15, 2) == TRANSPORT_ROAD) ? STR_1803_SELECT_ROAD_BRIDGE : STR_100D_SELECT_RAIL_BRIDGE;

   127

   128

		this->resize.step_height = 22;

   129

		this->vscroll.count = bl->Length();

   130

   131

		if (this->last_size <= 4) {

   132

			this->vscroll.cap = 4;

   133

		} else {

   134

			/* Resize the bridge selection window if we used a bigger one the last time */

   135

			this->vscroll.cap = min(this->last_size, this->vscroll.count);

   136

			ResizeWindow(this, 0, (this->vscroll.cap - 4) * this->resize.step_height);

   137

		}

   138

   139

		this->FindWindowPlacementAndResize(desc);

   140

	}

   141

   142

	~BuildBridgeWindow()

   143

	{

   144

		this->last_sorting = this->bridges->GetListing();

   145

   146

		delete bridges;

   147

	}

   148

   149

	virtual void OnPaint()

   150

	{

   151

		this->DrawWidgets();

   152

   153

		this->DrawSortButtonState(BBSW_DROPDOWN_ORDER, this->bridges->IsDescSortOrder() ? SBS_DOWN : SBS_UP);

   154

   155

		uint y = this->widget[BBSW_BRIDGE_LIST].top + 2;

   156

   157

		for (int i = this->vscroll.pos; (i < (this->vscroll.cap + this->vscroll.pos)) && (i < (int)this->bridges->Length()); i++) {

   158

			const BridgeSpec *b = this->bridges->Get(i)->spec;

   159

   160

			SetDParam(2, this->bridges->Get(i)->cost);

   161

			SetDParam(1, b->speed * 10 / 16);

   162

			SetDParam(0, b->material);

   163

   164

			DrawSprite(b->sprite, b->pal, 3, y);

   165

			DrawString(44, y, STR_500D, TC_FROMSTRING);

   166

			y += this->resize.step_height;

   167

   168

		}

   169

	}

   170

   171

	virtual EventState OnKeyPress(uint16 key, uint16 keycode)

   172

	{

   173

		const uint8 i = keycode - '1';

   174

		if (i < 9 && i < this->bridges->Length()) {

   175

			/* Build the requested bridge */

   176

			this->BuildBridge(i);

   177

			delete this;

   178

			return ES_HANDLED;

   179

		}

   180

		return ES_NOT_HANDLED;

   181

	}

   182

   183

	virtual void OnClick(Point pt, int widget)

   184

	{

   185

		switch (widget) {

   186

			default: break;

   187

			case BBSW_BRIDGE_LIST: {

   188

				uint i = ((int)pt.y - this->widget[BBSW_BRIDGE_LIST].top) / this->resize.step_height;

   189

				if (i < this->vscroll.cap) {

   190

					i += this->vscroll.pos;

   191

					if (i < this->bridges->Length()) {

   192

						this->BuildBridge(i);

   193

						delete this;

   194

					}

   195

				}

   196

			} break;

   197

   198

			case BBSW_DROPDOWN_ORDER:

   199

				this->bridges->ToggleSortOrder();

   200

				this->SetDirty();

   201

				break;

   202

   203

			case BBSW_DROPDOWN_CRITERIA:

   204

				ShowDropDownMenu(this, this->sorter_names, this->bridges->SortType(), BBSW_DROPDOWN_CRITERIA, 0, 0);

   205

				break;

   206

		}

   207

	}

   208

   209

	virtual void OnDropdownSelect(int widget, int index)

   210

	{

   211

		if (widget == BBSW_DROPDOWN_CRITERIA && this->bridges->SortType() != index) {

   212

			this->bridges->SetSortType(index);

   213

   214

			this->SortBridgeList();

   215

		}

   216

	}

   217

   218

	virtual void OnResize(Point new_size, Point delta)

   219

	{

   220

		this->vscroll.cap += delta.y / (int)this->resize.step_height;

   221

		this->widget[BBSW_BRIDGE_LIST].data = (this->vscroll.cap << 8) + 1;

   222

		SetVScrollCount(this, this->bridges->Length());

   223

   224

		this->last_size = max(this->vscroll.cap, this->last_size);

   225

	}

   226

};

   227

   228

/* Set the default size of the Build Bridge Window */

   229

uint16 BuildBridgeWindow::last_size = 4;

   230

/* Set the default sorting for the bridges */

   231

Listing BuildBridgeWindow::last_sorting = {false, 0};

   232

   233

/* Availible bridge sorting functions */

   234

GUIBridgeList::SortFunction* const BuildBridgeWindow::sorter_funcs[] = {

   235

	&BridgeIndexSorter,

   236

	&BridgePriceSorter,

   237

	&BridgeSpeedSorter

   238

};

   239

   240

/* Names of the sorting functions */

   241

const StringID BuildBridgeWindow::sorter_names[] = {

   242

	STR_SORT_BY_NUMBER,

   243

	STR_ENGINE_SORT_COST,

   244

	STR_SORT_BY_MAX_SPEED,

   245

	INVALID_STRING_ID

   246

};

   247

   248

/* Widget definition for the rail bridge selection window */

   249

static const Widget _build_bridge_widgets[] = {

   250

{   WWT_CLOSEBOX,   RESIZE_NONE,  COLOUR_DARK_GREEN,   0,  10,   0,  13, STR_00C5,                    STR_018B_CLOSE_WINDOW},            // BBSW_CLOSEBOX

   251

{    WWT_CAPTION,   RESIZE_NONE,  COLOUR_DARK_GREEN,  11, 199,   0,  13, STR_100D_SELECT_RAIL_BRIDGE, STR_018C_WINDOW_TITLE_DRAG_THIS},  // BBSW_CAPTION

   252

   253

{    WWT_TEXTBTN,   RESIZE_NONE,  COLOUR_DARK_GREEN,   0,  80,  14,  25, STR_SORT_BY,                 STR_SORT_ORDER_TIP},               // BBSW_DROPDOWN_ORDER

   254

{   WWT_DROPDOWN,   RESIZE_NONE,  COLOUR_DARK_GREEN,  81, 199,  14,  25, 0x0,                         STR_SORT_CRITERIA_TIP},            // BBSW_DROPDOWN_CRITERIA

   255

   256

{     WWT_MATRIX, RESIZE_BOTTOM,  COLOUR_DARK_GREEN,   0, 187,  26, 113, 0x401,                       STR_101F_BRIDGE_SELECTION_CLICK},  // BBSW_BRIDGE_LIST

   257

{  WWT_SCROLLBAR, RESIZE_BOTTOM,  COLOUR_DARK_GREEN, 188, 199,  26, 101, 0x0,                         STR_0190_SCROLL_BAR_SCROLLS_LIST}, // BBSW_SCROLLBAR

   258

{  WWT_RESIZEBOX,     RESIZE_TB,  COLOUR_DARK_GREEN, 188, 199, 102, 113, 0x0,                         STR_RESIZE_BUTTON},                // BBSW_RESIZEBOX

   259

{   WIDGETS_END},

   260

};

   261

   262

/* Window definition for the rail bridge selection window */

   263

static const WindowDesc _build_bridge_desc = {

   264

	WDP_AUTO, WDP_AUTO, 200, 114, 200, 114,

   265

	WC_BUILD_BRIDGE, WC_BUILD_TOOLBAR,

   266

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_RESIZABLE,

   267

	_build_bridge_widgets,

   268

};

   269

   270

/**

   271

 * Prepare the data for the build a bridge window.

   272

 *  If we can't build a bridge under the given conditions

   273

 *  show an error message.

   274

 *

   275

 * @parma start The start tile of the bridge

   276

 * @param end The end tile of the bridge

   277

 * @param transport_type The transport type

   278

 * @param road_rail_type The road/rail type

   279

 */

   280

void ShowBuildBridgeWindow(TileIndex start, TileIndex end, TransportType transport_type, byte road_rail_type)

   281

{

   282

	DeleteWindowById(WC_BUILD_BRIDGE, 0);

   283

   284

	/* Data type for the bridge.

   285

	 * Bit 16,15 = transport type,

   286

	 *     14..8 = road/rail types,

   287

	 *      7..0 = type of bridge */

   288

	uint32 type = (transport_type << 15) | (road_rail_type << 8);

   289

   290

	/* only query bridge building possibility once, result is the same for all bridges!

   291

	 * returns CMD_ERROR on failure, and price on success */

   292

	StringID errmsg = INVALID_STRING_ID;

   293

	CommandCost ret = DoCommand(end, start, type, DC_AUTO | DC_QUERY_COST, CMD_BUILD_BRIDGE);

   294

   295

	GUIBridgeList *bl = NULL;

   296

	if (CmdFailed(ret)) {

   297

		errmsg = _error_message;

   298

	} else {

   299

		/* check which bridges can be built

   300

		 * get absolute bridge length

   301

		 * length of the middle parts of the bridge */

   302

		const uint bridge_len = GetTunnelBridgeLength(start, end);

   303

		/* total length of bridge */

   304

		const uint tot_bridgedata_len = CalcBridgeLenCostFactor(bridge_len + 2);

   305

   306

		bl = new GUIBridgeList();

   307

   308

		/* loop for all bridgetypes */

   309

		for (BridgeType brd_type = 0; brd_type != MAX_BRIDGES; brd_type++) {

   310

			if (CheckBridge_Stuff(brd_type, bridge_len)) {

   311

				/* bridge is accepted, add to list */

   312

				BuildBridgeData *item = bl->Append();

   313

				item->index = brd_type;

   314

				item->spec = GetBridgeSpec(brd_type);

   315

				/* Add to terraforming & bulldozing costs the cost of the

   316

				 * bridge itself (not computed with DC_QUERY_COST) */

   317

				item->cost = ret.GetCost() + (((int64)tot_bridgedata_len * _price.build_bridge * item->spec->price) >> 8);

   318

			}

   319

		}

   320

	}

   321

   322

	if (bl != NULL && bl->Length() != 0) {

   323

		new BuildBridgeWindow(&_build_bridge_desc, start, end, type, bl);

   324

	} else {

   325

		if (bl != NULL) delete bl;

   326

		ShowErrorMessage(errmsg, STR_5015_CAN_T_BUILD_BRIDGE_HERE, TileX(end) * TILE_SIZE, TileY(end) * TILE_SIZE);

   327

	}

   328

}