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 of tile corners

    13

 */

    14

enum Corner {

    15

	CORNER_W = 0,

    16

	CORNER_S = 1,

    17

	CORNER_E = 2,

    18

	CORNER_N = 3,

    19

	CORNER_END,

    20

	CORNER_INVALID = 0xFF

    21

};

    22

    23

/**

    24

 * Enumeration for the slope-type.

    25

 *

    26

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

    27

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

    28

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

    29

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

    30

 *

    31

 * For halftile slopes an extra 3 bits are used to represent this

    32

 * properly; 1 bit for a halftile-flag and 2 bits to encode which

    33

 * extra side (corner) is leveled when the slope of the first 5

    34

 * bits is applied. This means that there can only be one leveled

    35

 * slope for steep slopes, which is logical because two leveled

    36

 * slopes would mean that it is not a steep slope as halftile

    37

 * slopes only span one height level.

    38

 */

    39

enum Slope {

    40

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

    41

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

    42

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

    43

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

    44

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

    45

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

    46

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

    47

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

    48

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

    49

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

    50

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

    51

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

    52

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

    53

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

    54

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

    55

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

    56

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

    57

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

    58

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

    59

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

    60

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

    61

    62

	SLOPE_HALFTILE = 0x20,                                  ///< one halftile is leveled (non continuous slope)

    63

	SLOPE_HALFTILE_MASK = 0xE0,                             ///< three bits used for halftile slopes

    64

	SLOPE_HALFTILE_W = SLOPE_HALFTILE | (CORNER_W << 6),    ///< the west halftile is leveled (non continuous slope)

    65

	SLOPE_HALFTILE_S = SLOPE_HALFTILE | (CORNER_S << 6),    ///< the south halftile is leveled (non continuous slope)

    66

	SLOPE_HALFTILE_E = SLOPE_HALFTILE | (CORNER_E << 6),    ///< the east halftile is leveled (non continuous slope)

    67

	SLOPE_HALFTILE_N = SLOPE_HALFTILE | (CORNER_N << 6),    ///< the north halftile is leveled (non continuous slope)

    68

};

    69

    70

/**

    71

 * Rangecheck for Corner enumeration.

    72

 *

    73

 * @param corner A #Corner.

    74

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

    75

 */

    76

static inline bool IsValidCorner(Corner corner)

    77

{

    79

}

    80

    81

/**

    82

 * Checks if a slope is steep.

    83

 *

    84

 * @param s The given #Slope.

    85

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

    86

 */

    87

static inline bool IsSteepSlope(Slope s)

    88

{

    89

	return (s & SLOPE_STEEP) != 0;

    90

}

    91

    92

/**

    93

 * Checks for non-continuous slope on halftile foundations.

    94

 *

    95

 * @param s The given #Slope.

    96

 * @return True if the slope is non-continuous, else false.

    97

 */

    98

static inline bool IsHalftileSlope(Slope s)

    99

{

   100

	return (s & SLOPE_HALFTILE) != 0;

   101

}

   102

   103

/**

   104

 * Return the complement of a slope.

   105

 *

   106

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

   107

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

   108

 * slope.

   109

 *

   110

 * @pre The slope must neither be steep nor a halftile slope.

   111

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

   112

 * @return a complement Slope of the given slope.

   113

 */

   114

static inline Slope ComplementSlope(Slope s)

   115

{

   116

	assert(!IsSteepSlope(s) && !IsHalftileSlope(s));

   117

	return (Slope)(0xF ^ s);

   118

}

   119

   120

/**

   121

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

   122

 *

   123

 * Note: A halftile slope is ignored.

   124

 *

   125

 * @param s The #Slope.

   126

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

   127

 */

   128

static inline bool HasSlopeHighestCorner(Slope s)

   129

{

   130

	s = (Slope)(s & ~SLOPE_HALFTILE_MASK);

   131

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

   132

}

   133

   134

/**

   135

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

   136

 *

   137

 * @pre      The slope must be a slope with one corner raised or a steep slope. A halftile slope is ignored.

   138

 * @param s  The #Slope.

   139

 * @return   Highest corner.

   140

 */

   141

static inline Corner GetHighestSlopeCorner(Slope s)

   142

