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

#include "depot.h"

    13

    14

static void FloodVehicle(Vehicle *v);

    15

    16

static bool IsClearWaterTile(uint tile)

    17

{

    18

	TileInfo ti;

    19

	FindLandscapeHeightByTile(&ti, tile);

    20

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

    21

}

    22

    23

/* Build a ship depot

    24

 * p1 - direction

    25

 */

    26

    27

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

    28

{

    29

	uint tile, tile2;

    30

    31

	int32 cost, ret;

    32

	Depot *depot;

    33

    34

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

    35

    36

	tile = TILE_FROM_XY(x,y);

    37

	if (!EnsureNoVehicle(tile))

    38

		return CMD_ERROR;

    39

    40

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

    41

	if (!EnsureNoVehicle(tile2))

    42

		return CMD_ERROR;

    43

    44

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

    45

		return_cmd_error(STR_3801_MUST_BE_BUILT_ON_WATER);

    46

    47

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

    48

	if (ret == CMD_ERROR) return CMD_ERROR;

    49

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

    50

	if (ret == CMD_ERROR)

    51

		return CMD_ERROR;

    52

    53

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

    54

	cost = 0;

    55

    56

	depot = AllocateDepot();

    57

	if (depot == NULL)

    58

		return CMD_ERROR;

    59

    60

	if (flags & DC_EXEC) {

    61

		depot->xy = tile;

    62

		_last_built_ship_depot_tile = tile;

    63

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

    64

    65

		ModifyTile(tile,

    66

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

    67

			(0x80 + p1*2)

    68

		);

    69

    70

		ModifyTile(tile2,

    71

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

    72

			(0x81 + p1*2)

    73

		);

    74

	}

    75

    76

	return cost + _price.build_ship_depot;

    77

}

    78

    79

static int32 RemoveShipDepot(uint tile, uint32 flags)

    80

{

    81

	uint tile2;

    82

    83

	if (!CheckTileOwnership(tile))

    84

		return CMD_ERROR;

    85

    86

	if (!EnsureNoVehicle(tile))

    87

		return CMD_ERROR;

    88

    89

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

    90

    91

	if (!EnsureNoVehicle(tile2))

    92

		return CMD_ERROR;

    93

    94

	if (flags & DC_EXEC) {

    95

		/* Kill the depot */

    96

		DoDeleteDepot(tile);

    97

    98

		/* Make the tiles water */

    99

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

   100

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

   101

	}

   102

   103

	return _price.remove_ship_depot;

   104

}

   105

   106

// build a shiplift

   107

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

   108

{

   109

	int32 ret;

   110

	int delta;

   111

   112

	// middle tile

   113

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

   114

	if (ret == CMD_ERROR) return CMD_ERROR;

   115

   116

	delta = TileOffsByDir(dir);

   117

	// lower tile

   118

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

   119

	if (ret == CMD_ERROR) return CMD_ERROR;

   120

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

   121

   122

	// upper tile

   123

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

   124

	if (ret == CMD_ERROR) return CMD_ERROR;

   125

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

   126

   127

	if (flags & DC_EXEC) {

   128

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

   129

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

   130

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

   131

	}

   132

   133

	return _price.clear_water * 22 >> 3;

   134

}

   135

   136

static int32 RemoveShiplift(uint tile, uint32 flags)

   137

{

   138

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

   139

   140

	// make sure no vehicle is on the tile.

   141

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

   142

		return CMD_ERROR;

   143

   144

	if (flags & DC_EXEC) {

   145

		DoClearSquare(tile);

   146

		DoClearSquare(tile + delta);

   147

		DoClearSquare(tile - delta);

   148

	}

   149

   150

	return _price.clear_water * 2;

   151

}

   152

   153

static void MarkTilesAroundDirty(uint tile)

   154

{

   155

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

   156

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

   157

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

   158

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

   159

}

   160

   161

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

   162

{

   163

	uint tile = TILE_FROM_XY(x,y);

   164

	int32 ret;

   165

	uint th;

   166

   167

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   168

	th = GetTileSlope(tile, NULL);

   169

   170

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

   171

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

   172

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

   173

		return ret;

   174

		}

   175

	else

   176

		return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

   177

}

   178

   179

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

   180

