codemp/game/q_shared.h

Go to the documentation of this file.

// Copyright (C) 1999-2000 Id Software, Inc.
//
#ifndef __Q_SHARED_H
#define __Q_SHARED_H

// q_shared.h -- included first by ALL program modules.
// A user mod should never modify this file

//NOTENOTE: Only change this to re-point ICARUS to a new script directory
#define Q3_SCRIPT_DIR   "scripts"

#define MAX_TEAMNAME 32

#include "../qcommon/disablewarnings.h"

#include "teams.h" //npc team stuff

#define MAX_WORLD_COORD         ( 64 * 1024 )
#define MIN_WORLD_COORD         ( -64 * 1024 )
#define WORLD_SIZE                      ( MAX_WORLD_COORD - MIN_WORLD_COORD )

//Pointer safety utilities
#define VALID( a )              ( a != NULL )
#define VALIDATE( a )   ( assert( a ) )

#define VALIDATEV( a )  if ( a == NULL ) {      assert(0);      return;                 }
#define VALIDATEB( a )  if ( a == NULL ) {      assert(0);      return qfalse;  }
#define VALIDATEP( a )  if ( a == NULL ) {      assert(0);      return NULL;    }

#define VALIDSTRING( a )        ( ( a != 0 ) && ( a[0] != 0 ) )

/*
#define G2_EHNANCEMENTS

#ifdef G2_EHNANCEMENTS
//these two will probably explode if they're defined independant of one another.
//rww - RAGDOLL_BEGIN
#define JK2_RAGDOLL
//rww - RAGDOLL_END
//rww - Bone cache for multiplayer base.
#define MP_BONECACHE
#endif
*/

#ifndef FINAL_BUILD
#define G2_PERFORMANCE_ANALYSIS
#define _FULL_G2_LEAK_CHECKING
extern int g_Ghoul2Allocations;
extern int g_G2ServerAlloc;
extern int g_G2ClientAlloc;
extern int g_G2AllocServer;
#endif

/**********************************************************************
  VM Considerations

  The VM can not use the standard system headers because we aren't really
  using the compiler they were meant for.  We use bg_lib.h which contains
  prototypes for the functions we define for our own use in bg_lib.c.

  When writing mods, please add needed headers HERE, do not start including
  stuff like <stdio.h> in the various .c files that make up each of the VMs
  since you will be including system headers files can will have issues.

  Remember, if you use a C library function that is not defined in bg_lib.c,
  you will have to add your own version for support in the VM.

 **********************************************************************/

#ifdef Q3_VM

#include "bg_lib.h"

#define assert(exp)     ((void)0)

#define min(x,y) ((x)<(y)?(x):(y))
#define max(x,y) ((x)>(y)?(x):(y))

#else

#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <ctype.h>
#include <limits.h>

// Special min treatment for Xbox C++ version

#ifdef _XBOX
#define min(x,y) ((x)<(y)?(x):(y))
#define max(x,y) ((x)>(y)?(x):(y))

#define tvector(T) std::vector< T >
#define tdeque(T) std::deque< T >

#define tlist(T) std::list< T >
#define tslist(T) std::slist< T >

#define tset(T) std::set< T, std::less< T > >
#define tmultiset(T) std::multiset< T, std::less< T > >

#define tcset(T,C) std::set< T, C >
#define tcmultiset(T,C) std::multiset< T, C >

#define tmap(K,T) std::map< K, T, std::less< K > >
#define tmultimap(K,T) std::multimap< K, T, std::less< K > >

#define tcmap(K,T,C) std::map< K, T, C >
#define tcmultimap(K,T,C) std::multimap< K, T, C >
#endif

#endif

#ifdef _WIN32

//#pragma intrinsic( memset, memcpy )

#endif

// this is the define for determining if we have an asm version of a C function
#if (defined _M_IX86 || defined __i386__) && !defined __sun__  && !defined __LCC__
#define id386   1
#else
#define id386   0
#endif

#if (defined(powerc) || defined(powerpc) || defined(ppc) || defined(__ppc) || defined(__ppc__)) && !defined(C_ONLY)
#define idppc   1
#else
#define idppc   0
#endif

// for windows fastcall option

#define QDECL

short   ShortSwap (short l);
int             LongSwap (int l);
float   FloatSwap (const float *f);

//======================= WIN32 DEFINES =================================

#ifdef WIN32

#define MAC_STATIC

#undef QDECL
#define QDECL   __cdecl

// buildstring will be incorporated into the version string
#ifdef NDEBUG
#ifdef _M_IX86
#define CPUSTRING       "win-x86"
#elif defined _M_ALPHA
#define CPUSTRING       "win-AXP"
#endif
#else
#ifdef _M_IX86
#define CPUSTRING       "win-x86-debug"
#elif defined _M_ALPHA
#define CPUSTRING       "win-AXP-debug"
#endif
#endif

#define ID_INLINE __inline 

static ID_INLINE short BigShort( short l) { return ShortSwap(l); }
#define LittleShort
static ID_INLINE int BigLong(int l) { return LongSwap(l); }
#define LittleLong
static ID_INLINE float BigFloat(const float *l) { FloatSwap(l); }
#define LittleFloat

#define PATH_SEP '\\'

#endif

//======================= MAC OS X DEFINES =====================

#if defined(MACOS_X)

