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

/* Save the sorting during runtime */

    26

static Listing _bridge_sorting = {false, 0};

    27

    28

/**

    29

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

    30

 */

    31

struct BuildBridgeData {

    32

	BridgeType index;

    33

	const BridgeSpec *spec;

    34

	Money cost;

    35

};

    36

    37

typedef GUIList<BuildBridgeData> GUIBridgeList;

    38

    39

/** Sort the bridges by their index */

    40

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

    41

{

    42

	const BuildBridgeData* ba = (BuildBridgeData*)a;

    43

	const BuildBridgeData* bb = (BuildBridgeData*)b;

    44

	int r = ba->index - bb->index;

    45

    46

	return (_bridge_sorting.order) ? -r : r;

    47

}

    48

    49

/** Sort the bridges by their price */

    50

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

    51

{

    52

	const BuildBridgeData* ba = (BuildBridgeData*)a;

    53

	const BuildBridgeData* bb = (BuildBridgeData*)b;

    54

	int r = ba->cost - bb->cost;

    55

    56

	return (_bridge_sorting.order) ? -r : r;

    57

}

    58

    59

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

    60

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

    61

{

    62

	const BuildBridgeData* ba = (BuildBridgeData*)a;

    63

	const BuildBridgeData* bb = (BuildBridgeData*)b;

    64

	int r = ba->spec->speed - bb->spec->speed;

    65

    66

	return (_bridge_sorting.order) ? -r : r;

    67

}

    68

    69

typedef int CDECL BridgeSortListingTypeFunction(const void*, const void*);

    70

    71

/* Availible bridge sorting functions */

    72

static BridgeSortListingTypeFunction* const _bridge_sorter[] = {

    73

	&BridgeIndexSorter,

    74

	&BridgePriceSorter,

    75

	&BridgeSpeedSorter

    76

};

    77

    78

/* Names of the sorting functions */

    79

static const StringID _bridge_sort_listing[] = {

    80

	STR_SORT_BY_NUMBER,

    81

	STR_ENGINE_SORT_COST,

    82

	STR_SORT_BY_MAX_SPEED,

    83

	INVALID_STRING_ID

    84

};

    85

    86

/**

    87

 * Callback executed after a build Bridge CMD has been called

    88

 *

    89

 * @param scucess True if the build succeded

    90

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

    91

 * @param p1 not used

    92

 * @param p2 not used

    93

 */

    94

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

    95

{

    96

	if (success) SndPlayTileFx(SND_27_BLACKSMITH_ANVIL, tile);

    97

}

    98

    99

/* Names of the build bridge selection window */

   100

enum BuildBridgeSelectionWidgets {

   101

	BBSW_CLOSEBOX = 0,

   102

	BBSW_CAPTION,

   103

	BBSW_DROPDOWN_ORDER,

   104

	BBSW_DROPDOWN_CRITERIA,

   105

	BBSW_BRIDGE_LIST,

   106

	BBSW_SCROLLBAR,

   107

	BBSW_RESIZEBOX

   108

};

   109

   110

class BuildBridgeWindow : public Window {

   111

private:

   112

	/* The last size of the build bridge window

   113

	 * is saved during runtime */

   114

	static uint last_size;

   115

   116

	TileIndex start_tile;

   117

	TileIndex end_tile;

   118

	uint32 type;

   119

	GUIBridgeList *bridges;

   120

   121

	void BuildBridge(uint8 i)

   122

	{

   124

				CcBuildBridge, CMD_BUILD_BRIDGE | CMD_MSG(STR_5015_CAN_T_BUILD_BRIDGE_HERE));

   125

	}

   126

   127

	/** Sort the builable bridges */

   128

	void SortBridgeList()

   129

	{

   130

		/* Skip sorting if resort bit is not set */

   131

		if (!(bridges->flags & VL_RESORT)) return;

   132

   134

   135

		/* Display the current sort variant */

   136

		this->widget[BBSW_DROPDOWN_CRITERIA].data = _bridge_sort_listing[this->bridges->sort_type];

   137

   138

		bridges->flags &= ~VL_RESORT;

   139

   140

		/* Set the modified widgets dirty */

   141

		this->InvalidateWidget(BBSW_DROPDOWN_CRITERIA);

   142

		this->InvalidateWidget(BBSW_BRIDGE_LIST);

   143

	}

   144

   145

