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

#include "industry_type.h"

    10

    11

/**

    12

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

    13

 */

    14

enum ClearGround {

    15

	CLEAR_GRASS  = 0, ///< 0-3

    16

	CLEAR_ROUGH  = 1, ///< 3

    17

	CLEAR_ROCKS  = 2, ///< 3

    18

	CLEAR_FIELDS = 3, ///< 3

    19

	CLEAR_SNOW   = 4, ///< 0-3

    20

	CLEAR_DESERT = 5  ///< 1,3

    21

};

    22

    23

    24

/**

    25

 * Get the type of clear tile.

    26

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

    27

 * @pre IsTileType(t, MP_CLEAR)

    28

 * @return the ground type

    29

 */

    30

static inline ClearGround GetClearGround(TileIndex t)

    31

{

    32

	assert(IsTileType(t, MP_CLEAR));

    33

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

    34

}

    35

    36

/**

    37

 * Set the type of clear tile.

    38

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

    39

 * @param ct the ground type

    40

 * @pre IsTileType(t, MP_CLEAR)

    41

 */

    42

static inline bool IsClearGround(TileIndex t, ClearGround ct)

    43

{

    44

	return GetClearGround(t) == ct;

    45

}

    46

    47

    48

/**

    49

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

    50

 * @param t the tile to get the density of

    51

 * @pre IsTileType(t, MP_CLEAR)

    52

 * @return the density

    53

 */

    54

static inline uint GetClearDensity(TileIndex t)

    55

{

    56

	assert(IsTileType(t, MP_CLEAR));

    57

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

    58

}

    59

    60

/**

    61

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

    62

 * @param t the tile to increment the density of

    63

 * @param d the amount to increment the density with

    64

 * @pre IsTileType(t, MP_CLEAR)

    65

 */

    66

static inline void AddClearDensity(TileIndex t, int d)

    67

{

    68

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

    69

	_m[t].m5 += d;

    70

}

    71

    72

    73

/**

    74

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

    75

 * @param t the tile to get the counter of

    76

 * @pre IsTileType(t, MP_CLEAR)

    77

 * @return the value of the counter

    78

 */

    79

static inline uint GetClearCounter(TileIndex t)

    80

{

    81

	assert(IsTileType(t, MP_CLEAR));

    82

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

    83

}

    84

    85

/**

    86

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

    87

 * @param t the tile to increment the counter of

    88

 * @param c the amount to increment the counter with

    89

 * @pre IsTileType(t, MP_CLEAR)

    90

 */

    91

static inline void AddClearCounter(TileIndex t, int c)

    92

{

    93

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

    94

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

    95

}

    96

    97

/**

    98

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

    99

 * @param t the tile to set the counter of

   100

 * @param c the amount to set the counter to

   101

 * @pre IsTileType(t, MP_CLEAR)

   102

 */

   103

static inline void SetClearCounter(TileIndex t, uint c)

   104

{

   105

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

   106

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

   107

}

   108

   109

   110

/**

   111

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

   112

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

   113

 * @param type    the new ground type of the tile

   114

 * @param density the density of the ground tile

   115

 * @pre IsTileType(t, MP_CLEAR)

   116

 */

   117

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

   118

{

   119

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

   120

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

   121

}

   122

   123

   124

/**

   125

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

   126

 * @param t the field to get the type of

   127

 * @pre GetClearGround(t) == CLEAR_FIELDS

   128

 * @return the field type

   129

 */

   130

static inline uint GetFieldType(TileIndex t)

   131

{

   132

	assert(GetClearGround(t) == CLEAR_FIELDS);

   133

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

   134

}

   135

   136

/**

   137

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

   138

 * @param t the field to get the type of

   139

 * @param f the field type

   140

 * @pre GetClearGround(t) == CLEAR_FIELDS

   141

 */

   142

static inline void SetFieldType(TileIndex t, uint f)

   143

{

   144

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

   145

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

   146

}

   147

   148

/**

   149

 * Get the industry (farm) that made the field

   150

 * @param t the field to get creating industry of

   151

 * @pre GetClearGround(t) == CLEAR_FIELDS

   152

 * @return the industry that made the field

   153

 */

   154

static inline IndustryID GetIndustryIndexOfField(TileIndex t)

   155

{

   156

	assert(GetClearGround(t) == CLEAR_FIELDS);

   157

	return(IndustryID) _m[t].m2;

   158

}

   159

   160

/**

   161

 * Set the industry (farm) that made the field

   162

 * @param t the field to get creating industry of

   163

 * @param i the industry that made the field

   164

 * @pre GetClearGround(t) == CLEAR_FIELDS

   165

 */

   166

static inline void SetIndustryIndexOfField(TileIndex t, IndustryID i)

   167

{

   168

	assert(GetClearGround(t) == CLEAR_FIELDS);

   169

	_m[t].m2 = i;

   170

}

   171

   172

   173

/**

   174

 * Is there a fence at the south eastern border?

   175

 * @param t the tile to check for fences

   176

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

   177

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

   178

 */

   179

static inline uint GetFenceSE(TileIndex t)

   180

{

   181

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

   182

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

   183

}

   184

   185

/**

   186

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

   187

 * eastern border.

   188

 * @param t the tile to check for fences

   189

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

   190

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

   191

 */

   192

static inline void SetFenceSE(TileIndex t, uint h)

   193

{

   194

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

   195

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

   196

}

   197

   198

/**

   199

 * Is there a fence at the south western border?

   200

 * @param t the tile to check for fences

   201

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

   202

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

   203

 */

   204

static inline uint GetFenceSW(TileIndex t)

   205

{

   206

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

   207

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

   208

}

   209

   210

/**

   211

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

   212

 * western border.

   213

 * @param t the tile to check for fences

   214

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

   215

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

   216

 */

   217

static inline void SetFenceSW(TileIndex t, uint h)

   218

{

   219

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

   220

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

   221

}

   222

   223

   224

/**

   225

 * Make a clear tile.

   226

 * @param t       the tile to make a clear tile

   227

 * @param g       the type of ground

   228

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

   229

 */

   230

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

   231

{

   232

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

   233

	 * of the tile information is still here. */

   234

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

   235

   236

	SetTileType(t, MP_CLEAR);

   237

	SetTileOwner(t, OWNER_NONE);

   238

	_m[t].m2 = 0;

   239

	_m[t].m3 = 0;

   240

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

   241

	SetClearGroundDensity(t, g, density);

   242

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

   243

}

   244

   245

   246

/**

   247

 * Make a (farm) field tile.

   248

 * @param t          the tile to make a farm field

   249

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

   250

 * @param industry   the industry this tile belongs to

   251

 */

   252

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

   253

{

   254

	SetTileType(t, MP_CLEAR);

   255

	SetTileOwner(t, OWNER_NONE);

   256

	_m[t].m2 = industry;

   257

	_m[t].m3 = field_type;

   258

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

   259

	SetClearGroundDensity(t, CLEAR_FIELDS, 3);

   260

}

   261

   262

#endif /* CLEAR_MAP_H */