1

/* $Id$ */

     2

     3

#ifndef DIRECTION_H

     4

#define DIRECTION_H

     5

     6

#include "helpers.hpp"

     7

     8

/* Direction as commonly used in v->direction, 8 way. */

     9

typedef enum Direction {

    10

	DIR_BEGIN = 0,

    11

	DIR_N   = 0,

    12

	DIR_NE  = 1,      /* Northeast, upper right on your monitor */

    13

	DIR_E   = 2,

    14

	DIR_SE  = 3,

    15

	DIR_S   = 4,

    16

	DIR_SW  = 5,

    17

	DIR_W   = 6,

    18

	DIR_NW  = 7,

    19

	DIR_END,

    20

	INVALID_DIR = 0xFF,

    21

} Direction;

    22

    23

/** Define basic enum properties */

    24

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

    25

typedef TinyEnumT<Direction> DirectionByte;

    26

    27

static inline Direction ReverseDir(Direction d)

    28

{

    29

	return (Direction)(4 ^ d);

    30

}

    31

    32

    33

typedef enum DirDiff {

    34

	DIRDIFF_SAME    = 0,

    35

	DIRDIFF_45RIGHT = 1,

    36

	DIRDIFF_90RIGHT = 2,

    37

	DIRDIFF_REVERSE = 4,

    38

	DIRDIFF_90LEFT  = 6,

    39

	DIRDIFF_45LEFT  = 7

    40

} DirDiff;

    41

    42

static inline DirDiff DirDifference(Direction d0, Direction d1)

    43

{

    44

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

    45

}

    46

    47

static inline DirDiff ChangeDirDiff(DirDiff d, DirDiff delta)

    48

{

    49

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

    50

}

    51

    52

    53

static inline Direction ChangeDir(Direction d, DirDiff delta)

    54

{

    55

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

    56

}

    57

    58

    59

/* Direction commonly used as the direction of entering and leaving tiles, 4-way */

    60

typedef enum DiagDirection {

    61

	DIAGDIR_BEGIN = 0,

    62

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

    63

	DIAGDIR_SE  = 1,

    64

	DIAGDIR_SW  = 2,

    65

	DIAGDIR_NW  = 3,

    66

	DIAGDIR_END,

    67

	INVALID_DIAGDIR = 0xFF,

    68

} DiagDirection;

    69

    70

DECLARE_POSTFIX_INCREMENT(DiagDirection);

    71

    72

/** Define basic enum properties */

    73

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

    74

typedef TinyEnumT<DiagDirection> DiagDirectionByte;

    75

    76

static inline DiagDirection ReverseDiagDir(DiagDirection d)

    77

{

    78

	return (DiagDirection)(2 ^ d);

    79

}

    80

    81

    82

typedef enum DiagDirDiff {

    83

	DIAGDIRDIFF_SAME    = 0,

    84

	DIAGDIRDIFF_90RIGHT = 1,

    85

	DIAGDIRDIFF_REVERSE = 2,

    86

	DIAGDIRDIFF_90LEFT  = 3

    87

} DiagDirDiff;

    88

    89

static inline DiagDirection ChangeDiagDir(DiagDirection d, DiagDirDiff delta)

    90

{

    91

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

    92

}

    93

    94

    95

static inline DiagDirection DirToDiagDir(Direction dir)

    96

{

    97

	return (DiagDirection)(dir >> 1);

    98

}

    99

   100

   101

static inline Direction DiagDirToDir(DiagDirection dir)

   102

{

   103

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

   104

}

   105

   106

   107

/* the 2 axis */

   108

typedef enum Axis {

   109

	AXIS_X = 0,

   110

	AXIS_Y = 1,

   111

	AXIS_END

   112

} Axis;

   113

   114

   115

static inline Axis OtherAxis(Axis a)

   116

{

   117

	return (Axis)(a ^ 1);

   118

}

   119

   120

   121

static inline Axis DiagDirToAxis(DiagDirection d)

   122

{

   123

	return (Axis)(d & 1);

   124

}

   125

   126

   127

/*

   128

 * Converts an Axis to a DiagDirection

   129

 * Points always in the positive direction, i.e. S[EW]

   130

 */

   131

static inline DiagDirection AxisToDiagDir(Axis a)

   132

{

   133

	return (DiagDirection)(2 - a);

   134

}

   135

   136

/**

   137

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

   138

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

   139

 */

   140

static inline DiagDirection XYNSToDiagDir(Axis xy, uint ns)

   141

{

   142

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

   143

}

   144

   145

   146

static inline bool IsValidDiagDirection(DiagDirection d)

   147

{

   148

	return d < DIAGDIR_END;

   149

}

   150

   151

static inline bool IsValidDirection(Direction d)

   152

{

   153

	return d < DIR_END;

   154

}

   155

   156

static inline bool IsValidAxis(Axis d)

   157

{

   158

	return d < AXIS_END;

   159

}

   160

   161

#endif /* DIRECTION_H */