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 "macros.h"

     9

#include "tile.h"

    10

#include "bridge_map.h"

    11

    12

/**

    13

 * Ground types. Valid densities 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

/**

    26

 * Get the type of clear tile.

    27

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

    28

 * @pre IsTileType(t, MP_CLEAR)

    29

 * @return the ground type

    30

 */

    31

static inline ClearGround GetClearGround(TileIndex t)

    32

{

    33

	assert(IsTileType(t, MP_CLEAR));

    34

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

    35

}

    36

    37

/**

    38

 * Set the type of clear tile.

    39

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

    40

 * @param ct the ground type

    41

 * @pre IsTileType(t, MP_CLEAR)

    42

 */

    43

static inline bool IsClearGround(TileIndex t, ClearGround ct)

    44

{

    45

	return GetClearGround(t) == ct;

    46

}

    47

    48

    49

/**

    50

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

    51

 * @param t the tile to get the density of

    52

 * @pre IsTileType(t, MP_CLEAR)

    53

 * @return the density

    54

 */

    55

static inline uint GetClearDensity(TileIndex t)

    56

{

    57

	assert(IsTileType(t, MP_CLEAR));

    58

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

    59

}

    60

    61

/**

    62

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

    63

 * @param t the tile to increment the density of

    64

 * @param d the amount to increment the density with

    65

 * @pre IsTileType(t, MP_CLEAR)

    66

 */

    67

static inline void AddClearDensity(TileIndex t, int d)

    68

{

    69

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

    70

	_m[t].m5 += d;

    71

}

    72

    73

    74

/**

    75

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

    76

 * @param t the tile to get the counter of

    77

 * @pre IsTileType(t, MP_CLEAR)

    78

 * @return the value of the counter

    79

 */

    80

static inline uint GetClearCounter(TileIndex t)

    81

{

    82

	assert(IsTileType(t, MP_CLEAR));

    83

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

    84

}

    85

    86

/**

    87

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

    88

 * @param t the tile to increment the counter of

    89

 * @param c the amount to increment the counter with

    90

 * @pre IsTileType(t, MP_CLEAR)

    91

 */

    92

static inline void AddClearCounter(TileIndex t, int c)

    93

{

    94

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

    95

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

    96

}

    97

    98

/**

    99

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

   100

 * @param t the tile to set the counter of

   101

 * @param c the amount to set the counter to

   102

 * @pre IsTileType(t, MP_CLEAR)

   103

 */

   104

static inline void SetClearCounter(TileIndex t, uint c)

   105

{

   106

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

   107

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

   108

}

   109

   110

   111

/**

   112

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

   113

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

   114

 * @param type    the new ground type of the tile

   115

 * @param density the density of the ground tile

   116

 * @pre IsTileType(t, MP_CLEAR)

   117

 */

   118

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

   119

{

   120

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

   121

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

   122

}

   123

   124

   125

/**

   126

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

   127

 * @param t the field to get the type of

   128

 * @pre GetClearGround(t) == CLEAR_FIELDS

   129

 * @return the field type

   130

 */

   131

static inline uint GetFieldType(TileIndex t)

   132

{

   133

	assert(GetClearGround(t) == CLEAR_FIELDS);

   134

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

   135

}

   136

   137

/**

   138

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

   139

 * @param t the field to get the type of

   140

 * @param f the field type

   141

 * @pre GetClearGround(t) == CLEAR_FIELDS

   142

 */

   143

static inline void SetFieldType(TileIndex t, uint f)

   144

{

   145

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

   146

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

   147

}

   148

   149

/**

   150

 * Get the industry (farm) that made the field

   151

 * @param t the field to get creating industry of

   152

 * @pre GetClearGround(t) == CLEAR_FIELDS

   153

 * @return the industry that made the field

   154

 */

   155

static inline IndustryID GetIndustryIndexOfField(TileIndex t)

   156

{

   157

	assert(GetClearGround(t) == CLEAR_FIELDS);

   158

	return(IndustryID) _m[t].m2;

   159

}

   160

   161

/**

   162

 * Set the industry (farm) that made the field

   163

 * @param t the field to get creating industry of

   164

 * @param i the industry that made the field

   165

 * @pre GetClearGround(t) == CLEAR_FIELDS

   166

 */

   167

static inline void SetIndustryIndexOfField(TileIndex t, IndustryID i)

   168

{

   169

	assert(GetClearGround(t) == CLEAR_FIELDS);

   170

	_m[t].m2 = i;

   171

}

   172

   173

   174

/**

   175

 * Is there a fence at the south eastern border?

   176

 * @param t the tile to check for fences

   177

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

   178

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

   179

 */

   180

static inline uint GetFenceSE(TileIndex t)

   181

{

   182

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

   183

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

   184

}

   185

   186

/**

   187

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

   188

 * eastern border.

   189

 * @param t the tile to check for fences

   190

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

   191

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

   192

 */

   193

static inline void SetFenceSE(TileIndex t, uint h)

   194

{

   195

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

   196

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

   197

}

   198

   199

/**

   200

 * Is there a fence at the south western border?

   201

 * @param t the tile to check for fences

   202

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

   203

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

   204

 */

   205

static inline uint GetFenceSW(TileIndex t)

   206

{

   207

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

   208

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

   209

}

   210

   211

/**

   212

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

   213

 * western border.

   214

 * @param t the tile to check for fences

   215

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

   216

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

   217

 */

   218

static inline void SetFenceSW(TileIndex t, uint h)

   219

{

   220

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

   221

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

   222

}

   223

   224

   225

/**

   226

 * Make a clear tile.

   227

 * @param t       the tile to make a clear tile

   228

 * @param g       the type of ground

   229

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

   230

 */

   231

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

   232

{

   233

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

   234

	 * of the tile information is still here. */

   235

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

   236

   237

	SetTileType(t, MP_CLEAR);

   238

	SetTileOwner(t, OWNER_NONE);

   239

	_m[t].m2 = 0;

   240

	_m[t].m3 = 0;

   241

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

   242

	SetClearGroundDensity(t, g, density);

   243

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

   244

}

   245

   246

   247

/**

   248

 * Make a (farm) field tile.

   249

 * @param t          the tile to make a farm field

   250

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

   251

 * @param industry   the industry this tile belongs to

   252

 */

   253

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

   254

{

   255

	SetTileType(t, MP_CLEAR);

   256

	SetTileOwner(t, OWNER_NONE);

   257

	_m[t].m2 = industry;

   258

	_m[t].m3 = field_type;

   259

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

   260

	SetClearGroundDensity(t, CLEAR_FIELDS, 3);

   261

}

   262

   263

#endif /* CLEAR_MAP_H */