2015/sin-2015
0
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity
sin-2015/mortician.cpp
archive 03d62e8675 as released 1999-04-22
1999-04-22 00:00:00 +00:00

595 lines
16 KiB
C++
Raw Permalink Blame History

/*
================================================================
MORTICIAN
================================================================
Copyright (C) 1998 by 2015, Inc.
All rights reserved.
This source is may not be distributed and/or modified without
expressly written permission by 2015, Inc.
*/
#include "g_local.h"
#include "actor.h"
#include "mortician.h"
#include "behavior.h"
#include "path.h"
#include "explosion.h"
CLASS_DECLARATION( Actor, Mortician, "monster_mortician" );
Event EV_Mortician_MJumpTo( "mjumpto" );
Event EV_Mortician_Flash( "doflash" );
ResponseDef Mortician::Responses[] =
{
{ &EV_Mortician_MJumpTo, ( Response )Mortician::JumpToEvent },
{ &EV_Mortician_Flash, ( Response )Mortician::FlashEvent },
{ NULL, NULL }
};
void Mortician::FlashEvent (Event *ev)
{
FlashPlayers(worldorigin, 1, 1, 1, 0.5, 300);
}
void Mortician::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( "mjump" );
for( i = 1; i <= n; i++ )
{
e->AddToken( ev->GetToken( i ) );
}
SetBehavior( new MJump, e, ev->GetThread() );
}
// This takes a target vector, and then sets
// the entity's horizontal and vertical velocity so that
// it will jump gracefully to its target, and returns
// the estimated travel time
// It is a copy of Actor::JumpTo, but I had to rewrite it because jumpTo
// spins the actor around to face its target, which is not something I
// want the mortician to do.
float Mortician::JumpTo (Vector targ)
{
float traveltime;
float vertical_speed;
float speed;
Vector target;
Vector dir;
Vector xydir;
CheckWater();
//
// if we got a jump, go into that mode
//
traveltime = 0;
target = targ;
dir = target - worldorigin;
xydir = dir;
xydir.z = 0;
speed = movespeed * 1.7 * gravity;
speed += (xydir.length()/ 2.5) * gravity;
//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;
}
Mortician::Mortician()
{
}
/****************************************************************************
MJump Class Definition
Based of jump behaviour, used for the mortician, so he can look better
when he jumps.
****************************************************************************/
CLASS_DECLARATION( Behavior, MJump, NULL );
ResponseDef MJump::Responses[] =
{
{ &EV_Behavior_Args, ( Response )MJump::SetArgs },
{ &EV_Behavior_AnimDone, ( Response )MJump::AnimDone },
{ NULL, NULL }
};
MJump::MJump()
{
endtime = 0;
state = 0;
animdone = true;
target = NULL;
jumpok = true;
heightneeded = 140;
heightwanted = 400;
jumpbegun = false;
}
void MJump::AnimDone (Event *ev)
{
animdone = true;
}
void MJump::SetArgs (Event *ev)
{
//
// see if it is an entity first
//
movegoal = AI_FindNode( ev->GetString( 2 ) );
if ( movegoal )
{
goal = movegoal->worldorigin;
}
else
{
Entity *ent;
ent = ev->GetEntity( 2 );
if ( ent )
{
goal = ent->worldorigin;
target = ent; //We need to set target seperate because goal may be changed soon
}
}
if ( ev->NumArgs() >= 3 )
accurate = ev->GetInteger( 3 );
else
accurate = false;
}
void MJump::ShowInfo (Actor &self)
{
Behavior::ShowInfo( self );
}
///////////////////////
// Find close sight node to
///////////////////////
// This function returns a pathnode which is near the target, visible from the target and from
// self's current position, and is as high or higher than the target (since that usually conveys
// a sense of tactical advantage). The node must also be more than a minimum distance from
// self's current position
Vector MJump::FindCloseSightNodeTo
(
Actor &self,
Vector pos,
float maxdist // This one is not squared yet!
)
{
int i;
PathNode *bestnode;
float bestdist;
PathNode *node;
Vector delta;
float dist;
trace_t trace1;
trace_t trace2;
Vector selfpos;
Vector temppos;
// How do I declare these as constants?
float maxjumpdist = 900*900; // Maximum distance he is capable of jumping (squared)
float minjumpdist = 150*150; // Absolute minimum distance he will jump
float jumpdist = 300*300; // Distance he likes to keep from his enemy
// reduce maxjumpdist if we need to
if ((maxdist*maxdist) < maxjumpdist)
maxjumpdist = maxdist*maxdist;
// Raise our endpoints up for a variety of reasons
selfpos = self.worldorigin;
selfpos.z += 100;
temppos = pos;
temppos.z += 100;
bestnode = NULL;
bestdist = 999999999; // greater than ( 8192 * sqr(2) ) ^ 2 -- maximum squared distance
delta = selfpos - temppos;
dist = delta * delta;
if (dist > jumpdist) // We are a long way away so jump jump near
{
for( i = rand()%4; i <= ai_maxnode; i+=4 ) //Check every fourth node since we don't want do be too accurate
{
node = AI_GetNode( i );
if ( node && ( node->occupiedTime <= level.time ) )
{
delta = node->worldorigin - self.worldorigin;
dist = delta * delta;
if (( node->worldorigin.z > (pos.z-20)) && ( dist > minjumpdist ) && (dist < maxjumpdist))
{
// get the distance squared (faster than getting real distance)
delta = node->worldorigin - pos;
dist = delta * delta;
trace1 = G_Trace(temppos, Vector(0, 0, 0), Vector(0, 0, 0), node->worldorigin, &self, MASK_SHOT, "MJump::FindCloseSightNodeTo");
trace2 = G_Trace(selfpos, Vector(0, 0, 0), Vector(0, 0, 0), node->worldorigin, &self, MASK_SHOT, "MJump::FindCloseSightNodeTo");
// Now if this one can be seen from both ends, is closest, and is also higher than the target, we want it.
if ((trace1.fraction >= 1) && (trace2.fraction >= 1) && (dist < bestdist) )
{
bestnode = node;
bestdist = dist;
}
}
}
}
}
else // We are close so try to jump over our enemy
{
for( i = rand()%4; i <= ai_maxnode; i+=4 ) //Check every fourth node since we don't want do be too accurate
{
node = AI_GetNode( i );
if ( node && ( node->occupiedTime <= level.time ) )
{
delta = node->worldorigin - self.worldorigin;
// get the distance squared (faster than getting real distance)
dist = delta * delta;
delta = node->worldorigin - pos;
jumpdist = delta * delta; // Jumpdist is now the distance from the test node to the target
if (( node->worldorigin.z > (pos.z-10)) && ( dist > minjumpdist ) && (dist > jumpdist) && (dist < maxjumpdist)) //This is the line that makes him try to jump over
{
dist = jumpdist;
trace1 = G_Trace(temppos, Vector(0, 0, 0), Vector(0, 0, 0), node->worldorigin, &self, MASK_SHOT, "MJump::FindCloseSightNodeTo");
trace2 = G_Trace(selfpos, Vector(0, 0, 0), Vector(0, 0, 0), node->worldorigin, &self, MASK_SHOT, "MJump::FindCloseSightNodeTo");
// Now if this one can be seen from both ends, is closest, and is also higher than the target, we want it.
if ((trace1.fraction >= 1) && (trace2.fraction >= 1) && (dist < bestdist))
{
bestnode = node;
bestdist = dist;
}
}
}
}
} //end else
// Oh, shit, we didn't find anywhere we can jump to, let's look harder this time
if ( bestnode == NULL )
{
for( i = 0; (i <= ai_maxnode && bestnode == NULL); i++ ) //Check every node this time since we're getting desperate
{
node = AI_GetNode( i );
// if we don't have a node value, carry on
if(!node)
{
continue;
}
delta = node->worldorigin - self.worldorigin; //Make sure it isn't too far away
dist = delta * delta;
if ( node && ( node->occupiedTime <= level.time ) && (dist > minjumpdist) && (dist < maxjumpdist) && (node->worldorigin.z > pos.z-500) )
{
// get the distance squared (faster than getting real distance)
delta = node->worldorigin - pos;
dist = delta * delta;
trace1 = G_Trace(temppos, Vector(0, 0, 0), Vector(0, 0, 0), node->worldorigin, &self, MASK_SHOT, "MJump::FindCloseSightNodeTo");
trace2 = G_Trace(selfpos, Vector(0, 0, 0), Vector(0, 0, 0), node->worldorigin, &self, MASK_SHOT, "MJump::FindCloseSightNodeTo");
if ((trace1.fraction >= 1) && (trace2.fraction >= 1) && (dist < bestdist))
{
bestnode = node;
bestdist = dist;
}
}
}
}
if ( bestnode == NULL ) // Revert back to original target if we didn't find anywhere near it
return pos;
else
return bestnode->worldorigin;
}
void MJump::Begin (Actor &self)
{
trace_t trace;
Vector upcheck;
float direction; //Used for testing of direction of movement relative to orientation
float maxjumpdistance = 1000; // Clips the max jump distance if we have a low ceiling
// This bit aborts the jump if the ceiling is too low, and culls it if it is a little too low
upcheck = self.worldorigin;
upcheck.z += heightneeded;
trace = G_Trace(self.worldorigin, Vector(-22, -22, 0), Vector(22, 22, 0), upcheck, &self, MASK_MONSTERSOLID, "MJumpTo::Begin");
if (trace.fraction >= 1)
{
state = 0; // I shouldn't have to do this here, but I tried it anyhow and it worked...
upcheck = self.worldorigin;
upcheck.z += heightwanted;
trace = G_Trace(self.worldorigin, Vector(-22, -22, 0), Vector(22, 22, 0), upcheck, &self, MASK_MONSTERSOLID, "MJumpTo::Begin");
if (trace.fraction < 1)
// In this piece, we assume that we can jump thrice as far as the roof is high,
// which is a reasonable (if not entirely accurate) assumption, I think.
maxjumpdistance = heightwanted * trace.fraction * 3;
if ( !accurate )
goal = FindCloseSightNodeTo ( self, goal, maxjumpdistance );
direction = Vector(self.orientation[0]).toYaw() - (goal-self.worldorigin).toYaw();
direction = fmod (direction, 360.0);
if (direction < 0)
direction += 360;
if (( direction >= 45 ) && ( direction < 135 ))
jumpdir = "right";
else if (( direction >= 135 ) && ( direction < 225 ))
jumpdir = "back";
else if (( direction >= 225 ) && ( direction < 315 ))
jumpdir = "left";
else
jumpdir = "forward";
anim = "jump_" + jumpdir;
if ( anim.length() )
{
animdone=false;
self.SetAnim( anim, EV_Actor_NotifyBehavior );
}
} //end if (ceiling is high enough)
else
{
jumpok = false;
}
}
qboolean MJump::Evaluate (Actor &self)
{
Vector landpos;
trace_t trace;
float direction; //Used for testing of direction of movement relative to orientation
Mortician *mself;
Vector targetdir;
// Do a quick check so we don't cause major problems if we accidentally pass
// a non-mortician to this function.
if (!self.isSubclassOf( Mortician ))
return false;
// Do a check to see if we have any ceiling height
if (!jumpok)
return false;
if(!target)
target = world;
// OK, now get on with it
mself = (Mortician *) (&self);
upspeed = (self.worldorigin.z - oldworldheight)/FRAMETIME;
switch( state )
{
case 0:
float traveltime;
if ( animdone )
{
animdone = false;
anim = "jump_" + jumpdir + "_inair";
self.SetAnim( anim, EV_Actor_NotifyBehavior );
// Use mself here instead of self so we call the correct jumping function
traveltime = mself->JumpTo( goal );
endtime = traveltime + level.time;
self.last_jump_time = endtime;
state = 1;
}
break;
case 1:
// Now, watch the player as we move upwards
if (animdone)
{
///////////////
// Turn to face the player
if ( target == NULL )
{
targetdir = (goal - self.worldorigin).toAngles();
targetdir.setPitch(0);
}
else
{
targetdir = (target->worldorigin - self.worldorigin).toAngles();
// Invert pitch since setAngles is screwy, and divide by 2
if (targetdir.pitch() > 180)
targetdir.setPitch(targetdir.pitch() - 360);
targetdir.setPitch(-targetdir.pitch()/2);
}
self.setAngles( targetdir );
/////////////////
// Check to see if we will be moving downwards next frame
if (upspeed <= 0)
{
state = 2;
}
else
{
// Take a shot from in the air
if ( ((endtime-level.time)>0.5) &&
animdone &&
self.currentEnemy &&
self.CanSee(self.currentEnemy)) // make sure can actually hit
{
animdone = false;
anim = "air_shoot";
self.SetAnim( anim, EV_Actor_NotifyBehavior );
}
else if (animdone)
{
self.SetAnim("air_idle");
}
}
}
break;
case 2:
//
// Moving downwards, waiting to hit the ground...
//
if (animdone)
self.SetAnim("air_idle");
///////////////
// Turn to face the player
if ( target == NULL )
{
targetdir = (goal - self.worldorigin).toAngles();
targetdir.setPitch(0);
}
else
{
targetdir = (target->worldorigin - self.worldorigin).toAngles();
// Invert pitch since setAngles is screwy, and divide by 2
if (targetdir.pitch() > 180)
targetdir.setPitch(targetdir.pitch() - 360);
targetdir.setPitch(-targetdir.pitch()/2);
}
self.setAngles( targetdir );
landpos = self.worldorigin + ( ((upspeed - self.gravity*sv_gravity->value)*Vector(0, 0, 1)) * FRAMETIME );
trace = G_Trace(self.worldorigin, Vector(-22, -22, 0), Vector(22, 22, 0), landpos, &self, MASK_MONSTERSOLID, "MJumpTo::Evaluate");
if ( (trace.fraction < 1) || ( self.groundentity ) )
{
state = 3;
// Make sure we're not tipped over any more
//
targetdir = (target->worldorigin - self.worldorigin).toAngles();
targetdir.setPitch(0);
self.setAngles( targetdir );
//
// Set landing animation depending on velocity relative to orientation
//
// We have to use toYaw here as opposed to yaw because
// this is a velocity vector rather than an angle vector
direction = Vector(self.orientation[0]).toYaw() - self.velocity.toYaw();
direction = fmod (direction, 360.0f);
if (direction < 0)
direction += 360;
temp_vel = self.velocity;
temp_vel.z = 0;
if ( (temp_vel.length()/(-upspeed) < 0.4 ) || (temp_vel.length() < 60) )
jumpdir = "down";
else if (( direction >= 45 ) && ( direction < 135 ))
jumpdir = "right";
else if (( direction >= 135 ) && ( direction < 225 ))
jumpdir = "back";
else if (( direction >= 225 ) && ( direction < 315 ))
jumpdir = "left";
else
jumpdir = "forward";
anim = "land_" + jumpdir;
//
// if we have an anim, we go to state 4
//
if ( self.HasAnim( anim.c_str() ) )
{
animdone = false;
self.SetAnim( anim, EV_Actor_NotifyBehavior );
state = 4;
}
else
{
self.SetAnim( "jump_idle", EV_Actor_NotifyBehavior );
state = 3;
}
}
// Record downward velocity for comparison with horizontal velocity
// later, to determine which landing animation should be played.
break;
case 3:
//
// we are on the ground and waiting to timeout
//
if ( (level.time > endtime) && (self.groundentity) )
return false;
break;
case 4:
//
// we are on the ground and waiting for our landing animation to finish
//
if (animdone)
{
if (self.groundentity)
return false;
else
self.SetAnim( "idle" );
}
break;
}
//Save off origin for velocity calcs
oldworldheight = self.worldorigin.z;
return true;
}
void MJump::End (Actor &self)
{
Vector targetdir = (target->worldorigin - self.worldorigin).toAngles();
targetdir.setPitch(0);
self.setAngles( targetdir );
self.SetAnim( "idle" );
}
Reference in a new issue View git blame Copy permalink