1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "viewport.h"

     6

#include "command.h"

     7

     8

typedef struct TerraformerHeightMod {

     9

	TileIndex tile;

    10

	byte height;

    11

} TerraformerHeightMod;

    12

    13

typedef struct TerraformerState {

    14

	int height[4];

    15

	uint32 flags;

    16

    17

	int direction;

    18

	int modheight_count;

    19

	int tile_table_count;

    20

    21

	int32 cost;

    22

    23

	TileIndex *tile_table;

    24

	TerraformerHeightMod *modheight;

    25

    26

} TerraformerState;

    27

    28

static int TerraformAllowTileProcess(TerraformerState *ts, TileIndex tile)

    29

{

    30

	TileIndex *t;

    31

	int count;

    32

    33

	if ((GET_TILE_X(tile) == TILE_X_MAX) || (GET_TILE_Y(tile) == TILE_Y_MAX))

    34

		return -1;

    35

    36

	t = ts->tile_table;

    37

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

    38

		if (*t == tile)

    39

			return 0;

    40

	}

    41

    42

	return 1;

    43

}

    44

    45

static int TerraformGetHeightOfTile(TerraformerState *ts, TileIndex tile)

    46

{

    47

	TerraformerHeightMod *mod = ts->modheight;

    48

	int count;

    49

    50

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

    51

		if (mod->tile == tile)

    52

			return mod->height;

    53

	}

    54

    55

	return _map_type_and_height[tile] & 0xF;

    56

}

    57

    58

static void TerraformAddDirtyTile(TerraformerState *ts, TileIndex tile)

    59

{

    60

	int count;

    61

	TileIndex *t;

    62

    63

	count = ts->tile_table_count;

    64

    65

	if (count >= 625)

    66

		return;

    67

    68

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

    69

		if (*t == tile)

    70

			return;

    71

	}

    72

    73

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

    74

}

    75

    76

static void TerraformAddDirtyTileAround(TerraformerState *ts, TileIndex tile)

    77

{

    78

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

    79

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

    80

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

    81

	TerraformAddDirtyTile(ts, tile);

    82

}

    83

    84

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

    85

{

    86

	int r;

    87

	int32 ret;

    88

    89

	assert(tile < TILES_X * TILES_Y);

    90

    91

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

    92

		return r;

    93

    94

	if ((_map_type_and_height[tile] >> 4) == MP_RAILWAY) {

    95

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

    96

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

    97

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

    98

    99

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

   100

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

   101

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

   102

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

   103

		if (tileh == _railway_dangslopes[mode] ||

   104

				tileh == _railway_dangslopes2[mode]) {

   105

			_terraform_err_tile = tile;

   106

			_error_message = STR_1008_MUST_REMOVE_RAILROAD_TRACK;

   107

			return -1;

   108

		}

   109

   110

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

   111

		// tile can be terraformed.

   112

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

   113

			return 0;

   114

	}

   115

   116

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

   117

   118

	if (ret == CMD_ERROR) {

   119

		_terraform_err_tile = tile;

   120

		return -1;

   121

	}

   122

   123

	ts->cost += ret;

   124

   125

	if (ts->tile_table_count >= 625)

   126

		return -1;

   127

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

   128

   129

	return 0;

   130

}

   131

   132

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

   133

{

   134

	int nh;

   135

	TerraformerHeightMod *mod;

   136

	int count;

   137

   138

	assert(tile < TILES_X * TILES_Y);

   139

   140

	if (height < 0) {

   141

		_error_message = STR_1003_ALREADY_AT_SEA_LEVEL;

   142

		return false;

   143

	}

   144

   145

	_error_message = STR_1004_TOO_HIGH;

   146

   147

	if (height > 0xF)

   148

		return false;

   149

   150

	nh = TerraformGetHeightOfTile(ts, tile);

   151

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

   152

		return false;

   153

   154

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

   155

		return false;

   156

   157

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

   158

		return false;

   159

   160

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

   161

		return false;

   162

   163

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

   164

		return false;

   165

   166

	mod = ts->modheight;

   167

	count = ts->modheight_count;

   168

   169

	for(;;) {

   170

		if (count == 0) {

   171

			if (ts->modheight_count >= 576)

   172

				return false;

   173

			ts->modheight_count++;

   174

			break;

   175

		}

   176

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

   177

			break;

   178

		mod++;

   179

		count--;

   180

	}

   181

   182

	mod->tile = (TileIndex)tile;

   183

	mod->height = (byte)height;

   184

   185

	ts->cost += _price.terraform;

   186

   187

	{

   188

		int direction = ts->direction, r;

   189

		const TileIndexDiff *ttm;

   190

   191

		static const TileIndexDiff _terraform_tilepos[5] = {TILE_XY(1,0), TILE_XY(-2,0), TILE_XY(1,1), TILE_XY(0,-2), 0 };

   192

   193

		for(ttm = _terraform_tilepos; *ttm != 0; ttm++) {

   194

			tile += *ttm;

   195

   196

			r = TerraformGetHeightOfTile(ts, tile);

   197

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

   198

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

   199

					return false;

   200

			}

   201

		}

   202

	}

   203

   204

	return true;

   205

}

   206

   207

