1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "vehicle.h"

     4

#include "viewport.h"

     5

#include "command.h"

     6

#include "town.h"

     7

#include "news.h"

     8

#include "sound.h"

     9

    10

static void FloodVehicle(Vehicle *v);

    11

    12

bool IsShipDepotTile(TileIndex tile)

    13

{

    14

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

    15

}

    16

    17

static bool IsClearWaterTile(uint tile)

    18

{

    19

	TileInfo ti;

    20

	FindLandscapeHeightByTile(&ti, tile);

    21

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

    22

}

    23

    24

/* Build a ship depot

    25

 * p1 - direction

    26

 */

    27

    28

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

    29

{

    30

	uint tile, tile2;

    31

    32

	int32 cost, ret;

    33

	Depot *dep;

    34

    35

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

    36

    37

	tile = TILE_FROM_XY(x,y);

    38

	if (!EnsureNoVehicle(tile))

    39

		return CMD_ERROR;

    40

    41

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

    42

	if (!EnsureNoVehicle(tile2))

    43

		return CMD_ERROR;

    44

    45

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

    46

		return_cmd_error(STR_3801_MUST_BE_BUILT_ON_WATER);

    47

    48

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

    49

	if (ret == CMD_ERROR) return CMD_ERROR;

    50

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

    51

	if (ret == CMD_ERROR)

    52

		return CMD_ERROR;

    53

    54

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

    55

	cost = 0;

    56

    57

	dep = AllocateDepot();

    58

	if (dep == NULL)

    59

		return CMD_ERROR;

    60

    61

	if (flags & DC_EXEC) {

    62

		dep->xy = tile;

    63

		_last_built_ship_depot_tile = tile;

    64

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

    65

    66

		ModifyTile(tile,

    67

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

    68

			(0x80 + p1*2)

    69

		);

    70

    71

		ModifyTile(tile2,

    72

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

    73

			(0x81 + p1*2)

    74

		);

    75

	}

    76

    77

	return cost + _price.build_ship_depot;

    78

}

    79

    80

static int32 RemoveShipDepot(uint tile, uint32 flags)

    81

{

    82

	uint tile2;

    83

    84

	if (!CheckTileOwnership(tile))

    85

		return CMD_ERROR;

    86

    87

	if (!EnsureNoVehicle(tile))

    88

		return CMD_ERROR;

    89

    90

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

    91

    92

	if (!EnsureNoVehicle(tile2))

    93

		return CMD_ERROR;

    94

    95

	if (flags & DC_EXEC) {

    96

		Depot *d;

    97

    98

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

		// Kill the entry from the depot table

   103

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

   104

		d->xy = 0;

   105

   106

		DeleteWindowById(WC_VEHICLE_DEPOT, tile);

   107

	}

   108

   109

	return _price.remove_ship_depot;

   110

}

   111

   112

// build a shiplift

   113

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

   114

{

   115

	int32 ret;

   116

	int delta;

   117

   118

	// middle tile

   119

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

   120

	if (ret == CMD_ERROR) return CMD_ERROR;

   121

   122

	delta = _tileoffs_by_dir[dir];

   123

	// lower tile

   124

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

   125

	if (ret == CMD_ERROR) return CMD_ERROR;

   126

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

   127

   128

	// upper tile

   129

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

   130

	if (ret == CMD_ERROR) return CMD_ERROR;

   131

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

   132

   133

	if (flags & DC_EXEC) {

   134

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

   135

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

   136

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

   137

	}

   138

   139

	return _price.clear_water * 22 >> 3;

   140

}

   141

   142

static int32 RemoveShiplift(uint tile, uint32 flags)

   143

{

   144

	int delta = _tileoffs_by_dir[_map5[tile] & 3];

   145

   146

	// make sure no vehicle is on the tile.

   147

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

   148

		return CMD_ERROR;

   149

   150

	if (flags & DC_EXEC) {

   151

		DoClearSquare(tile);

   152

		DoClearSquare(tile + delta);

   153

		DoClearSquare(tile - delta);

   154

	}

   155

   156

	return _price.clear_water * 2;

   157

}

   158

   159

static void MarkTilesAroundDirty(uint tile)

   160

{

   161

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

   162

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

   163

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

   164

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

   165

}

   166

   167

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

   168

{

   169

	uint tile = TILE_FROM_XY(x,y);

   170

	int32 ret;

   171

	uint th;

   172

	th = GetTileSlope(tile, NULL);

   173

   174

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

   175

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

   176

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

   177

		return ret;

   178

		}

   179

	else

   180

		return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

   181

   182

	return 0;

   183

}

   184

   185

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

   186

