1

/* $Id$ */

     2

     3

/** @file clear_map.h */

     4

     5

#ifndef CLEAR_MAP_H

     6

#define CLEAR_MAP_H

     7

     8

#include "macros.h"

     9

#include "tile.h"

    10

#include "bridge_map.h"

    11

    12

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

    13

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

    14

 */

    15

enum ClearGround {

    16

	CLEAR_GRASS  = 0, ///< 0-3

    17

	CLEAR_ROUGH  = 1, ///< 3

    18

	CLEAR_ROCKS  = 2, ///< 3

    19

	CLEAR_FIELDS = 3, ///< 3

    20

	CLEAR_SNOW   = 4, ///< 0-3

    21

	CLEAR_DESERT = 5  ///< 1,3

    22

};

    23

    24

    25

static inline ClearGround GetClearGround(TileIndex t)

    26

{

    27

	assert(IsTileType(t, MP_CLEAR));

    28

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

    29

}

    30

    31

static inline bool IsClearGround(TileIndex t, ClearGround ct)

    32

{

    33

	return GetClearGround(t) == ct;

    34

}

    35

    36

    37

static inline uint GetClearDensity(TileIndex t)

    38

{

    39

	assert(IsTileType(t, MP_CLEAR));

    40

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

    41

}

    42

    43

static inline void AddClearDensity(TileIndex t, int d)

    44

{

    45

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

    46

	_m[t].m5 += d;

    47

}

    48

    49

    50

static inline uint GetClearCounter(TileIndex t)

    51

{

    52

	assert(IsTileType(t, MP_CLEAR));

    53

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

    54

}

    55

    56

static inline void AddClearCounter(TileIndex t, int c)

    57

{

    58

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

    59

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

    60

}

    61

    62

static inline void SetClearCounter(TileIndex t, uint c)

    63

{

    64

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

    65

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

    66

}

    67

    68

    69

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

    70

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

    71

{

    72

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

    73

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

    74

}

    75

    76

    77

static inline uint GetFieldType(TileIndex t)

    78

{

    79

	assert(GetClearGround(t) == CLEAR_FIELDS);

    80

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

    81

}

    82

    83

static inline void SetFieldType(TileIndex t, uint f)

    84

{

    85

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

    86

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

    87

}

    88

    89

static inline uint16 GetIndustryIndexOfField(TileIndex t)

    90

{

    91

	assert(GetClearGround(t) == CLEAR_FIELDS);

    92

	return _m[t].m2;

    93

}

    94

    95

static inline void SetIndustryIndexOfField(TileIndex t, uint16 i)

    96

{

    97

	assert(GetClearGround(t) == CLEAR_FIELDS);

    98

	_m[t].m2 = i;

    99

}

   100

   101

/* Is used by tree tiles, too */

   102

static inline uint GetFenceSE(TileIndex t)

   103

{

   104

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

   105

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

   106

}

   107

   108

static inline void SetFenceSE(TileIndex t, uint h)

   109

{

   110

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

   111

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

   112

}

   113

   114

static inline uint GetFenceSW(TileIndex t)

   115

{

   116

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

   117

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

   118

}

   119

   120

static inline void SetFenceSW(TileIndex t, uint h)

   121

{

   122

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

   123

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

   124

}

   125

   126

   127

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

   128

{

   129

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

   130

	 * of the tile information is still here. */

   131

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

   132

   133

	SetTileType(t, MP_CLEAR);

   134

	SetTileOwner(t, OWNER_NONE);

   135

	_m[t].m2 = 0;

   136

	_m[t].m3 = 0;

   137

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

   138

	SetClearGroundDensity(t, g, density);

   139

	SB(_m[t].m6, 2, 4, 0); // Clear the rest of m6, bits 2 to 5

   140

}

   141

   142

   143

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

   144

{

   145

	SetTileType(t, MP_CLEAR);

   146

	SetTileOwner(t, OWNER_NONE);

   147

	_m[t].m2 = industry;

   148

	_m[t].m3 = field_type;

   149

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

   150

	SetClearGroundDensity(t, CLEAR_FIELDS, 3);

   151

}

   152

   153

#endif /* CLEAR_MAP_H */