1

/* $Id$ */

     2

     3

/** @file slope_func.h Functions related to slopes. */

     4

     5

#ifndef SLOPE_FUNC_H

     6

#define SLOPE_FUNC_H

     7

     8

#include "core/math_func.hpp"

     9

#include "slope_type.h"

    10

#include "direction_type.h"

    11

    12

/**

    13

 * Rangecheck for Corner enumeration.

    14

 *

    15

 * @param corner A #Corner.

    16

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

    17

 */

    18

static inline bool IsValidCorner(Corner corner)

    19

{

    20

	return IsInsideMM(corner, 0, CORNER_END);

    21

}

    22

    23

    24

/**

    25

 * Checks if a slope is steep.

    26

 *

    27

 * @param s The given #Slope.

    28

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

    29

 */

    30

static inline bool IsSteepSlope(Slope s)

    31

{

    32

	return (s & SLOPE_STEEP) != 0;

    33

}

    34

    35

/**

    36

 * Checks for non-continuous slope on halftile foundations.

    37

 *

    38

 * @param s The given #Slope.

    39

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

    40

 */

    41

static inline bool IsHalftileSlope(Slope s)

    42

{

    43

	return (s & SLOPE_HALFTILE) != 0;

    44

}

    45

    46

/**

    47

 * Return the complement of a slope.

    48

 *

    49

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

    50

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

    51

 * slope.

    52

 *

    53

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

    54

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

    55

 * @return a complement Slope of the given slope.

    56

 */

    57

static inline Slope ComplementSlope(Slope s)

    58

{

    59

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

    60

	return (Slope)(0xF ^ s);

    61

}

    62

    63

/**

    64

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

    65

 *

    66

 * Note: A halftile slope is ignored.

    67

 *

    68

 * @param s The #Slope.

    69

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

    70

 */

    71

static inline bool HasSlopeHighestCorner(Slope s)

    72

{

    73

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

    74

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

    75

}

    76

    77

/**

    78

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

    79

 *

    80

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

    81

 * @param s  The #Slope.

    82

 * @return   Highest corner.

    83

 */

    84

static inline Corner GetHighestSlopeCorner(Slope s)

    85

{

    86

	switch (s & ~SLOPE_HALFTILE_MASK) {

    87

		case SLOPE_W:

    88

		case SLOPE_STEEP_W: return CORNER_W;

    89

		case SLOPE_S:

    90

		case SLOPE_STEEP_S: return CORNER_S;

    91

		case SLOPE_E:

    92

		case SLOPE_STEEP_E: return CORNER_E;

    93

		case SLOPE_N:

    94

		case SLOPE_STEEP_N: return CORNER_N;

    95

		default: NOT_REACHED();

    96

	}

    97

}

    98

    99

/**

   100

 * Returns the leveled halftile of a halftile slope.

   101

 *

   102

 * @pre     The slope must be a halftile slope.

   103

 * @param s The #Slope.

   104

 * @return  The corner of the leveled halftile.

   105

 */

   106

static inline Corner GetHalftileSlopeCorner(Slope s)

   107

{

   108

	assert(IsHalftileSlope(s));

   109

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

   110

}

   111

   112

/**

   113

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

   114

 *

   115

 * @param s The #Slope.

   116

 * @return Relative height of highest corner.

   117

 */

   118

static inline uint GetSlopeMaxZ(Slope s)

   119

{

   120

	if (s == SLOPE_FLAT) return 0;

   121

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

   122

	return TILE_HEIGHT;

   123

}

   124

   125

/**

   126

 * Returns the opposite corner.

   127

 *

   128

 * @param corner A #Corner.

   129

 * @return The opposite corner to "corner".

   130

 */

   131

static inline Corner OppositeCorner(Corner corner)

   132

{

   133

	return (Corner)(corner ^ 2);

   134

}

   135

   136

/**

   137

 * Returns the slope with a specific corner raised.

   138

 *

   139

 * @param corner The #Corner.

   140

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

   141

 */

   142

static inline Slope SlopeWithOneCornerRaised(Corner corner)

   143

{

   144

	assert(IsValidCorner(corner));

   145

	return (Slope)(1 << corner);

   146

}

   147

   148

/**

   149

 * Returns the slope with all except one corner raised.

   150

 *

   151

 * @param corner The #Corner.

   152

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

   153

 */

   154

static inline Slope SlopeWithThreeCornersRaised(Corner corner)

   155

{

   156

	return ComplementSlope(SlopeWithOneCornerRaised(corner));

   157

}

   158

   159

