1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "tile.h"

     6

#include "viewport.h"

     7

#include "command.h"

     8

     9

typedef struct TerraformerHeightMod {

    10

	TileIndex tile;

    11

	byte height;

    12

} TerraformerHeightMod;

    13

    14

typedef struct TerraformerState {

    15

	int height[4];

    16

	uint32 flags;

    17

    18

	int direction;

    19

	int modheight_count;

    20

	int tile_table_count;

    21

    22

	int32 cost;

    23

    24

	TileIndex *tile_table;

    25

	TerraformerHeightMod *modheight;

    26

    27

} TerraformerState;

    28

    29

static int TerraformAllowTileProcess(TerraformerState *ts, TileIndex tile)

    30

{

    31

	TileIndex *t;

    32

	int count;

    33

    34

	if (TileX(tile) == MapMaxX() || TileY(tile) == MapMaxY())

    35

		return -1;

    36

    37

	t = ts->tile_table;

    38

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

    39

		if (*t == tile)

    40

			return 0;

    41

	}

    42

    43

	return 1;

    44

}

    45

    46

static int TerraformGetHeightOfTile(TerraformerState *ts, TileIndex tile)

    47

{

    48

	TerraformerHeightMod *mod = ts->modheight;

    49

	int count;

    50

    51

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

    52

		if (mod->tile == tile)

    53

			return mod->height;

    54

	}

    55

    56

	return TileHeight(tile);

    57

}

    58

    59

static void TerraformAddDirtyTile(TerraformerState *ts, TileIndex tile)

    60

{

    61

	int count;

    62

	TileIndex *t;

    63

    64

	count = ts->tile_table_count;

    65

    66

	if (count >= 625)

    67

		return;

    68

    69

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

    70

		if (*t == tile)

    71

			return;

    72

	}

    73

    74

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

    75

}

    76

    77

static void TerraformAddDirtyTileAround(TerraformerState *ts, TileIndex tile)

    78

{

    79

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

    80

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

    81

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

    82

	TerraformAddDirtyTile(ts, tile);

    83

}

    84

    85

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

    86

{

    87

	int r;

    88

	int32 ret;

    89

    90

	assert(tile < MapSize());

    91

    92

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

    93

		return r;

    94

    95

	if (IsTileType(tile, MP_RAILWAY)) {

    96

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

    97

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

    98

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

    99

   100

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

   101

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

   102

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

   103

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

   104

		if (tileh == _railway_dangslopes[mode] ||

   105

				tileh == _railway_dangslopes2[mode]) {

   106

			_terraform_err_tile = tile;

   107

			_error_message = STR_1008_MUST_REMOVE_RAILROAD_TRACK;

   108

			return -1;

   109

		}

   110

   111

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

   112

		// tile can be terraformed.

   113

		if ((_map5[tile]&~0x40) == _railway_modes[mode])

   114

			return 0;

   115

	}

   116

   117

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

   118

   119

	if (ret == CMD_ERROR) {

   120

		_terraform_err_tile = tile;

   121

		return -1;

   122

	}

   123

   124

	ts->cost += ret;

   125

   126

	if (ts->tile_table_count >= 625)

   127

		return -1;

   128

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

   129

   130

	return 0;

   131

}

   132

   133

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

   134

{

   135

	int nh;

   136

	TerraformerHeightMod *mod;

   137

	int count;

   138

   139

	assert(tile < MapSize());

   140

   141

	if (height < 0) {

   142

		_error_message = STR_1003_ALREADY_AT_SEA_LEVEL;

   143

		return false;

   144

	}

   145

   146

	_error_message = STR_1004_TOO_HIGH;

   147

   148

	if (height > 0xF)

   149

		return false;

   150

   151

	nh = TerraformGetHeightOfTile(ts, tile);

   152

	if (nh < 0 || height == nh)

   153

		return false;

   154

   155

	if (TerraformProc(ts, tile, 0)<0)

   156

		return false;

   157

   158

	if (TerraformProc(ts, tile + TILE_XY(0,-1), 1)<0)

   159

		return false;

   160

   161

	if (TerraformProc(ts, tile + TILE_XY(-1,-1), 2)<0)

   162

		return false;

   163

   164

	if (TerraformProc(ts, tile + TILE_XY(-1,0), 3)<0)

   165

		return false;

   166

   167

	mod = ts->modheight;

   168

	count = ts->modheight_count;

   169

   170

	for(;;) {

   171

		if (count == 0) {

   172

			if (ts->modheight_count >= 576)

   173

				return false;

   174

			ts->modheight_count++;

   175

			break;

   176

		}

   177

		if (mod->tile == (TileIndex)tile)

   178

			break;

   179

		mod++;

   180

		count--;

   181

	}

   182

   183

	mod->tile = (TileIndex)tile;

   184

	mod->height = (byte)height;

   185

   186

	ts->cost += _price.terraform;

   187

   188

	{

   189

		int direction = ts->direction, r;

   190

		const TileIndexDiffC *ttm;

   191

   192

		static const TileIndexDiffC _terraform_tilepos[] = {

   193

			{ 1,  0},

   194

			{-2,  0},

   195

			{ 1,  1},

   196

			{ 0, -2}

   197

		};

   198

   199

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

   200

			tile += ToTileIndexDiff(*ttm);

   201

   202

			r = TerraformGetHeightOfTile(ts, tile);

   203

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

   204

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

   205

					return false;

   206

			}

   207

		}

   208

	}

   209

   210

	return true;

   211

}

   212

   213