#define MAC_STATIC
#define __cdecl
#define __declspec(x)
#define stricmp strcasecmp
#define ID_INLINE inline 

#ifdef __ppc__
#define CPUSTRING       "MacOSX-ppc"
#elif defined __i386__
#define CPUSTRING       "MacOSX-i386"
#else
#define CPUSTRING       "MacOSX-other"
#endif

#define PATH_SEP        '/'

#define __rlwimi(out, in, shift, maskBegin, maskEnd) asm("rlwimi %0,%1,%2,%3,%4" : "=r" (out) : "r" (in), "i" (shift), "i" (maskBegin), "i" (maskEnd))
#define __dcbt(addr, offset) asm("dcbt %0,%1" : : "b" (addr), "r" (offset))

static inline unsigned int __lwbrx(register void *addr, register int offset) {
    register unsigned int word;
    
    asm("lwbrx %0,%2,%1" : "=r" (word) : "r" (addr), "b" (offset));
    return word;
}

static inline unsigned short __lhbrx(register void *addr, register int offset) {
    register unsigned short halfword;
    
    asm("lhbrx %0,%2,%1" : "=r" (halfword) : "r" (addr), "b" (offset));
    return halfword;
}

static inline float __fctiw(register float f) {
    register float fi;
    
    asm("fctiw %0,%1" : "=f" (fi) : "f" (f));

    return fi;
}

#define BigShort
static inline short LittleShort(short l) { return ShortSwap(l); }
#define BigLong
static inline int LittleLong (int l) { return LongSwap(l); }
#define BigFloat
static inline float LittleFloat (const float l) { return FloatSwap(&l); }

#endif

//======================= MAC DEFINES =================================

#ifdef __MACOS__

#include <MacTypes.h>
#define MAC_STATIC
#define ID_INLINE inline 

#define CPUSTRING       "MacOS-PPC"

#define PATH_SEP ':'

void Sys_PumpEvents( void );

#define BigShort
static inline short LittleShort(short l) { return ShortSwap(l); }
#define BigLong
static inline int LittleLong (int l) { return LongSwap(l); }
#define BigFloat
static inline float LittleFloat (const float l) { return FloatSwap(&l); }

#endif

//======================= LINUX DEFINES =================================

// the mac compiler can't handle >32k of locals, so we
// just waste space and make big arrays static...
#ifdef __linux__

// bk001205 - from Makefile
#define stricmp strcasecmp

#define MAC_STATIC // bk: FIXME
#define ID_INLINE inline 

#ifdef __i386__
#define CPUSTRING       "linux-i386"
#elif defined __axp__
#define CPUSTRING       "linux-alpha"
#else
#define CPUSTRING       "linux-other"
#endif

#define PATH_SEP '/'

// bk001205 - try
#ifdef Q3_STATIC
#define GAME_HARD_LINKED
#define CGAME_HARD_LINKED
#define UI_HARD_LINKED
#define BOTLIB_HARD_LINKED
#endif

#if !idppc
inline static short BigShort( short l) { return ShortSwap(l); }
#define LittleShort
inline static int BigLong(int l) { return LongSwap(l); }
#define LittleLong
inline static float BigFloat(const float *l) { return FloatSwap(l); }
#define LittleFloat
#else
#define BigShort
inline static short LittleShort(short l) { return ShortSwap(l); }
#define BigLong
inline static int LittleLong (int l) { return LongSwap(l); }
#define BigFloat
inline static float LittleFloat (const float *l) { return FloatSwap(l); }
#endif

#endif

//======================= FreeBSD DEFINES =====================
#ifdef __FreeBSD__ // rb010123

#define stricmp strcasecmp

#define MAC_STATIC
#define ID_INLINE inline 

#ifdef __i386__
#define CPUSTRING       "freebsd-i386"
#elif defined __axp__
#define CPUSTRING       "freebsd-alpha"
#else
#define CPUSTRING       "freebsd-other"
#endif

#define PATH_SEP '/'

// bk010116 - omitted Q3STATIC (see Linux above), broken target

#if !idppc
static short BigShort( short l) { return ShortSwap(l); }
#define LittleShort
static int BigLong(int l) { LongSwap(l); }
#define LittleLong
static float BigFloat(const float *l) { FloatSwap(l); }
#define LittleFloat
#else
#define BigShort
static short LittleShort(short l) { return ShortSwap(l); }
#define BigLong
static int LittleLong (int l) { return LongSwap(l); }
#define BigFloat
static float LittleFloat (const float *l) { return FloatSwap(l); }
#endif

#endif

//=============================================================

//=============================================================

typedef unsigned char           byte;
typedef unsigned short          word;
typedef unsigned long           ulong;

typedef enum {qfalse, qtrue}    qboolean;
#ifdef _XBOX
#define qboolean        int             //don't want strict type checking on the qboolean
#endif

typedef int             qhandle_t;
typedef int             thandle_t; //rwwRMG - inserted
typedef int             fxHandle_t;
typedef int             sfxHandle_t;
typedef int             fileHandle_t;
typedef int             clipHandle_t;

#ifndef NULL
#define NULL ((void *)0)
#endif

#define MAX_QINT                        0x7fffffff
#define MIN_QINT                        (-MAX_QINT-1)


// angle indexes
#define PITCH                           0               // up / down
#define YAW                                     1               // left / right
#define ROLL                            2               // fall over

