1

/* $Id$ */

     2

     3

/** @file terraform_gui.cpp GUI related to terraforming the map. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "bridge_map.h"

     8

#include "clear_map.h"

     9

#include "player_func.h"

    10

#include "player_base.h"

    11

#include "gui.h"

    12

#include "window_gui.h"

    13

#include "viewport_func.h"

    14

#include "gfx_func.h"

    15

#include "command_func.h"

    16

#include "signs_func.h"

    17

#include "variables.h"

    18

#include "functions.h"

    19

#include "sound_func.h"

    20

#include "station_base.h"

    21

#include "unmovable_map.h"

    22

#include "textbuf_gui.h"

    23

#include "genworld.h"

    24

#include "settings_type.h"

    25

#include "tree_map.h"

    26

#include "landscape_type.h"

    27

#include "tilehighlight_func.h"

    28

    29

#include "table/sprites.h"

    30

#include "table/strings.h"

    31

    32

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

    33

{

    34

	if (success) {

    35

		SndPlayTileFx(SND_1F_SPLAT, tile);

    36

	} else {

    37

		extern TileIndex _terraform_err_tile;

    38

		SetRedErrorSquare(_terraform_err_tile);

    39

	}

    40

}

    41

    42

    43

/** Scenario editor command that generates desert areas */

    44

static void GenerateDesertArea(TileIndex end, TileIndex start)

    45

{

    46

	int size_x, size_y;

    47

	int sx = TileX(start);

    48

	int sy = TileY(start);

    49

	int ex = TileX(end);

    50

	int ey = TileY(end);

    51

    52

	if (_game_mode != GM_EDITOR) return;

    53

    54

	if (ex < sx) Swap(ex, sx);

    55

	if (ey < sy) Swap(ey, sy);

    56

	size_x = (ex - sx) + 1;

    57

	size_y = (ey - sy) + 1;

    58

    59

	_generating_world = true;

    60

	BEGIN_TILE_LOOP(tile, size_x, size_y, TileXY(sx, sy)) {

    61

		if (GetTileType(tile) != MP_WATER) {

    62

			SetTropicZone(tile, (_ctrl_pressed) ? TROPICZONE_NORMAL : TROPICZONE_DESERT);

    63

			DoCommandP(tile, 0, 0, NULL, CMD_LANDSCAPE_CLEAR);

    64

			MarkTileDirtyByTile(tile);

    65

		}

    66

	} END_TILE_LOOP(tile, size_x, size_y, 0);

    67

	_generating_world = false;

    68

}

    69

    70

/** Scenario editor command that generates rocky areas */

    71

static void GenerateRockyArea(TileIndex end, TileIndex start)

    72

{

    73

	int size_x, size_y;

    74

	bool success = false;

    75

	int sx = TileX(start);

    76

	int sy = TileY(start);

    77

	int ex = TileX(end);

    78

	int ey = TileY(end);

    79

    80

	if (_game_mode != GM_EDITOR) return;

    81

    82

	if (ex < sx) Swap(ex, sx);

    83

	if (ey < sy) Swap(ey, sy);

    84

	size_x = (ex - sx) + 1;

    85

	size_y = (ey - sy) + 1;

    86

    87

	BEGIN_TILE_LOOP(tile, size_x, size_y, TileXY(sx, sy)) {

    88

		switch (GetTileType(tile)) {

    89

			case MP_TREES:

    90

				if (GetTreeGround(tile) == TREE_GROUND_SHORE) continue;

    91

			/* FALL THROUGH */

    92

			case MP_CLEAR:

    93

				MakeClear(tile, CLEAR_ROCKS, 3);

    94

				break;

    95

    96

			default: continue;

    97

		}

    98

		MarkTileDirtyByTile(tile);

    99

		success = true;

   100

	} END_TILE_LOOP(tile, size_x, size_y, 0);

   101

   102

	if (success) SndPlayTileFx(SND_1F_SPLAT, end);

   103

}

   104

   105

