// Diablo uses a 256 color palette // Entry 0-127 (0x00-0x7F) are level specific // Entry 128-255 (0x80-0xFF) are global // standard palette for all levels // 8 or 16 shades per color // example (dark blue): PAL16_BLUE+14, PAL8_BLUE+7 // example (light red): PAL16_RED+2, PAL8_RED // example (orange): PAL16_ORANGE+8, PAL8_ORANGE+4 #define PAL8_BLUE 128 #define PAL8_RED 136 #define PAL8_YELLOW 144 #define PAL8_ORANGE 152 #define PAL16_BEIGE 160 #define PAL16_BLUE 176 #define PAL16_YELLOW 192 #define PAL16_ORANGE 208 #define PAL16_RED 224 #define PAL16_GRAY 240 ///////////////////////////////////////////////////////////////////////// /* temporary stuff from the decompiler */ /* remove all the garbage below in the future */ ///////////////////////////////////////////////////////////////////////// #ifndef IDA_GARBAGE #define IDA_GARBAGE typedef __int64 ll; typedef unsigned __int64 ull; typedef unsigned int uint; typedef unsigned char uchar; typedef unsigned short ushort; typedef unsigned long ulong; typedef char int8; typedef signed char sint8; typedef unsigned char uint8; typedef short int16; typedef signed short sint16; typedef unsigned short uint16; typedef int int32; typedef signed int sint32; typedef unsigned int uint32; typedef ll int64; typedef ll sint64; typedef ull uint64; // Partially defined types. They are used when the decompiler does not know // anything about the type except its size. #define _BYTE uint8 #define _WORD uint16 #define _DWORD uint32 #define _QWORD uint64 // Some convenience macros to make partial accesses nicer #define LAST_IND(x,part_type) (sizeof(x)/sizeof(part_type) - 1) #if defined(__BYTE_ORDER) && __BYTE_ORDER == __BIG_ENDIAN # define LOW_IND(x,part_type) LAST_IND(x,part_type) # define HIGH_IND(x,part_type) 0 #else # define HIGH_IND(x,part_type) LAST_IND(x,part_type) # define LOW_IND(x,part_type) 0 #endif // first unsigned macros: #define BYTEn(x, n) (*((_BYTE*)&(x)+n)) #define WORDn(x, n) (*((_WORD*)&(x)+n)) #define DWORDn(x, n) (*((_DWORD*)&(x)+n)) #define _LOBYTE(x) BYTEn(x,LOW_IND(x,_BYTE)) #define _LOWORD(x) WORDn(x,LOW_IND(x,_WORD)) #define LODWORD(x) DWORDn(x,LOW_IND(x,_DWORD)) #define _HIBYTE(x) BYTEn(x,HIGH_IND(x,_BYTE)) #define _HIWORD(x) WORDn(x,HIGH_IND(x,_WORD)) #define HIDWORD(x) DWORDn(x,HIGH_IND(x,_DWORD)) #define BYTE1(x) BYTEn(x, 1) // byte 1 (counting from 0) #define BYTE2(x) BYTEn(x, 2) // now signed macros (the same but with sign extension) #define SBYTEn(x, n) (*((int8*)&(x)+n)) #define SWORDn(x, n) (*((int16*)&(x)+n)) #define SLOBYTE(x) SBYTEn(x,LOW_IND(x,int8)) #define SHIWORD(x) SWORDn(x,HIGH_IND(x,int16)) // Helper functions to represent some assembly instructions. #ifdef __cplusplus // memcpy() with determined behavoir: it always copies // from the start to the end of the buffer // note: it copies byte by byte, so it is not equivalent to, for example, rep movsd #define qmemcpy memcpy /* inline void *qmemcpy(void *dst, const void *src, size_t cnt) { char *out = (char *)dst; const char *in = (const char *)src; while ( cnt > 0 ) { *out++ = *in++; --cnt; } return dst; } */ // Generate a reference to pair of operands template int16 __PAIR__( int8 high, T low) { return ((( int16)high) << sizeof(high)*8) | uint8(low); } template int32 __PAIR__( int16 high, T low) { return ((( int32)high) << sizeof(high)*8) | uint16(low); } template int64 __PAIR__( int32 high, T low) { return ((( int64)high) << sizeof(high)*8) | uint32(low); } template uint16 __PAIR__(uint8 high, T low) { return (((uint16)high) << sizeof(high)*8) | uint8(low); } template uint32 __PAIR__(uint16 high, T low) { return (((uint32)high) << sizeof(high)*8) | uint16(low); } template uint64 __PAIR__(uint32 high, T low) { return (((uint64)high) << sizeof(high)*8) | uint32(low); } // rotate left template T __ROL__(T value, int count) { const uint nbits = sizeof(T) * 8; if ( count > 0 ) { count %= nbits; T high = value >> (nbits - count); if ( T(-1) < 0 ) // signed value high &= ~((T(-1) << count)); value <<= count; value |= high; } else { count = -count % nbits; T low = value << (nbits - count); value >>= count; value |= low; } return value; } inline uint16 __ROR2__(uint16 value, int count) { return __ROL__((uint16)value, -count); } inline uint32 __ROR4__(uint32 value, int count) { return __ROL__((uint32)value, -count); } // sign flag template int8 __SETS__(T x) { if ( sizeof(T) == 1 ) return int8(x) < 0; if ( sizeof(T) == 2 ) return int16(x) < 0; if ( sizeof(T) == 4 ) return int32(x) < 0; return int64(x) < 0; } // overflow flag of subtraction (x-y) template int8 __OFSUB__(T x, U y) { if ( sizeof(T) < sizeof(U) ) { U x2 = x; int8 sx = __SETS__(x2); return (sx ^ __SETS__(y)) & (sx ^ __SETS__(x2-y)); } else { T y2 = y; int8 sx = __SETS__(x); return (sx ^ __SETS__(y2)) & (sx ^ __SETS__(x-y2)); } } #endif #endif /* IDA_GARBAGE */