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

    38

#include "table/sprites.h"

    39

#include "table/strings.h"

    40

    41

/**

    42

 * Describes the behaviour of a tile during flooding.

    43

 */

    44

enum FloodingBehaviour {

    45

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

    46

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

    47

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

    48

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

    49

};

    50

    51

/**

    52

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

    53

 */

    54

static const uint8 _flood_from_dirs[] = {

    55

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

    56

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

    57

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

    58

	(1 << DIR_NE),                                                 // SLOPE_SW

    59

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

    60

	0,                                                             // SLOPE_EW

    61

	(1 << DIR_NW),                                                 // SLOPE_SE

    62

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

    63

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

    64

	(1 << DIR_SE),                                                 // SLOPE_NW

    65

	0,                                                             // SLOPE_NS

    66

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

    67

	(1 << DIR_SW),                                                 // SLOPE_NE

    68

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

    69

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

    70

};

    71

    72

/**

    73

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

    74

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

    75

 *

    76

 * @param tile tile to check

    77

 */

    78

static inline void MarkTileDirtyIfCanalOrRiver(TileIndex tile)

    79

{

    80

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

    81

}

    82

    83

/**

    84

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

    85

 *

    86

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

    87

 * @ingroup dirty

    88

 */

    89

static void MarkCanalsAndRiversAroundDirty(TileIndex tile)

    90

{

    91

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

    92

		MarkTileDirtyIfCanalOrRiver(tile + TileOffsByDir(dir));

    93

	}

    94

}

    95

    96

/**

    97

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

    98

 * This as for example docks and shipdepots do not store

    99

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

   100

 * @param t the tile to change.

   101

 * @param o the owner of the new tile.

   102

 */

   103

void MakeWaterOrCanalDependingOnSurroundings(TileIndex t, Owner o)

   104

{

   105

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

   106

   107

	/* Mark tile dirty in all cases */

   108

	MarkTileDirtyByTile(t);

   109

   110

	/* Non-sealevel -> canal */

   111

	if (TileHeight(t) != 0) {

   112

		MakeCanal(t, o, Random());

   113

		return;

   114

	}

   115

   116

	bool has_water = false;

   117

	bool has_canal = false;

   118

   119

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

   120

		TileIndex neighbour = TileAddByDiagDir(t, dir);

   121

		switch (GetTileType(neighbour)) {

   122

			case MP_WATER:

   123

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

   124

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

   125

				break;

   126

   127

			case MP_RAILWAY:

   128

				/* Shore or flooded halftile */

   129

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

   130

				break;

   131

   132

			default: break;

   133

		}

   134

	}

   135

	if (has_canal || !has_water) {

   136

		MakeCanal(t, o, Random());

   137

	} else {

   138

		MakeWater(t);

   139

	}

   140

}

   141

   142

   143

/** Build a ship depot.

   144

 * @param tile tile where ship depot is built

   145

 * @param flags type of operation

   146

 * @param p1 bit 0 depot orientation (Axis)

   147

 * @param p2 unused

   148

 */

   149

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

   150

{

   151

	TileIndex tile2;

   152

   153

	CommandCost ret;

   154

   155

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

   156

   157

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

   158

   159

	if (!IsWaterTile(tile) || !IsWaterTile(tile2))

   160

		return_cmd_error(STR_3801_MUST_BE_BUILT_ON_WATER);

   161

   162

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

   163

   164

	Owner o1 = GetTileOwner(tile);

   165

	Owner o2 = GetTileOwner(tile2);

   166

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

   167

	if (CmdFailed(ret)) return CMD_ERROR;

   168

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

   169

	if (CmdFailed(ret)) return CMD_ERROR;

   170

   171

	Depot *depot = new Depot(tile);

   172

	if (depot == NULL) return CMD_ERROR;

   173

	AutoPtrT<Depot> d_auto_delete = depot;

   174

   175

	if (flags & DC_EXEC) {

   176

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

   177

   178

		MakeShipDepot(tile,  _current_player, DEPOT_NORTH, axis, o1);

   179

		MakeShipDepot(tile2, _current_player, DEPOT_SOUTH, axis, o2);

   180

		MarkTileDirtyByTile(tile);

   181

		MarkTileDirtyByTile(tile2);

   182

		d_auto_delete.Detach();

   183

	}

   184

   185

	return CommandCost(EXPENSES_CONSTRUCTION, _price.build_ship_depot);

   186

}

   187

   188

void MakeWaterOrCanalDependingOnOwner(TileIndex tile, Owner o)

   189

{

   190

	if (o == OWNER_WATER) {

   191

		MakeWater(tile);

   192

	} else {

   193

		MakeCanal(tile, o, Random());

   194

	}

   195

}

   196

   197

