1

/* $Id$ */

     2

     3

#ifndef CLEAR_MAP_H

     4

#define CLEAR_MAP_H

     5

     6

#include "macros.h"

     7

#include "tile.h"

     8

#include "bridge_map.h"

     9

    10

/* ground type, m5 bits 2...4

    11

 * valid densities (bits 0...1) in comments after the enum

    12

 */

    13

typedef enum ClearGround {

    14

	CLEAR_GRASS  = 0, // 0-3

    15

	CLEAR_ROUGH  = 1, // 3

    16

	CLEAR_ROCKS  = 2, // 3

    17

	CLEAR_FIELDS = 3, // 3

    18

	CLEAR_SNOW   = 4, // 0-3

    19

	CLEAR_DESERT = 5  // 1,3

    20

} ClearGround;

    21

    22

    23

static inline ClearGround GetClearGround(TileIndex t)

    24

{

    25

	assert(IsTileType(t, MP_CLEAR));

    27

}

    28

    29

static inline bool IsClearGround(TileIndex t, ClearGround ct)

    30

{

    31

	return GetClearGround(t) == ct;

    32

}

    33

    34

    35

static inline uint GetClearDensity(TileIndex t)

    36

{

    37

	assert(IsTileType(t, MP_CLEAR));

    38

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

    39

}

    40

    41

static inline void AddClearDensity(TileIndex t, int d)

    42

{

    43

	assert(IsTileType(t, MP_CLEAR)); // XXX incomplete

    44

	_m[t].m5 += d;

    45

}

    46

    47

    48

static inline uint GetClearCounter(TileIndex t)

    49

{

    50

	assert(IsTileType(t, MP_CLEAR));

    51

	return GB(_m[t].m5, 5, 3);

    52

}

    53

    54

static inline void AddClearCounter(TileIndex t, int c)

    55

{

    56

	assert(IsTileType(t, MP_CLEAR)); // XXX incomplete

    57

	_m[t].m5 += c << 5;

    58

}

    59

    60

static inline void SetClearCounter(TileIndex t, uint c)

    61

{

    62

	assert(IsTileType(t, MP_CLEAR)); // XXX incomplete

    63

	SB(_m[t].m5, 5, 3, c);

    64

}

    65

    66

    67

/* Sets type and density in one go, also sets the counter to 0 */

    68

static inline void SetClearGroundDensity(TileIndex t, ClearGround type, uint density)

    69

{

    70

	assert(IsTileType(t, MP_CLEAR)); // XXX incomplete

    71

	_m[t].m5 = 0 << 5 | type << 2 | density;

    72

}

    73

    74

    75

static inline uint GetFieldType(TileIndex t)

    76

{

    77

	assert(GetClearGround(t) == CLEAR_FIELDS);

    78

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

    79

}

    80

    81

static inline void SetFieldType(TileIndex t, uint f)

    82

{

    83

	assert(GetClearGround(t) == CLEAR_FIELDS); // XXX incomplete

    84

	SB(_m[t].m3, 0, 4, f);

    85

}

    86

    87

static inline uint16 GetIndustryIndexOfField(TileIndex t)

    88

{

    89

	assert(GetClearGround(t) == CLEAR_FIELDS);

    90

	return _m[t].m2;

    91

}

    92

    93

static inline void SetIndustryIndexOfField(TileIndex t, uint16 i)

    94

{

    95

	assert(GetClearGround(t) == CLEAR_FIELDS);

    96

	_m[t].m2 = i;

    97

}

    98

    99

/* Is used by tree tiles, too */

   100

static inline uint GetFenceSE(TileIndex t)

   101

{

   102

	assert(IsTileType(t, MP_CLEAR) || IsTileType(t, MP_TREES));

   103

	return GB(_m[t].m4, 2, 3);

   104

}

   105

   106

static inline void SetFenceSE(TileIndex t, uint h)

   107

{

   108

	assert(IsTileType(t, MP_CLEAR) || IsTileType(t, MP_TREES)); // XXX incomplete

   109

	SB(_m[t].m4, 2, 3, h);

   110

}

   111

   112

static inline uint GetFenceSW(TileIndex t)

   113

{

   114

	assert(IsTileType(t, MP_CLEAR) || IsTileType(t, MP_TREES));

   115

	return GB(_m[t].m4, 5, 3);

   116

}

   117

   118

static inline void SetFenceSW(TileIndex t, uint h)

   119

{

   120

	assert(IsTileType(t, MP_CLEAR) || IsTileType(t, MP_TREES)); // XXX incomplete

   121

	SB(_m[t].m4, 5, 3, h);

   122

}

   123

   124

   125

static inline void MakeClear(TileIndex t, ClearGround g, uint density)

   126

{

   127

	/* If this is a non-bridgeable tile, clear the bridge bits while the rest

   128

	 * of the tile information is still here. */

   129

	if (!MayHaveBridgeAbove(t)) SB(_m[t].extra, 6, 2, 0);

   130

   131

	SetTileType(t, MP_CLEAR);

   132

	SetTileOwner(t, OWNER_NONE);

   133

	_m[t].m2 = 0;

   134

	_m[t].m3 = 0;

   135

	_m[t].m4 = 0 << 5 | 0 << 2;

   136

	SetClearGroundDensity(t, g, density);

   137

	SB(_m[t].extra, 2, 4, 0);

   138

}

   139

   140

   141

static inline void MakeField(TileIndex t, uint field_type, uint16 industry)

   142

{

   143

	SetTileType(t, MP_CLEAR);

   144

	SetTileOwner(t, OWNER_NONE);

   145

	_m[t].m2 = industry;

   146

	_m[t].m3 = field_type;

   147

	_m[t].m4 = 0 << 5 | 0 << 2;

   148

	SetClearGroundDensity(t, CLEAR_FIELDS, 3);

   149

}

   150

   151

#endif /* CLEAR_MAP_H */