codemp/game/g_ICARUScb.c

Go to the documentation of this file.

//====================================================================================
//
//rww - ICARUS callback file, all that can be handled within vm's is handled in here.
//
//====================================================================================

#include "q_shared.h"
#include "bg_public.h"
#include "b_local.h"
#include "../icarus/Q3_Interface.h"
#include "../icarus/Q3_Registers.h"
#include "g_nav.h"

#include "../namespace_begin.h"
qboolean BG_SabersOff( playerState_t *ps );
extern stringID_table_t WPTable[];
extern stringID_table_t BSTable[];
#include "../namespace_end.h"


//This is a hack I guess. It's because we can't include the file this enum is in
//unless we're using cpp. But we need it for the interpreter stuff.
//In any case, DO NOT modify this enum.

// Hack++
// This code is compiled as C++ on Xbox. We could try and rig something above
// so that we only get the C version of the includes (no full Icarus) in that
// scenario, but I think we'll just try to leave this out instead.
#ifndef _XBOX
#ifndef __linux__
enum
{
        TK_EOF = -1,
        TK_UNDEFINED,
        TK_COMMENT,
        TK_EOL,
        TK_CHAR,
        TK_STRING,
        TK_INT,
        TK_INTEGER = TK_INT,
        TK_FLOAT,
        TK_IDENTIFIER,
        TK_USERDEF,
};
#endif
#endif

#include "../icarus/interpreter.h"

extern stringID_table_t animTable [MAX_ANIMATIONS+1];

