1

/* $Id$ */

     2

     4

     7

    10

    11

/**

    12

 * Rangecheck for Corner enumeration.

    13

 *

    14

 * @param corner A #Corner.

    15

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

    16

 */

    17

static inline bool IsValidCorner(Corner corner)

    18

{

    19

	return IsInsideMM(corner, 0, CORNER_END);

    20

}

    21

    23

/**

    24

 * Checks if a slope is steep.

    25

 *

    26

 * @param s The given #Slope.

    27

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

    28

 */

    29

static inline bool IsSteepSlope(Slope s)

    30

{

    31

	return (s & SLOPE_STEEP) != 0;

    32

}

    33

    34

/**

    35

 * Checks for non-continuous slope on halftile foundations.

    36

 *

    37

 * @param s The given #Slope.

    38

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

    39

 */

    40

static inline bool IsHalftileSlope(Slope s)

    41

{

    42

	return (s & SLOPE_HALFTILE) != 0;

    43

}

    44

    45

/**

    46

 * Return the complement of a slope.

    47

 *

    48

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

    49

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

    50

 * slope.

    51

 *

    52

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

    53

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

    54

 * @return a complement Slope of the given slope.

    55

 */

    56

static inline Slope ComplementSlope(Slope s)

    57

{

    58

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

    59

	return (Slope)(0xF ^ s);

    60

}

    61

    62

/**

    63

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

    64

 *

    65

 * Note: A halftile slope is ignored.

    66

 *

    67

 * @param s The #Slope.

    68

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

    69

 */

    70

static inline bool HasSlopeHighestCorner(Slope s)

    71

{

    72

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

    73

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

    74

}

    75

    76

/**

    77

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

    78

 *

    79

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

    80

 * @param s  The #Slope.

    81

 * @return   Highest corner.

    82

 */

    83

static inline Corner GetHighestSlopeCorner(Slope s)

    84

{

    85

	switch (s & ~SLOPE_HALFTILE_MASK) {

    86

		case SLOPE_W:

    87

		case SLOPE_STEEP_W: return CORNER_W;

    88

		case SLOPE_S:

    89

		case SLOPE_STEEP_S: return CORNER_S;

    90

		case SLOPE_E:

    91

		case SLOPE_STEEP_E: return CORNER_E;

    92

		case SLOPE_N:

    93

		case SLOPE_STEEP_N: return CORNER_N;

    94

		default: NOT_REACHED();

    95

	}

    96

}

    97

    98

/**

    99

 * Returns the leveled halftile of a halftile slope.

   100

 *

   101

 * @pre     The slope must be a halftile slope.

   102

 * @param s The #Slope.

   103

 * @return  The corner of the leveled halftile.

   104

 */

   105

static inline Corner GetHalftileSlopeCorner(Slope s)

   106

{

   107

	assert(IsHalftileSlope(s));

   108

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

   109

}

   110

   111

/**

   112

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

   113

 *

   114

 * @param s The #Slope.

   115

 * @return Relative height of highest corner.

   116

 */

   117

static inline uint GetSlopeMaxZ(Slope s)

   118

{

   119

	if (s == SLOPE_FLAT) return 0;

   120

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

   121

	return TILE_HEIGHT;

   122

}

   123

   124

/**

   125

 * Returns the opposite corner.

   126

 *

   127

 * @param corner A #Corner.

   128

 * @return The opposite corner to "corner".

   129

 */

   130

static inline Corner OppositeCorner(Corner corner)

   131

{

   132

	return (Corner)(corner ^ 2);

   133

}

   134

   135

/**

   136

 * Returns the slope with a specific corner raised.

   137

 *

   138

 * @param corner The #Corner.

   139

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

   140

 */

   141

static inline Slope SlopeWithOneCornerRaised(Corner corner)

   142

{

   143

	assert(IsValidCorner(corner));

   144

	return (Slope)(1 << corner);

   145

}

   146

   147

/**

   148

 * Returns the slope with all except one corner raised.

   149

 *

   150

 * @param corner The #Corner.

   151

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

   152

 */

   153

static inline Slope SlopeWithThreeCornersRaised(Corner corner)

   154

{

   155

	return ComplementSlope(SlopeWithOneCornerRaised(corner));

   156

}

   157

   158

