sin-sdk/bullet.cpp

515 lines
14 KiB
C++
Raw Normal View History

1998-12-20 00:00:00 +00:00
//-----------------------------------------------------------------------------
//
// $Logfile:: /Quake 2 Engine/Sin/code/game/bullet.cpp $
// $Revision:: 71 $
// $Author:: Markd $
// $Date:: 10/22/98 7:57p $
//
// Copyright (C) 1997 by Ritual Entertainment, Inc.
// All rights reserved.
//
// This source is may not be distributed and/or modified without
// expressly written permission by Ritual Entertainment, Inc.
//
// $Log:: /Quake 2 Engine/Sin/code/game/bullet.cpp $
//
// 71 10/22/98 7:57p Markd
// put in proper pre-caching in all the classes
//
// 70 10/20/98 8:26p Markd
// Added Attacker to DamageSurface stuff
//
// 69 10/13/98 5:27p Markd
// revamped ricochet stuff
//
// 68 10/13/98 12:35p Markd
// Fixed tracers and bullet holes on non-player guys
//
// 67 10/05/98 11:30p Markd
// Added MakeBreakingSound when firing at things
//
// 66 10/04/98 10:36p Markd
// put in ricochet code
//
// 65 9/27/98 3:53p Aldie
// Put in some debugging information
//
// 64 9/18/98 8:14p Markd
// rewrote surface system so that surfaces are now damaged by surface name
// instead of by surfinfo
//
// 63 8/31/98 7:45p Aldie
// Updated surface data structure and removed surfinfo field
//
// 62 8/29/98 9:39p Jimdose
// Added call info to G_Trace
//
// 61 8/29/98 5:27p Markd
// added specialfx, replaced misc with specialfx where appropriate
//
// 60 8/25/98 7:55p Markd
// Fixed weapon angles
//
// 59 8/19/98 6:38p Markd
// Moved Assault rifle tracer into def file
//
// 58 8/14/98 5:37p Aldie
// Moved blood stuff to sentient
//
// 57 8/13/98 8:09p Aldie
// Moved blood particles to armor damage.
//
// 56 8/10/98 6:52p Aldie
// Added scale to bloodsplats
//
// 55 8/06/98 10:53p Aldie
// Added weapon tweaks and kickback. Also modified blast radius damage and
// rocket jumping.
//
// 54 8/04/98 3:27p Aldie
// Revert back to sending PITCH and YAW
//
// 53 8/03/98 3:28p Aldie
// Only send over the PITCH of the gun when firing it
//
// 52 8/01/98 4:39p Aldie
// Put some debug prints
//
// 51 8/01/98 3:24p Aldie
// Added server effects flag for specific weapons
//
// 50 7/31/98 7:42p Aldie
// Client side bullet effects
//
// 49 7/25/98 5:48p Aldie
// Remove shotgun effect
//
// 48 7/24/98 10:03p Aldie
// Fixed bullet damage with invalid traces
//
// 47 7/23/98 6:17p Aldie
// Updated damage system and fixed some damage related bugs. Also put tracers
// back to the way they were, and added gib event to funcscriptmodels
//
// 46 7/22/98 10:41p Aldie
// Fixed tracers
//
// 45 7/21/98 1:10p Aldie
// Added meansofdeath to obituaries
//
// 44 7/17/98 7:57p Markd
// Added radius to FullTrace
//
// 43 7/15/98 9:57p Markd
// Added shields support
//
// 42 6/20/98 7:48p Markd
// using FullTrace now, also checking to make sure we have a valid intersection
// before trying to determine group num etc.
//
// 41 6/19/98 9:29p Jimdose
// Moved gun orientation code to Weapon
//
// 40 6/15/98 10:52p Jimdose
// Disabled fulltrace until bmodels are checked.
//
// 39 6/15/98 10:07p Jimdose
// Made bullet weapons use G_FullTrace
//
// 38 6/11/98 3:34p Jimdose
// TraceAttack was damaging the entity before checking the blood and sparks
// flags, so if the entity died before the check, we got a NULL pointer
// TraceAttack was doing the ricochet trace before checking if it should
// ricochet
//
// 37 6/10/98 2:10p Aldie
// Updated damage function.
//
// 36 6/08/98 11:35a Aldie
// Updated location based damage stuff
//
// 35 6/05/98 6:23p Aldie
// Added location to AddMultiDamage
//
// 34 5/27/98 7:34p Markd
// commented out damage reduction if not hitting body part
//
// 33 5/27/98 5:21p Markd
// fixed up ray intersection a bit
//
// 32 5/27/98 5:02a Markd
// increased nominal multiplier to 0.5f
//
// 31 5/26/98 8:44p Markd
// Put in DamageSkin suport
//
// 30 5/26/98 4:22p Markd
// Working on tri-ray intersection stuff
//
// 29 5/23/98 4:46p Aldie
// Added bulletholes.
//
// 28 5/05/98 7:38p Markd
// Added timeofs to ricochets in bulllet smoke events
//
// 27 5/03/98 8:08p Markd
// Took out old code
//
// 26 5/03/98 4:30p Jimdose
// Changed Vector class
//
// 25 5/02/98 8:41p Markd
// Put in recursive bullet attacks and got rid of ricochets
//
// 24 4/10/98 1:22a Markd
// Added FL_BLOOD support
//
// 23 4/07/98 6:42p Jimdose
// Rewrote weapon code.
// Added order to rank
//
// 22 4/06/98 7:52p Aldie
// Increased range of bullets.
//
// 21 4/04/98 7:31p Jimdose
// Bullets don't spark or ricochet against sky
//
// 20 4/02/98 4:48p Jimdose
// Changed TraceAttack to properly place bloodsplats
//
// 19 3/30/98 2:35p Jimdose
// Moved firing from Magnum to make more general
// Added Ammo
// Added world models
//
// 18 3/27/98 6:34p Jimdose
// Added sparks to show impact of bullets
//
// 17 3/26/98 8:16p Jimdose
// Added precaching of sounds
//
// 16 3/23/98 1:31p Jimdose
// Revamped event and command system
//
// 15 3/05/98 5:44p Aldie
// Support for ricochet flag.
//
// 14 3/04/98 8:02p Aldie
// More support for damage surfaces.
//
// 13 3/04/98 5:12p Aldie
// Added support for damage surfaces.
//
// 12 2/19/98 2:35p Jimdose
// Updated to work with Q2 based progs
//
// 10 12/11/97 3:30p Markd
// Moved SpawnBlood to Weapon
//
// 9 11/18/97 5:28p Markd
// Commented out shotgun
//
// 8 11/11/97 9:41p Markd
// tweaked minimum scale in blood splats
//
// 7 11/11/97 9:38p Markd
// made blood splats be based off of distance as well as damage.
//
// 6 10/31/97 9:02p Jimdose
// Made it so that bsp objects don't leave bloodsplats
//
// 5 10/31/97 7:18p Markd
// Put in BloodSpray
//
// 4 10/31/97 4:28p Jimdose
// Removed redefinition of owner in base class Weapon, so any reference to
// gunoffset through owner had to use type overriding.
//
// 3 10/27/97 3:29p Jimdose
// Removed dependency on quakedef.h
//
// 2 9/26/97 4:43p Jimdose
// Added standard Ritual header
//
// DESCRIPTION:
// Base class for all bullet (hitscan) weapons. Includes definition for shotgun.
//
#include "g_local.h"
#include "specialfx.h"
#include "misc.h"
#include "bullet.h"
#include "q_shared.h"
#include "surface.h"
CLASS_DECLARATION( Weapon, BulletWeapon, NULL );
ResponseDef BulletWeapon::Responses[] =
{
{ NULL, NULL }
};
BulletWeapon::BulletWeapon()
{
modelIndex( "sprites/tracer.spr" );
modelIndex( "sprites/bullethole.spr" );
}
void BulletWeapon::TraceAttack
(
Vector start,
Vector end,
int damage,
trace_t *trace,
int numricochets,
int kick,
int dflags,
int meansofdeath,
qboolean server_effects
)
{
Vector org;
Vector dir;
Vector endpos;
int surfflags;
int surftype;
int timeofs;
Entity *ent;
qboolean ricochet;
if ( HitSky( trace ) )
{
return;
}
ricochet = false;
dir = end - start;
dir.normalize();
org = end - dir;
ent = trace->ent->entity;
if ( !trace->surface )
{
surfflags = 0;
surftype = 0;
}
else
{
surfflags = trace->surface->flags;
surftype = SURFACETYPE_FROM_FLAGS( surfflags );
surfaceManager.DamageSurface( trace, damage, owner );
if ( surfflags & SURF_RICOCHET )
ricochet = true;
}
if ( trace->intersect.valid && ent )
{
//
// see if the parent group has ricochet turned on
//
if ( trace->intersect.parentgroup >= 0 )
{
int flags;
flags = gi.Group_Flags( ent->edict->s.modelindex, trace->intersect.parentgroup );
if ( flags & MDL_GROUP_RICOCHET )
{
surftype = ( flags >> 8 ) & 0xf;
ricochet = true;
}
}
}
if ( ent )
{
if ( !(ent->flags & FL_SHIELDS) )
{
if ( ent->flags & FL_SPARKS )
{
// Take care of ricochet effects on the server
if ( server_effects && !ricochet )
{
timeofs = MAX_RICOCHETS - numricochets;
if ( timeofs > 0xf )
{
timeofs = 0xf;
}
gi.WriteByte( svc_temp_entity );
gi.WriteByte( TE_GUNSHOT );
gi.WritePosition( org.vec3() );
gi.WriteDir( trace->plane.normal );
gi.WriteByte( 0 );
gi.multicast( org.vec3(), MULTICAST_PVS );
}
MadeBreakingSound( org, owner );
}
if ( ent->takedamage )
{
if ( trace->intersect.valid )
{
// We hit a valid group so send in location based damage
ent->Damage( this,
owner,
damage,
trace->endpos,
dir,
trace->plane.normal,
kick,
dflags,
meansofdeath,
trace->intersect.parentgroup,
-1,
trace->intersect.damage_multiplier );
}
else
{
// We didn't hit any groups, so send in generic damage
ent->Damage( this,
owner,
damage,
trace->endpos,
dir,
trace->plane.normal,
kick,
dflags,
meansofdeath,
-1,
-1,
1 );
}
}
}
else
{
surftype = SURF_TYPE_METAL;
ricochet = true;
}
}
if ( ricochet && ( server_effects || ( numricochets < MAX_RICOCHETS ) ) )
{
timeofs = MAX_RICOCHETS - numricochets;
if ( timeofs > 0xf )
{
timeofs = 0xf;
}
gi.WriteByte( svc_temp_entity );
gi.WriteByte( TE_GUNSHOT );
gi.WritePosition( org.vec3() );
gi.WriteDir( trace->plane.normal );
gi.WriteByte( timeofs );
gi.multicast( org.vec3(), MULTICAST_PVS );
}
if (
ricochet &&
numricochets &&
damage
)
{
dir += Vector( trace->plane.normal ) * 2;
endpos = org + dir * 8192;
//
// since this is a ricochet, we don't ignore the wewapon owner this time.
//
*trace = G_FullTrace( org, vec_zero, vec_zero, endpos, 5, NULL, MASK_SHOT, "BulletWeapon::TraceAttack" );
if ( trace->fraction != 1.0 )
{
endpos = trace->endpos;
TraceAttack( org, endpos, damage * 0.8f, trace, numricochets - 1, kick, dflags, meansofdeath, true );
}
}
}
void BulletWeapon::FireBullets
(
int numbullets,
Vector spread,
int mindamage,
int maxdamage,
int dflags,
int meansofdeath,
qboolean server_effects
)
{
Vector src;
Vector dir;
Vector end;
trace_t trace;
Vector right;
Vector up;
int i;
assert( owner );
if ( !owner )
{
return;
}
GetMuzzlePosition( &src, &dir );
owner->angles.AngleVectors( NULL, &right, &up );
angles = dir.toAngles();
setAngles( angles );
for( i = 0; i < numbullets; i++ )
{
end = src +
dir * 8192 +
right * G_CRandom() * spread.x +
up * G_CRandom() * spread.y;
trace = G_FullTrace( src, vec_zero, vec_zero, end, 5, owner, MASK_SHOT, "BulletWeapon::FireBullets" );
#if 0
Com_Printf("Server OWNER Angles:%0.2f %0.2f %0.2f\n",owner->angles[0],owner->angles[1],owner->angles[2]);
Com_Printf("Server Bullet Angles:%0.2f %0.2f %0.2f\n",angles[0],angles[1],angles[2]);
Com_Printf("Right :%0.2f %0.2f %0.2f\n",right[0],right[1],right[2]);
Com_Printf("Up :%0.2f %0.2f %0.2f\n",up[0],up[1],up[2]);
Com_Printf("Direction :%0.2f %0.2f %0.2f\n",dir[0],dir[1],dir[2]);
Com_Printf("Endpoint :%0.2f %0.2f %0.2f\n",end[0],end[1],end[2]);
Com_Printf("Server Trace Start :%0.2f %0.2f %0.2f\n",src[0],src[1],src[2]);
Com_Printf("Server Trace End :%0.2f %0.2f %0.2f\n",trace.endpos[0],trace.endpos[1],trace.endpos[2]);
Com_Printf("\n");
#endif
if ( trace.fraction != 1.0 )
{
TraceAttack( src, trace.endpos, mindamage + (int)G_Random( maxdamage - mindamage + 1 ), &trace, MAX_RICOCHETS, kick, dflags, meansofdeath, server_effects );
}
}
}
void BulletWeapon::FireTracer( void )
{
Entity *tracer;
Vector src,dir,end;
trace_t trace;
GetMuzzlePosition( &src, &dir );
end = src + dir * 8192;
trace = G_Trace( src, vec_zero, vec_zero, end, owner, MASK_SHOT, "BulletWeapon::FireTracer" );
tracer = new Entity;
tracer->angles = dir.toAngles();
tracer->angles[ PITCH ] = -tracer->angles[ PITCH ] + 90;
//tracer->angles[PITCH] *= -1;
tracer->setAngles( tracer->angles );
tracer->setMoveType( MOVETYPE_NONE );
tracer->setSolidType( SOLID_NOT );
tracer->setModel( "sprites/tracer.spr" );
tracer->setSize( "0 0 0", "0 0 0" );
tracer->setOrigin( trace.endpos );
tracer->edict->s.renderfx &= ~RF_FRAMELERP;
VectorCopy( src, tracer->edict->s.old_origin );
tracer->PostEvent(EV_Remove,0.1f);
}