{

   181

	uint tile = TILE_FROM_XY(x,y);

   182

	int32 ret;

   183

	uint th;

   184

	uint endtile = (uint)p1;

   185

	int delta;

   186

	int32 cost;

   187

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   188

   189

	// move in which direction?

   190

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

   191

	if (endtile < tile) delta = -delta;

   192

   193

	cost = 0;

   194

	for(;;) {

   195

		ret = 0;

   196

		th = GetTileSlope(tile, NULL);

   197

		if(th!=0)

   198

			return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);

   199

   200

			// can't make water of water!

   201

			if (IsTileType(tile, MP_WATER)) {

   202

				_error_message = STR_1007_ALREADY_BUILT;

   203

			} else {

   204

   205

				/* is middle piece of a bridge? */

   206

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

   207

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

   208

						_error_message = STR_5800_OBJECT_IN_THE_WAY;

   209

						ret = CMD_ERROR;

   210

					}

   211

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

   212

						_error_message = STR_1007_ALREADY_BUILT;

   213

						ret = CMD_ERROR;

   214

					}

   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

		if (tile == endtile)

   238

			break;

   239

		tile += delta;

   240

	}

   241

	if (cost == 0) return CMD_ERROR;

   242

   243

	return cost;

   244

}

   245

   246

static int32 ClearTile_Water(uint tile, byte flags) {

   247

	byte m5 = _map5[tile];

   248

	uint slope;

   249

   250

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

   251

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

   252

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

   253

			return_cmd_error(STR_3807_CAN_T_BUILD_ON_WATER);

   254

   255

		// Make sure no vehicle is on the tile

   256

		if (!EnsureNoVehicle(tile))

   257

			return CMD_ERROR;

   258

   259

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

   260

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

   261

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

   262

			return_cmd_error(STR_0002_TOO_CLOSE_TO_EDGE_OF_MAP);

   263

   264

		if (m5 == 0) {

   265

			if (flags & DC_EXEC)

   266

				DoClearSquare(tile);

   267

			return _price.clear_water;

   268

		} else if (m5 == 1) {

   269

			slope = GetTileSlope(tile,NULL);

   270

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

   271

				if (flags & DC_EXEC)

   272

					DoClearSquare(tile);

   273

				return _price.clear_water;

   274

			}

   275

			if (flags & DC_EXEC)

   276

				DoClearSquare(tile);

   277

			return _price.purchase_land;

   278

		} else

   279

			return CMD_ERROR;

   280

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

   281

		// shiplift

   282

   283

		static const TileIndexDiffC _shiplift_tomiddle_offs[] = {

   284

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

   285

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

   286

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

   287

		};

   288

   289

		if (flags & DC_AUTO) return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

   290

		// don't allow water to delete it.

   291

		if (_current_player == OWNER_WATER) return CMD_ERROR;

   292

		// move to the middle tile..

   293

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

   294

	} else {

   295

		// ship depot

   296

		if (flags & DC_AUTO)

   297

			return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

   298

   299

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

   300

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

   301

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

   302

		else

   303

			return CMD_ERROR;

   304

   305

		return RemoveShipDepot(tile,flags);

   306

	}

   307

}

   308

   309

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

   310

static bool IsWateredTile(TileIndex tile)

   311

{

   312

	byte m5 = _map5[tile];

   313

   314

	switch (GetTileType(tile)) {

   315

		case MP_WATER:

   316

			// true, if not coast/riverbank

   317

			return m5 != 1;

   318

   319

		case MP_STATION:

   320

			// returns true if it is a dock-station

   321

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

   322

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

   323

   324

		case MP_TUNNELBRIDGE:

   325

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

   326

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

   327

   328

		default:

   329

			return false;

   330

	}

   331

}

   332

   333

// draw a canal styled water tile with dikes around

   334

void DrawCanalWater(uint tile)

   335

{

   336

	uint wa;

   337

   338

	// determine the edges around with water.

   339

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

   340

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

   341

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

   342

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

   343

   344

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

   345

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

   346

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

   347

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

   348

   349

	// right corner

   350

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

   351

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

   352

   353

	// bottom corner

   354

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

   355

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

   356

   357

	// left corner

   358

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

   359

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

   360

   361

	// upper corner

   362

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

   363

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

   364

}

   365

   366