/**

   106

 * A central place to handle all X_AND_Y dragged GUI functions.

   107

 * @param e WindowEvent variable holding in its higher bits (excluding the lower

   108

 * 4, since that defined the X_Y drag) the type of action to be performed

   109

 * @return Returns true if the action was found and handled, and false otherwise. This

   110

 * allows for additional implements that are more local. For example X_Y drag

   111

 * of convertrail which belongs in rail_gui.cpp and not terraform_gui.cpp

   112

 **/

   113

bool GUIPlaceProcDragXY(ViewportDragDropSelectionProcess proc, TileIndex start_tile, TileIndex end_tile)

   114

{

   115

	switch (proc) {

   116

		case DDSP_DEMOLISH_AREA:

   117

			DoCommandP(end_tile, start_tile, 0, CcPlaySound10, CMD_CLEAR_AREA | CMD_MSG(STR_00B5_CAN_T_CLEAR_THIS_AREA));

   118

			break;

   119

		case DDSP_RAISE_AND_LEVEL_AREA:

   120

			DoCommandP(end_tile, start_tile, 1, CcTerraform, CMD_LEVEL_LAND | CMD_MSG(STR_0808_CAN_T_RAISE_LAND_HERE));

   121

			break;

   122

		case DDSP_LOWER_AND_LEVEL_AREA:

   123

			DoCommandP(end_tile, start_tile, (uint32)-1, CcTerraform, CMD_LEVEL_LAND | CMD_MSG(STR_0809_CAN_T_LOWER_LAND_HERE));

   124

			break;

   125

		case DDSP_LEVEL_AREA:

   126

			DoCommandP(end_tile, start_tile, 0, CcPlaySound10, CMD_LEVEL_LAND);

   127

			break;

   128

		case DDSP_CREATE_ROCKS:

   129

			GenerateRockyArea(end_tile, start_tile);

   130

			break;

   131

		case DDSP_CREATE_DESERT:

   132

			GenerateDesertArea(end_tile, start_tile);

   133

			break;

   134

		default:

   135

			return false;

   136

	}

   137

   138

	return true;

   139

}

   140

   141

typedef void OnButtonClick(Window *w);

   142

   143

static const uint16 _terraform_keycodes[] = {

   144

	'Q',

   145

	'W',

   146

	'E',

   147

	'D',

   148

	'U',

   149

	'I',

   150

	'O',

   151

};

   152

   153

void CcPlaySound1E(bool success, TileIndex tile, uint32 p1, uint32 p2);

   154

   155

static void PlaceProc_BuyLand(TileIndex tile)

   156

{

   157

	DoCommandP(tile, 0, 0, CcPlaySound1E, CMD_PURCHASE_LAND_AREA | CMD_NO_WATER | CMD_MSG(STR_5806_CAN_T_PURCHASE_THIS_LAND));

   158

}

   159

   160

void PlaceProc_DemolishArea(TileIndex tile)

   161

{

   162

	VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_DEMOLISH_AREA);

   163

}

   164

   165

static void PlaceProc_RaiseLand(TileIndex tile)

   166

{

   167

	VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_RAISE_AND_LEVEL_AREA);

   168

}

   169

   170

static void PlaceProc_LowerLand(TileIndex tile)

   171

{

   172

	VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_LOWER_AND_LEVEL_AREA);

   173

}

   174

   175

static void PlaceProc_LevelLand(TileIndex tile)

   176

{

   177

	VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_LEVEL_AREA);

   178

}

   179

   180

/** Enum referring to the widgets of the terraform toolbar */

   181

enum TerraformToolbarWidgets {

   182

	TTW_CLOSEBOX = 0,                     ///< Close window button

   183

	TTW_CAPTION,                          ///< Window caption

   184

	TTW_STICKY,                           ///< Sticky window button

   185

	TTW_SEPERATOR,                        ///< Thin seperator line between level land button and demolish button

   186

	TTW_BUTTONS_START,                    ///< Start of pushable buttons

   187

