1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "clear_map.h"

     6

#include "table/strings.h"

     7

#include "functions.h"

     8

#include "map.h"

     9

#include "player.h"

    10

#include "tile.h"

    11

#include "viewport.h"

    12

#include "command.h"

    13

#include "tunnel_map.h"

    14

#include "variables.h"

    15

#include "table/sprites.h"

    16

    17

typedef struct TerraformerHeightMod {

    18

	TileIndex tile;

    19

	byte height;

    20

} TerraformerHeightMod;

    21

    22

typedef struct TerraformerState {

    23

	int height[4];

    24

	uint32 flags;

    25

    26

	int direction;

    27

	int modheight_count;

    28

	int tile_table_count;

    29

    30

	int32 cost;

    31

    32

	TileIndex *tile_table;

    33

	TerraformerHeightMod *modheight;

    34

    35

} TerraformerState;

    36

    37

static int TerraformAllowTileProcess(TerraformerState *ts, TileIndex tile)

    38

{

    39

	TileIndex *t;

    40

	int count;

    41

    42

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

    43

    44

	t = ts->tile_table;

    45

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

    46

		if (*t == tile) return 0;

    47

	}

    48

    49

	return 1;

    50

}

    51

    52

static int TerraformGetHeightOfTile(TerraformerState *ts, TileIndex tile)

    53

{

    54

	TerraformerHeightMod *mod = ts->modheight;

    55

	int count;

    56

    57

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

    58

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

    59

	}

    60

    61

	return TileHeight(tile);

    62

}

    63

    64

static void TerraformAddDirtyTile(TerraformerState *ts, TileIndex tile)

    65

{

    66

	int count;

    67

	TileIndex *t;

    68

    69

	count = ts->tile_table_count;

    70

    71

	if (count >= 625) return;

    72

    73

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

    74

		if (*t == tile) return;

    75

	}

    76

    77

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

    78

}

    79

    80

static void TerraformAddDirtyTileAround(TerraformerState *ts, TileIndex tile)

    81

{

    82

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

    83

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

    84

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

    85

	TerraformAddDirtyTile(ts, tile);

    86

}

    87

    88

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

    89

{

    90

	int r;

    91

	bool skip_clear = false;

    92

    93

	assert(tile < MapSize());

    94

    95

	if ((r=TerraformAllowTileProcess(ts, tile)) <= 0)

    96

		return r;

    97

    98

	if (IsTileType(tile, MP_RAILWAY)) {

    99

		static const byte _railway_modes[4] = {8, 0x10, 4, 0x20};

   100

		static const byte _railway_dangslopes[4] = {0xd, 0xe, 7, 0xb};

   101

		static const byte _railway_dangslopes2[4] = {0x2, 0x1, 0x8, 0x4};

   102

   103

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

   104

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

   105

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

   106

		int tileh = GetTileSlope(tile, NULL) & 0xF;

   107

		if (tileh == _railway_dangslopes[mode] ||

   108

				tileh == _railway_dangslopes2[mode]) {

   109

			_terraform_err_tile = tile;

   110

			_error_message = STR_1008_MUST_REMOVE_RAILROAD_TRACK;

   111

			return -1;

   112

		}

   113

   114

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

   115

		// tile can be terraformed.

   116

		if ((_m[tile].m5 & ~0x40) == _railway_modes[mode]) {

   117

			if (ts->direction == 1) return 0;

   118

			skip_clear = true;

   119

		}

   120

	}

   121

   122

	if (!skip_clear) {

   123

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

   124

   125

		if (CmdFailed(ret)) {

   126

			_terraform_err_tile = tile;

   127

			return -1;

   128

		}

   129

   130

		ts->cost += ret;

   131

	}

   132

   133

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

   134

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

   135

   136

	return 0;

   137

}

   138

   139

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

   140

{

   141

	int nh;

   142

	TerraformerHeightMod *mod;

   143

	int count;

   144

   145

	assert(tile < MapSize());

   146

   147

	if (height < 0) {

   148

		_error_message = STR_1003_ALREADY_AT_SEA_LEVEL;

   149

		return false;

   150

	}

   151

   152

	_error_message = STR_1004_TOO_HIGH;

   153

   154

	if (height > 15) return false;

   155

   156

	nh = TerraformGetHeightOfTile(ts, tile);

   157

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

   158

   159

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

   160

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

   161

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

   162

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

   163

   164

	mod = ts->modheight;

   165

	count = ts->modheight_count;

   166

   167

	for (;;) {

   168

		if (count == 0) {

   169

			if (ts->modheight_count >= 576)

   170

				return false;

   171

			ts->modheight_count++;

   172

			break;

   173

		}

   174

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

   175

		mod++;

   176

		count--;

   177

	}

   178

   179

	mod->tile = tile;

   180

	mod->height = (byte)height;

   181

   182

	ts->cost += _price.terraform;

   183

   184

	{

   185

		int direction = ts->direction, r;

   186

		const TileIndexDiffC *ttm;

   187

   188

		static const TileIndexDiffC _terraform_tilepos[] = {

   189

			{ 1,  0},

   190

			{-2,  0},

   191

			{ 1,  1},

   192

			{ 0, -2}

   193

		};

   194

   195

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

   196

			tile += ToTileIndexDiff(*ttm);

   197

   198

			r = TerraformGetHeightOfTile(ts, tile);

   199

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

   200

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

   201

					return false;

   202

			}

   203

		}

   204

	}

   205

   206

	return true;

   207

}

   208

   209

