1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "vehicle.h"

     6

#include "viewport.h"

     7

#include "command.h"

     8

#include "town.h"

     9

#include "news.h"

    10

#include "sound.h"

    11

    12

static void FloodVehicle(Vehicle *v);

    13

    14

bool IsShipDepotTile(TileIndex tile)

    15

{

    16

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

    17

}

    18

    19

static bool IsClearWaterTile(uint tile)

    20

{

    21

	TileInfo ti;

    22

	FindLandscapeHeightByTile(&ti, tile);

    23

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

    24

}

    25

    26

/* Build a ship depot

    27

 * p1 - direction

    28

 */

    29

    30

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

    31

{

    32

	uint tile, tile2;

    33

    34

	int32 cost, ret;

    35

	Depot *dep;

    36

    37

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

    38

    39

	tile = TILE_FROM_XY(x,y);

    40

	if (!EnsureNoVehicle(tile))

    41

		return CMD_ERROR;

    42

    43

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

    44

	if (!EnsureNoVehicle(tile2))

    45

		return CMD_ERROR;

    46

    47

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

    48

		return_cmd_error(STR_3801_MUST_BE_BUILT_ON_WATER);

    49

    50

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

    51

	if (ret == CMD_ERROR) return CMD_ERROR;

    52

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

    53

	if (ret == CMD_ERROR)

    54

		return CMD_ERROR;

    55

    56

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

    57

	cost = 0;

    58

    59

	dep = AllocateDepot();

    60

	if (dep == NULL)

    61

		return CMD_ERROR;

    62

    63

	if (flags & DC_EXEC) {

    64

		dep->xy = tile;

    65

		_last_built_ship_depot_tile = tile;

    66

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

    67

    68

		ModifyTile(tile,

    69

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

    70

			(0x80 + p1*2)

    71

		);

    72

    73

		ModifyTile(tile2,

    74

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

    75

			(0x81 + p1*2)

    76

		);

    77

	}

    78

    79

	return cost + _price.build_ship_depot;

    80

}

    81

    82

static int32 RemoveShipDepot(uint tile, uint32 flags)

    83

{

    84

	uint tile2;

    85

    86

	if (!CheckTileOwnership(tile))

    87

		return CMD_ERROR;

    88

    89

	if (!EnsureNoVehicle(tile))

    90

		return CMD_ERROR;

    91

    92

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

    93

    94

	if (!EnsureNoVehicle(tile2))

    95

		return CMD_ERROR;

    96

    97

	if (flags & DC_EXEC) {

    98

		Depot *d;

    99

   100

		// convert the cleared tiles to 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

		// Kill the entry from the depot table

   105

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

   106

		d->xy = 0;

   107

   108

		DeleteWindowById(WC_VEHICLE_DEPOT, tile);

   109

	}

   110

   111

	return _price.remove_ship_depot;

   112

}

   113

   114

// build a shiplift

   115

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

   116

{

   117

	int32 ret;

   118

	int delta;

   119

   120

	// middle tile

   121

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

   122

	if (ret == CMD_ERROR) return CMD_ERROR;

   123

   124

	delta = TileOffsByDir(dir);

   125

	// lower tile

   126

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

   127

	if (ret == CMD_ERROR) return CMD_ERROR;

   128

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

   129

   130

	// upper tile

   131

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

   132

	if (ret == CMD_ERROR) return CMD_ERROR;

   133

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

   134

   135

	if (flags & DC_EXEC) {

   136

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

   137

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

   138

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

   139

	}

   140

   141

	return _price.clear_water * 22 >> 3;

   142

}

   143

   144

static int32 RemoveShiplift(uint tile, uint32 flags)

   145

{

   146

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

   147

   148

	// make sure no vehicle is on the tile.

   149

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

   150

		return CMD_ERROR;

   151

   152

	if (flags & DC_EXEC) {

   153

		DoClearSquare(tile);

   154

		DoClearSquare(tile + delta);

   155

		DoClearSquare(tile - delta);

   156

	}

   157

   158

	return _price.clear_water * 2;

   159

}

   160

   161

static void MarkTilesAroundDirty(uint tile)

   162

{

   163

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

   164

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

   165

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

   166

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

   167

}

   168

   169

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

   170

{

   171

	uint tile = TILE_FROM_XY(x,y);

   172

	int32 ret;

   173

	uint th;

   174

   175

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   176

	th = GetTileSlope(tile, NULL);

   177

   178

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

   179

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

   180

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

   181

		return ret;

   182

		}

   183

	else

   184

		return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

   185

}

   186

   187

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

   188

