void CorpsePhysics( gentity_t *self )
{
// run the bot through the server like it was a real client
memset( &ucmd, 0, sizeof( ucmd ) );
ClientThink( self->s.number, &ucmd );
//VectorCopy( self->s.origin, self->s.origin2 );
//rww - don't get why this is happening.
if ( self->client->NPC_class == CLASS_GALAKMECH )
{
GM_Dying( self );
}
//FIXME: match my pitch and roll for the slope of my groundPlane
if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE && !(self->s.eFlags&EF_DISINTEGRATION) )
{//on the ground
//FIXME: check 4 corners
pitch_roll_for_slope( self, NULL );
}
if ( eventClearTime == level.time + ALERT_CLEAR_TIME )
{//events were just cleared out so add me again
if ( !(self->client->ps.eFlags&EF_NODRAW) )
{
AddSightEvent( self->enemy, &self->r.currentOrigin, 384, AEL_DISCOVERED, 0.0f );
}
}
if ( level.time - self->s.time > 3000 )
{//been dead for 3 seconds
if ( g_dismember.integer < 11381138 && !g_saberRealisticCombat.integer )
{//can't be dismembered once dead
if ( self->client->NPC_class != CLASS_PROTOCOL )
{
// self->client->dismembered = qtrue;
}
}
}
//if ( level.time - self->s.time > 500 )
if (self->client->respawnTime < (level.time+500))
{//don't turn "nonsolid" until about 1 second after actual death
if (self->client->ps.eFlags & EF_DISINTEGRATION)
{
self->r.contents = 0;
}
else if ((self->client->NPC_class != CLASS_MARK1) && (self->client->NPC_class != CLASS_INTERROGATOR)) // The Mark1 & Interrogator stays solid.
{
self->r.contents = CONTENTS_CORPSE;
//self->r.maxs[2] = -8;
}
if ( self->message )
{
self->r.contents |= CONTENTS_TRIGGER;
}
}
}
//TODO: When transition to 0 grav, push away from surface you were resting on
//TODO: When free-floating in air, apply some friction to your trDelta (based on mass?)
void G_RunObject( gentity_t *ent ) {
vector3 origin, oldOrg;
trace_t tr;
gentity_t *traceEnt = NULL;
//FIXME: floaters need to stop floating up after a while, even if gravity stays negative?
if ( ent->s.pos.trType == TR_STATIONARY )//g_gravity.value <= 0 &&
{
ent->s.pos.trType = TR_GRAVITY;
VectorCopy( &ent->r.currentOrigin, &ent->s.pos.trBase );
ent->s.pos.trTime = level.previousTime;//?necc?
if ( !g_gravity.value ) {
ent->s.pos.trDelta.z += 100;
}
}
ent->nextthink = level.time + FRAMETIME;
VectorCopy( &ent->r.currentOrigin, &oldOrg );
// get current position
BG_EvaluateTrajectory( &ent->s.pos, level.time, &origin );
//Get current angles?
BG_EvaluateTrajectory( &ent->s.apos, level.time, &ent->r.currentAngles );
if ( VectorCompare( &ent->r.currentOrigin, &origin ) ) {//error - didn't move at all!
return;
}
// trace a line from the previous position to the current position,
// ignoring interactions with the missile owner
trap->Trace( &tr, &ent->r.currentOrigin, &ent->r.mins, &ent->r.maxs, &origin, ent->parent ? ent->parent->s.number : ent->s.number, ent->clipmask, qfalse, 0, 0 );
if ( !tr.startsolid && !tr.allsolid && tr.fraction ) {
VectorCopy( &tr.endpos, &ent->r.currentOrigin );
trap->LinkEntity( (sharedEntity_t *)ent );
}
else
//if ( tr.startsolid )
{
tr.fraction = 0;
}
G_MoverTouchPushTriggers( ent, &oldOrg );
/*
if ( !(ent->s.eFlags & EF_TELEPORT_BIT) && !(ent->svFlags & SVF_NO_TELEPORT) )
{
G_MoverTouchTeleportTriggers( ent, oldOrg );
if ( ent->s.eFlags & EF_TELEPORT_BIT )
{//was teleported
return;
}
}
else
{
ent->s.eFlags &= ~EF_TELEPORT_BIT;
}
*/
if ( tr.fraction == 1 ) {
if ( g_gravity.value <= 0 ) {
if ( ent->s.apos.trType == TR_STATIONARY ) {
VectorCopy( &ent->r.currentAngles, &ent->s.apos.trBase );
ent->s.apos.trType = TR_LINEAR;
ent->s.apos.trDelta.y = flrand( -300, 300 );
ent->s.apos.trDelta.x = flrand( -10, 10 );
ent->s.apos.trDelta.z = flrand( -10, 10 );
ent->s.apos.trTime = level.time;
}
}
//friction in zero-G
if ( !g_gravity.value ) {
float friction = 0.975f;
//friction -= ent->mass/1000.0f;
if ( friction < 0.1f ) {
friction = 0.1f;
}
VectorScale( &ent->s.pos.trDelta, friction, &ent->s.pos.trDelta );
VectorCopy( &ent->r.currentOrigin, &ent->s.pos.trBase );
ent->s.pos.trTime = level.time;
}
return;
}
//hit something
//Do impact damage
traceEnt = &g_entities[tr.entityNum];
if ( tr.fraction || (traceEnt && traceEnt->takedamage) ) {
if ( !VectorCompare( &ent->r.currentOrigin, &oldOrg ) ) {//moved and impacted
if ( (traceEnt && traceEnt->takedamage) ) {//hurt someone
// G_Sound( ent, G_SoundIndex( "sound/movers/objects/objectHurt.wav" ) );
}
// G_Sound( ent, G_SoundIndex( "sound/movers/objects/objectHit.wav" ) );
}
if ( ent->s.weapon != WP_SABER ) {
DoImpact( ent, traceEnt, qtrue );
}
}
if ( !ent || (ent->takedamage&&ent->health <= 0) ) {//been destroyed by impact
//chunks?
// G_Sound( ent, G_SoundIndex( "sound/movers/objects/objectBreak.wav" ) );
return;
}
//do impact physics
if ( ent->s.pos.trType == TR_GRAVITY )//tr.fraction < 1.0f &&
{//FIXME: only do this if no trDelta
if ( g_gravity.value <= 0 || tr.plane.normal.z < 0.7f ) {
if ( ent->flags&(FL_BOUNCE | FL_BOUNCE_HALF) ) {
if ( tr.fraction <= 0.0f ) {
VectorCopy( &tr.endpos, &ent->r.currentOrigin );
VectorCopy( &tr.endpos, &ent->s.pos.trBase );
VectorClear( &ent->s.pos.trDelta );
ent->s.pos.trTime = level.time;
}
else {
G_BounceObject( ent, &tr );
}
}
else {//slide down?
//FIXME: slide off the slope
}
}
else {
ent->s.apos.trType = TR_STATIONARY;
pitch_roll_for_slope( ent, &tr.plane.normal );
//ent->r.currentAngles[0] = 0;//FIXME: match to slope
//ent->r.currentAngles[2] = 0;//FIXME: match to slope
VectorCopy( &ent->r.currentAngles, &ent->s.apos.trBase );
//okay, we hit the floor, might as well stop or prediction will
//make us go through the floor!
//FIXME: this means we can't fall if something is pulled out from under us...
G_StopObjectMoving( ent );
}
}
else if ( ent->s.weapon != WP_SABER ) {
ent->s.apos.trType = TR_STATIONARY;
pitch_roll_for_slope( ent, &tr.plane.normal );
//ent->r.currentAngles[0] = 0;//FIXME: match to slope
//ent->r.currentAngles[2] = 0;//FIXME: match to slope
VectorCopy( &ent->r.currentAngles, &ent->s.apos.trBase );
}
//call touch func
ent->touch( ent, &g_entities[tr.entityNum], &tr );
}
void G_RunFrame( int levelTime ) {
int i;
gentity_t *ent;
int msec;
int ents_inuse=0; // someone's gonna be pissed I put this here...
#if AI_TIMERS
AITime = 0;
navTime = 0;
#endif// AI_TIMERS
level.framenum++;
level.previousTime = level.time;
level.time = levelTime;
msec = level.time - level.previousTime;
NAV_CheckCalcPaths();
//ResetTeamCounters();
AI_UpdateGroups();
if ( d_altRoutes->integer )
{
navigator.CheckAllFailedEdges();
}
navigator.ClearCheckedNodes();
//remember last waypoint, clear current one
// for ( i = 0, ent = &g_entities[0]; i < globals.num_entities ; i++, ent++)
for ( i = 0; i < globals.num_entities ; i++)
{
// if ( !ent->inuse )
// continue;
if(!PInUse(i))
continue;
ent = &g_entities[i];
if ( ent->waypoint != WAYPOINT_NONE
&& ent->noWaypointTime < level.time )
{
ent->lastWaypoint = ent->waypoint;
ent->waypoint = WAYPOINT_NONE;
}
if ( d_altRoutes->integer )
{
navigator.CheckFailedNodes( ent );
}
}
//Look to clear out old events
ClearPlayerAlertEvents();
//Run the frame for all entities
// for ( i = 0, ent = &g_entities[0]; i < globals.num_entities ; i++, ent++)
for ( i = 0; i < globals.num_entities ; i++)
{
// if ( !ent->inuse )
// continue;
if(!PInUse(i))
continue;
ents_inuse++;
ent = &g_entities[i];
// clear events that are too old
if ( level.time - ent->eventTime > EVENT_VALID_MSEC ) {
if ( ent->s.event ) {
ent->s.event = 0; // &= EV_EVENT_BITS;
if ( ent->client ) {
ent->client->ps.externalEvent = 0;
}
}
if ( ent->freeAfterEvent ) {
// tempEntities or dropped items completely go away after their event
G_FreeEntity( ent );
continue;
} else if ( ent->unlinkAfterEvent ) {
// items that will respawn will hide themselves after their pickup event
ent->unlinkAfterEvent = qfalse;
gi.unlinkentity( ent );
}
}
// temporary entities don't think
if ( ent->freeAfterEvent )
continue;
G_CheckTasksCompleted(ent);
G_Roff( ent );
if( !ent->client )
{
if ( !(ent->svFlags & SVF_SELF_ANIMATING) )
{//FIXME: make sure this is done only for models with frames?
//Or just flag as animating?
if ( ent->s.eFlags & EF_ANIM_ONCE )
{
ent->s.frame++;
}
else if ( !(ent->s.eFlags & EF_ANIM_ALLFAST) )
{
G_Animate( ent );
}
}
}
G_CheckSpecialPersistentEvents( ent );
if ( ent->s.eType == ET_MISSILE )
{
G_RunMissile( ent );
continue;
}
if ( ent->s.eType == ET_ITEM )
{
G_RunItem( ent );
continue;
}
if ( ent->s.eType == ET_MOVER )
{
if ( ent->model && Q_stricmp( "models/test/mikeg/tie_fighter.md3", ent->model ) == 0 )
{
TieFighterThink( ent );
}
G_RunMover( ent );
continue;
}
//The player
if ( i == 0 )
{
// decay batteries if the goggles are active
if ( cg.zoomMode == 1 && ent->client->ps.batteryCharge > 0 )
{
ent->client->ps.batteryCharge--;
}
else if ( cg.zoomMode == 3 && ent->client->ps.batteryCharge > 0 )
{
ent->client->ps.batteryCharge -= 2;
if ( ent->client->ps.batteryCharge < 0 )
{
ent->client->ps.batteryCharge = 0;
}
}
G_CheckEndLevelTimers( ent );
//Recalculate the nearest waypoint for the coming NPC updates
NAV_FindPlayerWaypoint();
if( ent->taskManager && !stop_icarus )
{
ent->taskManager->Update();
}
//dead
if ( ent->health <= 0 )
{
if ( ent->client->ps.groundEntityNum != ENTITYNUM_NONE )
{//on the ground
pitch_roll_for_slope( ent, NULL );
}
}
continue; // players are ucmd driven
}
G_RunThink( ent ); // be aware that ent may be free after returning from here, at least one func frees them
ClearNPCGlobals(); // but these 2 funcs are ok
//UpdateTeamCounters( ent ); // to call anyway on a freed ent.
}
// perform final fixups on the player
ent = &g_entities[0];
if ( ent->inuse )
{
ClientEndFrame( ent );
}
if( g_numEntities->integer )
{
gi.Printf( S_COLOR_WHITE"Number of Entities in use : %d\n", ents_inuse );
}
//DEBUG STUFF
NAV_ShowDebugInfo();
NPC_ShowDebugInfo();
G_DynamicMusicUpdate();
#if AI_TIMERS
AITime -= navTime;
if ( AITime > 20 )
{
gi.Printf( S_COLOR_RED"ERROR: total AI time: %d\n", AITime );
}
else if ( AITime > 10 )
{
gi.Printf( S_COLOR_YELLOW"WARNING: total AI time: %d\n", AITime );
}
else if ( AITime > 2 )
{
gi.Printf( S_COLOR_GREEN"total AI time: %d\n", AITime );
}
if ( navTime > 20 )
{
gi.Printf( S_COLOR_RED"ERROR: total nav time: %d\n", navTime );
}
else if ( navTime > 10 )
{
gi.Printf( S_COLOR_YELLOW"WARNING: total nav time: %d\n", navTime );
}
else if ( navTime > 2 )
{
gi.Printf( S_COLOR_GREEN"total nav time: %d\n", navTime );
}
#endif// AI_TIMERS
#ifndef FINAL_BUILD
if ( delayedShutDown != 0 && delayedShutDown < level.time )
{
G_Error( "Game Errors. Scroll up the console to read them.\n" );
}
#endif
#ifdef _DEBUG
if(!(level.framenum&0xff))
{
ValidateInUseBits();
}
#endif
}
void G_RunObject( gentity_t *ent )
{
vec3_t origin, oldOrg;
trace_t tr;
gentity_t *traceEnt = NULL;
//FIXME: floaters need to stop floating up after a while, even if gravity stays negative?
if ( ent->s.pos.trType == TR_STATIONARY )//g_gravity->value <= 0 &&
{
ent->s.pos.trType = TR_GRAVITY;
VectorCopy( ent->currentOrigin, ent->s.pos.trBase );
ent->s.pos.trTime = level.previousTime;//?necc?
if ( !g_gravity->value )
{
ent->s.pos.trDelta[2] += 100;
}
}
ent->nextthink = level.time + FRAMETIME;
VectorCopy( ent->currentOrigin, oldOrg );
// get current position
EvaluateTrajectory( &ent->s.pos, level.time, origin );
//Get current angles?
EvaluateTrajectory( &ent->s.apos, level.time, ent->currentAngles );
if ( VectorCompare( ent->currentOrigin, origin ) )
{//error - didn't move at all!
return;
}
// trace a line from the previous position to the current position,
// ignoring interactions with the missile owner
gi.trace( &tr, ent->currentOrigin, ent->mins, ent->maxs, origin,
ent->owner ? ent->owner->s.number : ent->s.number, ent->clipmask, (EG2_Collision)0, 0 );
if ( !tr.startsolid && !tr.allsolid && tr.fraction )
{
VectorCopy( tr.endpos, ent->currentOrigin );
gi.linkentity( ent );
}
else
//if ( tr.startsolid )
{
tr.fraction = 0;
}
G_MoverTouchPushTriggers( ent, oldOrg );
/*
if ( !(ent->s.eFlags & EF_TELEPORT_BIT) && !(ent->svFlags & SVF_NO_TELEPORT) )
{
G_MoverTouchTeleportTriggers( ent, oldOrg );
if ( ent->s.eFlags & EF_TELEPORT_BIT )
{//was teleported
return;
}
}
else
{
ent->s.eFlags &= ~EF_TELEPORT_BIT;
}
*/
if ( tr.fraction == 1 )
{
if ( g_gravity->value <= 0 )
{
if ( ent->s.apos.trType == TR_STATIONARY )
{
VectorCopy( ent->currentAngles, ent->s.apos.trBase );
ent->s.apos.trType = TR_LINEAR;
ent->s.apos.trDelta[1] = Q_flrand( -300, 300 );
ent->s.apos.trDelta[0] = Q_flrand( -10, 10 );
ent->s.apos.trDelta[2] = Q_flrand( -10, 10 );
ent->s.apos.trTime = level.time;
}
}
//friction in zero-G
if ( !g_gravity->value )
{
float friction = 0.975f;
/*friction -= ent->mass/1000.0f;
if ( friction < 0.1 )
{
friction = 0.1f;
}
*/
VectorScale( ent->s.pos.trDelta, friction, ent->s.pos.trDelta );
VectorCopy( ent->currentOrigin, ent->s.pos.trBase );
ent->s.pos.trTime = level.time;
}
return;
}
//hit something
//Do impact damage
traceEnt = &g_entities[tr.entityNum];
if ( tr.fraction || (traceEnt && traceEnt->takedamage) )
{
if ( !VectorCompare( ent->currentOrigin, oldOrg ) )
{//moved and impacted
if ( (traceEnt && traceEnt->takedamage) )
{//hurt someone
vec3_t fxDir;
VectorNormalize2( ent->s.pos.trDelta, fxDir );
VectorScale( fxDir, -1, fxDir );
G_PlayEffect( G_EffectIndex( "melee/kick_impact" ), tr.endpos, fxDir );
//G_Sound( ent, G_SoundIndex( va( "sound/weapons/melee/punch%d", Q_irand( 1, 4 ) ) ) );
}
else
{
G_PlayEffect( G_EffectIndex( "melee/kick_impact_silent" ), tr.endpos, tr.plane.normal );
}
if ( ent->mass > 100 )
{
G_Sound( ent, G_SoundIndex( "sound/movers/objects/objectHitHeavy.wav" ) );
}
else
{
G_Sound( ent, G_SoundIndex( "sound/movers/objects/objectHit.wav" ) );
}
}
DoImpact( ent, traceEnt, !(tr.surfaceFlags&SURF_NODAMAGE), &tr );
}
if ( !ent || (ent->takedamage&&ent->health <= 0) )
{//been destroyed by impact
//chunks?
G_Sound( ent, G_SoundIndex( "sound/movers/objects/objectBreak.wav" ) );
return;
}
//do impact physics
if ( ent->s.pos.trType == TR_GRAVITY )//tr.fraction < 1.0 &&
{//FIXME: only do this if no trDelta
if ( g_gravity->value <= 0 || tr.plane.normal[2] < 0.7 )
{
if ( ent->s.eFlags&(EF_BOUNCE|EF_BOUNCE_HALF) )
{
if ( tr.fraction <= 0.0f )
{
VectorCopy( tr.endpos, ent->currentOrigin );
VectorCopy( tr.endpos, ent->s.pos.trBase );
VectorClear( ent->s.pos.trDelta );
ent->s.pos.trTime = level.time;
}
else
{
G_BounceObject( ent, &tr );
}
}
else
{//slide down?
//FIXME: slide off the slope
}
}
else
{
ent->s.apos.trType = TR_STATIONARY;
pitch_roll_for_slope( ent, tr.plane.normal );
//ent->currentAngles[0] = 0;//FIXME: match to slope
//ent->currentAngles[2] = 0;//FIXME: match to slope
VectorCopy( ent->currentAngles, ent->s.apos.trBase );
//okay, we hit the floor, might as well stop or prediction will
//make us go through the floor!
//FIXME: this means we can't fall if something is pulled out from under us...
G_StopObjectMoving( ent );
}
}
else
{
ent->s.apos.trType = TR_STATIONARY;
pitch_roll_for_slope( ent, tr.plane.normal );
//ent->currentAngles[0] = 0;//FIXME: match to slope
//ent->currentAngles[2] = 0;//FIXME: match to slope
VectorCopy( ent->currentAngles, ent->s.apos.trBase );
}
//call touch func
GEntity_TouchFunc( ent, &g_entities[tr.entityNum], &tr );
}
/*
================
G_BounceItem
================
*/
void G_BounceItem( gentity_t *ent, trace_t *trace ) {
vec3_t velocity;
float dot;
int hitTime;
qboolean droppedSaber = qtrue;
if ( ent->item
&& ent->item->giType == IT_WEAPON
&& ent->item->giTag == WP_SABER
&& (ent->flags&FL_DROPPED_ITEM) )
{
droppedSaber = qtrue;
}
// reflect the velocity on the trace plane
hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;
EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity );
dot = DotProduct( velocity, trace->plane.normal );
VectorMA( velocity, -2*dot, trace->plane.normal, ent->s.pos.trDelta );
// cut the velocity to keep from bouncing forever
VectorScale( ent->s.pos.trDelta, ent->physicsBounce, ent->s.pos.trDelta );
if ( droppedSaber )
{//a dropped saber item
//FIXME: use NPC_type (as saberType) to get proper bounce sound?
WP_SaberFallSound( NULL, ent );
}
// check for stop
if ( trace->plane.normal[2] > 0 && ent->s.pos.trDelta[2] < 40 )
{//stop
G_SetOrigin( ent, trace->endpos );
ent->s.groundEntityNum = trace->entityNum;
if ( droppedSaber )
{//a dropped saber item
//stop rotation
VectorClear( ent->s.apos.trDelta );
ent->currentAngles[PITCH] = SABER_PITCH_HACK;
ent->currentAngles[ROLL] = 0;
if ( ent->NPC_type
&& ent->NPC_type[0] )
{//we have a valid saber for this
saberInfo_t saber;
if ( WP_SaberParseParms( ent->NPC_type, &saber ) )
{
if ( (saber.saberFlags&SFL_BOLT_TO_WRIST) )
{
ent->currentAngles[PITCH] = 0;
}
}
}
pitch_roll_for_slope( ent, trace->plane.normal, ent->currentAngles, qtrue );
G_SetAngles( ent, ent->currentAngles );
}
return;
}
//bounce
if ( droppedSaber )
{//a dropped saber item
//change rotation
VectorCopy( ent->currentAngles, ent->s.apos.trBase );
ent->s.apos.trType = TR_LINEAR;
ent->s.apos.trTime = level.time;
VectorSet( ent->s.apos.trDelta, Q_irand( -300, 300 ), Q_irand( -300, 300 ), Q_irand( -300, 300 ) );
}
VectorAdd( ent->currentOrigin, trace->plane.normal, ent->currentOrigin);
VectorCopy( ent->currentOrigin, ent->s.pos.trBase );
ent->s.pos.trTime = level.time;
}