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

 * Checks if a slope is steep.

    45

 *

    46

 * @param s The given #Slope.

    47

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

    48

 */

    49

static inline bool IsSteepSlope(Slope s)

    50

{

    51

	return (s & SLOPE_STEEP) != 0;

    52

}

    53

    54

/**

    55

 * Return the complement of a slope.

    56

 *

    57

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

    58

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

    59

 * slope.

    60

 *

    61

 * @pre The slope must not be steep.

    62

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

    63

 * @return a complement Slope of the given slope.

    64

 */

    65

static inline Slope ComplementSlope(Slope s)

    66

{

    67

	assert(!IsSteepSlope(s));

    68

	return (Slope)(0xF ^ s);

    69

}

    70

    71

/**

    72

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

    73

 *

    74

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

    75

 * @param s  The #Slope.

    76

 * @return   Number of the highest corner. (0 west, 1 south, 2 east, 3 north)

    77

 */

    78

static inline byte GetHighestSlopeCorner(Slope s)

    79

{

    80

	switch (s) {

    81

		case SLOPE_W:

    82

		case SLOPE_STEEP_W: return 0;

    83

		case SLOPE_S:

    84

		case SLOPE_STEEP_S: return 1;

    85

		case SLOPE_E:

    86

		case SLOPE_STEEP_E: return 2;

    87

		case SLOPE_N:

    88

		case SLOPE_STEEP_N: return 3;

    89

		default: NOT_REACHED();

    90

	}

    91

}

    92

    93

/**

    94

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

    95

 *

    96

 * @param s The #Slope.

    97

 * @return Relative height of highest corner.

    98

 */

    99

static inline uint GetSlopeMaxZ(Slope s)

   100

{

   101

	if (s == SLOPE_FLAT) return 0;

   102

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

   103

	return TILE_HEIGHT;

   104

}

   105

   106

   107

/**

   108

 * Enumeration for Foundations.

   109

 */

   110

enum Foundation {

   111

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

   112

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

   113

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

   114

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

   115

	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.

   116

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

   117

};

   118

   119

/**

   120

 * Tests for FOUNDATION_NONE.

   121

 *

   122

 * @param f  Maybe a #Foundation.

   123

 * @return   true iff f is a foundation.

   124

 */

   125

static inline bool IsFoundation(Foundation f)

   126

{

   127

	return f != FOUNDATION_NONE;

   128

}

   129

   130

/**

   131

 * Tests if the foundation is a leveled foundation.

   132

 *

   133

 * @param f  The #Foundation.

   134

 * @return   true iff f is a leveled foundation.

   135

 */

   136

static inline bool IsLeveledFoundation(Foundation f)

   137

{

   138

	return f == FOUNDATION_LEVELED;

   139

}

   140

   141

/**

   142

 * Tests if the foundation is an inclined foundation.

   143

 *

   144

 * @param f  The #Foundation.

   145

 * @return   true iff f is an inclined foundation.

   146

 */

   147

static inline bool IsInclinedFoundation(Foundation f)

   148

{

   149

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

   150

}

   151

   152

/**

   153

 * Returns the foundation needed to flatten a slope.

   154

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

   155

 *

   156

 * @pre      The slope must not be steep.

   157

 * @param s  The current #Slope.

   158

 * @return   The needed #Foundation.

   159

 */

   160

static inline Foundation FlatteningFoundation(Slope s)

   161

{

   162

	assert(!IsSteepSlope(s));

   163

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

   164

}

   165

   166

/**

   167

 * Returns the along a specific axis inclined foundation.

   168

 *

   169

 * @param axis  The #Axis.

   170

 * @return      The needed #Foundation.

   171

 */

   172

static inline Foundation InclinedFoundation(Axis axis)

   173

{

   174

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

   175

}

   176

   177

#endif /* SLOPE_H */