// the game guarantees that no string from the network will ever
// exceed MAX_STRING_CHARS
#define MAX_STRING_CHARS        1024    // max length of a string passed to Cmd_TokenizeString
#define MAX_STRING_TOKENS       1024    // max tokens resulting from Cmd_TokenizeString
#define MAX_TOKEN_CHARS         1024    // max length of an individual token

#define MAX_INFO_STRING         1024
#define MAX_INFO_KEY            1024
#define MAX_INFO_VALUE          1024

#define BIG_INFO_STRING         8192  // used for system info key only
#define BIG_INFO_KEY              8192
#define BIG_INFO_VALUE          8192


#define MAX_QPATH                       64              // max length of a quake game pathname
#ifdef PATH_MAX
#define MAX_OSPATH                      PATH_MAX
#else
#define MAX_OSPATH                      256             // max length of a filesystem pathname
#endif

#define MAX_NAME_LENGTH         32              // max length of a client name

#define MAX_SAY_TEXT    150

// paramters for command buffer stuffing
typedef enum {
        EXEC_NOW,                       // don't return until completed, a VM should NEVER use this,
                                                // because some commands might cause the VM to be unloaded...
        EXEC_INSERT,            // insert at current position, but don't run yet
        EXEC_APPEND                     // add to end of the command buffer (normal case)
} cbufExec_t;


//
// these aren't needed by any of the VMs.  put in another header?
//
#define MAX_MAP_AREA_BYTES              32              // bit vector of area visibility


#define LS_STYLES_START                 0
#define LS_NUM_STYLES                   32
#define LS_SWITCH_START                 (LS_STYLES_START+LS_NUM_STYLES)
#define LS_NUM_SWITCH                   32
#if !defined MAX_LIGHT_STYLES
#define MAX_LIGHT_STYLES                64
#endif

//For system-wide prints
enum WL_e {
        WL_ERROR=1,
        WL_WARNING,
        WL_VERBOSE,
        WL_DEBUG
};

extern float forceSpeedLevels[4];

// print levels from renderer (FIXME: set up for game / cgame?)
typedef enum {
        PRINT_ALL,
        PRINT_DEVELOPER,                // only print when "developer 1"
        PRINT_WARNING,
        PRINT_ERROR
} printParm_t;


#ifdef ERR_FATAL
#undef ERR_FATAL                        // this is be defined in malloc.h
#endif

// parameters to the main Error routine
typedef enum {
        ERR_FATAL,                                      // exit the entire game with a popup window
        ERR_DROP,                                       // print to console and disconnect from game
        ERR_SERVERDISCONNECT,           // don't kill server
        ERR_DISCONNECT,                         // client disconnected from the server
        ERR_NEED_CD                                     // pop up the need-cd dialog
} errorParm_t;


// font rendering values used by ui and cgame

/*#define PROP_GAP_WIDTH                        3
#define PROP_SPACE_WIDTH                8
#define PROP_HEIGHT                             27
#define PROP_SMALL_SIZE_SCALE   0.75*/

#define PROP_GAP_WIDTH                  2
//#define PROP_GAP_WIDTH                        3
#define PROP_SPACE_WIDTH                4
#define PROP_HEIGHT                             16

#define PROP_TINY_SIZE_SCALE    1
#define PROP_SMALL_SIZE_SCALE   1
#define PROP_BIG_SIZE_SCALE             1
#define PROP_GIANT_SIZE_SCALE   2

#define PROP_TINY_HEIGHT                10
#define PROP_GAP_TINY_WIDTH             1
#define PROP_SPACE_TINY_WIDTH   3

#define PROP_BIG_HEIGHT                 24
#define PROP_GAP_BIG_WIDTH              3
#define PROP_SPACE_BIG_WIDTH    6

#define BLINK_DIVISOR                   200
#define PULSE_DIVISOR                   75

#define UI_LEFT                 0x00000000      // default
#define UI_CENTER               0x00000001
#define UI_RIGHT                0x00000002
#define UI_FORMATMASK   0x00000007
#define UI_SMALLFONT    0x00000010
#define UI_BIGFONT              0x00000020      // default
//#define UI_GIANTFONT  0x00000040
#define UI_DROPSHADOW   0x00000800
#define UI_BLINK                0x00001000
#define UI_INVERSE              0x00002000
#define UI_PULSE                0x00004000

#if defined(_DEBUG) && !defined(BSPC) && !defined(_XBOX)
        #define HUNK_DEBUG
#endif

typedef enum {
        h_high,
        h_low,
        h_dontcare
} ha_pref;

void *Hunk_Alloc( int size, ha_pref preference );

void Com_Memset (void* dest, const int val, const size_t count);
void Com_Memcpy (void* dest, const void* src, const size_t count);

#define CIN_system      1
#define CIN_loop        2
#define CIN_hold        4
#define CIN_silent      8
#define CIN_shader      16

/*
==============================================================

MATHLIB

==============================================================
*/


typedef float vec_t;
typedef vec_t vec2_t[2];
typedef vec_t vec3_t[3];
typedef vec_t vec4_t[4];
typedef vec_t vec5_t[5];

//rwwRMG - new vec types
typedef vec3_t  vec3pair_t[2];

typedef int ivec3_t[3];
typedef int ivec4_t[4];
typedef int ivec5_t[5];

