1

/* $Id$ */

     2

     3

#ifndef MACROS_H

     4

#define MACROS_H

     5

     6

#include "map.h"

     7

     8

#ifdef min

     9

#undef min

    10

#endif

    11

    12

#ifdef max

    13

#undef max

    14

#endif

    15

    16

static inline int min(int a, int b) { if (a <= b) return a; return b; }

    17

static inline int max(int a, int b) { if (a >= b) return a; return b; }

    18

static inline int64 max64(int64 a, int64 b) { if (a >= b) return a; return b; }

    19

    20

static inline uint minu(uint a, uint b) { if (a <= b) return a; return b; }

    21

static inline uint maxu(uint a, uint b) { if (a >= b) return a; return b; }

    22

    23

    24

static inline int clamp(int a, int min, int max)

    25

{

    26

	if (a <= min) return min;

    27

	if (a >= max) return max;

    28

	return a;

    29

}

    30

    31

    32

static inline int32 BIGMULSS(int32 a, int32 b, int shift) {

    33

	return (int32)(((int64)(a) * (int64)(b)) >> (shift));

    34

}

    35

    36

static inline int64 BIGMULSS64(int64 a, int64 b, int shift) {

    37

	return ((a) * (b)) >> (shift);

    38

}

    39

    40

static inline uint32 BIGMULUS(uint32 a, uint32 b, int shift) {

    41

	return (uint32)(((uint64)(a) * (uint64)(b)) >> (shift));

    42

}

    43

    44

static inline int64 BIGMULS(int32 a, int32 b) {

    45

	return (int32)(((int64)(a) * (int64)(b)));

    46

}

    47

    48

/* OPT: optimized into an unsigned comparison */

    49

//#define IS_INSIDE_1D(x, base, size) ((x) >= (base) && (x) < (base) + (size))

    50

#define IS_INSIDE_1D(x, base, size) ( (uint)((x) - (base)) < ((uint)(size)) )

    51

    52

    53

#define HASBIT(x,y)    ((x) &   (1 << (y)))

    54

#define SETBIT(x,y)    ((x) |=  (1 << (y)))

    55

#define CLRBIT(x,y)    ((x) &= ~(1 << (y)))

    56

#define TOGGLEBIT(x,y) ((x) ^=  (1 << (y)))

    57

    58

// checking more bits. Maybe unneccessary, but easy to use

    59

#define HASBITS(x,y) ((x) & (y))

    60

#define SETBITS(x,y) ((x) |= (y))

    61

#define CLRBITS(x,y) ((x) &= ~(y))

    62

    63

#define PLAYER_SPRITE_COLOR(owner) ( (_player_colors[owner] + 0x307) << PALETTE_SPRITE_START)

    64

#define SPRITE_PALETTE(x) ((x) | PALETTE_MODIFIER_COLOR)

    65

    66

extern const byte _ffb_64[128];

    67

/* Returns the position of the first bit that is not zero, counted from the

    68

 * left. Ie, 10110100 returns 2, 00000001 returns 0, etc. When x == 0 returns

    69

 * 0.

    70

 */

    71

#define FIND_FIRST_BIT(x) _ffb_64[(x)]

    72

/* Returns x with the first bit that is not zero, counted from the left, set

    73

 * to zero. So, 10110100 returns 10110000, 00000001 returns 00000000, etc.

    74

 */

    75

#define KILL_FIRST_BIT(x) _ffb_64[(x)+64]

    76

    77

static inline int FindFirstBit2x64(int value)

    78

{

    79

/*

    80

	int i = 0;

    81

	if ( (byte) value == 0) {

    82

		i += 8;

    83

		value >>= 8;

    84

	}

    85

	return i + FIND_FIRST_BIT(value & 0x3F);

    86

    87

Faster ( or at least cleaner ) implementation below?

    88

*/

    89

	if ( (byte) value == 0) {

    90

		return FIND_FIRST_BIT((value >> 8) & 0x3F) + 8;

    91

	} else {

    92

		return FIND_FIRST_BIT(value & 0x3F);

    93

	}

    94

    95

}

    96

    97

static inline int KillFirstBit2x64(int value)

    98