public:

   146

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

   147

		start_tile(start),

   148

		end_tile(end),

   149

		type(br_type),

   150

		bridges(bl)

   151

	{

   152

		this->SortBridgeList();

   153

   154

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

   155

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

   156

   157

		this->resize.step_height = 22;

   159

   160

		if (this->last_size <= 4) {

   161

			this->vscroll.cap = 4;

   162

		} else {

   163

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

   164

			this->vscroll.cap = (this->vscroll.count > this->last_size) ? this->last_size : this->vscroll.count;

   165

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

   166

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

   167

		}

   168

   169

		this->FindWindowPlacementAndResize(desc);

   170

	}

   171

   172

	~BuildBridgeWindow()

   173

	{

   174

		delete bridges;

   175

	}

   176

   177

	virtual void OnPaint()

   178

	{

   179

		this->DrawWidgets();

   180

   181

		this->DrawSortButtonState(BBSW_DROPDOWN_ORDER, (this->bridges->flags & VL_DESC) ? SBS_DOWN : SBS_UP);

   182

   183

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

   184

   187

   189

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

   190

			SetDParam(0, b->material);

   191

   192

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

   193

			DrawString(44, y, STR_500D, TC_FROMSTRING);

   194

			y += this->resize.step_height;

   195

   196

		}

   197

	}

   198

   199

	virtual EventState OnKeyPress(uint16 key, uint16 keycode)

   200

	{

   201

		const uint8 i = keycode - '1';

   203

			/* Build the requested bridge */

   204

			this->BuildBridge(i);

   205

			delete this;

   206

			return ES_HANDLED;

   207

		}

   208

		return ES_NOT_HANDLED;

   209

	}

   210

   211

	virtual void OnClick(Point pt, int widget)

   212

	{

   213

		switch (widget) {

   214

			default: break;

   215

			case BBSW_BRIDGE_LIST: {

   216

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

   217

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

   218

					i += this->vscroll.pos;

   220

						this->BuildBridge(i);

   221

						delete this;

   222

					}

   223

				}

   224

			} break;

   225

   226

			case BBSW_DROPDOWN_ORDER:

   227

				/* Revers the sort order */

   228

				this->bridges->flags ^= VL_DESC;

   229

				_bridge_sorting.order = !_bridge_sorting.order;

   230

   231

				this->bridges->flags |= VL_RESORT;

   232

				this->SortBridgeList();

   233

				break;

   234

   235

			case BBSW_DROPDOWN_CRITERIA:

   236

				ShowDropDownMenu(this, _bridge_sort_listing, bridges->sort_type, BBSW_DROPDOWN_CRITERIA, 0, 0);

   237

				break;

   238

		}

   239

	}

   240

   241

	virtual void OnDropdownSelect(int widget, int index)

   242

	{

   243

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

   244

			this->bridges->sort_type = index;

   245

			_bridge_sorting.criteria = index;

   246

   247

			this->bridges->flags |= VL_RESORT;

   248

			this->SortBridgeList();

   249

		}

   250

	}

   251

   252

	virtual void OnResize(Point new_size, Point delta)

   253

	{

   254

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

   255

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

   257

   258

		this->last_size = this->vscroll.cap;

   259

	}

   260

};

   261

   262

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

   263

uint BuildBridgeWindow::last_size = 4;

   264

   265

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

   266

static const Widget _build_bridge_widgets[] = {

   267

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

   268

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

   269

   270

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

   271

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

   272

   273

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

   274

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

   275

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

   276

{   WIDGETS_END},

   277

};

   278

   279

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

   280

static const WindowDesc _build_bridge_desc = {

   281

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

   282

	WC_BUILD_BRIDGE, WC_BUILD_TOOLBAR,

   283

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_RESIZABLE,

   284

	_build_bridge_widgets,

   285

};

   286

   287

/**

   288

 * Prepare the data for the build a bridge window.

   289

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

   290

 *  show an error message.

   291

 *

   292

 * @parma start The start tile of the bridge

   293

 * @param end The end tile of the bridge

   294

 * @param transport_type The transport type

   295

 * @param bridge_type The bridge type

   296

 */

   297

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

   298

{

   299

	DeleteWindowById(WC_BUILD_BRIDGE, 0);

   300

   301

	/* Data type for the bridge.

   302

	 * Bit 16,15 = transport type,

   303

	 *     14..8 = road/rail pieces,

   304

	 *      7..0 = type of bridge */

   305

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

   306

   307

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

   308

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

   309

	StringID errmsg = INVALID_STRING_ID;

   310

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

   311

   312

	GUIBridgeList *bl = NULL;

   313

	if (CmdFailed(ret)) {

   314

		errmsg = _error_message;

   315

	} else {

   316

		/* check which bridges can be built

   317

		 * get absolute bridge length

   318

		 * length of the middle parts of the bridge */

   319

		const uint bridge_len = GetTunnelBridgeLength(start, end);

   320

		/* total length of bridge */

   321

		const uint tot_bridgedata_len = CalcBridgeLenCostFactor(bridge_len + 2);

   322

   325

		/* loop for all bridgetypes */

   326

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

   327

			if (CheckBridge_Stuff(brd_type, bridge_len)) {

   328

				/* bridge is accepted, add to list */

   332

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

   333

				 * bridge itself (not computed with DC_QUERY_COST) */

   335

			}

   336

		}

   337

	}

   338

   340

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

   341

	} else {

   343

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

   344

	}

   345

}