1

/* $Id$ */

     2

     3

/** @file direction.h */

     4

     5

#ifndef DIRECTION_H

     6

#define DIRECTION_H

     7

     8

#include "helpers.hpp"

     9

    10

/**

    11

 * Defines the 8 directions on the map.

    12

 *

    13

 * This enum defines 8 possible directions which are used for

    14

 * the vehicles in the game. The directions are aligned straight

    15

 * to the viewport, not to the map. So north points to the top of

    16

 * your viewport and not rotated by 45 degrees left or right to get

    17

 * a "north" used in you games.

    18

 */

    19

enum Direction {

    20

	DIR_BEGIN = 0,          ///< Used to iterate

    21

	DIR_N   = 0,            ///< North

    22

	DIR_NE  = 1,            ///< Northeast

    23

	DIR_E   = 2,            ///< East

    24

	DIR_SE  = 3,            ///< Southeast

    25

	DIR_S   = 4,            ///< South

    26

	DIR_SW  = 5,            ///< Southwest

    27

	DIR_W   = 6,            ///< West

    28

	DIR_NW  = 7,            ///< Northwest

    29

	DIR_END,                ///< Used to iterate

    30

	INVALID_DIR = 0xFF,     ///< Flag for an invalid direction

    31

};

    32

    33

/** Define basic enum properties */

    34

template <> struct EnumPropsT<Direction> : MakeEnumPropsT<Direction, byte, DIR_BEGIN, DIR_END, INVALID_DIR> {};

    35

typedef TinyEnumT<Direction> DirectionByte; //typedefing-enumification of Direction

    36

    37

/**

    38

 * Return the reverse of a direction

    39

 *

    40

 * @param d The direction to get the reverse from

    41

 * @return The reverse Direction

    42

 */

    43

static inline Direction ReverseDir(Direction d)

    44

{

    45

	return (Direction)(4 ^ d);

    46

}

    47

    48

    49

/**

    50

 * Enumeration for the difference between two directions.

    51

 *

    52

 * This enumeration is used to mark differences between

    53

 * two directions. If you get one direction you can align

    54

 * a second direction in 8 different ways. This enumeration

    55

 * only contains 6 of these 8 differences, but the remaining

    56

 * two can be calculated by adding to differences together.

    57

 * This also means you can add two differences together and

    58

 * get the difference you really want to get. The difference

    59

 * of 45 degrees left + the difference of 45 degrees right results in the

    60

 * difference of 0 degrees.

    61

 *

    62

 * @note To get this mentioned addition of direction you must use

    63

 *       modulo DIR_END or use the #ChangeDirDiff(DirDiff, DirDiff) function.

    64

 * @see ChangeDirDiff(DirDiff, DirDiff)

    65

 */

    66

enum DirDiff {

    67

	DIRDIFF_SAME    = 0,    ///< Both directions faces to the same direction

    68

	DIRDIFF_45RIGHT = 1,    ///< Angle of 45 degrees right

    69

	DIRDIFF_90RIGHT = 2,    ///< Angle of 90 degrees right

    70

	DIRDIFF_REVERSE = 4,    ///< One direction is the opposit of the other one

    71

	DIRDIFF_90LEFT  = 6,    ///< Angle of 90 degrees left

    72

	DIRDIFF_45LEFT  = 7     ///< Angle of 45 degrees left

    73

};

    74

    75

/**

    76

 * Calculate the difference between to directions

    77

 *

    78

 * @param d0 The first direction as the base

    79

 * @param d1 The second direction as the offset from the base

    80

 * @return The difference how the second directions drifts of the first one.

    81

 */

    82

static inline DirDiff DirDifference(Direction d0, Direction d1)

    83

{

    84

	return (DirDiff)((d0 + 8 - d1) % 8);

    85

}

    86

    87

/**

    88

 * Applies two differences together

    89

 *

    90

 * This function adds two differences together and return the resulting

    91

 * difference. So adding two DIRDIFF_REVERSE together results in the

    92

 * DIRDIFF_SAME difference.

    93

 *

    94

 * @param d The first difference

    95

 * @param delta The second difference to add on

    96

 * @return The resulting difference

    97

 */

    98

