1

/* $Id$ */

     2

     3

/** @file water_cmd.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "bridge_map.h"

     8

#include "bridge.h"

     9

#include "cmd_helper.h"

    10

#include "station_map.h"

    11

#include "tile_cmd.h"

    12

#include "landscape.h"

    13

#include "viewport_func.h"

    14

#include "command_func.h"

    15

#include "town.h"

    16

#include "news.h"

    17

#include "depot.h"

    18

#include "vehicle_gui.h"

    19

#include "train.h"

    20

#include "roadveh.h"

    21

#include "water.h"

    22

#include "water_map.h"

    23

#include "industry_map.h"

    24

#include "newgrf.h"

    25

#include "newgrf_canal.h"

    26

#include "misc/autoptr.hpp"

    27

#include "transparency.h"

    28

#include "strings_func.h"

    29

#include "functions.h"

    30

#include "window_func.h"

    31

#include "vehicle_func.h"

    32

#include "sound_func.h"

    33

#include "variables.h"

    34

#include "player_func.h"

    35

#include "settings_type.h"

    36

#include "clear_map.h"

    37

#include "tree_map.h"

    38

    39

#include "table/sprites.h"

    40

#include "table/strings.h"

    41

    42

/**

    43

 * Describes the behaviour of a tile during flooding.

    44

 */

    45

enum FloodingBehaviour {

    46

	FLOOD_NONE,    ///< The tile does not flood neighboured tiles.

    47

	FLOOD_ACTIVE,  ///< The tile floods neighboured tiles.

    48

	FLOOD_PASSIVE, ///< The tile does not actively flood neighboured tiles, but it prevents them from drying up.

    49

	FLOOD_DRYUP,   ///< The tile drys up if it is not constantly flooded from neighboured tiles.

    50

};

    51

    52

/**

    53

 * Describes from which directions a specific slope can be flooded (if the tile is floodable at all).

    54

 */

    55

static const uint8 _flood_from_dirs[] = {

    56

	(1 << DIR_NW) | (1 << DIR_SW) | (1 << DIR_SE) | (1 << DIR_NE), // SLOPE_FLAT

    57

	(1 << DIR_NE) | (1 << DIR_SE),                                 // SLOPE_W

    58

	(1 << DIR_NW) | (1 << DIR_NE),                                 // SLOPE_S

    59

	(1 << DIR_NE),                                                 // SLOPE_SW

    60

	(1 << DIR_NW) | (1 << DIR_SW),                                 // SLOPE_E

    61

	0,                                                             // SLOPE_EW

    62

	(1 << DIR_NW),                                                 // SLOPE_SE

    63

	(1 << DIR_N ) | (1 << DIR_NW) | (1 << DIR_NE),                 // SLOPE_WSE, SLOPE_STEEP_S

    64

	(1 << DIR_SW) | (1 << DIR_SE),                                 // SLOPE_N

    65

	(1 << DIR_SE),                                                 // SLOPE_NW

    66

	0,                                                             // SLOPE_NS

    67

	(1 << DIR_E ) | (1 << DIR_NE) | (1 << DIR_SE),                 // SLOPE_NWS, SLOPE_STEEP_W

    68

	(1 << DIR_SW),                                                 // SLOPE_NE

    69

	(1 << DIR_S ) | (1 << DIR_SW) | (1 << DIR_SE),                 // SLOPE_ENW, SLOPE_STEEP_N

    70

	(1 << DIR_W ) | (1 << DIR_SW) | (1 << DIR_NW),                 // SLOPE_SEN, SLOPE_STEEP_E

    71

};

    72

    73

/**

    74

 * Marks tile dirty if it is a canal or river tile.

    75

 * Called to avoid glitches when flooding tiles next to canal tile.

    76

 *

    77

 * @param tile tile to check

    78

 */

    79

static inline void MarkTileDirtyIfCanalOrRiver(TileIndex tile)

    80

