1

/* $Id$ */

     2

     3

/** @file direction_func.h Different functions related to conversions between directions. */

     4

     5

#ifndef DIRECTION_FUNC_H

     6

#define DIRECTION_FUNC_H

     7

     8

#include "direction_type.h"

     9

    10

/**

    11

 * Return the reverse of a direction

    12

 *

    13

 * @param d The direction to get the reverse from

    14

 * @return The reverse Direction

    15

 */

    16

static inline Direction ReverseDir(Direction d)

    17

{

    18

	return (Direction)(4 ^ d);

    19

}

    20

    21

    22

/**

    23

 * Calculate the difference between to directions

    24

 *

    25

 * @param d0 The first direction as the base

    26

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

    27

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

    28

 */

    29

static inline DirDiff DirDifference(Direction d0, Direction d1)

    30

{

    31

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

    32

}

    33

    34

/**

    35

 * Applies two differences together

    36

 *

    37

 * This function adds two differences together and return the resulting

    38

 * difference. So adding two DIRDIFF_REVERSE together results in the

    39

 * DIRDIFF_SAME difference.

    40

 *

    41

 * @param d The first difference

    42

 * @param delta The second difference to add on

    43

 * @return The resulting difference

    44

 */

    45

static inline DirDiff ChangeDirDiff(DirDiff d, DirDiff delta)

    46

{

    47

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

    48

}

    49

    50

/**

    51

 * Change a direction by a given difference

    52

 *

    53

 * This functions returns a new direction of the given direction

    54

 * which is rotated by the given difference.

    55

 *

    56

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

    57

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

    58

 * @return The new direction

    59

 */

    60

static inline Direction ChangeDir(Direction d, DirDiff delta)

    61

{

    62

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

    63

}

    64

    65

    66

/**

    67

 * Returns the reverse direction of the given DiagDirection

    68

 *

    69

 * @param d The DiagDirection to get the reverse from

    70

 * @return The reverse direction

    71

 */

    72

static inline DiagDirection ReverseDiagDir(DiagDirection d)

    73

{

    74

	return (DiagDirection)(2 ^ d);

    75

}

    76

    77

    78

/**

    79

 * Applies a difference on a DiagDirection

    80

 *

    81

 * This function applies a difference on a DiagDirection and returns

    82

 * the new DiagDirection.

    83

 *

    84

 * @param d The DiagDirection

    85

 * @param delta The difference to applie on

    86

 * @return The new direction which was calculated

    87

 */

    88

static inline DiagDirection ChangeDiagDir(DiagDirection d, DiagDirDiff delta)

    89

{

    90

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

    91

}

    92

    93

/**

    94

 * Convert a Direction to a DiagDirection.

    95

 *

    96

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

    97

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

    98

 * "rounded clockwise". So DIR_N becomes DIAGDIR_NE.

    99

 *

   100

 * @param dir The direction to convert

   101

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

   102

 */

   103

static inline DiagDirection DirToDiagDir(Direction dir)

   104

{

   105

	return (DiagDirection)(dir >> 1);

   106

}

   107

   108

/**

   109

 * Convert a DiagDirection to a Direction.

   110

 *

   111

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

   112

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

   113

 * possible directions can be calculated.

   114

 *

   115

 * @param dir The direction to convert

   116

 * @return The resulting Direction

   117

 */

   118

static inline Direction DiagDirToDir(DiagDirection dir)

   119

{

   120

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

   121

}

   122

   123

   124

/**

   125

 * Select the other axis as provided.

   126

 *

   127

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

   128

 *

   129

 * @param a The given axis

   130

 * @return The other axis

   131

 */

   132

static inline Axis OtherAxis(Axis a)

   133

{

   134

	return (Axis)(a ^ 1);

   135

}

   136

   137

   138

/**

   139

 * Convert a DiagDirection to the axis.

   140

 *

   141

 * This function returns the axis which belongs to the given

   142

 * DiagDirection. The axis X belongs to the DiagDirection

   143

 * north-east and south-west.

   144

 *

   145

 * @param d The DiagDirection

   146

 * @return The axis which belongs to the direction

   147

 */

   148

static inline Axis DiagDirToAxis(DiagDirection d)

   149

{

   150

	return (Axis)(d & 1);

   151

}

   152

   153

   154

/**

   155

 * Converts an Axis to a DiagDirection

   156

 *

   157

 * This function returns the DiagDirection which

   158

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

   159

 * this function returns the one which points to south,

   160

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

   161

 *

   162

 * @param a The axis

   163

 * @return The direction pointed to south

   164

 */

   165

static inline DiagDirection AxisToDiagDir(Axis a)

   166

{

   167

	return (DiagDirection)(2 - a);

   168

}

   169

   170

/**

   171

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

   172

 * @param xy axis to convert

   173

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

   174

 * @return the desired DiagDirection

   175

 */

   176

static inline DiagDirection XYNSToDiagDir(Axis xy, uint ns)

   177

{

   178

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

   179

}

   180

   181

/**

   182

 * Checks if an interger value is a valid DiagDirection

   183

 *

   184

 * @param d The value to check

   185

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

   186

 */

   187

static inline bool IsValidDiagDirection(DiagDirection d)

   188

{

   189

	return d < DIAGDIR_END;

   190

}

   191

   192

/**

   193

 * Checks if an integer value is a valid Direction

   194

 *

   195

 * @param d The value to check

   196

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

   197

 */

   198

static inline bool IsValidDirection(Direction d)

   199

{

   200

	return d < DIR_END;

   201

}

   202

   203

/**

   204

 * Checks if an integer value is a valid Axis

   205

 *

   206

 * @param d The value to check

   207

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

   208

 */

   209

static inline bool IsValidAxis(Axis d)

   210

{

   211

	return d < AXIS_END;

   212

}

   213

   214

#endif /* DIRECTION_H */