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

 * Removes a halftile slope from a slope

    49

 *

    50

 * Non-halftile slopes remain unmodified.

    51

 *

    52

 * @param s A #Slope.

    53

 * @return The slope s without it's halftile slope.

    54

 */

    55

static inline Slope RemoveHalftileSlope(Slope s)

    56

{

    57

	return (Slope)(s & ~SLOPE_HALFTILE_MASK);

    58

}

    59

    60

/**

    61

 * Return the complement of a slope.

    62

 *

    63

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

    64

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

    65

 * slope.

    66

 *

    67

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

    68

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

    69

 * @return a complement Slope of the given slope.

    70

 */

    71

static inline Slope ComplementSlope(Slope s)

    72

{

    73

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

    74

	return (Slope)(0xF ^ s);

    75

}

    76

    77

/**

    78

 * Tests if a specific slope has exactly one corner raised.

    79

 *

    80

 * @param s The #Slope

    81

 * @return true iff exactly one corner is raised

    82

 */

    83

static inline bool IsSlopeWithOneCornerRaised(Slope s)

    84

{

    85

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

    86

}

    87

    88

/**

    89

 * Returns the slope with a specific corner raised.

    90

 *

    91

 * @param corner The #Corner.

    92

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

    93

 */

    94

static inline Slope SlopeWithOneCornerRaised(Corner corner)

    95

{

    96

	assert(IsValidCorner(corner));

    97

	return (Slope)(1 << corner);

    98

}

    99

   100

/**

   101

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

   102

 *

   103

 * Note: A halftile slope is ignored.

   104

 *

   105

 * @param s The #Slope.

   106

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

   107

 */

   108

static inline bool HasSlopeHighestCorner(Slope s)

   109

{

   110

	s = RemoveHalftileSlope(s);

   111

	return IsSteepSlope(s) || IsSlopeWithOneCornerRaised(s);

   112

}

   113

   114

/**

   115

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

   116

 *

   117

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

   118

 * @param s  The #Slope.

   119

 * @return   Highest corner.

   120

 */

   121

static inline Corner GetHighestSlopeCorner(Slope s)

   122

{

   123

	switch (RemoveHalftileSlope(s)) {

   124

		case SLOPE_W:

   125

		case SLOPE_STEEP_W: return CORNER_W;

   126

		case SLOPE_S:

   127

		case SLOPE_STEEP_S: return CORNER_S;

   128

		case SLOPE_E:

   129

		case SLOPE_STEEP_E: return CORNER_E;

   130

		case SLOPE_N:

   131

		case SLOPE_STEEP_N: return CORNER_N;

   132

		default: NOT_REACHED();

   133

	}

   134

}

   135

   136

/**

   137

 * Returns the leveled halftile of a halftile slope.

   138

 *

   139

 * @pre     The slope must be a halftile slope.

   140

 * @param s The #Slope.

   141

 * @return  The corner of the leveled halftile.

   142

 */

   143

static inline Corner GetHalftileSlopeCorner(Slope s)

   144

{

   145

	assert(IsHalftileSlope(s));

   146

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

   147

}

   148

   149

/**

   150

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

   151

 *

   152

 * @param s The #Slope.

   153

 * @return Relative height of highest corner.

   154

 */

   155

static inline uint GetSlopeMaxZ(Slope s)

   156

{

   157

	if (s == SLOPE_FLAT) return 0;

   158

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

   159

	return TILE_HEIGHT;

   160

}

   161

   162

/**

   163

 * Returns the opposite corner.

   164

 *

   165

 * @param corner A #Corner.

   166

 * @return The opposite corner to "corner".

   167

 */

   168

static inline Corner OppositeCorner(Corner corner)

   169

{

   170

	return (Corner)(corner ^ 2);

   171

}

   172

   173

/**

   174

 * Tests if a specific slope has exactly three corners raised.

   175

 *

   176

 * @param s The #Slope

   177

 * @return true iff exactly three corners are raised

   178

 */

   179

static inline bool IsSlopeWithThreeCornersRaised(Slope s)

   180

{

   181

	return !IsHalftileSlope(s) && !IsSteepSlope(s) && IsSlopeWithOneCornerRaised(ComplementSlope(s));

   182

}

   183

   184

/**

   185

 * Returns the slope with all except one corner raised.

   186

 *

   187

 * @param corner The #Corner.

   188

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

   189

 */

   190

static inline Slope SlopeWithThreeCornersRaised(Corner corner)

   191

{

   192

	return ComplementSlope(SlopeWithOneCornerRaised(corner));

   193

}

   194

   195

/**

   196

 * Returns a specific steep slope

   197

 *

   198

 * @param corner A #Corner.

   199

 * @return The steep #Slope with "corner" as highest corner.

   200

 */

   201

static inline Slope SteepSlope(Corner corner)

   202

{

   203

	return (Slope)(SLOPE_STEEP | SlopeWithThreeCornersRaised(OppositeCorner(corner)));

   204

}

   205

   206

/**

   207

 * Tests if a specific slope is an inclined slope.

   208

 *

   209

 * @param s The #Slope

   210

 * @return true iff the slope is inclined.

   211

 */

   212

static inline bool IsInclinedSlope(Slope s)

   213

{

   214

	return (s == SLOPE_NW) || (s == SLOPE_SW) || (s == SLOPE_SE) || (s == SLOPE_NE);

   215

}

   216

   217

/**

   218

 * Returns the direction of an inclined slope.

   219

 *

   220

 * @param s A #Slope

   221

 * @return The direction the slope goes up in. Or INVALID_DIAGDIR if the slope is not an inclined slope.

   222

 */

   223