{

    99

	if ( (byte) value == 0) {

   100

		return KILL_FIRST_BIT((value >> 8) & 0x3F) << 8;

   101

	} else {

   102

		return value & (KILL_FIRST_BIT(value & 0x3F)|0x3F00);

   103

	}

   104

}

   105

   106

/* [min,max), strictly less than */

   107

#define IS_BYTE_INSIDE(a,min,max) ((byte)((a)-(min)) < (byte)((max)-(min)))

   108

#define IS_INT_INSIDE(a,min,max) ((uint)((a)-(min)) < (uint)((max)-(min)))

   109

   110

   111

#define CHANCE16(a,b) ((uint16)Random() <= (uint16)((65536 * a) / b))

   112

#define CHANCE16R(a,b,r) ((uint16)(r=Random()) <= (uint16)((65536 * a) / b))

   113

#define CHANCE16I(a,b,v) ((uint16)(v) <= (uint16)((65536 * a) / b))

   114

   115

   116

#define for_each_bit(_i,_b)										\

   117

	for(_i=0; _b!=0; _i++,_b>>=1)								\

   118

		if (_b&1)

   119

   120

#define abs myabs

   121

   122

   123

static inline int intxchg_(int *a, int b) { int t = *a; *a = b; return t; }

   124

#define intswap(a,b) ((b) = intxchg_(&(a), (b)))

   125

static inline int uintxchg_(uint *a, uint b) { uint t = *a; *a = b; return t; }

   126

#define uintswap(a,b) ((b) = uintxchg_(&(a), (b)))

   127

   128

static inline int myabs(int a) { if (a<0) a = -a; return a; }

   129

static inline int64 myabs64(int64 a) { if (a<0) a = -a; return a; }

   130

   131

static inline void swap_byte(byte *a, byte *b) { byte t = *a; *a = *b; *b = t; }

   132

static inline void swap_uint16(uint16 *a, uint16 *b) { uint16 t = *a; *a = *b; *b = t; }

   133

static inline void swap_int16(int16 *a, int16 *b) { int16 t = *a; *a = *b; *b = t; }

   134

static inline void swap_int32(int32 *a, int32 *b) { int32 t = *a; *a = *b; *b = t; }

   135

static inline void swap_tile(TileIndex *a, TileIndex *b) { TileIndex t = *a; *a = *b; *b = t; }

   136

   137

   138

   139

#if defined(TTD_LITTLE_ENDIAN)

   140

#	define READ_LE_UINT16(b) (*(const uint16*)(b))

   141

#elif defined(TTD_BIG_ENDIAN)

   142

	static inline uint16 READ_LE_UINT16(const void *b) {

   143

		return ((const byte*)b)[0] + (((const byte*)b)[1] << 8);

   144

	}

   145

#endif

   146

   147

/// Fetch n bits starting at bit s from x

   148

#define GB(x, s, n) (((x) >> (s)) & ((1U << (n)) - 1))

   149

/// Set n bits starting at bit s in x to d

   150

#define SB(x, s, n, d) ((x) = ((x) & ~(((1U << (n)) - 1) << (s))) | ((d) << (s)))

   151

/// Add i to the n bits starting at bit s in x

   152

#define AB(x, s, n, i) ((x) = ((x) & ~(((1U << (n)) - 1) << (s))) | (((x) + ((i) << (s))) & (((1U << (n)) - 1) << (s))))

   153

   154

/**

   155

 * ROtate x Left/Right by n (must be >= 0)

   156

 * @note Assumes a byte has 8 bits

   157

 */

   158

#define ROL(x, n) ((x) << (n) | (x) >> (sizeof(x) * 8 - (n)))

   159

#define ROR(x, n) ((x) >> (n) | (x) << (sizeof(x) * 8 - (n)))

   160

   161

/**

   162

 * Return the smallest multiple of n equal or greater than x

   163

 * @note n must be a power of 2

   164

 */

   165

#define ALIGN(x, n) (((x) + (n) - 1) & ~((n) - 1))

   166

   167

/* IS_INT_INSIDE = filter for ascii-function codes like BELL and so on [we need an special filter here later] */

   168

static inline bool IsValidAsciiChar(byte key)

   169

{

   170

	return IS_INT_INSIDE(key, ' ', 256);

   171

}

   172

   173

#endif /* MACROS_H */