/* Terraform land

   208

 * p1 - corners

   209

 * p2 - direction

   210

 */

   211

   212

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

   213

{

   214

	TerraformerState ts;

   215

	uint tile;

   216

	int direction;

   217

   218

	TerraformerHeightMod modheight_data[576];

   219

	TileIndex tile_table_data[625];

   220

   221

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   222

   223

	_error_message = INVALID_STRING_ID;

   224

	_terraform_err_tile = 0;

   225

   226

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

   227

	ts.flags = flags;

   228

	ts.modheight_count = ts.tile_table_count = 0;

   229

	ts.cost = 0;

   230

	ts.modheight = modheight_data;

   231

	ts.tile_table = tile_table_data;

   232

   233

	tile = TILE_FROM_XY(x,y);

   234

   235

	if (p1 & 1) {

   236

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

   237

				(_map_type_and_height[tile+TILE_XY(1,0)]&0xF) + direction))

   238

					return CMD_ERROR;

   239

	}

   240

   241

	if (p1 & 2) {

   242

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

   243

				(_map_type_and_height[tile+TILE_XY(1,1)]&0xF) + direction))

   244

					return CMD_ERROR;

   245

	}

   246

   247

	if (p1 & 4) {

   248

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

   249

				(_map_type_and_height[tile+TILE_XY(0,1)]&0xF) + direction))

   250

					return CMD_ERROR;

   251

	}

   252

   253

	if (p1 & 8) {

   254

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

   255

				(_map_type_and_height[tile+TILE_XY(0,0)]&0xF) + direction))

   256

					return CMD_ERROR;

   257

	}

   258

   259

	if (direction == -1) {

   260

		/* Check if tunnel would take damage */

   261

		int count;

   262

		TileIndex *ti = ts.tile_table;

   263

   264

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

   265

			uint z, t;

   266

			uint tile = *ti;

   267

   268

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

   269

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

   270

			if (t <= z) z = t;

   271

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

   272

			if (t <= z) z = t;

   273

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

   274

			if (t <= z) z = t;

   275

   276

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

   277

				return_cmd_error(STR_1002_EXCAVATION_WOULD_DAMAGE);

   278

		}

   279

	}

   280

   281

	if (flags & DC_EXEC) {

   282

		/* Clear the landscape at the tiles */

   283

		{

   284

			int count;

   285

			TileIndex *ti = ts.tile_table;

   286

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

   287

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

   288

			}

   289

		}

   290

   291

		/* change the height */

   292

		{

   293

			int count;

   294

			TerraformerHeightMod *mod;

   295

			uint til;

   296

   297

			mod = ts.modheight;

   298

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

   299

				til = mod->tile;

   300

   301

				// Change tile height

   302

				_map_type_and_height[til] = (_map_type_and_height[til]&~0x0F)|mod->height;

   303

   304

				TerraformAddDirtyTileAround(&ts, til);

   305

			}

   306

		}

   307

   308

		/* finally mark the dirty tiles dirty */

   309

		{

   310

			int count;

   311

			TileIndex *ti = ts.tile_table;

   312

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

   313

				MarkTileDirtyByTile(*ti);

   314

			}

   315

		}

   316

	}

   317

	return ts.cost;

   318

}

   319

   320

   321

/*

   322

 * p1 - start

   323

 */

   324

   325

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

   326

{

   327

	int size_x, size_y;

   328

	int sx, sy;

   329

	uint h, curh;

   330

	uint tile;

   331

	int32 ret, cost, money;

   332

   333

	// remember level height

   334

	h = _map_type_and_height[p1]&0xF;

   335

   336

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

   337

   338

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

   339

	sx = GET_TILE_X(p1);

   340

	sy = GET_TILE_Y(p1);

   341

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

   342

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

   343

	tile = TILE_XY(sx,sy);

   344

   345

	size_x = ex-sx+1;

   346

	size_y = ey-sy+1;

   347

   348

	money = GetAvailableMoneyForCommand();

   349

	cost = 0;

   350

   351

	BEGIN_TILE_LOOP(tile2, size_x, size_y, tile)

   352

		curh = _map_type_and_height[tile2]&0xF;

   353

		while (curh != h) {

   354

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

   355

			if (ret == CMD_ERROR) break;

   356

			cost += ret;

   357

   358

			if (flags & DC_EXEC) {

   359

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

   360

					_additional_cash_required = ret;

   361

					return cost - ret;

   362

				}

   363

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

   364

			}

   365

   366

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

   367

		}

   368

	END_TILE_LOOP(tile2, size_x, size_y, tile)

   369

   370

	if (cost == 0) return CMD_ERROR;

   371

	return cost;

   372

}

   373

   374

