20

#include "sortlist_type.h"

    24

/**

    25

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

    26

 */

    27

struct BuildBridgeData {

    28

	BridgeType index;

    29

	const BridgeSpec *spec;

    30

	Money cost;

    31

};

    33

typedef GUIList<BuildBridgeData> GUIBridgeList;

    35

/**

    36

 * Callback executed after a build Bridge CMD has been called

    37

 *

    38

 * @param scucess True if the build succeded

    39

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

    40

 * @param p1 not used

    41

 * @param p2 not used

    42

 */

    57

class BuildBridgeWindow : public Window {

    58

private:

    59

	/* The last size of the build bridge window

    60

	 * is saved during runtime */

    61

	static uint8 last_size;

    63

	TileIndex start_tile;

    64

	TileIndex end_tile;

    65

	uint32 type;

    66

	const GUIBridgeList *bridges;

    68

	void BuildBridge(uint8 i)

    69

	{

    70

		DoCommandP(this->end_tile, this->start_tile, this->type | this->bridges->sort_list[i].index,

    71

				CcBuildBridge, CMD_BUILD_BRIDGE | CMD_MSG(STR_5015_CAN_T_BUILD_BRIDGE_HERE));

    72

	}

    74

public:

    75

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

    76

		start_tile(start),

    77

		end_tile(end),

    78

		type(br_type),

    79

		bridges(bl)

    80

	{

    82

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

    83

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

    84

    85

		this->resize.step_height = 22;

    86

		this->vscroll.count = bl->list_length;

    87

    88

		if (this->last_size <= 4) {

    89

			this->vscroll.cap = 4;

    90

		} else {

    91

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

    92

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

    93

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

    94

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

    97

		this->FindWindowPlacementAndResize(desc);

    98

	}

   100

	~BuildBridgeWindow()

   101

	{

   102

		free(this->bridges->sort_list);

   103

		delete bridges;

   104

	}

   105

   106

	virtual void OnPaint()

   107

	{

   108

		this->DrawWidgets();

   109

   110

		uint y = 15;

   111

		for (uint i = 0; (i < this->vscroll.cap) && ((i + this->vscroll.pos) < this->bridges->list_length); i++) {

   112

			const BridgeSpec *b = this->bridges->sort_list[i + this->vscroll.pos].spec;

   113

   114

			SetDParam(2, this->bridges->sort_list[i + this->vscroll.pos].cost);

   115

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

   116

			SetDParam(0, b->material);

   117

   118

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

   119

			DrawString(44, y, STR_500D, TC_FROMSTRING);

   120

			y += this->resize.step_height;

   122

	}

   124

	virtual bool OnKeyPress(uint16 key, uint16 keycode)

   125

	{

   126

		const uint8 i = keycode - '1';

   127

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

   128

			/* Build the requested bridge */

   129

			this->BuildBridge(i);

   130

			delete this;

   131

			return false;

   132

		}

   133

		return true;

   134

	}

   135

   136

	virtual void OnClick(Point pt, int widget)

   137

	{

   138

		if (widget == BBSW_BRIDGE_LIST) {

   139

			uint i = ((int)pt.y - 14) / this->resize.step_height;

   140

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

   141

				i += this->vscroll.pos;

   142

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

   143

					this->BuildBridge(i);

   144

					delete this;

   147

		}

   148

	}

   150

	virtual void OnResize(Point new_size, Point delta)

   151

	{

   152

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

   153

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

   154

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

   156

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

   158

};

   159

   160

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

   161

uint8 BuildBridgeWindow::last_size = 4;

   179

	NULL

   182

/**

   183

 * Add a buildable bridge to the list.

   184

 *  If the list is empty a new one is created.

   185

 *

   186

 * @param bl The list which we want to manage

   187

 * @param item The item to add

   188

 * @return The pointer to the list

   189

 */

   190

static GUIBridgeList *PushBridgeList(GUIBridgeList *bl, BuildBridgeData item)

   191

{

   192

	if (bl == NULL) {

   193

		/* Create the list if needed */

   194

		bl = new GUIBridgeList();

   195

		bl->flags |= VL_RESORT;

   196

		bl->list_length = 1;

   197

	} else {

   198

		/* Resize the list */

   199

		bl->list_length++;

   200

	}

   201

   202

	bl->sort_list = ReallocT(bl->sort_list, bl->list_length);

   203

   204

	bl->sort_list[bl->list_length - 1] = item;

   205

   206

	return bl;

   207

}

   208

   209

/**

   210

 * Prepare the data for the build a bridge window.

   211

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

   212

 *  show an error message.

   213

 *

   214

 * @parma start The start tile of the bridge

   215

 * @param end The end tile of the bridge

   216

 * @param transport_type The transport type

   217

 * @param bridge_type The bridge type

   218

 */

   223

	/* Data type for the bridge.

   224

	 * Bit 16,15 = transport type,

   225

	 *     14..8 = road/rail pieces,

   226

	 *      7..0 = type of bridge */

   227

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

   232

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

   234

	GUIBridgeList *bl = NULL;

   249

				BuildBridgeData item;

   250

				item.index = brd_type;

   251

				item.spec = GetBridgeSpec(brd_type);

   254

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

   255

				bl = PushBridgeList(bl, item);

   260

	if (bl != NULL) {

   261

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