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

#include "industry.h"

    20

    21

typedef struct TerraformerHeightMod {

    22

	TileIndex tile;

    23

	byte height;

    24

} TerraformerHeightMod;

    25

    26

typedef struct TerraformerState {

    27

	int height[4];

    28

	uint32 flags;

    29

    30

	int direction;

    31

	int modheight_count;

    32

	int tile_table_count;

    33

    34

	int32 cost;

    35

    36

	TileIndex *tile_table;

    37

	TerraformerHeightMod *modheight;

    38

    39

} TerraformerState;

    40

    41

static int TerraformAllowTileProcess(TerraformerState *ts, TileIndex tile)

    42

{

    43

	TileIndex *t;

    44

	int count;

    45

    46

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

    47

    48

	t = ts->tile_table;

    49

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

    50

		if (*t == tile) return 0;

    51

	}

    52

    53

	return 1;

    54

}

    55

    56

static int TerraformGetHeightOfTile(TerraformerState *ts, TileIndex tile)

    57

{

    58

	TerraformerHeightMod *mod = ts->modheight;

    59

	int count;

    60

    61

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

    62

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

    63

	}

    64

    65

	return TileHeight(tile);

    66

}

    67

    68

static void TerraformAddDirtyTile(TerraformerState *ts, TileIndex tile)

    69

{

    70

	int count;

    71

	TileIndex *t;

    72

    73

	count = ts->tile_table_count;

    74

    75

	if (count >= 625) return;

    76

    77

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

    78

		if (*t == tile) return;

    79

	}

    80

    81

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

    82

}

    83

    84

static void TerraformAddDirtyTileAround(TerraformerState *ts, TileIndex tile)

    85

{

    86

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

    87

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

    88

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

    89

	TerraformAddDirtyTile(ts, tile);

    90

}

    91

    92

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

    93

{

    94

	int r;

    95

	int32 ret;

    96

    97

	assert(tile < MapSize());

    98

    99

	r = TerraformAllowTileProcess(ts, tile);

   100

	if (r <= 0) return r;

   101

   102

	if (IsTileType(tile, MP_RAILWAY)) {

   103

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

   104

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

   105

   106

		Slope tileh;

   107

		uint z;

   108

   109

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

   110

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

   111

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

   112

		tileh = GetTileSlope(tile, &z);

   113

		if (tileh == unsafe_slope[mode] ||

   114

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

   115

			_terraform_err_tile = tile;

   116

			_error_message = STR_1008_MUST_REMOVE_RAILROAD_TRACK;

   117

			return -1;

   118

		}

   119

   120

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

   121

		// tile can be terraformed.

   122

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

   123

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

   124

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

   125

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

   126

			 * can be lowered and this is a safe action

   127

			 */

   128

			if (tileh == SLOPE_FLAT &&

   129

					ts->direction == -1 &&

   130

					IsTunnelInWay(tile, z - TILE_HEIGHT)) {

   131

				_terraform_err_tile = tile;

   132

				_error_message = STR_1002_EXCAVATION_WOULD_DAMAGE;

   133

				return -1;

   134

			}

   135

			return 0;

   136

		}

   137

	}

   138

   139

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

   140

   141

	if (ret == CMD_ERROR) {

   142

		_terraform_err_tile = tile;

   143

		return -1;

   144

	}

   145

   146

	ts->cost += ret;

   147

   148

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

   149

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

   150

   151

	return 0;

   152

}

   153

   154

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

   155

