src/slope_type.h

   1 /* $Id: slope_type.h 23595 2011-12-19 17:48:04Z rubidium $ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   6  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   8  */
   9
  10 /**
  11  * @file slope_type.h Definitions of a slope.
  12  * This file defines the enumeration and helper functions for handling
  13  * the slope info of a tile.
  14  */
  15
  16 #ifndef SLOPE_TYPE_H
  17 #define SLOPE_TYPE_H
  18
  19 #include "core/enum_type.hpp"
  20
  21 /**
  22  * Enumeration of tile corners
  23  */
  24 enum Corner {
  25         CORNER_W = 0,
  26         CORNER_S = 1,
  27         CORNER_E = 2,
  28         CORNER_N = 3,
  29         CORNER_END,
  30         CORNER_INVALID = 0xFF
  31 };
  32
  33
  34 /**
  35  * Enumeration for the slope-type.
  36  *
  37  * This enumeration use the chars N,E,S,W corresponding the
  38  * direction north, east, south and west. The top corner of a tile
  39  * is the north-part of the tile. The whole slope is encoded with
  40  * 5 bits, 4 bits for each corner and 1 bit for a steep-flag.
  41  *
  42  * For halftile slopes an extra 3 bits are used to represent this
  43  * properly; 1 bit for a halftile-flag and 2 bits to encode which
  44  * extra side (corner) is leveled when the slope of the first 5
  45  * bits is applied. This means that there can only be one leveled
  46  * slope for steep slopes, which is logical because two leveled
  47  * slopes would mean that it is not a steep slope as halftile
  48  * slopes only span one height level.
  49  */
  50 enum Slope {
  51         SLOPE_FLAT     = 0x00,                                  ///< a flat tile
  52         SLOPE_W        = 0x01,                                  ///< the west corner of the tile is raised
  53         SLOPE_S        = 0x02,                                  ///< the south corner of the tile is raised
  54         SLOPE_E        = 0x04,                                  ///< the east corner of the tile is raised
  55         SLOPE_N        = 0x08,                                  ///< the north corner of the tile is raised
  56         SLOPE_STEEP    = 0x10,                                  ///< indicates the slope is steep
  57         SLOPE_NW       = SLOPE_N | SLOPE_W,                     ///< north and west corner are raised
  58         SLOPE_SW       = SLOPE_S | SLOPE_W,                     ///< south and west corner are raised
  59         SLOPE_SE       = SLOPE_S | SLOPE_E,                     ///< south and east corner are raised
  60         SLOPE_NE       = SLOPE_N | SLOPE_E,                     ///< north and east corner are raised
  61         SLOPE_EW       = SLOPE_E | SLOPE_W,                     ///< east and west corner are raised
  62         SLOPE_NS       = SLOPE_N | SLOPE_S,                     ///< north and south corner are raised
  63         SLOPE_ELEVATED = SLOPE_N | SLOPE_E | SLOPE_S | SLOPE_W, ///< bit mask containing all 'simple' slopes
  64         SLOPE_NWS      = SLOPE_N | SLOPE_W | SLOPE_S,           ///< north, west and south corner are raised
  65         SLOPE_WSE      = SLOPE_W | SLOPE_S | SLOPE_E,           ///< west, south and east corner are raised
  66         SLOPE_SEN      = SLOPE_S | SLOPE_E | SLOPE_N,           ///< south, east and north corner are raised
  67         SLOPE_ENW      = SLOPE_E | SLOPE_N | SLOPE_W,           ///< east, north and west corner are raised
  68         SLOPE_STEEP_W  = SLOPE_STEEP | SLOPE_NWS,               ///< a steep slope falling to east (from west)
  69         SLOPE_STEEP_S  = SLOPE_STEEP | SLOPE_WSE,               ///< a steep slope falling to north (from south)
  70         SLOPE_STEEP_E  = SLOPE_STEEP | SLOPE_SEN,               ///< a steep slope falling to west (from east)
  71         SLOPE_STEEP_N  = SLOPE_STEEP | SLOPE_ENW,               ///< a steep slope falling to south (from north)
  72
  73         SLOPE_HALFTILE = 0x20,                                  ///< one halftile is leveled (non continuous slope)
  74         SLOPE_HALFTILE_MASK = 0xE0,                             ///< three bits used for halftile slopes
  75         SLOPE_HALFTILE_W = SLOPE_HALFTILE | (CORNER_W << 6),    ///< the west halftile is leveled (non continuous slope)
  76         SLOPE_HALFTILE_S = SLOPE_HALFTILE | (CORNER_S << 6),    ///< the south halftile is leveled (non continuous slope)
  77         SLOPE_HALFTILE_E = SLOPE_HALFTILE | (CORNER_E << 6),    ///< the east halftile is leveled (non continuous slope)
  78         SLOPE_HALFTILE_N = SLOPE_HALFTILE | (CORNER_N << 6),    ///< the north halftile is leveled (non continuous slope)
  79 };
  80 DECLARE_ENUM_AS_BIT_SET(Slope)
  81
  82 /**
  83  * Helper for creating a bitset of slopes.
  84  * @param x The slope to convert into a bitset.
  85  */
  86 #define M(x) (1 << (x))
  87 /** Constant bitset with safe slopes for building a level crossing. */
  88 static const uint32 VALID_LEVEL_CROSSING_SLOPES = M(SLOPE_SEN) | M(SLOPE_ENW) | M(SLOPE_NWS) | M(SLOPE_NS) | M(SLOPE_WSE) | M(SLOPE_EW) | M(SLOPE_FLAT);
  89 #undef M
  90
  91
  92 /**
  93  * Enumeration for Foundations.
  94  */
  95 enum Foundation {
  96         FOUNDATION_NONE,             ///< The tile has no foundation, the slope remains unchanged.
  97         FOUNDATION_LEVELED,          ///< The tile is leveled up to a flat slope.
  98         FOUNDATION_INCLINED_X,       ///< The tile has an along X-axis inclined foundation.
  99         FOUNDATION_INCLINED_Y,       ///< The tile has an along Y-axis inclined foundation.
 100         FOUNDATION_STEEP_LOWER,      ///< The tile has a steep slope. The lowest corner is raised by a foundation to allow building railroad on the lower halftile.
 101
 102         /* Halftile foundations */
 103         FOUNDATION_STEEP_BOTH,       ///< The tile has a steep slope. The lowest corner is raised by a foundation and the upper halftile is leveled.
 104         FOUNDATION_HALFTILE_W,       ///< Level west halftile non-continuously.
 105         FOUNDATION_HALFTILE_S,       ///< Level south halftile non-continuously.
 106         FOUNDATION_HALFTILE_E,       ///< Level east halftile non-continuously.
 107         FOUNDATION_HALFTILE_N,       ///< Level north halftile non-continuously.
 108
 109         /* Special anti-zig-zag foundations for single horizontal/vertical track */
 110         FOUNDATION_RAIL_W,           ///< Foundation for TRACK_BIT_LEFT, but not a leveled foundation.
 111         FOUNDATION_RAIL_S,           ///< Foundation for TRACK_BIT_LOWER, but not a leveled foundation.
 112         FOUNDATION_RAIL_E,           ///< Foundation for TRACK_BIT_RIGHT, but not a leveled foundation.
 113         FOUNDATION_RAIL_N,           ///< Foundation for TRACK_BIT_UPPER, but not a leveled foundation.
 114
 115         FOUNDATION_INVALID = 0xFF,   ///< Used inside "rail_cmd.cpp" to indicate invalid slope/track combination.
 116 };
 117
 118 #endif /* SLOPE_TYPE_H */