{

    81

	if (IsTileType(tile, MP_WATER) && (IsCanal(tile) || IsRiver(tile))) MarkTileDirtyByTile(tile);

    82

}

    83

    84

/**

    85

 * Marks the tiles around a tile as dirty, if they are canals or rivers.

    86

 *

    87

 * @param tile The center of the tile where all other tiles are marked as dirty

    88

 * @ingroup dirty

    89

 */

    90

static void MarkCanalsAndRiversAroundDirty(TileIndex tile)

    91

{

    92

	for (Direction dir = DIR_BEGIN; dir < DIR_END; dir++) {

    93

		MarkTileDirtyIfCanalOrRiver(tile + TileOffsByDir(dir));

    94

	}

    95

}

    96

    97

/**

    98

 * Makes a tile canal or water depending on the surroundings.

    99

 * This as for example docks and shipdepots do not store

   100

 * whether the tile used to be canal or 'normal' water.

   101

 * @param t the tile to change.

   102

 * @param o the owner of the new tile.

   103

 */

   105

{

   106

	assert(GetTileSlope(t, NULL) == SLOPE_FLAT);

   107

   108

	/* Mark tile dirty in all cases */

   109

	MarkTileDirtyByTile(t);

   110

   111

	bool has_water = false;

   112

	bool has_canal = false;

   114

   115

	for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {

   116

		TileIndex neighbour = TileAddByDiagDir(t, dir);

   117

		switch (GetTileType(neighbour)) {

   118

			case MP_WATER:

   119

				has_water |= IsSea(neighbour) || IsCoast(neighbour) || (IsShipDepot(neighbour) && GetShipDepotWaterOwner(neighbour) == OWNER_WATER);

   120

				has_canal |= IsCanal(neighbour) || (IsShipDepot(neighbour) && GetShipDepotWaterOwner(neighbour) != OWNER_WATER);

   122

				break;

   123

   124

			case MP_RAILWAY:

   125

				/* Shore or flooded halftile */

   126

				has_water |= (GetRailGroundType(neighbour) == RAIL_GROUND_WATER);

   127

				break;

   128

   129

			case MP_TREES:

   130

				/* trees on shore */

   131

				has_water |= (GetTreeGround(neighbour) == TREE_GROUND_SHORE);

   132

				break;

   133

   134

			default: break;

   135

		}

   136

	}

   142

	} else {

   144

	}

   145

}

   146

   147

   148

/** Build a ship depot.

   149

 * @param tile tile where ship depot is built

   150

 * @param flags type of operation

   151

 * @param p1 bit 0 depot orientation (Axis)

   152

 * @param p2 unused

   153

 */

   154

CommandCost CmdBuildShipDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   155

{

   156

	TileIndex tile2;

   157

   158

	CommandCost ret;

   159

   160

	Axis axis = Extract<Axis, 0>(p1);

   161

   162

	tile2 = tile + (axis == AXIS_X ? TileDiffXY(1, 0) : TileDiffXY(0, 1));

   163

   165

		return_cmd_error(STR_3801_MUST_BE_BUILT_ON_WATER);

   167

   168

	if (IsBridgeAbove(tile) || IsBridgeAbove(tile2)) return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);

   169

   177

	Owner o1 = GetTileOwner(tile);

   178

	Owner o2 = GetTileOwner(tile2);

   179

	ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

   180

	if (CmdFailed(ret)) return CMD_ERROR;

   181

	ret = DoCommand(tile2, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

   182

	if (CmdFailed(ret)) return CMD_ERROR;

   183

   184

	Depot *depot = new Depot(tile);

   185

	if (depot == NULL) return CMD_ERROR;

   186

	AutoPtrT<Depot> d_auto_delete = depot;

   187

   188

	if (flags & DC_EXEC) {

   189

		depot->town_index = ClosestTownFromTile(tile, (uint)-1)->index;

   190

   193

		MarkTileDirtyByTile(tile);

   194

		MarkTileDirtyByTile(tile2);

   195

		d_auto_delete.Detach();

   196

	}

   197

   198

	return CommandCost(EXPENSES_CONSTRUCTION, _price.build_ship_depot);

   199

}

   200

   202