typedef int     fixed4_t;
typedef int     fixed8_t;
typedef int     fixed16_t;

#ifndef M_PI
#define M_PI            3.14159265358979323846f // matches value in gcc v2 math.h
#endif


typedef enum {
        BLK_NO,
        BLK_TIGHT,              // Block only attacks and shots around the saber itself, a bbox of around 12x12x12
        BLK_WIDE                // Block all attacks in an area around the player in a rough arc of 180 degrees
} saberBlockType_t;

typedef enum {
        BLOCKED_NONE,
        BLOCKED_BOUNCE_MOVE,
        BLOCKED_PARRY_BROKEN,
        BLOCKED_ATK_BOUNCE,
        BLOCKED_UPPER_RIGHT,
        BLOCKED_UPPER_LEFT,
        BLOCKED_LOWER_RIGHT,
        BLOCKED_LOWER_LEFT,
        BLOCKED_TOP,
        BLOCKED_UPPER_RIGHT_PROJ,
        BLOCKED_UPPER_LEFT_PROJ,
        BLOCKED_LOWER_RIGHT_PROJ,
        BLOCKED_LOWER_LEFT_PROJ,
        BLOCKED_TOP_PROJ
} saberBlockedType_t;



typedef enum
{
        SABER_RED,
        SABER_ORANGE,
        SABER_YELLOW,
        SABER_GREEN,
        SABER_BLUE,
        SABER_PURPLE,
        NUM_SABER_COLORS

};
typedef int saber_colors_t;

typedef enum
{
        FP_FIRST = 0,//marker
        FP_HEAL = 0,//instant
        FP_LEVITATION,//hold/duration
        FP_SPEED,//duration
        FP_PUSH,//hold/duration
        FP_PULL,//hold/duration
        FP_TELEPATHY,//instant
        FP_GRIP,//hold/duration
        FP_LIGHTNING,//hold/duration
        FP_RAGE,//duration
        FP_PROTECT,
        FP_ABSORB,
        FP_TEAM_HEAL,
        FP_TEAM_FORCE,
        FP_DRAIN,
        FP_SEE,
        FP_SABER_OFFENSE,
        FP_SABER_DEFENSE,
        FP_SABERTHROW,
        NUM_FORCE_POWERS
};
typedef int forcePowers_t;

typedef enum
{
        SABER_NONE = 0,
        SABER_SINGLE,
        SABER_STAFF,
        SABER_DAGGER,
        SABER_BROAD,
        SABER_PRONG,
        SABER_ARC,
        SABER_SAI,
        SABER_CLAW,
        SABER_LANCE,
        SABER_STAR,
        SABER_TRIDENT,
        SABER_SITH_SWORD,
        NUM_SABERS
} saberType_t;

typedef struct 
{
        // Actual trail stuff
        int             inAction;       // controls whether should we even consider starting one
        int             duration;       // how long each trail seg stays in existence
        int             lastTime;       // time a saber segement was last stored
        vec3_t  base;
        vec3_t  tip;

        vec3_t  dualbase;
        vec3_t  dualtip;

        // Marks stuff
        qboolean        haveOldPos[2];
        vec3_t          oldPos[2];              
        vec3_t          oldNormal[2];   // store this in case we don't have a connect-the-dots situation
                                                        //      ..then we'll need the normal to project a mark blob onto the impact point
} saberTrail_t;

typedef struct
{
        qboolean        active;
        saber_colors_t  color;
        float           radius;
        float           length;
        float           lengthMax;
        float           lengthOld;
        float           desiredLength;
        vec3_t          muzzlePoint;
        vec3_t          muzzlePointOld;
        vec3_t          muzzleDir;
        vec3_t          muzzleDirOld;
        saberTrail_t    trail;
        int                     hitWallDebounceTime;
        int                     storageTime;
        int                     extendDebounce;
} bladeInfo_t;
#define MAX_BLADES 8

typedef enum
{
        SS_NONE = 0,
        SS_FAST,
        SS_MEDIUM,
        SS_STRONG,
        SS_DESANN,
        SS_TAVION,
        SS_DUAL,
        SS_STAFF,
        SS_NUM_SABER_STYLES
} saber_styles_t;

