1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "viewport.h"

     5

#include "command.h"

     6

     7

typedef struct TerraformerHeightMod {

     8

	TileIndex tile;

     9

	byte height;

    10

} TerraformerHeightMod;

    11

    12

typedef struct TerraformerState {

    13

	int height[4];

    14

	uint32 flags;

    15

    16

	int direction;

    17

	int modheight_count;

    18

	int tile_table_count;

    19

    20

	int32 cost;

    21

    22

	TileIndex *tile_table;

    23

	TerraformerHeightMod *modheight;

    24

    25

} TerraformerState;

    26

    27

static int TerraformAllowTileProcess(TerraformerState *ts, TileIndex tile)

    28

{

    29

	TileIndex *t;

    30

	int count;

    31

    32

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

    33

		return -1;

    34

    35

	t = ts->tile_table;

    36

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

    37

		if (*t == tile)

    38

			return 0;

    39

	}

    40

    41

	return 1;

    42

}

    43

    44

static int TerraformGetHeightOfTile(TerraformerState *ts, TileIndex tile)

    45

{

    46

	TerraformerHeightMod *mod = ts->modheight;

    47

	int count;

    48

    49

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

    50

		if (mod->tile == tile)

    51

			return mod->height;

    52

	}

    53

    54

	return _map_type_and_height[tile] & 0xF;

    55

}

    56

    57

static void TerraformAddDirtyTile(TerraformerState *ts, TileIndex tile)

    58

{

    59

	int count;

    60

	TileIndex *t;

    61

    62

	count = ts->tile_table_count;

    63

    64

	if (count >= 625)

    65

		return;

    66

    67

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

    68

		if (*t == tile)

    69

			return;

    70

	}

    71

    72

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

    73

}

    74

    75

static void TerraformAddDirtyTileAround(TerraformerState *ts, TileIndex tile)

    76

{

    77

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

    78

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

    79

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

    80

	TerraformAddDirtyTile(ts, tile);

    81

}

    82

    83

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

    84

{

    85

	int r;

    86

	int32 ret;

    87

    88

	assert(tile < TILES_X * TILES_Y);

    89

    90

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

    91

		return r;

    92

    93

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

    94

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

    95

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

    96

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

    97

    98

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

    99

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

   100

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

   101

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

   102

		if (tileh == _railway_dangslopes[mode] ||

   103

				tileh == _railway_dangslopes2[mode]) {

   104

			_terraform_err_tile = tile;

   105

			_error_message = STR_1008_MUST_REMOVE_RAILROAD_TRACK;

   106

			return -1;

   107

		}

   108

   109

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

   110

		// tile can be terraformed.

   111

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

   112

			return 0;

   113

	}

   114

   115

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

   116

   117

	if (ret == CMD_ERROR) {

   118

		_terraform_err_tile = tile;

   119

		return -1;

   120

	}

   121

   122

	ts->cost += ret;

   123

   124

	if (ts->tile_table_count >= 625)

   125

		return -1;

   126

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

   127

   128

	return 0;

   129

}

   130

   131

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

   132

{

   133

	int nh;

   134

	TerraformerHeightMod *mod;

   135

	int count;

   136

   137

	assert(tile < TILES_X * TILES_Y);

   138

   139

	if (height < 0) {

   140

		_error_message = STR_1003_ALREADY_AT_SEA_LEVEL;

   141

		return false;

   142

	}

   143

   144

	_error_message = STR_1004_TOO_HIGH;

   145

   146

	if (height > 0xF)

   147

		return false;

   148

   149

	nh = TerraformGetHeightOfTile(ts, tile);

   150

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

   151

		return false;

   152

   153

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

   154

		return false;

   155

   156

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

   157

		return false;

   158

   159

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

   160

		return false;

   161

   162

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

   163

		return false;

   164

   165

	mod = ts->modheight;

   166

	count = ts->modheight_count;

   167

   168

	for(;;) {

   169

		if (count == 0) {

   170

			if (ts->modheight_count >= 576)

   171

				return false;

   172

			ts->modheight_count++;

   173

			break;

   174

		}

   175

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

   176

			break;

   177

		mod++;

   178

		count--;

   179

	}

   180

   181

	mod->tile = (TileIndex)tile;

   182

	mod->height = (byte)height;

   183

   184

	ts->cost += _price.terraform;

   185

   186

	{

   187

		int direction = ts->direction, r;

   188

		const TileIndexDiff *ttm;

   189

   190

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

   191

   192

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

   193

			tile += *ttm;

   194

   195

			r = TerraformGetHeightOfTile(ts, tile);

   196

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

   197

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

   198

					return false;

   199

			}

   200

		}

   201

	}

   202

   203

	return true;

   204

}

   205

   206

