2015/sin-2015
0
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity
sin-2015/actor.cpp

5692 lines
112 KiB
C++
Raw Permalink Normal View History

as released 1999-04-22
1999-04-22 00:00:00 +00:00
// Copyright (C) 1998 by Ritual Entertainment, Inc.
// All rights reserved.
//
// This source may not be distributed and/or modified without
// expressly written permission by Ritual Entertainment, Inc.
//
// DESCRIPTION:
// Base class for character AI.
//
#include "g_local.h"
#include "actor.h"
#include "behavior.h"
#include "scriptmaster.h"
#include "doors.h"
#include "gibs.h"
#include "vehicle.h"
#include "misc.h"
#include "specialfx.h"
#include "object.h"
#include "scriptslave.h"
#include "explosion.h"
#include "misc.h"
//###
#include "flamethrower.h"
#include "crawler.h"
#include "hoverbike.h"
//###
//#define DEBUG_PRINT
CLASS_DECLARATION( Class, ActorState, NULL );
ResponseDef ActorState::Responses[] =
{
{ NULL, NULL }
};
cvar_t *ai_actorscript;
#define TURN_SPEED 30
CLASS_DECLARATION( Sentient, Actor, "monster_generic" );
Event EV_Actor_CrouchSize( "crouchsize" );
Event EV_Actor_Fov( "fov" );
Event EV_Actor_VisionDistance( "visiondistance" );
Event EV_Actor_Start( "start" );
Event EV_Actor_Dead( "dead" );
Event EV_Actor_ClearState( "clearstate" );
Event EV_Actor_SetState( "state" );
Event EV_Actor_SetBehavior( "behavior" );
Event EV_Actor_Friend( "friend" ); // Allied to player
Event EV_Actor_Civilian( "civilian" ); // Nuetral to all, runs from danger
Event EV_Actor_Enemy( "enemy" ); // Enemy to player
Event EV_Actor_Monster( "monster" ); // Enemy to player, civilians, and inanimate objects
Event EV_Actor_Animal( "animal" ); // neutral to all
Event EV_Actor_Inanimate( "inanimate" ); // Inanimate objects
Event EV_Actor_Swim( "swim" ); // specifies actor as being able to swim
Event EV_Actor_Fly( "fly" ); // specifies actor as being able to swim
Event EV_Actor_NotLand( "noland" ); // specifies actor as not being able to walk on land
Event EV_Actor_TargetEnemies( "targetenemies" );
// Scripting
Event EV_Actor_Script( "script" );
Event EV_Actor_Thread( "thread" );
Event EV_Actor_IfEnemyVisible( "ifenemyvisible" );
Event EV_Actor_IfNear( "ifnear" );
Event EV_Actor_ForwardSpeed( "forwardspeed" );
Event EV_Actor_Idle( "idle" );
Event EV_Actor_LookAt( "lookat" );
Event EV_Actor_TurnTo( "turnto" );
Event EV_Actor_FinishedBehavior( "finishedbehavior" );
Event EV_Actor_NotifyBehavior( "notifybehavior" );
Event EV_Actor_WalkTo( "walkto" );
Event EV_Actor_JumpTo( "jumpto" );
Event EV_Actor_RunTo( "runto" );
Event EV_Actor_Anim( "anim" );
Event EV_Actor_Attack( "attack" );
Event EV_Actor_AttackPlayer( "attackplayer" );
Event EV_Actor_ReserveNode( "reservenode" );
Event EV_Actor_ReleaseNode( "releasenode" );
Event EV_Actor_IfCanHideAt( "ifcanhideat" );
Event EV_Actor_IfCanStrafeAttack( "ifcanstrafeattack" );
Event EV_Actor_IfCanMeleeAttack( "ifcanmeleeattack" );
Event EV_Actor_IfCanShoot( "ifcanshoot" );
Event EV_Actor_IfEnemyWithin( "ifenemywithin" );
Event EV_Actor_IgnoreSounds( "ignoresounds" );
Event EV_Actor_RespondToSounds( "respondtosounds" );
Event EV_Actor_IgnoreAll( "ignoreall" );
Event EV_Actor_RespondToAll( "respondtoall" );
Event EV_Actor_RespondTo( "respondto" );
Event EV_Actor_Ignore( "ignore" );
Event EV_Actor_DefineState( "definestate" );
Event EV_Actor_CopyState( "copystate" );
Event EV_Actor_Remove( "remove_useless" );
Event EV_Actor_ForwardToBehavior( "forwardcommand" );
Event EV_Actor_Aim( "aim" );
Event EV_Actor_MeleeRange( "meleerange" );
Event EV_Actor_MeleeDamage( "meleedamage" );
Event EV_Actor_Melee( "melee" );
Event EV_Actor_AttackFinished( "attack_finished" );
Event EV_Actor_CanStrafe( "canstrafe" );
Event EV_Actor_NoStrafe( "nostrafe" );
Event EV_Actor_PainThreshold( "painthreshold" );
Event EV_Actor_SetKillThread( "killthread" );
Event EV_Actor_AttackRange( "attackrange" );
Event EV_Actor_ShotsPerAttack( "shotsperattack" );
Event EV_Actor_ClearEnemy( "clearenemy" );
Event EV_Actor_AttackMode( "attackmode" );
Event EV_Actor_EyePositionOffset( "eyeoffset" );
Event EV_Actor_NoDeathFade( "nodeathfade" );
Event EV_Actor_NoChatter( "nochatter" );
Event EV_Actor_TurnSpeed( "turnspeed" );
Event EV_Actor_GotoObject("gotoobject"); //###
ResponseDef StateInfo::Responses[] =
{
{ NULL, NULL }
};
CLASS_DECLARATION( Class, StateInfo, NULL );
StateInfo::StateInfo()
{
ignore = true;
}
ResponseDef Actor::Responses[] =
{
{ &EV_Activate, ( Response )Actor::ActivateEvent },
{ &EV_Use, ( Response )Actor::UseEvent },
{ &EV_Actor_Start, ( Response )Actor::Start },
{ &EV_Pain, ( Response )Actor::Pain },
{ &EV_Killed, ( Response )Actor::Killed },
{ &EV_Actor_Dead, ( Response )Actor::Dead },
{ &EV_Actor_TargetEnemies, ( Response )Actor::TargetEnemies },
{ &EV_Actor_SetBehavior, ( Response )Actor::SetBehaviorEvent },
{ &EV_Actor_ForwardSpeed, ( Response )Actor::ForwardSpeedEvent },
{ &EV_Actor_CrouchSize, ( Response )Actor::CrouchSize },
{ &EV_Actor_Fov, ( Response )Actor::SetFov },
{ &EV_Actor_VisionDistance, ( Response )Actor::SetVisionDistance },
{ &EV_Actor_Friend, ( Response )Actor::FriendEvent },
{ &EV_Actor_Civilian, ( Response )Actor::CivilianEvent },
{ &EV_Actor_Enemy, ( Response )Actor::EnemyEvent },
{ &EV_Actor_Monster, ( Response )Actor::MonsterEvent },
{ &EV_Actor_Animal, ( Response )Actor::AnimalEvent },
{ &EV_Actor_Inanimate, ( Response )Actor::InanimateEvent },
{ &EV_Actor_Swim, ( Response )Actor::SwimEvent },
{ &EV_Actor_Fly, ( Response )Actor::FlyEvent },
{ &EV_Actor_NotLand, ( Response )Actor::NotLandEvent },
{ &EV_Gib, ( Response )Actor::GibEvent },
// Scripting
{ &EV_Actor_DefineState, ( Response )Actor::DefineStateEvent },
{ &EV_Actor_CopyState, ( Response )Actor::CopyStateEvent },
{ &EV_Actor_IgnoreAll, ( Response )Actor::IgnoreAllEvent },
{ &EV_Actor_RespondToAll, ( Response )Actor::RespondToAllEvent },
{ &EV_Actor_RespondTo, ( Response )Actor::RespondToEvent },
{ &EV_Actor_Ignore, ( Response )Actor::IgnoreEvent },
{ &EV_Actor_IgnoreSounds, ( Response )Actor::IgnoreSoundsEvent },
{ &EV_Actor_RespondToSounds, ( Response )Actor::RespondToSoundsEvent },
{ &EV_Actor_ClearState, ( Response )Actor::ClearStateEvent },
{ &EV_ScriptThread_End, ( Response )Actor::StateDoneEvent },
{ &EV_Actor_SetState, ( Response )Actor::SetStateEvent },
{ &EV_Actor_Script, ( Response )Actor::SetScript },
{ &EV_Actor_Thread, ( Response )Actor::SetThread },
{ &EV_Actor_IfEnemyVisible, ( Response )Actor::IfEnemyVisibleEvent },
{ &EV_Actor_IfNear, ( Response )Actor::IfNearEvent },
{ &EV_Actor_Idle, ( Response )Actor::IdleEvent },
{ &EV_ProcessCommands, ( Response )Actor::StartMove },
{ &EV_Actor_LookAt, ( Response )Actor::LookAt },
{ &EV_Actor_TurnTo, ( Response )Actor::TurnToEvent },
{ &EV_Actor_FinishedBehavior, ( Response )Actor::FinishedBehavior },
{ &EV_Actor_NotifyBehavior, ( Response )Actor::NotifyBehavior },
{ &EV_Actor_WalkTo, ( Response )Actor::WalkTo },
{ &EV_Actor_JumpTo, ( Response )Actor::JumpToEvent },
{ &EV_Actor_RunTo, ( Response )Actor::RunTo },
{ &EV_Actor_Anim, ( Response )Actor::Anim },
{ &EV_Actor_Attack, ( Response )Actor::AttackEntity },
{ &EV_Actor_AttackPlayer, ( Response )Actor::AttackPlayer },
{ &EV_Actor_Remove, ( Response )Actor::RemoveUselessBody },
{ &EV_Actor_ForwardToBehavior,( Response )Actor::ForwardBehaviorEvent },
{ &EV_Actor_ReserveNode, ( Response )Actor::ReserveNodeEvent },
{ &EV_Actor_ReleaseNode, ( Response )Actor::ReleaseNodeEvent },
{ &EV_Actor_IfCanHideAt, ( Response )Actor::IfCanHideAtEvent },
{ &EV_Actor_IfCanStrafeAttack,( Response )Actor::IfCanStrafeAttackEvent },
{ &EV_Actor_IfCanMeleeAttack, ( Response )Actor::IfCanMeleeAttackEvent },
{ &EV_Actor_IfCanShoot, ( Response )Actor::IfCanShootEvent },
{ &EV_Actor_IfEnemyWithin, ( Response )Actor::IfEnemyWithinEvent },
{ &EV_HeardWeapon, ( Response )Actor::InvestigateWeaponSound },
{ &EV_HeardMovement, ( Response )Actor::InvestigateMovementSound },
{ &EV_HeardPain, ( Response )Actor::InvestigatePainSound },
{ &EV_HeardDeath, ( Response )Actor::InvestigateDeathSound },
{ &EV_HeardBreaking, ( Response )Actor::InvestigateBreakingSound },
{ &EV_HeardDoor, ( Response )Actor::InvestigateDoorSound },
{ &EV_HeardMutant, ( Response )Actor::InvestigateMutantSound },
{ &EV_HeardVoice, ( Response )Actor::InvestigateVoiceSound },
{ &EV_HeardMachine, ( Response )Actor::InvestigateMachineSound },
{ &EV_HeardRadio, ( Response )Actor::InvestigateRadioSound },
{ &EV_Actor_Aim, ( Response )Actor::SetAim },
{ &EV_Actor_MeleeRange, ( Response )Actor::SetMeleeRange },
{ &EV_Actor_MeleeDamage, ( Response )Actor::SetMeleeDamage },
{ &EV_Actor_Melee, ( Response )Actor::MeleeEvent },
{ &EV_Actor_AttackFinished, ( Response )Actor::AttackFinishedEvent },
{ &EV_Actor_CanStrafe, ( Response )Actor::CanStrafeEvent },
{ &EV_Actor_NoStrafe, ( Response )Actor::NoStrafeEvent },
{ &EV_Actor_PainThreshold, ( Response )Actor::SetPainThresholdEvent },
{ &EV_Actor_SetKillThread, ( Response )Actor::SetKillThreadEvent },
{ &EV_Actor_AttackRange, ( Response )Actor::AttackRangeEvent },
{ &EV_Actor_ShotsPerAttack, ( Response )Actor::ShotsPerAttackEvent },
{ &EV_Actor_ClearEnemy, ( Response )Actor::ClearEnemyEvent },
{ &EV_Actor_AttackMode, ( Response )Actor::AttackModeEvent },
{ &EV_SetHealth, ( Response )Actor::SetHealth },
{ &EV_Actor_EyePositionOffset,( Response )Actor::EyeOffset },
{ &EV_Actor_NoDeathFade, ( Response )Actor::NoDeathFadeEvent },
{ &EV_Actor_NoChatter, ( Response )Actor::NoChatterEvent },
{ &EV_Actor_TurnSpeed, ( Response )Actor::TurnSpeedEvent },
{&EV_Actor_GotoObject, (Response)Actor::GotoObjectEvent}, //###
{ &EV_ScriptThread_Goto, ( Response )Actor::GotoEvent },
{ NULL, NULL }
};
//***********************************************************************************************
//
// Initialization functions
//
//***********************************************************************************************
Actor::Actor()
{
const char *text;
str script;
const char * skinname;
Event *ev;
SpawnArgs args;
// don't spawn monsters in deathmatch
if ( deathmatch->value || nomonsters->value )
{
PostEvent( EV_Remove, 0 );
return;
}
actortype = IS_ENEMY;
setSolidType( SOLID_BBOX );
setMoveType( MOVETYPE_STEP );
health = G_GetFloatArg( "health", 100 );
max_health = health;
takedamage = DAMAGE_AIM;
mass = G_GetFloatArg( "mass", 200 );
deadflag = DEAD_NO;
edict->clipmask = MASK_MONSTERSOLID;
edict->svflags |= SVF_MONSTER;
forwardspeed = 0;
checkStrafe = true;
// No longer used
movement = AI_CANWALK;
lastmove = STEPMOVE_OK;
gunoffset = "0 0 44";
numonstack = 0;
behavior = NULL;
path = NULL;
newanimnum = -1;
newanim = "";
newanimevent = NULL;
text = G_GetSpawnArg( "weapon" );
if ( text )
{
giveWeapon( text );
}
spawngroup = G_GetStringArg( "spawngroup" );
attackmode = G_GetIntArg( "attackmode", 0 );
attack_range = G_GetFloatArg( "attackrange", 8192 );
fov = 150;
fovdot = cos( fov * 0.5 * M_PI / 180.0 );
vision_distance = G_GetFloatArg( "visiondistance", 1024 );
eyeoffset = "0 0 0";
eyeposition = "0 0 64";
hasalert = false;
lastEnemy = NULL;
enemyRange = RANGE_FAR;
seenEnemy = false;
nodeathfade = false;
nochatter = false;
// turnspeed = 60;
turnspeed = 180;
if ( !parentmode->value )
{
flags |= FL_BLOOD;
flags |= FL_DIE_GIBS;
}
edict->s.effects |= EF_WARM; //###
//
// don't talk all at once initially
//
chattime = G_Random( 20 );
nextsoundtime = 0;
trig = NULL;
deathgib = false;
// set default crouchsize
crouchsize_min = "-16 -16 0";
crouchsize_max = "16 16 32";
standsize_min = mins;
standsize_max = maxs;
// use a cvar to help with debugging
ai_actorscript = gi.cvar( "ai_actorscript", "", 0 );
actorscript = G_GetStringArg( "script", "global/enemy.scr" );
actorstart = G_GetStringArg( "thread", "" );
kill_thread = G_GetStringArg( "killthread", "" );
// default melee characteristics
melee_range = 100;
melee_damage = 30;
// default aim (normal)
aim = G_GetFloatArg( "aim", 0 );
// default pain_threshold is 10
pain_threshold = G_GetFloatArg( "painthreshold", 10 * skill->value );
// default shots per attack is 5 + ( 2 * skill->level )
shots_per_attack = G_GetFloatArg( "shotsperattack", 3 + ( 2 * skill->value ) );
startpos = worldorigin;
next_drown_time = 0;
air_finished = level.time + 5;
last_jump_time = 0;
CheckWater();
setSize( "-16 -16 0", "16 16 76" );
//setModel( G_GetSpawnArg( "model", "grunt.def" ) );
showModel();
if ( !LoadingSavegame )
{
// save off our spawn args
args.SetArgs();
G_InitSpawnArguments();
// force the init commands to be processed so that we start the right actor script immediately
CancelEventsOfType( EV_ProcessInitCommands );
ev = new Event( EV_ProcessInitCommands );
ev->AddInteger( edict->s.modelindex );
ProcessEvent( ev );
SetupThread();
if ( eyeposition.z > maxs.z )
{
eyeposition.z = maxs.z;
}
// restore our args
G_InitSpawnArguments();
args.RestoreArgs();
// wait until the script starts before thinking
PostEvent( EV_Actor_Start, FRAMETIME );
}
//
// I put this here, so that the initcommands would already be processed
//
skinname = G_GetSpawnArg( "skin" );
if ( skinname && skinname[ 0 ] )
{
int skinnum;
skinnum = gi.Skin_NumForName( edict->s.modelindex, skinname );
if (skinnum >= 0)
edict->s.skinnum = skinnum;
}
}
Actor::~Actor()
{
int n;
int i;
if ( actorthread )
{
actorthread->ProcessEvent( EV_ScriptThread_End );
actorthread = NULL;
}
// delete the old action/response list
n = actionList.NumObjects();
for( i = n; i >= 1; i-- )
{
delete actionList.ObjectAt( i );
}
actionList.ClearObjectList();
if ( behavior )
{
delete behavior;
behavior = NULL;
}
if ( path )
{
delete path;
path = NULL;
}
if ( trig )
{
delete trig;
trig = NULL;
}
ClearStateStack();
}
void Actor::Start
(
Event *ev
)
{
MonsterStart *start;
// This is only used for choosing delay times for targeting enemies
static int actornum = 0;
hasalert = ( gi.Anim_Random( edict->s.modelindex, "alert" ) != -1 );
start = MonsterStart::GetRandomSpot( spawngroup );
if ( start )
{
setOrigin( start->worldorigin );
worldorigin.copyTo( edict->s.old_origin );
setAngles( start->worldangles );
if ( start->animname != "" )
{
SetAnim( start->animname );
}
}
droptofloor( 16 );
flags |= FL_PRETHINK;
// see if we have any melee attacks
if ( HasAnim( "melee" ) )
{
has_melee = true;
}
else
{
//
// make sure we can't knock the weapon out of this characters hands
//
if ( currentWeapon )
{
Event * ev;
ev = new Event( EV_Weapon_NotDroppable );
currentWeapon->ProcessEvent( ev );
}
has_melee = false;
}
// spread their targeting about a bit
PostEvent( EV_Actor_TargetEnemies, ( actornum++ % 10 ) * FRAMETIME );
}
//***********************************************************************************************
//
// Vision functions
//
//***********************************************************************************************
range_t Actor::Range
(
Entity *targ
)
{
float r;
Vector delta;
delta = centroid - targ->centroid;
r = delta * delta;
if ( r < 120 * 120 )
{
return RANGE_MELEE;
}
if ( r < 500 * 500 )
{
return RANGE_NEAR;
}
if ( r < 1000 * 1000 )
{
return RANGE_MID;
}
return RANGE_FAR;
}
inline qboolean Actor::InFOV
(
Vector pos
)
{
Vector delta;
float dot;
delta = pos - EyePosition();
if ( !delta.x && !delta.y )
{
// special case for straight up and down
return true;
}
// give better vertical vision
delta.z = 0;
delta.normalize();
dot = DotProduct( orientation[ 0 ], delta.vec3() );
return ( dot > fovdot );
}
inline qboolean Actor::InFOV
(
Entity *ent
)
{
return InFOV( ent->centroid );
}
inline qboolean Actor::CanSeeFOV
(
Entity *ent
)
{
return InFOV( ent ) && CanSeeFrom( worldorigin, ent );
}
inline qboolean Actor::CanSeeFrom
(
Vector pos,
Entity *ent
)
{
trace_t trace;
Vector p;
p = ent->centroid;
// Check if he's visible
trace = G_Trace( pos + eyeposition, vec_zero, vec_zero, p, this, MASK_OPAQUE, "Actor::CanSeeFrom 1" );
if ( trace.fraction == 1.0 || trace.ent == ent->edict )
{
return true;
}
// Check if his head is visible
p.z = ent->absmax.z;
trace = G_Trace( pos + eyeposition, vec_zero, vec_zero, p, this, MASK_OPAQUE, "Actor::CanSeeFrom 2" );
if ( trace.fraction == 1.0 || trace.ent == ent->edict )
{
return true;
}
return false;
}
qboolean Actor::CanSee
(
Entity *ent
)
{
return CanSeeFrom( worldorigin, ent );
}
int Actor::EnemyCanSeeMeFrom
(
Vector pos
)
{
Entity *ent;
int i;
int n;
float rad;
Vector d;
Vector p1;
Vector p2;
int c;
rad = max( size.x, size.y ) * 1.44 * 0.5;
c = 0;
n = enemyList.NumObjects();
for( i = 1; i <= n; i++ )
{
ent = enemyList.ObjectAt( i );
if ( !ent || ent->deadflag || ( ent->flags & FL_NOTARGET ) )
{
continue;
}
if ( WithinDistance( ent, vision_distance ) )
{
// To check if we're visible, I create a plane that intersects the actor
// and is perpendicular to the delta vector between the actor and his enemy.
// I place four points on this plane that "frame" the actor and check if
// the enemy can see any of those points.
d = ent->centroid - pos;
d.z = 0;
d.normalize();
p1.x = -d.y;
p1.y = d.x;
p1 *= rad;
p2 = p1;
p1.z = mins.z;
p2.z = maxs.z;
if ( CanSeeFrom( pos + p1, ent ) )
{
c++;
}
if ( CanSeeFrom( pos + p2, ent ) )
{
c++;
}
p1.z = -p1.z;
p2.z = -p2.z;
if ( CanSeeFrom( pos - p1, ent ) )
{
c++;
}
if ( CanSeeFrom( pos - p2, ent ) )
{
c++;
}
}
}
return c;
}
qboolean Actor::CanSeeEnemyFrom
(
Vector pos
)
{
Entity *ent;
int i;
int n;
n = enemyList.NumObjects();
for( i = 1; i <= n; i++ )
{
ent = enemyList.ObjectAt( i );
if ( !ent || ent->deadflag || ( ent->flags & FL_NOTARGET ) )
{
continue;
}
if ( WithinDistance( ent, vision_distance ) && CanSeeFrom( pos, ent ) )
{
return true;
}
}
return false;
}
//***********************************************************************************************
//
// Weapon functions
//
//***********************************************************************************************
qboolean Actor::WeaponReady
(
void
)
{
if ( currentWeapon && currentWeapon->ReadyToFire() )
{
return true;
}
else if ( !currentWeapon && has_melee )
{
return true;
}
return false;
}
void Actor::Attack
(
Event *ev
)
{
Vector delta;
Vector ang;
Vector ang2;
if ( ( currentWeapon ) && currentWeapon->ReadyToFire() && currentWeapon->HasAmmo() )
{
if ( currentEnemy )
{
ang = angles;
delta = currentEnemy->centroid - GunPosition();
ang2 = delta.toAngles();
ang2[ 0 ] = -ang2[ 0 ];
setAngles( ang2 );
currentWeapon->Fire();
setAngles( ang );
}
else
{
currentWeapon->Fire();
}
}
}
Vector Actor::GunPosition
(
void
)
{
vec3_t trans[ 3 ];
vec3_t orient;
int groupindex;
int tri_num;
Vector offset = vec_zero;
Vector result;
// get the gun position of the actor
if ( !gi.GetBoneInfo( edict->s.modelindex, "gun", &groupindex, &tri_num, orient ) )
{
// Gun doesn't have a barrel, just return the default
return worldorigin + gunoffset;
}
gi.GetBoneTransform( edict->s.modelindex, groupindex, tri_num, orient, edict->s.anim,
edict->s.frame, edict->s.scale, trans, offset.vec3() );
MatrixTransformVector( offset.vec3(), orientation, result.vec3() );
result += worldorigin;
return result;
}
inline Vector Actor::MyGunAngles
(
Vector muzzlepos,
qboolean firing
)
{
Vector ang;
Vector dir;
if ( currentEnemy && firing )
{
dir = currentEnemy->centroid - muzzlepos;
dir.z += ( currentEnemy->absmax.z - currentEnemy->centroid.z ) * 0.75f;
dir.normalize();
ang = dir.toAngles();
ang.x = -ang.x;
}
else
{
ang.x = -worldangles.x;
ang.y = worldangles.y;
ang.z = worldangles.z;
}
return ang;
}
#define MIN_AIM_DISTANCE 400
inline void Actor::GetGunOrientation
(
Vector muzzlepos,
Vector *forward,
Vector *right,
Vector *up
)
{
Vector ang;
float accuracy;
float spread;
float invaim;
float skl;
float enemydistance;
ang = MyGunAngles( muzzlepos, true );
if ( currentEnemy )
{
enemydistance = ( currentEnemy->centroid - muzzlepos ).length();
if ( enemydistance < MIN_AIM_DISTANCE )
enemydistance = MIN_AIM_DISTANCE;
}
else
{
enemydistance = MIN_AIM_DISTANCE;
}
// 0 is maximum accuracy
invaim = 1.0f - aim;
if ( invaim < 0 )
invaim = 0;
skl = min( skill->value, 3 );
if ( skl < 1 )
skl = 1;
accuracy = 1 - ( min( skl, 3 ) * 0.18 );
accuracy *= invaim;
spread = ( 8 * MIN_AIM_DISTANCE * accuracy ) / enemydistance;
ang.x += G_CRandom( spread );
ang.y += G_CRandom( spread );
ang.AngleVectors( forward, right, up );
}
qboolean Actor::CanShootFrom
(
Vector pos,
Entity *ent,
qboolean usecurrentangles
)
{
int mask;
Vector delta;
Vector start;
Vector end;
float len;
trace_t trace;
Vehicle *v;
Entity *t;
Vector ang;
//### can't attack a player during a cinematic
if(level.cinematic && ent->isClient())
{
return false;
}
//###
if ( !currentWeapon || !WithinDistance( ent, vision_distance ) )
{
if (!currentWeapon && !has_melee )
return false;
}
if ( usecurrentangles )
{
Vector dir;
start = pos + GunPosition() - worldorigin;
// start = pos + centroid - worldorigin;
end = ent->centroid;
end.z += ( ent->absmax.z - ent->centroid.z ) * 0.75f;
delta = end - start;
ang = delta.toAngles();
ang.x = -ang.x;
ang.y = angles.y;
len = delta.length();
ang.AngleVectors( &dir, NULL, NULL );
dir *= len;
end = start + dir;
}
else
{
start = pos + GunPosition() - worldorigin;
end = ent->centroid;
end.z += ( ent->absmax.z - ent->centroid.z ) * 0.75f;
delta = end - start;
len = delta.length();
}
// check if we're too far away, or too close
if ( currentWeapon )
{
if ( ( len > attack_range ) || ( len > currentWeapon->GetMaxRange() ) || ( len < currentWeapon->GetMinRange() ) )
{
return false;
}
mask = MASK_SHOT;
}
else
{
if ( ( len > attack_range ) || ( len > melee_range ) )
{
return false;
}
mask = MASK_PROJECTILE;
}
// shoot past the guy we're shooting at
end += delta * 4;
#if 0
if ( usecurrentangles )
{
G_DebugLine( start, end, 1, 0, 0, 1 );
}
else
{
G_DebugLine( start, end, 1, 1, 0, 1 );
}
#endif
// Check if he's visible
trace = G_Trace( start, vec_zero, vec_zero, end, this, mask, "Actor::CanShootFrom" );
if ( trace.startsolid )
{
return false;
}
// If we hit the guy we wanted, then shoot
if ( trace.ent == ent->edict )
{
return true;
}
// if we hit a vehicle, check if the driver is someone we want to hit
t = trace.ent->entity;
if ( t && t->isSubclassOf( Vehicle ) )
{
v = ( Vehicle * )t;
if ( ( v->Driver() == ent ) || IsEnemy( v->Driver() ) )
{
return true;
}
return false;
}
//### if we hit a hoverbike, check if the rider is someone we want to hit
if(t)
{
if(t->isSubclassOf(Hoverbike))
{
Hoverbike *bike;
bike = (Hoverbike *)t;
if((bike->rider == ent) || IsEnemy(bike->rider))
{
return true;
}
return false;
}
if(t->isSubclassOf(HoverbikeBox))
{
HoverbikeBox *bikebox;
Hoverbike *bike;
bikebox = (HoverbikeBox *)t;
bike = (Hoverbike *)bikebox->bike.Ptr();
if((bike->rider == ent) || IsEnemy(bike->rider))
{
return true;
}
return false;
}
}
//###
// If we hit someone else we don't like, then shoot
if ( IsEnemy( t ) )
{
return true;
}
// if we hit something breakable, check if shooting it will
// let us shoot someone.
if ( t->isSubclassOf( Shatter ) ||
t->isSubclassOf( Object ) ||
t->isSubclassOf( DamageThreshold ) ||
t->isSubclassOf( ScriptModel ) )
{
trace = G_Trace( Vector( trace.endpos ), vec_zero, vec_zero, end, t, mask, "Actor::CanShootFrom 2" );
if ( trace.startsolid )
{
return false;
}
// If we hit the guy we wanted, then shoot
if ( trace.ent == ent->edict )
{
return true;
}
// If we hit someone else we don't like, then shoot
if ( IsEnemy( trace.ent->entity ) )
{
return true;
}
// Forget it then
return false;
}
return false;
}
qboolean Actor::CanShoot
(
Entity *ent,
qboolean usecurrentangles
)
{
//### can't attack a player during a cinematic
if(level.cinematic && ent->isClient())
{
return false;
}
//###
return CanShootFrom( worldorigin, ent, usecurrentangles );
}
float Actor::AttackRange
(
void
)
{
if ( !currentWeapon && !has_melee )
{
return 0;
}
if ( currentWeapon )
{
return ( currentWeapon->GetMaxRange() );
}
else
{
return ( melee_range );
}
}
float Actor::MinimumAttackRange
(
void
)
{
float range;
float maxrange;
if ( !currentWeapon && !has_melee )
{
return 100;
}
range = melee_range * 0.75f;
maxrange = melee_range;
if ( currentWeapon )
{
range = currentWeapon->GetMinRange();
if ( !range && melee_range )
range = melee_range * 0.75f;
maxrange = currentWeapon->GetMaxRange();
}
if ( range > maxrange )
range = maxrange;
return range;
}
qboolean Actor::HasWeapon
(
void
)
{
return ( currentWeapon != NULL );
}
//***********************************************************************************************
//
// Actor type script commands
//
//***********************************************************************************************
void Actor::FriendEvent
(
Event *ev
)
{
actortype = IS_FRIEND;
}
void Actor::CivilianEvent
(
Event *ev
)
{
actortype = IS_CIVILIAN;
}
void Actor::EnemyEvent
(
Event *ev
)
{
actortype = IS_ENEMY;
}
void Actor::InanimateEvent
(
Event *ev
)
{
actortype = IS_INANIMATE;
//
// clear the monster flag so triggers are not triggered
//
edict->svflags &= ~SVF_MONSTER;
//
// don't make them move
//
setMoveType( MOVETYPE_NONE );
//
// don't make it bleed
//
flags &= ~FL_BLOOD;
//
// don't make it gib
//
flags &= ~FL_DIE_GIBS;
edict->s.effects &= ~EF_WARM; //### don't make it light up to goggles
}
void Actor::MonsterEvent
(
Event *ev
)
{
actortype = IS_MONSTER;
}
void Actor::AnimalEvent
(
Event *ev
)
{
actortype = IS_ANIMAL;
}
//***********************************************************************************************
//
// Enemy management
//
//***********************************************************************************************
qboolean Actor::HasEnemies
(
void
)
{
return ( enemyList.NumObjects() > 0 );
}
qboolean Actor::IsEnemy
(
Entity *ent
)
{
return enemyList.ObjectInList( EntityPtr( ent ) ) && seenEnemy;
}
void Actor::MakeEnemy
(
Entity *ent,
qboolean force
)
{
// don't get mad at things that can't be hurt or the world
if (
ent &&
( ent != world ) &&
( ent != this ) &&
!( ent->flags & FL_NOTARGET ) &&
( ent->takedamage != DAMAGE_NO )
)
{
if ( !enemyList.ObjectInList( EntityPtr( ent ) ) )
{
enemyList.AddObject( EntityPtr( ent ) );
}
if ( !currentEnemy && !seenEnemy )
{
currentEnemy = ent;
if ( DoAction( "sightenemy", force ) )
{
seenEnemy = true;
Chatter( "snd_sightenemy", 5 );
}
else
{
currentEnemy = NULL;
}
}
}
}
void Actor::ClearEnemies
(
void
)
{
currentEnemy = NULL;
seenEnemy = false;
enemyList.ClearObjectList();
}
qboolean Actor::Likes
(
Entity *ent
)
{
Actor *act;
if ( ent->isClient() )
{
return ( actortype == IS_FRIEND );
}
else if ( actortype == IS_MONSTER )
{
// monsters don't like anyone, but they don't particular hate everyone
return false;
}
else if ( ent->isSubclassOf( Actor ) )
{
act = ( Actor * )ent;
return ( act->actortype == actortype );
}
return false;
}
qboolean Actor::Hates
(
Entity *ent
)
{
Actor *act;
assert( ent );
if ( !ent )
{
return false;
}
if ( ent->isClient() )
{
if ( ent->flags & FL_SP_MUTANT )
{
if ( actortype == IS_ENEMY )
return false;
else
return true;
}
else
{
return ( actortype != IS_CIVILIAN ) && ( actortype != IS_FRIEND );
}
}
else if ( ent->isSubclassOf( Actor ) && ( actortype != IS_INANIMATE ) )
{
act = ( Actor * )ent;
// if ( act->actortype == IS_INANIMATE )
// {
// // heh... Mutants hate inanimate objects. :)
// return ( actortype == IS_MONSTER );
// }
if ( ( act->actortype <= IS_ENEMY ) && ( actortype <= IS_ENEMY ) )
{
return false;
}
if ( ( act->actortype == IS_FRIEND ) && ( actortype <= IS_ENEMY ) )
{
return true;
}
if ( ( act->actortype <= IS_ENEMY ) && ( actortype == IS_FRIEND ) )
{
return true;
}
}
return false;
}
//***********************************************************************************************
//
// Targeting functions
//
//***********************************************************************************************
//### new GetVisibleTargets & TargetEnemies functions
qboolean Actor::GetVisibleTargets (void)
{
Sentient *ent;
Vector delta;
int i;
int n;
Actor *act;
targetList.ClearObjectList();
nearbyList.ClearObjectList();
n = SentientList.NumObjects();
for( i = 1; i <= n; i++ )
{
ent = SentientList.ObjectAt( i );
//if ( ( ent == this ) || ent->deadflag || ( ent->flags & FL_NOTARGET ) || !Hates( ent ) )
if ( ( ent == this ) || ( ent->flags & (FL_NOTARGET|FL_CLOAK|FL_STEALTH) ) || ent->hidden() )
{
continue;
}
if ( ent->isSubclassOf( Actor ) )
{
act = ( Actor * )ent;
if ( act->actortype == IS_INANIMATE ) //### added act-> thing
{
// don't trace to the fucking shitters and keyboards
continue;
}
}
if ( !ent->deadflag && Hates( ent ) && !IsEnemy( ent ) )
{
if ( WithinDistance( ent, vision_distance ) && CanSeeFOV( ent ) )
{
targetList.AddObject( EntityPtr( ent ) );
if ( WithinDistance( ent, 96 ) )
{
nearbyList.AddObject( EntityPtr( ent ) );
}
MakeEnemy( ent );
}
}
else if ( ent->isSubclassOf( Actor ) && Likes( ent ) )
{
act = ( Actor * )ent;
if ( act->currentEnemy && Hates( act->currentEnemy ) && !IsEnemy( act->currentEnemy ) )
{
if ( WithinDistance( ent, vision_distance ) && CanSeeFOV( ent ) )
{
targetList.AddObject( EntityPtr( ent ) );
if ( WithinDistance( ent, 96 ) )
{
nearbyList.AddObject( EntityPtr( ent ) );
}
MakeEnemy( act->currentEnemy );
if ( act->deadflag )
{
//
// we have passed on the post mortem message of our death, so let's clear it
//
act->ClearEnemies();
}
}
}
}
}
return ( targetList.NumObjects() > 0 );
}
void Actor::TargetEnemies (Event *ev)
{
Entity *newtarget;
if ( actortype == IS_INANIMATE )
{
// inanimate objects don't need to worry about this kind of thing
return;
}
if ( enemyList.NumObjects() >= 1 )
{
// don't target new enemies as much while we've already got an enemy
PostEvent( EV_Actor_TargetEnemies, 5 );
}
else
{
PostEvent( EV_Actor_TargetEnemies, 1 );
}
if ( hidden() )
{
// don't target while hidden (for cinematic characters)
//FIXME
// probably should have a start/stop function
return;
}
GetVisibleTargets();
newtarget = BestTarget();
if ( newtarget && ( newtarget != currentEnemy ) )
{
seenEnemy = false;
currentEnemy = newtarget;
if ( DoAction( "sightenemy" ) )
{
seenEnemy = true;
Chatter( "snd_sightenemy", 5 );
}
else
{
currentEnemy = NULL;
}
}
}
//###
Entity *Actor::BestTarget
(
void
)
{
int i;
int n;
Entity *ent;
Entity *bestent;
float bestscore;
float score;
bestscore = 8192 * 8192 * 20;
n = enemyList.NumObjects();
if ( n == 1 )
{
// don't waste our time when we only have one enemy
return enemyList.ObjectAt( 1 );
}
bestent = NULL;
for( i = 1; i <= n; i++ )
{
ent = enemyList.ObjectAt( i );
if ( !ent || ent->deadflag )
{
enemyList.RemoveObjectAt( i );
i--;
n--;
continue;
}
score = Range( ent ) + 1;
if ( ent->health < WEAK_HEALTH )
{
// Try to kill off really weak enemies
score *= WEAK_WEIGHT;
}
if ( ent->health > health )
{
score *= STRONGER_WEIGHT;
}
if ( CanSeeFOV( ent ) )
{
// We're more interested in guys we can see
score *= VISIBLE_WEIGHT;
}
if ( i == n )
{
// Favor the latest enemy
score *= NEWENEMY_WEIGHT;
}
if ( score < bestscore )
{
bestscore = score;
bestent = ent;
}
}
return bestent;
}
Sentient *Actor::NearFriend
(
void
)
{
int i;
int num;
Entity *ent;
num = nearbyList.NumObjects();
for( i = 1; i < num; i++ )
{
ent = nearbyList.ObjectAt( i );
if ( Likes( ent ) )
{
return ( Sentient * )ent;
}
}
return NULL;
}
qboolean Actor::CloseToEnemy
(
Vector pos,
float howclose
)
{
Entity *ent;
int i;
int n;
n = enemyList.NumObjects();
for( i = 1; i <= n; i++ )
{
ent = enemyList.ObjectAt( i );
if ( !ent || ent->deadflag || ( ent->flags & FL_NOTARGET ) )
{
continue;
}
if ( WithinDistance( ent, howclose ) )
{
return true;
}
}
return false;
}
void Actor::EyeOffset
(
Event *ev
)
{
eyeposition -= eyeoffset;
eyeoffset = ev->GetVector( 1 );
eyeposition += eyeoffset;
}
//***********************************************************************************************
//
// State control functions
//
//***********************************************************************************************
void Actor::EnableState
(
str action
)
{
StateInfo *ptr;
ptr = GetState( action );
if ( ptr )
{
ptr->ignore = false;
}
}
void Actor::DisableState
(
str action
)
{
StateInfo *ptr;
ptr = GetState( action );
if ( ptr )
{
ptr->ignore = true;
}
}
StateInfo *Actor::SetResponse
(
str action,
str response,
qboolean ignore
)
{
StateInfo *ptr;
ptr = GetState( action );
if ( !ptr )
{
ptr = new StateInfo;
actionList.AddObject( ptr );
ptr->action = action;
}
ptr->response = response;
ptr->ignore = ignore;
return ptr;
}
const char *Actor::GetResponse
(
str action,
qboolean force
)
{
StateInfo *ptr;
ptr = GetState( action );
if ( ptr && ( force || !ptr->ignore ) )
{
return ptr->response.c_str();
}
return "";
}
StateInfo *Actor::GetState
(
str action
)
{
int i;
int n;
StateInfo *ptr;
n = actionList.NumObjects();
for( i = 1; i <= n; i++ )
{
ptr = actionList.ObjectAt( i );
if ( ptr->action == action )
{
return ptr;
}
}
return NULL;
}
//***********************************************************************************************
//
// State stack management
//
//***********************************************************************************************
void Actor::ClearStateStack
(
void
)
{
ActorState *state;
int n;
int i;
while( !stateStack.Empty() )
{
state = stateStack.Pop();
if ( state->animDoneEvent )
{
delete state->animDoneEvent;
}
// delete the old action/response list
n = state->actionList.NumObjects();
for( i = n; i >= 1; i-- )
{
delete state->actionList.ObjectAt( i );
}
state->actionList.ClearObjectList();
if ( state->behavior )
{
delete state->behavior;
}
if ( state->path )
{
delete state->path;
}
delete state;
}
numonstack = 0;
}
qboolean Actor::PopState
(
void
)
{
ActorState *newstate;
int n;
int i;
#ifdef DEBUG_PRINT
gi.dprintf( "%d Pop:", numonstack );
#endif
if ( !stateStack.Empty() )
{
newstate = stateStack.Pop();
numonstack--;
state = newstate->name;
#ifdef DEBUG_PRINT
gi.dprintf( "state '%s' anim '%s'", state.c_str(), newstate->anim.c_str() );
#endif
if ( newstate->anim.length() )
{
SetAnim( newstate->anim, newstate->animDoneEvent );
ChangeAnim();
}
SetPath( newstate->path );
#ifdef DEBUG_PRINT
if ( newstate->behavior )
{
gi.dprintf( "%s", newstate->behavior->getClassname() );
}
else
{
gi.dprintf( "NULL behavior" );
}
gi.dprintf( "\n" );
#endif
// NULL out our current thread so that EndBehavior doesn't
// signal the thread that the behavior ended.
thread = NULL;
EndBehavior();
assert( !behavior );
// Set the thread after ending the old behavior, but before the new behavior
if ( newstate->thread != -1 )
{
thread = Director.GetThread( newstate->thread );
// Since PopState is called from the thread, we don't need to tell the thread to continue processing.
// In fact, depending upon the state of the thread when we pushed it onto the stack, we may not want
// the thread to continue processing (for example, if the last command was a waitFor). Just restoring the
// position here will tell the thread to continue executing or wait for an event to occur.
// If we ever call PopState from outside of a thread, we MUST check to see if the thread should
// continue execution.
//FIXME
// This is probably an actorthread that was removed
// ADDENDUM: actorThread is now only removed once. Thread should never be NULL.
if ( thread )
{
thread->Restore( &newstate->marker );
}
}
else
{
thread = NULL;
}
// delete the old action/response list
n = actionList.NumObjects();
for( i = n; i >= 1; i-- )
{
delete actionList.ObjectAt( i );
}
actionList.ClearObjectList();
// Copy the new action/response list
n = newstate->actionList.NumObjects();
for( i = 1; i <= n; i++ )
{
actionList.AddObject( newstate->actionList.ObjectAt( i ) );
}
assert( !behavior );
SetBehavior( newstate->behavior, NULL, thread );
delete newstate;
}
else
{
#ifdef DEBUG_PRINT
gi.dprintf( "\n" );
#endif
EndBehavior();
return false;
}
return true;
}
void Actor::PushState
(
const char *newstate,
ScriptThread *newthread,
ThreadMarker *marker
)
{
ActorState *oldstate;
int i;
int n;
oldstate = new ActorState;
// push the old state
#ifdef DEBUG_PRINT
gi.dprintf( "%d : Pushing old state %s\n", numonstack, state.c_str() );
if ( behavior )
{
gi.dprintf( "old behavior %s\n", behavior->getClassname() );
}
else
{
gi.dprintf( "old behavior NULL\n" );
}
gi.dprintf( "new state %s\n", newstate );
#endif
oldstate->name = state;
oldstate->anim = animname;
oldstate->animDoneEvent = animDoneEvent;
animDoneEvent = NULL;
oldstate->path = path;
oldstate->behavior = behavior;
// newthread must always be the old thread
assert( newthread );
oldstate->thread = newthread->ThreadNum();
assert( marker );
oldstate->marker = *marker;
// Copy the action/response list
n = actionList.NumObjects();
for( i = 1; i <= n; i++ )
{
StateInfo *ptr;
StateInfo *newobj;
ptr = actionList.ObjectAt( i );
newobj = new StateInfo;
newobj->action = ptr->action;
newobj->response = ptr->response;
newobj->ignore = ptr->ignore;
oldstate->actionList.AddObject( newobj );
}
numonstack++;
stateStack.Push( oldstate );
// Any SetBehavior following this will delete this behavior, so null it out so that it doesn't happen
if ( behavior )
{
behavior->End( *this );
behavior = NULL;
}
state = newstate;
thread = newthread;
}
//***********************************************************************************************
//
// State control script commands
//
//***********************************************************************************************
void Actor::DefineStateEvent
(
Event *ev
)
{
const char *action;
str response;
ScriptThread *thread;
str script;
int len;
action = ev->GetString( 1 );
response = ev->GetString( 2 );
// check if we have a filename in the label
if ( !strstr( response.c_str(), "::" ) )
{
thread = ev->GetThread();
if ( thread )
{
// add filename to the label so that if we jump to another script, our labels are still valid
response = str( thread->Filename() ) + "::" + response;
}
}
else
{
// prepend our debug directory name
script = ai_actorscript->string;
len = script.length();
// if we have a directory, make sure that it ends with a '/' or a '\'
if ( ( len > 0 ) && ( script[ len - 1 ] != '/' ) && ( script[ len - 1 ] != '\\' ) )
{
script += "/";
}
response = script + response;
}
SetResponse( action, response );
}
void Actor::CopyStateEvent
(
Event *ev
)
{
str action1;
str action2;
str response;
StateInfo *ptr;
action1 = ev->GetString( 1 );
action2 = ev->GetString( 2 );
ptr = GetState( action2 );
if ( ptr )
{
response = ptr->response;
}
SetResponse( action1, response );
}
void Actor::IgnoreAllEvent
(
Event *ev
)
{
int i;
int n;
n = actionList.NumObjects();
for( i = 1; i <= n; i++ )
{
actionList.ObjectAt( i )->ignore = true;
}
}
void Actor::IgnoreEvent
(
Event *ev
)
{
int i;
int n;
n = ev->NumArgs();
for( i = 1; i <= n; i++ )
{
DisableState( ev->GetString( i ) );
}
}
void Actor::RespondToAllEvent
(
Event *ev
)
{
int i;
int n;
n = actionList.NumObjects();
for( i = 1; i <= n; i++ )
{
actionList.ObjectAt( i )->ignore = false;
}
}
void Actor::RespondToEvent
(
Event *ev
)
{
int i;
int n;
n = ev->NumArgs();
for( i = 1; i <= n; i++ )
{
EnableState( ev->GetString( i ) );
}
}
void Actor::ClearStateEvent
(
Event *ev
)
{
ClearStateStack();
}
void Actor::StateDoneEvent
(
Event *ev
)
{
assert( actorthread == ev->GetThread() );
if ( !deadflag || ( actortype == IS_INANIMATE ) )
{
// if we're not dead, pop off the previous state
PopState();
}
else
{
// if we're dead, kill off all the previous states
ClearStateStack();
// kill off the thread
actorthread->ProcessEvent( EV_ScriptThread_End );
actorthread = NULL;
}
}
void Actor::SetStateEvent
(
Event *ev
)
{
str response;
str name;
ThreadMarker marker;
StateInfo *ptr;
if ( ( deadflag == DEAD_DEAD ) && ( actortype != IS_INANIMATE ) )
{
return;
}
name = ev->GetString( 1 );
// Don't check ignore flag
ptr = GetState( name );
if ( ptr )
{
response = ptr->response;
}
#ifdef DEBUG_PRINT
gi.dprintf( "%d : %d : Action: %s - %s\n",
actorthread->ThreadNum(), ev->GetThread()->ThreadNum(),
name.c_str(), response.c_str() );
#endif
//### check the existance of the sctor's thread to prevent a crash
if(!actorthread)
{
return;
}
//###
actorthread->Mark( &marker );
if ( response != "" && actorthread->Goto( response.c_str() ) )
{
PushState( name.c_str(), actorthread, &marker );
SetAnim( "idle" );
animname = "idle";
SetVariable( "state", name.c_str() );
ProcessScript( actorthread );
}
else
{
ev->Error( "Could not find label '%s'", response.c_str() );
actorthread->Goto( response.c_str() );
}
}
void Actor::CanStrafeEvent
(
Event *ev
)
{
checkStrafe = true;
}
void Actor::NoStrafeEvent
(
Event *ev
)
{
checkStrafe = false;
}
//***********************************************************************************************
//
// Thread management
//
//***********************************************************************************************
void Actor::SetupThread
(
void
)
{
str script;
int len;
Event *event;
// we should never have a thread at this point
assert( !actorthread );
// prepend our debug director name
script = ai_actorscript->string;
len = script.length();
// if we have a directory, make sure that it ends with a '/' or a '\'
if ( ( len > 0 ) && ( script[ len - 1 ] != '/' ) && ( script[ len - 1 ] != '\\' ) )
{
script += "/";
}
script += actorscript;
actorthread = Director.CreateThread( script.c_str(), MODEL_SCRIPT );
if ( actorthread )
{
// setup thread variables
SetVariable( "attackmode", attackmode );
if ( actorstart.length() )
{
if ( !actorthread->Goto( actorstart.c_str() ) )
{
gi.dprintf( "Label '%s' not found in %s.", actorstart.c_str(), script.c_str() );
}
}
ProcessScript( actorthread );
}
assert( actorthread );
if ( !actorthread )
{
// not having a script is bad
gi.dprintf( "Unable to start actor script '%s'. Killing actor '%s'(%d).\n",
script.c_str(), targetname.c_str(), entnum );
// just kill him
event = new Event( EV_Killed );
event->AddEntity( this );
event->AddInteger( 0 );
event->AddEntity( this );
event->AddString( "all" );
ProcessEvent( event );
return;
}
}
qboolean Actor::DoAction
(
str name,
qboolean force
)
{
str response;
ThreadMarker marker;
if ( !actorthread )
{
return false;
}
if ( ( deadflag == DEAD_DEAD ) && ( actortype != IS_INANIMATE ) )
{
return false;
}
response = GetResponse( name, force );
#ifdef DEBUG_PRINT
gi.dprintf( "Action: %s - %s\n", name.c_str(), response.c_str() );
#endif
actorthread->Mark( &marker );
if ( response != "" && actorthread->Goto( response.c_str() ) )
{
PushState( name.c_str(), actorthread, &marker );
SetAnim( "idle" );
animname = "idle";
SetVariable( "state", name.c_str() );
ProcessScript( actorthread );
return true;
}
return false;
}
qboolean Actor::ForceAction
(
str name
)
{
return DoAction( name, true );
}
void Actor::ProcessScript
(
ScriptThread *thread,
Event *ev
)
{
thread->Vars()->SetVariable( "self", this );
thread->Vars()->SetVariable( "origin", worldorigin );
thread->Vars()->SetVariable( "yaw", worldangles.y );
thread->Vars()->SetVariable( "health", health );
thread->Vars()->SetVariable( "startpos", startpos );
thread->Vars()->SetVariable( "shots_per_attack", shots_per_attack );
//
// see if the enemy lost his weapon
// i.e. it was shot out of his hands
//
if ( currentWeapon )
{
thread->Vars()->SetVariable( "has_weapon", 1 );
}
else
{
thread->Vars()->SetVariable( "has_weapon", 0 );
}
if ( currentEnemy )
{
thread->Vars()->SetVariable( "enemy", currentEnemy );
}
else
{
thread->Vars()->SetVariable( "enemy", "" );
}
if ( ev )
{
thread->ProcessEvent( ev );
}
else
{
thread->ProcessEvent( EV_ScriptThread_Execute );
}
}
void Actor::StartMove
(
Event *ev
)
{
if ( deadflag )
{
return;
}
// thread = ev->GetThread();
}
inline ScriptVariable *Actor::SetVariable
(
const char *name,
float value
)
{
if ( actorthread )
{
return actorthread->Vars()->SetVariable( name, value );
}
return NULL;
}
inline ScriptVariable *Actor::SetVariable
(
const char *name,
int value
)
{
if ( actorthread )
{
return actorthread->Vars()->SetVariable( name, value );
}
return NULL;
}
inline ScriptVariable *Actor::SetVariable
(
const char *name,
const char *text
)
{
if ( actorthread )
{
return actorthread->Vars()->SetVariable( name, text );
}
return NULL;
}
inline ScriptVariable *Actor::SetVariable
(
const char *name,
str &text
)
{
if ( actorthread )
{
return actorthread->Vars()->SetVariable( name, text.c_str() );
}
return NULL;
}
inline ScriptVariable *Actor::SetVariable
(
const char *name,
Entity *ent
)
{
if ( actorthread )
{
return actorthread->Vars()->SetVariable( name, ent );
}
return NULL;
}
inline ScriptVariable *Actor::SetVariable
(
const char *name,
Vector &vec
)
{
if ( actorthread )
{
return actorthread->Vars()->SetVariable( name, vec );
}
return NULL;
}
//***********************************************************************************************
//
// Thread based script commands
//
//***********************************************************************************************
void Actor::SetScript
(
Event *ev
)
{
str script;
str label;
int len;
actorscript = ev->GetString( 1 );
// gotta start the thread again!
if ( actorthread )
{
// prepend our debug directory name
script = ai_actorscript->string;
len = script.length();
// if we have a directory, make sure that it ends with a '/' or a '\'
if ( ( len > 0 ) && ( script[ len - 1 ] != '/' ) && ( script[ len - 1 ] != '\\' ) )
{
script += "/";
}
script += actorscript;
if ( !actorthread->SetScript( script.c_str() ) )
{
ev->Error( "Script '%s' not found", script.c_str() );
}
else
{
// setup thread variables
SetVariable( "attackmode", attackmode );
ProcessScript( actorthread );
}
}
}
void Actor::SetThread
(
Event *ev
)
{
ScriptThread *thread;
if ( ( deadflag == DEAD_DEAD ) && ( actortype != IS_INANIMATE ) )
{
return;
}
thread = ev->GetThread();
actorstart = ev->GetString( 1 );
// get the name of the script
if ( thread )
{
actorstart = str( thread->Filename() ) + "::" + actorstart;
}
// we may be getting this command from the .def file, so the thread may not have started yet
if ( actorthread && actorstart.length() )
{
// setup thread variables
SetVariable( "attackmode", attackmode );
if ( actorthread->Goto( actorstart.c_str() ) )
{
ProcessScript( actorthread );
}
else
{
ev->Error( "Label '%s' not found. Couldn't change thread.", actorstart.c_str() );
}
}
}
//***********************************************************************************************
//
// Behavior management
//
//***********************************************************************************************
void Actor::EndBehavior
(
void
)
{
ScriptThread *t;
Event *event;
if ( behavior )
{
behavior->End( *this );
delete behavior;
behavior = NULL;
if ( thread )
{
t = thread;
thread = NULL;
event = new Event( EV_MoveDone );
event->AddEntity( this );
#if 0
if ( t == actorthread )
{
ProcessScript( actorthread, event );
}
else
{
t->ProcessEvent( event );
}
#else
ProcessScript( actorthread, event );
if ( t != actorthread )
{
event = new Event( EV_MoveDone );
event->AddEntity( this );
t->ProcessEvent( event );
}
#endif
}
}
}
void Actor::SetBehaviorEvent
(
Event *ev
)
{
ClassDef *cls;
ScriptThread *thread;
Event *e;
str name;
int i;
int n;
name = ev->GetString( 1 );
if ( !checkInheritance( &Behavior::ClassInfo, name.c_str() ) )
{
ev->Error( "%s is not a valid behavior\n", name.c_str() );
return;
}
thread = ev->GetThread();
e = new Event( EV_Behavior_Args );
e->SetSource( EV_FROM_SCRIPT );
e->SetThread( thread );
e->SetLineNumber( ev->GetLineNumber() );
e->AddEntity( this );
n = ev->NumArgs();
for( i = 2; i <= n; i++ )
{
e->AddToken( ev->GetToken( i ) );
}
cls = getClass( name.c_str() );
SetBehavior( ( Behavior * )cls->newInstance(), e, thread );
}
void Actor::SetBehavior
(
Behavior *newbehavior,
Event *startevent,
ScriptThread *newthread
)
{
if ( ( deadflag ) && ( actortype != IS_INANIMATE ) )
{
return;
}
// End any previous behavior, but don't call EV_MoveDone if we're using the same thread,
// or we'll end THIS behavior
if ( thread == newthread )
{
thread = NULL;
}
EndBehavior();
behavior = newbehavior;
if ( behavior )
{
if ( actortype == IS_INANIMATE )
{
// think while we have a behavior
flags |= FL_PRETHINK;
}
#ifdef DEBUG_PRINT
gi.dprintf( "SetBehavior %s\n", behavior->getClassname() );
#endif
if ( startevent )
{
behavior->ProcessEvent( startevent );
}
currentBehavior = behavior->getClassname();
behavior->Begin( *this );
thread = newthread;
}
}
void Actor::FinishedBehavior
(
Event *ev
)
{
EndBehavior();
}
void Actor::NotifyBehavior
(
Event *ev
)
{
if ( behavior )
{
behavior->ProcessEvent( EV_Behavior_AnimDone );
}
}
void Actor::ForwardBehaviorEvent
(
Event *ev
)
{
ScriptThread *thread;
Event *e;
str name;
int i;
int n;
name = ev->GetString( 1 );
thread = ev->GetThread();
e = new Event( name );
e->SetSource( EV_FROM_SCRIPT );
e->SetThread( thread );
e->SetLineNumber( ev->GetLineNumber() );
// always add who got this event
e->AddEntity( this );
n = ev->NumArgs();
for( i = 2; i <= n; i++ )
{
e->AddToken( ev->GetToken( i ) );
}
if ( behavior )
behavior->ProcessEvent( e );
else
warning( "ForwardBehaviorEvent", "no behavior defined" );
}
//***********************************************************************************************
//
// Path and node management
//
//***********************************************************************************************
void Actor::SetPath
(
Path *newpath
)
{
if ( path && ( path != newpath ) )
{
delete path;
}
path = newpath;
}
void Actor::ReserveNodeEvent
(
Event *ev
)
{
PathNode *node;
Vector pos;
pos = ev->GetVector( 1 );
node = PathManager.NearestNode( pos, this );
if ( node && ( !node->entnum || ( node->entnum == entnum ) || ( node->occupiedTime < level.time ) ) )
{
// Mark node as occupied for a short time
node->occupiedTime = level.time + ev->GetFloat( 2 );
node->entnum = entnum;
}
}
void Actor::ReleaseNodeEvent
(
Event *ev
)
{
PathNode *node;
Vector pos;
pos = ev->GetVector( 1 );
node = PathManager.NearestNode( pos, this );
if ( node && ( node->entnum == entnum ) )
{
node->occupiedTime = 0;
node->entnum = 0;
}
}
//***********************************************************************************************
//
// Animation control functions
//
//***********************************************************************************************
void Actor::ChangeAnim
(
void
)
{
float time;
Vector totalmove;
if ( newanimnum == -1 )
{
return;
}
// If we're changing to the same anim, don't restart the animation
if ( animating && newanimnum == edict->s.anim )
{
if ( animDoneEvent )
{
delete animDoneEvent;
}
animDoneEvent = newanimevent;
}
else
{
StopAnimating();
animname = newanim;
time = gi.Anim_Time( edict->s.modelindex, newanimnum );
gi.Anim_Delta( edict->s.modelindex, newanimnum, totalmove.vec3() );
totalmove[ 1 ] = -totalmove[ 1 ];
totalmove *= edict->s.scale;
totallen = totalmove.length();
// always have a valid move direction
if ( totallen > 0.01 )
{
movespeed = totallen / time;
animdir = totalmove * ( 1 / totallen );
}
else
{
if ( forwardspeed )
{
movespeed = forwardspeed;
}
else
{
movespeed = 1;
}
animdir = Vector( 1, 0, 0 );
}
MatrixTransformVector( animdir.vec3(), orientation, movedir.vec3() );
movevelocity = movedir * movespeed;
NextAnim( newanimnum );
animDoneEvent = newanimevent;
StartAnimating();
}
// clear the new anim variables
newanimnum = -1;
newanim = "";
newanimevent = NULL;
}
qboolean Actor::SetAnim
(
str anim,
Event *ev
)
{
int num;
// FIXME
// HACK to make actors use alert when fighting instead of idle
if ( hasalert && currentEnemy && ( anim == "idle" ) )
{
anim = "alert";
}
num = gi.Anim_Random( edict->s.modelindex, anim.c_str() );
if ( num != -1 )
{
newanim = anim;
newanimnum = num;
newanimevent = ev;
if ( actortype == IS_INANIMATE )
{
// inanimate objects change anims immediately
ChangeAnim();
}
return true;
}
// kill the event
if ( ev )
{
delete ev;
}
return false;
}
qboolean Actor::SetAnim
(
str anim,
Event &ev
)
{
Event * event;
event = new Event( ev );
return SetAnim( anim, event );
}
void Actor::Anim
(
Event *ev
)
{
Event *e;
if ( ( deadflag ) && ( actortype != IS_INANIMATE ) )
{
return;
}
e = new Event( EV_Behavior_Args );
e->SetSource( EV_FROM_SCRIPT );
e->SetThread( ev->GetThread() );
e->SetLineNumber( ev->GetLineNumber() );
e->AddEntity( this );
e->AddToken( ev->GetToken( 1 ) );
SetBehavior( new PlayAnim, e, ev->GetThread() );
}
//***********************************************************************************************
//
// Script commands
//
//***********************************************************************************************
void Actor::CrouchSize
(
Event *ev
)
{
crouchsize_min = ev->GetVector( 1 );
crouchsize_max = ev->GetVector( 2 );
}
void Actor::SetFov
(
Event *ev
)
{
fov = ev->GetFloat( 1 );
fovdot = cos( fov * 0.5 * M_PI / 180.0 );
}
void Actor::SetVisionDistance
(
Event *ev
)
{
vision_distance = ev->GetFloat( 1 );
}
void Actor::LookAt
(
Event *ev
)
{
Entity *ent;
TurnTo *turnTo;
if ( ( deadflag ) && ( actortype != IS_INANIMATE ) )
{
return;
}
ent = ev->GetEntity( 1 );
if ( ent && ent != world )
{
turnTo = new TurnTo;
turnTo->SetTarget( ent );
SetBehavior( turnTo, NULL, ev->GetThread() );
}
}
void Actor::TurnToEvent
(
Event *ev
)
{
TurnTo *turnTo;
if ( ( deadflag ) && ( actortype != IS_INANIMATE ) )
{
return;
}
turnTo = new TurnTo;
turnTo->SetDirection( ev->GetFloat( 1 ) );
SetBehavior( turnTo, NULL, ev->GetThread() );
}
void Actor::IdleEvent
(
Event *ev
)
{
Event *e;
if ( ( deadflag ) && ( actortype != IS_INANIMATE ) )
{
return;
}
e = new Event( EV_Behavior_Args );
e->SetSource( EV_FROM_SCRIPT );
e->SetThread( ev->GetThread() );
e->SetLineNumber( ev->GetLineNumber() );
e->AddEntity( this );
e->AddString( ev->GetToken( 1 ) );
SetBehavior( new Idle, e, ev->GetThread() );
}
void Actor::WalkTo
(
Event *ev
)
{
Event *e;
int i;
int n;
if ( ( deadflag ) && ( actortype != IS_INANIMATE ) )
{
return;
}
e = new Event( EV_Behavior_Args );
e->SetSource( EV_FROM_SCRIPT );
e->SetThread( ev->GetThread() );
e->SetLineNumber( ev->GetLineNumber() );
e->AddEntity( this );
n = ev->NumArgs();
e->AddString( "walk" );
for( i = 1; i <= n; i++ )
{
e->AddToken( ev->GetToken( i ) );
}
SetBehavior( new GotoPathNode, e, ev->GetThread() );
}
void Actor::RunTo
(
Event *ev
)
{
Event *e;
int i;
int n;
if ( ( deadflag ) && ( actortype != IS_INANIMATE ) )
{
return;
}
e = new Event( EV_Behavior_Args );
e->SetSource( EV_FROM_SCRIPT );
e->SetThread( ev->GetThread() );
e->SetLineNumber( ev->GetLineNumber() );
e->AddEntity( this );
n = ev->NumArgs();
e->AddString( "run" );
for( i = 1; i <= n; i++ )
{
e->AddToken( ev->GetToken( i ) );
}
SetBehavior( new GotoPathNode, e, ev->GetThread() );
}
void Actor::AttackEntity
(
Event *ev
)
{
Entity *ent;
if ( ( deadflag ) && ( actortype != IS_INANIMATE ) )
{
return;
}
ent = ev->GetEntity( 1 );
// don't get mad at things that can't be hurt or the world
if (
ent &&
( ent != world ) &&
( ent->takedamage != DAMAGE_NO )
)
{
ClearEnemies();
MakeEnemy( ent, true );
}
}
void Actor::AttackPlayer
(
Event *ev
)
{
int i;
edict_t *ent;
if ( ( deadflag ) && ( actortype != IS_INANIMATE ) )
{
return;
}
ClearEnemies();
// make enemies of all the players
for( i = 0; i < maxclients->value; i++ )
{
ent = &g_edicts[ i + 1 ];
if ( !ent->inuse || !ent->client || !ent->entity )
{
continue;
}
MakeEnemy( ent->entity, true );
}
currentEnemy = BestTarget();
if ( state != "sightenemy" )
{
if ( ForceAction( "sightenemy" ) )
{
seenEnemy = true;
Chatter( "snd_sightenemy", 5 );
}
}
}
void Actor::JumpToEvent
(
Event *ev
)
{
Event *e;
int i;
int n;
if ( ( deadflag ) && ( actortype != IS_INANIMATE ) )
{
return;
}
e = new Event( EV_Behavior_Args );
e->SetSource( EV_FROM_SCRIPT );
e->SetThread( ev->GetThread() );
e->SetLineNumber( ev->GetLineNumber() );
e->AddEntity( this );
n = ev->NumArgs();
e->AddString( "jump" );
for( i = 1; i <= n; i++ )
{
e->AddToken( ev->GetToken( i ) );
}
SetBehavior( new Jump, e, ev->GetThread() );
}
void Actor::GotoEvent
(
Event *ev
)
{
// This command was added because it was a common mistake when writing actor scripts
// to say "local.self goto label". Since we're such nice guys, we'll print a warning
// and send it on the the calling thread. :)
ScriptThread *thread;
thread = ev->GetThread();
if ( thread )
{
gi.dprintf( "Actor recieved 'goto' command. Passing to thread.\n" );
thread->ProcessEvent( ev );
}
else
{
// should never happen, but say something anyways.
gi.dprintf( "Actor recieved 'goto' command. Thread is NULL.\n" );
}
}
//***********************************************************************************************
//
// Script conditionals
//
//***********************************************************************************************
void Actor::IfEnemyVisibleEvent
(
Event *ev
)
{
ScriptThread *thread;
thread = ev->GetThread();
assert( thread );
if ( !thread )
{
return;
}
if ( CanSeeEnemyFrom( worldorigin ) )
{
thread->ProcessCommandFromEvent( ev, 1 );
}
}
void Actor::IfNearEvent
(
Event *ev
)
{
ScriptThread *thread;
Entity *ent;
Entity *bestent;
float bestdist;
float dist;
str name;
Vector delta;
float distance;
TargetList *tlist;
int n;
int i;
thread = ev->GetThread();
assert( thread );
if ( !thread )
{
return;
}
name = ev->GetString( 1 );
distance = ev->GetFloat( 2 );
if ( name[ 0 ] == '*' )
{
ent = ev->GetEntity( 1 );
if ( WithinDistance( ent, distance ) )
{
SetVariable( "other", ent );
thread->ProcessCommandFromEvent( ev, 3 );
}
}
else if ( name[ 0 ] == '$' )
{
bestent = NULL;
bestdist = distance * distance;
tlist = world->GetTargetList( str( &name[ 1 ] ) );
n = tlist->list.NumObjects();
for( i = 1; i <= n; i++ )
{
ent = tlist->list.ObjectAt( i );
delta = centroid - ent->centroid;
dist = delta * delta;
if ( dist <= bestdist )
{
bestent = ent;
bestdist = dist;
}
}
if ( bestent )
{
SetVariable( "other", bestent );
thread->ProcessCommandFromEvent( ev, 3 );
}
}
else
{
bestent = NULL;
bestdist = distance * distance;
ent = NULL;
while( ent = findradius( ent, worldorigin.vec3(), distance ) )
{
if ( ent->inheritsFrom( name.c_str() ) )
{
delta = centroid - ent->centroid;
dist = delta * delta;
if ( dist <= bestdist )
{
bestent = ent;
bestdist = dist;
}
}
}
if ( bestent )
{
SetVariable( "other", bestent );
thread->ProcessCommandFromEvent( ev, 3 );
}
}
}
void Actor::IfCanHideAtEvent
(
Event *ev
)
{
PathNode *node;
Vector pos;
ScriptThread *thread;
thread = ev->GetThread();
assert( thread );
if ( !thread )
{
return;
}
pos = ev->GetVector( 1 );
node = PathManager.NearestNode( pos, this );
if ( node && ( node->nodeflags & ( AI_DUCK | AI_COVER ) ) && !CanSeeEnemyFrom( pos ) )
{
if ( !node->entnum || ( node->entnum == entnum ) || ( node->occupiedTime < level.time ) )
{
thread->ProcessCommandFromEvent( ev, 2 );
}
}
}
void Actor::IfCanStrafeAttackEvent
(
Event *ev
)
{
ScriptThread *thread;
int num;
Vector delta;
Vector left;
Vector pos;
if ( !checkStrafe )
return;
if ( !currentEnemy )
{
return;
}
thread = ev->GetThread();
assert( thread );
if ( !thread )
{
return;
}
delta = currentEnemy->worldorigin - worldorigin;
left.x = -delta.y;
left.y = delta.x;
left.normalize();
num = gi.Anim_Random( edict->s.modelindex, "step_left" );
if ( num != -1 )
{
gi.Anim_Delta( edict->s.modelindex, num, delta.vec3() );
delta *= edict->s.scale;
pos = worldorigin + left * delta.length();
if ( CanMoveTo( pos ) && CanShootFrom( pos, currentEnemy, false ) )
{
thread->ProcessCommandFromEvent( ev, 1 );
return;
}
}
num = gi.Anim_Random( edict->s.modelindex, "step_right" );
if ( num != -1 )
{
gi.Anim_Delta( edict->s.modelindex, num, delta.vec3() );
delta *= edict->s.scale;
pos = worldorigin - left * delta.length();
if ( CanMoveTo( pos ) && CanShootFrom( pos, currentEnemy, false ) )
{
thread->ProcessCommandFromEvent( ev, 1 );
return;
}
}
}
void Actor::IfCanMeleeAttackEvent
(
Event *ev
)
{
ScriptThread *thread;
Vector delta;
float r;
if ( !currentEnemy || !has_melee )
{
return;
}
//### can't attack a player during a cinematic
if(level.cinematic && currentEnemy->isClient())
{
return;
}
//###
thread = ev->GetThread();
assert( thread );
if ( !thread )
{
return;
}
delta = centroid - currentEnemy->centroid;
r = delta.length();
if ( r <= melee_range )
{
thread->ProcessCommandFromEvent( ev, 1 );
}
}
void Actor::IfCanShootEvent
(
Event *ev
)
{
ScriptThread *thread;
if ( !currentEnemy )
{
return;
}
thread = ev->GetThread();
assert( thread );
if ( !thread )
{
return;
}
if ( CanShoot( currentEnemy, false ) )
{
thread->ProcessCommandFromEvent( ev, 1 );
}
}
void Actor::IfEnemyWithinEvent
(
Event *ev
)
{
ScriptThread *thread;
if ( !currentEnemy )
{
return;
}
thread = ev->GetThread();
assert( thread );
if ( !thread )
{
return;
}
if ( WithinDistance( currentEnemy, ev->GetFloat( 1 ) ) )
{
thread->ProcessCommandFromEvent( ev, 2 );
}
}
//***********************************************************************************************
//
// Sound reaction functions
//
//***********************************************************************************************
void Actor::IgnoreSoundsEvent
(
Event *ev
)
{
DisableState( "weaponsound" );
DisableState( "movementsound" );
DisableState( "painsound" );
DisableState( "deathsound" );
DisableState( "breakingsound" );
DisableState( "doorsound" );
DisableState( "mutantsound" );
DisableState( "voicesound" );
DisableState( "machinesound" );
DisableState( "radiosound" );
}
void Actor::RespondToSoundsEvent
(
Event *ev
)
{
EnableState( "weaponsound" );
EnableState( "movementsound" );
EnableState( "painsound" );
EnableState( "deathsound" );
EnableState( "breakingsound" );
EnableState( "doorsound" );
EnableState( "mutantsound" );
EnableState( "voicesound" );
EnableState( "machinesound" );
EnableState( "radiosound" );
}
void Actor::InvestigateWeaponSound
(
Event *ev
)
{
Vector location;
Entity *other;
if ( !currentEnemy && !deadflag && ( nextsoundtime < level.time ) )
{
other = ev->GetEntity( 1 );
location = ev->GetVector( 2 );
SetVariable( "other", other );
SetVariable( "location", location );
if ( DoAction( "weaponsound" ) )
{
nextsoundtime = level.time + 2;
}
}
}
void Actor::InvestigateMovementSound
(
Event *ev
)
{
Vector location;
Entity *other;
other = ev->GetEntity( 1 );
if ( other && !currentEnemy && !deadflag && ( nextsoundtime < level.time ) && Hates( other ) )
{
location = ev->GetVector( 2 );
SetVariable( "other", other );
SetVariable( "location", location );
if ( DoAction( "movementsound" ) )
nextsoundtime = level.time + 2;
}
}
void Actor::InvestigatePainSound
(
Event *ev
)
{
Vector location;
Entity *other;
if ( !currentEnemy && !deadflag && ( nextsoundtime < level.time ) )
{
other = ev->GetEntity( 1 );
location = ev->GetVector( 2 );
SetVariable( "other", other );
SetVariable( "location", location );
if ( DoAction( "painsound" ) )
nextsoundtime = level.time + 2;
}
}
void Actor::InvestigateDeathSound
(
Event *ev
)
{
Vector location;
Entity *other;
if ( !currentEnemy && !deadflag && ( nextsoundtime < level.time ) )
{
other = ev->GetEntity( 1 );
location = ev->GetVector( 2 );
SetVariable( "other", other );
SetVariable( "location", location );
if ( DoAction( "deathsound" ) )
nextsoundtime = level.time + 2;
}
}
void Actor::InvestigateBreakingSound
(
Event *ev
)
{
Vector location;
Entity *other;
if ( !currentEnemy && !deadflag && ( nextsoundtime < level.time ) )
{
other = ev->GetEntity( 1 );
location = ev->GetVector( 2 );
SetVariable( "other", other );
SetVariable( "location", location );
if ( DoAction( "breakingsound" ) )
nextsoundtime = level.time + 2;
}
}
void Actor::InvestigateDoorSound
(
Event *ev
)
{
Vector location;
Entity *other;
other = ev->GetEntity( 1 );
if ( other && !currentEnemy && !deadflag && ( nextsoundtime < level.time ) && Hates( other ) )
{
location = ev->GetVector( 2 );
SetVariable( "other", other );
SetVariable( "location", location );
if ( DoAction( "doorsound" ) )
nextsoundtime = level.time + 2;
}
}
void Actor::InvestigateMutantSound
(
Event *ev
)
{
Vector location;
Entity *other;
other = ev->GetEntity( 1 );
if ( other && !currentEnemy && !deadflag && ( nextsoundtime < level.time ) && Hates( other ) )
{
location = ev->GetVector( 2 );
SetVariable( "other", other );
SetVariable( "location", location );
if ( DoAction( "mutantsound" ) )
nextsoundtime = level.time + 2;
}
}
void Actor::InvestigateVoiceSound
(
Event *ev
)
{
Vector location;
Entity *other;
other = ev->GetEntity( 1 );
if ( other && !currentEnemy && !deadflag && ( nextsoundtime < level.time ) && Hates( other ) )
{
location = ev->GetVector( 2 );
SetVariable( "other", other );
SetVariable( "location", location );
if ( DoAction( "voicesound" ) )
nextsoundtime = level.time + 2;
}
}
void Actor::InvestigateMachineSound
(
Event *ev
)
{
Vector location;
Entity *other;
other = ev->GetEntity( 1 );
if ( other && !currentEnemy && !deadflag && ( nextsoundtime < level.time ) && Hates( other ) )
{
location = ev->GetVector( 2 );
SetVariable( "other", other );
SetVariable( "location", location );
if ( DoAction( "machinesound" ) )
nextsoundtime = level.time + 2;
}
}
void Actor::InvestigateRadioSound
(
Event *ev
)
{
Vector location;
Entity *other;
other = ev->GetEntity( 1 );
if ( other && !currentEnemy && !deadflag && ( nextsoundtime < level.time ) && Hates( other ) )
{
location = ev->GetVector( 2 );
SetVariable( "other", other );
SetVariable( "location", location );
if ( DoAction( "radiosound" ) )
nextsoundtime = level.time + 2;
}
}
//***********************************************************************************************
//
// Pain and death related functions
//
//***********************************************************************************************
void Actor::Pain
(
Event *ev
)
{
float damage;
Entity *ent;
float oldhealth;
float newhealth;
#ifdef DEBUG_PRINT
gi.dprintf( "Pain\n" );
#endif
damage = ev->GetFloat( 1 );
ent = ev->GetEntity( 2 );
// if it's a Sentient and not liked, attack 'em.
if ( ent && ent->isSubclassOf( Sentient ) && !Likes( ent ) )
{
MakeEnemy( ent );
if ( ent != currentEnemy )
{
currentEnemy = BestTarget();
}
}
if ( damage <= 0 )
{
return;
}
oldhealth = ( health + damage ) / max_health;
newhealth = health / max_health;
SetVariable( "other", ev->GetEntity( 2 ) );
// If we pass more than one range,
if ( ( oldhealth > 0.75 ) && ( newhealth <= 0.75 ) )
{
DoAction( "health_ok" );
}
if ( ( oldhealth > 0.5 ) && ( newhealth <= 0.5 ) )
{
DoAction( "health_med" );
}
if ( ( oldhealth > 0.25 ) && ( newhealth <= 0.25 ) )
{
DoAction( "health_low" );
}
if ( ( oldhealth > 0.1 ) && ( newhealth <= 0.1 ) )
{
DoAction( "health_danger" );
}
if ( damage <= pain_threshold )
{
Chatter( "snd_pain_taunt", 5, true );
return;
}
if ( strncmp( animname.c_str(), "pain", 4 ) && strncmp( animname.c_str(), "crouch_pain", 11 ) )
{
str aname;
int index;
//
// determine pain animation
//
if ( !strncmp( animname.c_str(), "crouch", 6 ) )
{
aname = "crouch_";
}
aname += str("pain_") + str( ev->GetString( 3 ) );
index = gi.Anim_Random( edict->s.modelindex, aname.c_str() );
if ( ( index == -1 ) && !strncmp( animname.c_str(), "crouch", 6 ) )
{
aname = "crouch_pain";
index = gi.Anim_Random( edict->s.modelindex, aname.c_str() );
}
if ( index == -1 )
{
aname = "pain";
}
SetVariable( "painanim", aname.c_str() );
DoAction( "pain" );
}
}
void Actor::Dead
(
Event *ev
)
{
Vector min, max;
Event *event;
StopAnimating();
if ( !groundentity && ( velocity != vec_zero ) )
{
// wait until we hit the ground
PostEvent( ev, FRAMETIME );
return;
}
//
// drop anything that might be attached to us
//
if ( numchildren )
{
Entity * child;
int i;
//
// detach all our children
//
for ( i = 0; i < MAX_MODEL_CHILDREN; i++ )
{
if ( children[ i ] )
{
child = ( Entity * )G_GetEntity( children[ i ] );
child->ProcessEvent( EV_Detach );
}
}
}
deadflag = DEAD_DEAD;
maxs[0] *= 2.0f;
maxs[1] *= 2.0f;
maxs[2] *= 0.3f;
setSize(mins,maxs);
edict->svflags |= SVF_DEADMONSTER;
setMoveType( MOVETYPE_NONE );
setOrigin( worldorigin );
if ( deathgib )
{
// Put down a bloodsplat
Vector start, end, dir, norm, ang;
float scale;
BloodSplat *splat;
trace_t trace;
dir = Vector( 0, 0, -1 );
start = centroid;
end = start + 100 * dir;
trace = G_Trace( start, vec_zero, vec_zero, end, this, MASK_SOLIDNONFENCE, "Actor::Dead" );
if ( !( HitSky( &trace ) || ( trace.ent->solid != SOLID_BSP ) || ( trace.ent->s.number != 0 ) ) )
{
scale = G_Random( 1.2 );
if ( scale < 0.5 )
scale = 0.5;
norm = trace.plane.normal;
norm.x = -norm.x;
norm.y = -norm.y;
ang = norm.toAngles();
ang.z = G_Random( 360 );
end = trace.endpos + Vector( trace.plane.normal ) * 0.2;
splat = new BloodSplat( end, ang, scale );
}
}
// If this body has nothing interesting, then remove it
if ( !NumInventoryItems() )
{
if ( nodeathfade )
return;
PostEvent( EV_FadeOut, 10 );
return;
}
// Spawn a touch field
min = worldorigin - "32 32 32";
max = worldorigin + "32 32 32";
trig = new TouchField;
trig->Setup( this, EV_Touch, min, max, TRIGGER_PLAYERS );
assert( trig->edict->solid == SOLID_TRIGGER );
if ( !nodeathfade )
{
// Check in the future for uselessness
event = new Event ( EV_Sentient_UselessCheck );
PostEvent ( event, 1.0f + G_Random() );
// If this guy has no InventoryItems, then fade him in 1 minute
if ( !HasInventoryOfType( "InventoryItem" ) )
{
PostEvent( EV_Actor_Remove, 60.0f );
}
}
}
void Actor::Killed
(
Event *ev
)
{
const char *name;
Entity *ent;
int num;
Entity *attacker;
Entity *inflictor;
Vector dir;
Event *event;
int i;
str dname;
int meansofdeath;
int j; //###
CheckWater();
StopAnimating();
CancelPendingEvents();
// don't allow them to fly, think, or swim anymore
flags &= ~( FL_PRETHINK | FL_SWIM | FL_FLY );
deadflag = DEAD_DYING;
takedamage = DAMAGE_YES;
groundentity = NULL;
attacker = ev->GetEntity( 1 );
inflictor = ev->GetEntity( 3 );
meansofdeath = ev->GetInteger( 5 );
// Double all the armor
DoubleArmor();
SetVariable( "other", ev->GetEntity( 1 ) );
if ( !DoAction( "killed" ) && actorthread )
{
actorthread->ProcessEvent( EV_ScriptThread_End );
}
// Turn off dlight and shadow
edict->s.renderfx &= ~( RF_DLIGHT|RF_XFLIP );
//
// kill the killtargets
//
//###
/*
name = KillTarget();
if ( name && strcmp( name, "" ) )
{
num = 0;
do
{
num = G_FindTarget( num, name );
if ( !num )
{
break;
}
ent = G_GetEntity( num );
ent->PostEvent( EV_Remove, 0 );
}
while ( 1 );
}
*/
// added extended targeting stuff
name = KillTarget();
for(j = 0; j < 2; j++)
{
switch(j)
{
case 0:
name = KillTarget();
break;
case 1:
name = KillTarget2();
break;
}
if ( name && strcmp( name, "" ) )
{
num = 0;
do
{
num = G_FindTarget( num, name );
if ( !num )
{
break;
}
ent = G_GetEntity( num );
ent->PostEvent( EV_Remove, 0 );
} while ( 1 );
}
}
//###
//
// fire targets
//
//###
/*
name = Target();
if ( name && strcmp( name, "" ) )
{
num = 0;
do
{
num = G_FindTarget( num, name );
if ( !num )
{
break;
}
ent = G_GetEntity( num );
event = new Event( EV_Activate );
event->AddEntity( attacker );
ent->PostEvent( event, 0 );
}
while ( 1 );
}
*/
// added extended targeting stuff
for(j = 0; j < 4; j++)
{
switch(j)
{
case 0:
name = Target();
break;
case 1:
name = Target2();
break;
case 2:
name = Target3();
break;
case 3:
name = Target4();
break;
}
if ( name && strcmp( name, "" ) )
{
num = 0;
do
{
num = G_FindTarget( num, name );
if ( !num )
{
break;
}
ent = G_GetEntity( num );
event = new Event( EV_Activate );
event->AddEntity( attacker );
ent->ProcessEvent( event );
} while ( 1 );
}
}
//###
//
// see if we have a kill_thread
//
if ( kill_thread.length() > 1 )
{
ScriptThread * thread;
//
// create the thread, but don't start it yet
//
thread = ExecuteThread( kill_thread, false );
if ( thread )
{
ProcessScript( thread, NULL );
}
else
{
warning( "Killed", "could not process kill_thread" );
}
}
if (flags & FL_DIE_EXPLODE)
{
CreateExplosion( worldorigin, 150*edict->s.scale, edict->s.scale * 2, true, this, this, this );
}
if ( flags & FL_DIE_TESSELATE )
{
float power;
setSolidType( SOLID_NOT );
hideModel();
dir = worldorigin - attacker->worldorigin;
if ( meansofdeath == MOD_ION )
{
power = 1000;
}
else
{
power = ev->GetFloat( 2 );
}
TesselateModel
(
this,
tess_min_size,
tess_max_size,
dir,
power,
1.0f,
tess_thickness,
vec3_origin
);
DropInventoryItems();
// Tesselated models require the model to be on the client for 1 more frame
PostEvent( EV_Remove, FRAMETIME );
return;
}
if ( DoGib( meansofdeath, inflictor ) )
{
deathgib = true;
}
//###
// skin darkening for death from flames
if(inflictor->isSubclassOf(ThrowerFlame) || meansofdeath == MOD_FLAMETHROWER)
{
edict->s.renderfx |= RF_LIGHTOFFSET;
edict->s.lightofs = -127;
CancelEventsOfType(EV_Sentient_HurtFlame);
PostEvent(EV_Sentient_HurtFlame, 5);
edict->s.effects &= ~EF_FLAMES;
edict->s.effects |= EF_DEATHFLAMES;
}
else
{
// turn off the actor's heat signature
edict->s.effects &= ~EF_WARM;
}
//###
if ( currentWeapon )
{
DropWeapon( currentWeapon );
}
animOverride = false;
//
// determine death animation
//
if ( !strncmp( animname.c_str(), "crouch", 6 ) )
{
dname = "crouch_";
}
if ( deathgib )
{
str location;
location = ev->GetString( 4 );
// Check for location first otherwise randomize
if ( location == "torso_upper" )
dname += str( "gibdeath_upper" );
else if ( location == "torso_lower" )
dname += str( "gibdeath_lower" );
else if ( strstr( location.c_str(), "leg" ) )
dname += str( "gibdeath_lower" );
else if ( strstr( location.c_str(), "arm" ) )
dname += str( "gibdeath_upper" );
else if ( strstr( location.c_str(), "head" ) )
dname += str( "gibdeath_upper" );
else if ( G_Random() > 0.5 )
dname += str( "gibdeath_upper" );
else
dname += str( "gibdeath_lower" );
}
else
{
dname += str( "death_" ) + str( ev->GetString( 4 ) );
}
i = gi.Anim_Random( edict->s.modelindex, dname.c_str() );
if ( ( i == -1 ) && !strncmp( animname.c_str(), "crouch", 6 ) )
{
dname = "crouch_death";
i = gi.Anim_Random( edict->s.modelindex, dname.c_str() );
}
if ( i == -1 )
{
dname = "death";
}
if ( ( i != -1 ) && ( !strncmp( dname.c_str(), "gibdeath", 7 ) ) )
{
Event *ev1;
ev1 = new Event( EV_Gib );
ev1->AddInteger( 1 );
ProcessEvent( ev1 );
}
if ( attacker )
{
str location;
float damage;
damage = ev->GetFloat( 2 );
location = ev->GetString( 4 );
event = new Event( EV_GotKill );
event->AddEntity( this );
event->AddInteger( damage );
event->AddEntity( inflictor );
event->AddString( location );
event->AddInteger( meansofdeath );
event->AddInteger( deathgib );
attacker->ProcessEvent( event );
}
SetAnim( dname.c_str(), EV_Actor_Dead );
// Call changeanim immediatly since we're no longer calling prethink
ChangeAnim();
//
// moved this here so guys would not be solid right away
//
edict->svflags |= SVF_DEADMONSTER;
edict->clipmask = MASK_DEADSOLID;
if ( velocity.z < 10 )
{
velocity.z += G_Random( 300 );
}
angles.x = 0;
angles.z = 0;
setAngles( angles );
}
void Actor::GibEvent
(
Event *ev
)
{
qboolean hidemodel;
hidemodel = !ev->GetInteger( 1 );
if ( sv_gibs->value && !parentmode->value )
{
int numgibs;
float gibsize;
if ( hidemodel )
{
takedamage = DAMAGE_NO;
setSolidType( SOLID_NOT );
hideModel();
// If there is a touchfield, remove it.
if ( trig )
{
trig->PostEvent( EV_Remove, 0 );
trig = NULL;
}
}
gibsize = size.length() / 140;
numgibs = gibsize * 6;
if ( numgibs > 4 )
numgibs = 4;
CreateGibs( this, health, gibsize, numgibs );
}
DropInventoryItems();
if ( hidemodel )
PostEvent( EV_Remove, 0 );
}
void Actor::RemoveUselessBody
(
Event *ev
)
{
if ( trig )
{
trig->PostEvent( EV_Remove, 0 );
trig = NULL;
}
CancelEventsOfType( EV_Sentient_UselessCheck );
PostEvent( EV_FadeOut, 5);
}
void Actor::SetPainThresholdEvent
(
Event *ev
)
{
pain_threshold = ( ev->GetFloat( 1 ) ) * skill->value * 0.66f;
}
void Actor::SetKillThreadEvent
(
Event *ev
)
{
kill_thread = ev->GetString( 1 );
}
void Actor::AttackRangeEvent
(
Event *ev
)
{
attack_range = ev->GetFloat( 1 );
}
void Actor::AttackModeEvent
(
Event *ev
)
{
attackmode = ev->GetInteger( 1 );
SetVariable( "attackmode", attackmode );
}
void Actor::ShotsPerAttackEvent
(
Event *ev
)
{
float shots;
shots = ev->GetFloat( 1 );
//
// scale the shots based on skill
//
if ( skill->value < 1 )
shots_per_attack = shots * 0.4f;
else if ( skill->value < 2 )
shots_per_attack = shots * 0.7f;
else if ( skill->value < 3 )
shots_per_attack = shots;
else
shots_per_attack = shots * skill->value * 0.4f;
}
void Actor::ClearEnemyEvent
(
Event *ev
)
{
ClearEnemies();
}
void Actor::NoDeathFadeEvent
(
Event *ev
)
{
nodeathfade = true;
}
void Actor::NoChatterEvent
(
Event *ev
)
{
nochatter = true;
}
void Actor::TurnSpeedEvent
(
Event *ev
)
{
turnspeed = ev->GetFloat( 1 );
}
//***********************************************************************************************
//
// Movement functions
//
//***********************************************************************************************
void Actor::ForwardSpeedEvent
(
Event *ev
)
{
forwardspeed = ev->GetFloat( 1 );
}
void Actor::SwimEvent
(
Event *ev
)
{
// movement |= AI_CANSWIM;
flags &= ~FL_FLY;
flags |= FL_SWIM;
}
void Actor::FlyEvent
(
Event *ev
)
{
// movement |= AI_CANFLY;
flags &= ~FL_SWIM;
flags |= FL_FLY;
}
void Actor::NotLandEvent
(
Event *ev
)
{
//movement &= ~AI_CANWALK;
flags &= FL_SWIM | FL_FLY;
}
inline qboolean Actor::CanMoveTo
(
Vector pos
)
{
Vector min;
trace_t trace;
Vector start;
Vector end;
Vector s;
s = Vector( 0, 0, STEPSIZE );
start = worldorigin + s;
end = pos + s;
trace = G_Trace( start, mins, maxs, end, this, edict->clipmask, "Actor::CanMoveTo" );
if ( trace.fraction == 1 )
{
return true;
}
return false;
}
inline void Actor::CheckWater
(
void
)
{
Vector sample[3];
int cont;
//
// get waterlevel and type
//
waterlevel = 0;
watertype = 0;
sample[ 0 ] = worldorigin;
sample[ 2 ] = EyePosition();
sample[ 1 ] = ( sample[ 0 ] + sample[ 2 ] ) * 0.5f;
cont = gi.pointcontents( sample[ 0 ].vec3() );
if (cont & MASK_WATER)
{
watertype = cont;
waterlevel = 1;
cont = gi.pointcontents( sample[ 2 ].vec3() );
if (cont & MASK_WATER)
{
waterlevel = 3;
}
else
{
cont = gi.pointcontents( sample[ 1 ].vec3() );
if (cont & MASK_WATER)
{
waterlevel = 2;
}
}
}
}
#define MAX_PITCH 75
void Actor::Accelerate
(
Vector steering
)
{
//### activate this to limit turnrate
//#if 0
if ( steering.y > turnspeed )
steering.y = turnspeed;
else if ( steering.y < -turnspeed )
steering.y = -turnspeed;
//#endif
angles.y += steering.y;
if ( frame_delta.x > 4 )
{
// make him lean into the turn a bit
angles.z = movespeed * ( 0.4f / 320.0f ) * steering.y;
if ( ( flags & FL_FLY ) || ( ( flags & FL_SWIM ) && waterlevel > 0 ) )
{
angles.z = bound( angles.z, -2, 2 );
}
else
{
angles.z = bound( angles.z, -5, 5 );
}
}
else
{
angles.z = 0;
}
if ( ( flags & FL_FLY ) || ( ( flags & FL_SWIM ) && waterlevel > 0 ) )
{
angles.x -= steering.x;
//angles.x = bound( angles.x, -MAX_PITCH, MAX_PITCH );
}
setAngles( angles );
}
void Actor::CalcMove
(
void
)
{
if ( total_delta != vec_zero )
{
// movement deltas have inverted Y axis
total_delta[ 1 ] = -total_delta[ 1 ];
MatrixTransformVector( total_delta.vec3(), orientation, move.vec3() );
total_delta = vec_zero;
}
else
{
move = vec_zero;
}
// force movement if forwardspeed is set
if ( forwardspeed )
{
if ( move == vec_zero )
{
move = orientation[ 0 ];
}
else
{
move.normalize();
}
animdir = move;
movedir = move;
movespeed = forwardspeed;
move *= movespeed * FRAMETIME;
totallen = forwardspeed;
movevelocity = movedir * movespeed;
}
}
void Actor::setAngles
(
Vector ang
)
{
Sentient::setAngles( ang );
MatrixTransformVector( animdir.vec3(), orientation, movedir.vec3() );
movevelocity = movedir * movespeed;
}
stepmoveresult_t Actor::WaterMove
(
void
)
{
Vector oldorg;
Vector neworg;
trace_t trace;
int oldwater;
if ( ( totallen <= 0.01f ) || ( move == vec_zero ) )
{
return STEPMOVE_OK;
}
// try the move
oldorg = worldorigin;
neworg = worldorigin + move;
trace = G_Trace( oldorg, mins, maxs, neworg, this, edict->clipmask, "Actor::WaterMove 1" );
if ( trace.fraction == 0 )
{
return STEPMOVE_STUCK;
}
oldwater = waterlevel;
setOrigin( trace.endpos );
CheckWater();
// swim monsters don't exit water voluntarily
if ( ( oldwater > 1 ) && ( waterlevel < 2 ) )
{
waterlevel = oldwater;
setOrigin( oldorg );
return STEPMOVE_STUCK;
}
return STEPMOVE_OK;
}
stepmoveresult_t Actor::AirMove
(
void
)
{
Vector oldorg;
Vector neworg;
trace_t trace;
int oldwater;
if ( ( totallen <= 0.01f ) || ( move == vec_zero ) )
{
return STEPMOVE_OK;
}
// try the move
oldorg = worldorigin;
neworg = worldorigin + move;
trace = G_Trace( oldorg, mins, maxs, neworg, this, edict->clipmask, "Actor::AirMove 1" );
if ( trace.fraction == 0 )
{
return STEPMOVE_BLOCKED_BY_WATER;
}
oldwater = waterlevel;
setOrigin( trace.endpos );
CheckWater();
// fly monsters don't enter water voluntarily
if ( !oldwater && waterlevel )
{
waterlevel = oldwater;
setOrigin( oldorg );
return STEPMOVE_STUCK;
}
return STEPMOVE_OK;
}
//###
// used below for a slight movement tweak
// added as a global here to prevent constant re-allocation
Vector movetweak = "0 0 2";
//###
//### added stuff to make MOVETYPE_CEILINGSTEP work
stepmoveresult_t Actor::TryMove
(
void
)
{
Vector oldorg;
Vector neworg;
Vector end;
Entity *ent;
trace_t trace;
Door *door;
#if 0
vec3_t test;
int contents;
#endif
if ( ( totallen <= 0.01f ) || ( move == vec_zero ) )
{
return STEPMOVE_OK;
}
// try the move
oldorg = worldorigin;
neworg = worldorigin + move;
// push down from a step height above the wished position
//###
if(movetype == MOVETYPE_CEILINGSTEP)
{
neworg[ 2 ] -= STEPSIZE;
end = neworg;
end[ 2 ] += STEPSIZE * 4;//2;
}
else
{
neworg[ 2 ] += STEPSIZE;
end = neworg;
end[ 2 ] -= STEPSIZE * 4;//2;
}
//###
trace = G_Trace( neworg, mins, maxs, end, this, edict->clipmask, "Actor::TryMove 1" );
if ( trace.allsolid )
{
ent = trace.ent->entity;
if ( ent && ent->isSubclassOf( Door ) )
{
if ( state == "opendoor" )
{
return STEPMOVE_OK;
}
door = ( Door * )ent;
if ( !door->locked && !door->isOpen() )
{
SetVariable( "other", ent );
SetVariable( "dir", end - worldorigin );
ForceAction( "opendoor" );
return STEPMOVE_OK;
}
}
return STEPMOVE_STUCK;
}
if ( trace.startsolid )
{
//###
if(movetype == MOVETYPE_CEILINGSTEP)
{
neworg[ 2 ] += STEPSIZE;
}
else
{
neworg[ 2 ] -= STEPSIZE;
}
//###
//###KDT - The following line altered to allow short actors to detect doors,
// It doesn't seem to break anything else...
// trace = G_Trace( neworg, mins, maxs, end, this, edict->clipmask, "Actor::TryMove 2" );
if(maxs[2]>STEPSIZE*3)
trace = G_Trace( neworg, mins, maxs, end, this, edict->clipmask, "Actor::TryMove 2" );
else
trace = G_Trace(neworg + movetweak, mins, maxs - movetweak, end, this, edict->clipmask, "Actor::TryMove 2" );
//###
if ( trace.allsolid || trace.startsolid )
{
ent = trace.ent->entity;
if ( ent && ent->isSubclassOf( Door ) )
{
if ( state == "opendoor" )
{
return STEPMOVE_OK;
}
door = ( Door * )ent;
if ( !door->locked && !door->isOpen() )
{
SetVariable( "other", ent );
SetVariable( "dir", end - worldorigin );
ForceAction( "opendoor" );
return STEPMOVE_OK;
}
}
return STEPMOVE_STUCK;
}
}
#if 0
// don't go in to water
if ( waterlevel == 0 )
{
test[ 0 ] = trace.endpos[ 0 ];
test[ 1 ] = trace.endpos[ 1 ];
test[ 2 ] = trace.endpos[ 2 ] + mins[ 2 ] + 1;
contents = gi.pointcontents( test );
if ( contents & MASK_WATER )
{
return STEPMOVE_BLOCKED_BY_WATER;
}
}
#endif
if ( trace.fraction == 1 )
{
// don't let guys get stuck standing on other guys
// if monster had the ground pulled out, go ahead and fall
if ( ( flags & FL_PARTIALGROUND ) || ( groundentity && groundentity->entity &&
( groundentity->entity->isSubclassOf( Sentient ) ) ) )
{
setOrigin( worldorigin + move );
groundentity = NULL;
return STEPMOVE_OK;
}
// walked off an edge
return STEPMOVE_BLOCKED_BY_FALL;
}
// check point traces down for dangling corners
worldorigin = trace.endpos;
if ( !M_CheckBottom( this ) )
{
// don't let guys get stuck standing on other guys
if ( ( flags & FL_PARTIALGROUND ) || ( groundentity && groundentity->entity &&
( groundentity->entity->isSubclassOf( Sentient ) ) ) )
{
// entity had floor mostly pulled out from underneath it
// and is trying to correct
setOrigin( worldorigin );
CheckWater();
return STEPMOVE_OK;
}
setOrigin( oldorg );
return STEPMOVE_BLOCKED_BY_FALL;
}
if ( flags & FL_PARTIALGROUND )
{
flags &= ~FL_PARTIALGROUND;
}
groundentity = trace.ent;
groundentity_linkcount = trace.ent->linkcount;
groundplane = trace.plane;
groundsurface = trace.surface;
groundcontents = trace.contents;
// the move is ok
setOrigin( worldorigin );
CheckWater();
return STEPMOVE_OK;
}
void Actor::SetAim
(
Event *ev
)
{
aim = ev->GetFloat( 1 );
}
void Actor::SetMeleeRange
(
Event *ev
)
{
melee_range = ev->GetFloat( 1 );
melee_range *= edict->s.scale;
if ( melee_range < 70 )
melee_range = 70;
}
void Actor::SetMeleeDamage
(
Event *ev
)
{
melee_damage = ev->GetFloat( 1 );
melee_damage *= edict->s.scale;
}
void Actor::MeleeEvent
(
Event *ev
)
{
trace_t trace;
Vector start;
Vector end;
float damage;
float extra_reach;
Vector org;
Vector ang;
Vector dir;
float kick;
if ( !has_melee )
{
warning( "MeleeEvent","Melee being called without animation" );
return;
}
damage = G_Random( melee_damage*0.5f )+ G_Random( melee_damage*0.5f );
if ( ev->NumArgs() > 0 )
extra_reach = ev->GetFloat( 1 );
else
extra_reach = 0;
if ( ev->NumArgs() > 1 )
{
kick = ev->GetFloat( 2 );
}
else
{
kick = damage * 3;
}
// get the position of the attack
start = GunPosition();
// get the attack_dir
ang = MyGunAngles( start, true );
ang.AngleVectors( &dir, NULL, NULL );
end = start + dir * ( melee_range + extra_reach );
trace = G_FullTrace( start, vec_zero, vec_zero, end, 15, this, MASK_PROJECTILE, "Actor::Melee" );
dir = Vector(trace.endpos) - start;
dir.normalize();
org = Vector(trace.endpos) - dir;
if ( (trace.fraction < 1.0f) )
{
if ( trace.ent->entity && trace.ent->entity->takedamage )
{
if ( trace.ent->entity->flags & FL_BLOOD )
SpawnBlood( org, trace.plane.normal, damage );
RandomGlobalSound("impact_goryimpact");
if ( trace.intersect.valid )
{
// We hit a valid group so send in location based damage
trace.ent->entity->Damage( this,
this,
damage,
trace.endpos,
dir,
trace.plane.normal,
kick,
0,
MOD_FISTS,
trace.intersect.parentgroup,
-1,
trace.intersect.damage_multiplier );
}
else
{
// take the ground out so that the kick works
trace.ent->entity->groundentity = NULL;
// We didn't hit any groups, so send in generic damage
trace.ent->entity->Damage( this,
this,
damage,
trace.endpos,
dir,
trace.plane.normal,
kick,
0,
MOD_FISTS,
-1,
-1,
1 );
}
}
}
}
void Actor::AttackFinishedEvent
(
Event *ev
)
{
if ( currentWeapon )
{
currentWeapon->PostEvent( EV_Weapon_FinishAttack, 0 );
}
}
float Actor::JumpTo
(
Vector targ,
float speed
)
{
float traveltime;
float vertical_speed;
Vector target;
Vector dir;
Vector xydir;
CheckWater();
//
// if we got a jump, go into that mode
//
traveltime = 0;
if ( speed <= 0 )
{
speed = movespeed * 1.5f;
if ( speed < (400 * gravity) )
speed = (400 * gravity);
}
target = targ;
dir = target - worldorigin;
xydir = dir;
xydir.z = 0;
setAngles( xydir.toAngles() );
traveltime = xydir.length() / speed;
//
// we add 16 to allow for a little bit higher
//
if ( waterlevel > 2 )
{
vertical_speed = ( ( dir.z + 16 ) / traveltime ) + ( 0.5f * gravity * 60 * traveltime );
}
else
{
vertical_speed = ( ( dir.z + 16 ) / traveltime ) + ( 0.5f * gravity * sv_gravity->value * traveltime );
}
xydir.normalize();
velocity = speed * xydir;
velocity.z = vertical_speed;
return traveltime;
}
float Actor::JumpTo
(
PathNode *goal,
float speed
)
{
if ( goal )
return JumpTo( goal->worldorigin, speed );
else
return 0;
}
float Actor::JumpTo
(
Entity *goal,
float speed
)
{
if ( goal )
return JumpTo( goal->worldorigin, speed );
else
return 0;
}
EXPORT_FROM_DLL void Actor::setSize
(
Vector min,
Vector max
)
{
min *= edict->s.scale;
max *= edict->s.scale;
Sentient::setSize( min, max );
}
EXPORT_FROM_DLL void Actor::SetHealth
(
Event *ev
)
{
health = ev->GetFloat( 1 ) * edict->s.scale;
max_health = health;
}
//***********************************************************************************************
//
// Debug functions
//
//***********************************************************************************************
void Actor::ShowInfo
(
void
)
{
Entity *ent;
int i;
int n;
StateInfo *ptr;
gi.printf( "\nEntity # : %d\n", entnum );
gi.printf( "Class ID : %s\n", getClassID() );
gi.printf( "Classname : %s\n", getClassname() );
gi.printf( "Targetname : %s\n", TargetName() );
gi.printf( "Origin : ( %f, %f, %f )\n", worldorigin.x, worldorigin.y, worldorigin.z );
gi.printf( "Bounds : Mins( %.2f, %.2f, %.2f ) Maxs( %.2f, %.2f, %.2f )\n", mins.x, mins.y, mins.z, maxs.x, maxs.y, maxs.z );
gi.printf( "State : %s\n", state.c_str() );
//### added extra info for the crawler
if(isSubclassOf(Crawler))
{
gi.printf( "onceiling : %i\n", (int)((Crawler *)this)->onceiling );
}
if(movetype == MOVETYPE_STEP)
gi.printf( "Movetype : MOVETYPE_STEP\n");
else if(movetype == MOVETYPE_CEILINGSTEP)
gi.printf( "Movetype : MOVETYPE_CEILINGSTEP\n");
else
gi.printf( "Movetype : %i\n", (int)movetype);
//###
if ( behavior )
{
gi.printf( "Behavior : %s\n", behavior->getClassname() );
}
else
{
gi.printf( "Behavior : NULL -- was '%s'\n", currentBehavior.c_str() );
}
if ( actorthread )
{
gi.printf( "Thread : %s(%d)\n", actorthread->Filename(), actorthread->CurrentLine() );
}
else
{
gi.printf( "Thread : NULL\n" );
}
gi.printf( "Actortype : %d\n", actortype );
gi.printf( "Attackmode : %d\n", attackmode );
gi.printf( "Model : %s\n", model.c_str() );
gi.printf( "Anim : %s\n", animname.c_str() );
gi.printf( "Movespeed : %.2f\n", movespeed );
gi.printf( "Health : %f\n", health );
gi.printf( "\nResponses:\n" );
n = actionList.NumObjects();
for( i = 1; i <= n; i++ )
{
ptr = actionList.ObjectAt( i );
gi.printf( "%s : ", ptr->action.c_str() );
if ( ptr->ignore )
{
gi.printf( "ignored - " );
}
gi.printf( "%s\n", ptr->response.c_str() );
}
n = enemyList.NumObjects();
if ( n )
{
gi.printf( "\nEnemies:\n" );
for( i = 1; i <= n; i++ )
{
ent = enemyList.ObjectAt( i );
if ( ent )
{
if ( currentEnemy == ent )
{
gi.printf( "*" );
}
else
{
gi.printf( " " );
}
gi.printf( "%d : '%s'", ent->entnum, ent->targetname.c_str() );
gi.printf( "\n" );
}
}
}
gi.printf( "seenEnemy: %d\n", seenEnemy );
gi.printf( "actortype: %d\n", actortype );
gi.printf( "deadflag: %d\n", deadflag );
gi.printf( "\n" );
if ( behavior )
{
gi.printf( "Behavior Info:\n" );
gi.printf( "Game time: %f\n", level.time );
behavior->ShowInfo( *this );
gi.printf( "\n" );
}
}
//***********************************************************************************************
//
// General functions
//
//***********************************************************************************************
void Actor::Chatter
(
const char *snd,
float chance,
float volume,
int channel
)
{
str realname;
if ( nochatter || chattime > level.time )
{
return;
}
if ( G_Random( 10 ) > chance )
{
chattime = level.time + 1 + G_Random( 2 );
return;
}
realname = GetRandomAlias( snd );
if ( realname.length() > 1 )
{
float delay;
delay = gi.SoundLength( realname.c_str() );
chattime = level.time + delay + 4 + G_Random( 5 );
sound( realname, volume, channel );
}
else
{
// set it into the future, so we don't check it again right away
chattime = level.time + 1;
}
}
void Actor::ActivateEvent
(
Event *ev
)
{
Entity *ent;
if ( ( deadflag ) && ( actortype != IS_INANIMATE ) )
{
return;
}
ent = ev->GetEntity( 1 );
SetVariable( "other", ent );
DoAction( "activate" );
}
void Actor::UseEvent
(
Event *ev
)
{
Entity *ent;
if ( ( deadflag ) && ( actortype != IS_INANIMATE ) )
{
return;
}
ent = ev->GetEntity( 1 );
SetVariable( "other", ent );
DoAction( "use" );
}
void Actor::Prethink
(
void
)
{
range_t range;
Event *event;
assert( actorthread );
if ( !actorthread )
{
// not having a script is bad
gi.dprintf( "Null actorthread. Killing actor '%s'(%d).\n", targetname.c_str(), entnum );
// just kill him
event = new Event( EV_Killed );
event->AddEntity( this );
event->AddInteger( 0 );
event->AddEntity( this );
event->AddString( "all" );
ProcessEvent( event );
return;
}
if ( hidden() )
{
// Don't think while hidden, you're just a cinematic.
return;
}
if ( actortype == IS_INANIMATE )
{
if ( behavior && !behavior->Evaluate( *this ) )
{
// stop thinking
flags &= ~FL_PRETHINK;
EndBehavior();
}
return;
}
if ( currentEnemy )
{
if ( currentEnemy->deadflag )
{
DoAction( "enemydead" );
currentEnemy = NULL;
seenEnemy = false;
}
else
{
range = Range( currentEnemy );
if ( ( lastEnemy != currentEnemy ) || ( range != enemyRange ) )
{
lastEnemy = currentEnemy;
enemyRange = range;
SetVariable( "other", currentEnemy );
switch( range )
{
case RANGE_MELEE :
DoAction( "range_melee" );
break;
case RANGE_NEAR :
DoAction( "range_near" );
break;
case RANGE_MID :
DoAction( "range_mid" );
break;
case RANGE_FAR :
DoAction( "range_far" );
break;
}
}
}
}
else
{
lastEnemy = NULL;
enemyRange = RANGE_FAR;
}
eyeposition[ 2 ] = maxs[ 2 ] + eyeoffset[ 2 ];
angles.z = 0;
#ifdef DEBUG_PRINT
gi.dprintf( "stack %d : %s : %s\n", numonstack, behavior ? behavior->getClassname() : "", animname.c_str() );
#endif
if ( behavior && !behavior->Evaluate( *this ) )
{
EndBehavior();
}
if ( newanimnum != -1 )
{
ChangeAnim();
}
CalcMove();
lastmove = STEPMOVE_STUCK;
if ( flags & FL_SWIM )
{
lastmove = WaterMove();
}
else if ( flags & FL_FLY )
{
lastmove = AirMove();
}
else
{
lastmove = TryMove();
}
//
// see if we should damage the actor because of waterlevel
//
if ( waterlevel == 3 && !( flags & FL_SWIM ) )
{
// if out of air, start drowning
if ( air_finished < level.time )
{
// we may have been in a water brush when we spawned, so check our water level again to be sure
CheckWater();
if ( waterlevel < 3 )
{
// we're ok, so reset our air
air_finished = level.time + 5;
}
else if ( next_drown_time < level.time && health > 0 )
{
// drown!
next_drown_time = level.time + 1;
RandomGlobalSound( "snd_uwchoke", 1, CHAN_VOICE, ATTN_NORM );
ProcessEvent( EV_PainSound );
Damage( world, world, 15, worldorigin, vec_zero, vec_zero, 0, DAMAGE_NO_ARMOR, MOD_DROWN, -1, -1, 1.0f );
}
}
}
else
{
air_finished = level.time + 5;
}
G_TouchTriggers( this );
if ( groundentity && ( groundentity->entity != world ) && !M_CheckBottom( this ) )
{
// G_FixCheckBottom( this );
flags |= FL_PARTIALGROUND;
}
}
/*****************************************************************************/
/*SINED info_monster_spawnspot (1 0 0) (-16 -16 0) (16 16 64)
Potential spawn location for a monster.
"spawngroup" - the name of the group of spawn spots that this one belongs to.
Monsters use spawngroup to choose which spawn spots to spawn at.
"angle" - the orientation for the monster to spawn in.
"angles" - the full ( x, y, z ) orientation for the monster to spawn in.
"anim" - the animation that the monster should use when spawning here.
/*****************************************************************************/
CLASS_DECLARATION( PathNode, MonsterStart, "info_monster_spawnspot" );
ResponseDef MonsterStart::Responses[] =
{
{ NULL, NULL }
};
MonsterStart::MonsterStart()
{
spawngroup = G_GetSpawnArg( "spawngroup", "" );
leader = NULL;
leader = GetGroupLeader( spawngroup );
if ( !leader )
{
leader = this;
groupchain = NULL;
}
else
{
groupchain = leader->groupchain;
leader->groupchain = this;
}
}
MonsterStart *MonsterStart::GetGroupLeader
(
str& groupname
)
{
Entity *ent;
MonsterStart *m;
for( ent = world; ent; ent = G_NextEntity( ent ) )
{
if ( ent->isSubclassOf( MonsterStart ) )
{
m = ( MonsterStart * )ent;
if ( ( m->spawngroup == groupname ) && m->leader )
{
return m->leader;
}
}
}
return NULL;
}
MonsterStart *MonsterStart::GetRandomSpot
(
str& groupname
)
{
MonsterStart *leader;
MonsterStart *m;
int num;
int i;
int j;
leader = GetGroupLeader( groupname );
if ( !leader )
{
return NULL;
}
num = 0;
for( m = leader; m != NULL; m = m->groupchain )
{
num++;
}
j = ( int )G_Random( num );
for( m = leader, i = 0; m != NULL; m = m->groupchain, i++ )
{
if ( i == j )
{
break;
}
}
return m;
}
//### 2015 added actor stuff
void Actor::GotoObjectEvent (Event *ev)
{
Event *e;
int i;
int n;
if (deadflag)
{
return;
}
e = new Event( EV_Behavior_Args );
e->SetSource( EV_FROM_SCRIPT );
e->SetThread( ev->GetThread() );
e->SetLineNumber( ev->GetLineNumber() );
e->AddEntity( this );
n = ev->NumArgs();
for( i = 1; i <= n; i++ )
{
e->AddToken( ev->GetToken( i ) );
}
SetBehavior(new GetCloseToObject, e, ev->GetThread());
}
//###
Reference in a new issue Copy permalink