/**

   159

 * Adds a halftile slope to a slope.

   160

 *

   161

 * @param s #Slope without a halftile slope.

   162

 * @param corner The #Corner of the halftile.

   163

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

   164

 */

   165

static inline Slope HalftileSlope(Slope s, Corner corner)

   166

{

   167

	assert(IsValidCorner(corner));

   168

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

   169

}

   170

   171

   172

/**

   173

 * Tests for FOUNDATION_NONE.

   174

 *

   175

 * @param f  Maybe a #Foundation.

   176

 * @return   true iff f is a foundation.

   177

 */

   178

static inline bool IsFoundation(Foundation f)

   179

{

   180

	return f != FOUNDATION_NONE;

   181

}

   182

   183

/**

   184

 * Tests if the foundation is a leveled foundation.

   185

 *

   186

 * @param f  The #Foundation.

   187

 * @return   true iff f is a leveled foundation.

   188

 */

   189

static inline bool IsLeveledFoundation(Foundation f)

   190

{

   191

	return f == FOUNDATION_LEVELED;

   192

}

   193

   194

/**

   195

 * Tests if the foundation is an inclined foundation.

   196

 *

   197

 * @param f  The #Foundation.

   198

 * @return   true iff f is an inclined foundation.

   199

 */

   200

static inline bool IsInclinedFoundation(Foundation f)

   201

{

   202

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

   203

}

   204

   205

/**

   206

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

   207

 *

   208

 * @param f  The #Foundation.

   209

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

   210

 */

   211

static inline bool IsNonContinuousFoundation(Foundation f)

   212

{

   213

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

   214

}

   215

   216

/**

   217

 * Returns the halftile corner of a halftile-foundation

   218

 *

   219

 * @pre f != FOUNDATION_STEEP_BOTH

   220

 *

   221

 * @param f  The #Foundation.

   222

 * @return   The #Corner with track.

   223

 */

   224

static inline Corner GetHalftileFoundationCorner(Foundation f)

   225

{

   226

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

   227

	return (Corner)(f - FOUNDATION_HALFTILE_W);

   228

}

   229

   230

/**

   231

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

   232

 *

   233

 * @param f  The #Foundation.

   234

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

   235

 */

   236

static inline bool IsSpecialRailFoundation(Foundation f)

   237

{

   238

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

   239

}

   240

   241

/**

   242

 * Returns the track corner of a special rail foundation

   243

 *

   244

 * @param f  The #Foundation.

   245

 * @return   The #Corner with track.

   246

 */

   247

static inline Corner GetRailFoundationCorner(Foundation f)

   248

{

   249

	assert(IsSpecialRailFoundation(f));

   250

	return (Corner)(f - FOUNDATION_RAIL_W);

   251

}

   252

   253

/**

   254

 * Returns the foundation needed to flatten a slope.

   255

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

   256

 *

   257

 * @pre      The slope must not be steep.

   258

 * @param s  The current #Slope.

   259

 * @return   The needed #Foundation.

   260

 */

   261

static inline Foundation FlatteningFoundation(Slope s)

   262

{

   263

	assert(!IsSteepSlope(s));

   264

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

   265

}

   266

   267

/**

   268

 * Returns the along a specific axis inclined foundation.

   269

 *

   270

 * @param axis  The #Axis.

   271

 * @return      The needed #Foundation.

   272

 */

   273

static inline Foundation InclinedFoundation(Axis axis)

   274

{

   275

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

   276

}

   277

   278

/**

   279

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

   280

 *

   281

 * @param corner The #Corner with the track.

   282

 * @return       The wanted #Foundation.

   283

 */

   284

static inline Foundation HalftileFoundation(Corner corner)

   285

{

   286

	assert(IsValidCorner(corner));

   287

	return (Foundation)(FOUNDATION_HALFTILE_W + corner);

   288

}

   289

   290

/**

   291

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

   292

 *

   293

 * @param corner The #Corner with the track.

   294

 * @return       The wanted #Foundation.

   295

 */

   296

static inline Foundation SpecialRailFoundation(Corner corner)

   297

{

   298

	assert(IsValidCorner(corner));

   299

	return (Foundation)(FOUNDATION_RAIL_W + corner);

   300

}

   301