{

   209

	}

   210

}

   211

   212

static CommandCost RemoveShipDepot(TileIndex tile, uint32 flags)

   213

{

   214

	TileIndex tile2;

   215

   216

	if (!IsShipDepot(tile)) return CMD_ERROR;

   217

	if (!CheckTileOwnership(tile)) return CMD_ERROR;

   218

	if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;

   219

   220

	tile2 = GetOtherShipDepotTile(tile);

   221

   222

	if (!EnsureNoVehicleOnGround(tile2)) return CMD_ERROR;

   223

   224

	if (flags & DC_EXEC) {

   225

		/* Kill the depot, which is registered at the northernmost tile. Use that one */

   226

		delete GetDepotByTile(tile2 < tile ? tile2 : tile);

   227

   230

		MarkTileDirtyByTile(tile);

   231

		MarkTileDirtyByTile(tile2);

   232

	}

   233

   234

	return CommandCost(EXPENSES_CONSTRUCTION, _price.remove_ship_depot);

   235

}

   236

   237

/** build a shiplift */

   238

static CommandCost DoBuildShiplift(TileIndex tile, DiagDirection dir, uint32 flags)

   239

{

   240

	CommandCost ret;

   241

	int delta;

   242

   243

	/* middle tile */

   244

	ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

   245

	if (CmdFailed(ret)) return CMD_ERROR;

   246

   247

	delta = TileOffsByDiagDir(dir);

   248

	/* lower tile */

   251

	ret = DoCommand(tile - delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

   252

	if (CmdFailed(ret)) return CMD_ERROR;

   253

	if (GetTileSlope(tile - delta, NULL) != SLOPE_FLAT) {

   254

		return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

   255

	}

   256

   257

	/* upper tile */

   260

	ret = DoCommand(tile + delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

   261

	if (CmdFailed(ret)) return CMD_ERROR;

   262

	if (GetTileSlope(tile + delta, NULL) != SLOPE_FLAT) {

   263

		return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

   264

	}

   265

   266

	if ((MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) ||

   267

	    (MayHaveBridgeAbove(tile - delta) && IsBridgeAbove(tile - delta)) ||

   268

	    (MayHaveBridgeAbove(tile + delta) && IsBridgeAbove(tile + delta))) {

   269

		return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);

   270

	}

   271

   272

	if (flags & DC_EXEC) {

   274

		MarkTileDirtyByTile(tile);

   275

		MarkTileDirtyByTile(tile - delta);

   276

		MarkTileDirtyByTile(tile + delta);

   277

		MarkCanalsAndRiversAroundDirty(tile - delta);

   278

		MarkCanalsAndRiversAroundDirty(tile + delta);

   279

	}

   280

   281

	return CommandCost(EXPENSES_CONSTRUCTION, _price.clear_water * 22 >> 3);

   282

}

   283

   284

static CommandCost RemoveShiplift(TileIndex tile, uint32 flags)

   285

{

   286

	TileIndexDiff delta = TileOffsByDiagDir(GetLockDirection(tile));

   287

   288

	if (!CheckTileOwnership(tile) && GetTileOwner(tile) != OWNER_NONE) return CMD_ERROR;

   289

   290

	/* make sure no vehicle is on the tile. */

   291

	if (!EnsureNoVehicleOnGround(tile) || !EnsureNoVehicleOnGround(tile + delta) || !EnsureNoVehicleOnGround(tile - delta))

   292

		return CMD_ERROR;

   293

   294

	if (flags & DC_EXEC) {

   295

		DoClearSquare(tile);

   300

		MarkCanalsAndRiversAroundDirty(tile - delta);

   301

		MarkCanalsAndRiversAroundDirty(tile + delta);

   302

	}

   303

   304

	return CommandCost(EXPENSES_CONSTRUCTION, _price.clear_water * 2);

   305

}

   306

   307

/** Builds a lock (ship-lift)

   308

 * @param tile tile where to place the lock

   309

 * @param flags type of operation

   310

 * @param p1 unused

   311

 * @param p2 unused

   312

 */

   313

CommandCost CmdBuildLock(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   314

{

   315

	DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile, NULL));

   316

	if (dir == INVALID_DIAGDIR) return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

   317

   318

	/* Disallow building of locks on river rapids */

   320

   321

	return DoBuildShiplift(tile, dir, flags);

   322

}

   323

   324

