1

/* $Id$ */

     2

     3

/** @file direction.h */

     4

     5

#ifndef DIRECTION_H

     6

#define DIRECTION_H

     7

     8

#include "helpers.hpp"

     9

    10

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

    11

enum Direction {

    12

	DIR_BEGIN = 0,

    13

	DIR_N   = 0,

    14

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

    15

	DIR_E   = 2,

    16

	DIR_SE  = 3,

    17

	DIR_S   = 4,

    18

	DIR_SW  = 5,

    19

	DIR_W   = 6,

    20

	DIR_NW  = 7,

    21

	DIR_END,

    22

	INVALID_DIR = 0xFF,

    23

};

    24

    25

/** Define basic enum properties */

    26

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

    27

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

    28

    29

static inline Direction ReverseDir(Direction d)

    30

{

    31

	return (Direction)(4 ^ d);

    32

}

    33

    34

    35

enum DirDiff {

    36

	DIRDIFF_SAME    = 0,

    37

	DIRDIFF_45RIGHT = 1,

    38

	DIRDIFF_90RIGHT = 2,

    39

	DIRDIFF_REVERSE = 4,

    40

	DIRDIFF_90LEFT  = 6,

    41

	DIRDIFF_45LEFT  = 7

    42

};

    43

    44

static inline DirDiff DirDifference(Direction d0, Direction d1)

    45

{

    46

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

    47

}

    48

    49

static inline DirDiff ChangeDirDiff(DirDiff d, DirDiff delta)

    50

{

    51

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

    52

}

    53

    54

    55

static inline Direction ChangeDir(Direction d, DirDiff delta)

    56

{

    57

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

    58

}

    59

    60

    61

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

    62

enum DiagDirection {

    63

	DIAGDIR_BEGIN = 0,

    64

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

    65

	DIAGDIR_SE  = 1,

    66

	DIAGDIR_SW  = 2,

    67

	DIAGDIR_NW  = 3,

    68

	DIAGDIR_END,

    69

	INVALID_DIAGDIR = 0xFF,

    70

};

    71

    72

DECLARE_POSTFIX_INCREMENT(DiagDirection);

    73

    74

/** Define basic enum properties */

    75

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

    76

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

    77

    78

static inline DiagDirection ReverseDiagDir(DiagDirection d)

    79

{

    80

	return (DiagDirection)(2 ^ d);

    81

}

    82

    83

    84

enum DiagDirDiff {

    85

	DIAGDIRDIFF_SAME    = 0,

    86

	DIAGDIRDIFF_90RIGHT = 1,

    87

	DIAGDIRDIFF_REVERSE = 2,

    88

	DIAGDIRDIFF_90LEFT  = 3

    89

};

    90

    91

static inline DiagDirection ChangeDiagDir(DiagDirection d, DiagDirDiff delta)

    92

{

    93

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

    94

}

    95

    96

    97

static inline DiagDirection DirToDiagDir(Direction dir)

    98

{

    99

	return (DiagDirection)(dir >> 1);

   100

}

   101

   102

   103

static inline Direction DiagDirToDir(DiagDirection dir)

   104

{

   105

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

   106

}

   107

   108

   109

/* the 2 axis */

   110

enum Axis {

   111

	AXIS_X = 0,

   112

	AXIS_Y = 1,

   113

	AXIS_END

   114

};

   115

   116

   117

static inline Axis OtherAxis(Axis a)

   118

{

   119

	return (Axis)(a ^ 1);

   120

}

   121

   122

   123

static inline Axis DiagDirToAxis(DiagDirection d)

   124

{

   125

	return (Axis)(d & 1);

   126

}

   127

   128

   129

/*

   130

 * Converts an Axis to a DiagDirection

   131

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

   132

 */

   133

static inline DiagDirection AxisToDiagDir(Axis a)

   134

{

   135

	return (DiagDirection)(2 - a);

   136

}

   137

   138

/**

   139

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

   140

 * @param xy axis to convert

   141

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

   142

 * @return the desired DiagDirection

   143

 */

   144

static inline DiagDirection XYNSToDiagDir(Axis xy, uint ns)

   145

{

   146

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

   147

}

   148

   149

   150

static inline bool IsValidDiagDirection(DiagDirection d)

   151

{

   152

	return d < DIAGDIR_END;

   153

}

   154

   155

static inline bool IsValidDirection(Direction d)

   156

{

   157

	return d < DIR_END;

   158

}

   159

   160

static inline bool IsValidAxis(Axis d)

   161

{

   162

	return d < AXIS_END;

   163

}

   164

   165

#endif /* DIRECTION_H */