{

   143

	switch (s & ~SLOPE_HALFTILE_MASK) {

   144

		case SLOPE_W:

   145

		case SLOPE_STEEP_W: return CORNER_W;

   146

		case SLOPE_S:

   147

		case SLOPE_STEEP_S: return CORNER_S;

   148

		case SLOPE_E:

   149

		case SLOPE_STEEP_E: return CORNER_E;

   150

		case SLOPE_N:

   151

		case SLOPE_STEEP_N: return CORNER_N;

   152

		default: NOT_REACHED();

   153

	}

   154

}

   155

   156

/**

   157

 * Returns the leveled halftile of a halftile slope.

   158

 *

   159

 * @pre     The slope must be a halftile slope.

   160

 * @param s The #Slope.

   161

 * @return  The corner of the leveled halftile.

   162

 */

   163

static inline Corner GetHalftileSlopeCorner(Slope s)

   164

{

   165

	assert(IsHalftileSlope(s));

   166

	return (Corner)((s >> 6) & 3);

   167

}

   168

   169

/**

   170

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

   171

 *

   172

 * @param s The #Slope.

   173

 * @return Relative height of highest corner.

   174

 */

   175

static inline uint GetSlopeMaxZ(Slope s)

   176

{

   177

	if (s == SLOPE_FLAT) return 0;

   178

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

   179

	return TILE_HEIGHT;

   180

}

   181

   182

/**

   183

 * Returns the opposite corner.

   184

 *

   185

 * @param corner A #Corner.

   186

 * @return The opposite corner to "corner".

   187

 */

   188

static inline Corner OppositeCorner(Corner corner)

   189

{

   190

	return (Corner)(corner ^ 2);

   191

}

   192

   193

/**

   194

 * Returns the slope with a specific corner raised.

   195

 *

   196

 * @param corner The #Corner.

   197

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

   198

 */

   199

static inline Slope SlopeWithOneCornerRaised(Corner corner)

   200

{

   201

	assert(IsValidCorner(corner));

   202

	return (Slope)(1 << corner);

   203

}

   204

   205

/**

   206

 * Returns the slope with all except one corner raised.

   207

 *

   208

 * @param corner The #Corner.

   209

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

   210

 */

   211

static inline Slope SlopeWithThreeCornersRaised(Corner corner)

   212

{

   213

	return ComplementSlope(SlopeWithOneCornerRaised(corner));

   214

}

   215

   216

/**

   217

 * Adds a halftile slope to a slope.

   218

 *

   219

 * @param s #Slope without a halftile slope.

   220

 * @param corner The #Corner of the halftile.

   221

 * @return The #Slope s with the halftile slope added.

   222

 */

   223

static inline Slope HalftileSlope(Slope s, Corner corner)

   224

{

   225

	assert(IsValidCorner(corner));

   226

	return (Slope)(s | SLOPE_HALFTILE | (corner << 6));

   227

}

   228

   229

   230

/**

   231

 * Enumeration for Foundations.

   232

 */

   233

enum Foundation {

   234

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

   235

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

   236

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

   237

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

   238

	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.

   239

   240

/* Halftile foundations */

   241

	FOUNDATION_STEEP_BOTH,       ///< The tile has a steep slope. The lowest corner is raised by a foundation and the upper halftile is leveled.

   242

	FOUNDATION_HALFTILE_W,       ///< Level west halftile non-continuously.

   243

	FOUNDATION_HALFTILE_S,       ///< Level south halftile non-continuously.

   244

	FOUNDATION_HALFTILE_E,       ///< Level east halftile non-continuously.

   245

	FOUNDATION_HALFTILE_N,       ///< Level north halftile non-continuously.

   246

   247

/* Special anti-zig-zag foundations for single horizontal/vertical track */

   248

	FOUNDATION_RAIL_W,           ///< Foundation for TRACK_BIT_LEFT, but not a leveled foundation.

   249

	FOUNDATION_RAIL_S,           ///< Foundation for TRACK_BIT_LOWER, but not a leveled foundation.

   250

	FOUNDATION_RAIL_E,           ///< Foundation for TRACK_BIT_RIGHT, but not a leveled foundation.

   251

	FOUNDATION_RAIL_N,           ///< Foundation for TRACK_BIT_UPPER, but not a leveled foundation.

   252

   253

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

   254

};

   255

   256