static inline DirDiff ChangeDirDiff(DirDiff d, DirDiff delta)

    99

{

   100

	return (DirDiff)((d + delta) % 8);

   101

}

   102

   103

/**

   104

 * Change a direction by a given difference

   105

 *

   106

 * This functions returns a new direction of the given direction

   107

 * which is rotated by the given difference.

   108

 *

   109

 * @param d The direction to get a new direction from

   110

 * @param delta The offset/drift applied to the direction

   111

 * @return The new direction

   112

 */

   113

static inline Direction ChangeDir(Direction d, DirDiff delta)

   114

{

   115

	return (Direction)((d + delta) % 8);

   116

}

   117

   118

   119

/**

   120

 * Enumeration for diagonal directions.

   121

 *

   122

 * This enumeration is used for the 4 direction of the tile-edges.

   123

 */

   124

enum DiagDirection {

   125

	DIAGDIR_BEGIN = 0,      ///< Used for iterations

   126

	DIAGDIR_NE  = 0,        ///< Northeast, upper right on your monitor

   127

	DIAGDIR_SE  = 1,        ///< Southeast

   128

	DIAGDIR_SW  = 2,        ///< Southwest

   129

	DIAGDIR_NW  = 3,        ///< Northwest

   130

	DIAGDIR_END,            ///< Used for iterations

   131

	INVALID_DIAGDIR = 0xFF, ///< Flag for an invalid DiagDirection

   132

};

   133

   134

DECLARE_POSTFIX_INCREMENT(DiagDirection);

   135

   136

/** Define basic enum properties */

   137

template <> struct EnumPropsT<DiagDirection> : MakeEnumPropsT<DiagDirection, byte, DIAGDIR_BEGIN, DIAGDIR_END, INVALID_DIAGDIR> {};

   138

typedef TinyEnumT<DiagDirection> DiagDirectionByte; //typedefing-enumification of DiagDirection

   139

   140

/**

   141

 * Returns the reverse direction of the given DiagDirection

   142

 *

   143

 * @param d The DiagDirection to get the reverse from

   144

 * @return The reverse direction

   145

 */

   146

static inline DiagDirection ReverseDiagDir(DiagDirection d)

   147

{

   148

	return (DiagDirection)(2 ^ d);

   149

}

   150

   151

/**

   152

 * Enumeration for the difference between to DiagDirection.

   153

 *

   154

 * As the DiagDirection only contains 4 possible directions the

   155

 * difference between two of these directions can only be in 4 ways.

   156

 * As the DirDiff enumeration the values can be added together and

   157

 * you will get the resulting difference (use modulo DIAGDIR_END).

   158

 *

   159

 * @see DirDiff

   160

 */

   161

enum DiagDirDiff {

   162

	DIAGDIRDIFF_SAME    = 0,        ///< Same directions

   163

	DIAGDIRDIFF_90RIGHT = 1,        ///< 90 degrees right

   164

	DIAGDIRDIFF_REVERSE = 2,        ///< Reverse directions

   165

	DIAGDIRDIFF_90LEFT  = 3         ///< 90 degrees left

   166

};

   167

   171

/**

   172

 * Applies a difference on a DiagDirection

   173

 *

   174

 * This function applies a difference on a DiagDirection and returns

   175

 * the new DiagDirection.

   176

 *

   177

 * @param d The DiagDirection

   178

 * @param delta The difference to applie on

   179

 * @return The new direction which was calculated

   180

 */

   181

static inline DiagDirection ChangeDiagDir(DiagDirection d, DiagDirDiff delta)

   182

{

   183

	return (DiagDirection)((d + delta) % 4);

   184

}

   185

   186

/**

   187

 * Convert a Direction to a DiagDirection.

   188

 *

   189

 * This function can be used to convert the 8-way Direction to

   190

 * the 4-way DiagDirection. If the direction cannot be mapped its

   191

 * "rounded clockwise". So DIR_N becomes DIAGDIR_NE.

   192

 *

   193

 * @param dir The direction to convert

   194

 * @return The resulting DiagDirection, maybe "rounded clockwise".

   195

 */

   196

