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

#include "tile_type.h"

    12

    13

/**

    14

 * Rangecheck for Corner enumeration.

    15

 *

    16

 * @param corner A #Corner.

    17

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

    18

 */

    19

static inline bool IsValidCorner(Corner corner)

    20

{

    21

	return IsInsideMM(corner, 0, CORNER_END);

    22

}

    23

    24

    25

/**

    26

 * Checks if a slope is steep.

    27

 *

    28

 * @param s The given #Slope.

    29

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

    30

 */

    31

static inline bool IsSteepSlope(Slope s)

    32

{

    33

	return (s & SLOPE_STEEP) != 0;

    34

}

    35

    36

/**

    37

 * Checks for non-continuous slope on halftile foundations.

    38

 *

    39

 * @param s The given #Slope.

    40

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

    41

 */

    42

static inline bool IsHalftileSlope(Slope s)

    43

{

    44

	return (s & SLOPE_HALFTILE) != 0;

    45

}

    46

    47

/**

    48

 * Return the complement of a slope.

    49

 *

    50

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

    51

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

    52

 * slope.

    53

 *

    54

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

    55

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

    56

 * @return a complement Slope of the given slope.

    57

 */

    58

static inline Slope ComplementSlope(Slope s)

    59

{

    60

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

    61

	return (Slope)(0xF ^ s);

    62

}

    63

    64

/**

    65

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

    66

 *

    67

 * Note: A halftile slope is ignored.

    68

 *

    69

 * @param s The #Slope.

    70

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

    71

 */

    72

static inline bool HasSlopeHighestCorner(Slope s)

    73

{

    74

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

    75

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

    76

}

    77

    78

/**

    79

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

    80

 *

    81

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

    82

 * @param s  The #Slope.

    83

 * @return   Highest corner.

    84

 */

    85

static inline Corner GetHighestSlopeCorner(Slope s)

    86

{

    87

	switch (s & ~SLOPE_HALFTILE_MASK) {

    88

		case SLOPE_W:

    89

		case SLOPE_STEEP_W: return CORNER_W;

    90

		case SLOPE_S:

    91

		case SLOPE_STEEP_S: return CORNER_S;

    92

		case SLOPE_E:

    93

		case SLOPE_STEEP_E: return CORNER_E;

    94

		case SLOPE_N:

    95

		case SLOPE_STEEP_N: return CORNER_N;

    96

		default: NOT_REACHED();

    97

	}

    98

}

    99

   100

/**

   101

 * Returns the leveled halftile of a halftile slope.

   102

 *

   103

 * @pre     The slope must be a halftile slope.

   104

 * @param s The #Slope.

   105

 * @return  The corner of the leveled halftile.

   106

 */

   107

static inline Corner GetHalftileSlopeCorner(Slope s)

   108

{

   109

	assert(IsHalftileSlope(s));

   110

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

   111

}

   112

   113

/**

   114

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

   115

 *

   116

 * @param s The #Slope.

   117

 * @return Relative height of highest corner.

   118

 */

   119

static inline uint GetSlopeMaxZ(Slope s)

   120

{

   121

	if (s == SLOPE_FLAT) return 0;

   122

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

   123

	return TILE_HEIGHT;

   124

}

   125

   126

/**

   127

 * Returns the opposite corner.

   128

 *

   129

 * @param corner A #Corner.

   130

 * @return The opposite corner to "corner".

   131

 */

   132

static inline Corner OppositeCorner(Corner corner)

   133

{

   134

	return (Corner)(corner ^ 2);

   135

}

   136

   137

/**

   138

 * Returns the slope with a specific corner raised.

   139

 *

   140

 * @param corner The #Corner.

   141

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

   142

 */

   143

static inline Slope SlopeWithOneCornerRaised(Corner corner)

   144

{

   145

	assert(IsValidCorner(corner));

   146

	return (Slope)(1 << corner);

   147

}

   148

   149

/**

   150

 * Returns the slope with all except one corner raised.

   151

 *

   152

 * @param corner The #Corner.

   153

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

   154

 */

   155

static inline Slope SlopeWithThreeCornersRaised(Corner corner)

   156

{

   157

	return ComplementSlope(SlopeWithOneCornerRaised(corner));

   158

}

   159

   160