stringID_table_t setTable[] =
{
        ENUM2STRING(SET_SPAWNSCRIPT),//0
        ENUM2STRING(SET_USESCRIPT),
        ENUM2STRING(SET_AWAKESCRIPT),
        ENUM2STRING(SET_ANGERSCRIPT),
        ENUM2STRING(SET_ATTACKSCRIPT),
        ENUM2STRING(SET_VICTORYSCRIPT),
        ENUM2STRING(SET_PAINSCRIPT),
        ENUM2STRING(SET_FLEESCRIPT),
        ENUM2STRING(SET_DEATHSCRIPT),
        ENUM2STRING(SET_DELAYEDSCRIPT),
        ENUM2STRING(SET_BLOCKEDSCRIPT),
        ENUM2STRING(SET_FFIRESCRIPT),
        ENUM2STRING(SET_FFDEATHSCRIPT),
        ENUM2STRING(SET_MINDTRICKSCRIPT),
        ENUM2STRING(SET_NO_MINDTRICK),
        ENUM2STRING(SET_ORIGIN),
        ENUM2STRING(SET_TELEPORT_DEST),
        ENUM2STRING(SET_ANGLES),
        ENUM2STRING(SET_XVELOCITY),
        ENUM2STRING(SET_YVELOCITY),
        ENUM2STRING(SET_ZVELOCITY),
        ENUM2STRING(SET_Z_OFFSET),
        ENUM2STRING(SET_ENEMY),
        ENUM2STRING(SET_LEADER),
        ENUM2STRING(SET_NAVGOAL),
        ENUM2STRING(SET_ANIM_UPPER),
        ENUM2STRING(SET_ANIM_LOWER),
        ENUM2STRING(SET_ANIM_BOTH),
        ENUM2STRING(SET_ANIM_HOLDTIME_LOWER),
        ENUM2STRING(SET_ANIM_HOLDTIME_UPPER),
        ENUM2STRING(SET_ANIM_HOLDTIME_BOTH),
        ENUM2STRING(SET_PLAYER_TEAM),
        ENUM2STRING(SET_ENEMY_TEAM),
        ENUM2STRING(SET_BEHAVIOR_STATE),
        ENUM2STRING(SET_BEHAVIOR_STATE),
        ENUM2STRING(SET_HEALTH),
        ENUM2STRING(SET_ARMOR),
        ENUM2STRING(SET_DEFAULT_BSTATE),
        ENUM2STRING(SET_CAPTURE),
        ENUM2STRING(SET_DPITCH),
        ENUM2STRING(SET_DYAW),
        ENUM2STRING(SET_EVENT),
        ENUM2STRING(SET_TEMP_BSTATE),
        ENUM2STRING(SET_COPY_ORIGIN),
        ENUM2STRING(SET_VIEWTARGET),
        ENUM2STRING(SET_WEAPON),
        ENUM2STRING(SET_ITEM),
        ENUM2STRING(SET_WALKSPEED),
        ENUM2STRING(SET_RUNSPEED),
        ENUM2STRING(SET_YAWSPEED),
        ENUM2STRING(SET_AGGRESSION),
        ENUM2STRING(SET_AIM),
        ENUM2STRING(SET_FRICTION),
        ENUM2STRING(SET_GRAVITY),
        ENUM2STRING(SET_IGNOREPAIN),
        ENUM2STRING(SET_IGNOREENEMIES),
        ENUM2STRING(SET_IGNOREALERTS),
        ENUM2STRING(SET_DONTSHOOT),
        ENUM2STRING(SET_DONTFIRE),
        ENUM2STRING(SET_LOCKED_ENEMY),
        ENUM2STRING(SET_NOTARGET),
        ENUM2STRING(SET_LEAN),
        ENUM2STRING(SET_CROUCHED),
        ENUM2STRING(SET_WALKING),
        ENUM2STRING(SET_RUNNING),
        ENUM2STRING(SET_CHASE_ENEMIES),
        ENUM2STRING(SET_LOOK_FOR_ENEMIES),
        ENUM2STRING(SET_FACE_MOVE_DIR),
        ENUM2STRING(SET_ALT_FIRE),
        ENUM2STRING(SET_DONT_FLEE),
        ENUM2STRING(SET_FORCED_MARCH),
        ENUM2STRING(SET_NO_RESPONSE),
        ENUM2STRING(SET_NO_COMBAT_TALK),
        ENUM2STRING(SET_NO_ALERT_TALK),
        ENUM2STRING(SET_UNDYING),
        ENUM2STRING(SET_TREASONED),
        ENUM2STRING(SET_DISABLE_SHADER_ANIM),
        ENUM2STRING(SET_SHADER_ANIM),
        ENUM2STRING(SET_INVINCIBLE),
        ENUM2STRING(SET_NOAVOID),
        ENUM2STRING(SET_SHOOTDIST),
        ENUM2STRING(SET_TARGETNAME),
        ENUM2STRING(SET_TARGET),
        ENUM2STRING(SET_TARGET2),
        ENUM2STRING(SET_LOCATION),
        ENUM2STRING(SET_PAINTARGET),
        ENUM2STRING(SET_TIMESCALE),
        ENUM2STRING(SET_VISRANGE),
        ENUM2STRING(SET_EARSHOT),
        ENUM2STRING(SET_VIGILANCE),
        ENUM2STRING(SET_HFOV),
        ENUM2STRING(SET_VFOV),
        ENUM2STRING(SET_DELAYSCRIPTTIME),
        ENUM2STRING(SET_FORWARDMOVE),
        ENUM2STRING(SET_RIGHTMOVE),
        ENUM2STRING(SET_LOCKYAW),
        ENUM2STRING(SET_SOLID),
        ENUM2STRING(SET_CAMERA_GROUP),
        ENUM2STRING(SET_CAMERA_GROUP_Z_OFS),
        ENUM2STRING(SET_CAMERA_GROUP_TAG),
        ENUM2STRING(SET_LOOK_TARGET),
        ENUM2STRING(SET_ADDRHANDBOLT_MODEL),
        ENUM2STRING(SET_REMOVERHANDBOLT_MODEL),
        ENUM2STRING(SET_ADDLHANDBOLT_MODEL),
        ENUM2STRING(SET_REMOVELHANDBOLT_MODEL),
        ENUM2STRING(SET_FACEAUX),
        ENUM2STRING(SET_FACEBLINK),
        ENUM2STRING(SET_FACEBLINKFROWN),
        ENUM2STRING(SET_FACEFROWN),
        ENUM2STRING(SET_FACENORMAL),
        ENUM2STRING(SET_FACEEYESCLOSED),
        ENUM2STRING(SET_FACEEYESOPENED),
        ENUM2STRING(SET_SCROLLTEXT),
        ENUM2STRING(SET_LCARSTEXT),
        ENUM2STRING(SET_SCROLLTEXTCOLOR),
        ENUM2STRING(SET_CAPTIONTEXTCOLOR),
        ENUM2STRING(SET_CENTERTEXTCOLOR),
        ENUM2STRING(SET_PLAYER_USABLE),
        ENUM2STRING(SET_STARTFRAME),
        ENUM2STRING(SET_ENDFRAME),
        ENUM2STRING(SET_ANIMFRAME),
        ENUM2STRING(SET_LOOP_ANIM),
        ENUM2STRING(SET_INTERFACE),
        ENUM2STRING(SET_SHIELDS),
        ENUM2STRING(SET_NO_KNOCKBACK),
        ENUM2STRING(SET_INVISIBLE),
        ENUM2STRING(SET_VAMPIRE),
        ENUM2STRING(SET_FORCE_INVINCIBLE),
        ENUM2STRING(SET_GREET_ALLIES),
        ENUM2STRING(SET_PLAYER_LOCKED),
        ENUM2STRING(SET_LOCK_PLAYER_WEAPONS),
        ENUM2STRING(SET_NO_IMPACT_DAMAGE),
        ENUM2STRING(SET_PARM1),
        ENUM2STRING(SET_PARM2),
        ENUM2STRING(SET_PARM3),
        ENUM2STRING(SET_PARM4),
        ENUM2STRING(SET_PARM5),
        ENUM2STRING(SET_PARM6),
        ENUM2STRING(SET_PARM7),
        ENUM2STRING(SET_PARM8),
        ENUM2STRING(SET_PARM9),
        ENUM2STRING(SET_PARM10),
        ENUM2STRING(SET_PARM11),
        ENUM2STRING(SET_PARM12),
        ENUM2STRING(SET_PARM13),
        ENUM2STRING(SET_PARM14),
        ENUM2STRING(SET_PARM15),
        ENUM2STRING(SET_PARM16),
        ENUM2STRING(SET_DEFEND_TARGET),
        ENUM2STRING(SET_WAIT),
        ENUM2STRING(SET_COUNT),
        ENUM2STRING(SET_SHOT_SPACING),
        ENUM2STRING(SET_VIDEO_PLAY),
        ENUM2STRING(SET_VIDEO_FADE_IN),
        ENUM2STRING(SET_VIDEO_FADE_OUT),
        ENUM2STRING(SET_REMOVE_TARGET),
        ENUM2STRING(SET_LOADGAME),
        ENUM2STRING(SET_MENU_SCREEN),
        ENUM2STRING(SET_OBJECTIVE_SHOW),
        ENUM2STRING(SET_OBJECTIVE_HIDE),
        ENUM2STRING(SET_OBJECTIVE_SUCCEEDED),
        ENUM2STRING(SET_OBJECTIVE_FAILED),
        ENUM2STRING(SET_MISSIONFAILED),
        ENUM2STRING(SET_TACTICAL_SHOW),
        ENUM2STRING(SET_TACTICAL_HIDE),
        ENUM2STRING(SET_FOLLOWDIST),
        ENUM2STRING(SET_SCALE),
        ENUM2STRING(SET_OBJECTIVE_CLEARALL),
        ENUM2STRING(SET_MISSIONSTATUSTEXT),
        ENUM2STRING(SET_WIDTH),
        ENUM2STRING(SET_CLOSINGCREDITS),
        ENUM2STRING(SET_SKILL),
        ENUM2STRING(SET_MISSIONSTATUSTIME),
        ENUM2STRING(SET_FULLNAME),
        ENUM2STRING(SET_FORCE_HEAL_LEVEL),
        ENUM2STRING(SET_FORCE_JUMP_LEVEL),
        ENUM2STRING(SET_FORCE_SPEED_LEVEL),
        ENUM2STRING(SET_FORCE_PUSH_LEVEL),
        ENUM2STRING(SET_FORCE_PULL_LEVEL),
        ENUM2STRING(SET_FORCE_MINDTRICK_LEVEL),
        ENUM2STRING(SET_FORCE_GRIP_LEVEL),
        ENUM2STRING(SET_FORCE_LIGHTNING_LEVEL),
        ENUM2STRING(SET_SABER_THROW),
        ENUM2STRING(SET_SABER_DEFENSE),
        ENUM2STRING(SET_SABER_OFFENSE),
        ENUM2STRING(SET_VIEWENTITY),
        ENUM2STRING(SET_WATCHTARGET),
        ENUM2STRING(SET_SABERACTIVE),
        ENUM2STRING(SET_ADJUST_AREA_PORTALS),
        ENUM2STRING(SET_DMG_BY_HEAVY_WEAP_ONLY),
        ENUM2STRING(SET_SHIELDED),
        ENUM2STRING(SET_NO_GROUPS),
        ENUM2STRING(SET_FIRE_WEAPON),
        ENUM2STRING(SET_INACTIVE),
        ENUM2STRING(SET_FUNC_USABLE_VISIBLE),
        ENUM2STRING(SET_MISSION_STATUS_SCREEN),
        ENUM2STRING(SET_END_SCREENDISSOLVE),
        ENUM2STRING(SET_LOOPSOUND),
        ENUM2STRING(SET_ICARUS_FREEZE),
        ENUM2STRING(SET_ICARUS_UNFREEZE),
        ENUM2STRING(SET_USE_CP_NEAREST),
        ENUM2STRING(SET_MORELIGHT),
        ENUM2STRING(SET_CINEMATIC_SKIPSCRIPT),
        ENUM2STRING(SET_NO_FORCE),
        ENUM2STRING(SET_NO_FALLTODEATH),
        ENUM2STRING(SET_DISMEMBERABLE),
        ENUM2STRING(SET_NO_ACROBATICS),
        ENUM2STRING(SET_MUSIC_STATE),
        ENUM2STRING(SET_USE_SUBTITLES),
        ENUM2STRING(SET_CLEAN_DAMAGING_ENTS),
        ENUM2STRING(SET_HUD),

//FIXME: add BOTH_ attributes here too
        "",     SET_,
};

