1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "tile.h"

     6

#include "vehicle.h"

     7

#include "viewport.h"

     8

#include "command.h"

     9

#include "town.h"

    10

#include "news.h"

    11

#include "sound.h"

    12

    13

static void FloodVehicle(Vehicle *v);

    14

    15

bool IsShipDepotTile(TileIndex tile)

    16

{

    17

	return IsTileType(tile, MP_WATER) && (_map5[tile] & ~3) == 0x80;

    18

}

    19

    20

static bool IsClearWaterTile(uint tile)

    21

{

    22

	TileInfo ti;

    23

	FindLandscapeHeightByTile(&ti, tile);

    24

	return (ti.type == MP_WATER && ti.tileh == 0 && ti.map5 == 0);

    25

}

    26

    27

/* Build a ship depot

    28

 * p1 - direction

    29

 */

    30

    31

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

    32

{

    33

	uint tile, tile2;

    34

    35

	int32 cost, ret;

    36

	Depot *dep;

    37

    38

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

    39

    40

	tile = TILE_FROM_XY(x,y);

    41

	if (!EnsureNoVehicle(tile))

    42

		return CMD_ERROR;

    43

    44

	tile2 = tile + (p1 ? TILE_XY(0,1) : TILE_XY(1,0));

    45

	if (!EnsureNoVehicle(tile2))

    46

		return CMD_ERROR;

    47

    48

	if (!IsClearWaterTile(tile) || !IsClearWaterTile(tile2))

    49

		return_cmd_error(STR_3801_MUST_BE_BUILT_ON_WATER);

    50

    51

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

    52

	if (ret == CMD_ERROR) return CMD_ERROR;

    53

	ret = DoCommandByTile(tile2, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

    54

	if (ret == CMD_ERROR)

    55

		return CMD_ERROR;

    56

    57

	// pretend that we're not making land from the water even though we actually are.

    58

	cost = 0;

    59

    60

	dep = AllocateDepot();

    61

	if (dep == NULL)

    62

		return CMD_ERROR;

    63

    64

	if (flags & DC_EXEC) {

    65

		dep->xy = tile;

    66

		_last_built_ship_depot_tile = tile;

    67

		dep->town_index = ClosestTownFromTile(tile, (uint)-1)->index;

    68

    69

		ModifyTile(tile,

    70

			MP_SETTYPE(MP_WATER) | MP_MAPOWNER_CURRENT | MP_MAP5 | MP_MAP2_CLEAR | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR,

    71

			(0x80 + p1*2)

    72

		);

    73

    74

		ModifyTile(tile2,

    75

			MP_SETTYPE(MP_WATER) | MP_MAPOWNER_CURRENT | MP_MAP5 | MP_MAP2_CLEAR | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR,

    76

			(0x81 + p1*2)

    77

		);

    78

	}

    79

    80

	return cost + _price.build_ship_depot;

    81

}

    82

    83

static int32 RemoveShipDepot(uint tile, uint32 flags)

    84

{

    85

	uint tile2;

    86

    87

	if (!CheckTileOwnership(tile))

    88

		return CMD_ERROR;

    89

    90

	if (!EnsureNoVehicle(tile))

    91

		return CMD_ERROR;

    92

    93

	tile2 = tile + ((_map5[tile] & 2) ? TILE_XY(0,1) : TILE_XY(1,0));

    94

    95

	if (!EnsureNoVehicle(tile2))

    96

		return CMD_ERROR;

    97

    98

	if (flags & DC_EXEC) {

    99

		Depot *d;

   100

   101

		// convert the cleared tiles to water

   102

		ModifyTile(tile, MP_SETTYPE(MP_WATER) | MP_MAPOWNER | MP_MAP5 | MP_MAP2_CLEAR | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR, OWNER_WATER, 0);

   103

		ModifyTile(tile2, MP_SETTYPE(MP_WATER) | MP_MAPOWNER | MP_MAP5 | MP_MAP2_CLEAR | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR, OWNER_WATER, 0);

   104

   105

		// Kill the entry from the depot table

   106

		for(d=_depots; d->xy != tile; d++) {}

   107

		d->xy = 0;

   108

   109

		DeleteWindowById(WC_VEHICLE_DEPOT, tile);

   110

	}

   111

   112

	return _price.remove_ship_depot;

   113

}

   114

   115

// build a shiplift

   116

static int32 DoBuildShiplift(uint tile, int dir, uint32 flags)

   117

{

   118

	int32 ret;

   119

	int delta;

   120

   121

	// middle tile

   122

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

   123

	if (ret == CMD_ERROR) return CMD_ERROR;

   124

   125

	delta = TileOffsByDir(dir);

   126

	// lower tile

   127

	ret = DoCommandByTile(tile - delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

   128

	if (ret == CMD_ERROR) return CMD_ERROR;

   129

	if (GetTileSlope(tile - delta, NULL)) return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

   130

   131

	// upper tile

   132

	ret = DoCommandByTile(tile + delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

   133

	if (ret == CMD_ERROR) return CMD_ERROR;

   134

	if (GetTileSlope(tile + delta, NULL)) return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

   135

   136

	if (flags & DC_EXEC) {

   137

		ModifyTile(tile, MP_SETTYPE(MP_WATER) | MP_MAPOWNER | MP_MAP5 | MP_MAP2_CLEAR | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR, OWNER_WATER, 0x10 + dir);

   138

		ModifyTile(tile - delta, MP_SETTYPE(MP_WATER) | MP_MAPOWNER | MP_MAP5 | MP_MAP2_CLEAR | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR, OWNER_WATER, 0x14 + dir);

   139

		ModifyTile(tile + delta, MP_SETTYPE(MP_WATER) | MP_MAPOWNER | MP_MAP5 | MP_MAP2_CLEAR | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR, OWNER_WATER, 0x18 + dir);

   140

	}

   141

   142

	return _price.clear_water * 22 >> 3;

   143

}

   144

   145

static int32 RemoveShiplift(uint tile, uint32 flags)

   146

{

   147

	TileIndexDiff delta = TileOffsByDir(_map5[tile] & 3);

   148

   149

	// make sure no vehicle is on the tile.

   150

	if (!EnsureNoVehicle(tile) || !EnsureNoVehicle(tile + delta) || !EnsureNoVehicle(tile - delta))

   151

		return CMD_ERROR;

   152

   153

	if (flags & DC_EXEC) {

   154

		DoClearSquare(tile);

   155

		DoClearSquare(tile + delta);

   156

		DoClearSquare(tile - delta);

   157

	}

   158

   159

	return _price.clear_water * 2;

   160

}

   161

   162

static void MarkTilesAroundDirty(uint tile)

   163

{

   164

	MarkTileDirtyByTile(TILE_ADDXY(tile, 0, 1));

   165

	MarkTileDirtyByTile(TILE_ADDXY(tile, 0, -1));

   166

	MarkTileDirtyByTile(TILE_ADDXY(tile, 1, 0));

   167

	MarkTileDirtyByTile(TILE_ADDXY(tile, -1, 0));

   168

}

   169

   170

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

   171

{

   172

	uint tile = TILE_FROM_XY(x,y);

   173

	int32 ret;

   174

	uint th;

   175

   176

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   177

	th = GetTileSlope(tile, NULL);

   178

   179

	if (th==3 || th==6 || th==9 || th==12) {

   180

		static const byte _shiplift_dirs[16] = {0,0,0,2,0,0,1,0,0,3,0,0,0};

   181

		ret = DoBuildShiplift(tile, _shiplift_dirs[th], flags);

   182

		return ret;

   183

		}

   184

	else

   185

		return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

   186

}

   187

   188

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

   189

{

   190

	uint tile = TILE_FROM_XY(x,y);

   191

	int32 ret;

   192

	uint th;

   193

	uint endtile = (uint)p1;

   194

	int delta;

   195

	int32 cost;

   196

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   197

   198

	// move in which direction?

   199

	delta = (TileX(tile) == TileX(endtile)) ? TILE_XY(0,1) : TILE_XY(1,0);

   200

	if (endtile < tile) delta = -delta;

   201

   202

	cost = 0;

   203

	for(;;) {

   204

		ret = 0;

   205

		th = GetTileSlope(tile, NULL);

   206

		if(th!=0)

   207

			return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);

   208

   209

			// can't make water of water!

   210

			if (IsTileType(tile, MP_WATER)) {

   211

				_error_message = STR_1007_ALREADY_BUILT;

   212

			} else {

   213

   214

				/* is middle piece of a bridge? */

   215

				if (IsTileType(tile, MP_TUNNELBRIDGE) && _map5[tile] & 0x40) { /* build under bridge */

   216

					if(_map5[tile] & 0x20) { // transport route under bridge

   217

						_error_message = STR_5800_OBJECT_IN_THE_WAY;

   218

						ret = CMD_ERROR;

   219

					}

   220

					else if (_map5[tile] & 0x18) { // already water under bridge

   221

						_error_message = STR_1007_ALREADY_BUILT;

   222

						ret = CMD_ERROR;

   223

					}

   224

   225

				/* no bridge? then try to clear it. */

   226

				} else  {

   227

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

   228

				}

   229

				if (ret == CMD_ERROR) return ret;

   230

				cost += ret;

   231

   232

				/* execute modifications */

   233

				if (flags & DC_EXEC) {

   234

					if (IsTileType(tile, MP_TUNNELBRIDGE)) {

   235

						// change owner to OWNER_WATER and set land under bridge bit to water

   236

						ModifyTile(tile, MP_MAP5 | MP_MAPOWNER, OWNER_WATER, _map5[tile] | 0x08);

   237

					} else {

   238

						ModifyTile(tile, MP_SETTYPE(MP_WATER) | MP_MAPOWNER | MP_MAP5 | MP_MAP2_CLEAR | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR, OWNER_WATER, 0);

   239

					}

   240

					// mark the tiles around dirty too

   241

					MarkTilesAroundDirty(tile);

   242

				}

   243

   244

				cost += _price.clear_water;

   245

			}

   246

		if (tile == endtile)

   247

			break;

   248

		tile += delta;

   249

	}

   250

	if (cost == 0) return CMD_ERROR;

   251

   252

	return cost;

   253

}

   254

   255

static int32 ClearTile_Water(uint tile, byte flags) {

   256

	byte m5 = _map5[tile];

   257

	uint slope;

   258

   259

	if (m5 <= 1) { // water and shore

   260

		// Allow building on water? It's ok to build on shores.

   261

		if (flags & DC_NO_WATER && m5 != 1)

   262

			return_cmd_error(STR_3807_CAN_T_BUILD_ON_WATER);

   263

   264

		// Make sure no vehicle is on the tile

   265

		if (!EnsureNoVehicle(tile))

   266

			return CMD_ERROR;

   267

   268

		// Make sure it's not an edge tile.

   269

		if (!(IS_INT_INSIDE(TileX(tile), 1, MapMaxX() - 1) &&

   270

				IS_INT_INSIDE(TileY(tile), 1, MapMaxY() - 1)))

   271

			return_cmd_error(STR_0002_TOO_CLOSE_TO_EDGE_OF_MAP);

   272

   273

		if (m5 == 0) {

   274

			if (flags & DC_EXEC)

   275

				DoClearSquare(tile);

   276

			return _price.clear_water;

   277

		} else if (m5 == 1) {

   278

			slope = GetTileSlope(tile,NULL);

   279

			if (slope == 8 || slope == 4 || slope == 2 || slope == 1) {

   280

				if (flags & DC_EXEC)

   281

					DoClearSquare(tile);

   282

				return _price.clear_water;

   283

			}

   284

			if (flags & DC_EXEC)

   285

				DoClearSquare(tile);

   286

			return _price.purchase_land;

   287

		} else

   288

			return CMD_ERROR;

   289

	} else if ((m5 & 0x10) == 0x10) {

   290

		// shiplift

   291

   292

		static const TileIndexDiffC _shiplift_tomiddle_offs[] = {

   293

			{ 0,  0}, {0,  0}, { 0, 0}, {0,  0}, // middle

   294

			{-1,  0}, {0,  1}, { 1, 0}, {0, -1}, // lower

   295

			{ 1,  0}, {0, -1}, {-1, 0}, {0,  1}, // upper

   296

		};

   297

   298

		if (flags & DC_AUTO) return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

   299

		// don't allow water to delete it.

   300

		if (_current_player == OWNER_WATER) return CMD_ERROR;

   301

		// move to the middle tile..

   302

		return RemoveShiplift(tile + ToTileIndexDiff(_shiplift_tomiddle_offs[m5 & 0xF]), flags);

   303

	} else {

   304

		// ship depot

   305

		if (flags & DC_AUTO)

   306

			return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

   307

   308

		if (m5 == 0x80 || m5 == 0x82) {}

   309

		else if (m5 == 0x81) { tile -= TILE_XY(1,0); }

   310

		else if (m5 == 0x83) { tile -= TILE_XY(0,1); }

   311

		else

   312

			return CMD_ERROR;

   313

   314

		return RemoveShipDepot(tile,flags);

   315

	}

   316

}

   317

   318

// return true if a tile is a water tile.

   319

static bool IsWateredTile(TileIndex tile)

   320

{

   321

	byte m5 = _map5[tile];

   322

   323

	switch (GetTileType(tile)) {

   324

		case MP_WATER:

   325

			// true, if not coast/riverbank

   326

			return m5 != 1;

   327

   328

		case MP_STATION:

   329

			// returns true if it is a dock-station

   330

			// m5 inside values is m5 < 75 all stations, 83 <= m5 <= 114 new airports

   331

			return !(m5 < 75 || (m5 >= 83 && m5 <= 114));

   332

   333

		case MP_TUNNELBRIDGE:

   334

			// true, if tile is middle part of bridge with water underneath

   335

			return (m5 & 0xF8) == 0xC8;

   336

   337

		default:

   338

			return false;

   339

	}

   340

}

   341

   342

// draw a canal styled water tile with dikes around

   343

void DrawCanalWater(uint tile)

   344

{

   345

	uint wa;

   346

   347

	// determine the edges around with water.

   348

	wa = IsWateredTile(TILE_ADDXY(tile, -1, 0)) << 0;

   349

	wa += IsWateredTile(TILE_ADDXY(tile, 0, 1)) << 1;

   350

	wa += IsWateredTile(TILE_ADDXY(tile, 1, 0)) << 2;

   351

	wa += IsWateredTile(TILE_ADDXY(tile, 0, -1)) << 3;

   352

   353

	if (!(wa & 1)) DrawGroundSprite(SPR_CANALS_BASE + 57);

   354

	if (!(wa & 2)) DrawGroundSprite(SPR_CANALS_BASE + 58);

   355

	if (!(wa & 4)) DrawGroundSprite(SPR_CANALS_BASE + 59);

   356

	if (!(wa & 8)) DrawGroundSprite(SPR_CANALS_BASE + 60);

   357

   358

	// right corner

   359

	if ((wa & 3) == 0) DrawGroundSprite(SPR_CANALS_BASE + 57 + 4);

   360

	else if ((wa & 3) == 3 && !IsWateredTile(TILE_ADDXY(tile, -1, 1))) DrawGroundSprite(SPR_CANALS_BASE + 57 + 8);

   361

   362

	// bottom corner

   363

	if ((wa & 6) == 0) DrawGroundSprite(SPR_CANALS_BASE + 57 + 5);

   364

	else if ((wa & 6) == 6 && !IsWateredTile(TILE_ADDXY(tile, 1, 1))) DrawGroundSprite(SPR_CANALS_BASE + 57 + 9);

   365

   366

	// left corner

   367

	if ((wa & 12) == 0) DrawGroundSprite(SPR_CANALS_BASE + 57 + 6);

   368

	else if ((wa & 12) == 12 && !IsWateredTile(TILE_ADDXY(tile, 1, -1))) DrawGroundSprite(SPR_CANALS_BASE + 57 + 10);

   369

   370

	// upper corner

   371

	if ((wa & 9) == 0) DrawGroundSprite(SPR_CANALS_BASE + 57 + 7);

   372

	else if ((wa & 9) == 9 && !IsWateredTile(TILE_ADDXY(tile, -1, -1))) DrawGroundSprite(SPR_CANALS_BASE + 57 + 11);

   373

}

   374

   375

typedef struct WaterDrawTileStruct {

   376

	int8 delta_x;

   377

	int8 delta_y;

   378

	int8 delta_z;

   379

	byte width;

   380

	byte height;

   381

	byte unk;

   382

	SpriteID image;

   383

} WaterDrawTileStruct;

   384

   385

typedef struct LocksDrawTileStruct {

   386

	int8 delta_x, delta_y, delta_z;

   387

	byte width, height, depth;

   388

	SpriteID image;

   389

} LocksDrawTileStruct;

   390

   391

#include "table/water_land.h"

   392

   393

static void DrawWaterStuff(TileInfo *ti, const byte *t, uint32 palette, uint base)

   394

{

   395

	const WaterDrawTileStruct *wdts;

   396

	uint32 image;

   397

   398

	DrawGroundSprite(*(const uint16*)t);

   399

	t += sizeof(uint16);

   400

   401

	for(wdts = (const WaterDrawTileStruct *)t; (byte)wdts->delta_x != 0x80; wdts++) {

   402

		image =	wdts->image + base;

   403

		if (_display_opt & DO_TRANS_BUILDINGS) {

   404

			image = (image & 0x3FFF) | 0x03224000;

   405

		} else {

   406

			image |= palette;

   407

		}

   408

		AddSortableSpriteToDraw(image, ti->x + wdts->delta_x, ti->y + wdts->delta_y, wdts->width, wdts->height, wdts->unk, ti->z + wdts->delta_z);

   409

	}

   410

}

   411

   412

static void DrawTile_Water(TileInfo *ti)

   413

{

   414

	// draw water tile

   415

	if (ti->map5 == 0) {

   416

		DrawGroundSprite(0xFDD);

   417

		if (ti->z != 0) DrawCanalWater(ti->tile);

   418

		return;

   419

	}

   420

   421

	// draw shore

   422

	if (ti->map5 == 1) {

   423

		assert(ti->tileh < 16);

   424

		DrawGroundSprite(_water_shore_sprites[ti->tileh]);

   425

		return;

   426

	}

   427

   428

	// draw shiplift

   429

	if ((ti->map5 & 0xF0) == 0x10) {

   430

		const byte *t = _shiplift_display_seq[ti->map5 & 0xF];

   431

		DrawWaterStuff(ti, t, 0, ti->z > t[19] ? 24 : 0);

   432

		return;

   433

	}

   434

   435

	DrawWaterStuff(ti, _shipdepot_display_seq[ti->map5 & 0x7F], PLAYER_SPRITE_COLOR(_map_owner[ti->tile]), 0);

   436

}

   437

   438

void DrawShipDepotSprite(int x, int y, int image)

   439

{

   440

	const byte *t;

   441

	const WaterDrawTileStruct *wdts;

   442

   443

	t = _shipdepot_display_seq[image];

   444

	DrawSprite(*(const uint16*)t, x, y);

   445

	t += sizeof(uint16);

   446

   447

	for(wdts = (const WaterDrawTileStruct *)t; (byte)wdts->delta_x != 0x80; wdts++) {

   448

		Point pt = RemapCoords(wdts->delta_x, wdts->delta_y, wdts->delta_z);

   449

		DrawSprite(wdts->image + PLAYER_SPRITE_COLOR(_local_player), x + pt.x, y + pt.y);

   450

	}

   451

}

   452

   453

   454

static uint GetSlopeZ_Water(TileInfo *ti)

   455

{

   456

	return GetPartialZ(ti->x&0xF, ti->y&0xF, ti->tileh) + ti->z;

   457

}

   458

   459

static uint GetSlopeTileh_Water(TileInfo *ti)

   460

{

   461

	return ti->tileh;

   462

}

   463

   464

static void GetAcceptedCargo_Water(uint tile, AcceptedCargo ac)

   465

{

   466

	/* not used */

   467

}

   468

   469

static void GetTileDesc_Water(uint tile, TileDesc *td)

   470

{

   471

	if (_map5[tile] == 0 && TilePixelHeight(tile) == 0)

   472

		td->str = STR_3804_WATER;

   473

	else if (_map5[tile] == 0)

   474

		td->str = STR_LANDINFO_CANAL;

   475

	else if (_map5[tile] == 1)

   476

		td->str = STR_3805_COAST_OR_RIVERBANK;

   477

	else if ((_map5[tile]&0xF0) == 0x10)

   478

		td->str = STR_LANDINFO_LOCK;

   479

	else

   480

		td->str = STR_3806_SHIP_DEPOT;

   481

   482

	td->owner = _map_owner[tile];

   483

}

   484

   485

static void AnimateTile_Water(uint tile)

   486

{

   487

	/* not used */

   488

}

   489

   490

static void TileLoopWaterHelper(TileIndex tile, const TileIndexDiffC *offs)

   491

{

   492

	TileIndex target = TILE_ADD(tile, ToTileIndexDiff(offs[0]));

   493

   494

	// type of this tile mustn't be water already.

   495

	if (IsTileType(target, MP_WATER))

   496

		return;

   497

   498

	if (TileHeight(TILE_ADD(tile, ToTileIndexDiff(offs[1]))) != 0 ||

   499

			TileHeight(TILE_ADD(tile, ToTileIndexDiff(offs[2]))) != 0)

   500

		return;

   501

   502

	if (TileHeight(TILE_ADD(tile, ToTileIndexDiff(offs[3]))) != 0 ||

   503

			TileHeight(TILE_ADD(tile, ToTileIndexDiff(offs[4]))) != 0) {

   504

		// make coast..

   505

		switch (GetTileType(target)) {

   506

			case MP_RAILWAY: {

   507

				uint slope = GetTileSlope(target, NULL);

   508

				byte tracks = _map5[target] & 0x3F;

   509

				if (!(

   510

						(slope == 1 && tracks == 0x20) ||

   511

						(slope == 2 && tracks == 0x04) ||

   512

						(slope == 4 && tracks == 0x10) ||

   513

						(slope == 8 && tracks == 0x08)))

   514

					break;

   515

			}

   516

			/* FALLTHROUGH */

   517