1

/* $Id$ */

     2

     3

/** @file clear_cmd.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "clear_map.h"

     8

#include "rail_map.h"

     9

#include "table/strings.h"

    10

#include "functions.h"

    11

#include "map.h"

    12

#include "player.h"

    13

#include "tile.h"

    14

#include "viewport.h"

    15

#include "command.h"

    16

#include "tunnel_map.h"

    17

#include "bridge_map.h"

    18

#include "bridge.h"

    19

#include "landscape.h"

    20

#include "variables.h"

    21

#include "table/sprites.h"

    22

#include "unmovable_map.h"

    23

#include "genworld.h"

    24

#include "industry.h"

    25

#include "water_map.h"

    26

    30

struct TerraformerHeightMod {

    33

};

    34

    35

struct TerraformerState {

    36

	uint32 flags;

    37

    38

	int direction;

    41

    42

	CommandCost cost;

    43

    46

};

    47

    55

static int TerraformAllowTileProcess(TerraformerState *ts, TileIndex tile)

    56

{

    57

	TileIndex *t;

    58

	int count;

    59

    60

	if (TileX(tile) == MapMaxX() || TileY(tile) == MapMaxY()) return -1;

    61

    62

	t = ts->tile_table;

    63

	for (count = ts->tile_table_count; count != 0; count--, t++) {

    64

		if (*t == tile) return 0;

    65

	}

    66

    67

	return 1;

    68

}

    69

    77

static int TerraformGetHeightOfTile(TerraformerState *ts, TileIndex tile)

    78

{

    79

	TerraformerHeightMod *mod = ts->modheight;

    80

	int count;

    81

    82

	for (count = ts->modheight_count; count != 0; count--, mod++) {

    83

		if (mod->tile == tile) return mod->height;

    84

	}

    85

    87

	return TileHeight(tile);

    88

}

    89

    96

static void TerraformAddDirtyTile(TerraformerState *ts, TileIndex tile)

    97

{

    98

	int count;

    99

	TileIndex *t;

   100

   101

	count = ts->tile_table_count;

   102

   103

	for (t = ts->tile_table; count != 0; count--, t++) {

   104

		if (*t == tile) return;

   105

	}

   106

   109

	ts->tile_table[ts->tile_table_count++] = tile;

   110

}

   111

   118

static void TerraformAddDirtyTileAround(TerraformerState *ts, TileIndex tile)

   119

{

   120

	TerraformAddDirtyTile(ts, tile + TileDiffXY( 0, -1));

   121

	TerraformAddDirtyTile(ts, tile + TileDiffXY(-1, -1));

   122

	TerraformAddDirtyTile(ts, tile + TileDiffXY(-1,  0));

   123

	TerraformAddDirtyTile(ts, tile);

   124

}

   125

   135

static int TerraformProc(TerraformerState *ts, TileIndex tile, int mode)

   136

{

   137

	int r;

   138

	CommandCost ret;

   139

   140

	assert(tile < MapSize());

   141

   143

	r = TerraformAllowTileProcess(ts, tile);

   144

	if (r <= 0) return r;

   145

   147

	if (IsTileType(tile, MP_RAILWAY)) {

   148

		static const TrackBits safe_track[] = { TRACK_BIT_LOWER, TRACK_BIT_LEFT, TRACK_BIT_UPPER, TRACK_BIT_RIGHT };

   149

		static const Slope unsafe_slope[] = { SLOPE_S, SLOPE_W, SLOPE_N, SLOPE_E };

   150

   151

		Slope tileh;

   152

		uint z;

   153

   154

		/* Nothing could be built at the steep slope - this avoids a bug

   155

		 * when you have a single diagonal track in one corner on a

   156

		 * basement and then you raise/lower the other corner. */

   157

		tileh = GetTileSlope(tile, &z);

   158

		if (tileh == unsafe_slope[mode] ||

   159

				tileh == (SLOPE_STEEP | ComplementSlope(unsafe_slope[mode]))) {

   160

			_terraform_err_tile = tile;

   161

			_error_message = STR_1008_MUST_REMOVE_RAILROAD_TRACK;

   162

			return -1;

   163

		}

   164

   165

		/* If we have a single diagonal track there, the other side of

   166

		 * tile can be terraformed. */

   167

		if (IsPlainRailTile(tile) && GetTrackBits(tile) == safe_track[mode]) {

   168

			/* If terraforming downwards prevent damaging a potential tunnel below.

   169

			 * This check is only necessary for flat tiles, because if the tile is

   170

			 * non-flat, then the corner opposing the rail is raised. Only this corner

   171

			 * can be lowered and this is a safe action

   172

			 */

   173

			if (tileh == SLOPE_FLAT &&

   174

					ts->direction == -1 &&

   175

					IsTunnelInWay(tile, z - TILE_HEIGHT)) {

   176

				_terraform_err_tile = tile;

   177

				_error_message = STR_1002_EXCAVATION_WOULD_DAMAGE;

   178

				return -1;

   179

			}

   184

			return 0;

   185

		}

   186

	}

   187

   188

	/* Canals can't be terraformed */

   189

	if (IsClearWaterTile(tile) && IsCanal(tile)) {

   190

		_terraform_err_tile = tile;

   191

		_error_message = STR_MUST_DEMOLISH_CANAL_FIRST;

   192

		return -1;

   193

	}

   194

   196

	ret = DoCommand(tile, 0, 0, ts->flags & ~DC_EXEC, CMD_LANDSCAPE_CLEAR);

   197

   198

	if (CmdFailed(ret)) {

   199

		_terraform_err_tile = tile;

   200

		return -1;

   201

	}

   202

   203

	ts->cost.AddCost(ret.GetCost());

   204

   207

	ts->tile_table[ts->tile_table_count++] = tile;

   208

   209

	return 0;

   210

}

   211

   220