/**

   160

 * Adds a halftile slope to a slope.

   161

 *

   162

 * @param s #Slope without a halftile slope.

   163

 * @param corner The #Corner of the halftile.

   164

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

   165

 */

   166

static inline Slope HalftileSlope(Slope s, Corner corner)

   167

{

   168

	assert(IsValidCorner(corner));

   169

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

   170

}

   171

   172

   173

/**

   174

 * Tests for FOUNDATION_NONE.

   175

 *

   176

 * @param f  Maybe a #Foundation.

   177

 * @return   true iff f is a foundation.

   178

 */

   179

static inline bool IsFoundation(Foundation f)

   180

{

   181

	return f != FOUNDATION_NONE;

   182

}

   183

   184

/**

   185

 * Tests if the foundation is a leveled foundation.

   186

 *

   187

 * @param f  The #Foundation.

   188

 * @return   true iff f is a leveled foundation.

   189

 */

   190

static inline bool IsLeveledFoundation(Foundation f)

   191

{

   192

	return f == FOUNDATION_LEVELED;

   193

}

   194

   195

/**

   196

 * Tests if the foundation is an inclined foundation.

   197

 *

   198

 * @param f  The #Foundation.

   199

 * @return   true iff f is an inclined foundation.

   200

 */

   201

static inline bool IsInclinedFoundation(Foundation f)

   202

{

   203

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

   204

}

   205

   206

/**

   207

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

   208

 *

   209

 * @param f  The #Foundation.

   210

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

   211

 */

   212

static inline bool IsNonContinuousFoundation(Foundation f)

   213

{

   214

	return IsInsideMM(f, FOUNDATION_STEEP_BOTH, FOUNDATION_HALFTILE_N + 1);

   215

}

   216

   217

/**

   218

 * Returns the halftile corner of a halftile-foundation

   219

 *

   220

 * @pre f != FOUNDATION_STEEP_BOTH

   221

 *

   222

 * @param f  The #Foundation.

   223

 * @return   The #Corner with track.

   224

 */

   225

static inline Corner GetHalftileFoundationCorner(Foundation f)

   226

{

   227

	assert(IsInsideMM(f, FOUNDATION_HALFTILE_W, FOUNDATION_HALFTILE_N + 1));

   228

	return (Corner)(f - FOUNDATION_HALFTILE_W);

   229

}

   230

   231

/**

   232

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

   233

 *

   234

 * @param f  The #Foundation.

   235

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

   236

 */

   237

static inline bool IsSpecialRailFoundation(Foundation f)

   238

{

   239

	return IsInsideMM(f, FOUNDATION_RAIL_W, FOUNDATION_RAIL_N + 1);

   240

}

   241

   242

/**

   243

 * Returns the track corner of a special rail foundation

   244

 *

   245

 * @param f  The #Foundation.

   246

 * @return   The #Corner with track.

   247

 */

   248

static inline Corner GetRailFoundationCorner(Foundation f)

   249

{

   250

	assert(IsSpecialRailFoundation(f));

   251

	return (Corner)(f - FOUNDATION_RAIL_W);

   252

}

   253

   254

/**

   255

 * Returns the foundation needed to flatten a slope.

   256

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

   257

 *

   258

 * @pre      The slope must not be steep.

   259

 * @param s  The current #Slope.

   260

 * @return   The needed #Foundation.

   261

 */

   262

static inline Foundation FlatteningFoundation(Slope s)

   263

{

   264

	assert(!IsSteepSlope(s));

   265

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

   266

}

   267

   268

/**

   269

 * Returns the along a specific axis inclined foundation.

   270

 *

   271

 * @param axis  The #Axis.

   272

 * @return      The needed #Foundation.

   273

 */

   274

static inline Foundation InclinedFoundation(Axis axis)

   275

{

   276

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

   277

}

   278

   279

/**

   280

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

   281

 *

   282

 * @param corner The #Corner with the track.

   283

 * @return       The wanted #Foundation.

   284

 */

   285

static inline Foundation HalftileFoundation(Corner corner)

   286

{

   287

	assert(IsValidCorner(corner));

   288

	return (Foundation)(FOUNDATION_HALFTILE_W + corner);

   289

}

   290

   291

/**

   292

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

   293

 *

   294

 * @param corner The #Corner with the track.

   295

 * @return       The wanted #Foundation.

   296

 */

   297

static inline Foundation SpecialRailFoundation(Corner corner)

   298

{

   299

	assert(IsValidCorner(corner));

   300

	return (Foundation)(FOUNDATION_RAIL_W + corner);

   301

}

   302

   303

#endif /* SLOPE_FUNC_H */