1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "clear_map.h"

     6

#include "rail_map.h"

     7

#include "table/strings.h"

     8

#include "functions.h"

     9

#include "map.h"

    10

#include "player.h"

    11

#include "tile.h"

    12

#include "viewport.h"

    13

#include "command.h"

    14

#include "tunnel_map.h"

    15

#include "variables.h"

    16

#include "table/sprites.h"

    17

#include "unmovable_map.h"

    18

#include "genworld.h"

    19

    20

typedef struct TerraformerHeightMod {

    21

	TileIndex tile;

    22

	byte height;

    23

} TerraformerHeightMod;

    24

    25

typedef struct TerraformerState {

    26

	int height[4];

    27

	uint32 flags;

    28

    29

	int direction;

    30

	int modheight_count;

    31

	int tile_table_count;

    32

    33

	int32 cost;

    34

    35

	TileIndex *tile_table;

    36

	TerraformerHeightMod *modheight;

    37

    38

} TerraformerState;

    39

    40

static int TerraformAllowTileProcess(TerraformerState *ts, TileIndex tile)

    41

{

    42

	TileIndex *t;

    43

	int count;

    44

    45

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

    46

    47

	t = ts->tile_table;

    48

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

    49

		if (*t == tile) return 0;

    50

	}

    51

    52

	return 1;

    53

}

    54

    55

static int TerraformGetHeightOfTile(TerraformerState *ts, TileIndex tile)

    56

{

    57

	TerraformerHeightMod *mod = ts->modheight;

    58

	int count;

    59

    60

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

    61

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

    62

	}

    63

    64

	return TileHeight(tile);

    65

}

    66

    67

static void TerraformAddDirtyTile(TerraformerState *ts, TileIndex tile)

    68

{

    69

	int count;

    70

	TileIndex *t;

    71

    72

	count = ts->tile_table_count;

    73

    74

	if (count >= 625) return;

    75

    76

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

    77

		if (*t == tile) return;

    78

	}

    79

    80

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

    81

}

    82

    83

static void TerraformAddDirtyTileAround(TerraformerState *ts, TileIndex tile)

    84

{

    85

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

    86

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

    87

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

    88

	TerraformAddDirtyTile(ts, tile);

    89

}

    90

    91

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

    92

{

    93

	int r;

    94

	int32 ret;

    95

    96

	assert(tile < MapSize());

    97

    98

	r = TerraformAllowTileProcess(ts, tile);

    99

	if (r <= 0) return r;

   100

   101

	if (IsTileType(tile, MP_RAILWAY)) {

   102

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

   103

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

   104

   105

		Slope tileh;

   106

		uint z;

   107

   108

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

   109

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

   110

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

   111

		tileh = GetTileSlope(tile, &z);

   112

		if (tileh == unsafe_slope[mode] ||

   113

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

   114

			_terraform_err_tile = tile;

   115

			_error_message = STR_1008_MUST_REMOVE_RAILROAD_TRACK;

   116

			return -1;

   117

		}

   118

   119

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

   120

		// tile can be terraformed.

   121

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

   122

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

   123

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

   124

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

   125

			 * can be lowered and this is a safe action

   126

			 */

   127

			if (tileh == SLOPE_FLAT &&

   128

					ts->direction == -1 &&

   129

					IsTunnelInWay(tile, z - TILE_HEIGHT)) {

   130

				_terraform_err_tile = tile;

   131

				_error_message = STR_1002_EXCAVATION_WOULD_DAMAGE;

   132

				return -1;

   133

			}

   134

			return 0;

   135

		}

   136

	}

   137

   138

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

   139

   140

	if (ret == CMD_ERROR) {

   141

		_terraform_err_tile = tile;

   142

		return -1;

   143

	}

   144

   145

	ts->cost += ret;

   146

   147

	if (ts->tile_table_count >= 625) return -1;

   148

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

   149

   150

	return 0;

   151

}

   152

   153

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

   154