/* Terraform land

   207

 * p1 - corners

   208

 * p2 - direction

   209

 */

   210

   211

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

   212

{

   213

	TerraformerState ts;

   214

	uint tile;

   215

	int direction;

   216

   217

	TerraformerHeightMod modheight_data[576];

   218

	TileIndex tile_table_data[625];

   219

   220

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   221

   222

	_error_message = INVALID_STRING_ID;

   223

	_terraform_err_tile = 0;

   224

   225

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

   226

	ts.flags = flags;

   227

	ts.modheight_count = ts.tile_table_count = 0;

   228

	ts.cost = 0;

   229

	ts.modheight = modheight_data;

   230

	ts.tile_table = tile_table_data;

   231

   232

	tile = TILE_FROM_XY(x,y);

   233

   234

	if (p1 & 1) {

   235

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

   236

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

   237

					return CMD_ERROR;

   238

	}

   239

   240

	if (p1 & 2) {

   241

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

   242

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

   243

					return CMD_ERROR;

   244

	}

   245

   246

	if (p1 & 4) {

   247

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

   248

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

   249

					return CMD_ERROR;

   250

	}

   251

   252

	if (p1 & 8) {

   253

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

   254

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

   255

					return CMD_ERROR;

   256

	}

   257

   258

	if (direction == -1) {

   259

		/* Check if tunnel would take damage */

   260

		int count;

   261

		TileIndex *ti = ts.tile_table;

   262

   263

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

   264

			uint z, t;

   265

			uint tile = *ti;

   266

   267

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

   268

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

   269

			if (t <= z) z = t;

   270

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

   271

			if (t <= z) z = t;

   272

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

   273

			if (t <= z) z = t;

   274

   275

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

   276

				return_cmd_error(STR_1002_EXCAVATION_WOULD_DAMAGE);

   277

		}

   278

	}

   279

   280

	if (flags & DC_EXEC) {

   281

		/* Clear the landscape at the tiles */

   282

		{

   283

			int count;

   284

			TileIndex *ti = ts.tile_table;

   285

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

   286

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

   287

			}

   288

		}

   289

   290

		/* change the height */

   291

		{

   292

			int count;

   293

			TerraformerHeightMod *mod;

   294

			uint til;

   295

   296

			mod = ts.modheight;

   297

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

   298

				til = mod->tile;

   299

   300

				// Change tile height

   301

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

   302

   303

				TerraformAddDirtyTileAround(&ts, til);

   304

			}

   305

		}

   306

   307

		/* finally mark the dirty tiles dirty */

   308

		{

   309

			int count;

   310

			TileIndex *ti = ts.tile_table;

   311

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

   312

				MarkTileDirtyByTile(*ti);

   313

			}

   314

		}

   315

	}

   316

	return ts.cost;

   317

}

   318

   319

   320

/*

   321

 * p1 - start

   322

 */

   323

   324

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

   325

{

   326

	int size_x, size_y;

   327

	int sx, sy;

   328

	uint h, curh;

   329

	uint tile;

   330

	int32 ret, cost, money;

   331

   332

	// remember level height

   333

	h = _map_type_and_height[p1]&0xF;

   334

   335

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

   336

   337

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

   338

	sx = GET_TILE_X(p1);

   339

	sy = GET_TILE_Y(p1);

   340

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

   341

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

   342

	tile = TILE_XY(sx,sy);

   343

   344

	size_x = ex-sx+1;

   345

	size_y = ey-sy+1;

   346

   347

	money = GetAvailableMoneyForCommand();

   348

	cost = 0;

   349

   350

	BEGIN_TILE_LOOP(tile2, size_x, size_y, tile)

   351

		curh = _map_type_and_height[tile2]&0xF;

   352

		while (curh != h) {

   353

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

   354

			if (ret == CMD_ERROR) break;

   355

			cost += ret;

   356

   357

			if (flags & DC_EXEC) {

   358

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

   359

					_additional_cash_required = ret;

   360

					return cost - ret;

   361

				}

   362

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

   363

			}

   364

   365

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

   366

		}

   367

	END_TILE_LOOP(tile2, size_x, size_y, tile)

   368

   369

	if (cost == 0) return CMD_ERROR;

   370

	return cost;

   371

}

   372

   373

