1 #pragma once 2 3 //******************************************************************************************** 4 //* 5 //* This file is part of Egoboo. 6 //* 7 //* Egoboo is free software: you can redistribute it and/or modify it 8 //* under the terms of the GNU General Public License as published by 9 //* the Free Software Foundation, either version 3 of the License, or 10 //* (at your option) any later version. 11 //* 12 //* Egoboo is distributed in the hope that it will be useful, but 13 //* WITHOUT ANY WARRANTY; without even the implied warranty of 14 //* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 //* General Public License for more details. 16 //* 17 //* You should have received a copy of the GNU General Public License 18 //* along with Egoboo. If not, see <http://www.gnu.org/licenses/>. 19 //* 20 //******************************************************************************************** 21 22 /// @file egoboo_typedef.h 23 /// @details some basic types that are used throughout the game code. 24 25 #include "egoboo_config.h" 26 27 #include <SDL_types.h> 28 #include "egoboo_mem.h" 29 30 //-------------------------------------------------------------------------------------------- 31 // portable definition of assert. the c++ version can be activated below. 32 33 #include <assert.h> 34 #define C_EGOBOO_ASSERT(X) assert(X) 35 36 //-------------------------------------------------------------------------------------------- 37 // BOOLEAN 38 39 #if defined(__cplusplus) 40 typedef bool bool_t; 41 #define btrue true 42 #define bfalse false 43 #else 44 enum e_bool 45 { 46 btrue = ( 1 == 1 ), 47 bfalse = ( !btrue ) 48 }; 49 typedef enum e_bool bool_t; 50 #endif 51 52 //-------------------------------------------------------------------------------------------- 53 //-------------------------------------------------------------------------------------------- 54 55 /// special return values 56 enum e_egoboo_rv 57 { 58 rv_error = -1, 59 rv_fail = bfalse, 60 rv_success = btrue 61 }; 62 63 typedef enum e_egoboo_rv egoboo_rv; 64 65 //-------------------------------------------------------------------------------------------- 66 // 24.8 fixed point types 67 68 typedef Uint32 UFP8_T; 69 typedef Sint32 SFP8_T; 70 71 #define UFP8_TO_UINT(V1) ( ((unsigned)(V1)) >> 8 ) ///< fast version of V1 / 256 72 73 #define SFP8_TO_SINT(V1) ( (V1) < 0 ? -((signed)UFP8_TO_UINT(-V1)) : (signed)UFP8_TO_UINT(V1) ) 74 #define FP8_TO_FLOAT(V1) ( (float)(V1) * INV_0100 ) 75 #define FLOAT_TO_FP8(V1) ( (Uint32)((V1) * (float)(0x0100) ) ) 76 #define FP8_TO_INT(V1) ( (V1) >> 8 ) ///< fast version of V1 / 256 77 #define INT_TO_FP8(V1) ( (V1) << 8 ) ///< fast version of V1 * 256 78 #define FP8_MUL(V1, V2) ( ((V1)*(V2)) >> 8 ) ///< this may overflow if V1 or V2 have non-zero bits in their upper 8 bits 79 #define FP8_DIV(V1, V2) ( ((V1)<<8) / (V2) ) ///< this will fail if V1 has bits in the upper 8 bits 80 81 //-------------------------------------------------------------------------------------------- 82 // the type for the 16-bit value used to stor angles 83 typedef Uint16 FACING_T; 84 typedef FACING_T TURN_T; 85 86 #define TO_FACING(X) ((FACING_T)(X)) 87 #define TO_TURN(X) ((TURN_T)((TO_FACING(X)>>2) & TRIG_TABLE_MASK)) 88 89 //-------------------------------------------------------------------------------------------- 90 // 16.16 fixed point types 91 92 typedef Uint32 UFP16_T; 93 typedef Sint32 SFP16_T; 94 95 #define FLOAT_TO_FP16( V1 ) ( (Uint32)((V1) * 0x00010000) ) 96 #define FP16_TO_FLOAT( V1 ) ( (float )((V1) * 0.0000152587890625f ) ) 97 98 //-------------------------------------------------------------------------------------------- 99 // BIT FIELDS 100 typedef Uint32 BIT_FIELD; ///< A big string supporting 32 bits 101 #define FULL_BIT_FIELD 0x7FFFFFFF ///< A bit string where all bits are flagged as 1 102 #define EMPTY_BIT_FIELD 0 ///< A bit string where all bits are flagged as 0 103 #define FILL_BIT_FIELD(XX) XX = FULL_BIT_FIELD ///< Fills up all bits in a bit pattern 104 #define RESET_BIT_FIELD(XX) XX = EMPTY_BIT_FIELD ///< Resets all bits in a BIT_FIELD to 0 105 106 #if !defined(SET_BIT) 107 #define SET_BIT(XX, YY) XX |= YY 108 #endif 109 110 #if !defined(UNSET_BIT) 111 #define UNSET_BIT(XX, YY) XX &= ~YY 112 #endif 113 114 #if !defined(BOOL_TO_BIT) 115 # define BOOL_TO_BIT(X) ((X) ? 1 : 0 ) 116 #endif 117 118 #if !defined(BIT_TO_BOOL) 119 # define BIT_TO_BOOL(X) ((1 == X) ? btrue : bfalse ) 120 #endif 121 122 #if !defined(HAS_SOME_BITS) 123 # define HAS_SOME_BITS(XX,YY) (0 != ((XX)&(YY))) 124 #endif 125 126 #if !defined(HAS_ALL_BITS) 127 # define HAS_ALL_BITS(XX,YY) ((YY) == ((XX)&(YY))) 128 #endif 129 130 #if !defined(HAS_NO_BITS) 131 # define HAS_NO_BITS(XX,YY) (0 == ((XX)&(YY))) 132 #endif 133 134 #if !defined(MISSING_BITS) 135 # define MISSING_BITS(XX,YY) (HAS_SOME_BITS(XX,YY) && !HAS_ALL_BITS(XX,YY)) 136 #endif 137 138 #define CLIP_TO_08BITS( V1 ) ( (V1) & 0xFF ) 139 #define CLIP_TO_16BITS( V1 ) ( (V1) & 0xFFFF ) 140 #define CLIP_TO_24BITS( V1 ) ( (V1) & 0xFFFFFF ) 141 #define CLIP_TO_32BITS( V1 ) ( (V1) & 0xFFFFFFFF ) 142 143 //-------------------------------------------------------------------------------------------- 144 // RECTANGLE 145 struct s_irect 146 { 147 int left; 148 int right; 149 int top; 150 int bottom; 151 }; 152 153 typedef struct s_irect irect_t; 154 155 bool_t irect_point_inside( irect_t * prect, int ix, int iy ); 156 157 struct s_frect 158 { 159 float left; 160 float right; 161 float top; 162 float bottom; 163 }; 164 165 typedef struct s_frect frect_t; 166 167 bool_t frect_point_inside( frect_t * prect, float fx, float fy ); 168 169 //-------------------------------------------------------------------------------------------- 170 // Rectangle types 171 172 struct s_ego_irect 173 { 174 int xmin, ymin; 175 int xmax, ymax; 176 }; 177 typedef struct s_ego_irect ego_irect_t; 178 179 struct s_ego_frect 180 { 181 float xmin, ymin; 182 float xmax, ymax; 183 }; 184 typedef struct s_ego_frect ego_frect_t; 185 186 //-------------------------------------------------------------------------------------------- 187 // PAIR AND RANGE 188 189 // Specifies a value between "base" and "base + rand" 190 struct s_pair 191 { 192 int base, rand; 193 }; 194 typedef struct s_pair IPair; 195 196 // Specifies a value from "from" to "to" 197 struct s_range 198 { 199 float from, to; 200 }; 201 typedef struct s_range FRange; 202 203 void pair_to_range( IPair pair, FRange * prange ); 204 void range_to_pair( FRange range, IPair * ppair ); 205 206 void ints_to_range( int base, int rand, FRange * prange ); 207 void floats_to_pair( float vmin, float vmax, IPair * ppair ); 208 209 //-------------------------------------------------------------------------------------------- 210 // IDSZ 211 typedef Uint32 IDSZ; 212 213 #if !defined(MAKE_IDSZ) 214 #define MAKE_IDSZ(C0,C1,C2,C3) \ 215 ((IDSZ)( \ 216 ((((C0)-'A')&0x1F) << 15) | \ 217 ((((C1)-'A')&0x1F) << 10) | \ 218 ((((C2)-'A')&0x1F) << 5) | \ 219 ((((C3)-'A')&0x1F) << 0) \ 220 )) 221 #endif 222 223 #define IDSZ_NONE MAKE_IDSZ('N','O','N','E') ///< [NONE] 224 #define IDSZ_BOOK MAKE_IDSZ('B','O','O','K') ///< [BOOK] 225 226 const char * undo_idsz( IDSZ idsz ); 227 228 //-------------------------------------------------------------------------------------------- 229 // STRING 230 typedef char STRING[256]; 231 232 //-------------------------------------------------------------------------------------------- 233 234 /// the "base class" of Egoboo profiles 235 #define EGO_PROFILE_STUFF \ 236 bool_t loaded; /** Was the data read in? */ \ 237 STRING name; /** Usually the source filename */ \ 238 int request_count; /** the number of attempted spawnx */ \ 239 int create_count; /** the number of successful spawns */ 240 241 //-------------------------------------------------------------------------------------------- 242 //-------------------------------------------------------------------------------------------- 243 244 /// The latch used by the input system 245 struct s_latch 246 { 247 float x; ///< the x input 248 float y; ///< the y input 249 BIT_FIELD b; ///< the button bits 250 }; 251 252 typedef struct s_latch latch_t; 253 254 void latch_init( latch_t * platch ); 255 256 //-------------------------------------------------------------------------------------------- 257 //-------------------------------------------------------------------------------------------- 258 // References 259 260 /// base reference type 261 typedef Uint16 REF_T; 262 263 //-------------------------------------------------------------------------------------------- 264 // definition of the c-type reference 265 266 #define C_DECLARE_REF( NAME ) typedef REF_T NAME 267 268 //-------------------------------------------------------------------------------------------- 269 // reference conversions 270 271 // define the c implementation always 272 #define C_REF_TO_INT(X) ((REF_T)(X)) 273 274 //-------------------------------------------------------------------------------------------- 275 //-------------------------------------------------------------------------------------------- 276 // a simple array 277 278 #define C_DECLARE_T_ARY(TYPE, NAME, COUNT) TYPE NAME[COUNT] 279 280 //-------------------------------------------------------------------------------------------- 281 //-------------------------------------------------------------------------------------------- 282 // a simple list structure that tracks free elements 283 284 #define ACCESS_TYPE_NONE 285 286 #define INVALID_UPDATE_GUID ((unsigned)(~((unsigned)0))) 287 288 #define C_DEFINE_LIST_TYPE(TYPE, NAME, COUNT) \ 289 struct s_c_list__##TYPE__##NAME \ 290 { \ 291 unsigned update_guid; \ 292 int used_count; \ 293 int free_count; \ 294 size_t used_ref[COUNT]; \ 295 size_t free_ref[COUNT]; \ 296 C_DECLARE_T_ARY(TYPE, lst, COUNT); \ 297 } 298 299 #define C_DECLARE_LIST_EXTERN(TYPE, NAME, COUNT) \ 300 C_DEFINE_LIST_TYPE(TYPE, NAME, COUNT); \ 301 extern struct s_c_list__##TYPE__##NAME NAME 302 303 #define C_INSTANTIATE_LIST_STATIC(TYPE,NAME, COUNT) \ 304 C_DEFINE_LIST_TYPE(TYPE, NAME, COUNT); \ 305 static struct s_c_list__##TYPE__##NAME NAME = {INVALID_UPDATE_GUID, 0, 0} 306 307 #define C_INSTANTIATE_LIST(ACCESS,TYPE,NAME, COUNT) ACCESS struct s_c_list__##TYPE__##NAME NAME = {INVALID_UPDATE_GUID, 0, 0} 308 309 //-------------------------------------------------------------------------------------------- 310 //-------------------------------------------------------------------------------------------- 311 // a simple stack structure 312 313 #define C_DEFINE_STACK_TYPE(TYPE, NAME, COUNT) \ 314 struct s_c_stack__##TYPE__##NAME \ 315 { \ 316 unsigned update_guid; \ 317 int count; \ 318 C_DECLARE_T_ARY(TYPE, lst, COUNT); \ 319 } 320 321 #define C_DECLARE_STACK_EXTERN(TYPE, NAME, COUNT) \ 322 C_DEFINE_STACK_TYPE(TYPE, NAME, COUNT); \ 323 extern struct s_c_stack__##TYPE__##NAME NAME 324 325 #define C_INSTANTIATE_STACK_STATIC(TYPE, NAME, COUNT) \ 326 C_DEFINE_STACK_TYPE(TYPE, NAME, COUNT); \ 327 static struct s_c_stack__##TYPE__##NAME NAME = {0} 328 329 #define C_INSTANTIATE_STACK(ACCESS, TYPE, NAME, COUNT) ACCESS struct s_c_stack__##TYPE__##NAME NAME = {INVALID_UPDATE_GUID, 0} 330 331 //-------------------------------------------------------------------------------------------- 332 //-------------------------------------------------------------------------------------------- 333 334 /// a template-like declaration of a dynamically allocated array 335 #define DECLARE_DYNAMIC_ARY(ARY_T, ELEM_T) \ 336 struct s_DYNAMIC_ARY_##ARY_T \ 337 { \ 338 size_t alloc; \ 339 int top; \ 340 ELEM_T * ary; \ 341 }; \ 342 typedef struct s_DYNAMIC_ARY_##ARY_T ARY_T##_t; \ 343 \ 344 ARY_T##_t * ARY_T##_ctor( ARY_T##_t * pary, size_t sz ); \ 345 ARY_T##_t * ARY_T##_dtor( ARY_T##_t * pary ); \ 346 bool_t ARY_T##_alloc( ARY_T##_t * pary, size_t sz ); \ 347 bool_t ARY_T##_free( ARY_T##_t * pary ); \ 348 void ARY_T##_clear( ARY_T##_t * pary ); \ 349 bool_t ARY_T##_push_back( ARY_T##_t * pary, ELEM_T val ); \ 350 size_t ARY_T##_get_top( ARY_T##_t * pary ); \ 351 size_t ARY_T##_get_size( ARY_T##_t * pary ); \ 352 ELEM_T * ARY_T##_pop_back( ARY_T##_t * pary ); \ 353 bool_t ARY_T##_push_back( ARY_T##_t * pary , ELEM_T val ); 354 355 #define DYNAMIC_ARY_INIT_VALS {0,0,NULL} 356 357 #define INSTANTIATE_DYNAMIC_ARY(ARY_T, NAME) ARY_T##_t NAME = DYNAMIC_ARY_INIT_VALS; 358 359 #define IMPLEMENT_DYNAMIC_ARY(ARY_T, ELEM_T) \ 360 bool_t ARY_T##_alloc( ARY_T##_t * pary, size_t sz ) { if(NULL == pary) return bfalse; ARY_T##_free( pary ); pary->ary = EGOBOO_NEW_ARY( ELEM_T, sz ); pary->alloc = (NULL == pary->ary) ? 0 : sz; return btrue; } \ 361 bool_t ARY_T##_free(ARY_T##_t * pary ) { if(NULL == pary) return bfalse; EGOBOO_DELETE_ARY(pary->ary); pary->alloc = 0; pary->top = 0; return btrue; } \ 362 ARY_T##_t * ARY_T##_ctor(ARY_T##_t * pary, size_t sz) { if(NULL == pary) return NULL; memset(pary, 0, sizeof(*pary)); if( !ARY_T##_alloc(pary, sz) ) return NULL; return pary; } \ 363 ARY_T##_t * ARY_T##_dtor(ARY_T##_t * pary ) { if(NULL == pary) return NULL; ARY_T##_free(pary); memset(pary, 0, sizeof(*pary)); return pary; } \ 364 \ 365 void ARY_T##_clear( ARY_T##_t * pary ) { if(NULL != pary) pary->top = 0; } \ 366 size_t ARY_T##_get_top( ARY_T##_t * pary ) { return (NULL == pary->ary) ? 0 : pary->top; } \ 367 size_t ARY_T##_get_size( ARY_T##_t * pary ) { return (NULL == pary->ary) ? 0 : pary->alloc; } \ 368 \ 369 ELEM_T * ARY_T##_pop_back( ARY_T##_t * pary ) { if( NULL == pary || pary->top < 1 ) return NULL; --pary->top; return &(pary->ary[pary->top]); } \ 370 bool_t ARY_T##_push_back( ARY_T##_t * pary, ELEM_T val ) { bool_t retval = bfalse; if( NULL == pary ) return bfalse; if (pary->top < pary->alloc) { pary->ary[pary->top] = val; pary->top++; retval = btrue; } return retval; } 371 372 //-------------------------------------------------------------------------------------------- 373 //-------------------------------------------------------------------------------------------- 374 375 /// a template-like declaration of a statically allocated array 376 377 #define DECLARE_STATIC_ARY_TYPE(ARY_T, ELEM_T, SIZE) \ 378 struct s_STATIC_ARY_##ARY_T \ 379 { \ 380 int count; \ 381 ELEM_T ary[SIZE]; \ 382 }; \ 383 typedef struct s_STATIC_ARY_##ARY_T ARY_T##_t 384 385 #define DECLARE_EXTERN_STATIC_ARY(ARY_T, NAME) extern ARY_T##_t NAME; 386 #define STATIC_ARY_INIT_VALS {0} 387 #define INSTANTIATE_STATIC_ARY(ARY_T, NAME) ARY_T##_t NAME = STATIC_ARY_INIT_VALS; 388 389 //-------------------------------------------------------------------------------------------- 390 //-------------------------------------------------------------------------------------------- 391 // definitions for the compiler environment 392 393 #define EGOBOO_ASSERT(X) C_EGOBOO_ASSERT(X) 394 #define _EGOBOO_ASSERT(X) C_EGOBOO_ASSERT(X) 395 396 //-------------------------------------------------------------------------------------------- 397 //-------------------------------------------------------------------------------------------- 398 // implementation of forward declaration of references 399 400 #define REF_TO_INT(X) C_REF_TO_INT(X) 401 402 #define DECLARE_T_ARY(TYPE, NAME, COUNT) C_DECLARE_T_ARY(TYPE, NAME, COUNT) 403 404 #define DECLARE_LIST_EXTERN(TYPE, NAME, COUNT) C_DECLARE_LIST_EXTERN(TYPE, NAME, COUNT) 405 #define INSTANTIATE_LIST_STATIC(TYPE,NAME, COUNT) C_INSTANTIATE_LIST_STATIC(TYPE,NAME, COUNT) 406 #define INSTANTIATE_LIST(ACCESS,TYPE,NAME, COUNT) C_INSTANTIATE_LIST(ACCESS,TYPE,NAME, COUNT) 407 408 #define DECLARE_STACK_EXTERN(TYPE, NAME, COUNT) C_DECLARE_STACK_EXTERN(TYPE, NAME, COUNT) 409 #define INSTANTIATE_STACK_STATIC(TYPE, NAME, COUNT) C_INSTANTIATE_STACK_STATIC(TYPE, NAME, COUNT) 410 #define INSTANTIATE_STACK(ACCESS, TYPE, NAME, COUNT) C_INSTANTIATE_STACK(ACCESS, TYPE, NAME, COUNT) 411 412 // use an underscore to force the c implementation 413 #define _DECLARE_T_ARY(TYPE, NAME, COUNT) C_DECLARE_T_ARY(TYPE, NAME, COUNT) 414 415 #define _DECLARE_LIST_EXTERN(TYPE, NAME, COUNT) C_DECLARE_LIST_EXTERN(TYPE, NAME, COUNT) 416 #define _INSTANTIATE_LIST_STATIC(TYPE,NAME, COUNT) C_INSTANTIATE_LIST_STATIC(TYPE,NAME, COUNT) 417 #define _INSTANTIATE_LIST(ACCESS,TYPE,NAME, COUNT) C_INSTANTIATE_LIST(ACCESS,TYPE,NAME, COUNT) 418 419 #define _DECLARE_STACK_EXTERN(TYPE, NAME, COUNT) C_DECLARE_STACK_EXTERN(TYPE, NAME, COUNT) 420 #define _INSTANTIATE_STACK_STATIC(TYPE, NAME, COUNT) C_INSTANTIATE_STACK_STATIC(TYPE, NAME, COUNT) 421 #define _INSTANTIATE_STACK(ACCESS, TYPE, NAME, COUNT) C_INSTANTIATE_STACK(ACCESS, TYPE, NAME, COUNT) 422 423 C_DECLARE_REF( CAP_REF ); 424 C_DECLARE_REF( CHR_REF ); 425 C_DECLARE_REF( TEAM_REF ); 426 C_DECLARE_REF( EVE_REF ); 427 C_DECLARE_REF( ENC_REF ); 428 C_DECLARE_REF( MAD_REF ); 429 C_DECLARE_REF( PLA_REF ); 430 C_DECLARE_REF( PIP_REF ); 431 C_DECLARE_REF( PRT_REF ); 432 C_DECLARE_REF( PASS_REF ); 433 C_DECLARE_REF( SHOP_REF ); 434 C_DECLARE_REF( PRO_REF ); 435 C_DECLARE_REF( TX_REF ); 436 C_DECLARE_REF( BBOARD_REF ); 437 C_DECLARE_REF( LOOP_REF ); 438 C_DECLARE_REF( MOD_REF ); 439 C_DECLARE_REF( TREQ_REF ); 440 C_DECLARE_REF( MOD_REF_REF ); 441 442 //-------------------------------------------------------------------------------------------- 443 //-------------------------------------------------------------------------------------------- 444 // forward declaration of standard dynamic array types 445 446 DECLARE_DYNAMIC_ARY( char_ary, char ) 447 DECLARE_DYNAMIC_ARY( short_ary, short ) 448 DECLARE_DYNAMIC_ARY( int_ary, int ) 449 DECLARE_DYNAMIC_ARY( float_ary, float ) 450 DECLARE_DYNAMIC_ARY( double_ary, double ) 451 452 //-------------------------------------------------------------------------------------------- 453 //-------------------------------------------------------------------------------------------- 454 #define egoboo_typedef_h 455