static inline DiagDirection GetInclinedSlopeDirection(Slope s)

   224

{

   225

	switch (s) {

   226

		case SLOPE_NE: return DIAGDIR_NE;

   227

		case SLOPE_SE: return DIAGDIR_SE;

   228

		case SLOPE_SW: return DIAGDIR_SW;

   229

		case SLOPE_NW: return DIAGDIR_NW;

   230

		default: return INVALID_DIAGDIR;

   231

	}

   232

}

   233

   234

/**

   235

 * Returns the slope, that is inclined in a specific direction.

   236

 *

   237

 * @param dir A #DiagDirection

   238

 * @return The #Slope that goes up in direction dir.

   239

 */

   240

static inline Slope InclinedSlope(DiagDirection dir)

   241

{

   242

	switch (dir) {

   243

		case DIAGDIR_NE: return SLOPE_NE;

   244

		case DIAGDIR_SE: return SLOPE_SE;

   245

		case DIAGDIR_SW: return SLOPE_SW;

   246

		case DIAGDIR_NW: return SLOPE_NW;

   247

		default: NOT_REACHED();

   248

	}

   249

}

   250

   251

/**

   252

 * Adds a halftile slope to a slope.

   253

 *

   254

 * @param s #Slope without a halftile slope.

   255

 * @param corner The #Corner of the halftile.

   256

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

   257

 */

   258

static inline Slope HalftileSlope(Slope s, Corner corner)

   259

{

   260

	assert(IsValidCorner(corner));

   261

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

   262

}

   263

   264

   265

/**

   266

 * Tests for FOUNDATION_NONE.

   267

 *

   268

 * @param f  Maybe a #Foundation.

   269

 * @return   true iff f is a foundation.

   270

 */

   271

static inline bool IsFoundation(Foundation f)

   272

{

   273

	return f != FOUNDATION_NONE;

   274

}

   275

   276

/**

   277

 * Tests if the foundation is a leveled foundation.

   278

 *

   279

 * @param f  The #Foundation.

   280

 * @return   true iff f is a leveled foundation.

   281

 */

   282

static inline bool IsLeveledFoundation(Foundation f)

   283

{

   284

	return f == FOUNDATION_LEVELED;

   285

}

   286

   287

/**

   288

 * Tests if the foundation is an inclined foundation.

   289

 *

   290

 * @param f  The #Foundation.

   291

 * @return   true iff f is an inclined foundation.

   292

 */

   293

static inline bool IsInclinedFoundation(Foundation f)

   294

{

   295

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

   296

}

   297

   298

/**

   299

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

   300

 *

   301

 * @param f  The #Foundation.

   302

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

   303

 */

   304

static inline bool IsNonContinuousFoundation(Foundation f)

   305

{

   306

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

   307

}

   308

   309

/**

   310

 * Returns the halftile corner of a halftile-foundation

   311

 *

   312

 * @pre f != FOUNDATION_STEEP_BOTH

   313

 *

   314

 * @param f  The #Foundation.

   315

 * @return   The #Corner with track.

   316

 */

   317

static inline Corner GetHalftileFoundationCorner(Foundation f)

   318

{

   319

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

   320

	return (Corner)(f - FOUNDATION_HALFTILE_W);

   321

}

   322

   323

/**

   324

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

   325

 *

   326

 * @param f  The #Foundation.

   327

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

   328

 */

   329

static inline bool IsSpecialRailFoundation(Foundation f)

   330

{

   331

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

   332

}

   333

   334

/**

   335

 * Returns the track corner of a special rail foundation

   336

 *

   337

 * @param f  The #Foundation.

   338

 * @return   The #Corner with track.

   339

 */

   340

static inline Corner GetRailFoundationCorner(Foundation f)

   341

{

   342

	assert(IsSpecialRailFoundation(f));

   343

	return (Corner)(f - FOUNDATION_RAIL_W);

   344

}

   345

   346

/**

   347

 * Returns the foundation needed to flatten a slope.

   348

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

   349

 *

   350

 * @pre      The slope must not be steep.

   351

 * @param s  The current #Slope.

   352

 * @return   The needed #Foundation.

   353

 */

   354

static inline Foundation FlatteningFoundation(Slope s)

   355

{

   356

	assert(!IsSteepSlope(s));

   357

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

   358

}

   359

   360

/**

   361

 * Returns the along a specific axis inclined foundation.

   362

 *

   363

 * @param axis  The #Axis.

   364

 * @return      The needed #Foundation.

   365

 */

   366

static inline Foundation InclinedFoundation(Axis axis)

   367

{

   368

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

   369

}

   370

   371

/**

   372

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

   373

 *

   374

 * @param corner The #Corner with the track.

   375

 * @return       The wanted #Foundation.

   376

 */

   377

static inline Foundation HalftileFoundation(Corner corner)

   378

{

   379

	assert(IsValidCorner(corner));

   380

	return (Foundation)(FOUNDATION_HALFTILE_W + corner);

   381

}

   382

   383

/**

   384

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

   385

 *

   386

 * @param corner The #Corner with the track.

   387

 * @return       The wanted #Foundation.

   388

 */

   389

static inline Foundation SpecialRailFoundation(Corner corner)

   390

{

   391

	assert(IsValidCorner(corner));

   392

	return (Foundation)(FOUNDATION_RAIL_W + corner);

   393

}

   394

   395

#endif /* SLOPE_FUNC_H */