1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/sprites.h"

     4

#include "table/strings.h"

     5

#include "map.h"

     6

#include "tile.h"

     7

#include "vehicle.h"

     8

#include "viewport.h"

     9

#include "command.h"

    10

#include "town.h"

    11

#include "news.h"

    12

#include "sound.h"

    13

#include "depot.h"

    15

    16

static void FloodVehicle(Vehicle *v);

    17

    18

static bool IsClearWaterTile(uint tile)

    19

{

    20

	TileInfo ti;

    21

	FindLandscapeHeightByTile(&ti, tile);

    22

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

    23

}

    24

    25

/* Build a ship depot

    26

 * p1 - direction

    27

 */

    28

    29

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

    30

{

    31

	uint tile, tile2;

    32

    33

	int32 cost, ret;

    34

	Depot *depot;

    35

    36

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

    37

    38

	tile = TILE_FROM_XY(x,y);

    39

	if (!EnsureNoVehicle(tile))

    40

		return CMD_ERROR;

    41

    42

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

    43

	if (!EnsureNoVehicle(tile2))

    44

		return CMD_ERROR;

    45

    46

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

    47

		return_cmd_error(STR_3801_MUST_BE_BUILT_ON_WATER);

    48

    49

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

    50

	if (ret == CMD_ERROR) return CMD_ERROR;

    51

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

    52

	if (ret == CMD_ERROR)

    53

		return CMD_ERROR;

    54

    55

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

    56

	cost = 0;

    57

    58

	depot = AllocateDepot();

    59

	if (depot == NULL)

    60

		return CMD_ERROR;

    61

    62

	if (flags & DC_EXEC) {

    63

		depot->xy = tile;

    64

		_last_built_ship_depot_tile = tile;

    65

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

    66

    67

		ModifyTile(tile,

    68

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

    69

			(0x80 + p1*2)

    70

		);

    71

    72

		ModifyTile(tile2,

    73

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

    74

			(0x81 + p1*2)

    75

		);

    76

	}

    77

    78

	return cost + _price.build_ship_depot;

    79

}

    80

    81

static int32 RemoveShipDepot(uint tile, uint32 flags)

    82

{

    83

	uint tile2;

    84

    85

	if (!CheckTileOwnership(tile))

    86

		return CMD_ERROR;

    87

    88

	if (!EnsureNoVehicle(tile))

    89

		return CMD_ERROR;

    90

    91

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

    92

    93

	if (!EnsureNoVehicle(tile2))

    94

		return CMD_ERROR;

    95

    96

	if (flags & DC_EXEC) {

    97

		/* Kill the depot */

    98

		DoDeleteDepot(tile);

    99

   100

		/* Make the tiles water */

   101

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

   102

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

   103

	}

   104

   105

	return _price.remove_ship_depot;

   106

}

   107

   108

// build a shiplift

   109

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

   110

{

   111

	int32 ret;

   112

	int delta;

   113

   114

	// middle tile

   115

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

   116

	if (ret == CMD_ERROR) return CMD_ERROR;

   117

   118

	delta = TileOffsByDir(dir);

   119

	// lower tile

   120

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

   121

	if (ret == CMD_ERROR) return CMD_ERROR;

   122

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

   123

   124

	// upper tile

   125

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

   126

	if (ret == CMD_ERROR) return CMD_ERROR;

   127

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

   128

   129

	if (flags & DC_EXEC) {

   130

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

   131

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

   132

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

   133

	}

   134

   135

	return _price.clear_water * 22 >> 3;

   136

}

   137

   138

static int32 RemoveShiplift(uint tile, uint32 flags)

   139

{

   140

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

   141

   142

	// make sure no vehicle is on the tile.

   143

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

   144

		return CMD_ERROR;

   145

   146

	if (flags & DC_EXEC) {

   147

		DoClearSquare(tile);

   148

		DoClearSquare(tile + delta);

   149

		DoClearSquare(tile - delta);

   150

	}

   151

   152

	return _price.clear_water * 2;

   153

}

   154

   155

static void MarkTilesAroundDirty(uint tile)

   156

{

   157

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

   158

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

   159

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

   160

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

   161

}

   162

   163

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

   164

{

   165

	uint tile = TILE_FROM_XY(x,y);

   166

	int32 ret;

   167

	uint th;

   168

   169

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   170

	th = GetTileSlope(tile, NULL);

   171

   172

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

   173

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

   174

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

   175

		return ret;

   176

		}

   177

	else

   178

		return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

   179

}

   180

   181

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

   182

