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 "table/strings.h"

     8

#include "strings.h"

     9

#include "functions.h"

    10

#include "map.h"

    11

#include "window.h"

    12

#include "gui.h"

    13

#include "viewport.h"

    14

#include "gfx.h"

    15

#include "command.h"

    16

#include "sound.h"

    17

#include "variables.h"

    18

#include "bridge.h"

    19

    20

static struct BridgeData {

    21

	uint count;

    22

	TileIndex start_tile;

    23

	TileIndex end_tile;

    24

	byte type;

    25

	byte indexes[MAX_BRIDGES];

    26

	Money costs[MAX_BRIDGES];

    27

} _bridgedata;

    28

    29

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

    30

{

    31

	if (success) SndPlayTileFx(SND_27_BLACKSMITH_ANVIL, tile);

    32

}

    33

    34

static void BuildBridge(Window *w, int i)

    35

{

    36

	DeleteWindow(w);

    37

	DoCommandP(_bridgedata.end_tile, _bridgedata.start_tile,

    38

		_bridgedata.indexes[i] | (_bridgedata.type << 8), CcBuildBridge,

    39

		CMD_BUILD_BRIDGE | CMD_MSG(STR_5015_CAN_T_BUILD_BRIDGE_HERE));

    40

}

    41

    42

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

    43

{

    44

	switch (e->event) {

    45

		case WE_PAINT:

    46

			DrawWindowWidgets(w);

    47

    48

			for (uint i = 0; i < 4 && i + w->vscroll.pos < _bridgedata.count; i++) {

    49

				const Bridge *b = &_bridge[_bridgedata.indexes[i + w->vscroll.pos]];

    50

    51

				SetDParam(2, _bridgedata.costs[i + w->vscroll.pos]);

    52

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

    53

				SetDParam(0, b->material);

    54

				DrawSprite(b->sprite, b->pal, 3, 15 + i * 22);

    55

    56

				DrawString(44, 15 + i * 22 , STR_500D, 0);

    57

			}

    58

			break;

    59

    60

		case WE_KEYPRESS: {

    61

			uint i = e->we.keypress.keycode - '1';

    62

			if (i < 9 && i < _bridgedata.count) {

    63

				e->we.keypress.cont = false;

    64

				BuildBridge(w, i);

    65

			}

    66

    67

			break;

    68

		}

    69

    70

		case WE_CLICK:

    71

			if (e->we.click.widget == 2) {

    72

				uint ind = ((int)e->we.click.pt.y - 14) / 22;

    73

				if (ind < 4 && (ind += w->vscroll.pos) < _bridgedata.count)

    74

					BuildBridge(w, ind);

    75

			}

    76

			break;

    77

	}

    78

}

    79

    80

static const Widget _build_bridge_widgets[] = {

    81

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

    82

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

    83

{     WWT_MATRIX,   RESIZE_NONE,     7,     0,   187,    14,   101, 0x401,                       STR_101F_BRIDGE_SELECTION_CLICK},

    84

{  WWT_SCROLLBAR,   RESIZE_NONE,     7,   188,   199,    14,   101, 0x0,                         STR_0190_SCROLL_BAR_SCROLLS_LIST},

    85

{   WIDGETS_END},

    86

};

    87

    88

static const WindowDesc _build_bridge_desc = {

    89

	WDP_AUTO, WDP_AUTO, 200, 102, 200, 102,

    90

	WC_BUILD_BRIDGE, WC_BUILD_TOOLBAR,

    91

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

    92

	_build_bridge_widgets,

    93

	BuildBridgeWndProc

    94

};

    95

    96

    97

static const Widget _build_road_bridge_widgets[] = {

    98

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

    99

{    WWT_CAPTION,   RESIZE_NONE,     7,    11,   199,     0,    13, STR_1803_SELECT_ROAD_BRIDGE, STR_018C_WINDOW_TITLE_DRAG_THIS},

   100

{     WWT_MATRIX,   RESIZE_NONE,     7,     0,   187,    14,   101, 0x401,                       STR_101F_BRIDGE_SELECTION_CLICK},

   101

{  WWT_SCROLLBAR,   RESIZE_NONE,     7,   188,   199,    14,   101, 0x0,                         STR_0190_SCROLL_BAR_SCROLLS_LIST},

   102

{   WIDGETS_END},

   103

};

   104

   105

static const WindowDesc _build_road_bridge_desc = {

   106

	WDP_AUTO, WDP_AUTO, 200, 102, 200, 102,

   107

	WC_BUILD_BRIDGE, WC_BUILD_TOOLBAR,

   108

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   109

	_build_road_bridge_widgets,

   110

	BuildBridgeWndProc

   111

};

   112

   113

   114

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

   115

{

   116

	uint j = 0;

   117

	CommandCost ret;

   118

	StringID errmsg;

   119

   120

	DeleteWindowById(WC_BUILD_BRIDGE, 0);

   121

   122

	_bridgedata.type = bridge_type;

   123

	_bridgedata.start_tile = start;

   124

	_bridgedata.end_tile = end;

   125

   126

	errmsg = INVALID_STRING_ID;

   127

   128

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

   129

	// returns CMD_ERROR on failure, and price on success

   130

	ret = DoCommand(end, start, (bridge_type << 8), DC_AUTO | DC_QUERY_COST, CMD_BUILD_BRIDGE);

   131

   132

	if (CmdFailed(ret)) {

   133

		errmsg = _error_message;

   134

	} else {

   135

		// check which bridges can be built

   136

		// get absolute bridge length

   137

		// length of the middle parts of the bridge

   138

		int bridge_len = GetBridgeLength(start, end);

   139

		// total length of bridge

   140

		int tot_bridgedata_len = bridge_len + 2;

   141

   142

		tot_bridgedata_len = CalcBridgeLenCostFactor(tot_bridgedata_len);

   143

   144

		for (bridge_type = 0; bridge_type != MAX_BRIDGES; bridge_type++) { // loop for all bridgetypes

   145

			if (CheckBridge_Stuff(bridge_type, bridge_len)) {

   146

				const Bridge *b = &_bridge[bridge_type];

   147

				// bridge is accepted, add to list

   148

				// add to terraforming & bulldozing costs the cost of the bridge itself (not computed with DC_QUERY_COST)

   149

				_bridgedata.costs[j] = ret.GetCost() + (((int64)tot_bridgedata_len * _price.build_bridge * b->price) >> 8);

   150

				_bridgedata.indexes[j] = bridge_type;

   151

				j++;

   152

			}

   153

		}

   154

	}

   155

   156

	_bridgedata.count = j;

   157

   158

	if (j != 0) {

   159

		Window *w = AllocateWindowDesc((_bridgedata.type & 0x80) ? &_build_road_bridge_desc : &_build_bridge_desc);

   160

		w->vscroll.cap = 4;

   161

		w->vscroll.count = (byte)j;

   162

	} else {

   163

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

   164

	}

   165

}