void Q3_TaskIDClear( int *taskID )
{
        *taskID = -1;
}

void G_DebugPrint( int level, const char *format, ... )
{
        va_list         argptr;
        char            text[1024];

        //Don't print messages they don't want to see
        //if ( g_ICARUSDebug->integer < level )
        if (g_developer.integer != 2)
                return;

        va_start (argptr, format);
        vsprintf (text, format, argptr);
        va_end (argptr);

        //Add the color formatting
        switch ( level )
        {
                case WL_ERROR:
                        Com_Printf ( S_COLOR_RED"ERROR: %s", text );
                        break;
                
                case WL_WARNING:
                        Com_Printf ( S_COLOR_YELLOW"WARNING: %s", text );
                        break;
                
                case WL_DEBUG:
                        {
                                int             entNum;
                                char    *buffer;

                                sscanf( text, "%d", &entNum );

                                //if ( ( ICARUS_entFilter >= 0 ) && ( ICARUS_entFilter != entNum ) )
                                //      return;

                                buffer = (char *) text;
                                buffer += 5;

                                if ( ( entNum < 0 ) || ( entNum > MAX_GENTITIES ) )
                                        entNum = 0;

                                Com_Printf ( S_COLOR_BLUE"DEBUG: %s(%d): %s\n", g_entities[entNum].script_targetname, entNum, buffer );
                                break;
                        }
                default:
                case WL_VERBOSE:
                        Com_Printf ( S_COLOR_GREEN"INFO: %s", text );
                        break;
        }
}

/*
-------------------------
Q3_GetAnimLower
-------------------------
*/
static char *Q3_GetAnimLower( gentity_t *ent )
{
        int anim = 0;

        if ( ent->client == NULL )
        {
                G_DebugPrint( WL_WARNING, "Q3_GetAnimLower: attempted to read animation state off non-client!\n" );
                return NULL;
        }

        anim = ent->client->ps.legsAnim;

        return (char *)animTable[anim].name;
}

/*
-------------------------
Q3_GetAnimUpper
-------------------------
*/
static char *Q3_GetAnimUpper( gentity_t *ent )
{
        int anim = 0;

        if ( ent->client == NULL )
        {
                G_DebugPrint( WL_WARNING, "Q3_GetAnimUpper: attempted to read animation state off non-client!\n" );
                return NULL;
        }

        anim = ent->client->ps.torsoAnim;

        return (char *)animTable[anim].name;
}

