1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "vehicle.h"

     5

#include "viewport.h"

     6

#include "command.h"

     7

#include "town.h"

     8

#include "news.h"

     9

#include "sound.h"

    10

    11

static void FloodVehicle(Vehicle *v);

    12

    13

bool IsShipDepotTile(TileIndex tile)

    14

{

    15

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

    16

}

    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 *dep;

    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

	dep = AllocateDepot();

    59

	if (dep == NULL)

    60

		return CMD_ERROR;

    61

    62

	if (flags & DC_EXEC) {

    63

		dep->xy = tile;

    64

		_last_built_ship_depot_tile = tile;

    65

		dep->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

		Depot *d;

    98

    99

		// convert the cleared tiles to water

   100

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

   101

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

   102

   103

		// Kill the entry from the depot table

   104

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

   105

		d->xy = 0;

   106

   107

		DeleteWindowById(WC_VEHICLE_DEPOT, tile);

   108

	}

   109

   110

	return _price.remove_ship_depot;

   111

}

   112

   113

// build a shiplift

   114

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

   115

{

   116

	int32 ret;

   117

	int delta;

   118

   119

	// middle tile

   120

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

   121

	if (ret == CMD_ERROR) return CMD_ERROR;

   122

   123

	delta = _tileoffs_by_dir[dir];

   124

	// lower 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

	// upper tile

   130

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

   131

	if (ret == CMD_ERROR) return CMD_ERROR;

   132

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

   133

   134

	if (flags & DC_EXEC) {

   135

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

   136

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

   137

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

   138

	}

   139

   140

	return _price.clear_water * 22 >> 3;

   141

}

   142

   143

static int32 RemoveShiplift(uint tile, uint32 flags)

   144

{

   145

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

   146

   147

	// make sure no vehicle is on the tile.

   148

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

   149

		return CMD_ERROR;

   150

   151

	if (flags & DC_EXEC) {

   152

		DoClearSquare(tile);

   153

		DoClearSquare(tile + delta);

   154

		DoClearSquare(tile - delta);

   155

	}

   156

   157

	return _price.clear_water * 2;

   158

}

   159

   160

static void MarkTilesAroundDirty(uint tile)

   161

{

   162

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

   163

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

   164

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

   165

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

   166

}

   167

   168

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

   169

{

   170

	uint tile = TILE_FROM_XY(x,y);

   171

	int32 ret;

   172

	uint th;

   173

	th = GetTileSlope(tile, NULL);

   174

   175

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

   176

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

   177

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

   178

		return ret;

   179

		}

   180

	else

   181

		return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

   182

   183

	return 0;

   184

}

   185

   186

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

   187

{

   188

	uint tile = TILE_FROM_XY(x,y);

   189

	int32 ret;

   190

	uint th;

   191

	uint endtile = (uint)p1;

   192

	int delta;

   193

	int32 cost;

   194

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   195

   196

	// move in which direction?

   197

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

   198

	if (endtile < tile) delta = -delta;

   199

   200

	cost = 0;

   201

	for(;;) {

   202

		ret = 0;

   203

		th = GetTileSlope(tile, NULL);

   204

		if(th!=0)

   205

			return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

   206

   207

			// can't make water of water!

   208

			if (IS_TILETYPE(tile, MP_WATER)) {

   209

				_error_message = STR_1007_ALREADY_BUILT;

   210

			} else {

   211

   212

				/* is middle piece of a bridge? */

   213

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

   214

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

   215

						_error_message = STR_5800_OBJECT_IN_THE_WAY;

   216

						ret = CMD_ERROR;

   217

					}

   218

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

   219

						_error_message = STR_1007_ALREADY_BUILT;

   220

						ret = CMD_ERROR;

   221

					}

   222

   223

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

   224

				} else  {

   225

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

   226

				}

   227

				if (ret == CMD_ERROR) return ret;

   228

				cost += ret;

   229

   230

				/* execute modifications */

   231

				if (flags & DC_EXEC) {

   232

					if(IS_TILETYPE(tile, MP_TUNNELBRIDGE)) {

   233

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

   234

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

   235

					} else {

   236

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

   237

					}

   238

					// mark the tiles around dirty too

   239

					MarkTilesAroundDirty(tile);

   240

				}

   241

   242

				cost += _price.clear_water;

   243

			}

   244

		if (tile == endtile)

   245

			break;

   246

		tile += delta;

   247

	}

   248

	if (cost == 0) return CMD_ERROR;

   249

   250

	return cost;

   251

}

   252

   253

static int32 ClearTile_Water(uint tile, byte flags) {

   254

	byte m5 = _map5[tile];

   255

	uint slope;

   256

   257

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

   258

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

   259

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

   260

			return_cmd_error(STR_3807_CAN_T_BUILD_ON_WATER);

   261

   262

		// Make sure no vehicle is on the tile

   263

		if (!EnsureNoVehicle(tile))

   264

			return CMD_ERROR;

   265

   266

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

   267

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

   268

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

   269

			return_cmd_error(STR_0002_TOO_CLOSE_TO_EDGE_OF_MAP);

   270

   271

		if (m5 == 0) {

   272

			if (flags & DC_EXEC)

   273

				DoClearSquare(tile);

   274

			return _price.clear_water;

   275

		} else if (m5 == 1) {

   276

			slope = GetTileSlope(tile,NULL);

   277

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

   278

				if (flags & DC_EXEC)

   279

					DoClearSquare(tile);

   280

				return _price.clear_water;

   281

			}

   282

			if (flags & DC_EXEC)

   283

				DoClearSquare(tile);

   284

			return _price.purchase_land;

   285

		} else

   286

			return CMD_ERROR;

   287

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

   288

		// shiplift

   289

   290

		static const TileIndexDiff _shiplift_tomiddle_offs[12] = {

   291

			0,0,0,0, // middle

   292

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

   293

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

   294

		};

   295

   296

		if (flags & DC_AUTO) return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

   297

		// don't allow water to delete it.

   298

		if (_current_player == OWNER_WATER) return CMD_ERROR;

   299

		// move to the middle tile..

   300

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

   301

	} else {

   302

		// ship depot

   303

		if (flags & DC_AUTO)

   304

			return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);

   305

   306

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

   307

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

   308

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

   309

		else

   310

			return CMD_ERROR;

   311

   312

		return RemoveShipDepot(tile,flags);

   313

	}

   314

}

   315

   316

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

   317

