1

/* $Id$ */

     2

     3

/** @file clear_map.h Map accessors for 'clear' tiles */

     4

     5

#ifndef CLEAR_MAP_H

     6

#define CLEAR_MAP_H

     7

     8

#include "bridge_map.h"

     9

    10

/**

    11

 * Ground types. Valid densities in comments after the enum.

    12

 */

    13

enum ClearGround {

    14

	CLEAR_GRASS  = 0, ///< 0-3

    15

	CLEAR_ROUGH  = 1, ///< 3

    16

	CLEAR_ROCKS  = 2, ///< 3

    17

	CLEAR_FIELDS = 3, ///< 3

    18

	CLEAR_SNOW   = 4, ///< 0-3

    19

	CLEAR_DESERT = 5  ///< 1,3

    20

};

    21

    22

    23

/**

    24

 * Get the type of clear tile.

    25

 * @param t the tile to get the clear ground type of

    26

 * @pre IsTileType(t, MP_CLEAR)

    27

 * @return the ground type

    28

 */

    29

static inline ClearGround GetClearGround(TileIndex t)

    30

{

    31

	assert(IsTileType(t, MP_CLEAR));

    32

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

    33

}

    34

    35

/**

    36

 * Set the type of clear tile.

    37

 * @param t  the tile to set the clear ground type of

    38

 * @param ct the ground type

    39

 * @pre IsTileType(t, MP_CLEAR)

    40

 */

    41

static inline bool IsClearGround(TileIndex t, ClearGround ct)

    42

{

    43

	return GetClearGround(t) == ct;

    44

}

    45

    46

    47

/**

    48

 * Get the density of a non-field clear tile.

    49

 * @param t the tile to get the density of

    50

 * @pre IsTileType(t, MP_CLEAR)

    51

 * @return the density

    52

 */

    53

static inline uint GetClearDensity(TileIndex t)

    54

{

    55

	assert(IsTileType(t, MP_CLEAR));

    56

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

    57

}

    58

    59

/**

    60

 * Increment the density of a non-field clear tile.

    61

 * @param t the tile to increment the density of

    62

 * @param d the amount to increment the density with

    63

 * @pre IsTileType(t, MP_CLEAR)

    64

 */

    65

static inline void AddClearDensity(TileIndex t, int d)

    66

{

    67

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

    68

	_m[t].m5 += d;

    69

}

    70

    71

    72

/**

    73

 * Get the counter used to advance to the next clear density/field type.

    74

 * @param t the tile to get the counter of

    75

 * @pre IsTileType(t, MP_CLEAR)

    76

 * @return the value of the counter

    77

 */

    78

static inline uint GetClearCounter(TileIndex t)

    79

{

    80

	assert(IsTileType(t, MP_CLEAR));

    81

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

    82

}

    83

    84

/**

    85

 * Increments the counter used to advance to the next clear density/field type.

    86

 * @param t the tile to increment the counter of

    87

 * @param c the amount to increment the counter with

    88

 * @pre IsTileType(t, MP_CLEAR)

    89

 */

    90

static inline void AddClearCounter(TileIndex t, int c)

    91

{

    92

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

    93

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

    94

}

    95

    96

/**

    97

 * Sets the counter used to advance to the next clear density/field type.

    98

 * @param t the tile to set the counter of

    99

 * @param c the amount to set the counter to

   100

 * @pre IsTileType(t, MP_CLEAR)

   101

 */

   102

static inline void SetClearCounter(TileIndex t, uint c)

   103

{

   104

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

   105

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

   106

}

   107

   108

   109

/**

   110

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

   111

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

   112

 * @param type    the new ground type of the tile

   113

 * @param density the density of the ground tile

   114

 * @pre IsTileType(t, MP_CLEAR)

   115

 */

   116

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

   117

{

   118

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

   119

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

   120

}

   121

   122

   123

/**

   124

 * Get the field type (production stage) of the field

   125

 * @param t the field to get the type of

   126

 * @pre GetClearGround(t) == CLEAR_FIELDS

   127

 * @return the field type

   128

 */

   129

static inline uint GetFieldType(TileIndex t)

   130

{

   131

	assert(GetClearGround(t) == CLEAR_FIELDS);

   132

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

   133

}

   134

   135