//SABER FLAGS
//Old bools converted to a flag now
#define SFL_NOT_LOCKABLE                        (1<<0)//can't get into a saberlock
#define SFL_NOT_THROWABLE                       (1<<1)//can't be thrown - FIXME: maybe make this a max level of force saber throw that can be used with this saber?
#define SFL_NOT_DISARMABLE                      (1<<2)//can't be dropped
#define SFL_NOT_ACTIVE_BLOCKING         (1<<3)//don't to try to block incoming shots with this saber
#define SFL_TWO_HANDED                          (1<<4)//uses both hands
#define SFL_SINGLE_BLADE_THROWABLE      (1<<5)//can throw this saber if only the first blade is on
#define SFL_RETURN_DAMAGE                       (1<<6)//when returning from a saber throw, it keeps spinning and doing damage
//NEW FLAGS
#define SFL_ON_IN_WATER                         (1<<7)//if set, weapon stays active even in water
#define SFL_BOUNCE_ON_WALLS                     (1<<8)//if set, the saber will bounce back when it hits solid architecture (good for real-sword type mods)
#define SFL_BOLT_TO_WRIST                       (1<<9)//if set, saber model is bolted to wrist, not in hand... useful for things like claws & shields, etc.
//#define SFL_STICK_ON_IMPACT           (1<<?)//if set, the saber will stick in the wall when thrown and hits solid architecture (good for sabers that are meant to be thrown).
//#define SFL_NO_ATTACK                         (1<<?)//if set, you cannot attack with the saber (for sabers/weapons that are meant to be thrown only, not used as melee weapons).
//Move Restrictions
#define SFL_NO_PULL_ATTACK                      (1<<10)//if set, cannot do pull+attack move (move not available in MP anyway)
#define SFL_NO_BACK_ATTACK                      (1<<11)//if set, cannot do back-stab moves
#define SFL_NO_STABDOWN                         (1<<12)//if set, cannot do stabdown move (when enemy is on ground)
#define SFL_NO_WALL_RUNS                        (1<<13)//if set, cannot side-run or forward-run on walls
#define SFL_NO_WALL_FLIPS                       (1<<14)//if set, cannot do backflip off wall or side-flips off walls
#define SFL_NO_WALL_GRAB                        (1<<15)//if set, cannot grab wall & jump off
#define SFL_NO_ROLLS                            (1<<16)//if set, cannot roll
#define SFL_NO_FLIPS                            (1<<17)//if set, cannot do flips
#define SFL_NO_CARTWHEELS                       (1<<18)//if set, cannot do cartwheels
#define SFL_NO_KICKS                            (1<<19)//if set, cannot do kicks (can't do kicks anyway if using a throwable saber/sword)
#define SFL_NO_MIRROR_ATTACKS           (1<<20)//if set, cannot do the simultaneous attack left/right moves (only available in Dual Lightsaber Combat Style)
#define SFL_NO_ROLL_STAB                        (1<<21)//if set, cannot do roll-stab move at end of roll
//SABER FLAGS2
//Primary Blade Style
#define SFL2_NO_WALL_MARKS                      (1<<0)//if set, stops the saber from drawing marks on the world (good for real-sword type mods)
#define SFL2_NO_DLIGHT                          (1<<1)//if set, stops the saber from drawing a dynamic light (good for real-sword type mods)
#define SFL2_NO_BLADE                           (1<<2)//if set, stops the saber from drawing a blade (good for real-sword type mods)
#define SFL2_NO_CLASH_FLARE                     (1<<3)//if set, the saber will not do the big, white clash flare with other sabers
#define SFL2_NO_DISMEMBERMENT           (1<<4)//if set, the saber never does dismemberment (good for pointed/blunt melee weapons)
#define SFL2_NO_IDLE_EFFECT                     (1<<5)//if set, the saber will not do damage or any effects when it is idle (not in an attack anim).  (good for real-sword type mods)
#define SFL2_ALWAYS_BLOCK                       (1<<6)//if set, the blades will always be blocking (good for things like shields that should always block)
#define SFL2_NO_MANUAL_DEACTIVATE       (1<<7)//if set, the blades cannot manually be toggled on and off
#define SFL2_TRANSITION_DAMAGE          (1<<8)//if set, the blade does damage in start, transition and return anims (like strong style does)
//Secondary Blade Style
#define SFL2_NO_WALL_MARKS2                     (1<<9)//if set, stops the saber from drawing marks on the world (good for real-sword type mods)
#define SFL2_NO_DLIGHT2                         (1<<10)//if set, stops the saber from drawing a dynamic light (good for real-sword type mods)
#define SFL2_NO_BLADE2                          (1<<11)//if set, stops the saber from drawing a blade (good for real-sword type mods)
#define SFL2_NO_CLASH_FLARE2            (1<<12)//if set, the saber will not do the big, white clash flare with other sabers
#define SFL2_NO_DISMEMBERMENT2          (1<<13)//if set, the saber never does dismemberment (good for pointed/blunt melee weapons)
#define SFL2_NO_IDLE_EFFECT2            (1<<14)//if set, the saber will not do damage or any effects when it is idle (not in an attack anim).  (good for real-sword type mods)
#define SFL2_ALWAYS_BLOCK2                      (1<<15)//if set, the blades will always be blocking (good for things like shields that should always block)
#define SFL2_NO_MANUAL_DEACTIVATE2      (1<<16)//if set, the blades cannot manually be toggled on and off
#define SFL2_TRANSITION_DAMAGE2         (1<<17)//if set, the blade does damage in start, transition and return anims (like strong style does)