static CommandCost RemoveShipDepot(TileIndex tile, uint32 flags)

   198

{

   199

	TileIndex tile2;

   200

   201

	if (!IsShipDepot(tile)) return CMD_ERROR;

   202

	if (!CheckTileOwnership(tile)) return CMD_ERROR;

   203

	if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;

   204

   205

	tile2 = GetOtherShipDepotTile(tile);

   206

   207

	if (!EnsureNoVehicleOnGround(tile2)) return CMD_ERROR;

   208

   209

	if (flags & DC_EXEC) {

   210

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

   211

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

   212

   213

		MakeWaterOrCanalDependingOnOwner(tile,  GetShipDepotWaterOwner(tile));

   214

		MakeWaterOrCanalDependingOnOwner(tile2, GetShipDepotWaterOwner(tile2));

   215

		MarkTileDirtyByTile(tile);

   216

		MarkTileDirtyByTile(tile2);

   217

	}

   218

   219

	return CommandCost(EXPENSES_CONSTRUCTION, _price.remove_ship_depot);

   220

}

   221

   222

/** build a shiplift */

   223

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

   224

{

   225

	CommandCost ret;

   226

	int delta;

   227

   228

	/* middle tile */

   229

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

   230

	if (CmdFailed(ret)) return CMD_ERROR;

   231

   232

	delta = TileOffsByDiagDir(dir);

   233

	/* lower tile */

   234

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

   235

	if (CmdFailed(ret)) return CMD_ERROR;

   236

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

   237

		return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

   238

	}

   239

   240

	/* upper tile */

   241

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

   242

	if (CmdFailed(ret)) return CMD_ERROR;

   243

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

   244

		return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

   245

	}

   246

   247

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

   248

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

   249

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

   250

		return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);

   251

	}

   252

   253

	if (flags & DC_EXEC) {

   254

		MakeLock(tile, _current_player, dir);

   255

		MarkTileDirtyByTile(tile);

   256

		MarkTileDirtyByTile(tile - delta);

   257

		MarkTileDirtyByTile(tile + delta);

   258

		MarkCanalsAndRiversAroundDirty(tile - delta);

   259

		MarkCanalsAndRiversAroundDirty(tile + delta);

   260

	}

   261

   262

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

   263

}

   264

   265

static CommandCost RemoveShiplift(TileIndex tile, uint32 flags)

   266

{

   267

	TileIndexDiff delta = TileOffsByDiagDir(GetLockDirection(tile));

   268

   269

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

   270

   271

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

   272

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

   273

		return CMD_ERROR;

   274

   275

	if (flags & DC_EXEC) {

   276

		DoClearSquare(tile);

   277

		MakeWaterOrCanalDependingOnSurroundings(tile + delta, _current_player);

   278

		MakeWaterOrCanalDependingOnSurroundings(tile - delta, _current_player);

   279

		MarkCanalsAndRiversAroundDirty(tile - delta);

   280

		MarkCanalsAndRiversAroundDirty(tile + delta);

   281

	}

   282

   283

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

   284

}

   285

   286

/** Builds a lock (ship-lift)

   287

 * @param tile tile where to place the lock

   288

 * @param flags type of operation

   289

 * @param p1 unused

   290

 * @param p2 unused

   291

 */

   292

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

   293

{

   294

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

   295

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

   296

   297

	/* Disallow building of locks on river rapids */

   298

	if (IsRiverTile(tile)) return_cmd_error(STR_0239_SITE_UNSUITABLE);

   299

   300

	return DoBuildShiplift(tile, dir, flags);

   301

}

   302

   303

/** Build a piece of canal.

   304

 * @param tile end tile of stretch-dragging

   305

 * @param flags type of operation

   306

 * @param p1 start tile of stretch-dragging

   307

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

   308

 */

   309

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

   310

{

   311

	CommandCost cost(EXPENSES_CONSTRUCTION);

   312

	int size_x, size_y;

   313

	int x;

   314

	int y;

   315

	int sx, sy;

   316

   317

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

   318

   319

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

   320

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

   321

   322

	x = TileX(tile);

   323

	y = TileY(tile);

   324

	sx = TileX(p1);

   325

	sy = TileY(p1);

   326

   327

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

   328

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

   329

	size_x = (x - sx) + 1;

   330

	size_y = (y - sy) + 1;

   331

   332

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

   333

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

   334

   335

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

   336

		CommandCost ret;

   337

   338

		Slope slope = GetTileSlope(tile, NULL);

   339

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

   340

			return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);

   341

		}

   342

   343

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

   344

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

   345

   346

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

   347

		if (CmdFailed(ret)) return ret;

   348

		cost.AddCost(ret);

   349

   350

		if (flags & DC_EXEC) {

   351

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

   352

				MakeWater(tile);

   353

			} else if (p2 == 2) {

   354

				MakeRiver(tile, Random());

   355

			} else {

   356

				MakeCanal(tile, _current_player, Random());

   357

			}

   358

			MarkTileDirtyByTile(tile);

   359

			MarkCanalsAndRiversAroundDirty(tile);

   360

		}

   361

   362

		cost.AddCost(_price.clear_water);

   363

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

   364

   365

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

   366

		return_cmd_error(STR_1007_ALREADY_BUILT);

   367

	} else {

   368

		return cost;

   369

	}

   370

}

   371

   372

