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

	CL_GRASS  = 0, // 0-3

    14

	CL_ROUGH  = 1, // 3

    15

	CL_ROCKS  = 2, // 3

    16

	CL_FIELDS = 3, // 3

    17

	CL_SNOW   = 4, // 0-3

    18

	CL_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) == CL_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) == CL_FIELDS); // XXX incomplete

    83

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

    84

}

    85

    86

    87

/* Is used by tree tiles, too */

    88

static inline uint GetFenceSE(TileIndex t)

    89

{

    90

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

    91

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

    92

}

    93

    94

static inline void SetFenceSE(TileIndex t, uint h)

    95

{

    96

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

    97

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

    98

}

    99

   100

static inline uint GetFenceSW(TileIndex t)

   101

{

   102

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

   103

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

   104

}

   105

   106

static inline void SetFenceSW(TileIndex t, uint h)

   107

{

   108

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

   109

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

   110

}

   111

   112

   113

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

   114

{

   115

	SetTileType(t, MP_CLEAR);

   116

	SetTileOwner(t, OWNER_NONE);

   117

	_m[t].m2 = 0;

   118

	_m[t].m3 = 0;

   119

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

   120

	SetClearGroundDensity(t, g, density);

   121

}

   122

   123

   124

static inline void MakeField(TileIndex t, uint field_type)

   125

{

   126

	SetTileType(t, MP_CLEAR);

   127

	SetTileOwner(t, OWNER_NONE);

   128

	_m[t].m2 = 0;

   129

	_m[t].m3 = field_type;

   130

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

   131

	SetClearGroundDensity(t, CL_FIELDS, 3);

   132

}

   133

   134

#endif