{

   189

	uint tile = TILE_FROM_XY(x,y);

   190

	int32 ret;

   191

	uint th;

   192

	uint endtile = (uint)p1;

   193

	int delta;

   194

	int32 cost;

   195

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   196

   197

	// move in which direction?

   198

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

   199

	if (endtile < tile) delta = -delta;

   200

   201

	cost = 0;

   202

	for(;;) {

   203

		ret = 0;

   204

		th = GetTileSlope(tile, NULL);

   205

		if(th!=0)

   206

			return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);

   207

   208

			// can't make water of water!

   209

			if (IsTileType(tile, MP_WATER)) {

   210

				_error_message = STR_1007_ALREADY_BUILT;

   211

			} else {

   212

   213

				/* is middle piece of a bridge? */

   214

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

   215

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

   216

						_error_message = STR_5800_OBJECT_IN_THE_WAY;

   217

						ret = CMD_ERROR;

   218

					}

   219

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

   220

						_error_message = STR_1007_ALREADY_BUILT;

   221

						ret = CMD_ERROR;

   222

					}

   223

   224

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

   225

				} else  {

   226

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

   227

				}

   228

				if (ret == CMD_ERROR) return ret;

   229

				cost += ret;

   230

   231

				/* execute modifications */

   232

				if (flags & DC_EXEC) {

   233

					if (IsTileType(tile, MP_TUNNELBRIDGE)) {

   234

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

   235

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

   236

					} else {

   237

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

   238

					}

   239

					// mark the tiles around dirty too

   240

					MarkTilesAroundDirty(tile);

   241

				}

   242

   243

				cost += _price.clear_water;

   244

			}

   245

		if (tile == endtile)

   246

			break;

   247

		tile += delta;

   248

	}

   249

	if (cost == 0) return CMD_ERROR;

   250

   251

	return cost;

   252

}

   253

   254

static int32 ClearTile_Water(uint tile, byte flags) {

   255

	byte m5 = _map5[tile];

   256

	uint slope;

   257

   258

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

   259

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

   260

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

   261

			return_cmd_error(STR_3807_CAN_T_BUILD_ON_WATER);

   262

   263

		// Make sure no vehicle is on the tile

   264

		if (!EnsureNoVehicle(tile))

   265

			return CMD_ERROR;

   266

   267

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

   268

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

   269

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

   270

			return_cmd_error(STR_0002_TOO_CLOSE_TO_EDGE_OF_MAP);

   271

   272

		if (m5 == 0) {

   273

			if (flags & DC_EXEC)

   274

				DoClearSquare(tile);

   275

			return _price.clear_water;

   276

		} else if (m5 == 1) {

   277

			slope = GetTileSlope(tile,NULL);

   278

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

   279

				if (flags & DC_EXEC)

   280

					DoClearSquare(tile);

   281

				return _price.clear_water;

   282

			}

   283

			if (flags & DC_EXEC)

   284

				DoClearSquare(tile);

   285

			return _price.purchase_land;

   286

		} else

   287

			return CMD_ERROR;

   288

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

   289

		// shiplift

   290

   291

		static const TileIndexDiffC _shiplift_tomiddle_offs[] = {

   292

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

   293

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

   294

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

   295

		};

   296

   297

		if (flags & DC_AUTO) return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

   298

		// don't allow water to delete it.

   299

		if (_current_player == OWNER_WATER) return CMD_ERROR;

   300

		// move to the middle tile..

   301

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

   302

	} else {

   303

		// ship depot

   304

		if (flags & DC_AUTO)

   305

			return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

   306

   307

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

   308

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

   309

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

   310

		else

   311

			return CMD_ERROR;

   312

   313

		return RemoveShipDepot(tile,flags);

   314

	}

   315

}

   316

   317

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

   319

{

   320

	byte m5 = _map5[tile];

   339

}

   340

   341

// draw a canal styled water tile with dikes around

   342

void DrawCanalWater(uint tile)

   343

{

   344

	uint wa;

   345

   346

	// determine the edges around with water.

   347

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

   348

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

   349

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

   350

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

   351

   352

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

   353

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

   354

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

   355

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

   356

   357

	// right corner

   358

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

   359

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

   360

   361

	// bottom corner

   362

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

   363

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

   364

   365

	// left corner

   366

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

   367

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

   368

   369

	// upper corner

   370

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

   371

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

   372

}

   373

   374

