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

    94

static inline TileIndex IsShipDepot(TileIndex t)

    95

{

    96

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

    97

}

    98

    99

static inline Axis GetShipDepotAxis(TileIndex t)

   100

{

   101

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

   102

}

   103

   104

static inline DiagDirection GetShipDepotDirection(TileIndex t)

   105

{

   106

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

   107

}

   108

   110

{

   112

}

   113

   114

static inline DiagDirection GetLockDirection(TileIndex t)

   115

{

   116

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

   117

}

   118

   119

static inline byte GetSection(TileIndex t)

   120

{

   121

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

   122

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

   123

}

   124

   125

static inline byte GetWaterTileRandomBits(TileIndex t)

   126

{

   127

	return _m[t].m4;

   128

}

   129

   130

   131

static inline void MakeWater(TileIndex t)

   132

{

   133

	SetTileType(t, MP_WATER);

   134

	SetTileOwner(t, OWNER_WATER);

   135

	_m[t].m2 = 0;

   136

	_m[t].m3 = WATER_CLASS_SEA;

   137

	_m[t].m4 = 0;

   138

	_m[t].m5 = 0;

   139

}

   140

   141

static inline void MakeShore(TileIndex t)

   142

{

   143

	SetTileType(t, MP_WATER);

   144

	SetTileOwner(t, OWNER_WATER);

   145

	_m[t].m2 = 0;

   146

	_m[t].m3 = 0;

   147

	_m[t].m4 = 0;

   148

	_m[t].m5 = 1;

   149

}

   150

   151

static inline void MakeRiver(TileIndex t, uint8 random_bits)

   152

{

   153

	SetTileType(t, MP_WATER);

   154

	SetTileOwner(t, OWNER_WATER);

   155

	_m[t].m2 = 0;

   156

	_m[t].m3 = WATER_CLASS_RIVER;

   157

	_m[t].m4 = random_bits;

   158

	_m[t].m5 = 0;

   159

}

   160

   161

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

   162

{

   163

	assert(o != OWNER_WATER);

   164

	SetTileType(t, MP_WATER);

   165

	SetTileOwner(t, o);

   166

	_m[t].m2 = 0;

   167

	_m[t].m3 = WATER_CLASS_CANAL;

   168

	_m[t].m4 = random_bits;

   169

	_m[t].m5 = 0;

   170

}

   171

   173

{

   174

	SetTileType(t, MP_WATER);

   175

	SetTileOwner(t, o);

   176

	_m[t].m2 = 0;

   177

	_m[t].m3 = original_water_class;

   179

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

   180

}

   181

   182

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

   183

{

   184

	SetTileType(t, MP_WATER);

   185

	SetTileOwner(t, o);

   186

	_m[t].m2 = 0;

   187

	_m[t].m3 = original_water_class;

   188

	_m[t].m4 = 0;

   189

	_m[t].m5 = section;

   190

}

   191

   192

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

   193

{

   194

	TileIndexDiff delta = TileOffsByDiagDir(d);

   195

   196

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

   197

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

   198

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

   199

}

   200

   201

#endif /* WATER_MAP_H */