{

   155

	int nh;

   156

	TerraformerHeightMod *mod;

   157

	int count;

   158

   159

	assert(tile < MapSize());

   160

   161

	if (height < 0) {

   162

		_error_message = STR_1003_ALREADY_AT_SEA_LEVEL;

   163

		return false;

   164

	}

   165

   166

	_error_message = STR_1004_TOO_HIGH;

   167

   168

	if (height > 15) return false;

   169

   170

	nh = TerraformGetHeightOfTile(ts, tile);

   171

	if (nh < 0 || height == nh) return false;

   172

   173

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

   174

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

   175

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

   176

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

   177

   178

	mod = ts->modheight;

   179

	count = ts->modheight_count;

   180

   181

	for (;;) {

   182

		if (count == 0) {

   183

			if (ts->modheight_count >= 576) return false;

   184

			ts->modheight_count++;

   185

			break;

   186

		}

   187

		if (mod->tile == tile) break;

   188

		mod++;

   189

		count--;

   190

	}

   191

   192

	mod->tile = tile;

   193

	mod->height = (byte)height;

   194

   195

	ts->cost += _price.terraform;

   196

   197

	{

   198

		int direction = ts->direction, r;

   199

		const TileIndexDiffC *ttm;

   200

   201

		static const TileIndexDiffC _terraform_tilepos[] = {

   202

			{ 1,  0},

   203

			{-2,  0},

   204

			{ 1,  1},

   205

			{ 0, -2}

   206

		};

   207

   208

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

   209

			tile += ToTileIndexDiff(*ttm);

   210

   211

			r = TerraformGetHeightOfTile(ts, tile);

   212

			if (r != height && r-direction != height && r+direction != height) {

   213

				if (!TerraformTileHeight(ts, tile, r+direction))

   214

					return false;

   215

			}

   216

		}

   217

	}

   218

   219

	return true;

   220

}

   221

   222

/** Terraform land

   223

 * @param tile tile to terraform

   224

 * @param p1 corners to terraform.

   225

 * @param p2 direction; eg up or down

   226

 */

   227

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

   228

{

   229

	TerraformerState ts;

   230

	TileIndex t;

   231

	int direction;

   232

   233

	TerraformerHeightMod modheight_data[576];

   234

	TileIndex tile_table_data[625];

   235

   236

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   237

   238

	_terraform_err_tile = 0;

   239

   240

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

   241

	ts.flags = flags;

   242

	ts.modheight_count = ts.tile_table_count = 0;

   243

	ts.cost = 0;

   244

	ts.modheight = modheight_data;

   245

	ts.tile_table = tile_table_data;

   246

   247

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

   248

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

   249

   250

	if (p1 & 1) {

   251

		t = tile + TileDiffXY(1, 0);

   252

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

   253

			return CMD_ERROR;

   254

		}

   255

	}

   256

   257

	if (p1 & 2) {

   258

		t = tile + TileDiffXY(1, 1);

   259

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

   260

			return CMD_ERROR;

   261

		}

   262

	}

   263

   264

	if (p1 & 4) {

   265

		t = tile + TileDiffXY(0, 1);

   266

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

   267

			return CMD_ERROR;

   268

		}

   269

	}

   270

   271

	if (p1 & 8) {

   272

		t = tile + TileDiffXY(0, 0);

   273

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

   274

			return CMD_ERROR;

   275

		}

   276

	}

   277

   278

	if (direction == -1) {

   279

		/* Check if tunnel would take damage */

   280

		int count;

   281

		TileIndex *ti = ts.tile_table;

   282

   283

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

   284

			uint z, t;

   285

			TileIndex tile = *ti;

   286

   287

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

   288

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

   289

			if (t <= z) z = t;

   290

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

   291

			if (t <= z) z = t;

   292

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

   293

			if (t <= z) z = t;

   294

   295

			if (IsTunnelInWay(tile, z * TILE_HEIGHT)) {

   296

				return_cmd_error(STR_1002_EXCAVATION_WOULD_DAMAGE);

   297

			}

   298

		}

   299

	}

   300

   301

	if (flags & DC_EXEC) {

   302

		/* Clear the landscape at the tiles */

   303

		{

   304

			int count;

   305

			TileIndex *ti = ts.tile_table;

   306

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

   307

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

   308

			}

   309

		}

   310

   311

		/* change the height */

   312

		{

   313

			int count;

   314

			TerraformerHeightMod *mod;

   315

   316

			mod = ts.modheight;

   317

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

   318

				TileIndex til = mod->tile;

   319

   320

				SetTileHeight(til, mod->height);

   321

				TerraformAddDirtyTileAround(&ts, til);

   322

			}

   323

		}

   324

   325

		/* finally mark the dirty tiles dirty */

   326

		{

   327

			int count;

   328

			TileIndex *ti = ts.tile_table;

   329

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

   330

				MarkTileDirtyByTile(*ti);

   331

			}

   332

		}

   333

	}

   334

	return ts.cost;

   335

}

   336

   337

   338

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

   339

 * @param tile end tile of area-drag

   340

 * @param p1 start tile of area drag

   341

 * @param p2 unused

   342

 */

   343

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

   344

