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 IS_TILETYPE(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 = _tileoffs_by_dir[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

	int delta = _tileoffs_by_dir[_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

	th = GetTileSlope(tile, NULL);

   175

   176

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

   177

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

   178

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

   179

		return ret;

   180

		}

   181

	else

   182

		return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

   183

   184

	return 0;

   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 = (GET_TILE_X(tile) == GET_TILE_X(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 (IS_TILETYPE(tile, MP_WATER)) {

   210

				_error_message = STR_1007_ALREADY_BUILT;

   211

			} else {

   212

   213

				/* is middle piece of a bridge? */

   214

				if (IS_TILETYPE(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(IS_TILETYPE(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(GET_TILE_X(tile), 1, MapMaxX() - 1) &&

   269

				IS_INT_INSIDE(GET_TILE_Y(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 TileIndexDiff _shiplift_tomiddle_offs[12] = {

   292

			0,0,0,0, // middle

   293

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

   294

			TILE_XY(1, 0),TILE_XY(0, -1),TILE_XY(-1, 0),TILE_XY(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 + _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.

   318

static bool IsWateredTile(uint tile)

   319

{

   320

	byte m5 = _map5[tile];

   321

	if (IS_TILETYPE(tile, MP_WATER)) {

   322

		return m5 != 1;

   323

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

   324

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

   325

		// 83<=m5<=114 new airports

   326

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

   327

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

   328

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

   329

	} else

   330

		return false;

   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 && GET_TILEHEIGHT(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(uint tile, const int16 *offs)

   482

{

   483

	byte *p;

   484

   485

	p = &_map_type_and_height[tile];

   486

	tile += offs[0];

   487

   488

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

   489

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

   490

		return;

   491

   492

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

   493

		return;

   494

   495

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

   496

		// make coast..

   497

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

   498

			_current_player = OWNER_WATER;

   499

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

   500

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

   501

		}

   502

	} else {

   503

		if (IS_TILETYPE(tile, MP_TUNNELBRIDGE)) {

   504

			byte m5 = _map5[tile];

   505

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

   506

				return;

   507

   508

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

   509

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

   510

				return;

   511

			}

   512

		}

   513

   514

		_current_player = OWNER_WATER;

   515

		{

   516

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

   517

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

   518

		}

   519

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

   520

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

   521

	}

   522

}