static bool TerraformTileHeight(TerraformerState *ts, TileIndex tile, int height)

   221

{

   222

	assert(tile < MapSize());

   223

   225

	if (height < 0) {

   226

		_error_message = STR_1003_ALREADY_AT_SEA_LEVEL;

   227

		return false;

   228

	}

   229

   230

	_error_message = STR_1004_TOO_HIGH;

   231

   232

	if (height > MAX_TILE_HEIGHT) return false;

   233

   240

   242

	if (TerraformProc(ts, tile, 0) < 0) return false;

   243

	if (TerraformProc(ts, tile + TileDiffXY( 0, -1), 1) < 0) return false;

   244

	if (TerraformProc(ts, tile + TileDiffXY(-1, -1), 2) < 0) return false;

   245

	if (TerraformProc(ts, tile + TileDiffXY(-1,  0), 3) < 0) return false;

   246

   248

   255

		mod++;

   256

		count--;

   257

	}

   258

   266

	mod->tile = tile;

   267

	mod->height = (byte)height;

   268

   270

	ts->cost.AddCost(_price.terraform);

   271

   273

	{

   274

		const TileIndexDiffC *ttm;

   275

   276

		static const TileIndexDiffC _terraform_tilepos[] = {

   281

		};

   282

   283

		for (ttm = _terraform_tilepos; ttm != endof(_terraform_tilepos); ttm++) {

   284

			tile += ToTileIndexDiff(*ttm);

   285

   295

					return false;

   296

			}

   297

		}

   298

	}

   299

   300

	return true;

   301

}

   302

   303

/** Terraform land

   304

 * @param tile tile to terraform

   305

 * @param flags for this command type

   308

 * @return error or cost of terraforming

   309

 */

   310

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

   311