/**

   257

 * Tests for FOUNDATION_NONE.

   258

 *

   259

 * @param f  Maybe a #Foundation.

   260

 * @return   true iff f is a foundation.

   261

 */

   262

static inline bool IsFoundation(Foundation f)

   263

{

   264

	return f != FOUNDATION_NONE;

   265

}

   266

   267

/**

   268

 * Tests if the foundation is a leveled foundation.

   269

 *

   270

 * @param f  The #Foundation.

   271

 * @return   true iff f is a leveled foundation.

   272

 */

   273

static inline bool IsLeveledFoundation(Foundation f)

   274

{

   275

	return f == FOUNDATION_LEVELED;

   276

}

   277

   278

/**

   279

 * Tests if the foundation is an inclined foundation.

   280

 *

   281

 * @param f  The #Foundation.

   282

 * @return   true iff f is an inclined foundation.

   283

 */

   284

static inline bool IsInclinedFoundation(Foundation f)

   285

{

   286

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

   287

}

   288

   289

/**

   290

 * Tests if a foundation is a non-continuous foundation, i.e. halftile-foundation or FOUNDATION_STEEP_BOTH.

   291

 *

   292

 * @param f  The #Foundation.

   293

 * @return   true iff f is a non-continuous foundation

   294

 */

   295

static inline bool IsNonContinuousFoundation(Foundation f)

   296

{

   298

}

   299

   300

/**

   301

 * Returns the halftile corner of a halftile-foundation

   302

 *

   303

 * @pre f != FOUNDATION_STEEP_BOTH

   304

 *

   305

 * @param f  The #Foundation.

   306

 * @return   The #Corner with track.

   307

 */

   308

static inline Corner GetHalftileFoundationCorner(Foundation f)

   309

{

   311

	return (Corner)(f - FOUNDATION_HALFTILE_W);

   312

}

   313

   314

/**

   315

 * Tests if a foundation is a special rail foundation for single horizontal/vertical track.

   316

 *

   317

 * @param f  The #Foundation.

   318

 * @return   true iff f is a special rail foundation for single horizontal/vertical track.

   319

 */

   320

static inline bool IsSpecialRailFoundation(Foundation f)

   321

{

   323

}

   324

   325

/**

   326

 * Returns the track corner of a special rail foundation

   327

 *

   328

 * @param f  The #Foundation.

   329

 * @return   The #Corner with track.

   330

 */

   331

static inline Corner GetRailFoundationCorner(Foundation f)

   332

{

   333

	assert(IsSpecialRailFoundation(f));

   334

	return (Corner)(f - FOUNDATION_RAIL_W);

   335

}

   336

   337

/**

   338

 * Returns the foundation needed to flatten a slope.

   339

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

   340

 *

   341

 * @pre      The slope must not be steep.

   342

 * @param s  The current #Slope.

   343

 * @return   The needed #Foundation.

   344

 */

   345

static inline Foundation FlatteningFoundation(Slope s)

   346

{

   347

	assert(!IsSteepSlope(s));

   348

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

   349

}

   350

   351

/**

   352

 * Returns the along a specific axis inclined foundation.

   353

 *

   354

 * @param axis  The #Axis.

   355

 * @return      The needed #Foundation.

   356

 */

   357

static inline Foundation InclinedFoundation(Axis axis)

   358

{

   359

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

   360

}

   361

   362

/**

   363

 * Returns the halftile foundation for single horizontal/vertical track.

   364

 *

   365

 * @param corner The #Corner with the track.

   366

 * @return       The wanted #Foundation.

   367

 */

   368

static inline Foundation HalftileFoundation(Corner corner)

   369

{

   370

	assert(IsValidCorner(corner));

   371

	return (Foundation)(FOUNDATION_HALFTILE_W + corner);

   372

}

   373

   374

/**

   375

 * Returns the special rail foundation for single horizontal/vertical track.

   376

 *

   377

 * @param corner The #Corner with the track.

   378

 * @return       The wanted #Foundation.

   379

 */

   380

static inline Foundation SpecialRailFoundation(Corner corner)

   381

{

   382

	assert(IsValidCorner(corner));

   383

	return (Foundation)(FOUNDATION_RAIL_W + corner);

   384

}

   385

   386

#endif /* SLOPE_H */