/** Build a piece of canal.

   325

 * @param tile end tile of stretch-dragging

   326

 * @param flags type of operation

   327

 * @param p1 start tile of stretch-dragging

   328

 * @param p2 specifies canal (0), water (1) or river (2); last two can only be built in scenario editor

   329

 */

   330

CommandCost CmdBuildCanal(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   331

{

   332

	CommandCost cost(EXPENSES_CONSTRUCTION);

   333

	int size_x, size_y;

   334

	int x;

   335

	int y;

   336

	int sx, sy;

   337

   338

	if (p1 >= MapSize()) return CMD_ERROR;

   339

   340

	/* Outside of the editor you can only build canals, not oceans */

   341

	if (p2 != 0 && _game_mode != GM_EDITOR) return CMD_ERROR;

   342

   343

	x = TileX(tile);

   344

	y = TileY(tile);

   345

	sx = TileX(p1);

   346

	sy = TileY(p1);

   347

   348

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

   349

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

   350

	size_x = (x - sx) + 1;

   351

	size_y = (y - sy) + 1;

   352

   353

	/* Outside the editor you can only drag canals, and not areas */

   354

	if (_game_mode != GM_EDITOR && (sx != x && sy != y)) return CMD_ERROR;

   355

   356

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

   357

		CommandCost ret;

   358

   359

		Slope slope = GetTileSlope(tile, NULL);

   360

		if (slope != SLOPE_FLAT && (p2 != 2 || !IsInclinedSlope(slope))) {

   361

			return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);

   362

		}

   363

   364

		/* can't make water of water! */

   365

		if (IsTileType(tile, MP_WATER) && (!IsTileOwner(tile, OWNER_WATER) || p2 == 1)) continue;

   366

   367

		ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

   368

		if (CmdFailed(ret)) return ret;

   369

		cost.AddCost(ret);

   370

   371

		if (flags & DC_EXEC) {

   372

			if (TileHeight(tile) == 0 && p2 == 1) {

   373

				MakeWater(tile);

   374

			} else if (p2 == 2) {

   375

				MakeRiver(tile, Random());

   376

			} else {

   377

				MakeCanal(tile, _current_player, Random());

   378

			}

   379

			MarkTileDirtyByTile(tile);

   380

			MarkCanalsAndRiversAroundDirty(tile);

   381

		}

   382

   383

		cost.AddCost(_price.clear_water);

   384

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

   385

   386

	if (cost.GetCost() == 0) {

   387

		return_cmd_error(STR_1007_ALREADY_BUILT);

   388

	} else {

   389

		return cost;

   390

	}

   391

}

   392

   393

static CommandCost ClearTile_Water(TileIndex tile, byte flags)

   394