{

   156

	int nh;

   157

	TerraformerHeightMod *mod;

   158

	int count;

   159

   160

	assert(tile < MapSize());

   161

   162

	if (height < 0) {

   163

		_error_message = STR_1003_ALREADY_AT_SEA_LEVEL;

   164

		return false;

   165

	}

   166

   167

	_error_message = STR_1004_TOO_HIGH;

   168

   169

	if (height > 15) return false;

   170

   171

	nh = TerraformGetHeightOfTile(ts, tile);

   172

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

   173

   174

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

   175

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

   176

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

   177

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

   178

   179

	mod = ts->modheight;

   180

	count = ts->modheight_count;

   181

   182

	for (;;) {

   183

		if (count == 0) {

   184

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

   185

			ts->modheight_count++;

   186

			break;

   187

		}

   188

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

   189

		mod++;

   190

		count--;

   191

	}

   192

   193

	mod->tile = tile;

   194

	mod->height = (byte)height;

   195

   196

	ts->cost += _price.terraform;

   197

   198

	{

   199

		int direction = ts->direction, r;

   200

		const TileIndexDiffC *ttm;

   201

   202

		static const TileIndexDiffC _terraform_tilepos[] = {

   203

			{ 1,  0},

   204

			{-2,  0},

   205

			{ 1,  1},

   206

			{ 0, -2}

   207

		};

   208

   209

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

   210

			tile += ToTileIndexDiff(*ttm);

   211

   212

			r = TerraformGetHeightOfTile(ts, tile);

   213

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

   214

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

   215

					return false;

   216

			}

   217

		}

   218

	}

   219

   220

	return true;

   221

}

   222

   223

/** Terraform land

   224

 * @param tile tile to terraform

   225

 * @param p1 corners to terraform.

   226

 * @param p2 direction; eg up or down

   227

 */

   228

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

   229

{

   230

	TerraformerState ts;

   231

	TileIndex t;

   232

	int direction;

   233

   234

	TerraformerHeightMod modheight_data[576];

   235

	TileIndex tile_table_data[625];

   236

   237

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   238

   239

	_terraform_err_tile = 0;

   240

   241

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

   242

	ts.flags = flags;

   243

	ts.modheight_count = ts.tile_table_count = 0;

   244

	ts.cost = 0;

   245

	ts.modheight = modheight_data;

   246

	ts.tile_table = tile_table_data;

   247

   248

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

   249

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

   250

   251

	if (p1 & 1) {

   252

		t = tile + TileDiffXY(1, 0);

   253

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

   254

			return CMD_ERROR;

   255

		}

   256

	}

   257

   258

	if (p1 & 2) {

   259

		t = tile + TileDiffXY(1, 1);

   260

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

   261

			return CMD_ERROR;

   262

		}

   263

	}

   264

   265

	if (p1 & 4) {

   266

		t = tile + TileDiffXY(0, 1);

   267

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

   268

			return CMD_ERROR;

   269

		}

   270

	}

   271

   272

	if (p1 & 8) {

   273

		t = tile + TileDiffXY(0, 0);

   274

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

   275

			return CMD_ERROR;

   276

		}

   277

	}

   278

   279

	if (direction == -1) {

   280

		/* Check if tunnel would take damage */

   281

		int count;

   282

		TileIndex *ti = ts.tile_table;

   283

   284

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

   285

			uint z, t;

   286

			TileIndex tile = *ti;

   287

   288

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

   289

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

   290

			if (t <= z) z = t;

   291

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

   292

			if (t <= z) z = t;

   293

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

   294

			if (t <= z) z = t;

   295

   296

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

   297

				return_cmd_error(STR_1002_EXCAVATION_WOULD_DAMAGE);

   298

			}

   299

		}

   300

	}

   301

   302

	if (flags & DC_EXEC) {

   303

		/* Clear the landscape at the tiles */

   304

		{

   305

			int count;

   306

			TileIndex *ti = ts.tile_table;

   307

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

   308

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

   309

			}

   310

		}

   311

   312

		/* change the height */

   313

		{

   314

			int count;

   315

			TerraformerHeightMod *mod;

   316

   317

			mod = ts.modheight;

   318

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

   319

				TileIndex til = mod->tile;

   320

   321

				SetTileHeight(til, mod->height);

   322

				TerraformAddDirtyTileAround(&ts, til);

   323

			}

   324

		}

   325

   326

		/* finally mark the dirty tiles dirty */

   327

		{

   328

			int count;

   329

			TileIndex *ti = ts.tile_table;

   330

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

   331

				MarkTileDirtyByTile(*ti);

   332

			}

   333

		}

   334

	}

   335

	return ts.cost;

   336

}

   337

   338

   339

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

   340

 * @param tile end tile of area-drag

   341

 * @param p1 start tile of area drag

   342

 * @param p2 unused

   343

 */

   344

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

   345