{

   187

	uint tile = TILE_FROM_XY(x,y);

   188

	int32 ret;

   189

	uint th;

   190

	uint endtile = (uint)p1;

   191

	int delta;

   192

	int32 cost;

   193

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   194

   195

	// move in which direction?

   196

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

   197

	if (endtile < tile) delta = -delta;

   198

   199

	cost = 0;

   200

	for(;;) {

   201

		ret = 0;

   202

		th = GetTileSlope(tile, NULL);

   203

		if(th!=0)

   204

			return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

   205

   206

			// can't make water of water!

   207

			if (IS_TILETYPE(tile, MP_WATER)) {

   208

				_error_message = STR_1007_ALREADY_BUILT;

   209

			} else {

   210

   211

				/* is middle piece of a bridge? */

   212

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

   213

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

   214

						_error_message = STR_5800_OBJECT_IN_THE_WAY;

   215

						ret = CMD_ERROR;

   216

					}

   217

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

   218

						_error_message = STR_1007_ALREADY_BUILT;

   219

						ret = CMD_ERROR;

   220

					}

   221

   222

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

   223

				} else  {

   224

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

   225

				}

   226

				if (ret == CMD_ERROR) return ret;

   227

				cost += ret;

   228

   229

				/* execute modifications */

   230

				if (flags & DC_EXEC) {

   231

					if(IS_TILETYPE(tile, MP_TUNNELBRIDGE)) {

   232

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

   233

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

   234

					} else {

   235

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

   236

					}

   237

					// mark the tiles around dirty too

   238

					MarkTilesAroundDirty(tile);

   239

				}

   240

   241

				cost += _price.clear_water;

   242

			}

   243

		if (tile == endtile)

   244

			break;

   245

		tile += delta;

   246

	}

   247

	if (cost == 0) return CMD_ERROR;

   248

   249

	return cost;

   250

}

   251

   252

static int32 ClearTile_Water(uint tile, byte flags) {

   253

	byte m5 = _map5[tile];

   254

	uint slope;

   255

   256

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

   257

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

   258

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

   259

			return_cmd_error(STR_3807_CAN_T_BUILD_ON_WATER);

   260

   261

		// Make sure no vehicle is on the tile

   262

		if (!EnsureNoVehicle(tile))

   263

			return CMD_ERROR;

   264

   265

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

   266

		if (!(IS_INT_INSIDE(GET_TILE_X(tile),1,TILE_X_MAX-1) &&

   267

				IS_INT_INSIDE(GET_TILE_Y(tile),1,TILE_Y_MAX-1)))

   268

			return_cmd_error(STR_0002_TOO_CLOSE_TO_EDGE_OF_MAP);

   269

   270

		if (m5 == 0) {

   271

			if (flags & DC_EXEC)

   272

				DoClearSquare(tile);

   273

			return _price.clear_water;

   274

		} else if (m5 == 1) {

   275

			slope = GetTileSlope(tile,NULL);

   276

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

   277

				if (flags & DC_EXEC)

   278

					DoClearSquare(tile);

   279

				return _price.clear_water;

   280

			}

   281

			if (flags & DC_EXEC)

   282

				DoClearSquare(tile);

   283

			return _price.purchase_land;

   284

		} else

   285

			return CMD_ERROR;

   286

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

   287

		// shiplift

   288

   289

		static const TileIndexDiff _shiplift_tomiddle_offs[12] = {

   290

			0,0,0,0, // middle

   291

			TILE_XY(-1, 0),TILE_XY(0, 1),TILE_XY(1, 0),TILE_XY(0, -1), // lower

   292

			TILE_XY(1, 0),TILE_XY(0, -1),TILE_XY(-1, 0),TILE_XY(0, 1), // upper

   293

		};

   294

   295

		if (flags & DC_AUTO) return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

   296

		// don't allow water to delete it.

   297

		if (_current_player == OWNER_WATER) return CMD_ERROR;

   298

		// move to the middle tile..

   299

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

   300

	} else {

   301

		// ship depot

   302

		if (flags & DC_AUTO)

   303

			return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

   304

   305

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

   306

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

   307

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

   308

		else

   309

			return CMD_ERROR;

   310

   311

		return RemoveShipDepot(tile,flags);

   312

	}

   313

}

   314

   315

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

   316

static bool IsWateredTile(uint tile)

   317

{

   318

	byte m5 = _map5[tile];

   319

	if (IS_TILETYPE(tile, MP_WATER)) {

   320

		return m5 != 1;

   321

	} else if (IS_TILETYPE(tile, MP_STATION)) {

   322

		// returns true if it is a dock-station (m5 inside values is m5<75 all stations,

   323

		// 83<=m5<=114 new airports

   324

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

   325

	} else if (IS_TILETYPE(tile, MP_TUNNELBRIDGE)) {

   326

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

   327

	} else

   328

		return false;

   329

}

   330

   331