typedef struct
{
        char            name[64];                                               //entry in sabers.cfg, if any
        char            fullName[64];                           //the "Proper Name" of the saber, shown in UI
        saberType_t     type;                                           //none, single or staff
        char            model[MAX_QPATH];                                               //hilt model
        qhandle_t       skin;                                           //registered skin id
        int                     soundOn;                                        //game soundindex for turning on sound
        int                     soundLoop;                                      //game soundindex for hum/loop sound
        int                     soundOff;                                       //game soundindex for turning off sound
        int                     numBlades;
        bladeInfo_t     blade[MAX_BLADES];                      //blade info - like length, trail, origin, dir, etc.
        int                     stylesLearned;                          //styles you get when you get this saber, if any
        int                     stylesForbidden;                        //styles you cannot use with this saber, if any
        int                     maxChain;                                       //how many moves can be chained in a row with this weapon (-1 is infinite, 0 is use default behavior)
        int                     forceRestrictions;                      //force powers that cannot be used while this saber is on (bitfield) - FIXME: maybe make this a limit on the max level, per force power, that can be used with this type?
        int                     lockBonus;                                      //in saberlocks, this type of saber pushes harder or weaker
        int                     parryBonus;                                     //added to strength of parry with this saber
        int                     breakParryBonus;                        //added to strength when hit a parry
        int                     breakParryBonus2;                       //for bladeStyle2 (see bladeStyle2Start below)
        int                     disarmBonus;                            //added to disarm chance when win saberlock or have a good parry (knockaway)
        int                     disarmBonus2;                           //for bladeStyle2 (see bladeStyle2Start below)
        saber_styles_t  singleBladeStyle;               //makes it so that you use a different style if you only have the first blade active
//      char            *brokenSaber1;                          //if saber is actually hit by another saber, it can be cut in half/broken and will be replaced with this saber in your right hand
//      char            *brokenSaber2;                          //if saber is actually hit by another saber, it can be cut in half/broken and will be replaced with this saber in your left hand
//===NEW========================================================================================
        //these values are global to the saber, like all of the ones above
        int                     saberFlags;                                     //from SFL_ list above
        int                     saberFlags2;                            //from SFL2_ list above

        //done in cgame (client-side code)
        qhandle_t       spinSound;                                      //none - if set, plays this sound as it spins when thrown
        qhandle_t       swingSound[3];                          //none - if set, plays one of these 3 sounds when swung during an attack - NOTE: must provide all 3!!!

        //done in game (server-side code)
        float           moveSpeedScale;                         //1.0 - you move faster/slower when using this saber
        float           animSpeedScale;                         //1.0 - plays normal attack animations faster/slower

        //done in both cgame and game (BG code)
        int     kataMove;                               //LS_INVALID - if set, player will execute this move when they press both attack buttons at the same time 
        int     lungeAtkMove;                   //LS_INVALID - if set, player will execute this move when they crouch+fwd+attack 
        int     jumpAtkUpMove;                  //LS_INVALID - if set, player will execute this move when they jump+attack 
        int     jumpAtkFwdMove;                 //LS_INVALID - if set, player will execute this move when they jump+fwd+attack 
        int     jumpAtkBackMove;                //LS_INVALID - if set, player will execute this move when they jump+back+attack
        int     jumpAtkRightMove;               //LS_INVALID - if set, player will execute this move when they jump+rightattack
        int     jumpAtkLeftMove;                //LS_INVALID - if set, player will execute this move when they jump+left+attack
        int     readyAnim;                              //-1 - anim to use when standing idle
        int     drawAnim;                               //-1 - anim to use when drawing weapon
        int     putawayAnim;                    //-1 - anim to use when putting weapon away
        int     tauntAnim;                              //-1 - anim to use when hit "taunt"
        int     bowAnim;                                //-1 - anim to use when hit "bow"
        int     meditateAnim;                   //-1 - anim to use when hit "meditate"
        int     flourishAnim;                   //-1 - anim to use when hit "flourish"
        int     gloatAnim;                              //-1 - anim to use when hit "gloat"

        //***NOTE: you can only have a maximum of 2 "styles" of blades, so this next value, "bladeStyle2Start" is the number of the first blade to use these value on... all blades before this use the normal values above, all blades at and after this number use the secondary values below***
        int                     bladeStyle2Start;                       //0 - if set, blades from this number and higher use the following values (otherwise, they use the normal values already set)

        //***The following can be different for the extra blades - not setting them individually defaults them to the value for the whole saber (and first blade)***
        
        //===PRIMARY BLADES=====================
        //done in cgame (client-side code)
        int                     trailStyle;                                     //0 - default (0) is normal, 1 is a motion blur and 2 is no trail at all (good for real-sword type mods)
        int                     g2MarksShader;                          //none - if set, the game will use this shader for marks on enemies instead of the default "gfx/damage/saberglowmark"
        int                     g2WeaponMarkShader;                     //none - if set, the game will ry to project this shader onto the weapon when it damages a person (good for a blood splatter on the weapon)
        //int           bladeShader;                            //none - if set, overrides the shader used for the saber blade?
        //int           trailShader;                            //none - if set, overrides the shader used for the saber trail?
        qhandle_t       hitSound[3];                            //none - if set, plays one of these 3 sounds when saber hits a person - NOTE: must provide all 3!!!
        qhandle_t       blockSound[3];                          //none - if set, plays one of these 3 sounds when saber/sword hits another saber/sword - NOTE: must provide all 3!!!
        qhandle_t       bounceSound[3];                         //none - if set, plays one of these 3 sounds when saber/sword hits a wall and bounces off (must set bounceOnWall to 1 to use these sounds) - NOTE: must provide all 3!!!
        int                     blockEffect;                            //none - if set, plays this effect when the saber/sword hits another saber/sword (instead of "saber/saber_block.efx")
        int                     hitPersonEffect;                        //none - if set, plays this effect when the saber/sword hits a person (instead of "saber/blood_sparks_mp.efx")
        int                     hitOtherEffect;                         //none - if set, plays this effect when the saber/sword hits something else damagable (instead of "saber/saber_cut.efx")
        int                     bladeEffect;                            //none - if set, plays this effect at the blade tag

        //done in game (server-side code)
        float           knockbackScale;                         //0 - if non-zero, uses damage done to calculate an appropriate amount of knockback
        float           damageScale;                            //1 - scale up or down the damage done by the saber
        float           splashRadius;                           //0 - radius of splashDamage
        int                     splashDamage;                           //0 - amount of splashDamage, 100% at a distance of 0, 0% at a distance = splashRadius
        float           splashKnockback;                        //0 - amount of splashKnockback, 100% at a distance of 0, 0% at a distance = splashRadius
        
        //===SECONDARY BLADES===================
        //done in cgame (client-side code)
        int                     trailStyle2;                            //0 - default (0) is normal, 1 is a motion blur and 2 is no trail at all (good for real-sword type mods)
        int                     g2MarksShader2;                         //none - if set, the game will use this shader for marks on enemies instead of the default "gfx/damage/saberglowmark"
        int                     g2WeaponMarkShader2;            //none - if set, the game will ry to project this shader onto the weapon when it damages a person (good for a blood splatter on the weapon)
        //int           bladeShader2;                           //none - if set, overrides the shader used for the saber blade?
        //int           trailShader2;                           //none - if set, overrides the shader used for the saber trail?
        qhandle_t       hit2Sound[3];                           //none - if set, plays one of these 3 sounds when saber hits a person - NOTE: must provide all 3!!!
        qhandle_t       block2Sound[3];                         //none - if set, plays one of these 3 sounds when saber/sword hits another saber/sword - NOTE: must provide all 3!!!
        qhandle_t       bounce2Sound[3];                        //none - if set, plays one of these 3 sounds when saber/sword hits a wall and bounces off (must set bounceOnWall to 1 to use these sounds) - NOTE: must provide all 3!!!
        int                     blockEffect2;                           //none - if set, plays this effect when the saber/sword hits another saber/sword (instead of "saber/saber_block.efx")
        int                     hitPersonEffect2;                       //none - if set, plays this effect when the saber/sword hits a person (instead of "saber/blood_sparks_mp.efx")
        int                     hitOtherEffect2;                        //none - if set, plays this effect when the saber/sword hits something else damagable (instead of "saber/saber_cut.efx")
        int                     bladeEffect2;                           //none - if set, plays this effect at the blade tag

        //done in game (server-side code)
        float           knockbackScale2;                        //0 - if non-zero, uses damage done to calculate an appropriate amount of knockback
        float           damageScale2;                           //1 - scale up or down the damage done by the saber
        float           splashRadius2;                          //0 - radius of splashDamage
        int                     splashDamage2;                          //0 - amount of splashDamage, 100% at a distance of 0, 0% at a distance = splashRadius
        float           splashKnockback2;                       //0 - amount of splashKnockback, 100% at a distance of 0, 0% at a distance = splashRadius
//=========================================================================================================================================

} saberInfo_t;
#define MAX_SABERS 2