{

   346

	int size_x, size_y;

   347

	int ex;

   348

	int ey;

   349

	int sx, sy;

   350

	uint h, curh;

   351

	int32 ret, cost, money;

   352

   353

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

   354

   355

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   356

   357

	// remember level height

   358

	h = TileHeight(p1);

   359

   360

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

   361

	ex = TileX(tile);

   362

	ey = TileY(tile);

   363

	sx = TileX(p1);

   364

	sy = TileY(p1);

   365

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

   366

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

   367

	tile = TileXY(sx, sy);

   368

   369

	size_x = ex-sx+1;

   370

	size_y = ey-sy+1;

   371

   372

	money = GetAvailableMoneyForCommand();

   373

	cost = 0;

   374

   375

	BEGIN_TILE_LOOP(tile2, size_x, size_y, tile) {

   376

		curh = TileHeight(tile2);

   377

		while (curh != h) {

   378

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

   379

			if (CmdFailed(ret)) break;

   380

			cost += ret;

   381

   382

			if (flags & DC_EXEC) {

   383

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

   384

					_additional_cash_required = ret;

   385

					return cost - ret;

   386

				}

   387

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

   388

			}

   389

   390

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

   391

		}

   392

	} END_TILE_LOOP(tile2, size_x, size_y, tile)

   393

   394

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

   395

}

   396

   397

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

   398

 * the name is a bit confusing ;p

   399

 * @param tile the tile the player is purchasing

   400

 * @param p1 unused

   401

 * @param p2 unused

   402

 */

   403

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

   404

{

   405

	int32 cost;

   406

   407

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   408

   409

	if (!EnsureNoVehicle(tile)) return CMD_ERROR;

   410

   411

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

   412

		return_cmd_error(STR_5807_YOU_ALREADY_OWN_IT);

   413

	}

   414

   415

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

   416

	if (CmdFailed(cost)) return CMD_ERROR;

   417

   418

	if (flags & DC_EXEC) {

   419

		MakeOwnedLand(tile, _current_player);

   420

		MarkTileDirtyByTile(tile);

   421

	}

   422

   423

	return cost + _price.purchase_land * 10;

   424

}

   425

   426

   427

static int32 ClearTile_Clear(TileIndex tile, byte flags)

   428

{

   429

	static const int32* clear_price_table[] = {

   430

		&_price.clear_1,

   431

		&_price.purchase_land,

   432

		&_price.clear_2,

   433

		&_price.clear_3,

   434

		&_price.purchase_land,

   435

		&_price.purchase_land,

   436

		&_price.clear_2, // XXX unused?

   437

	};

   438

	int32 price;

   439

   440

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

   441

		price = 0;

   442

	} else {

   443

		price = *clear_price_table[GetClearGround(tile)];

   444

	}

   445

   446

	if (flags & DC_EXEC) DoClearSquare(tile);

   447

   448

	return price;

   449

}

   450

   451

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

   452

 * the name is a bit confusing ;p

   453

 * @param tile the tile the player is selling

   454

 * @param p1 unused

   455

 * @param p2 unused

   456

 */

   457

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

   458

{

   459

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   460

   461

	if (!IsOwnedLandTile(tile)) return CMD_ERROR;

   462

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

   463

   464

   465

	if (!EnsureNoVehicle(tile)) return CMD_ERROR;

   466

   467

	if (flags & DC_EXEC) DoClearSquare(tile);

   468

   469

	return - _price.purchase_land * 2;

   470

}

   471

   472

   473

#include "table/clear_land.h"

   474

   475

   476

void DrawClearLandTile(const TileInfo *ti, byte set)

   477

{

   478

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

   479

}

   480

   481

void DrawHillyLandTile(const TileInfo *ti)

   482

{

   483

	if (ti->tileh != SLOPE_FLAT) {

   484

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

   485

	} else {

   486

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

   487

	}

   488

}

   489

   490

void DrawClearLandFence(const TileInfo *ti)

   491

{

   492

	byte z = ti->z;

   493

   494

	if (ti->tileh & SLOPE_S) {

   495

		z += TILE_HEIGHT;

   496

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

   497

	}

   498