static bool IsWateredTile(uint tile)

   318

{

   319

	byte m5 = _map5[tile];

   320

	if (IS_TILETYPE(tile, MP_WATER)) {

   321

		return m5 != 1;

   322

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

   323

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

   324

		// 83<=m5<=114 new airports

   325

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

   326

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

   327

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

   328

	} else

   329

		return false;

   330

}

   331

   332

// draw a canal styled water tile with dikes around

   333

void DrawCanalWater(uint tile)

   334

{

   335

	uint wa;

   336

   337

	// determine the edges around with water.

   338

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

   339

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

   340

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

   341

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

   342

   343

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

   344

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

   345

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

   346

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

   347

   348

	// right corner

   349

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

   350

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

   351

   352

	// bottom corner

   353

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

   354

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

   355

   356

	// left corner

   357

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

   358

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

   359

   360

	// upper corner

   361

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

   362

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

   363

}

   364

   365

typedef struct WaterDrawTileStruct {

   366

	int8 delta_x;

   367

	int8 delta_y;

   368

	int8 delta_z;

   369

	byte width;

   370

	byte height;

   371

	byte unk;

   372

	SpriteID image;

   373

} WaterDrawTileStruct;

   374

   375

typedef struct LocksDrawTileStruct {

   376

	int8 delta_x, delta_y, delta_z;

   377

	byte width, height, depth;

   378

	SpriteID image;

   379

} LocksDrawTileStruct;

   380

   381

#include "table/water_land.h"

   382

   383

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

   384

{

   385

	const WaterDrawTileStruct *wdts;

   386

	uint32 image;

   387

   388

	DrawGroundSprite(*(const uint16*)t);

   389

	t += sizeof(uint16);

   390

   391

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

   392

		image =	wdts->image + base;

   393

		if (_display_opt & DO_TRANS_BUILDINGS) {

   394

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

   395

		} else {

   396

			image |= palette;

   397

		}

   398

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

   399

	}

   400

}

   401

   402

static void DrawTile_Water(TileInfo *ti)

   403

{

   404

	// draw water tile

   405

	if (ti->map5 == 0) {

   406

		DrawGroundSprite(0xFDD);

   407

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

   408

		return;

   409

	}

   410

   411

	// draw shore

   412

	if (ti->map5 == 1) {

   413

		assert(ti->tileh < 16);

   414

		DrawGroundSprite(_water_shore_sprites[ti->tileh]);

   415

		return;

   416

	}

   417

   418

	// draw shiplift

   419

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

   420

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

   421

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

   422

		return;

   423

	}

   424

   425

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

   426

}

   427

   428

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

   429

{

   430

	const byte *t;

   431

	const WaterDrawTileStruct *wdts;

   432

   433

	t = _shipdepot_display_seq[image];

   434

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

   435

	t += sizeof(uint16);

   436

   437

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

   438

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

   439

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

   440

	}

   441

}

   442

   443

   444

static uint GetSlopeZ_Water(TileInfo *ti)

   445

{

   446

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

   447

}

   448

   449

static uint GetSlopeTileh_Water(TileInfo *ti)

   450

{

   451

	return ti->tileh;

   452

}

   453

   454

static void GetAcceptedCargo_Water(uint tile, AcceptedCargo ac)

   455

{

   456

	/* not used */

   457

}

   458

   459

static void GetTileDesc_Water(uint tile, TileDesc *td)

   460

{

   461

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

   462

		td->str = STR_3804_WATER;

   463

	else if (_map5[tile] == 0)

   464

		td->str = STR_LANDINFO_CANAL;

   465

	else if (_map5[tile] == 1)

   466

		td->str = STR_3805_COAST_OR_RIVERBANK;

   467

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

   468

		td->str = STR_LANDINFO_LOCK;

   469

	else

   470

		td->str = STR_3806_SHIP_DEPOT;

   471

   472

	td->owner = _map_owner[tile];

   473

}

   474

   475

static void AnimateTile_Water(uint tile)

   476

{

   477

	/* not used */

   478

}

   479

   480

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

   481

{

   482

	byte *p;

   483

   484

	p = &_map_type_and_height[tile];

   485

	tile += offs[0];

   486

   487

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

   488

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

   489

		return;

   490

   491

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

   492

		return;

   493

   494

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

   495

		// make coast..

   496

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

   497

			_current_player = OWNER_WATER;

   498

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

   499

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

   500

		}

   501

	} else {

   502

		if (IS_TILETYPE(tile, MP_TUNNELBRIDGE)) {

   503

			byte m5 = _map5[tile];

   504

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

   505

				return;

   506

   507

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

   508

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

   509

				return;

   510

			}

   511

		}

   512

   513

		_current_player = OWNER_WATER;

   514

		{

   515

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

   516

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

   517

		}

   518

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

   519

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

   520

	}

   521

}

   522