1

/* $Id$ */

     2

     3

/** @file tree_map.h Map accessors for tree tiles. */

     4

     5

#ifndef TREE_MAP_H

     6

#define TREE_MAP_H

     7

     8

/**

     9

 * List of tree types along all landscape types.

    10

 *

    11

 * This enumeration contains a list of the different tree types along

    12

 * all landscape types. The values for the enumerations may be used for

    13

 * offsets from the grfs files. These points to the start of

    14

 * the tree list for a landscape. See the TREE_COUNT_* enumerations

    15

 * for the amount of different trees for a specific landscape.

    16

 *

    17

 * @note TREE_INVALID may be 0xFF according to the coding style, not -1 (Progman)

    18

 */

    19

enum TreeType {

    20

	TREE_INVALID      = -1,   ///< An invalid tree

    21

	TREE_TEMPERATE    = 0x00, ///< temperate tree

    22

	TREE_SUB_ARCTIC   = 0x0C, ///< tree on a sub_arctic landscape

    23

	TREE_RAINFOREST   = 0x14, ///< tree on the 'green part' on a sub-tropical map

    24

	TREE_CACTUS       = 0x1B, ///< a catus for the 'desert part' on a sub-tropical map

    25

	TREE_SUB_TROPICAL = 0x1C, ///< tree on a sub-tropical map, non-rainforest, non-desert

    26

	TREE_TOYLAND      = 0x20, ///< tree on a toyland map

    27

};

    28

    29

/**

    30

 * Counts the number of treetypes for each landscape.

    31

 *

    32

 * This list contains the counts of different treetypes for each landscape. This list contains

    33

 * 5 entries instead of 4 (as there are only 4 landscape types) as the sub tropic landscape

    34

 * got two types of area, one for normal trees and one only for cacti.

    35

 */

    36

enum {

    37

	TREE_COUNT_TEMPERATE    = TREE_SUB_ARCTIC   - TREE_TEMPERATE,  ///< number of treetypes on a temperate map

    38

	TREE_COUNT_SUB_ARCTIC   = TREE_RAINFOREST   - TREE_SUB_ARCTIC, ///< number of treetypes on a sub arctic map

    39

	TREE_COUNT_RAINFOREST   = TREE_CACTUS       - TREE_RAINFOREST, ///< number of treetypes for the 'green part' of a sub tropic map

    40

	TREE_COUNT_SUB_TROPICAL = TREE_SUB_TROPICAL - TREE_CACTUS,     ///< number of treetypes for the 'desert part' of a sub tropic map

    41

	TREE_COUNT_TOYLAND      = 9                                    ///< number of treetypes on a toyland map

    42

};

    43

    44

/**

    45

 * Enumeration for ground types of tiles with trees.

    46

 *

    47

 * This enumeration defines the ground types for tiles with trees on it.

    48

 */

    49

enum TreeGround {

    50

	TREE_GROUND_GRASS       = 0, ///< normal grass

    51

	TREE_GROUND_ROUGH       = 1, ///< some rough tile

    52

	TREE_GROUND_SNOW_DESERT = 2, ///< a desert or snow tile, depend on landscape

    53

	TREE_GROUND_SHORE       = 3, ///< shore

    54

};

    55

    56

    57

/**

    58

 * Returns the treetype of a tile.

    59

 *

    60

 * This function returns the treetype of a given tile. As there are more

    61

 * possible treetypes for a tile in a game as the enumeration #TreeType defines

    62

 * this function may be return a value which isn't catch by an entry of the

    63

 * enumeration #TreeType. But there is no problem known about it.

    64

 *

    65

 * @param t The tile to get the treetype from

    66

 * @return The treetype of the given tile with trees

    67

 * @pre Tile t must be of type MP_TREES

    68

 */

    69

static inline TreeType GetTreeType(TileIndex t)

    70

{

    71

	assert(IsTileType(t, MP_TREES));

    72

	return (TreeType)_m[t].m3;

    73

}

    74

    75

/**

    76

 * Returns the groundtype for tree tiles.

    77

 *

    78

 * This function returns the groundtype of a tile with trees.

    79

 *

    80

 * @param t The tile to get the groundtype from

    81

 * @return The groundtype of the tile

    82

 * @pre Tile must be of type MP_TREES

    83

 */

    84

static inline TreeGround GetTreeGround(TileIndex t)

    85

{

    86

	assert(IsTileType(t, MP_TREES));

    87

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

    88

}

    89

    90

/**

    91

 * Returns the 'density' of a tile with trees.

    92

 *

    93

 * This function returns the density of a tile which got trees. Note

    94

 * that this value doesn't count the number of trees on a tile, use

    95

 * #GetTreeCount instead. This function instead returns some kind of

    96

 * groundtype of the tile. As the map-array is finite in size and

    97

 * the informations about the trees must be saved somehow other

    98

 * informations about a tile must be saved somewhere encoded in the

    99

 * tile. So this function returns the density of a tile for sub arctic

   100

 * and sub tropical games. This means for sub arctic the type of snowline

   101

 * (0 to 3 for all 4 types of snowtiles) and for sub tropical the value

   102

 * 3 for a desert (and 0 for non-desert). The functionname is not read as

   103

 * "get the tree density of a tile" but "get the density of a tile which got trees".

   104

 *

   105

 * @param t The tile to get the 'density'

   106

 * @pre Tile must be of type MP_TREES

   107

 * @see GetTreeCount

   108

 */

   109

static inline uint GetTreeDensity(TileIndex t)

   110

{

   111

	assert(IsTileType(t, MP_TREES));

   112

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

   113

}

   114

   115