/**

   161

 * Adds a halftile slope to a slope.

   162

 *

   163

 * @param s #Slope without a halftile slope.

   164

 * @param corner The #Corner of the halftile.

   165

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

   166

 */

   167

static inline Slope HalftileSlope(Slope s, Corner corner)

   168

{

   169

	assert(IsValidCorner(corner));

   170

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

   171

}

   172

   173

   174

/**

   175

 * Tests for FOUNDATION_NONE.

   176

 *

   177

 * @param f  Maybe a #Foundation.

   178

 * @return   true iff f is a foundation.

   179

 */

   180

static inline bool IsFoundation(Foundation f)

   181

{

   182

	return f != FOUNDATION_NONE;

   183

}

   184

   185

/**

   186

 * Tests if the foundation is a leveled foundation.

   187

 *

   188

 * @param f  The #Foundation.

   189

 * @return   true iff f is a leveled foundation.

   190

 */

   191

static inline bool IsLeveledFoundation(Foundation f)

   192

{

   193

	return f == FOUNDATION_LEVELED;

   194

}

   195

   196

/**

   197

 * Tests if the foundation is an inclined foundation.

   198

 *

   199

 * @param f  The #Foundation.

   200

 * @return   true iff f is an inclined foundation.

   201

 */

   202

static inline bool IsInclinedFoundation(Foundation f)

   203

{

   204

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

   205

}

   206

   207

/**

   208

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

   209

 *

   210

 * @param f  The #Foundation.

   211

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

   212

 */

   213

static inline bool IsNonContinuousFoundation(Foundation f)

   214

{

   215

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

   216

}

   217

   218

/**

   219

 * Returns the halftile corner of a halftile-foundation

   220

 *

   221

 * @pre f != FOUNDATION_STEEP_BOTH

   222

 *

   223

 * @param f  The #Foundation.

   224

 * @return   The #Corner with track.

   225

 */

   226

static inline Corner GetHalftileFoundationCorner(Foundation f)

   227

{

   228

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

   229

	return (Corner)(f - FOUNDATION_HALFTILE_W);

   230

}

   231

   232

/**

   233

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

   234

 *

   235

 * @param f  The #Foundation.

   236

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

   237

 */

   238

static inline bool IsSpecialRailFoundation(Foundation f)

   239

{

   240

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

   241

}

   242

   243

/**

   244

 * Returns the track corner of a special rail foundation

   245

 *

   246

 * @param f  The #Foundation.

   247

 * @return   The #Corner with track.

   248

 */

   249

static inline Corner GetRailFoundationCorner(Foundation f)

   250

{

   251

	assert(IsSpecialRailFoundation(f));

   252

	return (Corner)(f - FOUNDATION_RAIL_W);

   253

}

   254

   255

/**

   256

 * Returns the foundation needed to flatten a slope.

   257

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

   258

 *

   259

 * @pre      The slope must not be steep.

   260

 * @param s  The current #Slope.

   261

 * @return   The needed #Foundation.

   262

 */

   263

static inline Foundation FlatteningFoundation(Slope s)

   264

{

   265

	assert(!IsSteepSlope(s));

   266

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

   267

}

   268

   269

/**

   270

 * Returns the along a specific axis inclined foundation.

   271

 *

   272

 * @param axis  The #Axis.

   273

 * @return      The needed #Foundation.

   274

 */

   275

static inline Foundation InclinedFoundation(Axis axis)

   276

{

   277

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

   278

}

   279

   280

/**

   281

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

   282

 *

   283

 * @param corner The #Corner with the track.

   284

 * @return       The wanted #Foundation.

   285

 */

   286

static inline Foundation HalftileFoundation(Corner corner)

   287

{

   288

	assert(IsValidCorner(corner));

   289

	return (Foundation)(FOUNDATION_HALFTILE_W + corner);

   290

}

   291

   292

/**

   293

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

   294

 *

   295

 * @param corner The #Corner with the track.

   296

 * @return       The wanted #Foundation.

   297

 */

   298

static inline Foundation SpecialRailFoundation(Corner corner)

   299

{

   300

	assert(IsValidCorner(corner));

   301

	return (Foundation)(FOUNDATION_RAIL_W + corner);

   302

}

   303

   304

#endif /* SLOPE_FUNC_H */