typedef enum
{
        FORCE_LEVEL_0,
        FORCE_LEVEL_1,
        FORCE_LEVEL_2,
        FORCE_LEVEL_3,
        NUM_FORCE_POWER_LEVELS
};

#define FORCE_LEVEL_4 (FORCE_LEVEL_3+1)
#define FORCE_LEVEL_5 (FORCE_LEVEL_4+1)

//rww - a C-ified structure version of the class which fires off callbacks and gives arguments to update ragdoll status.
enum sharedERagPhase
{
        RP_START_DEATH_ANIM,
        RP_END_DEATH_ANIM,
        RP_DEATH_COLLISION,
        RP_CORPSE_SHOT,
        RP_GET_PELVIS_OFFSET,  // this actually does nothing but set the pelvisAnglesOffset, and pelvisPositionOffset
        RP_SET_PELVIS_OFFSET,  // this actually does nothing but set the pelvisAnglesOffset, and pelvisPositionOffset
        RP_DISABLE_EFFECTORS  // this removes effectors given by the effectorsToTurnOff member
};

enum sharedERagEffector
{
        RE_MODEL_ROOT=                  0x00000001, //"model_root"
        RE_PELVIS=                              0x00000002, //"pelvis"
        RE_LOWER_LUMBAR=                0x00000004, //"lower_lumbar"
        RE_UPPER_LUMBAR=                0x00000008, //"upper_lumbar"
        RE_THORACIC=                    0x00000010, //"thoracic"
        RE_CRANIUM=                             0x00000020, //"cranium"
        RE_RHUMEROUS=                   0x00000040, //"rhumerus"
        RE_LHUMEROUS=                   0x00000080, //"lhumerus"
        RE_RRADIUS=                             0x00000100, //"rradius"
        RE_LRADIUS=                             0x00000200, //"lradius"
        RE_RFEMURYZ=                    0x00000400, //"rfemurYZ"
        RE_LFEMURYZ=                    0x00000800, //"lfemurYZ"
        RE_RTIBIA=                              0x00001000, //"rtibia"
        RE_LTIBIA=                              0x00002000, //"ltibia"
        RE_RHAND=                               0x00004000, //"rhand"
        RE_LHAND=                               0x00008000, //"lhand"
        RE_RTARSAL=                             0x00010000, //"rtarsal"
        RE_LTARSAL=                             0x00020000, //"ltarsal"
        RE_RTALUS=                              0x00040000, //"rtalus"
        RE_LTALUS=                              0x00080000, //"ltalus"
        RE_RRADIUSX=                    0x00100000, //"rradiusX"
        RE_LRADIUSX=                    0x00200000, //"lradiusX"
        RE_RFEMURX=                             0x00400000, //"rfemurX"
        RE_LFEMURX=                             0x00800000, //"lfemurX"
        RE_CEYEBROW=                    0x01000000 //"ceyebrow"
};

