1

/* $Id$ */

     2

     3

/** @file tree_map.h */

     4

     5

#ifndef TREE_MAP_H

     6

#define TREE_MAP_H

     7

     8

#include "macros.h"

     9

    10

enum TreeType {

    11

	TREE_INVALID      = -1,

    12

	TREE_TEMPERATE    = 0,

    13

	TREE_SUB_ARCTIC   = 12,

    14

	TREE_RAINFOREST   = 20,

    15

	TREE_CACTUS       = 27,

    16

	TREE_SUB_TROPICAL = 28,

    17

	TREE_TOYLAND      = 32

    18

};

    19

    20

enum {

    21

	TREE_COUNT_TEMPERATE    = TREE_SUB_ARCTIC   - TREE_TEMPERATE,

    22

	TREE_COUNT_SUB_ARCTIC   = TREE_RAINFOREST   - TREE_SUB_ARCTIC,

    23

	TREE_COUNT_RAINFOREST   = TREE_CACTUS       - TREE_RAINFOREST,

    24

	TREE_COUNT_SUB_TROPICAL = TREE_SUB_TROPICAL - TREE_CACTUS,

    25

	TREE_COUNT_TOYLAND      = 9

    26

};

    27

    28

/* ground type, m2 bits 4...5

    29

 * valid densities (bits 6...7) in comments after the enum */

    30

enum TreeGround {

    31

	TREE_GROUND_GRASS       = 0, ///< 0

    32

	TREE_GROUND_ROUGH       = 1, ///< 0

    33

	TREE_GROUND_SNOW_DESERT = 2  ///< 0-3 for snow, 3 for desert

    34

};

    35

    36

    37

static inline TreeType GetTreeType(TileIndex t)

    38

{

    39

	assert(IsTileType(t, MP_TREES));

    40

	return (TreeType)_m[t].m3;

    41

}

    42

    43

    44

static inline TreeGround GetTreeGround(TileIndex t)

    45

{

    46

	assert(IsTileType(t, MP_TREES));

    47

	return (TreeGround)GB(_m[t].m2, 4, 2);

    48

}

    49

    50

    51

static inline uint GetTreeDensity(TileIndex t)

    52

{

    53

	assert(IsTileType(t, MP_TREES));

    54

	return GB(_m[t].m2, 6, 2);

    55

}

    56

    57

    58

static inline void SetTreeGroundDensity(TileIndex t, TreeGround g, uint d)

    59

{

    60

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

    61

	SB(_m[t].m2, 4, 2, g);

    62

	SB(_m[t].m2, 6, 2, d);

    63

}

    64

    65

    66

static inline uint GetTreeCount(TileIndex t)

    67

{

    68

	assert(IsTileType(t, MP_TREES));

    69

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

    70

}

    71

    72

static inline void AddTreeCount(TileIndex t, int c)

    73

{

    74

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

    75

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

    76

}

    77

    78

static inline void SetTreeCount(TileIndex t, uint c)

    79

{

    80

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

    81

	SB(_m[t].m5, 6, 2, c);

    82

}

    83

    84

    85

static inline uint GetTreeGrowth(TileIndex t)

    86

{

    87

	assert(IsTileType(t, MP_TREES));

    88

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

    89

}

    90

    91

static inline void AddTreeGrowth(TileIndex t, int a)

    92

{

    93

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

    94

	_m[t].m5 += a;

    95

}

    96

    97

static inline void SetTreeGrowth(TileIndex t, uint g)

    98

{

    99

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

   100

	SB(_m[t].m5, 0, 3, g);

   101

}

   102

   103

   104

static inline uint GetTreeCounter(TileIndex t)

   105

{

   106

	assert(IsTileType(t, MP_TREES));

   107

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

   108

}

   109

   110

static inline void AddTreeCounter(TileIndex t, int a)

   111

{

   112

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

   113

	_m[t].m2 += a;

   114

}

   115

   116

static inline void SetTreeCounter(TileIndex t, uint c)

   117

{

   118

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

   119

	SB(_m[t].m2, 0, 4, c);

   120

}

   121

   122

   123

static inline void MakeTree(TileIndex t, TreeType type, uint count, uint growth, TreeGround ground, uint density)

   124

{

   125

	SetTileType(t, MP_TREES);

   126

	SetTileOwner(t, OWNER_NONE);

   127

	_m[t].m2 = density << 6 | ground << 4 | 0;

   128

	_m[t].m3 = type;

   129

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

   130

	_m[t].m5 = count << 6 | growth;

   131

}

   132

   133

#endif /* TREE_MAP_H */