/*
-------------------------
Q3_GetAnimBoth
-------------------------
*/
static char *Q3_GetAnimBoth( gentity_t *ent )
{
        char    *lowerName, *upperName;

        lowerName = Q3_GetAnimLower( ent );
        upperName = Q3_GetAnimUpper( ent );

        if ( !lowerName || !lowerName[0] )
        {
                G_DebugPrint( WL_WARNING, "Q3_GetAnimBoth: NULL legs animation string found!\n" );
                return NULL;
        }

        if ( !upperName || !upperName[0] )
        {
                G_DebugPrint( WL_WARNING, "Q3_GetAnimBoth: NULL torso animation string found!\n" );
                return NULL;
        }

        if ( Q_stricmp( lowerName, upperName ) )
        {
#ifdef _DEBUG   // sigh, cut down on tester reports that aren't important
                G_DebugPrint( WL_WARNING, "Q3_GetAnimBoth: legs and torso animations did not match : returning legs\n" );
#endif
        }

        return lowerName;
}

int Q3_PlaySound( int taskID, int entID, const char *name, const char *channel )
{
        gentity_t               *ent = &g_entities[entID];
        char                    finalName[MAX_QPATH];
        soundChannel_t  voice_chan = CHAN_VOICE; // set a default so the compiler doesn't bitch
        qboolean                type_voice = qfalse;
        int                             soundHandle;
        qboolean                bBroadcast;

        Q_strncpyz( finalName, name, MAX_QPATH );
        Q_strupr(finalName);
        //G_AddSexToMunroString( finalName, qtrue );

        COM_StripExtension( (const char *)finalName, finalName );

        soundHandle = G_SoundIndex( (char *) finalName );
        bBroadcast = qfalse;

        if ( ( Q_stricmp( channel, "CHAN_ANNOUNCER" ) == 0 ) || (ent->classname && Q_stricmp("target_scriptrunner", ent->classname ) == 0) ) {
                bBroadcast = qtrue;
        }


        // moved here from further down so I can easily check channel-type without code dup...
        //
        if ( Q_stricmp( channel, "CHAN_VOICE" ) == 0 )
        {
                voice_chan = CHAN_VOICE;
                type_voice = qtrue;
        }
        else if ( Q_stricmp( channel, "CHAN_VOICE_ATTEN" ) == 0 )
        {
                voice_chan = CHAN_AUTO;//CHAN_VOICE_ATTEN;
                type_voice = qtrue;
        }
        else if ( Q_stricmp( channel, "CHAN_VOICE_GLOBAL" ) == 0 ) // this should broadcast to everyone, put only casue animation on G_SoundOnEnt...
        {
                voice_chan = CHAN_AUTO;//CHAN_VOICE_GLOBAL;
                type_voice = qtrue;
                bBroadcast = qtrue;
        }

        // if we're in-camera, check for skipping cinematic and ifso, no subtitle print (since screen is not being
        //      updated anyway during skipping). This stops leftover subtitles being left onscreen after unskipping.
        //
        /*
        if (!in_camera ||
                (!g_skippingcin || !g_skippingcin->integer)
                )       // paranoia towards project end <g>
        {
                // Text on
                // certain NPC's we always want to use subtitles regardless of subtitle setting
                if (g_subtitles->integer == 1 || (ent->NPC && (ent->NPC->scriptFlags & SCF_USE_SUBTITLES) ) ) // Show all text
                {
                        if ( in_camera) // Cinematic
                        {                                       
                                trap_SendServerCommand( -1, va("ct \"%s\" %i", finalName, soundHandle) );
                        }
                        else //if (precacheWav[i].speaker==SP_NONE)     //  lower screen text
                        {
                                sharedEntity_t          *ent2 = SV_GentityNum(0);
                                // the numbers in here were either the original ones Bob entered (350), or one arrived at from checking the distance Chell stands at in stasis2 by the computer core that was submitted as a bug report...
                                //
                                if (bBroadcast || (DistanceSquared(ent->currentOrigin, ent2->currentOrigin) < ((voice_chan == CHAN_VOICE_ATTEN)?(350 * 350):(1200 * 1200)) ) )
                                {
                                        trap_SendServerCommand( -1, va("ct \"%s\" %i", finalName, soundHandle) );
                                }
                        }
                }
                // Cinematic only
                else if (g_subtitles->integer == 2) // Show only talking head text and CINEMATIC
                {
                        if ( in_camera) // Cinematic text
                        {                                                       
                                trap_SendServerCommand( -1, va("ct \"%s\" %i", finalName, soundHandle));
                        }
                }

        }
        */

        if ( type_voice )
        {
                char buf[128];
                float tFVal = 0;

                trap_Cvar_VariableStringBuffer("timescale", buf, sizeof(buf));

                tFVal = atof(buf);


                if ( tFVal > 1.0f )
                {//Skip the damn sound!
                        return qtrue;
                }
                else
                {
                        //This the voice channel
                        G_Sound( ent, voice_chan, G_SoundIndex((char *) finalName) );
                }
                //Remember we're waiting for this
                trap_ICARUS_TaskIDSet( ent, TID_CHAN_VOICE, taskID );

                return qfalse;
        }

        if ( bBroadcast )
        {//Broadcast the sound
                gentity_t       *te;

                te = G_TempEntity( ent->r.currentOrigin, EV_GLOBAL_SOUND );
                te->s.eventParm = soundHandle;
                te->r.svFlags |= SVF_BROADCAST;
        }
        else
        {
                G_Sound( ent, CHAN_AUTO, soundHandle );
        }

        return qtrue;
}