/** Terraform land

   210

 * @param x,y coordinates to terraform

   211

 * @param p1 corners to terraform.

   212

 * @param p2 direction; eg up or down

   213

 */

   214

int32 CmdTerraformLand(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   215

{

   216

	TerraformerState ts;

   217

	TileIndex tile;

   218

	int direction;

   219

   220

	TerraformerHeightMod modheight_data[576];

   221

	TileIndex tile_table_data[625];

   222

   223

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   224

   225

	_error_message = INVALID_STRING_ID;

   226

	_terraform_err_tile = 0;

   227

   228

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

   229

	ts.flags = flags;

   230

	ts.modheight_count = ts.tile_table_count = 0;

   231

	ts.cost = 0;

   232

	ts.modheight = modheight_data;

   233

	ts.tile_table = tile_table_data;

   234

   235

	tile = TileVirtXY(x, y);

   236

   237

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

   238

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

   239

   240

	if (p1 & 1) {

   241

		if (!TerraformTileHeight(&ts, tile + TileDiffXY(1, 0),

   242

				TileHeight(tile + TileDiffXY(1, 0)) + direction))

   243

					return CMD_ERROR;

   244

	}

   245

   246

	if (p1 & 2) {

   247

		if (!TerraformTileHeight(&ts, tile + TileDiffXY(1, 1),

   248

				TileHeight(tile + TileDiffXY(1, 1)) + direction))

   249

					return CMD_ERROR;

   250

	}

   251

   252

	if (p1 & 4) {

   253

		if (!TerraformTileHeight(&ts, tile + TileDiffXY(0, 1),

   254

				TileHeight(tile + TileDiffXY(0, 1)) + direction))

   255

					return CMD_ERROR;

   256

	}

   257

   258

	if (p1 & 8) {

   259

		if (!TerraformTileHeight(&ts, tile + TileDiffXY(0, 0),

   260

				TileHeight(tile + TileDiffXY(0, 0)) + direction))

   261

					return CMD_ERROR;

   262

	}

   263

   264

	if (direction == -1) {

   265

		/* Check if tunnel would take damage */

   266

		int count;

   267

		TileIndex *ti = ts.tile_table;

   268

   269

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

   270

			uint z, t;

   271

			TileIndex tile = *ti;

   272

   273

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

   274

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

   275

			if (t <= z) z = t;

   276

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

   277

			if (t <= z) z = t;

   278

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

   279

			if (t <= z) z = t;

   280

   281

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

   282

				return_cmd_error(STR_1002_EXCAVATION_WOULD_DAMAGE);

   283

			}

   284

		}

   285

	}

   286

   287

	if (flags & DC_EXEC) {

   288

		/* Clear the landscape at the tiles */

   289

		{

   290

			int count;

   291

			TileIndex *ti = ts.tile_table;

   292

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

   293

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

   294

			}

   295

		}

   296

   297

		/* change the height */

   298

		{

   299

			int count;

   300

			TerraformerHeightMod *mod;

   301

   302

			mod = ts.modheight;

   303

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

   304

				TileIndex til = mod->tile;

   305

   306

				SetTileHeight(til, mod->height);

   307

				TerraformAddDirtyTileAround(&ts, til);

   308

			}

   309

		}

   310

   311

		/* finally mark the dirty tiles dirty */

   312

		{

   313

			int count;

   314

			TileIndex *ti = ts.tile_table;

   315

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

   316

				MarkTileDirtyByTile(*ti);

   317

			}

   318

		}

   319

	}

   320

	return ts.cost;

   321

}

   322

   323

   324

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

   325

 * @param x,y end tile of area-drag

   326

 * @param p1 start tile of area drag

   327

 * @param p2 unused

   328

 */

   329

int32 CmdLevelLand(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)

   330