	TTW_LOWER_LAND = TTW_BUTTONS_START,   ///< Lower land button

   188

	TTW_RAISE_LAND,                       ///< Raise land button

   189

	TTW_LEVEL_LAND,                       ///< Level land button

   190

	TTW_DEMOLISH,                         ///< Demolish aka dynamite button

   191

	TTW_BUY_LAND,                         ///< Buy land button

   192

	TTW_PLANT_TREES,                      ///< Plant trees button (note: opens seperate window, no place-push-button)

   193

	TTW_PLACE_SIGN,                       ///< Place sign button

   194

};

   195

   196

static void TerraformClick_Lower(Window *w)

   197

{

   198

	HandlePlacePushButton(w, TTW_LOWER_LAND, ANIMCURSOR_LOWERLAND, VHM_POINT, PlaceProc_LowerLand);

   199

}

   200

   201

static void TerraformClick_Raise(Window *w)

   202

{

   203

	HandlePlacePushButton(w, TTW_RAISE_LAND, ANIMCURSOR_RAISELAND, VHM_POINT, PlaceProc_RaiseLand);

   204

}

   205

   206

static void TerraformClick_Level(Window *w)

   207

{

   208

	HandlePlacePushButton(w, TTW_LEVEL_LAND, SPR_CURSOR_LEVEL_LAND, VHM_POINT, PlaceProc_LevelLand);

   209

}

   210

   211

static void TerraformClick_Dynamite(Window *w)

   212

{

   213

	HandlePlacePushButton(w, TTW_DEMOLISH, ANIMCURSOR_DEMOLISH , VHM_RECT, PlaceProc_DemolishArea);

   214

}

   215

   216

static void TerraformClick_BuyLand(Window *w)

   217

{

   218

	HandlePlacePushButton(w, TTW_BUY_LAND, SPR_CURSOR_BUY_LAND, VHM_RECT, PlaceProc_BuyLand);

   219

}

   220

   221

static void TerraformClick_Trees(Window *w)

   222

{

   223

	/* This button is NOT a place-push-button, so don't treat it as such */

   224

	ShowBuildTreesToolbar();

   225

}

   226

   227

static void TerraformClick_PlaceSign(Window *w)

   228

{

   229

	HandlePlacePushButton(w, TTW_PLACE_SIGN, SPR_CURSOR_SIGN, VHM_RECT, PlaceProc_Sign);

   230

}

   231

   232

static OnButtonClick * const _terraform_button_proc[] = {

   233

	TerraformClick_Lower,

   234

	TerraformClick_Raise,

   235

	TerraformClick_Level,

   236

	TerraformClick_Dynamite,

   237

	TerraformClick_BuyLand,

   238

	TerraformClick_Trees,

   239

	TerraformClick_PlaceSign,

   240

};

   241

   242

struct TerraformToolbarWindow : Window {

   243

	TerraformToolbarWindow(const WindowDesc *desc, WindowNumber window_number) : Window(desc, window_number)

   244

	{

   245

		this->FindWindowPlacementAndResize(desc);

   246

	}

   247

   248

	~TerraformToolbarWindow()

   249

	{

   250

	}

   251

   252

	virtual void OnPaint()

   253

	{

   254

		this->DrawWidgets();

   255

	}

   256

   257

	virtual void OnClick(Point pt, int widget)

   258

	{

   259

		if (widget >= TTW_BUTTONS_START) _terraform_button_proc[widget - TTW_BUTTONS_START](this);

   260

	}

   261

   262

	virtual EventState OnKeyPress(uint16 key, uint16 keycode)

   263

	{

   264

		for (uint i = 0; i != lengthof(_terraform_keycodes); i++) {

   265

			if (keycode == _terraform_keycodes[i]) {

   266

				_terraform_button_proc[i](this);

   267

				return ES_HANDLED;

   268

			}

   269

		}

   270

		return ES_NOT_HANDLED;

   271

	}

   272

   273

	virtual void OnPlaceObject(Point pt, TileIndex tile)