/*
-------------------------
Q3_Play
-------------------------
*/
void Q3_Play( int taskID, int entID, const char *type, const char *name )
{
        gentity_t *ent = &g_entities[entID];

        if ( !Q_stricmp( type, "PLAY_ROFF" ) )
        {
                // Try to load the requested ROFF
                ent->roffid = trap_ROFF_Cache((char*)name);
                if ( ent->roffid )
                {
                        ent->roffname = G_NewString( name );

                        // Start the roff from the beginning
                        //ent->roff_ctr = 0;

                        //Save this off for later
                        trap_ICARUS_TaskIDSet( ent, TID_MOVE_NAV, taskID );

                        // Let the ROFF playing start.
                        //ent->next_roff_time = level.time;

                        //rww - Maybe use pos1 and pos2? I don't think we need to care if these values are sent across the net.
                        // These need to be initialised up front...
                        //VectorCopy( ent->r.currentOrigin, ent->pos1 );
                        //VectorCopy( ent->r.currentAngles, ent->pos2 );
                        VectorCopy( ent->r.currentOrigin, ent->s.origin2 );
                        VectorCopy( ent->r.currentAngles, ent->s.angles2 );
                        
                        trap_LinkEntity( ent );

                        trap_ROFF_Play(ent->s.number, ent->roffid, qtrue);
                }
        }
}

/*
=============
anglerCallback

Utility function
=============
*/
void anglerCallback( gentity_t *ent )
{
        //Complete the task
        trap_ICARUS_TaskIDComplete( ent, TID_ANGLE_FACE );

        //Set the currentAngles, clear all movement
        VectorMA( ent->s.apos.trBase, (ent->s.apos.trDuration*0.001f), ent->s.apos.trDelta, ent->r.currentAngles );
        VectorCopy( ent->r.currentAngles, ent->s.apos.trBase );
        VectorClear( ent->s.apos.trDelta );
        ent->s.apos.trDuration = 1;
        ent->s.apos.trType = TR_STATIONARY;
        ent->s.apos.trTime = level.time;

        //Stop thinking
        ent->reached = 0;
        if ( ent->think == anglerCallback )
        {
                ent->think = 0;
        }

        //link
        trap_LinkEntity( ent );
}

void MatchTeam( gentity_t *teamLeader, int moverState, int time );
void Blocked_Mover( gentity_t *ent, gentity_t *other );

/*
=============
moverCallback

Utility function
=============
*/
void moverCallback( gentity_t *ent )
{       //complete the task
        trap_ICARUS_TaskIDComplete( ent, TID_MOVE_NAV );
        
        // play sound
        ent->s.loopSound = 0;//stop looping sound
        ent->s.loopIsSoundset = qfalse;
        G_PlayDoorSound( ent, BMS_END );//play end sound

        if ( ent->moverState == MOVER_1TO2 ) 
        {//reached open
                // reached pos2
                MatchTeam( ent, MOVER_POS2, level.time );
                //SetMoverState( ent, MOVER_POS2, level.time );
        } 
        else if ( ent->moverState == MOVER_2TO1 ) 
        {//reached closed
                MatchTeam( ent, MOVER_POS1, level.time );
                //SetMoverState( ent, MOVER_POS1, level.time );
        }

        if ( ent->blocked == Blocked_Mover )
        {
                ent->blocked = 0;
        }

//      if ( !Q_stricmp( "misc_model_breakable", ent->classname ) && ent->physicsBounce )
//      {//a gravity-affected model
//              misc_model_breakable_gravity_init( ent, qfalse );
//      }
}

void Blocked_Mover( gentity_t *ent, gentity_t *other )
{
        // remove anything other than a client -- no longer the case

        // don't remove security keys or goodie keys
        if ( (other->s.eType == ET_ITEM) )
        {
                // should we be doing anything special if a key blocks it... move it somehow..?
        }
        // if your not a client, or your a dead client remove yourself...
        else if ( other->s.number && (!other->client || (other->client && other->health <= 0 && other->r.contents == CONTENTS_CORPSE && !other->message)) )
        {
                //if ( !other->taskManager || !other->taskManager->IsRunning() )
                {
                        // if an item or weapon can we do a little explosion..?
                        G_FreeEntity( other );
                        return;
                }
        }

        if ( ent->damage ) {
                G_Damage( other, ent, ent, NULL, NULL, ent->damage, 0, MOD_CRUSH );
        }
}

/*
=============
moveAndRotateCallback

Utility function
=============
*/
void moveAndRotateCallback( gentity_t *ent )
{
        //stop turning
        anglerCallback( ent );
        //stop moving
        moverCallback( ent );
}