/** Terraform land

   214

 * @param x,y coordinates to terraform

   215

 * @param p1 corners to terraform.

   216

 * @param p2 direction; eg up or down

   217

 */

   218

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

   219

{

   220

	TerraformerState ts;

   221

	TileIndex tile;

   222

	int direction;

   223

   224

	TerraformerHeightMod modheight_data[576];

   225

	TileIndex tile_table_data[625];

   226

   227

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   228

   229

	_error_message = INVALID_STRING_ID;

   230

	_terraform_err_tile = 0;

   231

   232

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

   233

	ts.flags = flags;

   234

	ts.modheight_count = ts.tile_table_count = 0;

   235

	ts.cost = 0;

   236

	ts.modheight = modheight_data;

   237

	ts.tile_table = tile_table_data;

   238

   239

	tile = TILE_FROM_XY(x,y);

   240

   244

	if (p1 & 1) {

   245

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

   246

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

   247

					return CMD_ERROR;

   248

	}

   249

   250

	if (p1 & 2) {

   251

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

   252

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

   253

					return CMD_ERROR;

   254

	}

   255

   256

	if (p1 & 4) {

   257

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

   258

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

   259

					return CMD_ERROR;

   260

	}

   261

   262

	if (p1 & 8) {

   263

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

   264

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

   265

					return CMD_ERROR;

   266

	}

   267

   268

	if (direction == -1) {

   269

		/* Check if tunnel would take damage */

   270

		int count;

   271

		TileIndex *ti = ts.tile_table;

   272

   273

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

   274

			uint z, t;

   275

			uint tile = *ti;

   276

   277

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

   278

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

   279

			if (t <= z) z = t;

   280

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

   281

			if (t <= z) z = t;

   282

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

   283

			if (t <= z) z = t;

   284

   285

			if (!CheckTunnelInWay(tile, z*8))

   286

				return_cmd_error(STR_1002_EXCAVATION_WOULD_DAMAGE);

   287

		}

   288

	}

   289

   290

	if (flags & DC_EXEC) {

   291

		/* Clear the landscape at the tiles */

   292

		{

   293

			int count;

   294

			TileIndex *ti = ts.tile_table;

   295

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

   296

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

   297

			}

   298

		}

   299

   300

		/* change the height */

   301

		{

   302

			int count;

   303

			TerraformerHeightMod *mod;

   304

			uint til;

   305

   306

			mod = ts.modheight;

   307

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

   308

				til = mod->tile;

   309

   310

				SetTileHeight(til, mod->height);

   311

				TerraformAddDirtyTileAround(&ts, til);

   312

			}

   313

		}

   314

   315

		/* finally mark the dirty tiles dirty */

   316

		{

   317

			int count;

   318

			TileIndex *ti = ts.tile_table;

   319

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

   320

				MarkTileDirtyByTile(*ti);

   321

			}

   322

		}

   323

	}

   324

	return ts.cost;

   325

}

   326

   327

   328

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

   329

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

   330

 * @param p1 start tile of area drag

   331

 * @param p2 unused

   332

 */

   333

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

   334

{

   335

	int size_x, size_y;

   336

	int sx, sy;

   337

	uint h, curh;

   338

	TileIndex tile;

   339

	int32 ret, cost, money;

   340

   341

	if (p1 > MapSize()) return CMD_ERROR;

   342

   343

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   344

   345

	// remember level height

   346

	h = TileHeight(p1);

   347

   348

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

   349

   350

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

   351

	sx = TileX(p1);

   352

	sy = TileY(p1);

   353

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

   354

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

   355

	tile = TILE_XY(sx,sy);

   356

   357

	size_x = ex-sx+1;

   358

	size_y = ey-sy+1;

   359

   360

	money = GetAvailableMoneyForCommand();

   361

	cost = 0;

   362

   363

	BEGIN_TILE_LOOP(tile2, size_x, size_y, tile) {

   364

		curh = TileHeight(tile2);

   365

		while (curh != h) {

   366

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

   367

			if (CmdFailed(ret)) break;

   368

			cost += ret;

   369

   370

			if (flags & DC_EXEC) {

   371

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

   372

					_additional_cash_required = ret;

   373

					return cost - ret;

   374

				}

   375

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

   376

			}

   377

   378

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

   379

		}

   380

	} END_TILE_LOOP(tile2, size_x, size_y, tile)

   381

   382

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

   383

}

   384

   385

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

   386

 * the name is a bit confusing ;p

   387

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

   388

 * @param p1 unused

   389

 * @param p2 unused

   390

 */

   391

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

   392

