1

/* $Id$ */

     2

     3

/** @file slope.h Definitions of a slope.

     4

 * This file defines the enumeration and helper functions for handling

     5

 * the slope info of a tile.

     6

 */

     7

     8

#ifndef SLOPE_H

     9

#define SLOPE_H

    10

    11

/**

    12

 * Enumeration for the slope-type.

    13

 *

    14

 * This enumeration use the chars N,E,S,W corresponding the

    15

 * direction north, east, south and west. The top corner of a tile

    16

 * is the north-part of the tile. The whole slope is encoded with

    17

 * 5 bits, 4 bits for each corner and 1 bit for a steep-flag.

    18

 */

    19

enum Slope {

    20

	SLOPE_FLAT     = 0x00,                                  ///< a flat tile

    21

	SLOPE_W        = 0x01,                                  ///< the west corner of the tile is raised

    22

	SLOPE_S        = 0x02,                                  ///< the south corner of the tile is raised

    23

	SLOPE_E        = 0x04,                                  ///< the east corner of the tile is raised

    24

	SLOPE_N        = 0x08,                                  ///< the north corner of the tile is raised

    25

	SLOPE_STEEP    = 0x10,                                  ///< indicates the slope is steep

    26

	SLOPE_NW       = SLOPE_N | SLOPE_W,                     ///< north and west corner are raised

    27

	SLOPE_SW       = SLOPE_S | SLOPE_W,                     ///< south and west corner are raised

    28

	SLOPE_SE       = SLOPE_S | SLOPE_E,                     ///< south and east corner are raised

    29

	SLOPE_NE       = SLOPE_N | SLOPE_E,                     ///< north and east corner are raised

    30

	SLOPE_EW       = SLOPE_E | SLOPE_W,                     ///< east and west corner are raised

    31

	SLOPE_NS       = SLOPE_N | SLOPE_S,                     ///< north and south corner are raised

    32

	SLOPE_ELEVATED = SLOPE_N | SLOPE_E | SLOPE_S | SLOPE_W, ///< all corner are raised, similar to SLOPE_FLAT

    33

	SLOPE_NWS      = SLOPE_N | SLOPE_W | SLOPE_S,           ///< north, west and south corner are raised

    34

	SLOPE_WSE      = SLOPE_W | SLOPE_S | SLOPE_E,           ///< west, south and east corner are raised

    35

	SLOPE_SEN      = SLOPE_S | SLOPE_E | SLOPE_N,           ///< south, east and north corner are raised

    36

	SLOPE_ENW      = SLOPE_E | SLOPE_N | SLOPE_W,           ///< east, north and west corner are raised

    37

	SLOPE_STEEP_W  = SLOPE_STEEP | SLOPE_NWS,               ///< a steep slope falling to east (from west)

    38

	SLOPE_STEEP_S  = SLOPE_STEEP | SLOPE_WSE,               ///< a steep slope falling to north (from south)

    39

	SLOPE_STEEP_E  = SLOPE_STEEP | SLOPE_SEN,               ///< a steep slope falling to west (from east)

    40

	SLOPE_STEEP_N  = SLOPE_STEEP | SLOPE_ENW                ///< a steep slope falling to south (from north)

    41

};

    42

    43

/**

    44

 * Enumeration of tile corners

    45

 */

    46

enum Corner {

    47

	CORNER_W = 0,

    48

	CORNER_S = 1,

    49

	CORNER_E = 2,

    50

	CORNER_N = 3,

    51

	CORNER_END

    52

};

    53

    54

/**

    55

 * Rangecheck for Corner enumeration.

    56

 *

    57

 * @param corner A #Corner.

    58

 * @return true iff corner is in a valid range.

    59

 */

    60

static inline bool IsValidCorner(Corner corner)

    61

{

    62

	return IS_INT_INSIDE(corner, 0, CORNER_END);

    63

}

    64

    65

/**

    66

 * Checks if a slope is steep.

    67

 *

    68

 * @param s The given #Slope.

    69

 * @return True if the slope is steep, else false.

    70

 */

    71

static inline bool IsSteepSlope(Slope s)

    72

{

    73

	return (s & SLOPE_STEEP) != 0;

    74

}

    75

    76

/**

    77

 * Return the complement of a slope.

    78

 *

    79

 * This method returns the complement of a slope. The complement of a

    80

 * slope is a slope with raised corner which aren't raised in the given

    81

 * slope.

    82

 *

    83

 * @pre The slope must not be steep.

    84

 * @param s The #Slope to get the complement.

    85

 * @return a complement Slope of the given slope.

    86

 */

    87

static inline Slope ComplementSlope(Slope s)

    88

{

    89

	assert(!IsSteepSlope(s));

    90

	return (Slope)(0xF ^ s);

    91

}

    92

    93

/**

    94

 * Tests if a slope has a highest corner (i.e. one corner raised or a steep slope).

    95

 *

    96

 * @param s The #Slope.

    97

 * @return  true iff the slope has a highest corner.

    98

 */

    99

static inline bool HasSlopeHighestCorner(Slope s)

   100

{

   101

	return IsSteepSlope(s) || (s == SLOPE_W) || (s == SLOPE_S) || (s == SLOPE_E) || (s == SLOPE_N);

   102

}

   103

   104

/**

   105

 * Returns the highest corner of a slope (one corner raised or a steep slope).

   106

 *

   107

 * @pre      The slope must be a slope with one corner raised or a steep slope.

   108

 * @param s  The #Slope.

   109

 * @return   Highest corner.

   110

 */

   111