static inline DiagDirection DirToDiagDir(Direction dir)

   197

{

   198

	return (DiagDirection)(dir >> 1);

   199

}

   200

   201

/**

   202

 * Convert a DiagDirection to a Direction.

   203

 *

   204

 * This function can be used to convert the 4-way DiagDirection

   205

 * to the 8-way Direction. As 4-way are less than 8-way not all

   206

 * possible directions can be calculated.

   207

 *

   208

 * @param dir The direction to convert

   209

 * @return The resulting Direction

   210

 */

   211

static inline Direction DiagDirToDir(DiagDirection dir)

   212

{

   213

	return (Direction)(dir * 2 + 1);

   214

}

   215

   216

   217

/**

   218

 * Enumeration for the two axis X and Y

   219

 *

   220

 * This enumeration represente the two axis X and Y in the game.

   221

 * The X axis is the one which goes align the north-west edge

   222

 * (and south-east edge). The Y axis must be so the one which goes

   223

 * align the north-east edge (and south-west) edge.

   224

 */

   225

enum Axis {

   226

	AXIS_X = 0,     ///< The X axis

   227

	AXIS_Y = 1,     ///< The y axis

   228

	AXIS_END        ///< Used for iterations

   229

};

   230

   231

   232

/**

   233

 * Select the other axis as provided.

   234

 *

   235

 * This is basically the not-operator for the axis.

   236

 *

   237

 * @param a The given axis

   238

 * @return The other axis

   239

 */

   240

static inline Axis OtherAxis(Axis a)

   241

{

   242

	return (Axis)(a ^ 1);

   243

}

   244

   245

   246

/**

   247

 * Convert a DiagDirection to the axis.

   248

 *

   249

 * This function returns the axis which belongs to the given

   250

 * DiagDirection. The axis X belongs to the DiagDirection

   251

 * north-east and south-west.

   252

 *

   253

 * @param d The DiagDirection

   254

 * @return The axis which belongs to the direction

   255

 */

   256

static inline Axis DiagDirToAxis(DiagDirection d)

   257

{

   258

	return (Axis)(d & 1);

   259

}

   260

   261

   262

/**

   263

 * Converts an Axis to a DiagDirection

   264

 *

   265

 * This function returns the DiagDirection which

   266

 * belongs to the axis. As 2 directions are mapped to an axis

   267

 * this function returns the one which points to south,

   268

 * either south-west (on X axis) or south-east (on Y axis)

   269

 *

   270

 * @param a The axis

   271

 * @return The direction pointed to south

   272

 */

   273

static inline DiagDirection AxisToDiagDir(Axis a)

   274

{

   275

	return (DiagDirection)(2 - a);

   276

}

   277

   278

/**

   279

 * Convert an axis and a flag for north/south into a DiagDirection

   280

 * @param xy axis to convert

   281

 * @param ns north -> 0, south -> 1

   282

 * @return the desired DiagDirection

   283

 */

   284

static inline DiagDirection XYNSToDiagDir(Axis xy, uint ns)

   285

{

   286

	return (DiagDirection)(xy * 3 ^ ns * 2);

   287

}

   288

   289

/**

   290

 * Checks if an interger value is a valid DiagDirection

   291

 *

   292

 * @param d The value to check

   293

 * @return True if the value belongs to a DiagDirection, else false

   294

 */

   295

static inline bool IsValidDiagDirection(DiagDirection d)

   296

{

   297

	return d < DIAGDIR_END;

   298

}

   299

   300

/**

   301

 * Checks if an integer value is a valid Direction

   302

 *

   303

 * @param d The value to check

   304

 * @return True if the value belongs to a Direction, else false

   305

 */

   306

static inline bool IsValidDirection(Direction d)

   307

{

   308

	return d < DIR_END;

   309

}

   310

   311

/**

   312

 * Checks if an integer value is a valid Axis

   313

 *

   314

 * @param d The value to check

   315

 * @return True if the value belongs to an Axis, else false

   316

 */

   317

static inline bool IsValidAxis(Axis d)

   318

{

   319

	return d < AXIS_END;

   320

}

   321

   322

#endif /* DIRECTION_H */