{

   331

	int size_x, size_y;

   332

	int sx, sy;

   333

	uint h, curh;

   334

	TileIndex tile;

   335

	int32 ret, cost, money;

   336

   337

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

   338

   339

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   340

   341

	// remember level height

   342

	h = TileHeight(p1);

   343

   344

	ex >>= 4; ey >>= 4;

   345

   346

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

   347

	sx = TileX(p1);

   348

	sy = TileY(p1);

   349

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

   350

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

   351

	tile = TileXY(sx, sy);

   352

   353

	size_x = ex-sx+1;

   354

	size_y = ey-sy+1;

   355

   356

	money = GetAvailableMoneyForCommand();

   357

	cost = 0;

   358

   359

	BEGIN_TILE_LOOP(tile2, size_x, size_y, tile) {

   360

		curh = TileHeight(tile2);

   361

		while (curh != h) {

   362

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

   363

			if (CmdFailed(ret)) break;

   364

			cost += ret;

   365

   366

			if (flags & DC_EXEC) {

   367

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

   368

					_additional_cash_required = ret;

   369

					return cost - ret;

   370

				}

   371

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

   372

			}

   373

   374

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

   375

		}

   376

	} END_TILE_LOOP(tile2, size_x, size_y, tile)

   377

   378

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

   379

}

   380

   381

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

   382

 * the name is a bit confusing ;p

   383

 * @param x,y the tile the player is purchasing

   384

 * @param p1 unused

   385

 * @param p2 unused

   386

 */

   387

int32 CmdPurchaseLandArea(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   388

{

   389

	TileIndex tile;

   390

	int32 cost;

   391

   392

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   393

   394

	tile = TileVirtXY(x, y);

   395

   396

	if (!EnsureNoVehicle(tile)) return CMD_ERROR;

   397

   398

	if (IsTileType(tile, MP_UNMOVABLE) && _m[tile].m5 == 3 &&

   399

			IsTileOwner(tile, _current_player))

   400

		return_cmd_error(STR_5807_YOU_ALREADY_OWN_IT);

   401

   402

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

   403

	if (CmdFailed(cost)) return CMD_ERROR;

   404

   405

	if (flags & DC_EXEC) {

   406

		ModifyTile(tile,

   407

			MP_SETTYPE(MP_UNMOVABLE) | MP_MAPOWNER_CURRENT | MP_MAP5,

   408

			3 /* map5 */

   409

			);

   410

	}

   411

   412

	return cost + _price.purchase_land * 10;

   413

}

   414

   415

   416

static int32 ClearTile_Clear(TileIndex tile, byte flags)

   417

{

   418

	static const int32* clear_price_table[] = {

   419

		&_price.clear_1,

   420

		&_price.purchase_land,

   421

		&_price.clear_2,

   422

		&_price.clear_3,

   423

		&_price.purchase_land,

   424

		&_price.purchase_land,

   425

		&_price.clear_2, // XXX unused?

   426

	};

   427

	int32 price;

   428

   429

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

   430

		price = 0;

   431

	} else {

   432

		price = *clear_price_table[GetClearGround(tile)];

   433

	}

   434

   435

	if (flags & DC_EXEC) DoClearSquare(tile);

   436

   437

	return price;

   438

}

   439

   440

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

   441

 * the name is a bit confusing ;p

   442

 * @param x,y the tile the player is selling

   443

 * @param p1 unused

   444

 * @param p2 unused

   445

 */

   446

int32 CmdSellLandArea(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   447

{

   448

	TileIndex tile;

   449

   450

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   451

   452

	tile = TileVirtXY(x, y);

   453

   454

	if (!IsTileType(tile, MP_UNMOVABLE) || _m[tile].m5 != 3) return CMD_ERROR;

   455

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

   456

   457

   458

	if (!EnsureNoVehicle(tile)) return CMD_ERROR;

   459

   460

	if (flags & DC_EXEC)

   461

		DoClearSquare(tile);

   462

   463

	return - _price.purchase_land * 2;

   464

}

   465

   466

   467

#include "table/clear_land.h"

   468

   469

   470

void DrawClearLandTile(const TileInfo *ti, byte set)

   471

{

   472

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

   473

}

   474

   475

void DrawHillyLandTile(const TileInfo *ti)

   476

{

   477

	if (ti->tileh != 0) {

   478

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

   479

	} else {

   480

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

   481

	}

   482

}

   483

   484

void DrawClearLandFence(const TileInfo *ti)

   485

{

   486

	byte z = ti->z;

   487

   488

	if (ti->tileh & 2) {

   489

		z += 8;

   490

		if (ti->tileh == 0x17) z += 8;

   491

	}

   492

   493

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

   494

		DrawGroundSpriteAt(_clear_land_fence_sprites_1[GetFenceSW(ti->tile) - 1] + _fence_mod_by_tileh[ti->tileh], ti->x, ti->y, z);

   495

	}

   496

   497

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

   498

		DrawGroundSpriteAt(_clear_land_fence_sprites_1[GetFenceSE(ti->tile) - 1] + _fence_mod_by_tileh_2[ti->tileh], ti->x, ti->y, z);

   499

	}

   500

}

   501

   502

static void DrawTile_Clear(TileInfo *ti)

   503

{