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 WaterClass {

    16

	WATER_CLASS_SEA,

    17

	WATER_CLASS_CANAL,

    18

	WATER_CLASS_RIVER,

    19

};

    20

    21

enum DepotPart {

    22

	DEPOT_NORTH = 0x80,

    23

	DEPOT_SOUTH = 0x81,

    24

	DEPOT_END   = 0x84,

    25

};

    26

    27

enum LockPart {

    28

	LOCK_MIDDLE = 0x10,

    29

	LOCK_LOWER  = 0x14,

    30

	LOCK_UPPER  = 0x18,

    31

	LOCK_END    = 0x1C

    32

};

    33

    34

static inline WaterTileType GetWaterTileType(TileIndex t)

    35

{

    36

	assert(IsTileType(t, MP_WATER));

    37

    38

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

    39

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

    40

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

    41

    42

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

    43

	return WATER_TILE_DEPOT;

    44

}

    45

    46

static inline WaterClass GetWaterClass(TileIndex t)

    47

{

    48

	assert(IsTileType(t, MP_WATER) || IsTileType(t, MP_STATION));

    49

	return (WaterClass)GB(_m[t].m3, 0, 2);

    50

}

    51

    52

static inline void SetWaterClass(TileIndex t, WaterClass wc)

    53

{

    54

	assert(IsTileType(t, MP_WATER) || IsTileType(t, MP_STATION));

    55

	SB(_m[t].m3, 0, 2, wc);

    56

}

    57

    58

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

    59

static inline bool IsWater(TileIndex t)

    60

{

    61

	return GetWaterTileType(t) == WATER_TILE_CLEAR;

    62

}

    63

    64

static inline bool IsSea(TileIndex t)

    65

{

    66

	return IsWater(t) && GetWaterClass(t) == WATER_CLASS_SEA;

    67

}

    68

    69

static inline bool IsCanal(TileIndex t)

    70

{

    71

	return IsWater(t) && GetWaterClass(t) == WATER_CLASS_CANAL;

    72

}

    73

    74

static inline bool IsRiver(TileIndex t)

    75

{

    76

	return IsWater(t) && GetWaterClass(t) == WATER_CLASS_RIVER;

    77

}

    78

    79

static inline bool IsWaterTile(TileIndex t)

    80

{

    81

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

    82

}

    83

    84

static inline bool IsCoast(TileIndex t)

    85

{

    86

	return GetWaterTileType(t) == WATER_TILE_COAST;

    87

}

    88

    89

static inline TileIndex GetOtherShipDepotTile(TileIndex t)

    90

{

    91

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

    92

}

    93

    95

{

    96

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

    97

}

    98

   100

{

   101

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

   102

}

   103

   104

static inline Axis GetShipDepotAxis(TileIndex t)

   105

{

   106

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

   107

}

   108

   109

static inline DiagDirection GetShipDepotDirection(TileIndex t)

   110

{

   111

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

   112

}

   113

   114

static inline bool IsLock(TileIndex t)

   115

{

   116

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

   117

}

   118

   119

static inline DiagDirection GetLockDirection(TileIndex t)

   120

{

   121

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

   122

}

   123

   124

static inline byte GetSection(TileIndex t)

   125

{

   126

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

   127

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

   128

}

   129

   130

static inline byte GetWaterTileRandomBits(TileIndex t)

   131

{

   132

	return _m[t].m4;

   133

}

   134

   135

   136

static inline void MakeWater(TileIndex t)

   137

{

   138

	SetTileType(t, MP_WATER);

   139

	SetTileOwner(t, OWNER_WATER);

   140

	_m[t].m2 = 0;

   141

	_m[t].m3 = WATER_CLASS_SEA;

   142

	_m[t].m4 = 0;

   143

	_m[t].m5 = 0;

   144

}

   145

   146

static inline void MakeShore(TileIndex t)

   147

{

   148

	SetTileType(t, MP_WATER);

   149

	SetTileOwner(t, OWNER_WATER);

   150

	_m[t].m2 = 0;

   151

	_m[t].m3 = 0;

   152

	_m[t].m4 = 0;

   153

	_m[t].m5 = 1;

   154

}

   155

   156

static inline void MakeRiver(TileIndex t, uint8 random_bits)

   157

{

   158

	SetTileType(t, MP_WATER);

   159

	SetTileOwner(t, OWNER_WATER);

   160

	_m[t].m2 = 0;

   161

	_m[t].m3 = WATER_CLASS_RIVER;

   162

	_m[t].m4 = random_bits;

   163

	_m[t].m5 = 0;

   164

}

   165

   166

static inline void MakeCanal(TileIndex t, Owner o, uint8 random_bits)

   167

{

   168

	assert(o != OWNER_WATER);

   169

	SetTileType(t, MP_WATER);

   170

	SetTileOwner(t, o);

   171

	_m[t].m2 = 0;

   172

	_m[t].m3 = WATER_CLASS_CANAL;

   173

	_m[t].m4 = random_bits;

   174

	_m[t].m5 = 0;

   175

}

   176

   177

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

   178

{

   179

	SetTileType(t, MP_WATER);

   180

	SetTileOwner(t, o);

   181

	_m[t].m2 = 0;

   182

	_m[t].m3 = original_water_class;

   183

	_m[t].m4 = 0;

   184

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

   185

}

   186

   187

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

   188

{

   189

	SetTileType(t, MP_WATER);

   190

	SetTileOwner(t, o);

   191

	_m[t].m2 = 0;

   192

	_m[t].m3 = original_water_class;

   193

	_m[t].m4 = 0;

   194

	_m[t].m5 = section;

   195

}

   196

   197

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

   198

{

   199

	TileIndexDiff delta = TileOffsByDiagDir(d);

   200

   201

	MakeLockTile(t, o, LOCK_MIDDLE + d, WATER_CLASS_CANAL);

   202

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

   203

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

   204

}

   205

   206

#endif /* WATER_MAP_H */