static inline Corner GetHighestSlopeCorner(Slope s)

   112

{

   113

	switch (s) {

   114

		case SLOPE_W:

   115

		case SLOPE_STEEP_W: return CORNER_W;

   116

		case SLOPE_S:

   117

		case SLOPE_STEEP_S: return CORNER_S;

   118

		case SLOPE_E:

   119

		case SLOPE_STEEP_E: return CORNER_E;

   120

		case SLOPE_N:

   121

		case SLOPE_STEEP_N: return CORNER_N;

   122

		default: NOT_REACHED();

   123

	}

   124

}

   125

   126

/**

   127

 * Returns the height of the highest corner of a slope relative to TileZ (= minimal height)

   128

 *

   129

 * @param s The #Slope.

   130

 * @return Relative height of highest corner.

   131

 */

   132

static inline uint GetSlopeMaxZ(Slope s)

   133

{

   134

	if (s == SLOPE_FLAT) return 0;

   135

	if (IsSteepSlope(s)) return 2 * TILE_HEIGHT;

   136

	return TILE_HEIGHT;

   137

}

   138

   139

/**

   140

 * Returns the opposite corner.

   141

 *

   142

 * @param corner A #Corner.

   143

 * @return The opposite corner to "corner".

   144

 */

   145

static inline Corner OppositeCorner(Corner corner)

   146

{

   147

	return (Corner)(corner ^ 2);

   148

}

   149

   150

/**

   151

 * Returns the slope with a specific corner raised.

   152

 *

   153

 * @param corner The #Corner.

   154

 * @return The #Slope with corner "corner" raised.

   155

 */

   156

static inline Slope SlopeWithOneCornerRaised(Corner corner)

   157

{

   158

	assert(IsValidCorner(corner));

   159

	return (Slope)(1 << corner);

   160

}

   161

   162

/**

   163

 * Returns the slope with all except one corner raised.

   164

 *

   165

 * @param corner The #Corner.

   166

 * @return The #Slope with all corners but "corner" raised.

   167

 */

   168

static inline Slope SlopeWithThreeCornersRaised(Corner corner)

   169

{

   170

	return ComplementSlope(SlopeWithOneCornerRaised(corner));

   171

}

   172

   173

   174

/**

   175

 * Enumeration for Foundations.

   176

 */

   177

enum Foundation {

   178

	FOUNDATION_NONE,             ///< The tile has no foundation, the slope remains unchanged.

   179

	FOUNDATION_LEVELED,          ///< The tile is leveled up to a flat slope.

   180

	FOUNDATION_INCLINED_X,       ///< The tile has an along X-axis inclined foundation.

   181

	FOUNDATION_INCLINED_Y,       ///< The tile has an along Y-axis inclined foundation.

   182

	FOUNDATION_STEEP_LOWER,      ///< The tile has a steep slope. The lowerst corner is raised by a foundation to allow building railroad on the lower halftile.

   183

	FOUNDATION_STEEP_HIGHER,     ///< The tile has a steep slope. Three corners are raised by a foundation to allow building railroad on the higher halftile.

   184

   185

	FOUNDATION_INVALID = 0xFF    ///< Used inside "rail_cmd.cpp" to indicate invalid slope/track combination.

   186

};

   187

   188

/**

   189

 * Tests for FOUNDATION_NONE.

   190

 *

   191

 * @param f  Maybe a #Foundation.

   192

 * @return   true iff f is a foundation.

   193

 */

   194

static inline bool IsFoundation(Foundation f)

   195

{

   196

	return f != FOUNDATION_NONE;

   197

}

   198

   199

/**

   200

 * Tests if the foundation is a leveled foundation.

   201

 *

   202

 * @param f  The #Foundation.

   203

 * @return   true iff f is a leveled foundation.

   204

 */

   205

static inline bool IsLeveledFoundation(Foundation f)

   206

{

   207

	return f == FOUNDATION_LEVELED;

   208

}

   209

   210

/**

   211

 * Tests if the foundation is an inclined foundation.

   212

 *

   213

 * @param f  The #Foundation.

   214

 * @return   true iff f is an inclined foundation.

   215

 */

   216

static inline bool IsInclinedFoundation(Foundation f)

   217

{

   218

	return (f == FOUNDATION_INCLINED_X) || (f == FOUNDATION_INCLINED_Y);

   219

}

   220

   221

/**

   222

 * Returns the foundation needed to flatten a slope.

   223

 * The returned foundation is either FOUNDATION_NONE if the tile was already flat, or FOUNDATION_LEVELED.

   224

 *

   225

 * @pre      The slope must not be steep.

   226

 * @param s  The current #Slope.

   227

 * @return   The needed #Foundation.

   228

 */

   229

static inline Foundation FlatteningFoundation(Slope s)

   230

{

   231

	assert(!IsSteepSlope(s));

   232

	return (s == SLOPE_FLAT ? FOUNDATION_NONE : FOUNDATION_LEVELED);

   233

}

   234

   235

/**

   236

 * Returns the along a specific axis inclined foundation.

   237

 *

   238

 * @param axis  The #Axis.

   239

 * @return      The needed #Foundation.

   240

 */

   241

static inline Foundation InclinedFoundation(Axis axis)

   242

{

   243

	return (axis == AXIS_X ? FOUNDATION_INCLINED_X : FOUNDATION_INCLINED_Y);

   244

}

   245

   246

#endif /* SLOPE_H */