typedef struct WaterDrawTileStruct {

   367

	int8 delta_x;

   368

	int8 delta_y;

   369

	int8 delta_z;

   370

	byte width;

   371

	byte height;

   372

	byte unk;

   373

	SpriteID image;

   374

} WaterDrawTileStruct;

   375

   376

typedef struct LocksDrawTileStruct {

   377

	int8 delta_x, delta_y, delta_z;

   378

	byte width, height, depth;

   379

	SpriteID image;

   380

} LocksDrawTileStruct;

   381

   382

#include "table/water_land.h"

   383

   384

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

   385

{

   386

	const WaterDrawTileStruct *wdts;

   387

	uint32 image;

   388

   389

	DrawGroundSprite(*(const uint16*)t);

   390

	t += sizeof(uint16);

   391

   392

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

   393

		image =	wdts->image + base;

   394

		if (_display_opt & DO_TRANS_BUILDINGS) {

   395

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

   396

		} else {

   397

			image |= palette;

   398

		}

   399

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

   400

	}

   401

}

   402

   403

static void DrawTile_Water(TileInfo *ti)

   404

{

   405

	// draw water tile

   406

	if (ti->map5 == 0) {

   407

		DrawGroundSprite(0xFDD);

   408

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

   409

		return;

   410

	}

   411

   412

	// draw shore

   413

	if (ti->map5 == 1) {

   414

		assert(ti->tileh < 16);

   415

		DrawGroundSprite(_water_shore_sprites[ti->tileh]);

   416

		return;

   417

	}

   418

   419

	// draw shiplift

   420

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

   421

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

   422

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

   423

		return;

   424

	}

   425

   426

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

   427

}

   428

   429

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

   430

{

   431

	const byte *t;

   432

	const WaterDrawTileStruct *wdts;

   433

   434

	t = _shipdepot_display_seq[image];

   435

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

   436

	t += sizeof(uint16);

   437

   438

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

   439

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

   440

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

   441

	}

   442

}

   443

   444

   445

static uint GetSlopeZ_Water(TileInfo *ti)

   446

{

   447

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

   448

}

   449

   450

static uint GetSlopeTileh_Water(TileInfo *ti)

   451

{

   452

	return ti->tileh;

   453

}

   454

   455

static void GetAcceptedCargo_Water(uint tile, AcceptedCargo ac)

   456

{

   457

	/* not used */

   458

}

   459

   460

static void GetTileDesc_Water(uint tile, TileDesc *td)

   461

{

   462

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

   463

		td->str = STR_3804_WATER;

   464

	else if (_map5[tile] == 0)

   465

		td->str = STR_LANDINFO_CANAL;

   466

	else if (_map5[tile] == 1)

   467

		td->str = STR_3805_COAST_OR_RIVERBANK;

   468

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

   469

		td->str = STR_LANDINFO_LOCK;

   470

	else

   471

		td->str = STR_3806_SHIP_DEPOT;

   472

   473

	td->owner = _map_owner[tile];

   474

}

   475

   476

static void AnimateTile_Water(uint tile)

   477

{

   478

	/* not used */

   479

}

   480

   481

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

   482

{

   483

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

   484

   485

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

   486

	if (IsTileType(target, MP_WATER))

   487

		return;

   488

   489

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

   490

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

   491

		return;

   492

   493

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

   494

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

   495

		// make coast..

   496

		switch (GetTileType(target)) {

   497

			case MP_RAILWAY: {

   498

				uint slope = GetTileSlope(target, NULL);

   499

				byte tracks = _map5[target] & 0x3F;

   500

				if (!(

   501

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

   502

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

   503

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

   504

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

   505

					break;

   506

			}

   507

			/* FALLTHROUGH */

   508

   509

			case MP_CLEAR:

   510

			case MP_TREES:

   511

				_current_player = OWNER_WATER;

   512

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

   513

					ModifyTile(

   514

						target,

   515

						MP_SETTYPE(MP_WATER) | MP_MAPOWNER | MP_MAP5 | MP_MAP2_CLEAR |