static CommandCost ClearTile_Water(TileIndex tile, byte flags)

   373

{

   374

	switch (GetWaterTileType(tile)) {

   375

		case WATER_TILE_CLEAR:

   376

		case WATER_TILE_RIVER:

   377

			if (flags & DC_NO_WATER) return_cmd_error(STR_3807_CAN_T_BUILD_ON_WATER);

   378

   379

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

   380

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

   381

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

   382

				return_cmd_error(STR_0002_TOO_CLOSE_TO_EDGE_OF_MAP);

   383

			}

   384

   385

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

   386

			if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;

   387

   388

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

   389

   390

			if (flags & DC_EXEC) {

   391

				DoClearSquare(tile);

   392

				MarkCanalsAndRiversAroundDirty(tile);

   393

			}

   394

			return CommandCost(EXPENSES_CONSTRUCTION, _price.clear_water);

   395

   396

		case WATER_TILE_COAST: {

   397

			Slope slope = GetTileSlope(tile, NULL);

   398

   399

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

   400

			if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;

   401

   402

			if (flags & DC_EXEC) {

   403

				DoClearSquare(tile);

   404

				MarkCanalsAndRiversAroundDirty(tile);

   405

			}

   406

			if (IsSlopeWithOneCornerRaised(slope)) {

   407

				return CommandCost(EXPENSES_CONSTRUCTION, _price.clear_water);

   408

			} else {

   409

				return CommandCost(EXPENSES_CONSTRUCTION, _price.clear_roughland);

   410

			}

   411

		}

   412

   413

		case WATER_TILE_LOCK: {

   414

			static const TileIndexDiffC _shiplift_tomiddle_offs[] = {

   415

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

   416

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

   417

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

   418

			};

   419

   420

			if (flags & DC_AUTO) return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

   421

			if (_current_player == OWNER_WATER) return CMD_ERROR;

   422

			/* move to the middle tile.. */

   423

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

   424

		}

   425

   426

		case WATER_TILE_DEPOT:

   427

			if (flags & DC_AUTO) return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

   428

			return RemoveShipDepot(tile, flags);

   429

   430

		default:

   431

			NOT_REACHED();

   432

	}

   433

}

   434

   435

/**

   436

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

   437

 *

   438

 * @param tile The tile of interest.

   439

 * @param from The direction of interest.

   440

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

   441

 *

   442

 */

   443

static bool IsWateredTile(TileIndex tile, Direction from)

   444

{

   445

	switch (GetTileType(tile)) {

   446

		case MP_WATER:

   447

			if (!IsCoast(tile)) return true;

   448

			switch (GetTileSlope(tile, NULL)) {

   449

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

   450

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

   451

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

   452

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

   453

				default: return false;

   454

			}

   455

   456

		case MP_RAILWAY:

   457

			if (GetRailGroundType(tile) == RAIL_GROUND_WATER) {

   458

				assert(IsPlainRailTile(tile));

   459

				switch (GetTileSlope(tile, NULL)) {

   460

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

   461

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

   462

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

   463

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

   464

					default: return false;

   465

				}

   466

			}

   467

			return false;

   468

   469

		case MP_STATION:  return IsOilRig(tile) || IsDock(tile) || IsBuoy(tile);

   470

		case MP_INDUSTRY: return (GetIndustrySpec(GetIndustryType(tile))->behaviour & INDUSTRYBEH_BUILT_ONWATER) != 0;

   471

		default:          return false;

   472

	}

   473

}

   474

   475

static void DrawWaterEdges(SpriteID base, TileIndex tile)

   476

{

   477

	uint wa;

   478

   479

	/* determine the edges around with water. */

   480

	wa  = IsWateredTile(TILE_ADDXY(tile, -1,  0), DIR_SW) << 0;

   481

	wa += IsWateredTile(TILE_ADDXY(tile,  0,  1), DIR_NW) << 1;

   482

	wa += IsWateredTile(TILE_ADDXY(tile,  1,  0), DIR_NE) << 2;

   483

	wa += IsWateredTile(TILE_ADDXY(tile,  0, -1), DIR_SE) << 3;