/*
=============
Q3_Lerp2Start

Lerps the origin of an entity to its starting position
=============
*/
void Q3_Lerp2Start( int entID, int taskID, float duration )
{
        gentity_t       *ent = &g_entities[entID];

        if(!ent)
        {       
                G_DebugPrint( WL_WARNING, "Q3_Lerp2Start: invalid entID %d\n", entID);
                return;
        }
        
        if ( ent->client || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
        {
                G_DebugPrint( WL_ERROR, "Q3_Lerp2Start: ent %d is NOT a mover!\n", entID);
                return;
        }

        if ( ent->s.eType != ET_MOVER )
        {
                ent->s.eType = ET_MOVER;
        }

        //FIXME: set up correctly!!!
        ent->moverState = MOVER_2TO1;
        ent->s.eType = ET_MOVER;
        ent->reached = moverCallback;           //Callsback the the completion of the move
        if ( ent->damage )
        {
                ent->blocked = Blocked_Mover;
        }

        ent->s.pos.trDuration = duration * 10;  //In seconds
        ent->s.pos.trTime = level.time;
        
        trap_ICARUS_TaskIDSet( ent, TID_MOVE_NAV, taskID );
        // starting sound
        G_PlayDoorLoopSound( ent );
        G_PlayDoorSound( ent, BMS_START );      //??

        trap_LinkEntity( ent );
}

/*
=============
Q3_Lerp2End

Lerps the origin of an entity to its ending position
=============
*/
void Q3_Lerp2End( int entID, int taskID, float duration )
{
        gentity_t       *ent = &g_entities[entID];

        if(!ent)
        {
                G_DebugPrint( WL_WARNING, "Q3_Lerp2End: invalid entID %d\n", entID);
                return;
        }
        
        if ( ent->client || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
        {
                G_DebugPrint( WL_ERROR, "Q3_Lerp2End: ent %d is NOT a mover!\n", entID);
                return;
        }

        if ( ent->s.eType != ET_MOVER )
        {
                ent->s.eType = ET_MOVER;
        }

        //FIXME: set up correctly!!!
        ent->moverState = MOVER_1TO2;
        ent->s.eType = ET_MOVER;
        ent->reached = moverCallback;           //Callsback the the completion of the move
        if ( ent->damage )
        {
                ent->blocked = Blocked_Mover;
        }

        ent->s.pos.trDuration = duration * 10;  //In seconds
        ent->s.time = level.time;
        
        trap_ICARUS_TaskIDSet( ent, TID_MOVE_NAV, taskID );
        // starting sound
        G_PlayDoorLoopSound( ent );
        G_PlayDoorSound( ent, BMS_START );      //??

        trap_LinkEntity( ent );
}

void InitMoverTrData( gentity_t *ent );

/*
=============
Q3_Lerp2Pos

Lerps the origin and angles of an entity to the destination values

=============
*/
void Q3_Lerp2Pos( int taskID, int entID, vec3_t origin, vec3_t angles, float duration )
{
        gentity_t       *ent = &g_entities[entID];
        vec3_t          ang;
        int                     i;
        moverState_t moverState;

        if(!ent)
        {
                G_DebugPrint( WL_WARNING, "Q3_Lerp2Pos: invalid entID %d\n", entID);
                return;
        }
        
        if ( ent->client || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
        {
                G_DebugPrint( WL_ERROR, "Q3_Lerp2Pos: ent %d is NOT a mover!\n", entID);
                return;
        }

        if ( ent->s.eType != ET_MOVER )
        {
                ent->s.eType = ET_MOVER;
        }

        //Don't allow a zero duration
        if ( duration == 0 )
                duration = 1;

        //
        // Movement

        moverState = ent->moverState;

        if ( moverState == MOVER_POS1 || moverState == MOVER_2TO1 )
        {
                VectorCopy( ent->r.currentOrigin, ent->pos1 );
                VectorCopy( origin, ent->pos2 );

                moverState = MOVER_1TO2;
        }
        else
        {
                VectorCopy( ent->r.currentOrigin, ent->pos2 );
                VectorCopy( origin, ent->pos1 );

                moverState = MOVER_2TO1;
        }

        InitMoverTrData( ent );

        ent->s.pos.trDuration = duration;

        // start it going
        MatchTeam( ent, moverState, level.time );
        //SetMoverState( ent, moverState, level.time );

        //Only do the angles if specified
        if ( angles != NULL )
        {
                //
                // Rotation

                for ( i = 0; i < 3; i++ )
                {
                        ang[i] = AngleDelta( angles[i], ent->r.currentAngles[i] );
                        ent->s.apos.trDelta[i] = ( ang[i] / ( duration * 0.001f ) );
                }

                VectorCopy( ent->r.currentAngles, ent->s.apos.trBase );

                if ( ent->alt_fire )
                {
                        ent->s.apos.trType = TR_LINEAR_STOP;
                }
                else
                {
                        ent->s.apos.trType = TR_NONLINEAR_STOP;
                }
                ent->s.apos.trDuration = duration;

                ent->s.apos.trTime = level.time;

                ent->reached = moveAndRotateCallback;
                trap_ICARUS_TaskIDSet( ent, TID_ANGLE_FACE, taskID );
        }
        else
        {
                //Setup the last bits of information
                ent->reached = moverCallback;
        }

        if ( ent->damage )
        {
                ent->blocked = Blocked_Mover;
        }

        trap_ICARUS_TaskIDSet( ent, TID_MOVE_NAV, taskID );
        // starting sound
        G_PlayDoorLoopSound( ent );
        G_PlayDoorSound( ent, BMS_START );      //??

        trap_LinkEntity( ent );
}

/*
=============
Q3_LerpAngles

Lerps the angles to the destination value
=============
*/
void Q3_Lerp2Angles( int taskID, int entID, vec3_t angles, float duration )
{
        gentity_t       *ent = &g_entities[entID];
        vec3_t          ang;
        int                     i;

        if(!ent)
        {
                G_DebugPrint( WL_WARNING, "Q3_Lerp2Angles: invalid entID %d\n", entID);
                return;
        }
        
        if ( ent->client || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
        {
                G_DebugPrint( WL_ERROR, "Q3_Lerp2Angles: ent %d is NOT a mover!\n", entID);
                return;
        }

        //If we want an instant move, don't send 0...
        ent->s.apos.trDuration = (duration>0) ? duration : 1;

        for ( i = 0; i < 3; i++ )
        {
                ang [i] = AngleSubtract( angles[i], ent->r.currentAngles[i]);
                ent->s.apos.trDelta[i] = ( ang[i] / ( ent->s.apos.trDuration * 0.001f ) );
        }

        VectorCopy( ent->r.currentAngles, ent->s.apos.trBase );

        if ( ent->alt_fire )
        {
                ent->s.apos.trType = TR_LINEAR_STOP;
        }
        else
        {
                ent->s.apos.trType = TR_NONLINEAR_STOP;
        }

        ent->s.apos.trTime = level.time;
        
        trap_ICARUS_TaskIDSet( ent, TID_ANGLE_FACE, taskID );

        //ent->e_ReachedFunc = reachedF_NULL;
        ent->think = anglerCallback;
        ent->nextthink = level.time + duration;

        trap_LinkEntity( ent );
}

/*
=============
Q3_GetTag

Gets the value of a tag by the give name
=============
*/
int     Q3_GetTag( int entID, const char *name, int lookup, vec3_t info )
{
        gentity_t       *ent = &g_entities[entID];

        if (!ent->inuse)
        {
                assert(0);
                return 0;
        }

        switch ( lookup )
        {
        case TYPE_ORIGIN:
                return TAG_GetOrigin( ent->ownername, name, info );
                break;

        case TYPE_ANGLES:
                return TAG_GetAngles( ent->ownername, name, info );
                break;  
        }

        return 0;
}

//-----------------------------------------------

/*
============
Q3_Use

Uses an entity
============
*/
void Q3_Use( int entID, const char *target )
{
        gentity_t       *ent  = &g_entities[entID];
        
        if ( !ent )
        {
                G_DebugPrint( WL_WARNING, "Q3_Use: invalid entID %d\n", entID);
                return;
        }

        if( !target || !target[0] )
        {
                G_DebugPrint( WL_WARNING, "Q3_Use: string is NULL!\n" );
                return;
        }

        G_UseTargets2(ent, ent, target);
}

/*
============
Q3_Kill
  Description   : 
  Return type   : void 
  Argument              :  int entID
  Argument              : const char *name
============
*/
void Q3_Kill( int entID, const char *name )
{
        gentity_t       *ent = &g_entities[entID];
        gentity_t       *victim = NULL;
        int                     o_health;

        if( !Q_stricmp( name, "self") )
        {
                victim = ent;
        }
        else if( !Q_stricmp( name, "enemy" ) )
        {
                victim = ent->enemy;
        }
        else
        {
                victim = G_Find (NULL, FOFS(targetname), (char *) name );
        }

        if ( !victim )
        {
                G_DebugPrint( WL_WARNING, "Q3_Kill: can't find %s\n", name);
                return;
        }

        //rww - I guess this would only apply to NPCs anyway. I'm not going to bother.
        //if ( victim == ent )
        //{//don't ICARUS_FreeEnt me, I'm in the middle of a script!  (FIXME: shouldn't ICARUS handle this internally?)
        //      victim->svFlags |= SVF_KILLED_SELF;
        //}

        o_health = victim->health;
        victim->health = 0;
        if ( victim->client )
        {
                victim->flags |= FL_NO_KNOCKBACK;
        }
        //G_SetEnemy(victim, ent);
        if( victim->die != NULL )       // check can be omitted
        {
                //GEntity_DieFunc( victim, NULL, NULL, o_health, MOD_UNKNOWN );
                victim->die(victim, victim, victim, o_health, MOD_UNKNOWN);
        }
}

/*
============
Q3_RemoveEnt
  Description   : 
  Return type   : void 
  Argument              : sharedEntity_t *victim
============
*/
void Q3_RemoveEnt( gentity_t *victim )
{
        if( victim->client )
        {
                if ( victim->s.eType != ET_NPC )
                {
                        G_DebugPrint( WL_WARNING, "Q3_RemoveEnt: You can't remove clients in MP!\n" );
                        assert(0); //can't remove clients in MP
                }
                else
                {//remove the NPC
                        if ( victim->client->NPC_class == CLASS_VEHICLE )
                        {//eject everyone out of a vehicle that's about to remove itself
                                Vehicle_t *pVeh = victim->m_pVehicle;
                                if ( pVeh && pVeh->m_pVehicleInfo )
                                {
                                        pVeh->m_pVehicleInfo->EjectAll( pVeh );
                                }
                        }
                        victim->think = G_FreeEntity;
                        victim->nextthink = level.time + 100;
                }
                /*
                //ClientDisconnect(ent);
                victim->s.eFlags |= EF_NODRAW;
                victim->s.eType = ET_INVISIBLE;
                victim->contents = 0;
                victim->health = 0;
                victim->targetname = NULL;

                if ( victim->NPC && victim->NPC->tempGoal != NULL )
                {
                        G_FreeEntity( victim->NPC->tempGoal );
                        victim->NPC->tempGoal = NULL;
                }
                if ( victim->client->ps.saberEntityNum != ENTITYNUM_NONE && victim->client->ps.saberEntityNum > 0 )
                {
                        if ( g_entities[victim->client->ps.saberEntityNum].inuse )
                        {
                                G_FreeEntity( &g_entities[victim->client->ps.saberEntityNum] );
                        }
                        victim->client->ps.saberEntityNum = ENTITYNUM_NONE;
                }
                //Disappear in half a second
                victim->e_ThinkFunc = thinkF_G_FreeEntity;
                victim->nextthink = level.time + 500;
                return;
                */
        }
        else
        {
                victim->think = G_FreeEntity;
                victim->nextthink = level.time + 100;
        }
}


/*
============
Q3_Remove
  Description   : 
  Return type   : void 
  Argument              :  int entID
  Argument              : const char *name
============
*/
void Q3_Remove( int entID, const char *name )
{
        gentity_t *ent = &g_entities[entID];
        gentity_t       *victim = NULL;

        if( !Q_stricmp( "self", name ) )
        {
                victim = ent;
                if ( !victim )
                {
                        G_DebugPrint( WL_WARNING, "Q3_Remove: can't find %s\n", name );
                        return;
                }
                Q3_RemoveEnt( victim );
        }
        else if( !Q_stricmp( "enemy", name ) )
        {
                victim = ent->enemy;
                if ( !victim )
                {
                        G_DebugPrint( WL_WARNING, "Q3_Remove: can't find %s\n", name );
                        return;
                }
                Q3_RemoveEnt( victim );
        }
        else
        {
                victim = G_Find( NULL, FOFS(targetname), (char *) name );
                if ( !victim )
                {
                        G_DebugPrint( WL_WARNING, "Q3_Remove: can't find %s\n", name );
                        return;
                }

                while ( victim )
                {
                        Q3_RemoveEnt( victim );
                        victim = G_Find( victim, FOFS(targetname), (char *) name );
                }
        }
}

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

  Get / Set Functions

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

/*
============
Q3_GetFloat
  Description   : 
  Return type   : int 
  Argument              :  int entID
  Argument              : int type
  Argument              : const char *name
  Argument              : float *value
============
*/
int Q3_GetFloat( int entID, int type, const char *name, float *value )
{
        gentity_t       *ent = &g_entities[entID];
        int toGet = 0;

        if ( !ent )
        {
                return 0;
        }

        toGet = GetIDForString( setTable, name );       //FIXME: May want to make a "getTable" as well
        //FIXME: I'm getting really sick of these huge switch statements!

        //NOTENOTE: return true if the value was correctly obtained
        switch ( toGet )
        {
        case SET_PARM1:
        case SET_PARM2:
        case SET_PARM3:
        case SET_PARM4:
        case SET_PARM5:
        case SET_PARM6:
        case SET_PARM7:
        case SET_PARM8:
        case SET_PARM9:
        case SET_PARM10:
        case SET_PARM11:
        case SET_PARM12:
        case SET_PARM13:
        case SET_PARM14:
        case SET_PARM15:
        case SET_PARM16:
                if (ent->parms == NULL)
                {
                        G_DebugPrint( WL_ERROR, "GET_PARM: %s %s did not have any parms set!\n", ent->classname, ent->targetname );
                        return 0;       // would prefer qfalse, but I'm fitting in with what's here <sigh>
                }
                *value = atof( ent->parms->parm[toGet - SET_PARM1] );
                break;
        
        case SET_COUNT:
                *value = ent->count;
                break;

        case SET_HEALTH:
                *value = ent->health;
                break;

        case SET_SKILL:
                return 0;
                break;

        case SET_XVELOCITY://## %f="0.0" # Velocity along X axis
                if ( ent->client == NULL )
                {
                        G_DebugPrint( WL_WARNING, "Q3_GetFloat: SET_XVELOCITY, %s not a client\n", ent->targetname );
                        return 0;
                }
                *value = ent->client->ps.velocity[0];
                break;

        case SET_YVELOCITY://## %f="0.0" # Velocity along Y axis
                if ( ent->client == NULL )
                {
                        G_DebugPrint( WL_WARNING, "Q3_GetFloat: SET_YVELOCITY, %s not a client\n", ent->targetname );
                        return 0;
                }
                *value = ent->client->ps.velocity[1];
                break;

        case SET_ZVELOCITY://## %f="0.0" # Velocity along Z axis
                if ( ent->client == NULL )
                {
                        G_DebugPrint( WL_WARNING, "Q3_GetFloat: SET_ZVELOCITY, %s not a client\n", ent->targetname );
                        return 0;
                }
                *value = ent->client->ps.velocity[2];
                break;

        case SET_Z_OFFSET:
                *value = ent->r.currentOrigin[2] - ent->s.origin[2];
                break;

        case SET_DPITCH://## %f="0.0" # Pitch for NPC to turn to
                return 0;
                break;

        case SET_DYAW://## %f="0.0" # Yaw for NPC to turn to
                return 0;
                break;

        case SET_WIDTH://## %f="0.0" # Width of NPC bounding box
                *value = ent->r.mins[0];
                break;
        case SET_TIMESCALE://## %f="0.0" # Speed-up slow down game (0 - 1.0)
                return 0;
                break;
        case SET_CAMERA_GROUP_Z_OFS://## %s="NULL" # all ents with this cameraGroup will be focused on
                return 0;
                break;

        case SET_VISRANGE://## %f="0.0" # How far away NPC can see
                return 0;
                break;

        case SET_EARSHOT://## %f="0.0" # How far an NPC can hear
                return 0;
                break;

        case SET_VIGILANCE://## %f="0.0" # How often to look for enemies (0 - 1.0)
                return 0;
                break;

        case SET_GRAVITY://## %f="0.0" # Change this ent's gravity - 800 default
                *value = g_gravity.value;
                break;

        case SET_FACEEYESCLOSED:
        case SET_FACEEYESOPENED:
        case