   274

	{

   275

		_place_proc(tile);

   276

	}

   277

   278

	virtual void OnPlaceDrag(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt)

   279

	{

   280

		VpSelectTilesWithMethod(pt.x, pt.y, select_method);

   281

	}

   282

   283

	virtual void OnPlaceMouseUp(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt, TileIndex start_tile, TileIndex end_tile)

   284

	{

   285

		if (pt.x != -1) {

   286

			switch (select_proc) {

   287

				default: NOT_REACHED();

   288

				case DDSP_DEMOLISH_AREA:

   289

				case DDSP_RAISE_AND_LEVEL_AREA:

   290

				case DDSP_LOWER_AND_LEVEL_AREA:

   291

				case DDSP_LEVEL_AREA:

   292

					GUIPlaceProcDragXY(select_proc, start_tile, end_tile);

   293

					break;

   294

			}

   295

		}

   296

	}

   297

   298

	virtual void OnPlaceObjectAbort()

   299

	{

   300

		this->RaiseButtons();

   301

	}

   302

};

   303

   304

static const Widget _terraform_widgets[] = {

   305

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

   306

{  WWT_CAPTION,   RESIZE_NONE,     7,  11, 145,   0,  13, STR_LANDSCAPING_TOOLBAR, STR_018C_WINDOW_TITLE_DRAG_THIS},   // TTW_CAPTION

   307

{WWT_STICKYBOX,   RESIZE_NONE,     7, 146, 157,   0,  13, STR_NULL,                STR_STICKY_BUTTON},                 // TTW_STICKY

   308

   309

{    WWT_PANEL,   RESIZE_NONE,     7,  66,  69,  14,  35, 0x0,                    STR_NULL},                           // TTW_SEPERATOR

   310

{   WWT_IMGBTN,   RESIZE_NONE,     7,   0,  21,  14,  35, SPR_IMG_TERRAFORM_DOWN,  STR_018E_LOWER_A_CORNER_OF_LAND},   // TTW_LOWER_LAND

   311

{   WWT_IMGBTN,   RESIZE_NONE,     7,  22,  43,  14,  35, SPR_IMG_TERRAFORM_UP,    STR_018F_RAISE_A_CORNER_OF_LAND},   // TTW_RAISE_LAND

   312

{   WWT_IMGBTN,   RESIZE_NONE,     7,  44,  65,  14,  35, SPR_IMG_LEVEL_LAND,      STR_LEVEL_LAND_TOOLTIP},            // TTW_LEVEL_LAND

   313

{   WWT_IMGBTN,   RESIZE_NONE,     7,  70,  91,  14,  35, SPR_IMG_DYNAMITE,        STR_018D_DEMOLISH_BUILDINGS_ETC},   // TTW_DEMOLISH

   314

{   WWT_IMGBTN,   RESIZE_NONE,     7,  92, 113,  14,  35, SPR_IMG_BUY_LAND,        STR_0329_PURCHASE_LAND_FOR_FUTURE}, // TTW_BUY_LAND

   315

{   WWT_IMGBTN,   RESIZE_NONE,     7, 114, 135,  14,  35, SPR_IMG_PLANTTREES,      STR_0185_PLANT_TREES_PLACE_SIGNS},  // TTW_PLANT_TREES

   316

{   WWT_IMGBTN,   RESIZE_NONE,     7, 136, 157,  14,  35, SPR_IMG_SIGN,            STR_0289_PLACE_SIGN},               // TTW_PLACE_SIGN

   317

   318

{   WIDGETS_END},

   319

};

   320

   321

static const WindowDesc _terraform_desc = {

   322

	WDP_ALIGN_TBR, 22 + 36, 158, 36, 158, 36,

   323

	WC_SCEN_LAND_GEN, WC_NONE,

   324

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_STICKY_BUTTON,

   325

	_terraform_widgets,

   326

};

   327

   328

void ShowTerraformToolbar(Window *link)

   329

