|
@@ -6,18 +6,37 @@
|
|
|
*/
|
|
|
|
|
|
#ifndef SLOPE_H
|
|
|
#define SLOPE_H
|
|
|
|
|
|
/**
|
|
|
* Enumeration of tile corners
|
|
|
*/
|
|
|
enum Corner {
|
|
|
CORNER_W = 0,
|
|
|
CORNER_S = 1,
|
|
|
CORNER_E = 2,
|
|
|
CORNER_N = 3,
|
|
|
CORNER_END
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Enumeration for the slope-type.
|
|
|
*
|
|
|
* This enumeration use the chars N,E,S,W corresponding the
|
|
|
* direction north, east, south and west. The top corner of a tile
|
|
|
* is the north-part of the tile. The whole slope is encoded with
|
|
|
* 5 bits, 4 bits for each corner and 1 bit for a steep-flag.
|
|
|
*
|
|
|
* For halftile slopes an extra 3 bits are used to represent this
|
|
|
* properly; 1 bit for a halftile-flag and 2 bits to encode which
|
|
|
* extra side (corner) is leveled when the slope of the first 5
|
|
|
* bits is applied. This means that there can only be one leveled
|
|
|
* slope for steep slopes, which is logical because two leveled
|
|
|
* slopes would mean that it is not a steep slope as halftile
|
|
|
* slopes only span one height level.
|
|
|
*/
|
|
|
enum Slope {
|
|
|
SLOPE_FLAT = 0x00, ///< a flat tile
|
|
|
SLOPE_W = 0x01, ///< the west corner of the tile is raised
|
|
|
SLOPE_S = 0x02, ///< the south corner of the tile is raised
|
|
|
SLOPE_E = 0x04, ///< the east corner of the tile is raised
|
|
@@ -34,24 +53,20 @@ enum Slope {
|
|
|
SLOPE_WSE = SLOPE_W | SLOPE_S | SLOPE_E, ///< west, south and east corner are raised
|
|
|
SLOPE_SEN = SLOPE_S | SLOPE_E | SLOPE_N, ///< south, east and north corner are raised
|
|
|
SLOPE_ENW = SLOPE_E | SLOPE_N | SLOPE_W, ///< east, north and west corner are raised
|
|
|
SLOPE_STEEP_W = SLOPE_STEEP | SLOPE_NWS, ///< a steep slope falling to east (from west)
|
|
|
SLOPE_STEEP_S = SLOPE_STEEP | SLOPE_WSE, ///< a steep slope falling to north (from south)
|
|
|
SLOPE_STEEP_E = SLOPE_STEEP | SLOPE_SEN, ///< a steep slope falling to west (from east)
|
|
|
SLOPE_STEEP_N = SLOPE_STEEP | SLOPE_ENW ///< a steep slope falling to south (from north)
|
|
|
};
|
|
|
SLOPE_STEEP_N = SLOPE_STEEP | SLOPE_ENW, ///< a steep slope falling to south (from north)
|
|
|
|
|
|
/**
|
|
|
* Enumeration of tile corners
|
|
|
*/
|
|
|
enum Corner {
|
|
|
CORNER_W = 0,
|
|
|
CORNER_S = 1,
|
|
|
CORNER_E = 2,
|
|
|
CORNER_N = 3,
|
|
|
CORNER_END
|
|
|
SLOPE_HALFTILE = 0x20, ///< one halftile is leveled (non continuous slope)
|
|
|
SLOPE_HALFTILE_MASK = 0xE0, ///< three bits used for halftile slopes
|
|
|
SLOPE_HALFTILE_W = SLOPE_HALFTILE | (CORNER_W << 6), ///< the west halftile is leveled (non continuous slope)
|
|
|
SLOPE_HALFTILE_S = SLOPE_HALFTILE | (CORNER_S << 6), ///< the south halftile is leveled (non continuous slope)
|
|
|
SLOPE_HALFTILE_E = SLOPE_HALFTILE | (CORNER_E << 6), ///< the east halftile is leveled (non continuous slope)
|
|
|
SLOPE_HALFTILE_N = SLOPE_HALFTILE | (CORNER_N << 6), ///< the north halftile is leveled (non continuous slope)
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Rangecheck for Corner enumeration.
|
|
|
*
|
|
|
* @param corner A #Corner.
|
|
@@ -71,49 +86,63 @@ static inline bool IsValidCorner(Corner
|
|
|
static inline bool IsSteepSlope(Slope s)
|
|
|
{
|
|
|
return (s & SLOPE_STEEP) != 0;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Checks for non-continuous slope on halftile foundations.
|
|
|
*
|
|
|
* @param s The given #Slope.
|
|
|
* @return True if the slope is non-continuous, else false.
|
|
|
*/
|
|
|
static inline bool IsHalftileSlope(Slope s)
|
|
|
{
|
|
|
return (s & SLOPE_HALFTILE) != 0;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Return the complement of a slope.
|
|
|
*
|
|
|
* This method returns the complement of a slope. The complement of a
|
|
|
* slope is a slope with raised corner which aren't raised in the given
|
|
|
* slope.
|
|
|
*
|
|
|
* @pre The slope must not be steep.
|
|
|
* @pre The slope must neither be steep nor a halftile slope.
|
|
|
* @param s The #Slope to get the complement.
|
|
|
* @return a complement Slope of the given slope.
|
|
|
*/
|
|
|
static inline Slope ComplementSlope(Slope s)
|
|
|
{
|
|
|
assert(!IsSteepSlope(s));
|
|
|
assert(!IsSteepSlope(s) && !IsHalftileSlope(s));
|
|
|
return (Slope)(0xF ^ s);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Tests if a slope has a highest corner (i.e. one corner raised or a steep slope).
|
|
|
*
|
|
|
* Note: A halftile slope is ignored.
|
|
|
*
|
|
|
* @param s The #Slope.
|
|
|
* @return true iff the slope has a highest corner.
|
|
|
*/
|
|
|
static inline bool HasSlopeHighestCorner(Slope s)
|
|
|
{
|
|
|
s = (Slope)(s & ~SLOPE_HALFTILE_MASK);
|
|
|
return IsSteepSlope(s) || (s == SLOPE_W) || (s == SLOPE_S) || (s == SLOPE_E) || (s == SLOPE_N);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Returns the highest corner of a slope (one corner raised or a steep slope).
|
|
|
*
|
|
|
* @pre The slope must be a slope with one corner raised or a steep slope.
|
|
|
* @pre The slope must be a slope with one corner raised or a steep slope. A halftile slope is ignored.
|
|
|
* @param s The #Slope.
|
|
|
* @return Highest corner.
|
|
|
*/
|
|
|
static inline Corner GetHighestSlopeCorner(Slope s)
|
|
|
{
|
|
|
switch (s) {
|
|
|
switch (s & ~SLOPE_HALFTILE_MASK) {
|
|
|
case SLOPE_W:
|
|
|
case SLOPE_STEEP_W: return CORNER_W;
|
|
|
case SLOPE_S:
|
|
|
case SLOPE_STEEP_S: return CORNER_S;
|
|
|
case SLOPE_E:
|
|
|
case SLOPE_STEEP_E: return CORNER_E;
|
|
@@ -121,12 +150,25 @@ static inline Corner GetHighestSlopeCorn
|
|
|
case SLOPE_STEEP_N: return CORNER_N;
|
|
|
default: NOT_REACHED();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Returns the leveled halftile of a halftile slope.
|
|
|
*
|
|
|
* @pre The slope must be a halftile slope.
|
|
|
* @param s The #Slope.
|
|
|
* @return The corner of the leveled halftile.
|
|
|
*/
|
|
|
static inline Corner GetHalftileSlopeCorner(Slope s)
|
|
|
{
|
|
|
assert(IsHalftileSlope(s));
|
|
|
return (Corner)((s >> 6) & 3);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Returns the height of the highest corner of a slope relative to TileZ (= minimal height)
|
|
|
*
|
|
|
* @param s The #Slope.
|
|
|
* @return Relative height of highest corner.
|
|
|
*/
|
|
|
static inline uint GetSlopeMaxZ(Slope s)
|
|
@@ -167,12 +209,25 @@ static inline Slope SlopeWithOneCornerRa
|
|
|
*/
|
|
|
static inline Slope SlopeWithThreeCornersRaised(Corner corner)
|
|
|
{
|
|
|
return ComplementSlope(SlopeWithOneCornerRaised(corner));
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Adds a halftile slope to a slope.
|
|
|
*
|
|
|
* @param s #Slope without a halftile slope.
|
|
|
* @param corner The #Corner of the halftile.
|
|
|
* @return The #Slope s with the halftile slope added.
|
|
|
*/
|
|
|
static inline Slope HalftileSlope(Slope s, Corner corner)
|
|
|
{
|
|
|
assert(IsValidCorner(corner));
|
|
|
return (Slope)(s | SLOPE_HALFTILE | (corner << 6));
|
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
|
|
* Enumeration for Foundations.
|
|
|
*/
|
|
|
enum Foundation {
|
|
|
FOUNDATION_NONE, ///< The tile has no foundation, the slope remains unchanged.
|