/**

   136

 * Set the field type (production stage) of the field

   137

 * @param t the field to get the type of

   138

 * @param f the field type

   139

 * @pre GetClearGround(t) == CLEAR_FIELDS

   140

 */

   141

static inline void SetFieldType(TileIndex t, uint f)

   142

{

   143

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

   144

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

   145

}

   146

   147

/**

   148

 * Get the industry (farm) that made the field

   149

 * @param t the field to get creating industry of

   150

 * @pre GetClearGround(t) == CLEAR_FIELDS

   151

 * @return the industry that made the field

   152

 */

   153

static inline IndustryID GetIndustryIndexOfField(TileIndex t)

   154

{

   155

	assert(GetClearGround(t) == CLEAR_FIELDS);

   156

	return(IndustryID) _m[t].m2;

   157

}

   158

   159

/**

   160

 * Set the industry (farm) that made the field

   161

 * @param t the field to get creating industry of

   162

 * @param i the industry that made the field

   163

 * @pre GetClearGround(t) == CLEAR_FIELDS

   164

 */

   165

static inline void SetIndustryIndexOfField(TileIndex t, IndustryID i)

   166

{

   167

	assert(GetClearGround(t) == CLEAR_FIELDS);

   168

	_m[t].m2 = i;

   169

}

   170

   171

   172

/**

   173

 * Is there a fence at the south eastern border?

   174

 * @param t the tile to check for fences

   175

 * @pre IsTileType(t, MP_CLEAR) || IsTileType(t, MP_TREES)

   176

 * @return 0 if there is no fence, otherwise the fence type

   177

 */

   178

static inline uint GetFenceSE(TileIndex t)

   179

{

   180

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

   181

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

   182

}

   183

   184

/**

   185

 * Sets the type of fence (and whether there is one) for the south

   186

 * eastern border.

   187

 * @param t the tile to check for fences

   188

 * @param h 0 if there is no fence, otherwise the fence type

   189

 * @pre IsTileType(t, MP_CLEAR) || IsTileType(t, MP_TREES)

   190

 */

   191

static inline void SetFenceSE(TileIndex t, uint h)

   192

{

   193

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

   194

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

   195

}

   196

   197

/**

   198

 * Is there a fence at the south western border?

   199

 * @param t the tile to check for fences

   200

 * @pre IsTileType(t, MP_CLEAR) || IsTileType(t, MP_TREES)

   201

 * @return 0 if there is no fence, otherwise the fence type

   202

 */

   203

static inline uint GetFenceSW(TileIndex t)

   204

{

   205

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

   206

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

   207

}

   208

   209

/**

   210

 * Sets the type of fence (and whether there is one) for the south

   211

 * western border.

   212

 * @param t the tile to check for fences

   213

 * @param h 0 if there is no fence, otherwise the fence type

   214

 * @pre IsTileType(t, MP_CLEAR) || IsTileType(t, MP_TREES)

   215

 */

   216

static inline void SetFenceSW(TileIndex t, uint h)

   217

{

   218

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

   219

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

   220

}

   221

   222

   223

/**

   224

 * Make a clear tile.

   225

 * @param t       the tile to make a clear tile

   226

 * @param g       the type of ground

   227

 * @param density the density of the grass/snow/desert etc

   228

 */

   229

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

   230

{

   231

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

   232

	 * of the tile information is still here. */

   233

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

   234

   235

	SetTileType(t, MP_CLEAR);

   236

	SetTileOwner(t, OWNER_NONE);

   237

	_m[t].m2 = 0;

   238

	_m[t].m3 = 0;

   239

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

   240

	SetClearGroundDensity(t, g, density);

   241

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

   242

}

   243

   244

   245

/**

   246

 * Make a (farm) field tile.

   247

 * @param t          the tile to make a farm field

   248

 * @param field_type the 'growth' level of the field

   249

 * @param industry   the industry this tile belongs to

   250

 */

   251

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

   252

{

   253

	SetTileType(t, MP_CLEAR);

   254

	SetTileOwner(t, OWNER_NONE);

   255

	_m[t].m2 = industry;

   256

	_m[t].m3 = field_type;

   257

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

   258

	SetClearGroundDensity(t, CLEAR_FIELDS, 3);

   259

}

   260

   261

#endif /* CLEAR_MAP_H */