// draw a canal styled water tile with dikes around

   332

void DrawCanalWater(uint tile)

   333

{

   334

	uint wa;

   335

   336

	// determine the edges around with water.

   337

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

   338

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

   339

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

   340

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

   341

   342

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

   343

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

   344

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

   345

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

   346

   347

	// right corner

   348

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

   349

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

   350

   351

	// bottom corner

   352

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

   353

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

   354

   355

	// left corner

   356

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

   357

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

   358

   359

	// upper corner

   360

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

   361

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

   362

}

   363

   364

typedef struct WaterDrawTileStruct {

   365

	int8 delta_x;

   366

	int8 delta_y;

   367

	int8 delta_z;

   368

	byte width;

   369

	byte height;

   370

	byte unk;

   371

	SpriteID image;

   372

} WaterDrawTileStruct;

   373

   374

typedef struct LocksDrawTileStruct {

   375

	int8 delta_x, delta_y, delta_z;

   376

	byte width, height, depth;

   377

	SpriteID image;

   378

} LocksDrawTileStruct;

   379

   380

#include "table/water_land.h"

   381

   382

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

   383

{

   384

	const WaterDrawTileStruct *wdts;

   385

	uint32 image;

   386

   387

	DrawGroundSprite(*(const uint16*)t);

   388

	t += sizeof(uint16);

   389

   390

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

   391

		image =	wdts->image + base;

   392

		if (_display_opt & DO_TRANS_BUILDINGS) {

   395

			image |= palette;

   396

		}

   397

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

   398

	}

   399

}

   400

   401

static void DrawTile_Water(TileInfo *ti)

   402

{

   403

	// draw water tile

   404

	if (ti->map5 == 0) {

   405

		DrawGroundSprite(0xFDD);

   406

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

   407

		return;

   408

	}

   409

   410

	// draw shore

   411

	if (ti->map5 == 1) {

   412

		assert(ti->tileh < 16);

   413

		DrawGroundSprite(_water_shore_sprites[ti->tileh]);

   414

		return;

   415

	}

   416

   417

	// draw shiplift

   418

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

   419

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

   420

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

   421

		return;

   422

	}

   423

   424

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

   425

}

   426

   427

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

   428

{

   429

	const byte *t;

   430

	const WaterDrawTileStruct *wdts;

   431

   432

	t = _shipdepot_display_seq[image];

   433

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

   434

	t += sizeof(uint16);

   435

   436

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

   437

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

   438

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

   439

	}

   440

}

   441

   442

   443

static uint GetSlopeZ_Water(TileInfo *ti)

   444

{

   445

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

   446

}

   447

   448

static uint GetSlopeTileh_Water(TileInfo *ti)

   449

{

   450

	return ti->tileh;

   451

}

   452

   453

static void GetAcceptedCargo_Water(uint tile, AcceptedCargo ac)

   454

{

   455

	/* not used */

   456

}

   457

   458

static void GetTileDesc_Water(uint tile, TileDesc *td)

   459

{

   460

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

   461

		td->str = STR_3804_WATER;

   462

	else if (_map5[tile] == 0)

   463

		td->str = STR_LANDINFO_CANAL;

   464

	else if (_map5[tile] == 1)

   465

		td->str = STR_3805_COAST_OR_RIVERBANK;

   466

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

   467

		td->str = STR_LANDINFO_LOCK;

   468

	else

   469

		td->str = STR_3806_SHIP_DEPOT;

   470

   471

	td->owner = _map_owner[tile];

   472

}

   473

   474

static void AnimateTile_Water(uint tile)

   475

{

   476

	/* not used */

   477

}

   478

   479

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

   480

{

   481

	byte *p;

   482

   483

	p = &_map_type_and_height[tile];

   484

	tile += offs[0];

   485

   486

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

   487

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

   488

		return;

   489

   490

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

   491

		return;

   492

   493

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

   494

		// make coast..

   495

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

   496

			_current_player = OWNER_WATER;

   497

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

   498

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

   499

		}

   500

	} else {

   501

		if (IS_TILETYPE(tile, MP_TUNNELBRIDGE)) {

   502

			byte m5 = _map5[tile];

   503

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

   504

				return;

   505

   506

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

   507

				ModifyTile(tile, MP_MAPOWNER | MP_MAP5,OWNER_WATER,(m5 & ~0x38)|0x8);

   508

				return;

   509

			}

   510

		}

   511

   512

		_current_player = OWNER_WATER;

   513

		{

   514

			Vehicle *v = FindVehicleBetween(tile, tile, 0);

   515

			if (v != NULL) {FloodVehicle(v);}

   516

		}

   517

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

   518

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

   519

	}

   520

}

   521

   522

static void FloodVehicle(Vehicle *v)

   523