{

   330

	if (!IsValidPlayer(_current_player)) return;

   331

	Window *w = AllocateWindowDescFront<TerraformToolbarWindow>(&_terraform_desc, 0);

   332

	if (w != NULL && link != NULL) {

   333

		/* Align the terraform toolbar under the main toolbar and put the linked

   334

		 * toolbar to left of it

   335

		 */

   336

		w->top = 22;

   337

		w->SetDirty();

   338

		link->left = w->left - link->width;

   339

		link->SetDirty();

   340

	}

   341

}

   342

   343

static byte _terraform_size = 1;

   344

   345

/**

   346

 * Raise/Lower a bigger chunk of land at the same time in the editor. When

   347

 * raising get the lowest point, when lowering the highest point, and set all

   348

 * tiles in the selection to that height.

   349

 * @todo : Incorporate into game itself to allow for ingame raising/lowering of

   350

 *         larger chunks at the same time OR remove altogether, as we have 'level land' ?

   351

 * @param tile The top-left tile where the terraforming will start

   352

 * @param mode 1 for raising, 0 for lowering land

   353

 */

   354

static void CommonRaiseLowerBigLand(TileIndex tile, int mode)

   355

{

   356

	int sizex, sizey;

   357

	uint h;

   358

   359

	if (_terraform_size == 1) {

   360

		StringID msg =

   361

			mode ? STR_0808_CAN_T_RAISE_LAND_HERE : STR_0809_CAN_T_LOWER_LAND_HERE;

   362

   363

		DoCommandP(tile, SLOPE_N, (uint32)mode, CcTerraform, CMD_TERRAFORM_LAND | CMD_MSG(msg));

   364

	} else {

   365

		assert(_terraform_size != 0);

   366

		/* check out for map overflows */

   367

		sizex = min(MapSizeX() - TileX(tile) - 1, _terraform_size);

   368

		sizey = min(MapSizeY() - TileY(tile) - 1, _terraform_size);

   369

   370

		if (sizex == 0 || sizey == 0) return;

   371

   372

		SndPlayTileFx(SND_1F_SPLAT, tile);

   373

   374

		if (mode != 0) {

   375

			/* Raise land */

   376

			h = 15; // XXX - max height

   377

			BEGIN_TILE_LOOP(tile2, sizex, sizey, tile) {

   378

				h = min(h, TileHeight(tile2));

   379

			} END_TILE_LOOP(tile2, sizex, sizey, tile)

   380

		} else {

   381

			/* Lower land */

   382

			h = 0;

   383

			BEGIN_TILE_LOOP(tile2, sizex, sizey, tile) {

   384

				h = max(h, TileHeight(tile2));

   385

			} END_TILE_LOOP(tile2, sizex, sizey, tile)

   386

		}

   387

   388

		BEGIN_TILE_LOOP(tile2, sizex, sizey, tile) {

   389

			if (TileHeight(tile2) == h) {

   390

				DoCommandP(tile2, SLOPE_N, (uint32)mode, NULL, CMD_TERRAFORM_LAND);

   391

			}

   392

		} END_TILE_LOOP(tile2, sizex, sizey, tile)

   393

	}

   394

}

   395

   396

static void PlaceProc_RaiseBigLand(TileIndex tile)

   397

{

   398

	CommonRaiseLowerBigLand(tile, 1);

   399

}

   400

   401

static void PlaceProc_LowerBigLand(TileIndex tile)

   402

{

   403

	CommonRaiseLowerBigLand(tile, 0);

   404

}

   405

   406

static void PlaceProc_RockyArea(TileIndex tile)

   407

{

   408

	VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_CREATE_ROCKS);

   409

}

   410

   411

static void PlaceProc_LightHouse(TileIndex tile)

   412

