1

/* $Id$ */

     2

     3

/** @file water_map.h Map accessors for water tiles. */

     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

	WATER_CLASS_INVALID, ///< Used for industry tiles on land (also for oilrig if newgrf says so)

    20

};

    21

    22

enum DepotPart {

    23

	DEPOT_NORTH = 0x80,

    24

	DEPOT_SOUTH = 0x81,

    25

	DEPOT_END   = 0x84,

    26

};

    27

    28

enum LockPart {

    29

	LOCK_MIDDLE = 0x10,

    30

	LOCK_LOWER  = 0x14,

    31

	LOCK_UPPER  = 0x18,

    32

	LOCK_END    = 0x1C

    33

};

    34

    35

static inline WaterTileType GetWaterTileType(TileIndex t)

    36

{

    37

	assert(IsTileType(t, MP_WATER));

    38

    39

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

    40

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

    41

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

    42

    43

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

    44

	return WATER_TILE_DEPOT;

    45

}

    46

    47

static inline WaterClass GetWaterClass(TileIndex t)

    48

{

    49

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

    50

	return (WaterClass)(IsTileType(t, MP_INDUSTRY) ? GB(_m[t].m1, 5, 2) : GB(_m[t].m3, 0, 2));

    51

}

    52

    53

static inline void SetWaterClass(TileIndex t, WaterClass wc)

    54

{

    55

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

    56

	if (IsTileType(t, MP_INDUSTRY)) {

    57

		SB(_m[t].m1, 5, 2, wc);

    58

	} else {

    59

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

    60

	}

    61

}

    62

    63

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

    64

static inline bool IsWater(TileIndex t)

    65

{

    66

	return GetWaterTileType(t) == WATER_TILE_CLEAR;

    67

}

    68

    69

static inline bool IsSea(TileIndex t)

    70

{

    71

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

    72

}

    73

    74

static inline bool IsCanal(TileIndex t)

    75

{

    76

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

    77

}

    78

    79

static inline bool IsRiver(TileIndex t)

    80

{

    81

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

    82

}

    83

    84

static inline bool IsWaterTile(TileIndex t)

    85

{

    86

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

    87

}

    88

    89

static inline bool IsCoast(TileIndex t)

    90

{

    91

	return GetWaterTileType(t) == WATER_TILE_COAST;

    92

}

    93

    94

static inline TileIndex GetOtherShipDepotTile(TileIndex t)

    95

{

    96

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

    97

}

    98

    99

static inline bool IsShipDepot(TileIndex t)

   100

{

   101

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

   102

}

   103

   104

static inline bool IsShipDepotTile(TileIndex t)

   105

{

   106

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

   107

}

   108

   109

static inline Axis GetShipDepotAxis(TileIndex t)

   110

{

   111

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

   112

}

   113

   114

static inline DiagDirection GetShipDepotDirection(TileIndex t)

   115

{

   116

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

   117

}

   118

   119

static inline bool IsLock(TileIndex t)

   120

{

   121

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

   122

}

   123

   124

static inline DiagDirection GetLockDirection(TileIndex t)

   125

{

   126

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

   127

}

   128

   129

static inline byte GetSection(TileIndex t)

   130

{

   131

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

   132

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

   133

}

   134

   135

static inline byte GetWaterTileRandomBits(TileIndex t)

   136

{

   137

	return _m[t].m4;

   138

}

   139

   140

   141

static inline void MakeWater(TileIndex t)

   142

{

   143

	SetTileType(t, MP_WATER);

   144

	SetTileOwner(t, OWNER_WATER);

   145

	_m[t].m2 = 0;

   146

	_m[t].m3 = WATER_CLASS_SEA;

   147

	_m[t].m4 = 0;

   148

	_m[t].m5 = 0;

   149

}

   150

   151

static inline void MakeShore(TileIndex t)

   152

{

   153

	SetTileType(t, MP_WATER);

   154

	SetTileOwner(t, OWNER_WATER);

   155

	_m[t].m2 = 0;

   156

	_m[t].m3 = 0;

   157

	_m[t].m4 = 0;

   158

	_m[t].m5 = 1;

   159

}

   160

   161

static inline void MakeRiver(TileIndex t, uint8 random_bits)

   162

{

   163

	SetTileType(t, MP_WATER);

   164

	SetTileOwner(t, OWNER_WATER);

   165

	_m[t].m2 = 0;

   166

	_m[t].m3 = WATER_CLASS_RIVER;

   167

	_m[t].m4 = random_bits;

   168

	_m[t].m5 = 0;

   169

}

   170

   171

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

   172

{

   173

	assert(o != OWNER_WATER);

   174

	SetTileType(t, MP_WATER);

   175

	SetTileOwner(t, o);

   176

	_m[t].m2 = 0;

   177

	_m[t].m3 = WATER_CLASS_CANAL;

   178

	_m[t].m4 = random_bits;

   179

	_m[t].m5 = 0;

   180

}

   181

   182

static inline void MakeShipDepot(TileIndex t, Owner o, DepotPart base, Axis a, 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 = base + a * 2;

   190

}

   191

   192

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

   193

{

   194

	SetTileType(t, MP_WATER);

   195

	SetTileOwner(t, o);

   196

	_m[t].m2 = 0;

   197

	_m[t].m3 = original_water_class;

   198

	_m[t].m4 = 0;

   199

	_m[t].m5 = section;

   200

}

   201

   202

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

   203

{

   204

	TileIndexDiff delta = TileOffsByDiagDir(d);

   205

   206

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

   207

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

   208

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

   209

}

   210

   211

#endif /* WATER_MAP_H */