/* Purchase a land area

   374

 * p1 = unused

   375

 * p2 = unused

   376

 */

   377

   378

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

   379

{

   380

	uint tile;

   381

	int32 cost;

   382

   383

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   384

   385

	tile = TILE_FROM_XY(x,y);

   386

   387

	if (!EnsureNoVehicle(tile))

   388

		return CMD_ERROR;

   389

   390

	if (IS_TILETYPE(tile, MP_UNMOVABLE) &&

   391

			_map5[tile] == 3 &&

   392

			_map_owner[tile] == _current_player)

   393

		return_cmd_error(STR_5807_YOU_ALREADY_OWN_IT);

   394

   395

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

   396

	if (cost == CMD_ERROR)

   397

		return CMD_ERROR;

   398

   399

	if (flags & DC_EXEC) {

   400

		ModifyTile(tile,

   401

			MP_SETTYPE(MP_UNMOVABLE) | MP_MAPOWNER_CURRENT | MP_MAP5,

   402

			3 /* map5 */

   403

			);

   404

	}

   405

   406

	return cost + _price.purchase_land * 10;

   407

}

   408

   409

   410

int32 ClearTile_Clear(uint tile, byte flags) {

   411

	static const int32 * _clear_price_table[] = {

   412

			NULL,

   413

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

   414

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

   415

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

   416

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

   417

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

   418

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

   419

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

   420

	};

   421

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

   422

   423

	if (flags & DC_EXEC)

   424

		DoClearSquare(tile);

   425

   426

	if (price == NULL)

   427

		return 0;

   428

	return *price;

   429

}

   430

   431

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

   432

{

   433

	uint tile;

   434

   435

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   436

   437

	tile = TILE_FROM_XY(x,y);

   438

   439

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

   440

		return CMD_ERROR;

   441

   442

	if (!EnsureNoVehicle(tile))

   443

		return CMD_ERROR;

   444

   445

	if (flags & DC_EXEC)

   446

		DoClearSquare(tile);

   447

   448

	return - _price.purchase_land*2;

   449

}

   450

   451

   452

#include "table/clear_land.h"

   453

   454

   455

void DrawClearLandTile(TileInfo *ti, byte set)

   456

{

   457

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

   458

}

   459

   460

void DrawHillyLandTile(TileInfo *ti)

   461

{

   462

	if (ti->tileh != 0) {

   463

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

   464

	} else {

   465

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

   466

	}

   467

}

   468

   469

void DrawClearLandFence(TileInfo *ti, byte img)

   470

{

   471

	byte z = ti->z;

   472

   473

	if (ti->tileh & 2) {

   474

		z += 8;

   475

		if (ti->tileh == 0x17)

   476

			z += 8;

   477

	}

   478

   479

	if (img & 0x38) {

   480

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

   481

	}

   482

   483

	if (img & 0x7) {

   484

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

   485

	}

   486

}

   487

   488

static void DrawTile_Clear(TileInfo *ti)

   489

{

   490

   491

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

   492

	case 0:

   493

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

   494

		break;

   495

   496

	case 1:

   497

		DrawHillyLandTile(ti);

   498

		break;

   499

   500

	case 2:

   501

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

   502

		break;

   503

   504

	case 3:

   505

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

   506

		break;

   507

   508

	case 4:

   509

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

   510

		break;

   511

   512

	case 5:

   513

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

   514

		break;

   515

	}

   516

   517

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

   518

}

   519

   520

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

   521

   522

uint GetSlopeTileh_Clear(TileInfo *ti)

   523

{

   524

	return ti->tileh;