1

/* $Id$ */

     2

     3

/** @file water_map.h */

     4

     5

#ifndef WATER_MAP_H

     6

#define WATER_MAP_H

     7

     8

enum WaterTileType {

     9

	WATER_TILE_CLEAR,

    10

	WATER_TILE_COAST,

    11

	WATER_TILE_LOCK,

    12

	WATER_TILE_DEPOT,

    13

};

    14

    15

enum DepotPart {

    16

	DEPOT_NORTH = 0x80,

    17

	DEPOT_SOUTH = 0x81,

    18

	DEPOT_END   = 0x84,

    19

};

    20

    21

enum LockPart {

    22

	LOCK_MIDDLE = 0x10,

    23

	LOCK_LOWER  = 0x14,

    24

	LOCK_UPPER  = 0x18,

    25

	LOCK_END    = 0x1C

    26

};

    27

    28

static inline WaterTileType GetWaterTileType(TileIndex t)

    29

{

    30

	assert(IsTileType(t, MP_WATER));

    31

    32

	if (_m[t].m5 == 0) return WATER_TILE_CLEAR;

    33

	if (_m[t].m5 == 1) return WATER_TILE_COAST;

    34

	if (IsInsideMM(_m[t].m5, LOCK_MIDDLE, LOCK_END)) return WATER_TILE_LOCK;

    35

    36

	assert(IsInsideMM(_m[t].m5, DEPOT_NORTH, DEPOT_END));

    37

	return WATER_TILE_DEPOT;

    38

}

    39

    40

/** IsWater return true if any type of clear water like ocean, river, canal */

    41

static inline bool IsWater(TileIndex t)

    42

{

    43

	return GetWaterTileType(t) == WATER_TILE_CLEAR;

    44

}

    45

    46

static inline bool IsSea(TileIndex t)

    47

{

    48

	if (GetWaterTileType(t) != WATER_TILE_CLEAR) return false;

    49

	if (!IsTileOwner(t, OWNER_WATER)) return false; // 'Human' built water = canal, not sea

    50

	return true;

    51

}

    52

    53

static inline bool IsCoast(TileIndex t)

    54

{

    55

	return GetWaterTileType(t) == WATER_TILE_COAST;

    56

}

    57

    58

static inline bool IsCanal(TileIndex t)

    59

{

    60

	return GetWaterTileType(t) == WATER_TILE_CLEAR && GetTileOwner(t) != OWNER_WATER;

    61

}

    62

    63

static inline bool IsWaterTile(TileIndex t)

    64

{

    65

	return IsTileType(t, MP_WATER) && IsWater(t);

    66

}

    67

    68

static inline TileIndex GetOtherShipDepotTile(TileIndex t)

    69

{

    70

	return t + (HasBit(_m[t].m5, 0) ? -1 : 1) * (HasBit(_m[t].m5, 1) ? TileDiffXY(0, 1) : TileDiffXY(1, 0));

    71

}

    72

    73

static inline TileIndex IsShipDepot(TileIndex t)

    74

{

    75

	return IsInsideMM(_m[t].m5, DEPOT_NORTH, DEPOT_END);

    76

}

    77

    78

static inline Axis GetShipDepotAxis(TileIndex t)

    79

{

    80

	return (Axis)GB(_m[t].m5, 1, 1);

    81

}

    82

    83

static inline DiagDirection GetShipDepotDirection(TileIndex t)

    84

{

    85

	return XYNSToDiagDir(GetShipDepotAxis(t), GB(_m[t].m5, 0, 1));

    86

}

    87

    88

static inline DiagDirection GetLockDirection(TileIndex t)

    89

{

    90

	return (DiagDirection)GB(_m[t].m5, 0, 2);

    91

}

    92

    93

static inline byte GetSection(TileIndex t)

    94

{

    95

	assert(GetWaterTileType(t) == WATER_TILE_LOCK || GetWaterTileType(t) == WATER_TILE_DEPOT);

    96

	return GB(_m[t].m5, 0, 4);

    97

}

    98

    99

   100

static inline void MakeWater(TileIndex t)

   101

{

   102

	SetTileType(t, MP_WATER);

   103

	SetTileOwner(t, OWNER_WATER);

   104

	_m[t].m2 = 0;

   105

	_m[t].m3 = 0;

   106

	_m[t].m4 = 0;

   107

	_m[t].m5 = 0;

   108

}

   109

   110

static inline void MakeShore(TileIndex t)

   111

{

   112

	SetTileType(t, MP_WATER);

   113

	SetTileOwner(t, OWNER_WATER);

   114

	_m[t].m2 = 0;

   115

	_m[t].m3 = 0;

   116

	_m[t].m4 = 0;

   117

	_m[t].m5 = 1;

   118

}

   119

   120

static inline void MakeCanal(TileIndex t, Owner o)

   121

{

   122

	assert(o != OWNER_WATER);

   123

	SetTileType(t, MP_WATER);

   124

	SetTileOwner(t, o);

   125

	_m[t].m2 = 0;

   126

	_m[t].m3 = 0;

   127

	_m[t].m4 = 0;

   128

	_m[t].m5 = 0;

   129

}

   130

   131

static inline void MakeShipDepot(TileIndex t, Owner o, DepotPart base, Axis a)

   132

{

   133

	SetTileType(t, MP_WATER);

   134

	SetTileOwner(t, o);

   135

	_m[t].m2 = 0;

   136

	_m[t].m3 = 0;

   137

	_m[t].m4 = 0;

   138

	_m[t].m5 = base + a * 2;

   139

}

   140

   141

static inline void MakeLockTile(TileIndex t, Owner o, byte section)

   142

{

   143

	SetTileType(t, MP_WATER);

   144

	SetTileOwner(t, o);

   145

	_m[t].m2 = 0;

   146

	_m[t].m3 = 0;

   147

	_m[t].m4 = 0;

   148

	_m[t].m5 = section;

   149

}

   150

   151

static inline void MakeLock(TileIndex t, Owner o, DiagDirection d)

   152

{

   153

	TileIndexDiff delta = TileOffsByDiagDir(d);

   154

   155

	MakeLockTile(t, o, LOCK_MIDDLE + d);

   156

	MakeLockTile(t - delta, o, LOCK_LOWER + d);

   157

	MakeLockTile(t + delta, o, LOCK_UPPER + d);

   158

}

   159

   160

#endif /* WATER_MAP_H */