/* Purchase a land area

   375

 * p1 = unused

   376

 * p2 = unused

   377

 */

   378

   379

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

   380

{

   381

	uint tile;

   382

	int32 cost;

   383

   384

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   385

   386

	tile = TILE_FROM_XY(x,y);

   387

   388

	if (!EnsureNoVehicle(tile))

   389

		return CMD_ERROR;

   390

   391

	if (IS_TILETYPE(tile, MP_UNMOVABLE) &&

   392

			_map5[tile] == 3 &&

   393

			_map_owner[tile] == _current_player)

   394

		return_cmd_error(STR_5807_YOU_ALREADY_OWN_IT);

   395

   396

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

   397

	if (cost == CMD_ERROR)

   398

		return CMD_ERROR;

   399

   400

	if (flags & DC_EXEC) {

   401

		ModifyTile(tile,

   402

			MP_SETTYPE(MP_UNMOVABLE) | MP_MAPOWNER_CURRENT | MP_MAP5,

   403

			3 /* map5 */

   404

			);

   405

	}

   406

   407

	return cost + _price.purchase_land * 10;

   408

}

   409

   410

   411

int32 ClearTile_Clear(uint tile, byte flags) {

   412

	static const int32 * _clear_price_table[] = {

   413

			NULL,

   414

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

   415

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

   416

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

   417

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

   418

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

   419

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

   420

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

   421

	};

   422

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

   423

   424

	if (flags & DC_EXEC)

   425

		DoClearSquare(tile);

   426

   427

	if (price == NULL)

   428

		return 0;

   429

	return *price;

   430

}

   431

   432

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

   433

{

   434

	uint tile;

   435

   436

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   437

   438

	tile = TILE_FROM_XY(x,y);

   439

   440

	if (!CheckTileOwnership(tile) && _current_player != OWNER_WATER)

   441

		return CMD_ERROR;

   442

   443

	if (!EnsureNoVehicle(tile))

   444

		return CMD_ERROR;

   445

   446

	if (flags & DC_EXEC)

   447

		DoClearSquare(tile);

   448

   449

	return - _price.purchase_land*2;

   450

}

   451

   452

   453

#include "table/clear_land.h"

   454

   455

   456

void DrawClearLandTile(TileInfo *ti, byte set)

   457

{

   458

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

   459

}

   460

   461

void DrawHillyLandTile(TileInfo *ti)

   462

{

   463

	if (ti->tileh != 0) {

   464

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

   465

	} else {

   466

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

   467

	}

   468

}

   469

   470

void DrawClearLandFence(TileInfo *ti, byte img)

   471

{

   472

	byte z = ti->z;

   473

   474

	if (ti->tileh & 2) {

   475

		z += 8;

   476

		if (ti->tileh == 0x17)

   477

			z += 8;

   478

	}

   479

   480

	if (img & 0x38) {

   481

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

   482

	}

   483

   484

	if (img & 0x7) {

   485

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

   486

	}

   487

}

   488

   489

static void DrawTile_Clear(TileInfo *ti)

   490

{

   491

   492

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

   493

	case 0:

   494

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

   495

		break;

   496

   497

	case 1:

   498

		DrawHillyLandTile(ti);

   499

		break;

   500

   501

	case 2:

   502

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

   503

		break;

   504

   505

	case 3:

   506

		DrawGroundSprite( _clear_land_sprites_1[_map3_lo[ti->tile]&0xF] + _tileh_to_sprite[ti->tileh]);

   507

		break;

   508

   509

	case 4:

   510

		DrawGroundSprite( _clear_land_sprites_2[ti->map5&3] + _tileh_to_sprite[ti->tileh]);

   511

		break;

   512

   513

	case 5:

   514

		DrawGroundSprite( _clear_land_sprites_3[ti->map5&3] + _tileh_to_sprite[ti->tileh]);

   515

		break;

   516

	}

   517

   518

	DrawClearLandFence(ti, _map3_hi[ti->tile] >> 2);

   519

}

   520

   521

uint GetSlopeZ_Clear(TileInfo *ti) { return GetPartialZ(ti->x&0xF, ti->y&0xF, ti->tileh) + ti->z; }

   522

   523

uint GetSlopeTileh_Clear(TileInfo *ti)

   524

{