/**

   116

 * Set the density and ground type of a tile with trees.

   117

 *

   118

 * This functions saves the ground type and the density which belongs to it

   119

 * for a given tile.

   120

 *

   121

 * @param t The tile to set the density and ground type

   122

 * @param g The ground type to save

   123

 * @param d The density to save with

   124

 * @pre Tile must be of type MP_TREES

   125

 */

   126

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

   127

{

   128

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

   129

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

   130

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

   131

}

   132

   133

/**

   134

 * Returns the number of trees on a tile.

   135

 *

   136

 * This function returns the number of trees of a tile (1-4).

   137

 * The tile must be contains at least one tree or be more specific: it must be

   138

 * of type MP_TREES.

   139

 *

   140

 * @param t The index to get the number of trees

   141

 * @return The number of trees (1-4)

   142

 * @pre Tile must be of type MP_TREES

   143

 */

   144

static inline uint GetTreeCount(TileIndex t)

   145

{

   146

	assert(IsTileType(t, MP_TREES));

   147

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

   148

}

   149

   150

/**

   151

 * Add a amount to the tree-count value of a tile with trees.

   152

 *

   153

 * This function add a value to the tree-count value of a tile. This

   154

 * value may be negative to reduce the tree-counter. If the resulting

   155

 * value reach 0 it doesn't get converted to a "normal" tile.

   156

 *

   157

 * @param t The tile to change the tree amount

   158

 * @param c The value to add (or reduce) on the tree-count value

   159

 * @pre Tile must be of type MP_TREES

   160

 */

   161

static inline void AddTreeCount(TileIndex t, int c)

   162

{

   163

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

   164

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

   165

}

   166

   167

/**

   168

 * Sets the tree amount of a tile.

   169

 *

   170

 * This function directly sets the amount of trees of a tile.

   171

 *

   172

 * @param t The tile to set the amount of trees

   173

 * @param c The number of trees

   174

 * @pre Tile must be of type MP_TREES

   175

 */

   176

static inline void SetTreeCount(TileIndex t, uint c)

   177

{

   178

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

   179

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

   180

}

   181

   182

/**

   183

 * Returns the tree growth status.

   184

 *

   185

 * This function returns the tree growth status of a tile with trees.

   186

 *

   187

 * @param t The tile to get the tree growth status

   188

 * @return The tree growth status

   189

 * @pre Tile must be of type MP_TREES

   190

 */

   191

static inline uint GetTreeGrowth(TileIndex t)

   192

{

   193

	assert(IsTileType(t, MP_TREES));

   194

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

   195

}

   196

   197

/**

   198

 * Add a value to the tree growth status.

   199

 *

   200

 * This function adds a value to the tree grow status of a tile.

   201

 *

   202

 * @param t The tile to add the value on

   203

 * @param a The value to add on the tree growth status

   204

 * @pre Tile must be of type MP_TREES

   205

 */

   206

static inline void AddTreeGrowth(TileIndex t, int a)

   207

{

   208

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

   209

	_m[t].m5 += a;

   210

}

   211

   212

/**

   213

 * Sets the tree growth status of a tile.

   214

 *

   215

 * This function sets the tree growth status of a tile directly with

   216

 * the given value.

   217

 *

   218

 * @param t The tile to change the tree growth status

   219

 * @param g The new value

   220

 * @pre Tile must be of type MP_TREES

   221

 */

   222

static inline void SetTreeGrowth(TileIndex t, uint g)

   223

{

   224

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

   225

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

   226

}

   227

   228

/**

   229

 * Get the tick counter of a tree tile.

   230

 *

   231

 * Returns the saved tick counter of a given tile.

   232

 *

   233

 * @param t The tile to get the counter value from

   234

 * @pre Tile must be of type MP_TREES

   235

 */

   236

static inline uint GetTreeCounter(TileIndex t)

   237

{

   238

	assert(IsTileType(t, MP_TREES));

   239

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

   240

}

   241

   242

/**

   243

 * Add a value on the tick counter of a tree-tile

   244

 *

   245

 * This function adds a value on the tick counter of a tree-tile.

   246

 *

   247

 * @param t The tile to add the value on

   248

 * @param a The value to add on the tick counter

   249

 * @pre Tile must be of type MP_TREES

   250

 */

   251

static inline void AddTreeCounter(TileIndex t, int a)

   252

{

   253

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

   254

	_m[t].m2 += a;

   255

}

   256

   257

/**

   258

 * Set the tick counter for a tree-tile

   259

 *

   260

 * This function sets directly the tick counter for a tree-tile.

   261

 *

   262

 * @param t The tile to set the tick counter

   263

 * @param c The new tick counter value

   264

 * @pre Tile must be of type MP_TREES

   265

 */

   266

static inline void SetTreeCounter(TileIndex t, uint c)

   267

{

   268

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

   269

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

   270

}

   271

   272

/**

   273

 * Make a tree-tile.

   274

 *

   275

 * This functions change the tile to a tile with trees and all informations which belongs to it.

   276

 *

   277

 * @param t The tile to make a tree-tile from

   278

 * @param type The type of the tree

   279

 * @param set the number of trees

   280

 * @param growth the growth status

   281

 * @param ground the ground type

   282

 * @param density the density (not the number of trees)

   283

 */

   284

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

   285

{

   286

	SetTileType(t, MP_TREES);

   287

	SetTileOwner(t, OWNER_NONE);

   288

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

   289

	_m[t].m3 = type;

   290

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

   291

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

   292

}

   293

   294

#endif /* TREE_MAP_H */