{

   345

	int size_x, size_y;

   346

	int ex;

   347

	int ey;

   348

	int sx, sy;

   349

	uint h, curh;

   350

	int32 ret, cost, money;

   351

   352

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

   353

   354

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   355

   356

	// remember level height

   357

	h = TileHeight(p1);

   358

   359

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

   360

	ex = TileX(tile);

   361

	ey = TileY(tile);

   362

	sx = TileX(p1);

   363

	sy = TileY(p1);

   364

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

   365

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

   366

	tile = TileXY(sx, sy);

   367

   368

	size_x = ex-sx+1;

   369

	size_y = ey-sy+1;

   370

   371

	money = GetAvailableMoneyForCommand();

   372

	cost = 0;

   373

   374

	BEGIN_TILE_LOOP(tile2, size_x, size_y, tile) {

   375

		curh = TileHeight(tile2);

   376

		while (curh != h) {

   377

			ret = DoCommand(tile2, 8, (curh > h) ? 0 : 1, flags & ~DC_EXEC, CMD_TERRAFORM_LAND);

   378

			if (CmdFailed(ret)) break;

   379

			cost += ret;

   380

   381

			if (flags & DC_EXEC) {

   382

				if ((money -= ret) < 0) {

   383

					_additional_cash_required = ret;

   384

					return cost - ret;

   385

				}

   386

				DoCommand(tile2, 8, (curh > h) ? 0 : 1, flags, CMD_TERRAFORM_LAND);

   387

			}

   388

   389

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

   390

		}

   391

	} END_TILE_LOOP(tile2, size_x, size_y, tile)

   392

   393

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

   394

}

   395

   396

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

   397

 * the name is a bit confusing ;p

   398

 * @param tile the tile the player is purchasing

   399

 * @param p1 unused

   400

 * @param p2 unused

   401

 */

   402

int32 CmdPurchaseLandArea(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   403

{

   404

	int32 cost;

   405

   406

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   407

   408

	if (!EnsureNoVehicle(tile)) return CMD_ERROR;

   409

   410

	if (IsOwnedLandTile(tile) && IsTileOwner(tile, _current_player)) {

   411

		return_cmd_error(STR_5807_YOU_ALREADY_OWN_IT);

   412

	}

   413

   414

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

   415

	if (CmdFailed(cost)) return CMD_ERROR;

   416

   417

	if (flags & DC_EXEC) {

   418

		MakeOwnedLand(tile, _current_player);

   419

		MarkTileDirtyByTile(tile);

   420

	}

   421

   422

	return cost + _price.purchase_land * 10;

   423

}

   424

   425

   426

static int32 ClearTile_Clear(TileIndex tile, byte flags)

   427

{

   428

	static const int32* clear_price_table[] = {

   429

		&_price.clear_1,

   430

		&_price.purchase_land,

   431

		&_price.clear_2,

   432

		&_price.clear_3,

   433

		&_price.purchase_land,

   434

		&_price.purchase_land,

   435

		&_price.clear_2, // XXX unused?

   436

	};

   437

	int32 price;

   438

   439

	if (IsClearGround(tile, CLEAR_GRASS) && GetClearDensity(tile) == 0) {

   440

		price = 0;

   441

	} else {

   442

		price = *clear_price_table[GetClearGround(tile)];

   443

	}

   444

   445

	if (flags & DC_EXEC) DoClearSquare(tile);

   446

   447

	return price;

   448

}

   449

   450

/** Sell a land area. Actually you only sell one tile, so

   451

 * the name is a bit confusing ;p

   452

 * @param tile the tile the player is selling

   453

 * @param p1 unused

   454

 * @param p2 unused

   455

 */

   456

int32 CmdSellLandArea(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   457

{

   458

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   459

   460

	if (!IsOwnedLandTile(tile)) return CMD_ERROR;

   461

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

   462

   463

   464

	if (!EnsureNoVehicle(tile)) return CMD_ERROR;

   465

   466

	if (flags & DC_EXEC) DoClearSquare(tile);

   467

   468

	return - _price.purchase_land * 2;

   469

}

   470

   471

   472

#include "table/clear_land.h"

   473

   474

   475

void DrawClearLandTile(const TileInfo *ti, byte set)

   476

{

   477

	DrawGroundSprite(SPR_FLAT_BARE_LAND + _tileh_to_sprite[ti->tileh] + set * 19);

   478

}

   479

   480

void DrawHillyLandTile(const TileInfo *ti)

   481

{

   482

	if (ti->tileh != SLOPE_FLAT) {

   483

		DrawGroundSprite(SPR_FLAT_ROUGH_LAND + _tileh_to_sprite[ti->tileh]);

   484

	} else {

   485

		DrawGroundSprite(_landscape_clear_sprites[GB(ti->x ^ ti->y, 4, 3)]);

   486

	}

   487

}

   488

   489

void DrawClearLandFence(const TileInfo *ti)

   490

{

   491

	byte z = ti->z;

   492

   493

	if (ti->tileh & SLOPE_S) {

   494

		z += TILE_HEIGHT;

   495

		if (ti->tileh == SLOPE_STEEP_S) z += TILE_HEIGHT;

   496

	}

   497

   498

	if (GetFenceSW(ti->tile) != 0) {