{

   312

	TerraformerState ts;

   313

	TileIndex t;

   314

	int direction;

   315

   316

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   317

   318

	_terraform_err_tile = 0;

   319

   320

	ts.direction = direction = p2 ? 1 : -1;

   321

	ts.flags = flags;

   322

	ts.modheight_count = ts.tile_table_count = 0;

   323

	ts.cost = CommandCost();

   324

   325

	/* Make an extra check for map-bounds cause we add tiles to the originating tile */

   326

	if (tile + TileDiffXY(1, 1) >= MapSize()) return CMD_ERROR;

   327

   330

		t = tile + TileDiffXY(1, 0);

   331

		if (!TerraformTileHeight(&ts, t, TileHeight(t) + direction)) {

   332

			return CMD_ERROR;

   333

		}

   334

	}

   335

   337

		t = tile + TileDiffXY(1, 1);

   338

		if (!TerraformTileHeight(&ts, t, TileHeight(t) + direction)) {

   339

			return CMD_ERROR;

   340

		}

   341

	}

   342

   344

		t = tile + TileDiffXY(0, 1);

   345

		if (!TerraformTileHeight(&ts, t, TileHeight(t) + direction)) {

   346

			return CMD_ERROR;

   347

		}

   348

	}

   349

   351

		t = tile + TileDiffXY(0, 0);

   352

		if (!TerraformTileHeight(&ts, t, TileHeight(t) + direction)) {

   353

			return CMD_ERROR;

   354

		}

   355

	}

   356

   358

	{

   359

		int count;

   360

		TileIndex *ti = ts.tile_table;

   361

   362

		for (count = ts.tile_table_count; count != 0; count--, ti++) {

   363

			TileIndex tile = *ti;

   364

   366

			uint z_min = TerraformGetHeightOfTile(&ts, tile + TileDiffXY(0, 0));

   367

			uint z_max = z_min;

   368

			uint t = TerraformGetHeightOfTile(&ts, tile + TileDiffXY(1, 0));

   369

			z_min = min(z_min, t);

   370

			z_max = max(z_max, t);

   371

			t = TerraformGetHeightOfTile(&ts, tile + TileDiffXY(1, 1));

   372

			z_min = min(z_min, t);

   373

			z_max = max(z_max, t);

   374

			t = TerraformGetHeightOfTile(&ts, tile + TileDiffXY(0, 1));

   375

			z_min = min(z_min, t);

   376

			z_max = max(z_max, t);

   377

   379

			if (direction == 1 && MayHaveBridgeAbove(tile) && IsBridgeAbove(tile) &&

   380

					GetBridgeHeight(GetSouthernBridgeEnd(tile)) <= z_max * TILE_HEIGHT) {

   382

				return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);

   383

			}

   385

			if (direction == -1 && IsTunnelInWay(tile, z_min * TILE_HEIGHT)) {

   387

				return_cmd_error(STR_1002_EXCAVATION_WOULD_DAMAGE);

   388

			}

   389

		}

   390

	}

   391

   392

	if (flags & DC_EXEC) {

   393

		/* Clear the landscape at the tiles */

   394

		{

   395

			int count;

   396

			TileIndex *ti = ts.tile_table;

   397

			for (count = ts.tile_table_count; count != 0; count--, ti++) {

   398

				DoCommand(*ti, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

   399

			}

   400

		}

   401

   402

		/* change the height */

   403

		{

   404

			int count;

   405

			TerraformerHeightMod *mod;

   406

   407

			mod = ts.modheight;

   408

			for (count = ts.modheight_count; count != 0; count--, mod++) {

   409

				TileIndex til = mod->tile;

   410

   411

				SetTileHeight(til, mod->height);

   413

			}

   414

		}

   415

   416

		/* finally mark the dirty tiles dirty */

   417

		{

   418

			int count;

   419

			TileIndex *ti = ts.tile_table;

   420

			for (count = ts.tile_table_count; count != 0; count--, ti++) {

   421

				MarkTileDirtyByTile(*ti);

   422

			}

   423

		}

   424

	}

   425

	return ts.cost;

   426

}

   427

   428

   429

/** Levels a selected (rectangle) area of land

   430

 * @param tile end tile of area-drag

   431

 * @param flags for this command type

   432

 * @param p1 start tile of area drag

   433

 * @param p2 unused

   434

 * @return  error or cost of terraforming

   435

 */

   436

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

   437

{

   438

	int size_x, size_y;

   439

	int ex;

   440

	int ey;

   441

	int sx, sy;

   442

	uint h, curh;

   443

	CommandCost money;

   444

	CommandCost ret;

   445

	CommandCost cost;

   446

   447

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

   448

   449

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   450

   451

	/* remember level height */

   452

	h = TileHeight(p1);

   453

   454

	/* make sure sx,sy are smaller than ex,ey */

   455

	ex = TileX(tile);

   456

	ey = TileY(tile);

   457

	sx = TileX(p1);

   458

	sy = TileY(p1);

   459

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

   460

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

   461

	tile = TileXY(sx, sy);

   462

   463

	size_x = ex - sx + 1;

   464

	size_y = ey - sy + 1;

   465

   466

	money.AddCost(GetAvailableMoneyForCommand());

   467

   468

	BEGIN_TILE_LOOP(tile2, size_x, size_y, tile) {

   469

		curh = TileHeight(tile2);

   470

		while (curh != h) {

   472

			if (CmdFailed(ret)) break;

   473

   474

			if (flags & DC_EXEC) {

   475

				money.AddCost(-ret.GetCost());

   476

				if (money.GetCost() < 0) {

   477

					_additional_cash_required = ret.GetCost();

   478

					return cost;

   479

				}

   481

			}

   482

   483

			cost.AddCost(ret);

   484

			curh += (curh > h) ? -1 : 1;

   485

		}

   486

	} END_TILE_LOOP(tile2, size_x, size_y, tile)

   487

   488

	return (cost.GetCost() == 0) ? CMD_ERROR : cost;

   489

}

   490

   491

/** Purchase a land area. Actually you only purchase one tile, so