typedef struct
{
        vec3_t angles;
        vec3_t position;
        vec3_t scale;
        vec3_t pelvisAnglesOffset;    // always set on return, an argument for RP_SET_PELVIS_OFFSET
        vec3_t pelvisPositionOffset; // always set on return, an argument for RP_SET_PELVIS_OFFSET

        float fImpactStrength; //should be applicable when RagPhase is RP_DEATH_COLLISION
        float fShotStrength; //should be applicable for setting velocity of corpse on shot (probably only on RP_CORPSE_SHOT)
        int me; //index of entity giving this update

        //rww - we have convenient animation/frame access in the game, so just send this info over from there.
        int startFrame;
        int endFrame;

        int collisionType; // 1 = from a fall, 0 from effectors, this will be going away soon, hence no enum 

        qboolean CallRagDollBegin; // a return value, means that we are now begininng ragdoll and the NPC stuff needs to happen

        int RagPhase;

// effector control, used for RP_DISABLE_EFFECTORS call

        int effectorsToTurnOff;  // set this to an | of the above flags for a RP_DISABLE_EFFECTORS

} sharedRagDollParams_t;

//And one for updating during model animation.
typedef struct
{
        vec3_t angles;
        vec3_t position;
        vec3_t scale;
        vec3_t velocity;
        int     me;
        int settleFrame;
} sharedRagDollUpdateParams_t;

//rww - update parms for ik bone stuff
typedef struct
{
        char boneName[512]; //name of bone
        vec3_t desiredOrigin; //world coordinate that this bone should be attempting to reach
        vec3_t origin; //world coordinate of the entity who owns the g2 instance that owns the bone
        float movementSpeed; //how fast the bone should move toward the destination
} sharedIKMoveParams_t;


typedef struct
{
        vec3_t pcjMins; //ik joint limit
        vec3_t pcjMaxs; //ik joint limit
        vec3_t origin; //origin of caller
        vec3_t angles; //angles of caller
        vec3_t scale; //scale of caller
        float radius; //bone rad
        int blendTime; //bone blend time
        int pcjOverrides; //override ik bone flags
        int startFrame; //base pose start
        int endFrame; //base pose end
        qboolean forceAnimOnBone; //normally if the bone has specified start/end frames already it will leave it alone.. if this is true, then the animation will be restarted on the bone with the specified frames anyway.
} sharedSetBoneIKStateParams_t;

enum sharedEIKMoveState
{
        IKS_NONE = 0,
        IKS_DYNAMIC
};

//material stuff needs to be shared
typedef enum //# material_e
{
        MAT_METAL = 0,  // scorched blue-grey metal
        MAT_GLASS,              // not a real chunk type, just plays an effect with glass sprites
        MAT_ELECTRICAL, // sparks only
        MAT_ELEC_METAL, // sparks/electrical type metal
        MAT_DRK_STONE,  // brown
        MAT_LT_STONE,   // tan
        MAT_GLASS_METAL,// glass sprites and METAl chunk
        MAT_METAL2,             // electrical metal type
        MAT_NONE,               // no chunks
        MAT_GREY_STONE, // grey
        MAT_METAL3,             // METAL and METAL2 chunks
        MAT_CRATE1,             // yellow multi-colored crate chunks
        MAT_GRATE1,             // grate chunks
        MAT_ROPE,               // for yavin trial...no chunks, just wispy bits
        MAT_CRATE2,             // read multi-colored crate chunks
        MAT_WHITE_METAL,// white angular chunks
        MAT_SNOWY_ROCK, // gray & brown chunks

        NUM_MATERIALS

};
typedef int material_t;

//rww - bot stuff that needs to be shared
#define MAX_WPARRAY_SIZE 4096
#define MAX_NEIGHBOR_SIZE 32

#define MAX_NEIGHBOR_LINK_DISTANCE 128
#define MAX_NEIGHBOR_FORCEJUMP_LINK_DISTANCE 400

#define DEFAULT_GRID_SPACING 400

typedef struct wpneighbor_s
{
        int num;
        int forceJumpTo;
} wpneighbor_t;

typedef struct wpobject_s
{
        vec3_t origin;
        int inuse;
        int index;
        float weight;
        float disttonext;
        int flags;
        int associated_entity;

        int forceJumpTo;

        int neighbornum;
        wpneighbor_t neighbors[MAX_NEIGHBOR_SIZE];
} wpobject_t;


#define NUMVERTEXNORMALS        162
extern  vec3_t  bytedirs[NUMVERTEXNORMALS];

// all drawing is done to a 640*480 virtual screen size
// and will be automatically scaled to the real resolution
#define SCREEN_WIDTH            640
#define SCREEN_HEIGHT           480

#define TINYCHAR_WIDTH          (SMALLCHAR_WIDTH)
#define TINYCHAR_HEIGHT         (SMALLCHAR_HEIGHT/2)

#define SMALLCHAR_WIDTH         8
#define SMALLCHAR_HEIGHT        16