{

   183

	int32 ret, cost;

   184

	int size_x, size_y;

   185

	int sx = TileX((TileIndex)p1);

   186

	int sy = TileY((TileIndex)p1);

   187

	x >>= 4; y >>= 4;

   188

   189

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   190

   191

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

   192

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

   193

	size_x = (x - sx) + 1;

   194

	size_y = (y - sy) + 1;

   195

   196

	cost = 0;

   197

	BEGIN_TILE_LOOP(tile, size_x, size_y, TILE_XY(sx, sy)) {

   198

		ret = 0;

   199

		if (GetTileSlope(tile, NULL) != 0)

   200

			return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);

   201

   202

			// can't make water of water!

   203

			if (IsTileType(tile, MP_WATER)) {

   204

				_error_message = STR_1007_ALREADY_BUILT;

   205

			} else {

   206

				/* is middle piece of a bridge? */

   207

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

   208

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

   209

						_error_message = STR_5800_OBJECT_IN_THE_WAY;

   210

						ret = CMD_ERROR;

   211

					}

   212

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

   213

						_error_message = STR_1007_ALREADY_BUILT;

   214

						ret = CMD_ERROR;

   215

					}

   216

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

   217

				} else

   218

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

   219

   220

				if (ret == CMD_ERROR) return ret;

   221

				cost += ret;

   222

   223

				/* execute modifications */

   224

				if (flags & DC_EXEC) {

   225

					if (IsTileType(tile, MP_TUNNELBRIDGE)) {

   226

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

   227

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

   228

					} else {

   229

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

   230

					}

   231

					// mark the tiles around dirty too

   232

					MarkTilesAroundDirty(tile);

   233

				}

   234

   235

				cost += _price.clear_water;

   236

			}

   237

	} END_TILE_LOOP(tile, size_x, size_y, 0);

   238

   239

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

   240

}

   241

   242

static int32 ClearTile_Water(uint tile, byte flags) {

   243

	byte m5 = _map5[tile];

   244

	uint slope;

   245

   246

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

   247

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

   248

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

   249

			return_cmd_error(STR_3807_CAN_T_BUILD_ON_WATER);

   250

   251

		// Make sure no vehicle is on the tile

   252

		if (!EnsureNoVehicle(tile))

   253

			return CMD_ERROR;

   254

   255

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

   256

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

   257

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

   258

			return_cmd_error(STR_0002_TOO_CLOSE_TO_EDGE_OF_MAP);

   259

   260

		if (m5 == 0) {

   261

			if (flags & DC_EXEC)

   262

				DoClearSquare(tile);

   263

			return _price.clear_water;

   264

		} else if (m5 == 1) {

   265

			slope = GetTileSlope(tile,NULL);

   266

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

   267

				if (flags & DC_EXEC)

   268

					DoClearSquare(tile);

   269

				return _price.clear_water;

   270

			}

   271

			if (flags & DC_EXEC)

   272

				DoClearSquare(tile);

   273

			return _price.purchase_land;

   274

		} else

   275

			return CMD_ERROR;

   276

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

   277

		// shiplift

   278

   279

		static const TileIndexDiffC _shiplift_tomiddle_offs[] = {

   280

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

   281

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

   282

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

   283

		};

   284

   285

		if (flags & DC_AUTO) return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

   286

		// don't allow water to delete it.

   287

		if (_current_player == OWNER_WATER) return CMD_ERROR;

   288

		// move to the middle tile..

   289

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

   290

	} else {

   291

		// ship depot

   292

		if (flags & DC_AUTO)

   293

			return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

   294

   295

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

   296

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

   297

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

   298

		else

   299

			return CMD_ERROR;

   300

   301

		return RemoveShipDepot(tile,flags);

   302

	}

   303

}

   304

   305

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

   306

static bool IsWateredTile(TileIndex tile)

   307

{

   308

	byte m5 = _map5[tile];

   309

   310

	switch (GetTileType(tile)) {

   311

		case MP_WATER:

   312

			// true, if not coast/riverbank

   313

			return m5 != 1;

   314

   315

		case MP_STATION:

   316

			// returns true if it is a dock-station

   317

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

   318

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

   319

   320

		case MP_TUNNELBRIDGE:

   321

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

   322

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

   323

   324

		default:

   325

			return false;

   326

	}

   327

}

   328

   329

// draw a canal styled water tile with dikes around

   330

void DrawCanalWater(uint tile)

   331