{

   413

	/* not flat || not(trees || clear without bridge above) */

   414

	if (GetTileSlope(tile, NULL) != SLOPE_FLAT || !(IsTileType(tile, MP_TREES) || (IsTileType(tile, MP_CLEAR) && !IsBridgeAbove(tile)))) {

   415

		return;

   416

	}

   417

   418

	MakeLighthouse(tile);

   419

	MarkTileDirtyByTile(tile);

   420

	SndPlayTileFx(SND_1F_SPLAT, tile);

   421

}

   422

   423

static void PlaceProc_Transmitter(TileIndex tile)

   424

{

   425

	/* not flat || not(trees || clear without bridge above) */

   426

	if (GetTileSlope(tile, NULL) != SLOPE_FLAT || !(IsTileType(tile, MP_TREES) || (IsTileType(tile, MP_CLEAR) && !IsBridgeAbove(tile)))) {

   427

		return;

   428

	}

   429

   430

	MakeTransmitter(tile);

   431

	MarkTileDirtyByTile(tile);

   432

	SndPlayTileFx(SND_1F_SPLAT, tile);

   433

}

   434

   435

static void PlaceProc_DesertArea(TileIndex tile)

   436

{

   437

	VpStartPlaceSizing(tile, VPM_X_AND_Y, DDSP_CREATE_DESERT);

   438

}

   439

   440

   441

static const Widget _scen_edit_land_gen_widgets[] = {

   442

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

   443

{   WWT_CAPTION,   RESIZE_NONE,     7,    11,   150,     0,    13, STR_0223_LAND_GENERATION,  STR_018C_WINDOW_TITLE_DRAG_THIS},         // ETTW_CAPTION

   444

{ WWT_STICKYBOX,   RESIZE_NONE,     7,   151,   162,     0,    13, STR_NULL,                  STR_STICKY_BUTTON},                       // ETTW_STICKY

   445

{     WWT_PANEL,   RESIZE_NONE,     7,     0,   162,    14,   102, 0x0,                       STR_NULL},                                // ETTW_BACKGROUND

   446

{    WWT_IMGBTN,   RESIZE_NONE,    14,     2,    23,    16,    37, SPR_IMG_DYNAMITE,          STR_018D_DEMOLISH_BUILDINGS_ETC},         // ETTW_DEMOLISH

   447

{    WWT_IMGBTN,   RESIZE_NONE,    14,    24,    45,    16,    37, SPR_IMG_TERRAFORM_DOWN,    STR_018E_LOWER_A_CORNER_OF_LAND},         // ETTW_LOWER_LAND

   448

{    WWT_IMGBTN,   RESIZE_NONE,    14,    46,    67,    16,    37, SPR_IMG_TERRAFORM_UP,      STR_018F_RAISE_A_CORNER_OF_LAND},         // ETTW_RAISE_LAND

   449

{    WWT_IMGBTN,   RESIZE_NONE,    14,    68,    89,    16,    37, SPR_IMG_LEVEL_LAND,        STR_LEVEL_LAND_TOOLTIP},                  // ETTW_LEVEL_LAND

   450

{    WWT_IMGBTN,   RESIZE_NONE,    14,   90,    111,    16,    37, SPR_IMG_ROCKS,             STR_028C_PLACE_ROCKY_AREAS_ON_LANDSCAPE}, // ETTW_PLACE_ROCKS

   451

{    WWT_IMGBTN,   RESIZE_NONE,    14,   112,   133,    16,    37, SPR_IMG_LIGHTHOUSE_DESERT, STR_NULL},                                // ETTW_PLACE_DESERT_LIGHTHOUSE XXX - dynamic

   452

{    WWT_IMGBTN,   RESIZE_NONE,    14,   134,   156,    16,    37, SPR_IMG_TRANSMITTER,       STR_028E_PLACE_TRANSMITTER},              // ETTW_PLACE_TRANSMITTER

   453

{    WWT_IMGBTN,   RESIZE_NONE,    14,   150,   161,    45,    56, SPR_ARROW_UP,              STR_0228_INCREASE_SIZE_OF_LAND_AREA},     // ETTW_INCREASE_SIZE

   454

{    WWT_IMGBTN,   RESIZE_NONE,    14,   150,   161,    58,    69, SPR_ARROW_DOWN,            STR_0229_DECREASE_SIZE_OF_LAND_AREA},     // ETTW_DECREASE_SIZE

   455

{   WWT_TEXTBTN,   RESIZE_NONE,    14,    2,    161,    76,    87, STR_SE_NEW_WORLD,          STR_022A_GENERATE_RANDOM_LAND},           // ETTW_NEW_SCENARIO

   456

{   WWT_TEXTBTN,   RESIZE_NONE,    14,    2,    161,    89,   100, STR_022B_RESET_LANDSCAPE,  STR_RESET_LANDSCAPE_TOOLTIP},             // ETTW_RESET_LANDSCAPE

   457

{   WIDGETS_END},

   458

};

   459

   460

