codemp/game/g_object.c File Reference

#include "g_local.h"

Go to the source code of this file.

Functions
void	G_MoverTouchPushTriggers (gentity_t *ent, vec3_t oldOrg)
void	G_StopObjectMoving (gentity_t *object)
void	pitch_roll_for_slope (gentity_t *forwhom, vec3_t pass_slope)
void	G_BounceObject (gentity_t *ent, trace_t *trace)
void	DoImpact (gentity_t *self, gentity_t *other, qboolean damageSelf)
void	G_RunObject (gentity_t *ent)
void	G_StartObjectMoving (gentity_t *object, vec3_t dir, float speed, trType_t trType)

---

Function Documentation

void DoImpact (  gentity_t *  self, gentity_t *  other, qboolean  damageSelf )

10; Definition at line 213 of file g_active.c. References entityShared_t::absmax, gentity_s::client, CONTENTS_WATER, entityShared_t::currentOrigin, DAMAGE_NO_ARMOR, DotProduct, ENTITYNUM_NONE, ENTITYNUM_WORLD, playerState_s::fd, FL_BBRUSH, gentity_s::flags, forcedata_s::forceJumpZStart, G_ApplyKnockback(), G_Damage(), g_gravity, gentity_t, playerState_s::groundEntityNum, gentity_s::health, playerState_s::lastOnGround, level, gentity_s::mass, MAT_GLASS, MAT_GLASS_METAL, MAT_GRATE1, gentity_s::material, entityShared_t::maxs, entityShared_t::mins, MOD_CRUSH, MOD_FALLING, NULL, entityState_s::number, entityState_s::pos, gclient_s::ps, qboolean, qtrue, gentity_s::r, gentity_s::s, gentity_s::spawnflags, gentity_s::splashRadius, SVF_GLASS_BRUSH, entityShared_t::svFlags, gentity_s::takedamage, level_locals_t::time, TR_GRAVITY, trap_PointContents(), trajectory_t::trDelta, trajectory_t::trType, vmCvar_t::value, vec3_origin, vec3_t, VectorCopy, VectorNormalize(), VectorSubtract, playerState_s::velocity, entityState_s::weapon, and WP_SABER. Referenced by Client_CheckImpactBBrush(), and G_RunObject(). { float magnitude, my_mass; vec3_t velocity; int cont; qboolean easyBreakBrush = qtrue; if( self->client ) { VectorCopy( self->client->ps.velocity, velocity ); if( !self->mass ) { my_mass = 10; } else { my_mass = self->mass; } } else { VectorCopy( self->s.pos.trDelta, velocity ); if ( self->s.pos.trType == TR_GRAVITY ) { velocity[2] -= 0.25f * g_gravity.value; } if( !self->mass ) { my_mass = 1; } else if ( self->mass <= 10 ) { my_mass = 10; } else { my_mass = self->mass; } } magnitude = VectorLength( velocity ) * my_mass / 10; /* if(pointcontents(self.absmax)==CONTENT_WATER)//FIXME: or other watertypes magnitude/=3; //water absorbs 2/3 velocity if(self.classname=="barrel"&&self.aflag)//rolling barrels are made for impacts! magnitude*=3; if(self.frozen>0&&magnitude<300&&self.flags&FL_ONGROUND&&loser==world&&self.velocity_z<-20&&self.last_onground+0.3<time) magnitude=300; */ if ( other->material == MAT_GLASS || other->material == MAT_GLASS_METAL || other->material == MAT_GRATE1 || ((other->flags&FL_BBRUSH)&&(other->spawnflags&8/*THIN*/)) || (other->r.svFlags&SVF_GLASS_BRUSH) ) { easyBreakBrush = qtrue; } if ( !self->client || self->client->ps.lastOnGround+300<level.time || ( self->client->ps.lastOnGround+100 < level.time && easyBreakBrush ) ) { vec3_t dir1, dir2; float force = 0, dot; if ( easyBreakBrush ) magnitude *= 2; //damage them if ( magnitude >= 100 && other->s.number < ENTITYNUM_WORLD ) { VectorCopy( velocity, dir1 ); VectorNormalize( dir1 ); if( VectorCompare( other->r.currentOrigin, vec3_origin ) ) {//a brush with no origin VectorCopy ( dir1, dir2 ); } else { VectorSubtract( other->r.currentOrigin, self->r.currentOrigin, dir2 ); VectorNormalize( dir2 ); } dot = DotProduct( dir1, dir2 ); if ( dot >= 0.2 ) { force = dot; } else { force = 0; } force *= (magnitude/50); cont = trap_PointContents( other->r.absmax, other->s.number ); if( (cont&CONTENTS_WATER) )//|| (self.classname=="barrel"&&self.aflag))//FIXME: or other watertypes { force /= 3; //water absorbs 2/3 velocity } /* if(self.frozen>0&&force>10) force=10; */ if( ( force >= 1 && other->s.number != 0 ) || force >= 10) { /* dprint("Damage other ("); dprint(loser.classname); dprint("): "); dprint(ftos(force)); dprint("\n"); */ if ( other->r.svFlags & SVF_GLASS_BRUSH ) { other->splashRadius = (float)(self->r.maxs[0] - self->r.mins[0])/4.0f; } if ( other->takedamage ) { G_Damage( other, self, self, velocity, self->r.currentOrigin, force, DAMAGE_NO_ARMOR, MOD_CRUSH);//FIXME: MOD_IMPACT } else { G_ApplyKnockback( other, dir2, force ); } } } if ( damageSelf && self->takedamage ) { //Now damage me //FIXME: more lenient falling damage, especially for when driving a vehicle if ( self->client && self->client->ps.fd.forceJumpZStart ) {//we were force-jumping if ( self->r.currentOrigin[2] >= self->client->ps.fd.forceJumpZStart ) {//we landed at same height or higher than we landed magnitude = 0; } else {//FIXME: take off some of it, at least? magnitude = (self->client->ps.fd.forceJumpZStart-self->r.currentOrigin[2])/3; } } //if(self.classname!="monster_mezzoman"&&self.netname!="spider")//Cats always land on their feet if( ( magnitude >= 100 + self->health && self->s.number != 0 && self->s.weapon != WP_SABER ) || ( magnitude >= 700 ) )//&& self.safe_time < level.time ))//health here is used to simulate structural integrity { if ( (self->s.weapon == WP_SABER || self->s.number == 0) && self->client && self->client->ps.groundEntityNum < ENTITYNUM_NONE && magnitude < 1000 ) {//players and jedi take less impact damage //allow for some lenience on high falls magnitude /= 2; /* if ( self.absorb_time >= time )//crouching on impact absorbs 1/2 the damage { magnitude/=2; } */ } magnitude /= 40; magnitude = magnitude - force/2;//If damage other, subtract half of that damage off of own injury if ( magnitude >= 1 ) { //FIXME: Put in a thingtype impact sound function /* dprint("Damage self ("); dprint(self.classname); dprint("): "); dprint(ftos(magnitude)); dprint("\n"); */ /* if ( self.classname=="player_sheep "&& self.flags&FL_ONGROUND && self.velocity_z > -50 ) return; */ G_Damage( self, NULL, NULL, NULL, self->r.currentOrigin, magnitude/2, DAMAGE_NO_ARMOR, MOD_FALLING );//FIXME: MOD_IMPACT } } } //FIXME: slow my velocity some? // NOTENOTE We don't use lastimpact as of yet // self->lastImpact = level.time; /* if(self.flags&FL_ONGROUND) self.last_onground=time; */ } }

void G_BounceObject (  gentity_t *  ent, trace_t *  trace )

Definition at line 14 of file g_object.c. References entityState_s::apos, BG_EvaluateTrajectoryDelta(), entityShared_t::currentAngles, entityShared_t::currentOrigin, DotProduct, trace_t::endpos, FL_BOUNCE_HALF, gentity_s::flags, trace_t::fraction, g_gravity, gentity_t, level, cplane_s::normal, trace_t::plane, entityState_s::pos, gentity_s::pos1, level_locals_t::previousTime, gentity_s::r, gentity_s::s, level_locals_t::time, TR_STATIONARY, trajectory_t::trBase, trajectory_t::trDelta, trajectory_t::trTime, trajectory_t::trType, vmCvar_t::value, vec3_t, VectorCopy, VectorMA, and VectorScale. Referenced by G_RunObject(). { vec3_t velocity; float dot, bounceFactor; int hitTime; // reflect the velocity on the trace plane hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction; BG_EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity ); dot = DotProduct( velocity, trace->plane.normal ); // bounceFactor = 60/ent->mass; // NOTENOTE Mass is not yet implemented bounceFactor = 1.0f; if ( bounceFactor > 1.0f ) { bounceFactor = 1.0f; } VectorMA( velocity, -2*dot*bounceFactor, trace->plane.normal, ent->s.pos.trDelta ); //FIXME: customized or material-based impact/bounce sounds if ( ent->flags & FL_BOUNCE_HALF ) { VectorScale( ent->s.pos.trDelta, 0.5, ent->s.pos.trDelta ); // check for stop if ( ((trace->plane.normal[2] > 0.7&&g_gravity.value>0) || (trace->plane.normal[2]<-0.7&&g_gravity.value<0)) && ((ent->s.pos.trDelta[2]<40&&g_gravity.value>0)||(ent->s.pos.trDelta[2]>-40&&g_gravity.value<0)) ) //this can happen even on very slightly sloped walls, so changed it from > 0 to > 0.7 { //G_SetOrigin( ent, trace->endpos ); //ent->nextthink = level.time + 500; ent->s.apos.trType = TR_STATIONARY; VectorCopy( ent->r.currentAngles, ent->s.apos.trBase ); VectorCopy( trace->endpos, ent->r.currentOrigin ); VectorCopy( trace->endpos, ent->s.pos.trBase ); ent->s.pos.trTime = level.time; return; } } // NEW--It would seem that we want to set our trBase to the trace endpos // and set the trTime to the actual time of impact.... // FIXME: Should we still consider adding the normal though?? VectorCopy( trace->endpos, ent->r.currentOrigin ); ent->s.pos.trTime = hitTime; VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase ); VectorCopy( trace->plane.normal, ent->pos1 );//??? }

void G_MoverTouchPushTriggers (  gentity_t *  ent, vec3_t  oldOrg )

Definition at line 601 of file g_active.c. References entityShared_t::contents, CONTENTS_TRIGGER, entityShared_t::currentOrigin, ET_PUSH_TRIGGER, entityState_s::eType, g_entities, gentity_t, MAX_GENTITIES, entityShared_t::maxs, memset(), entityShared_t::mins, NULL, entityState_s::pos, gentity_s::r, gentity_s::s, gentity_s::touch, trap_EntitiesInBox(), trap_EntityContact(), trajectory_t::trDelta, vec3_t, VectorAdd, VectorMA, VectorNormalize(), and VectorSubtract. Referenced by G_RunObject(). { int i, num; float step, stepSize, dist; int touch[MAX_GENTITIES]; gentity_t *hit; trace_t trace; vec3_t mins, maxs, dir, size, checkSpot; const vec3_t range = { 40, 40, 52 }; // non-moving movers don't hit triggers! if ( !VectorLengthSquared( ent->s.pos.trDelta ) ) { return; } VectorSubtract( ent->r.mins, ent->r.maxs, size ); stepSize = VectorLength( size ); if ( stepSize < 1 ) { stepSize = 1; } VectorSubtract( ent->r.currentOrigin, oldOrg, dir ); dist = VectorNormalize( dir ); for ( step = 0; step <= dist; step += stepSize ) { VectorMA( ent->r.currentOrigin, step, dir, checkSpot ); VectorSubtract( checkSpot, range, mins ); VectorAdd( checkSpot, range, maxs ); num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES ); // can't use ent->r.absmin, because that has a one unit pad VectorAdd( checkSpot, ent->r.mins, mins ); VectorAdd( checkSpot, ent->r.maxs, maxs ); for ( i=0 ; i<num ; i++ ) { hit = &g_entities[touch[i]]; if ( hit->s.eType != ET_PUSH_TRIGGER ) { continue; } if ( hit->touch == NULL ) { continue; } if ( !( hit->r.contents & CONTENTS_TRIGGER ) ) { continue; } if ( !trap_EntityContact( mins, maxs, hit ) ) { continue; } memset( &trace, 0, sizeof(trace) ); if ( hit->touch != NULL ) { hit->touch(hit, ent, &trace); } } } }

void G_RunObject (  gentity_t *  ent  )

Definition at line 72 of file g_object.c. References trace_t::allsolid, entityState_s::apos, BG_EvaluateTrajectory(), gentity_s::clipmask, entityShared_t::currentAngles, entityShared_t::currentOrigin, DoImpact(), trace_t::endpos, trace_t::entityNum, FL_BOUNCE, FL_BOUNCE_HALF, gentity_s::flags, flrand(), trace_t::fraction, FRAMETIME, G_BounceObject(), g_entities, g_gravity, G_MoverTouchPushTriggers(), G_StopObjectMoving(), gentity_t, gentity_s::health, level, entityShared_t::maxs, entityShared_t::mins, gentity_s::nextthink, cplane_s::normal, NULL, entityState_s::number, gentity_s::parent, pitch_roll_for_slope(), trace_t::plane, entityState_s::pos, level_locals_t::previousTime, qtrue, gentity_s::r, gentity_s::s, trace_t::startsolid, gentity_s::takedamage, level_locals_t::time, gentity_s::touch, TR_GRAVITY, TR_LINEAR, TR_STATIONARY, trap_LinkEntity(), trap_Trace(), trajectory_t::trBase, trajectory_t::trDelta, trajectory_t::trTime, trajectory_t::trType, vmCvar_t::value, vec3_t, VectorClear, VectorCopy, VectorScale, entityState_s::weapon, and WP_SABER. Referenced by DeadSaberThink(), DownedSaberThink(), drop_charge(), G_StartObjectMoving(), HolocronThink(), JMSaberThink(), pas_fire(), saberFirstThrown(), SP_PAS(), thermalThinkStandard(), and TrapThink(). { 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->r.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->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 ); if ( !tr.startsolid && !tr.allsolid && tr.fraction ) { VectorCopy( tr.endpos, ent->r.currentOrigin ); trap_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->r.currentAngles, ent->s.apos.trBase ); ent->s.apos.trType = TR_LINEAR; ent->s.apos.trDelta[1] = flrand( -300, 300 ); ent->s.apos.trDelta[0] = flrand( -10, 10 ); ent->s.apos.trDelta[2] = 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->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.0 && {//FIXME: only do this if no trDelta if ( g_gravity.value <= 0 || tr.plane.normal[2] < 0.7 ) { 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_StartObjectMoving (  gentity_t *  object, vec3_t  dir, float  speed, trType_t  trType )

Definition at line 260 of file g_object.c. References entityShared_t::currentOrigin, FRAMETIME, G_RunObject(), gentity_t, level, gentity_s::nextthink, NULL, entityState_s::pos, gentity_s::r, gentity_s::s, gentity_s::think, level_locals_t::time, trajectory_t::trBase, trajectory_t::trDelta, trajectory_t::trTime, trajectory_t::trType, vec3_t, VectorCopy, VectorNormalize(), and VectorScale. { VectorNormalize (dir); //object->s.eType = ET_GENERAL; object->s.pos.trType = trType; VectorCopy( object->r.currentOrigin, object->s.pos.trBase ); VectorScale(dir, speed, object->s.pos.trDelta ); object->s.pos.trTime = level.time; /* //FIXME: incorporate spin? vectoangles(dir, object->s.angles); VectorCopy(object->s.angles, object->s.apos.trBase); VectorSet(object->s.apos.trDelta, 300, 0, 0 ); object->s.apos.trTime = level.time; */ //FIXME: make these objects go through G_RunObject automatically, like missiles do if ( object->think == NULL ) { object->nextthink = level.time + FRAMETIME; object->think = G_RunObject; } else {//You're responsible for calling RunObject } }

void G_StopObjectMoving (  gentity_t *  object  )

Definition at line 244 of file g_object.c. References entityShared_t::currentOrigin, gentity_t, entityState_s::origin, entityState_s::pos, gentity_s::r, gentity_s::s, TR_STATIONARY, trajectory_t::trBase, trajectory_t::trDelta, trajectory_t::trType, VectorClear, and VectorCopy. Referenced by G_RunObject(). { object->s.pos.trType = TR_STATIONARY; VectorCopy( object->r.currentOrigin, object->s.origin ); VectorCopy( object->r.currentOrigin, object->s.pos.trBase ); VectorClear( object->s.pos.trDelta ); /* //Stop spinning VectorClear( self->s.apos.trDelta ); vectoangles(trace->plane.normal, self->s.angles); VectorCopy(self->s.angles, self->r.currentAngles ); VectorCopy(self->s.angles, self->s.apos.trBase); */ }

void pitch_roll_for_slope (  gentity_t *  forwhom, vec3_t  pass_slope )

Definition at line 395 of file NPC.c. References AngleVectors(), gentity_s::client, entityShared_t::currentAngles, entityShared_t::currentOrigin, DotProduct, fabs(), trace_t::fraction, gentity_t, MASK_SOLID, entityShared_t::mins, cplane_s::normal, NULL, entityState_s::number, playerState_s::origin, PITCH, trace_t::plane, gclient_s::ps, Q_fabs(), gentity_s::r, ROLL, gentity_s::s, trap_LinkEntity(), trap_Trace(), vec3_origin, vec3_t, vectoangles(), VectorCopy, and playerState_s::viewangles. { vec3_t slope; vec3_t nvf, ovf, ovr, startspot, endspot, new_angles = { 0, 0, 0 }; float pitch, mod, dot; //if we don't have a slope, get one if( !pass_slope || VectorCompare( vec3_origin, pass_slope ) ) { trace_t trace; VectorCopy( forwhom->r.currentOrigin, startspot ); startspot[2] += forwhom->r.mins[2] + 4; VectorCopy( startspot, endspot ); endspot[2] -= 300; trap_Trace( &trace, forwhom->r.currentOrigin, vec3_origin, vec3_origin, endspot, forwhom->s.number, MASK_SOLID ); // if(trace_fraction>0.05&&forwhom.movetype==MOVETYPE_STEP) // forwhom.flags(-)FL_ONGROUND; if ( trace.fraction >= 1.0 ) return; if( !( &trace.plane ) ) return; if ( VectorCompare( vec3_origin, trace.plane.normal ) ) return; VectorCopy( trace.plane.normal, slope ); } else { VectorCopy( pass_slope, slope ); } AngleVectors( forwhom->r.currentAngles, ovf, ovr, NULL ); vectoangles( slope, new_angles ); pitch = new_angles[PITCH] + 90; new_angles[ROLL] = new_angles[PITCH] = 0; AngleVectors( new_angles, nvf, NULL, NULL ); mod = DotProduct( nvf, ovr ); if ( mod<0 ) mod = -1; else mod = 1; dot = DotProduct( nvf, ovf ); if ( forwhom->client ) { float oldmins2; forwhom->client->ps.viewangles[PITCH] = dot * pitch; forwhom->client->ps.viewangles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod); oldmins2 = forwhom->r.mins[2]; forwhom->r.mins[2] = -24 + 12 * fabs(forwhom->client->ps.viewangles[PITCH])/180.0f; //FIXME: if it gets bigger, move up if ( oldmins2 > forwhom->r.mins[2] ) {//our mins is now lower, need to move up //FIXME: trace? forwhom->client->ps.origin[2] += (oldmins2 - forwhom->r.mins[2]); forwhom->r.currentOrigin[2] = forwhom->client->ps.origin[2]; trap_LinkEntity( forwhom ); } } else { forwhom->r.currentAngles[PITCH] = dot * pitch; forwhom->r.currentAngles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod); } }