{

   332

	uint wa;

   333

   334

	// determine the edges around with water.

   335

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

   336

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

   337

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

   338

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

   339

   340

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

   341

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

   342

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

   343

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

   344

   345

	// right corner

   346

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

   347

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

   348

   349

	// bottom corner

   350

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

   351

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

   352

   353

	// left corner

   354

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

   355

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

   356

   357

	// upper corner

   358

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

   359

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

   360

}

   361

   362

typedef struct LocksDrawTileStruct {

   363

	int8 delta_x, delta_y, delta_z;

   364

	byte width, height, depth;

   365

	SpriteID image;

   366

} LocksDrawTileStruct;

   367

   368

#include "table/water_land.h"

   369

   370

static void DrawWaterStuff(TileInfo *ti, const WaterDrawTileStruct *wdts,

   371

	uint32 palette, uint base

   372

)

   373

{

   374

	uint32 image;

   375

   376

	DrawGroundSprite(wdts++->image);

   377

   378

	for (; wdts->delta_x != 0x80; wdts++) {

   379

		image =	wdts->image + base;

   380

		if (_display_opt & DO_TRANS_BUILDINGS) {

   381

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

   382

		} else {

   383

			image |= palette;

   384

		}

   385

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

   386

	}

   387

}

   388

   389

static void DrawTile_Water(TileInfo *ti)

   390

{

   391

	// draw water tile

   392

	if (ti->map5 == 0) {

   393

		DrawGroundSprite(0xFDD);

   394

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

   395

		return;

   396

	}

   397

   398

	// draw shore

   399

	if (ti->map5 == 1) {

   400

		assert(ti->tileh < 16);

   401

		DrawGroundSprite(_water_shore_sprites[ti->tileh]);

   402

		return;

   403

	}

   404

   405

	// draw shiplift

   406

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

   407

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

   408

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

   409

		return;

   410

	}

   411

   412

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

   413

}

   414

   415

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

   416

{

   417

	const WaterDrawTileStruct *wdts = _shipdepot_display_seq[image];

   418

   419

	DrawSprite(wdts++->image, x, y);

   420

   421

	for (; wdts->delta_x != 0x80; wdts++) {

   422

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

   423

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

   424

	}

   425

}

   426

   427

   428

static uint GetSlopeZ_Water(TileInfo *ti)

   429

{

   430

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

   431

}

   432

   433

static uint GetSlopeTileh_Water(TileInfo *ti)

   434

{

   435

	return ti->tileh;

   436

}

   437

   438

static void GetAcceptedCargo_Water(uint tile, AcceptedCargo ac)

   439

{

   440

	/* not used */

   441

}

   442

   443

static void GetTileDesc_Water(uint tile, TileDesc *td)

   444

{

   445

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

   446

		td->str = STR_3804_WATER;

   447

	else if (_map5[tile] == 0)

   448

		td->str = STR_LANDINFO_CANAL;

   449

	else if (_map5[tile] == 1)

   450

		td->str = STR_3805_COAST_OR_RIVERBANK;

   451

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

   452

		td->str = STR_LANDINFO_LOCK;

   453

	else

   454

		td->str = STR_3806_SHIP_DEPOT;

   455

   456

	td->owner = _map_owner[tile];

   457

}

   458

   459

static void AnimateTile_Water(uint tile)

   460

{

   461

	/* not used */

   462

}

   463

   464

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

   465

{

   466

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

   467

   468

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

   469

	if (IsTileType(target, MP_WATER))

   470

		return;

   471

   472

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

   473

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

   474

		return;

   475

   476

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

   477

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

   478

		// make coast..

   479

		switch (GetTileType(target)) {

   480

			case MP_RAILWAY: {

   481

				uint slope = GetTileSlope(target, NULL);

   482

				byte tracks = _map5[target] & 0x3F;

   483

				if (!(

   484

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

   485

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

   486

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

   487

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

   488

					break;

   489

			}

   490

			/* FALLTHROUGH */

   491

   492

			case MP_CLEAR:

   493

			case MP_TREES:

   494

				_current_player = OWNER_WATER;

   495

				if (DoCommandByTile(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR) != CMD_ERROR) {

   496

					ModifyTile(

   497

						target,

   498

						MP_SETTYPE(MP_WATER) | MP_MAPOWNER | MP_MAP5 | MP_MAP2_CLEAR |

   499

							MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR,

   500

						OWNER_WATER, 1

   501

					);

   502

				}

   503

				break;

   504

   505

			case MP_TUNNELBRIDGE:

   506

				// Middle part of bridge with clear land below?

   507

				if ((_map5[target] & 0xF8) == 0xC0) {

   508

					_map5[target] |= 0x08;

   509

					MarkTileDirtyByTile(tile);

   510

				}

   511

				break;