{

   393

	TileIndex tile;

   394

	int32 cost;

   395

   396

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   397

   398

	tile = TILE_FROM_XY(x,y);

   399

   400

	if (!EnsureNoVehicle(tile)) return CMD_ERROR;

   401

   402

	if (IsTileType(tile, MP_UNMOVABLE) && _map5[tile] == 3 && _map_owner[tile] == _current_player)

   403

		return_cmd_error(STR_5807_YOU_ALREADY_OWN_IT);

   404

   405

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

   406

	if (CmdFailed(cost)) return CMD_ERROR;

   407

   408

	if (flags & DC_EXEC) {

   409

		ModifyTile(tile,

   410

			MP_SETTYPE(MP_UNMOVABLE) | MP_MAPOWNER_CURRENT | MP_MAP5,

   411

			3 /* map5 */

   412

			);

   413

	}

   414

   415

	return cost + _price.purchase_land * 10;

   416

}

   417

   418

   419

static int32 ClearTile_Clear(uint tile, byte flags)

   420

{

   421

	static const int32 * _clear_price_table[] = {

   422

			NULL,

   423

			&_price.clear_1, &_price.clear_1,&_price.clear_1,

   424

			&_price.purchase_land,&_price.purchase_land,&_price.purchase_land,&_price.purchase_land,

   425

			&_price.clear_2,&_price.clear_2,&_price.clear_2,&_price.clear_2,

   426

			&_price.clear_3,&_price.clear_3,&_price.clear_3,&_price.clear_3,

   427

			&_price.purchase_land,&_price.purchase_land,&_price.purchase_land,&_price.purchase_land,

   428

			&_price.purchase_land,&_price.purchase_land,&_price.purchase_land,&_price.purchase_land,

   429

			&_price.clear_2,&_price.clear_2,&_price.clear_2,&_price.clear_2,

   430

	};

   431

	const int32 *price = _clear_price_table[_map5[tile] & 0x1F];

   432

   433

	if (flags & DC_EXEC)

   434

		DoClearSquare(tile);

   435

   436

	if (price == NULL)

   437

		return 0;

   438

	return *price;

   439

}

   440

   441

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

   442

 * the name is a bit confusing ;p

   443

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

   444

 * @param p1 unused

   445

 * @param p2 unused

   446

 */

   447

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

   448

{

   449

	TileIndex tile;

   450

   451

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   452

   453

	tile = TILE_FROM_XY(x,y);

   454

   458

   459

	if (!EnsureNoVehicle(tile)) return CMD_ERROR;

   460

   461

	if (flags & DC_EXEC)

   462

		DoClearSquare(tile);

   463

   464

	return - _price.purchase_land * 2;

   465

}

   466

   467

   468

#include "table/clear_land.h"

   469

   470

   471

void DrawClearLandTile(TileInfo *ti, byte set)

   472

{

   473

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

   474

}

   475

   476

void DrawHillyLandTile(TileInfo *ti)

   477

{

   478

	if (ti->tileh != 0) {

   479

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

   480

	} else {

   481

		DrawGroundSprite(_landscape_clear_sprites[((ti->x^ti->y) >> 4) & 0x7]);

   482

	}

   483

}

   484

   485

void DrawClearLandFence(TileInfo *ti, byte img)

   486

{

   487

	byte z = ti->z;

   488

   489

	if (ti->tileh & 2) {

   490

		z += 8;

   491

		if (ti->tileh == 0x17)

   492

			z += 8;

   493

	}

   494

   495

	if (img & 0x38) {

   496

		DrawGroundSpriteAt(_clear_land_fence_sprites_1[((img >> 3) & 7) - 1] + _fence_mod_by_tileh[ti->tileh], ti->x, ti->y, z);

   497

	}

   498

   499

	if (img & 0x7) {

   500

		DrawGroundSpriteAt(_clear_land_fence_sprites_1[(img & 7) - 1] + _fence_mod_by_tileh_2[ti->tileh], ti->x, ti->y, z);

   501

	}

   502

}

   503

   504

static void DrawTile_Clear(TileInfo *ti)

   505

{

   506

   507

	switch((ti->map5 & (7<<2)) >> 2) {

   508

	case 0:

   509

		DrawClearLandTile(ti, (ti->map5 & 3));

   510

		break;

   511

   512

	case 1:

   513

		DrawHillyLandTile(ti);

   514

		break;

   515