{

   395

	switch (GetWaterTileType(tile)) {

   396

		case WATER_TILE_CLEAR:

   397

			if (flags & DC_NO_WATER) return_cmd_error(STR_3807_CAN_T_BUILD_ON_WATER);

   398

   399

			/* Make sure it's not an edge tile. */

   400

			if (!IsInsideMM(TileX(tile), 1, MapMaxX() - 1) ||

   401

					!IsInsideMM(TileY(tile), 1, MapMaxY() - 1)) {

   402

				return_cmd_error(STR_0002_TOO_CLOSE_TO_EDGE_OF_MAP);

   403

			}

   404

   405

			/* Make sure no vehicle is on the tile */

   406

			if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;

   407

   408

			if (GetTileOwner(tile) != OWNER_WATER && GetTileOwner(tile) != OWNER_NONE && !CheckTileOwnership(tile)) return CMD_ERROR;

   409

   410

			if (flags & DC_EXEC) {

   411

				DoClearSquare(tile);

   412

				MarkCanalsAndRiversAroundDirty(tile);

   413

			}

   414

			return CommandCost(EXPENSES_CONSTRUCTION, _price.clear_water);

   415

   416

		case WATER_TILE_COAST: {

   417

			Slope slope = GetTileSlope(tile, NULL);

   418

   419

			/* Make sure no vehicle is on the tile */

   420

			if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;

   421

   422

			if (flags & DC_EXEC) {

   423

				DoClearSquare(tile);

   424

				MarkCanalsAndRiversAroundDirty(tile);

   425

			}

   426

			if (IsSlopeWithOneCornerRaised(slope)) {

   427

				return CommandCost(EXPENSES_CONSTRUCTION, _price.clear_water);

   428

			} else {

   429

				return CommandCost(EXPENSES_CONSTRUCTION, _price.clear_roughland);

   430

			}

   431

		}

   432

   433

		case WATER_TILE_LOCK: {

   434

			static const TileIndexDiffC _shiplift_tomiddle_offs[] = {

   435

				{ 0,  0}, {0,  0}, { 0, 0}, {0,  0}, // middle

   436

				{-1,  0}, {0,  1}, { 1, 0}, {0, -1}, // lower

   437

				{ 1,  0}, {0, -1}, {-1, 0}, {0,  1}, // upper

   438

			};

   439

   440

			if (flags & DC_AUTO) return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

   441

			if (_current_player == OWNER_WATER) return CMD_ERROR;

   442

			/* move to the middle tile.. */

   443

			return RemoveShiplift(tile + ToTileIndexDiff(_shiplift_tomiddle_offs[GetSection(tile)]), flags);

   444

		}

   445

   446

		case WATER_TILE_DEPOT:

   447

			if (flags & DC_AUTO) return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

   448

			return RemoveShipDepot(tile, flags);

   449

   450

		default:

   451

			NOT_REACHED();

   452

	}

   453

}

   454

   455

/**

   456

 * return true if a tile is a water tile wrt. a certain direction.

   457

 *

   458

 * @param tile The tile of interest.

   459

 * @param from The direction of interest.

   460

 * @return true iff the tile is water in the view of 'from'.

   461

 *

   462

 */

   463

static bool IsWateredTile(TileIndex tile, Direction from)

   464

{

   465

	switch (GetTileType(tile)) {

   466

		case MP_WATER:

   467

			if (!IsCoast(tile)) return true;

   468

			switch (GetTileSlope(tile, NULL)) {

   469

				case SLOPE_W: return (from == DIR_SE) || (from == DIR_E) || (from == DIR_NE);

   470

				case SLOPE_S: return (from == DIR_NE) || (from == DIR_N) || (from == DIR_NW);

   471

				case SLOPE_E: return (from == DIR_NW) || (from == DIR_W) || (from == DIR_SW);

   472

				case SLOPE_N: return (from == DIR_SW) || (from == DIR_S) || (from == DIR_SE);

   473

				default: return false;

   474

			}

   475

   476

		case MP_RAILWAY:

   477

			if (GetRailGroundType(tile) == RAIL_GROUND_WATER) {

   478

				assert(IsPlainRailTile(tile));

   479

				switch (GetTileSlope(tile, NULL)) {

   480

					case SLOPE_W: return (from == DIR_SE) || (from == DIR_E) || (from == DIR_NE);

   481

					case SLOPE_S: return (from == DIR_NE) || (from == DIR_N) || (from == DIR_NW);

   482

					case SLOPE_E: return (from == DIR_NW) || (from == DIR_W) || (from == DIR_SW);

   483