static const int8 _multi_terraform_coords[][2] = {

   461

	{  0, -2},

   462

	{  4,  0}, { -4,  0}, {  0,  2},

   463

	{ -8,  2}, { -4,  4}, {  0,  6}, {  4,  4}, {  8,  2},

   464

	{-12,  0}, { -8, -2}, { -4, -4}, {  0, -6}, {  4, -4}, {  8, -2}, { 12,  0},

   465

	{-16,  2}, {-12,  4}, { -8,  6}, { -4,  8}, {  0, 10}, {  4,  8}, {  8,  6}, { 12,  4}, { 16,  2},

   466

	{-20,  0}, {-16, -2}, {-12, -4}, { -8, -6}, { -4, -8}, {  0,-10}, {  4, -8}, {  8, -6}, { 12, -4}, { 16, -2}, { 20,  0},

   467

	{-24,  2}, {-20,  4}, {-16,  6}, {-12,  8}, { -8, 10}, { -4, 12}, {  0, 14}, {  4, 12}, {  8, 10}, { 12,  8}, { 16,  6}, { 20,  4}, { 24,  2},

   468

	{-28,  0}, {-24, -2}, {-20, -4}, {-16, -6}, {-12, -8}, { -8,-10}, { -4,-12}, {  0,-14}, {  4,-12}, {  8,-10}, { 12, -8}, { 16, -6}, { 20, -4}, { 24, -2}, { 28,  0},

   469

};

   470

   471

/** Enum referring to the widgets of the editor terraform toolbar */

   472

enum EditorTerraformToolbarWidgets {

   473

	ETTW_START = 0,                        ///< Used for iterations

   474

	ETTW_CLOSEBOX = ETTW_START,            ///< Close window button

   475

	ETTW_CAPTION,                          ///< Window caption

   476

	ETTW_STICKY,                           ///< Sticky window button

   477

	ETTW_BACKGROUND,                       ///< Background of the lower part of the window

   478

	ETTW_BUTTONS_START,                    ///< Start of pushable buttons

   479

	ETTW_DEMOLISH = ETTW_BUTTONS_START,    ///< Demolish aka dynamite button

   480

	ETTW_LOWER_LAND,                       ///< Lower land button

   481

	ETTW_RAISE_LAND,                       ///< Raise land button

   482

	ETTW_LEVEL_LAND,                       ///< Level land button

   483

	ETTW_PLACE_ROCKS,                      ///< Place rocks button

   484

	ETTW_PLACE_DESERT_LIGHTHOUSE,          ///< Place desert button (in tropical climate) / place lighthouse button (else)

   485

	ETTW_PLACE_TRANSMITTER,                ///< Place transmitter button

   486

	ETTW_BUTTONS_END,                      ///< End of pushable buttons

   487

	ETTW_INCREASE_SIZE = ETTW_BUTTONS_END, ///< Upwards arrow button to increase terraforming size

   488

	ETTW_DECREASE_SIZE,                    ///< Downwards arrow button to decrease terraforming size

   489

	ETTW_NEW_SCENARIO,                     ///< Button for generating a new scenario

   490

	ETTW_RESET_LANDSCAPE,                  ///< Button for removing all player-owned property