0
|
1 |
#ifndef MACROS_H
|
|
2 |
#define MACROS_H
|
|
3 |
|
|
4 |
#define MAX_INT 0x7FFFFFFF
|
|
5 |
|
|
6 |
#ifdef min
|
|
7 |
#undef min
|
|
8 |
#endif
|
|
9 |
|
|
10 |
#ifdef max
|
|
11 |
#undef max
|
|
12 |
#endif
|
|
13 |
|
|
14 |
static INLINE int min(int a, int b) { if (a <= b) return a; return b; }
|
|
15 |
static INLINE int max(int a, int b) { if (a >= b) return a; return b; }
|
|
16 |
|
|
17 |
static INLINE uint minu(uint a, uint b) { if (a <= b) return a; return b; }
|
|
18 |
static INLINE uint maxu(uint a, uint b) { if (a >= b) return a; return b; }
|
|
19 |
|
|
20 |
|
|
21 |
static INLINE int clamp(int a, int min, int max) { if (a <= min) return min; if (a >= max) return max; return a; }
|
|
22 |
static INLINE int clamp2(int a, int min, int max) { if (a <= min) a=min; if (a >= max) a=max; return a; }
|
|
23 |
static INLINE bool int32_add_overflow(int32 a, int32 b) { return (int32)(a^b)>=0 && (int32)(a^(a+b))<0; }
|
|
24 |
static INLINE bool int32_sub_overflow(int32 a, int32 b) { return (int32)(a^b)<0 && (int32)(a^(a-b))<0; }
|
|
25 |
|
|
26 |
static INLINE bool str_eq(const byte *a, const byte *b)
|
|
27 |
{
|
|
28 |
int i=0;
|
|
29 |
while (a[i] == b[i]) {
|
|
30 |
if (a[i] == 0)
|
|
31 |
return true;
|
|
32 |
i++;
|
|
33 |
}
|
|
34 |
return false;
|
|
35 |
}
|
|
36 |
|
|
37 |
// Will crash if strings are equal
|
|
38 |
static INLINE bool str_is_below(byte *a, byte *b) {
|
|
39 |
while (*a <= *b) {
|
|
40 |
if (*a < *b) return true;
|
|
41 |
a++;
|
|
42 |
b++;
|
|
43 |
}
|
|
44 |
return false;
|
|
45 |
}
|
|
46 |
|
|
47 |
|
|
48 |
static INLINE int32 BIGMULSS(int32 a, int32 b, int shift) {
|
|
49 |
return (int32)(((int64)(a) * (int64)(b)) >> (shift));
|
|
50 |
}
|
|
51 |
|
|
52 |
static INLINE uint32 BIGMULUS(uint32 a, uint32 b, int shift) {
|
|
53 |
return (uint32)(((uint64)(a) * (uint64)(b)) >> (shift));
|
|
54 |
}
|
|
55 |
|
|
56 |
static INLINE int64 BIGMULS(int32 a, int32 b) {
|
|
57 |
return (int32)(((int64)(a) * (int64)(b)));
|
|
58 |
}
|
|
59 |
|
|
60 |
/* OPT: optimized into an unsigned comparison */
|
|
61 |
//#define IS_INSIDE_1D(x, base, size) ((x) >= (base) && (x) < (base) + (size))
|
|
62 |
#define IS_INSIDE_1D(x, base, size) ( (uint)((x) - (base)) < ((uint)(size)) )
|
|
63 |
|
|
64 |
#define TILE_X_BITS 8
|
|
65 |
#define TILE_Y_BITS 8
|
|
66 |
#define LANDSCAPE_SIZE_FACTOR 1
|
|
67 |
|
|
68 |
#define TILE_FROM_XY(x,y) (int)((((y) >> 4) << TILE_X_BITS) + ((x) >> 4))
|
|
69 |
#define TILE_XY(x,y) (int)(((y) << TILE_X_BITS) + (x))
|
|
70 |
|
|
71 |
#define IS_TILETYPE(_t_, _s_) (_map_type_and_height[(_t_)] >> 4 == (_s_))
|
|
72 |
#define GET_TILETYPE(_t_) (_map_type_and_height[(_t_)] >> 4)
|
|
73 |
#define GET_TILEHEIGHT(_t_) ((_map_type_and_height[_t_] & 0xF) * 8)
|
|
74 |
|
|
75 |
enum {
|
|
76 |
CORRECT_Z_BITS = 1 << 1 | 1 << 2 | 1 << 3 | 1 << 4 | 1 << 5 | 1 << 6 | 1 << 7
|
|
77 |
};
|
|
78 |
#define CORRECT_Z(tileh) (CORRECT_Z_BITS & (1 << tileh))
|
|
79 |
|
|
80 |
#define TILES_X (1 << TILE_X_BITS)
|
|
81 |
#define TILES_Y (1 << TILE_Y_BITS)
|
|
82 |
|
|
83 |
#define TILE_X_MAX (TILES_X-1)
|
|
84 |
#define TILE_Y_MAX (TILES_Y-1)
|
|
85 |
|
|
86 |
#define TILE_ASSERT(x) assert( TILE_MASK(x) == (x) );
|
|
87 |
|
|
88 |
extern uint SafeTileAdd(uint x, int add, const char *exp, const char *file, int line);
|
|
89 |
|
|
90 |
#if !defined(_DEBUG) || TILE_X_BITS != 8
|
|
91 |
# define TILE_ADD(x,y) ((x)+(y))
|
|
92 |
#else
|
|
93 |
# if defined(__GNUC__)
|
|
94 |
# define TILE_ADD(x,y) (SafeTileAdd((x),(y), "??", __FILE__, __LINE__))
|
|
95 |
# else
|
|
96 |
# define TILE_ADD(x,y) (SafeTileAdd((x),(y), #x ## ", " ## #y, __FILE__, __LINE__))
|
|
97 |
# endif
|
|
98 |
#endif
|
|
99 |
|
|
100 |
#define TILE_ADDXY(tile, x, y) TILE_ADD(tile, TILE_XY(x,y))
|
|
101 |
|
|
102 |
#if TILE_X_BITS == 8
|
|
103 |
#define GET_TILE_X(t) (uint)((byte)(t))
|
|
104 |
#define GET_TILE_Y(t) (uint)((t) >> 8)
|
|
105 |
#define TILE_MASK(x) ((uint16)(x))
|
|
106 |
#else
|
|
107 |
#define GET_TILE_X(t) (uint)((t) & ((1 << TILE_X_BITS)-1))
|
|
108 |
#define GET_TILE_Y(t) (uint)((t) >> TILE_X_BITS)
|
|
109 |
#define TILE_MASK(x) (int)((x) & ((1 << (TILE_X_BITS + TILE_Y_BITS))-1))
|
|
110 |
#endif
|
|
111 |
|
|
112 |
//#define REMADP_COORDS(x,y,z) { int t = x; x = (y-t)*2; y+=t-z; }
|
|
113 |
|
|
114 |
#define PACK_POINT(x,y) ((x) | ((y) << 16))
|
|
115 |
#define UNPACK_POINT_X(p) ((uint16)(p))
|
|
116 |
#define UNPACK_POINT_Y(p) ((uint16)(p>>16))
|
|
117 |
|
|
118 |
#define PACK_PPOINT(p) PACK_POINT((p).x, (p).y)
|
|
119 |
|
|
120 |
#define HASBIT(x,y) ((x) & (1 << (y)))
|
|
121 |
#define SETBIT(x,y) ((x) |= (1 << (y)))
|
|
122 |
#define CLRBIT(x,y) ((x) &= ~(1 << (y)))
|
|
123 |
|
|
124 |
// checking more bits. Maybe unneccessary, but easy to use
|
|
125 |
#define HASBITS(x,y) ((x) & (y))
|
|
126 |
#define SETBITS(x,y) ((x) |= (y))
|
|
127 |
#define CLRBITS(x,y) ((x) &= ~(y))
|
|
128 |
|
|
129 |
#define PLAYER_SPRITE_COLOR(owner) ((_player_colors[owner] << 16) + 0x3070000)
|
|
130 |
#define SPRITE_PALETTE(x) ((x) + 0x8000)
|
|
131 |
|
|
132 |
extern const byte _ffb_64[128];
|
|
133 |
#define FIND_FIRST_BIT(x) _ffb_64[(x)]
|
|
134 |
#define KILL_FIRST_BIT(x) _ffb_64[(x)+64]
|
|
135 |
|
|
136 |
static INLINE int FindFirstBit2x64(int value)
|
|
137 |
{
|
|
138 |
int i = 0;
|
|
139 |
if ( (byte) value == 0) {
|
|
140 |
i += 8;
|
|
141 |
value >>= 8;
|
|
142 |
}
|
|
143 |
return i + FIND_FIRST_BIT(value & 0x3F);
|
|
144 |
}
|
|
145 |
|
|
146 |
|
|
147 |
#if TILE_X_BITS + TILE_Y_BITS <= 16
|
|
148 |
typedef uint16 TileIndex;
|
|
149 |
typedef int16 TileIndexDiff;
|
|
150 |
#else
|
|
151 |
typedef uint32 TileIndex;
|
|
152 |
typedef int32 TileIndexDiff;
|
|
153 |
#endif
|
|
154 |
|
|
155 |
/* [min,max), strictly less than */
|
|
156 |
#define IS_BYTE_INSIDE(a,min,max) ((byte)((a)-(min)) < (byte)((max)-(min)))
|
|
157 |
#define IS_INT_INSIDE(a,min,max) ((uint)((a)-(min)) < (uint)((max)-(min)))
|
|
158 |
|
|
159 |
|
|
160 |
#define CHANCE16(a,b) ((uint16)Random() <= (uint16)((65536 * a) / b))
|
|
161 |
#define CHANCE16R(a,b,r) ((uint16)(r=Random()) <= (uint16)((65536 * a) / b))
|
|
162 |
#define CHANCE16I(a,b,v) ((uint16)(v) <= (uint16)((65536 * a) / b))
|
|
163 |
|
|
164 |
#define BEGIN_TILE_LOOP(var,w,h,tile) \
|
|
165 |
{int h_cur = h; \
|
|
166 |
uint var = tile; \
|
|
167 |
do { \
|
|
168 |
int w_cur = w; \
|
|
169 |
do {
|
|
170 |
|
|
171 |
#define END_TILE_LOOP(var,w,h,tile) \
|
|
172 |
} while (++var, --w_cur != 0); \
|
|
173 |
} while (var += TILE_XY(0,1) - (w), --h_cur != 0);}
|
|
174 |
|
|
175 |
|
|
176 |
#define for_each_bit(_i,_b) \
|
|
177 |
for(_i=0; _b!=0; _i++,_b>>=1) \
|
|
178 |
if (_b&1)
|
|
179 |
|
|
180 |
#define assert_array(i,j) assert(i < lengthof(j))
|
|
181 |
|
|
182 |
#define abs myabs
|
|
183 |
|
|
184 |
|
|
185 |
static INLINE int intxchg_(int *a, int b) { int t = *a; *a = b; return t; }
|
|
186 |
#define intxchg(a,b) intxchg_(&(a), (b))
|
|
187 |
#define intswap(a,b) ((b) = intxchg_(&(a), (b)))
|
|
188 |
|
|
189 |
static INLINE int myabs(int a) { if (a<0) a = -a; return a; }
|
|
190 |
|
|
191 |
static INLINE void swap_byte(byte *a, byte *b) { byte t = *a; *a = *b; *b = t; }
|
|
192 |
static INLINE void swap_uint16(uint16 *a, uint16 *b) { uint16 t = *a; *a = *b; *b = t; }
|
|
193 |
static INLINE void swap_int16(int16 *a, int16 *b) { int16 t = *a; *a = *b; *b = t; }
|
|
194 |
static INLINE void swap_tile(TileIndex *a, TileIndex *b) { TileIndex t = *a; *a = *b; *b = t; }
|
|
195 |
|
|
196 |
|
|
197 |
|
|
198 |
#if defined(TTD_LITTLE_ENDIAN)
|
|
199 |
# define READ_LE_UINT16(b) (*(uint16*)(b))
|
|
200 |
# define ADD_WORD(x) (x)&0xFF, ((x) >> 8)&0xFF
|
|
201 |
# define ADD_DWORD(x) (x)&0xFF, ((x) >> 8)&0xFF, ((x) >> 16)&0xFF, ((x) >> 24)&0xFF
|
|
202 |
#elif defined(TTD_BIG_ENDIAN)
|
|
203 |
static INLINE uint16 READ_LE_UINT16(const void *b) {
|
|
204 |
return ((byte*)b)[0] + (((byte*)b)[1] << 8);
|
|
205 |
}
|
|
206 |
# define ADD_WORD(x) ((x) >> 8)&0xFF, (x)&0xFF
|
|
207 |
# define ADD_DWORD(x) ((x) >> 24)&0xFF, ((x) >> 16)&0xFF, ((x) >> 8)&0xFF, (x)&0xFF
|
|
208 |
#endif
|
|
209 |
|
|
210 |
static INLINE void WRITE_LE_UINT16(const void *b, uint16 x) {
|
|
211 |
((byte*)b)[0] = (byte)x;
|
|
212 |
((byte*)b)[1] = (byte)(x >> 8);
|
|
213 |
}
|
|
214 |
|
|
215 |
#endif /* MACROS_H */
|