1

/* $Id$ */

     2

     3

#ifndef CLEAR_MAP_H

     4

#define CLEAR_MAP_H

     5

     6

#include "macros.h"

     7

#include "tile.h"

     8

     9

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

    10

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

    11

 */

    12

typedef enum ClearGround {

    13

	CLEAR_GRASS  = 0, // 0-3

    14

	CLEAR_ROUGH  = 1, // 3

    15

	CLEAR_ROCKS  = 2, // 3

    16

	CLEAR_FIELDS = 3, // 3

    17

	CLEAR_SNOW   = 4, // 0-3

    18

	CLEAR_DESERT = 5  // 1,3

    19

} ClearGround;

    20

    21

    22

static inline ClearGround GetClearGround(TileIndex t)

    23

{

    24

	assert(IsTileType(t, MP_CLEAR));

    25

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

    26

}

    27

    28

static inline bool IsClearGround(TileIndex t, ClearGround ct)

    29

{

    30

	return GetClearGround(t) == ct;

    31

}

    32

    33

    34

static inline uint GetClearDensity(TileIndex t)

    35

{

    36

	assert(IsTileType(t, MP_CLEAR));

    37

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

    38

}

    39

    40

static inline void AddClearDensity(TileIndex t, int d)

    41

{

    42

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

    43

	_m[t].m5 += d;

    44

}

    45

    46

    47

static inline uint GetClearCounter(TileIndex t)

    48

{

    49

	assert(IsTileType(t, MP_CLEAR));

    50

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

    51

}

    52

    53

static inline void AddClearCounter(TileIndex t, int c)

    54

{

    55

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

    56

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

    57

}

    58

    59

static inline void SetClearCounter(TileIndex t, uint c)

    60

{

    61

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

    62

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

    63

}

    64

    65

    66

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

    67

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

    68

{

    69

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

    70

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

    71

}

    72

    73

    74

static inline uint GetFieldType(TileIndex t)

    75

{

    76

	assert(GetClearGround(t) == CLEAR_FIELDS);

    77

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

    78

}

    79

    80

static inline void SetFieldType(TileIndex t, uint f)

    81

{

    82

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

    83

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

    84

}

    85

    86

static inline uint16 GetIndustryIndexOfField(TileIndex t)

    87

{

    88

	assert(GetClearGround(t) == CLEAR_FIELDS);

    89

	return _m[t].m2;

    90

}

    91

    92

static inline void SetIndustryIndexOfField(TileIndex t, uint16 i)

    93

{

    94

	assert(GetClearGround(t) == CLEAR_FIELDS);

    95

	_m[t].m2 = i;

    96

}

    97

    98

/* Is used by tree tiles, too */

    99

static inline uint GetFenceSE(TileIndex t)

   100

{

   101

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

   102

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

   103

}

   104

   105

static inline void SetFenceSE(TileIndex t, uint h)

   106

{

   107

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

   108

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

   109

}

   110

   111

static inline uint GetFenceSW(TileIndex t)

   112

{

   113

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

   114

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

   115

}

   116

   117

static inline void SetFenceSW(TileIndex t, uint h)

   118

{

   119

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

   120

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

   121

}

   122

   123

   124

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

   125

{

   126

	SetTileType(t, MP_CLEAR);

   127

	SetTileOwner(t, OWNER_NONE);

   128

	_m[t].m2 = 0;

   129

	_m[t].m3 = 0;

   130

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

   131

	SetClearGroundDensity(t, g, density);

   132

}

   133

   134

   135

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

   136

{

   137

	SetTileType(t, MP_CLEAR);

   138

	SetTileOwner(t, OWNER_NONE);

   139

	_m[t].m2 = industry;

   140

	_m[t].m3 = field_type;

   141

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

   142

	SetClearGroundDensity(t, CLEAR_FIELDS, 3);

   143

}

   144

   145

#endif /* CLEAR_MAP_H */