typedef struct WaterDrawTileStruct {

   375

	int8 delta_x;

   376

	int8 delta_y;

   377

	int8 delta_z;

   378

	byte width;

   379

	byte height;

   380

	byte unk;

   381

	SpriteID image;

   382

} WaterDrawTileStruct;

   383

   384

typedef struct LocksDrawTileStruct {

   385

	int8 delta_x, delta_y, delta_z;

   386

	byte width, height, depth;

   387

	SpriteID image;

   388

} LocksDrawTileStruct;

   389

   390

#include "table/water_land.h"

   391

   392

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

   393

{

   394

	const WaterDrawTileStruct *wdts;

   395

	uint32 image;

   396

   397

	DrawGroundSprite(*(const uint16*)t);

   398

	t += sizeof(uint16);

   399

   400

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

   401

		image =	wdts->image + base;

   402

		if (_display_opt & DO_TRANS_BUILDINGS) {

   403

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

   404

		} else {

   405

			image |= palette;

   406

		}

   407

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

   408

	}

   409

}

   410

   411

static void DrawTile_Water(TileInfo *ti)

   412

{

   413

	// draw water tile

   414

	if (ti->map5 == 0) {

   415

		DrawGroundSprite(0xFDD);

   416

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

   417

		return;

   418

	}

   419

   420

	// draw shore

   421

	if (ti->map5 == 1) {

   422

		assert(ti->tileh < 16);

   423

		DrawGroundSprite(_water_shore_sprites[ti->tileh]);

   424

		return;

   425

	}

   426

   427

	// draw shiplift

   428

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

   429

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

   430

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

   431

		return;

   432

	}

   433

   434

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

   435

}

   436

   437

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

   438

{

   439

	const byte *t;

   440

	const WaterDrawTileStruct *wdts;

   441

   442

	t = _shipdepot_display_seq[image];

   443

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

   444

	t += sizeof(uint16);

   445

   446

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

   447

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

   448

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

   449

	}

   450

}

   451

   452

   453

static uint GetSlopeZ_Water(TileInfo *ti)

   454

{

   455

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

   456

}

   457

   458

static uint GetSlopeTileh_Water(TileInfo *ti)

   459

{

   460

	return ti->tileh;

   461

}

   462

   463

static void GetAcceptedCargo_Water(uint tile, AcceptedCargo ac)

   464

{

   465

	/* not used */

   466

}

   467

   468

static void GetTileDesc_Water(uint tile, TileDesc *td)

   469

{

   470

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

   471

		td->str = STR_3804_WATER;

   472

	else if (_map5[tile] == 0)

   473

		td->str = STR_LANDINFO_CANAL;

   474

	else if (_map5[tile] == 1)

   475

		td->str = STR_3805_COAST_OR_RIVERBANK;

   476

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

   477

		td->str = STR_LANDINFO_LOCK;

   478

	else

   479

		td->str = STR_3806_SHIP_DEPOT;

   480

   481

	td->owner = _map_owner[tile];

   482

}

   483

   484

static void AnimateTile_Water(uint tile)

   485

{

   486

	/* not used */

   487

}

   488

   489

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

   490

{

   491

	byte *p;

   492

   493

	p = &_map_type_and_height[tile];

   494

	tile += ToTileIndexDiff(offs[0]);

   495

   496

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

   497

	if (p[ToTileIndexDiff(offs[0])] >> 4 == MP_WATER)

   498

		return;

   499

   500

	if ((p[ToTileIndexDiff(offs[1])] | p[ToTileIndexDiff(offs[2])]) & 0xF)

   501

		return;

   502

   503

	if ((p[ToTileIndexDiff(offs[3])] | p[ToTileIndexDiff(offs[4])]) & 0xF) {

   504

		// make coast..

   505

		if (p[ToTileIndexDiff(offs[0])] >> 4 == MP_CLEAR ||

   506

				p[ToTileIndexDiff(offs[0])] >> 4 == MP_TREES) {

   507

			_current_player = OWNER_WATER;

   508

			if (DoCommandByTile(tile,0,0,DC_EXEC | DC_AUTO, CMD_LANDSCAPE_CLEAR) != CMD_ERROR)

   509

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

   510

		}

   511

	} else {

   512

		if (IsTileType(tile, MP_TUNNELBRIDGE)) {

   513

			byte m5 = _map5[tile];

   514

			if ( (m5&0xF8) == 0xC8 || (m5&0xF8) == 0xF0)

   515

				return;

   516

   517

			if ( (m5&0xC0) == 0xC0) {