mirror of
https://github.com/ioquake/jedi-academy.git
synced 2024-11-22 04:11:57 +00:00
2582 lines
58 KiB
C
2582 lines
58 KiB
C
// Copyright (C) 1999-2000 Id Software, Inc.
|
|
//
|
|
// cg_weapons.c -- events and effects dealing with weapons
|
|
#include "cg_local.h"
|
|
#include "fx_local.h"
|
|
|
|
extern vec4_t bluehudtint;
|
|
extern vec4_t redhudtint;
|
|
extern float *hudTintColor;
|
|
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
// set up the appropriate ghoul2 info to a refent
|
|
void CG_SetGhoul2InfoRef( refEntity_t *ent, refEntity_t *s1)
|
|
{
|
|
ent->ghoul2 = s1->ghoul2;
|
|
VectorCopy( s1->modelScale, ent->modelScale);
|
|
ent->radius = s1->radius;
|
|
VectorCopy( s1->angles, ent->angles);
|
|
}
|
|
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|
|
|
|
/*
|
|
=================
|
|
CG_RegisterItemVisuals
|
|
|
|
The server says this item is used on this level
|
|
=================
|
|
*/
|
|
void CG_RegisterItemVisuals( int itemNum ) {
|
|
itemInfo_t *itemInfo;
|
|
gitem_t *item;
|
|
int handle;
|
|
|
|
if ( itemNum < 0 || itemNum >= bg_numItems ) {
|
|
CG_Error( "CG_RegisterItemVisuals: itemNum %d out of range [0-%d]", itemNum, bg_numItems-1 );
|
|
}
|
|
|
|
itemInfo = &cg_items[ itemNum ];
|
|
if ( itemInfo->registered ) {
|
|
return;
|
|
}
|
|
|
|
item = &bg_itemlist[ itemNum ];
|
|
|
|
memset( itemInfo, 0, sizeof( &itemInfo ) );
|
|
itemInfo->registered = qtrue;
|
|
|
|
if (item->giType == IT_TEAM &&
|
|
(item->giTag == PW_REDFLAG || item->giTag == PW_BLUEFLAG) &&
|
|
cgs.gametype == GT_CTY)
|
|
{ //in CTY the flag model is different
|
|
itemInfo->models[0] = trap_R_RegisterModel( item->world_model[1] );
|
|
}
|
|
else if (item->giType == IT_WEAPON &&
|
|
(item->giTag == WP_THERMAL || item->giTag == WP_TRIP_MINE || item->giTag == WP_DET_PACK))
|
|
{
|
|
itemInfo->models[0] = trap_R_RegisterModel( item->world_model[1] );
|
|
}
|
|
else
|
|
{
|
|
itemInfo->models[0] = trap_R_RegisterModel( item->world_model[0] );
|
|
}
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
if (!Q_stricmp(&item->world_model[0][strlen(item->world_model[0]) - 4], ".glm"))
|
|
{
|
|
handle = trap_G2API_InitGhoul2Model(&itemInfo->g2Models[0], item->world_model[0], 0 , 0, 0, 0, 0);
|
|
if (handle<0)
|
|
{
|
|
itemInfo->g2Models[0] = NULL;
|
|
}
|
|
else
|
|
{
|
|
itemInfo->radius[0] = 60;
|
|
}
|
|
}
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|
|
if (item->icon)
|
|
{
|
|
if (item->giType == IT_HEALTH)
|
|
{ //medpack gets nomip'd by the ui or something I guess.
|
|
itemInfo->icon = trap_R_RegisterShaderNoMip( item->icon );
|
|
}
|
|
else
|
|
{
|
|
itemInfo->icon = trap_R_RegisterShader( item->icon );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
itemInfo->icon = 0;
|
|
}
|
|
|
|
if ( item->giType == IT_WEAPON ) {
|
|
CG_RegisterWeapon( item->giTag );
|
|
}
|
|
|
|
//
|
|
// powerups have an accompanying ring or sphere
|
|
//
|
|
if ( item->giType == IT_POWERUP || item->giType == IT_HEALTH ||
|
|
item->giType == IT_ARMOR || item->giType == IT_HOLDABLE ) {
|
|
if ( item->world_model[1] ) {
|
|
itemInfo->models[1] = trap_R_RegisterModel( item->world_model[1] );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
========================================================================================
|
|
|
|
VIEW WEAPON
|
|
|
|
========================================================================================
|
|
*/
|
|
|
|
#define WEAPON_FORCE_BUSY_HOLSTER
|
|
|
|
#ifdef WEAPON_FORCE_BUSY_HOLSTER
|
|
//rww - this was done as a last resort. Forgive me.
|
|
static int cgWeapFrame = 0;
|
|
static int cgWeapFrameTime = 0;
|
|
#endif
|
|
|
|
/*
|
|
=================
|
|
CG_MapTorsoToWeaponFrame
|
|
|
|
=================
|
|
*/
|
|
static int CG_MapTorsoToWeaponFrame( clientInfo_t *ci, int frame, int animNum ) {
|
|
animation_t *animations = bgHumanoidAnimations;
|
|
#ifdef WEAPON_FORCE_BUSY_HOLSTER
|
|
if (cg.snap->ps.forceHandExtend != HANDEXTEND_NONE || cgWeapFrameTime > cg.time)
|
|
{ //the reason for the after delay is so that it doesn't snap the weapon frame to the "idle" (0) frame
|
|
//for a very quick moment
|
|
if (cgWeapFrame < 6)
|
|
{
|
|
cgWeapFrame = 6;
|
|
cgWeapFrameTime = cg.time + 10;
|
|
}
|
|
|
|
if (cgWeapFrameTime < cg.time && cgWeapFrame < 10)
|
|
{
|
|
cgWeapFrame++;
|
|
cgWeapFrameTime = cg.time + 10;
|
|
}
|
|
|
|
if (cg.snap->ps.forceHandExtend != HANDEXTEND_NONE &&
|
|
cgWeapFrame == 10)
|
|
{
|
|
cgWeapFrameTime = cg.time + 100;
|
|
}
|
|
|
|
return cgWeapFrame;
|
|
}
|
|
else
|
|
{
|
|
cgWeapFrame = 0;
|
|
cgWeapFrameTime = 0;
|
|
}
|
|
#endif
|
|
|
|
switch( animNum )
|
|
{
|
|
case TORSO_DROPWEAP1:
|
|
if ( frame >= animations[animNum].firstFrame && frame < animations[animNum].firstFrame + 5 )
|
|
{
|
|
return frame - animations[animNum].firstFrame + 6;
|
|
}
|
|
break;
|
|
|
|
case TORSO_RAISEWEAP1:
|
|
if ( frame >= animations[animNum].firstFrame && frame < animations[animNum].firstFrame + 4 )
|
|
{
|
|
return frame - animations[animNum].firstFrame + 6 + 4;
|
|
}
|
|
break;
|
|
case BOTH_ATTACK1:
|
|
case BOTH_ATTACK2:
|
|
case BOTH_ATTACK3:
|
|
case BOTH_ATTACK4:
|
|
case BOTH_ATTACK10:
|
|
case BOTH_THERMAL_THROW:
|
|
if ( frame >= animations[animNum].firstFrame && frame < animations[animNum].firstFrame + 6 )
|
|
{
|
|
return 1 + ( frame - animations[animNum].firstFrame );
|
|
}
|
|
|
|
break;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
/*
|
|
==============
|
|
CG_CalculateWeaponPosition
|
|
==============
|
|
*/
|
|
static void CG_CalculateWeaponPosition( vec3_t origin, vec3_t angles ) {
|
|
float scale;
|
|
int delta;
|
|
float fracsin;
|
|
|
|
VectorCopy( cg.refdef.vieworg, origin );
|
|
VectorCopy( cg.refdef.viewangles, angles );
|
|
|
|
// on odd legs, invert some angles
|
|
if ( cg.bobcycle & 1 ) {
|
|
scale = -cg.xyspeed;
|
|
} else {
|
|
scale = cg.xyspeed;
|
|
}
|
|
|
|
// gun angles from bobbing
|
|
angles[ROLL] += scale * cg.bobfracsin * 0.005;
|
|
angles[YAW] += scale * cg.bobfracsin * 0.01;
|
|
angles[PITCH] += cg.xyspeed * cg.bobfracsin * 0.005;
|
|
|
|
// drop the weapon when landing
|
|
delta = cg.time - cg.landTime;
|
|
if ( delta < LAND_DEFLECT_TIME ) {
|
|
origin[2] += cg.landChange*0.25 * delta / LAND_DEFLECT_TIME;
|
|
} else if ( delta < LAND_DEFLECT_TIME + LAND_RETURN_TIME ) {
|
|
origin[2] += cg.landChange*0.25 *
|
|
(LAND_DEFLECT_TIME + LAND_RETURN_TIME - delta) / LAND_RETURN_TIME;
|
|
}
|
|
|
|
#if 0
|
|
// drop the weapon when stair climbing
|
|
delta = cg.time - cg.stepTime;
|
|
if ( delta < STEP_TIME/2 ) {
|
|
origin[2] -= cg.stepChange*0.25 * delta / (STEP_TIME/2);
|
|
} else if ( delta < STEP_TIME ) {
|
|
origin[2] -= cg.stepChange*0.25 * (STEP_TIME - delta) / (STEP_TIME/2);
|
|
}
|
|
#endif
|
|
|
|
// idle drift
|
|
scale = cg.xyspeed + 40;
|
|
fracsin = sin( cg.time * 0.001 );
|
|
angles[ROLL] += scale * fracsin * 0.01;
|
|
angles[YAW] += scale * fracsin * 0.01;
|
|
angles[PITCH] += scale * fracsin * 0.01;
|
|
}
|
|
|
|
|
|
/*
|
|
===============
|
|
CG_LightningBolt
|
|
|
|
Origin will be the exact tag point, which is slightly
|
|
different than the muzzle point used for determining hits.
|
|
The cent should be the non-predicted cent if it is from the player,
|
|
so the endpoint will reflect the simulated strike (lagging the predicted
|
|
angle)
|
|
===============
|
|
*/
|
|
static void CG_LightningBolt( centity_t *cent, vec3_t origin ) {
|
|
// trace_t trace;
|
|
refEntity_t beam;
|
|
// vec3_t forward;
|
|
// vec3_t muzzlePoint, endPoint;
|
|
|
|
//Must be a durational weapon that continuously generates an effect.
|
|
if ( cent->currentState.weapon == WP_DEMP2 && cent->currentState.eFlags & EF_ALT_FIRING )
|
|
{ /*nothing*/ }
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
|
|
memset( &beam, 0, sizeof( beam ) );
|
|
|
|
// NOTENOTE No lightning gun-ish stuff yet.
|
|
/*
|
|
// CPMA "true" lightning
|
|
if ((cent->currentState.number == cg.predictedPlayerState.clientNum) && (cg_trueLightning.value != 0)) {
|
|
vec3_t angle;
|
|
int i;
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
float a = cent->lerpAngles[i] - cg.refdef.viewangles[i];
|
|
if (a > 180) {
|
|
a -= 360;
|
|
}
|
|
if (a < -180) {
|
|
a += 360;
|
|
}
|
|
|
|
angle[i] = cg.refdef.viewangles[i] + a * (1.0 - cg_trueLightning.value);
|
|
if (angle[i] < 0) {
|
|
angle[i] += 360;
|
|
}
|
|
if (angle[i] > 360) {
|
|
angle[i] -= 360;
|
|
}
|
|
}
|
|
|
|
AngleVectors(angle, forward, NULL, NULL );
|
|
VectorCopy(cent->lerpOrigin, muzzlePoint );
|
|
// VectorCopy(cg.refdef.vieworg, muzzlePoint );
|
|
} else {
|
|
// !CPMA
|
|
AngleVectors( cent->lerpAngles, forward, NULL, NULL );
|
|
VectorCopy(cent->lerpOrigin, muzzlePoint );
|
|
}
|
|
|
|
// FIXME: crouch
|
|
muzzlePoint[2] += DEFAULT_VIEWHEIGHT;
|
|
|
|
VectorMA( muzzlePoint, 14, forward, muzzlePoint );
|
|
|
|
// project forward by the lightning range
|
|
VectorMA( muzzlePoint, LIGHTNING_RANGE, forward, endPoint );
|
|
|
|
// see if it hit a wall
|
|
CG_Trace( &trace, muzzlePoint, vec3_origin, vec3_origin, endPoint,
|
|
cent->currentState.number, MASK_SHOT );
|
|
|
|
// this is the endpoint
|
|
VectorCopy( trace.endpos, beam.oldorigin );
|
|
|
|
// use the provided origin, even though it may be slightly
|
|
// different than the muzzle origin
|
|
VectorCopy( origin, beam.origin );
|
|
|
|
beam.reType = RT_LIGHTNING;
|
|
beam.customShader = cgs.media.lightningShader;
|
|
trap_R_AddRefEntityToScene( &beam );
|
|
*/
|
|
|
|
// NOTENOTE No lightning gun-ish stuff yet.
|
|
/*
|
|
// add the impact flare if it hit something
|
|
if ( trace.fraction < 1.0 ) {
|
|
vec3_t angles;
|
|
vec3_t dir;
|
|
|
|
VectorSubtract( beam.oldorigin, beam.origin, dir );
|
|
VectorNormalize( dir );
|
|
|
|
memset( &beam, 0, sizeof( beam ) );
|
|
beam.hModel = cgs.media.lightningExplosionModel;
|
|
|
|
VectorMA( trace.endpos, -16, dir, beam.origin );
|
|
|
|
// make a random orientation
|
|
angles[0] = rand() % 360;
|
|
angles[1] = rand() % 360;
|
|
angles[2] = rand() % 360;
|
|
AnglesToAxis( angles, beam.axis );
|
|
trap_R_AddRefEntityToScene( &beam );
|
|
}
|
|
*/
|
|
}
|
|
|
|
|
|
/*
|
|
========================
|
|
CG_AddWeaponWithPowerups
|
|
========================
|
|
*/
|
|
static void CG_AddWeaponWithPowerups( refEntity_t *gun, int powerups ) {
|
|
// add powerup effects
|
|
trap_R_AddRefEntityToScene( gun );
|
|
|
|
if (cg.predictedPlayerState.electrifyTime > cg.time)
|
|
{ //add electrocution shell
|
|
int preShader = gun->customShader;
|
|
if ( rand() & 1 )
|
|
{
|
|
gun->customShader = cgs.media.electricBodyShader;
|
|
}
|
|
else
|
|
{
|
|
gun->customShader = cgs.media.electricBody2Shader;
|
|
}
|
|
trap_R_AddRefEntityToScene( gun );
|
|
gun->customShader = preShader; //set back just to be safe
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
CG_AddPlayerWeapon
|
|
|
|
Used for both the view weapon (ps is valid) and the world modelother character models (ps is NULL)
|
|
The main player will have this called for BOTH cases, so effects like light and
|
|
sound should only be done on the world model case.
|
|
=============
|
|
*/
|
|
void CG_AddPlayerWeapon( refEntity_t *parent, playerState_t *ps, centity_t *cent, int team, vec3_t newAngles, qboolean thirdPerson ) {
|
|
refEntity_t gun;
|
|
refEntity_t barrel;
|
|
vec3_t angles;
|
|
weapon_t weaponNum;
|
|
weaponInfo_t *weapon;
|
|
centity_t *nonPredictedCent;
|
|
refEntity_t flash;
|
|
|
|
weaponNum = cent->currentState.weapon;
|
|
|
|
if (cent->currentState.weapon == WP_EMPLACED_GUN)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (cg.predictedPlayerState.pm_type == PM_SPECTATOR &&
|
|
cent->currentState.number == cg.predictedPlayerState.clientNum)
|
|
{ //spectator mode, don't draw it...
|
|
return;
|
|
}
|
|
|
|
CG_RegisterWeapon( weaponNum );
|
|
weapon = &cg_weapons[weaponNum];
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
|
|
memset( &gun, 0, sizeof( gun ) );
|
|
|
|
// only do this if we are in first person, since world weapons are now handled on the server by Ghoul2
|
|
if (!thirdPerson)
|
|
{
|
|
|
|
// add the weapon
|
|
VectorCopy( parent->lightingOrigin, gun.lightingOrigin );
|
|
gun.shadowPlane = parent->shadowPlane;
|
|
gun.renderfx = parent->renderfx;
|
|
|
|
if (ps)
|
|
{ // this player, in first person view
|
|
gun.hModel = weapon->viewModel;
|
|
}
|
|
else
|
|
{
|
|
gun.hModel = weapon->weaponModel;
|
|
}
|
|
if (!gun.hModel) {
|
|
return;
|
|
}
|
|
|
|
if ( !ps ) {
|
|
// add weapon ready sound
|
|
cent->pe.lightningFiring = qfalse;
|
|
if ( ( cent->currentState.eFlags & EF_FIRING ) && weapon->firingSound ) {
|
|
// lightning gun and guantlet make a different sound when fire is held down
|
|
trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, weapon->firingSound );
|
|
cent->pe.lightningFiring = qtrue;
|
|
} else if ( weapon->readySound ) {
|
|
trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, weapon->readySound );
|
|
}
|
|
}
|
|
|
|
CG_PositionEntityOnTag( &gun, parent, parent->hModel, "tag_weapon");
|
|
|
|
if (!CG_IsMindTricked(cent->currentState.trickedentindex,
|
|
cent->currentState.trickedentindex2,
|
|
cent->currentState.trickedentindex3,
|
|
cent->currentState.trickedentindex4,
|
|
cg.snap->ps.clientNum))
|
|
{
|
|
CG_AddWeaponWithPowerups( &gun, cent->currentState.powerups ); //don't draw the weapon if the player is invisible
|
|
/*
|
|
if ( weaponNum == WP_STUN_BATON )
|
|
{
|
|
gun.shaderRGBA[0] = gun.shaderRGBA[1] = gun.shaderRGBA[2] = 25;
|
|
|
|
gun.customShader = trap_R_RegisterShader( "gfx/effects/stunPass" );
|
|
gun.renderfx = RF_RGB_TINT | RF_FIRST_PERSON | RF_DEPTHHACK;
|
|
trap_R_AddRefEntityToScene( &gun );
|
|
}
|
|
*/
|
|
}
|
|
|
|
if (weaponNum == WP_STUN_BATON)
|
|
{
|
|
int i = 0;
|
|
|
|
while (i < 3)
|
|
{
|
|
memset( &barrel, 0, sizeof( barrel ) );
|
|
VectorCopy( parent->lightingOrigin, barrel.lightingOrigin );
|
|
barrel.shadowPlane = parent->shadowPlane;
|
|
barrel.renderfx = parent->renderfx;
|
|
|
|
if (i == 0)
|
|
{
|
|
barrel.hModel = trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel.md3");
|
|
}
|
|
else if (i == 1)
|
|
{
|
|
barrel.hModel = trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel2.md3");
|
|
}
|
|
else
|
|
{
|
|
barrel.hModel = trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel3.md3");
|
|
}
|
|
angles[YAW] = 0;
|
|
angles[PITCH] = 0;
|
|
angles[ROLL] = 0;
|
|
|
|
AnglesToAxis( angles, barrel.axis );
|
|
|
|
if (i == 0)
|
|
{
|
|
CG_PositionRotatedEntityOnTag( &barrel, parent/*&gun*/, /*weapon->weaponModel*/weapon->handsModel, "tag_barrel" );
|
|
}
|
|
else if (i == 1)
|
|
{
|
|
CG_PositionRotatedEntityOnTag( &barrel, parent/*&gun*/, /*weapon->weaponModel*/weapon->handsModel, "tag_barrel2" );
|
|
}
|
|
else
|
|
{
|
|
CG_PositionRotatedEntityOnTag( &barrel, parent/*&gun*/, /*weapon->weaponModel*/weapon->handsModel, "tag_barrel3" );
|
|
}
|
|
CG_AddWeaponWithPowerups( &barrel, cent->currentState.powerups );
|
|
|
|
i++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// add the spinning barrel
|
|
if ( weapon->barrelModel ) {
|
|
memset( &barrel, 0, sizeof( barrel ) );
|
|
VectorCopy( parent->lightingOrigin, barrel.lightingOrigin );
|
|
barrel.shadowPlane = parent->shadowPlane;
|
|
barrel.renderfx = parent->renderfx;
|
|
|
|
barrel.hModel = weapon->barrelModel;
|
|
angles[YAW] = 0;
|
|
angles[PITCH] = 0;
|
|
angles[ROLL] = 0;
|
|
|
|
AnglesToAxis( angles, barrel.axis );
|
|
|
|
CG_PositionRotatedEntityOnTag( &barrel, parent/*&gun*/, /*weapon->weaponModel*/weapon->handsModel, "tag_barrel" );
|
|
|
|
CG_AddWeaponWithPowerups( &barrel, cent->currentState.powerups );
|
|
}
|
|
}
|
|
}
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|
|
|
|
memset (&flash, 0, sizeof(flash));
|
|
CG_PositionEntityOnTag( &flash, &gun, gun.hModel, "tag_flash");
|
|
|
|
VectorCopy(flash.origin, cg.lastFPFlashPoint);
|
|
|
|
// Do special charge bits
|
|
//-----------------------
|
|
if ( (ps || cg.renderingThirdPerson || cg.predictedPlayerState.clientNum != cent->currentState.number) &&
|
|
( ( cent->currentState.modelindex2 == WEAPON_CHARGING_ALT && cent->currentState.weapon == WP_BRYAR_PISTOL ) ||
|
|
( cent->currentState.modelindex2 == WEAPON_CHARGING_ALT && cent->currentState.weapon == WP_BRYAR_OLD ) ||
|
|
( cent->currentState.weapon == WP_BOWCASTER && cent->currentState.modelindex2 == WEAPON_CHARGING ) ||
|
|
( cent->currentState.weapon == WP_DEMP2 && cent->currentState.modelindex2 == WEAPON_CHARGING_ALT) ) )
|
|
{
|
|
int shader = 0;
|
|
float val = 0.0f;
|
|
float scale = 1.0f;
|
|
addspriteArgStruct_t fxSArgs;
|
|
vec3_t flashorigin, flashdir;
|
|
|
|
if (!thirdPerson)
|
|
{
|
|
VectorCopy(flash.origin, flashorigin);
|
|
VectorCopy(flash.axis[0], flashdir);
|
|
}
|
|
else
|
|
{
|
|
mdxaBone_t boltMatrix;
|
|
|
|
if (!trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 1))
|
|
{ //it's quite possible that we may have have no weapon model and be in a valid state, so return here if this is the case
|
|
return;
|
|
}
|
|
|
|
// go away and get me the bolt position for this frame please
|
|
if (!(trap_G2API_GetBoltMatrix(cent->ghoul2, 1, 0, &boltMatrix, newAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale)))
|
|
{ // Couldn't find bolt point.
|
|
return;
|
|
}
|
|
|
|
BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, flashorigin);
|
|
BG_GiveMeVectorFromMatrix(&boltMatrix, POSITIVE_X, flashdir);
|
|
}
|
|
|
|
if ( cent->currentState.weapon == WP_BRYAR_PISTOL ||
|
|
cent->currentState.weapon == WP_BRYAR_OLD)
|
|
{
|
|
// Hardcoded max charge time of 1 second
|
|
val = ( cg.time - cent->currentState.constantLight ) * 0.001f;
|
|
shader = cgs.media.bryarFrontFlash;
|
|
}
|
|
else if ( cent->currentState.weapon == WP_BOWCASTER )
|
|
{
|
|
// Hardcoded max charge time of 1 second
|
|
val = ( cg.time - cent->currentState.constantLight ) * 0.001f;
|
|
shader = cgs.media.greenFrontFlash;
|
|
}
|
|
else if ( cent->currentState.weapon == WP_DEMP2 )
|
|
{
|
|
val = ( cg.time - cent->currentState.constantLight ) * 0.001f;
|
|
shader = cgs.media.lightningFlash;
|
|
scale = 1.75f;
|
|
}
|
|
|
|
if ( val < 0.0f )
|
|
{
|
|
val = 0.0f;
|
|
}
|
|
else if ( val > 1.0f )
|
|
{
|
|
val = 1.0f;
|
|
if (ps && cent->currentState.number == ps->clientNum)
|
|
{
|
|
CGCam_Shake( /*0.1f*/0.2f, 100 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ps && cent->currentState.number == ps->clientNum)
|
|
{
|
|
CGCam_Shake( val * val * /*0.3f*/0.6f, 100 );
|
|
}
|
|
}
|
|
|
|
val += random() * 0.5f;
|
|
|
|
VectorCopy(flashorigin, fxSArgs.origin);
|
|
VectorClear(fxSArgs.vel);
|
|
VectorClear(fxSArgs.accel);
|
|
fxSArgs.scale = 3.0f*val*scale;
|
|
fxSArgs.dscale = 0.0f;
|
|
fxSArgs.sAlpha = 0.7f;
|
|
fxSArgs.eAlpha = 0.7f;
|
|
fxSArgs.rotation = random()*360;
|
|
fxSArgs.bounce = 0.0f;
|
|
fxSArgs.life = 1.0f;
|
|
fxSArgs.shader = shader;
|
|
fxSArgs.flags = 0x08000000;
|
|
|
|
//FX_AddSprite( flash.origin, NULL, NULL, 3.0f * val, 0.0f, 0.7f, 0.7f, WHITE, WHITE, random() * 360, 0.0f, 1.0f, shader, FX_USE_ALPHA );
|
|
trap_FX_AddSprite(&fxSArgs);
|
|
}
|
|
|
|
// make sure we aren't looking at cg.predictedPlayerEntity for LG
|
|
nonPredictedCent = &cg_entities[cent->currentState.clientNum];
|
|
|
|
// if the index of the nonPredictedCent is not the same as the clientNum
|
|
// then this is a fake player (like on teh single player podiums), so
|
|
// go ahead and use the cent
|
|
if( ( nonPredictedCent - cg_entities ) != cent->currentState.clientNum ) {
|
|
nonPredictedCent = cent;
|
|
}
|
|
|
|
// add the flash
|
|
if ( ( weaponNum == WP_DEMP2)
|
|
&& ( nonPredictedCent->currentState.eFlags & EF_FIRING ) )
|
|
{
|
|
// continuous flash
|
|
} else {
|
|
// impulse flash
|
|
if ( cg.time - cent->muzzleFlashTime > MUZZLE_FLASH_TIME) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ( ps || cg.renderingThirdPerson ||
|
|
cent->currentState.number != cg.predictedPlayerState.clientNum )
|
|
{ // Make sure we don't do the thirdperson model effects for the local player if we're in first person
|
|
vec3_t flashorigin, flashdir;
|
|
refEntity_t flash;
|
|
|
|
memset (&flash, 0, sizeof(flash));
|
|
|
|
if (!thirdPerson)
|
|
{
|
|
CG_PositionEntityOnTag( &flash, &gun, gun.hModel, "tag_flash");
|
|
VectorCopy(flash.origin, flashorigin);
|
|
VectorCopy(flash.axis[0], flashdir);
|
|
}
|
|
else
|
|
{
|
|
mdxaBone_t boltMatrix;
|
|
|
|
if (!trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 1))
|
|
{ //it's quite possible that we may have have no weapon model and be in a valid state, so return here if this is the case
|
|
return;
|
|
}
|
|
|
|
// go away and get me the bolt position for this frame please
|
|
if (!(trap_G2API_GetBoltMatrix(cent->ghoul2, 1, 0, &boltMatrix, newAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale)))
|
|
{ // Couldn't find bolt point.
|
|
return;
|
|
}
|
|
|
|
BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, flashorigin);
|
|
BG_GiveMeVectorFromMatrix(&boltMatrix, POSITIVE_X, flashdir);
|
|
}
|
|
|
|
if ( cg.time - cent->muzzleFlashTime <= MUZZLE_FLASH_TIME + 10 )
|
|
{ // Handle muzzle flashes
|
|
if ( cent->currentState.eFlags & EF_ALT_FIRING )
|
|
{ // Check the alt firing first.
|
|
if (weapon->altMuzzleEffect)
|
|
{
|
|
if (!thirdPerson)
|
|
{
|
|
trap_FX_PlayEntityEffectID(weapon->altMuzzleEffect, flashorigin, flash.axis, -1, -1, -1, -1 );
|
|
}
|
|
else
|
|
{
|
|
trap_FX_PlayEffectID(weapon->altMuzzleEffect, flashorigin, flashdir, -1, -1);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{ // Regular firing
|
|
if (weapon->muzzleEffect)
|
|
{
|
|
if (!thirdPerson)
|
|
{
|
|
trap_FX_PlayEntityEffectID(weapon->muzzleEffect, flashorigin, flash.axis, -1, -1, -1, -1 );
|
|
}
|
|
else
|
|
{
|
|
trap_FX_PlayEffectID(weapon->muzzleEffect, flashorigin, flashdir, -1, -1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// add lightning bolt
|
|
CG_LightningBolt( nonPredictedCent, flashorigin );
|
|
|
|
if ( weapon->flashDlightColor[0] || weapon->flashDlightColor[1] || weapon->flashDlightColor[2] ) {
|
|
trap_R_AddLightToScene( flashorigin, 300 + (rand()&31), weapon->flashDlightColor[0],
|
|
weapon->flashDlightColor[1], weapon->flashDlightColor[2] );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
==============
|
|
CG_AddViewWeapon
|
|
|
|
Add the weapon, and flash for the player's view
|
|
==============
|
|
*/
|
|
void CG_AddViewWeapon( playerState_t *ps ) {
|
|
refEntity_t hand;
|
|
centity_t *cent;
|
|
clientInfo_t *ci;
|
|
float fovOffset;
|
|
vec3_t angles;
|
|
weaponInfo_t *weapon;
|
|
float cgFov = cg_fov.value;
|
|
|
|
if (cgFov < 1)
|
|
{
|
|
cgFov = 1;
|
|
}
|
|
if (cgFov > 97)
|
|
{
|
|
cgFov = 97;
|
|
}
|
|
|
|
if ( ps->persistant[PERS_TEAM] == TEAM_SPECTATOR ) {
|
|
return;
|
|
}
|
|
|
|
if ( ps->pm_type == PM_INTERMISSION ) {
|
|
return;
|
|
}
|
|
|
|
// no gun if in third person view or a camera is active
|
|
//if ( cg.renderingThirdPerson || cg.cameraMode) {
|
|
if ( cg.renderingThirdPerson ) {
|
|
return;
|
|
}
|
|
|
|
// allow the gun to be completely removed
|
|
if ( !cg_drawGun.integer || cg.predictedPlayerState.zoomMode) {
|
|
vec3_t origin;
|
|
|
|
if ( cg.predictedPlayerState.eFlags & EF_FIRING ) {
|
|
// special hack for lightning gun...
|
|
VectorCopy( cg.refdef.vieworg, origin );
|
|
VectorMA( origin, -8, cg.refdef.viewaxis[2], origin );
|
|
CG_LightningBolt( &cg_entities[ps->clientNum], origin );
|
|
}
|
|
return;
|
|
}
|
|
|
|
// don't draw if testing a gun model
|
|
if ( cg.testGun ) {
|
|
return;
|
|
}
|
|
|
|
// drop gun lower at higher fov
|
|
if ( cgFov > 90 ) {
|
|
fovOffset = -0.2 * ( cgFov - 90 );
|
|
} else {
|
|
fovOffset = 0;
|
|
}
|
|
|
|
cent = &cg_entities[cg.predictedPlayerState.clientNum];
|
|
CG_RegisterWeapon( ps->weapon );
|
|
weapon = &cg_weapons[ ps->weapon ];
|
|
|
|
memset (&hand, 0, sizeof(hand));
|
|
|
|
// set up gun position
|
|
CG_CalculateWeaponPosition( hand.origin, angles );
|
|
|
|
VectorMA( hand.origin, cg_gun_x.value, cg.refdef.viewaxis[0], hand.origin );
|
|
VectorMA( hand.origin, cg_gun_y.value, cg.refdef.viewaxis[1], hand.origin );
|
|
VectorMA( hand.origin, (cg_gun_z.value+fovOffset), cg.refdef.viewaxis[2], hand.origin );
|
|
|
|
AnglesToAxis( angles, hand.axis );
|
|
|
|
// map torso animations to weapon animations
|
|
if ( cg_gun_frame.integer ) {
|
|
// development tool
|
|
hand.frame = hand.oldframe = cg_gun_frame.integer;
|
|
hand.backlerp = 0;
|
|
} else {
|
|
// get clientinfo for animation map
|
|
if (cent->currentState.eType == ET_NPC)
|
|
{
|
|
if (!cent->npcClient)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ci = cent->npcClient;
|
|
}
|
|
else
|
|
{
|
|
ci = &cgs.clientinfo[ cent->currentState.clientNum ];
|
|
}
|
|
hand.frame = CG_MapTorsoToWeaponFrame( ci, cent->pe.torso.frame, cent->currentState.torsoAnim );
|
|
hand.oldframe = CG_MapTorsoToWeaponFrame( ci, cent->pe.torso.oldFrame, cent->currentState.torsoAnim );
|
|
hand.backlerp = cent->pe.torso.backlerp;
|
|
|
|
// Handle the fringe situation where oldframe is invalid
|
|
if ( hand.frame == -1 )
|
|
{
|
|
hand.frame = 0;
|
|
hand.oldframe = 0;
|
|
hand.backlerp = 0;
|
|
}
|
|
else if ( hand.oldframe == -1 )
|
|
{
|
|
hand.oldframe = hand.frame;
|
|
hand.backlerp = 0;
|
|
}
|
|
}
|
|
|
|
hand.hModel = weapon->handsModel;
|
|
hand.renderfx = RF_DEPTHHACK | RF_FIRST_PERSON;// | RF_MINLIGHT;
|
|
|
|
// add everything onto the hand
|
|
CG_AddPlayerWeapon( &hand, ps, &cg_entities[cg.predictedPlayerState.clientNum], ps->persistant[PERS_TEAM], angles, qfalse );
|
|
}
|
|
|
|
/*
|
|
==============================================================================
|
|
|
|
WEAPON SELECTION
|
|
|
|
==============================================================================
|
|
*/
|
|
#define ICON_WEAPONS 0
|
|
#define ICON_FORCE 1
|
|
#define ICON_INVENTORY 2
|
|
|
|
|
|
void CG_DrawIconBackground(void)
|
|
{
|
|
int height,xAdd,x2,y2,t;
|
|
// int prongLeftX,prongRightX;
|
|
float inTime = cg.invenSelectTime+WEAPON_SELECT_TIME;
|
|
float wpTime = cg.weaponSelectTime+WEAPON_SELECT_TIME;
|
|
float fpTime = cg.forceSelectTime+WEAPON_SELECT_TIME;
|
|
// int drawType = cgs.media.weaponIconBackground;
|
|
// int yOffset = 0;
|
|
|
|
#ifdef _XBOX
|
|
//yOffset = -50;
|
|
#endif
|
|
|
|
// don't display if dead
|
|
if ( cg.snap->ps.stats[STAT_HEALTH] <= 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (cg_hudFiles.integer)
|
|
{ //simple hud
|
|
return;
|
|
}
|
|
|
|
x2 = 30;
|
|
y2 = SCREEN_HEIGHT-70;
|
|
|
|
//prongLeftX =x2+37;
|
|
//prongRightX =x2+544;
|
|
|
|
if (inTime > wpTime)
|
|
{
|
|
// drawType = cgs.media.inventoryIconBackground;
|
|
cg.iconSelectTime = cg.invenSelectTime;
|
|
}
|
|
else
|
|
{
|
|
// drawType = cgs.media.weaponIconBackground;
|
|
cg.iconSelectTime = cg.weaponSelectTime;
|
|
}
|
|
|
|
if (fpTime > inTime && fpTime > wpTime)
|
|
{
|
|
// drawType = cgs.media.forceIconBackground;
|
|
cg.iconSelectTime = cg.forceSelectTime;
|
|
}
|
|
|
|
if ((cg.iconSelectTime+WEAPON_SELECT_TIME)<cg.time) // Time is up for the HUD to display
|
|
{
|
|
if (cg.iconHUDActive) // The time is up, but we still need to move the prongs back to their original position
|
|
{
|
|
t = cg.time - (cg.iconSelectTime+WEAPON_SELECT_TIME);
|
|
cg.iconHUDPercent = t/ 130.0f;
|
|
cg.iconHUDPercent = 1 - cg.iconHUDPercent;
|
|
|
|
if (cg.iconHUDPercent<0)
|
|
{
|
|
cg.iconHUDActive = qfalse;
|
|
cg.iconHUDPercent=0;
|
|
}
|
|
|
|
xAdd = (int) 8*cg.iconHUDPercent;
|
|
|
|
height = (int) (60.0f*cg.iconHUDPercent);
|
|
//CG_DrawPic( x2+60, y2+30+yOffset, 460, -height, drawType); // Top half
|
|
//CG_DrawPic( x2+60, y2+30-2+yOffset, 460, height, drawType); // Bottom half
|
|
|
|
}
|
|
else
|
|
{
|
|
xAdd = 0;
|
|
}
|
|
|
|
return;
|
|
}
|
|
//prongLeftX =x2+37;
|
|
//prongRightX =x2+544;
|
|
|
|
if (!cg.iconHUDActive)
|
|
{
|
|
t = cg.time - cg.iconSelectTime;
|
|
cg.iconHUDPercent = t/ 130.0f;
|
|
|
|
// Calc how far into opening sequence we are
|
|
if (cg.iconHUDPercent>1)
|
|
{
|
|
cg.iconHUDActive = qtrue;
|
|
cg.iconHUDPercent=1;
|
|
}
|
|
else if (cg.iconHUDPercent<0)
|
|
{
|
|
cg.iconHUDPercent=0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cg.iconHUDPercent=1;
|
|
}
|
|
|
|
//trap_R_SetColor( colorTable[CT_WHITE] );
|
|
//height = (int) (60.0f*cg.iconHUDPercent);
|
|
//CG_DrawPic( x2+60, y2+30+yOffset, 460, -height, drawType); // Top half
|
|
//CG_DrawPic( x2+60, y2+30-2+yOffset, 460, height, drawType); // Bottom half
|
|
|
|
// And now for the prongs
|
|
/* if ((cg.inventorySelectTime+WEAPON_SELECT_TIME)>cg.time)
|
|
{
|
|
cgs.media.currentBackground = ICON_INVENTORY;
|
|
background = &cgs.media.inventoryProngsOn;
|
|
}
|
|
else if ((cg.weaponSelectTime+WEAPON_SELECT_TIME)>cg.time)
|
|
{
|
|
cgs.media.currentBackground = ICON_WEAPONS;
|
|
}
|
|
else
|
|
{
|
|
cgs.media.currentBackground = ICON_FORCE;
|
|
background = &cgs.media.forceProngsOn;
|
|
}
|
|
*/
|
|
// Side Prongs
|
|
// trap_R_SetColor( colorTable[CT_WHITE]);
|
|
// xAdd = (int) 8*cg.iconHUDPercent;
|
|
// CG_DrawPic( prongLeftX+xAdd, y2-10, 40, 80, background);
|
|
// CG_DrawPic( prongRightX-xAdd, y2-10, -40, 80, background);
|
|
|
|
}
|
|
|
|
qboolean CG_WeaponCheck(int weap)
|
|
{
|
|
if (cg.snap->ps.ammo[weaponData[weap].ammoIndex] < weaponData[weap].energyPerShot &&
|
|
cg.snap->ps.ammo[weaponData[weap].ammoIndex] < weaponData[weap].altEnergyPerShot)
|
|
{
|
|
return qfalse;
|
|
}
|
|
|
|
return qtrue;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
CG_WeaponSelectable
|
|
===============
|
|
*/
|
|
static qboolean CG_WeaponSelectable( int i ) {
|
|
/*if ( !cg.snap->ps.ammo[weaponData[i].ammoIndex] ) {
|
|
return qfalse;
|
|
}*/
|
|
if (!i)
|
|
{
|
|
return qfalse;
|
|
}
|
|
|
|
if (cg.predictedPlayerState.ammo[weaponData[i].ammoIndex] < weaponData[i].energyPerShot &&
|
|
cg.predictedPlayerState.ammo[weaponData[i].ammoIndex] < weaponData[i].altEnergyPerShot)
|
|
{
|
|
return qfalse;
|
|
}
|
|
|
|
if (i == WP_DET_PACK && cg.predictedPlayerState.ammo[weaponData[i].ammoIndex] < 1 &&
|
|
!cg.predictedPlayerState.hasDetPackPlanted)
|
|
{
|
|
return qfalse;
|
|
}
|
|
|
|
if ( ! (cg.predictedPlayerState.stats[ STAT_WEAPONS ] & ( 1 << i ) ) ) {
|
|
return qfalse;
|
|
}
|
|
|
|
return qtrue;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
CG_DrawWeaponSelect
|
|
===================
|
|
*/
|
|
#ifdef _XBOX
|
|
extern bool CL_ExtendSelectTime(void);
|
|
#endif
|
|
void CG_DrawWeaponSelect( void ) {
|
|
int i;
|
|
int bits;
|
|
int count;
|
|
int smallIconSize,bigIconSize;
|
|
int holdX,x,y,pad;
|
|
int sideLeftIconCnt,sideRightIconCnt;
|
|
int sideMax,holdCount,iconCnt;
|
|
int height;
|
|
int yOffset = 0;
|
|
qboolean drewConc = qfalse;
|
|
|
|
if (cg.predictedPlayerState.emplacedIndex)
|
|
{ //can't cycle when on a weapon
|
|
cg.weaponSelectTime = 0;
|
|
}
|
|
|
|
if ((cg.weaponSelectTime+WEAPON_SELECT_TIME)<cg.time) // Time is up for the HUD to display
|
|
{
|
|
return;
|
|
}
|
|
|
|
// don't display if dead
|
|
if ( cg.predictedPlayerState.stats[STAT_HEALTH] <= 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
#ifdef _XBOX
|
|
if(CL_ExtendSelectTime()) {
|
|
cg.weaponSelectTime = cg.time;
|
|
}
|
|
|
|
yOffset = -50;
|
|
#endif
|
|
|
|
// showing weapon select clears pickup item display, but not the blend blob
|
|
cg.itemPickupTime = 0;
|
|
|
|
bits = cg.predictedPlayerState.stats[ STAT_WEAPONS ];
|
|
|
|
// count the number of weapons owned
|
|
count = 0;
|
|
|
|
if ( !CG_WeaponSelectable(cg.weaponSelect) &&
|
|
(cg.weaponSelect == WP_THERMAL || cg.weaponSelect == WP_TRIP_MINE) )
|
|
{ //display this weapon that we don't actually "have" as unhighlighted until it's deselected
|
|
//since it's selected we must increase the count to display the proper number of valid selectable weapons
|
|
count++;
|
|
}
|
|
|
|
for ( i = 1 ; i < WP_NUM_WEAPONS ; i++ )
|
|
{
|
|
if ( bits & ( 1 << i ) )
|
|
{
|
|
if ( CG_WeaponSelectable(i) ||
|
|
(i != WP_THERMAL && i != WP_TRIP_MINE) )
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (count == 0) // If no weapons, don't display
|
|
{
|
|
return;
|
|
}
|
|
|
|
sideMax = 3; // Max number of icons on the side
|
|
|
|
// Calculate how many icons will appear to either side of the center one
|
|
holdCount = count - 1; // -1 for the center icon
|
|
if (holdCount == 0) // No icons to either side
|
|
{
|
|
sideLeftIconCnt = 0;
|
|
sideRightIconCnt = 0;
|
|
}
|
|
else if (count > (2*sideMax)) // Go to the max on each side
|
|
{
|
|
sideLeftIconCnt = sideMax;
|
|
sideRightIconCnt = sideMax;
|
|
}
|
|
else // Less than max, so do the calc
|
|
{
|
|
sideLeftIconCnt = holdCount/2;
|
|
sideRightIconCnt = holdCount - sideLeftIconCnt;
|
|
}
|
|
|
|
if ( cg.weaponSelect == WP_CONCUSSION )
|
|
{
|
|
i = WP_FLECHETTE;
|
|
}
|
|
else
|
|
{
|
|
i = cg.weaponSelect - 1;
|
|
}
|
|
if (i<1)
|
|
{
|
|
i = LAST_USEABLE_WEAPON;
|
|
}
|
|
|
|
smallIconSize = 40;
|
|
bigIconSize = 80;
|
|
pad = 12;
|
|
|
|
x = 320;
|
|
y = 410;
|
|
|
|
// Background
|
|
// memcpy(calcColor, colorTable[CT_WHITE], sizeof(vec4_t));
|
|
// calcColor[3] = .35f;
|
|
// trap_R_SetColor( calcColor);
|
|
|
|
// Left side ICONS
|
|
trap_R_SetColor(colorTable[CT_WHITE]);
|
|
// Work backwards from current icon
|
|
holdX = x - ((bigIconSize/2) + pad + smallIconSize);
|
|
height = smallIconSize * 1;//cg.iconHUDPercent;
|
|
drewConc = qfalse;
|
|
|
|
for (iconCnt=1;iconCnt<(sideLeftIconCnt+1);i--)
|
|
{
|
|
if ( i == WP_CONCUSSION )
|
|
{
|
|
i--;
|
|
}
|
|
else if ( i == WP_FLECHETTE && !drewConc && cg.weaponSelect != WP_CONCUSSION )
|
|
{
|
|
i = WP_CONCUSSION;
|
|
}
|
|
if (i<1)
|
|
{
|
|
//i = 13;
|
|
//...don't ever do this.
|
|
i = LAST_USEABLE_WEAPON;
|
|
}
|
|
|
|
if ( !(bits & ( 1 << i ))) // Does he have this weapon?
|
|
{
|
|
if ( i == WP_CONCUSSION )
|
|
{
|
|
drewConc = qtrue;
|
|
i = WP_ROCKET_LAUNCHER;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if ( !CG_WeaponSelectable(i) &&
|
|
(i == WP_THERMAL || i == WP_TRIP_MINE) )
|
|
{ //Don't show thermal and tripmine when out of them
|
|
continue;
|
|
}
|
|
|
|
++iconCnt; // Good icon
|
|
|
|
if (cgs.media.weaponIcons[i])
|
|
{
|
|
weaponInfo_t *weaponInfo;
|
|
CG_RegisterWeapon( i );
|
|
weaponInfo = &cg_weapons[i];
|
|
|
|
trap_R_SetColor(colorTable[CT_WHITE]);
|
|
if (!CG_WeaponCheck(i))
|
|
{
|
|
CG_DrawPic( holdX, y+10+yOffset, smallIconSize, smallIconSize, /*weaponInfo->weaponIconNoAmmo*/cgs.media.weaponIcons_NA[i] );
|
|
}
|
|
else
|
|
{
|
|
CG_DrawPic( holdX, y+10+yOffset, smallIconSize, smallIconSize, /*weaponInfo->weaponIcon*/cgs.media.weaponIcons[i] );
|
|
}
|
|
|
|
holdX -= (smallIconSize+pad);
|
|
}
|
|
if ( i == WP_CONCUSSION )
|
|
{
|
|
drewConc = qtrue;
|
|
i = WP_ROCKET_LAUNCHER;
|
|
}
|
|
}
|
|
|
|
// Current Center Icon
|
|
height = bigIconSize * cg.iconHUDPercent;
|
|
if (cgs.media.weaponIcons[cg.weaponSelect])
|
|
{
|
|
weaponInfo_t *weaponInfo;
|
|
CG_RegisterWeapon( cg.weaponSelect );
|
|
weaponInfo = &cg_weapons[cg.weaponSelect];
|
|
|
|
trap_R_SetColor( colorTable[CT_WHITE]);
|
|
if (!CG_WeaponCheck(cg.weaponSelect))
|
|
{
|
|
CG_DrawPic( x-(bigIconSize/2), (y-((bigIconSize-smallIconSize)/2))+10+yOffset, bigIconSize, bigIconSize, cgs.media.weaponIcons_NA[cg.weaponSelect] );
|
|
}
|
|
else
|
|
{
|
|
CG_DrawPic( x-(bigIconSize/2), (y-((bigIconSize-smallIconSize)/2))+10+yOffset, bigIconSize, bigIconSize, cgs.media.weaponIcons[cg.weaponSelect] );
|
|
}
|
|
}
|
|
|
|
if ( cg.weaponSelect == WP_CONCUSSION )
|
|
{
|
|
i = WP_ROCKET_LAUNCHER;
|
|
}
|
|
else
|
|
{
|
|
i = cg.weaponSelect + 1;
|
|
}
|
|
if (i> LAST_USEABLE_WEAPON)
|
|
{
|
|
i = 1;
|
|
}
|
|
|
|
// Right side ICONS
|
|
// Work forwards from current icon
|
|
holdX = x + (bigIconSize/2) + pad;
|
|
height = smallIconSize * cg.iconHUDPercent;
|
|
for (iconCnt=1;iconCnt<(sideRightIconCnt+1);i++)
|
|
{
|
|
if ( i == WP_CONCUSSION )
|
|
{
|
|
i++;
|
|
}
|
|
else if ( i == WP_ROCKET_LAUNCHER && !drewConc && cg.weaponSelect != WP_CONCUSSION )
|
|
{
|
|
i = WP_CONCUSSION;
|
|
}
|
|
if (i>LAST_USEABLE_WEAPON)
|
|
{
|
|
i = 1;
|
|
}
|
|
|
|
if ( !(bits & ( 1 << i ))) // Does he have this weapon?
|
|
{
|
|
if ( i == WP_CONCUSSION )
|
|
{
|
|
drewConc = qtrue;
|
|
i = WP_FLECHETTE;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if ( !CG_WeaponSelectable(i) &&
|
|
(i == WP_THERMAL || i == WP_TRIP_MINE) )
|
|
{ //Don't show thermal and tripmine when out of them
|
|
continue;
|
|
}
|
|
|
|
++iconCnt; // Good icon
|
|
|
|
if (/*weaponData[i].weaponIcon[0]*/cgs.media.weaponIcons[i])
|
|
{
|
|
weaponInfo_t *weaponInfo;
|
|
CG_RegisterWeapon( i );
|
|
weaponInfo = &cg_weapons[i];
|
|
// No ammo for this weapon?
|
|
trap_R_SetColor( colorTable[CT_WHITE]);
|
|
if (!CG_WeaponCheck(i))
|
|
{
|
|
CG_DrawPic( holdX, y+10+yOffset, smallIconSize, smallIconSize, cgs.media.weaponIcons_NA[i] );
|
|
}
|
|
else
|
|
{
|
|
CG_DrawPic( holdX, y+10+yOffset, smallIconSize, smallIconSize, cgs.media.weaponIcons[i] );
|
|
}
|
|
|
|
|
|
holdX += (smallIconSize+pad);
|
|
}
|
|
if ( i == WP_CONCUSSION )
|
|
{
|
|
drewConc = qtrue;
|
|
i = WP_FLECHETTE;
|
|
}
|
|
}
|
|
|
|
// draw the selected name
|
|
if ( cg_weapons[ cg.weaponSelect ].item )
|
|
{
|
|
vec4_t textColor = { .875f, .718f, .121f, 1.0f };
|
|
char text[1024];
|
|
char upperKey[1024];
|
|
|
|
strcpy(upperKey, cg_weapons[ cg.weaponSelect ].item->classname);
|
|
|
|
if ( trap_SP_GetStringTextString( va("SP_INGAME_%s",Q_strupr(upperKey)), text, sizeof( text )))
|
|
{
|
|
UI_DrawProportionalString(320, y+45+yOffset, text, UI_CENTER|UI_SMALLFONT, textColor);
|
|
}
|
|
else
|
|
{
|
|
UI_DrawProportionalString(320, y+45+yOffset, cg_weapons[ cg.weaponSelect ].item->classname, UI_CENTER|UI_SMALLFONT, textColor);
|
|
}
|
|
}
|
|
|
|
trap_R_SetColor( NULL );
|
|
}
|
|
|
|
|
|
/*
|
|
===============
|
|
CG_NextWeapon_f
|
|
===============
|
|
*/
|
|
void CG_NextWeapon_f( void ) {
|
|
int i;
|
|
int original;
|
|
|
|
if ( !cg.snap ) {
|
|
return;
|
|
}
|
|
if ( cg.snap->ps.pm_flags & PMF_FOLLOW ) {
|
|
return;
|
|
}
|
|
|
|
if (cg.predictedPlayerState.pm_type == PM_SPECTATOR)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (cg.snap->ps.emplacedIndex)
|
|
{
|
|
return;
|
|
}
|
|
|
|
cg.weaponSelectTime = cg.time;
|
|
original = cg.weaponSelect;
|
|
|
|
for ( i = 0 ; i < WP_NUM_WEAPONS ; i++ ) {
|
|
//*SIGH*... Hack to put concussion rifle before rocketlauncher
|
|
if ( cg.weaponSelect == WP_FLECHETTE )
|
|
{
|
|
cg.weaponSelect = WP_CONCUSSION;
|
|
}
|
|
else if ( cg.weaponSelect == WP_CONCUSSION )
|
|
{
|
|
cg.weaponSelect = WP_ROCKET_LAUNCHER;
|
|
}
|
|
else if ( cg.weaponSelect == WP_DET_PACK )
|
|
{
|
|
cg.weaponSelect = WP_BRYAR_OLD;
|
|
}
|
|
else
|
|
{
|
|
cg.weaponSelect++;
|
|
}
|
|
if ( cg.weaponSelect == WP_NUM_WEAPONS ) {
|
|
cg.weaponSelect = 0;
|
|
}
|
|
// if ( cg.weaponSelect == WP_STUN_BATON ) {
|
|
// continue; // never cycle to gauntlet
|
|
// }
|
|
if ( CG_WeaponSelectable( cg.weaponSelect ) ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( i == WP_NUM_WEAPONS ) {
|
|
cg.weaponSelect = original;
|
|
}
|
|
else
|
|
{
|
|
trap_S_MuteSound(cg.snap->ps.clientNum, CHAN_WEAPON);
|
|
}
|
|
}
|
|
|
|
/*
|
|
===============
|
|
CG_PrevWeapon_f
|
|
===============
|
|
*/
|
|
void CG_PrevWeapon_f( void ) {
|
|
int i;
|
|
int original;
|
|
|
|
if ( !cg.snap ) {
|
|
return;
|
|
}
|
|
if ( cg.snap->ps.pm_flags & PMF_FOLLOW ) {
|
|
return;
|
|
}
|
|
|
|
if (cg.predictedPlayerState.pm_type == PM_SPECTATOR)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (cg.snap->ps.emplacedIndex)
|
|
{
|
|
return;
|
|
}
|
|
|
|
cg.weaponSelectTime = cg.time;
|
|
original = cg.weaponSelect;
|
|
|
|
for ( i = 0 ; i < WP_NUM_WEAPONS ; i++ ) {
|
|
//*SIGH*... Hack to put concussion rifle before rocketlauncher
|
|
if ( cg.weaponSelect == WP_ROCKET_LAUNCHER )
|
|
{
|
|
cg.weaponSelect = WP_CONCUSSION;
|
|
}
|
|
else if ( cg.weaponSelect == WP_CONCUSSION )
|
|
{
|
|
cg.weaponSelect = WP_FLECHETTE;
|
|
}
|
|
else if ( cg.weaponSelect == WP_BRYAR_OLD )
|
|
{
|
|
cg.weaponSelect = WP_DET_PACK;
|
|
}
|
|
else
|
|
{
|
|
cg.weaponSelect--;
|
|
}
|
|
if ( cg.weaponSelect == -1 ) {
|
|
cg.weaponSelect = WP_NUM_WEAPONS-1;
|
|
}
|
|
// if ( cg.weaponSelect == WP_STUN_BATON ) {
|
|
// continue; // never cycle to gauntlet
|
|
// }
|
|
if ( CG_WeaponSelectable( cg.weaponSelect ) ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( i == WP_NUM_WEAPONS ) {
|
|
cg.weaponSelect = original;
|
|
}
|
|
else
|
|
{
|
|
trap_S_MuteSound(cg.snap->ps.clientNum, CHAN_WEAPON);
|
|
}
|
|
}
|
|
|
|
/*
|
|
===============
|
|
CG_Weapon_f
|
|
===============
|
|
*/
|
|
void CG_Weapon_f( void ) {
|
|
int num;
|
|
|
|
if ( !cg.snap ) {
|
|
return;
|
|
}
|
|
if ( cg.snap->ps.pm_flags & PMF_FOLLOW ) {
|
|
return;
|
|
}
|
|
|
|
if (cg.snap->ps.emplacedIndex)
|
|
{
|
|
return;
|
|
}
|
|
|
|
num = atoi( CG_Argv( 1 ) );
|
|
|
|
if ( num < 1 || num > LAST_USEABLE_WEAPON ) {
|
|
return;
|
|
}
|
|
|
|
if (num == 1 && cg.snap->ps.weapon == WP_SABER)
|
|
{
|
|
if (cg.snap->ps.weaponTime < 1)
|
|
{
|
|
trap_SendConsoleCommand("sv_saberswitch\n");
|
|
}
|
|
return;
|
|
}
|
|
|
|
//rww - hack to make weapon numbers same as single player
|
|
if (num > WP_STUN_BATON)
|
|
{
|
|
//num++;
|
|
num += 2; //I suppose this is getting kind of crazy, what with the wp_melee in there too now.
|
|
}
|
|
else
|
|
{
|
|
if (cg.snap->ps.stats[STAT_WEAPONS] & (1 << WP_SABER))
|
|
{
|
|
num = WP_SABER;
|
|
}
|
|
else
|
|
{
|
|
num = WP_MELEE;
|
|
}
|
|
}
|
|
|
|
if (num > LAST_USEABLE_WEAPON+1)
|
|
{ //other weapons are off limits due to not actually being weapon weapons
|
|
return;
|
|
}
|
|
|
|
if (num >= WP_THERMAL && num <= WP_DET_PACK)
|
|
{
|
|
int weap, i = 0;
|
|
|
|
if (cg.snap->ps.weapon >= WP_THERMAL &&
|
|
cg.snap->ps.weapon <= WP_DET_PACK)
|
|
{
|
|
// already in cycle range so start with next cycle item
|
|
weap = cg.snap->ps.weapon + 1;
|
|
}
|
|
else
|
|
{
|
|
// not in cycle range, so start with thermal detonator
|
|
weap = WP_THERMAL;
|
|
}
|
|
|
|
// prevent an endless loop
|
|
while ( i <= 4 )
|
|
{
|
|
if (weap > WP_DET_PACK)
|
|
{
|
|
weap = WP_THERMAL;
|
|
}
|
|
|
|
if (CG_WeaponSelectable(weap))
|
|
{
|
|
num = weap;
|
|
break;
|
|
}
|
|
|
|
weap++;
|
|
i++;
|
|
}
|
|
}
|
|
|
|
if (!CG_WeaponSelectable(num))
|
|
{
|
|
return;
|
|
}
|
|
|
|
cg.weaponSelectTime = cg.time;
|
|
|
|
if ( ! ( cg.snap->ps.stats[STAT_WEAPONS] & ( 1 << num ) ) )
|
|
{
|
|
if (num == WP_SABER)
|
|
{ //don't have saber, try melee on the same slot
|
|
num = WP_MELEE;
|
|
|
|
if ( ! ( cg.snap->ps.stats[STAT_WEAPONS] & ( 1 << num ) ) )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return; // don't have the weapon
|
|
}
|
|
}
|
|
|
|
if (cg.weaponSelect != num)
|
|
{
|
|
trap_S_MuteSound(cg.snap->ps.clientNum, CHAN_WEAPON);
|
|
}
|
|
|
|
cg.weaponSelect = num;
|
|
}
|
|
|
|
|
|
//Version of the above which doesn't add +2 to a weapon. The above can't
|
|
//triger WP_MELEE or WP_STUN_BATON. Derogatory comments go here.
|
|
void CG_WeaponClean_f( void ) {
|
|
int num;
|
|
|
|
if ( !cg.snap ) {
|
|
return;
|
|
}
|
|
if ( cg.snap->ps.pm_flags & PMF_FOLLOW ) {
|
|
return;
|
|
}
|
|
|
|
if (cg.snap->ps.emplacedIndex)
|
|
{
|
|
return;
|
|
}
|
|
|
|
num = atoi( CG_Argv( 1 ) );
|
|
|
|
if ( num < 1 || num > LAST_USEABLE_WEAPON ) {
|
|
return;
|
|
}
|
|
|
|
if (num == 1 && cg.snap->ps.weapon == WP_SABER)
|
|
{
|
|
if (cg.snap->ps.weaponTime < 1)
|
|
{
|
|
trap_SendConsoleCommand("sv_saberswitch\n");
|
|
}
|
|
return;
|
|
}
|
|
|
|
if(num == WP_STUN_BATON) {
|
|
if (cg.snap->ps.stats[STAT_WEAPONS] & (1 << WP_SABER))
|
|
{
|
|
num = WP_SABER;
|
|
}
|
|
else
|
|
{
|
|
num = WP_MELEE;
|
|
}
|
|
}
|
|
|
|
if (num > LAST_USEABLE_WEAPON+1)
|
|
{ //other weapons are off limits due to not actually being weapon weapons
|
|
return;
|
|
}
|
|
|
|
if (num >= WP_THERMAL && num <= WP_DET_PACK)
|
|
{
|
|
int weap, i = 0;
|
|
|
|
if (cg.snap->ps.weapon >= WP_THERMAL &&
|
|
cg.snap->ps.weapon <= WP_DET_PACK)
|
|
{
|
|
// already in cycle range so start with next cycle item
|
|
weap = cg.snap->ps.weapon + 1;
|
|
}
|
|
else
|
|
{
|
|
// not in cycle range, so start with thermal detonator
|
|
weap = WP_THERMAL;
|
|
}
|
|
|
|
// prevent an endless loop
|
|
while ( i <= 4 )
|
|
{
|
|
if (weap > WP_DET_PACK)
|
|
{
|
|
weap = WP_THERMAL;
|
|
}
|
|
|
|
if (CG_WeaponSelectable(weap))
|
|
{
|
|
num = weap;
|
|
break;
|
|
}
|
|
|
|
weap++;
|
|
i++;
|
|
}
|
|
}
|
|
|
|
if (!CG_WeaponSelectable(num))
|
|
{
|
|
return;
|
|
}
|
|
|
|
cg.weaponSelectTime = cg.time;
|
|
|
|
if ( ! ( cg.snap->ps.stats[STAT_WEAPONS] & ( 1 << num ) ) )
|
|
{
|
|
if (num == WP_SABER)
|
|
{ //don't have saber, try melee on the same slot
|
|
num = WP_MELEE;
|
|
|
|
if ( ! ( cg.snap->ps.stats[STAT_WEAPONS] & ( 1 << num ) ) )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return; // don't have the weapon
|
|
}
|
|
}
|
|
|
|
if (cg.weaponSelect != num)
|
|
{
|
|
trap_S_MuteSound(cg.snap->ps.clientNum, CHAN_WEAPON);
|
|
}
|
|
|
|
cg.weaponSelect = num;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
===================
|
|
CG_OutOfAmmoChange
|
|
|
|
The current weapon has just run out of ammo
|
|
===================
|
|
*/
|
|
void CG_OutOfAmmoChange( int oldWeapon )
|
|
{
|
|
int i;
|
|
|
|
cg.weaponSelectTime = cg.time;
|
|
|
|
for ( i = LAST_USEABLE_WEAPON ; i > 0 ; i-- ) //We don't want the emplaced or turret
|
|
{
|
|
if ( CG_WeaponSelectable( i ) )
|
|
{
|
|
/*
|
|
if ( 1 == cg_autoswitch.integer &&
|
|
( i == WP_TRIP_MINE || i == WP_DET_PACK || i == WP_THERMAL || i == WP_ROCKET_LAUNCHER) ) // safe weapon switch
|
|
*/
|
|
//rww - Don't we want to make sure i != one of these if autoswitch is 1 (safe)?
|
|
if (cg_autoswitch.integer != 1 || (i != WP_TRIP_MINE && i != WP_DET_PACK && i != WP_THERMAL && i != WP_ROCKET_LAUNCHER))
|
|
{
|
|
if (i != oldWeapon)
|
|
{ //don't even do anything if we're just selecting the weapon we already have/had
|
|
cg.weaponSelect = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
trap_S_MuteSound(cg.snap->ps.clientNum, CHAN_WEAPON);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
===================================================================================================
|
|
|
|
WEAPON EVENTS
|
|
|
|
===================================================================================================
|
|
*/
|
|
|
|
void CG_GetClientWeaponMuzzleBoltPoint(int clIndex, vec3_t to)
|
|
{
|
|
centity_t *cent;
|
|
mdxaBone_t boltMatrix;
|
|
|
|
if (clIndex < 0 || clIndex >= MAX_CLIENTS)
|
|
{
|
|
return;
|
|
}
|
|
|
|
cent = &cg_entities[clIndex];
|
|
|
|
if (!cent || !cent->ghoul2 || !trap_G2_HaveWeGhoul2Models(cent->ghoul2) ||
|
|
!trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 1))
|
|
{
|
|
return;
|
|
}
|
|
|
|
trap_G2API_GetBoltMatrix(cent->ghoul2, 1, 0, &boltMatrix, cent->turAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
|
|
BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, to);
|
|
}
|
|
|
|
/*
|
|
================
|
|
CG_FireWeapon
|
|
|
|
Caused by an EV_FIRE_WEAPON event
|
|
================
|
|
*/
|
|
void CG_FireWeapon( centity_t *cent, qboolean altFire ) {
|
|
entityState_t *ent;
|
|
int c;
|
|
weaponInfo_t *weap;
|
|
|
|
ent = ¢->currentState;
|
|
if ( ent->weapon == WP_NONE ) {
|
|
return;
|
|
}
|
|
if ( ent->weapon >= WP_NUM_WEAPONS ) {
|
|
CG_Error( "CG_FireWeapon: ent->weapon >= WP_NUM_WEAPONS" );
|
|
return;
|
|
}
|
|
weap = &cg_weapons[ ent->weapon ];
|
|
|
|
// mark the entity as muzzle flashing, so when it is added it will
|
|
// append the flash to the weapon model
|
|
cent->muzzleFlashTime = cg.time;
|
|
|
|
if (cg.predictedPlayerState.clientNum == cent->currentState.number)
|
|
{
|
|
if ((ent->weapon == WP_BRYAR_PISTOL && altFire) ||
|
|
(ent->weapon == WP_BRYAR_OLD && altFire) ||
|
|
(ent->weapon == WP_BOWCASTER && !altFire) ||
|
|
(ent->weapon == WP_DEMP2 && altFire))
|
|
{
|
|
float val = ( cg.time - cent->currentState.constantLight ) * 0.001f;
|
|
|
|
if (val > 3)
|
|
{
|
|
val = 3;
|
|
}
|
|
if (val < 0.2)
|
|
{
|
|
val = 0.2;
|
|
}
|
|
|
|
val *= 2;
|
|
|
|
CGCam_Shake( val, 250 );
|
|
}
|
|
else if (ent->weapon == WP_ROCKET_LAUNCHER ||
|
|
(ent->weapon == WP_REPEATER && altFire) ||
|
|
ent->weapon == WP_FLECHETTE ||
|
|
(ent->weapon == WP_CONCUSSION && !altFire))
|
|
{
|
|
if (ent->weapon == WP_CONCUSSION)
|
|
{
|
|
if (!cg.renderingThirdPerson )//gives an advantage to being in 3rd person, but would look silly otherwise
|
|
{//kick the view back
|
|
cg.kick_angles[PITCH] = flrand( -10, -15 );
|
|
cg.kick_time = cg.time;
|
|
}
|
|
}
|
|
else if (ent->weapon == WP_ROCKET_LAUNCHER)
|
|
{
|
|
CGCam_Shake(flrand(2, 3), 350);
|
|
}
|
|
else if (ent->weapon == WP_REPEATER)
|
|
{
|
|
CGCam_Shake(flrand(2, 3), 350);
|
|
}
|
|
else if (ent->weapon == WP_FLECHETTE)
|
|
{
|
|
if (altFire)
|
|
{
|
|
CGCam_Shake(flrand(2, 3), 350);
|
|
}
|
|
else
|
|
{
|
|
CGCam_Shake(1.5, 250);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// lightning gun only does this this on initial press
|
|
if ( ent->weapon == WP_DEMP2 ) {
|
|
if ( cent->pe.lightningFiring ) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// play quad sound if needed
|
|
if ( cent->currentState.powerups & ( 1 << PW_QUAD ) ) {
|
|
//trap_S_StartSound (NULL, cent->currentState.number, CHAN_ITEM, cgs.media.quadSound );
|
|
}
|
|
|
|
|
|
// play a sound
|
|
if (altFire)
|
|
{
|
|
// play a sound
|
|
for ( c = 0 ; c < 4 ; c++ ) {
|
|
if ( !weap->altFlashSound[c] ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( c > 0 ) {
|
|
c = rand() % c;
|
|
if ( weap->altFlashSound[c] )
|
|
{
|
|
trap_S_StartSound( NULL, ent->number, CHAN_WEAPON, weap->altFlashSound[c] );
|
|
}
|
|
}
|
|
// if ( weap->altFlashSnd )
|
|
// {
|
|
// trap_S_StartSound( NULL, ent->number, CHAN_WEAPON, weap->altFlashSnd );
|
|
// }
|
|
}
|
|
else
|
|
{
|
|
// play a sound
|
|
for ( c = 0 ; c < 4 ; c++ ) {
|
|
if ( !weap->flashSound[c] ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( c > 0 ) {
|
|
c = rand() % c;
|
|
if ( weap->flashSound[c] )
|
|
{
|
|
trap_S_StartSound( NULL, ent->number, CHAN_WEAPON, weap->flashSound[c] );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
qboolean CG_VehicleWeaponImpact( centity_t *cent )
|
|
{//see if this is a missile entity that's owned by a vehicle and should do a special, overridden impact effect
|
|
if ((cent->currentState.eFlags&EF_JETPACK_ACTIVE)//hack so we know we're a vehicle Weapon shot
|
|
&& cent->currentState.otherEntityNum2
|
|
&& g_vehWeaponInfo[cent->currentState.otherEntityNum2].iImpactFX)
|
|
{//missile is from a special vehWeapon
|
|
vec3_t normal;
|
|
ByteToDir( cent->currentState.eventParm, normal );
|
|
|
|
trap_FX_PlayEffectID( g_vehWeaponInfo[cent->currentState.otherEntityNum2].iImpactFX, cent->lerpOrigin, normal, -1, -1 );
|
|
return qtrue;
|
|
}
|
|
return qfalse;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
CG_MissileHitWall
|
|
|
|
Caused by an EV_MISSILE_MISS event, or directly by local bullet tracing
|
|
=================
|
|
*/
|
|
void CG_MissileHitWall(int weapon, int clientNum, vec3_t origin, vec3_t dir, impactSound_t soundType, qboolean altFire, int charge)
|
|
{
|
|
int parm;
|
|
vec3_t up={0,0,1};
|
|
|
|
switch( weapon )
|
|
{
|
|
case WP_BRYAR_PISTOL:
|
|
if ( altFire )
|
|
{
|
|
parm = charge;
|
|
FX_BryarAltHitWall( origin, dir, parm );
|
|
}
|
|
else
|
|
{
|
|
FX_BryarHitWall( origin, dir );
|
|
}
|
|
break;
|
|
|
|
case WP_CONCUSSION:
|
|
FX_ConcussionHitWall( origin, dir );
|
|
break;
|
|
|
|
case WP_BRYAR_OLD:
|
|
if ( altFire )
|
|
{
|
|
parm = charge;
|
|
FX_BryarAltHitWall( origin, dir, parm );
|
|
}
|
|
else
|
|
{
|
|
FX_BryarHitWall( origin, dir );
|
|
}
|
|
break;
|
|
|
|
case WP_TURRET:
|
|
FX_TurretHitWall( origin, dir );
|
|
break;
|
|
|
|
case WP_BLASTER:
|
|
FX_BlasterWeaponHitWall( origin, dir );
|
|
break;
|
|
|
|
case WP_DISRUPTOR:
|
|
FX_DisruptorAltMiss( origin, dir );
|
|
break;
|
|
|
|
case WP_BOWCASTER:
|
|
FX_BowcasterHitWall( origin, dir );
|
|
break;
|
|
|
|
case WP_REPEATER:
|
|
if ( altFire )
|
|
{
|
|
FX_RepeaterAltHitWall( origin, dir );
|
|
}
|
|
else
|
|
{
|
|
FX_RepeaterHitWall( origin, dir );
|
|
}
|
|
break;
|
|
|
|
case WP_DEMP2:
|
|
if (altFire)
|
|
{
|
|
trap_FX_PlayEffectID(cgs.effects.mAltDetonate, origin, dir, -1, -1);
|
|
}
|
|
else
|
|
{
|
|
FX_DEMP2_HitWall( origin, dir );
|
|
}
|
|
break;
|
|
|
|
case WP_FLECHETTE:
|
|
/*if (altFire)
|
|
{
|
|
CG_SurfaceExplosion(origin, dir, 20.0f, 12.0f, qtrue);
|
|
}
|
|
else
|
|
*/
|
|
if (!altFire)
|
|
{
|
|
FX_FlechetteWeaponHitWall( origin, dir );
|
|
}
|
|
break;
|
|
|
|
case WP_ROCKET_LAUNCHER:
|
|
FX_RocketHitWall( origin, dir );
|
|
break;
|
|
|
|
case WP_THERMAL:
|
|
trap_FX_PlayEffectID( cgs.effects.thermalExplosionEffect, origin, dir, -1, -1 );
|
|
trap_FX_PlayEffectID( cgs.effects.thermalShockwaveEffect, origin, up, -1, -1 );
|
|
break;
|
|
|
|
case WP_EMPLACED_GUN:
|
|
FX_BlasterWeaponHitWall( origin, dir );
|
|
//FIXME: Give it its own hit wall effect
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
CG_MissileHitPlayer
|
|
=================
|
|
*/
|
|
void CG_MissileHitPlayer(int weapon, vec3_t origin, vec3_t dir, int entityNum, qboolean altFire)
|
|
{
|
|
qboolean humanoid = qtrue;
|
|
vec3_t up={0,0,1};
|
|
|
|
/*
|
|
// NOTENOTE Non-portable code from single player
|
|
if ( cent->gent )
|
|
{
|
|
other = &g_entities[cent->gent->s.otherEntityNum];
|
|
|
|
if ( other->client && other->client->playerTeam == TEAM_BOTS )
|
|
{
|
|
humanoid = qfalse;
|
|
}
|
|
}
|
|
*/
|
|
|
|
// NOTENOTE No bleeding in this game
|
|
// CG_Bleed( origin, entityNum );
|
|
|
|
// some weapons will make an explosion with the blood, while
|
|
// others will just make the blood
|
|
switch ( weapon ) {
|
|
case WP_BRYAR_PISTOL:
|
|
if ( altFire )
|
|
{
|
|
FX_BryarAltHitPlayer( origin, dir, humanoid );
|
|
}
|
|
else
|
|
{
|
|
FX_BryarHitPlayer( origin, dir, humanoid );
|
|
}
|
|
break;
|
|
|
|
case WP_CONCUSSION:
|
|
FX_ConcussionHitPlayer( origin, dir, humanoid );
|
|
break;
|
|
|
|
case WP_BRYAR_OLD:
|
|
if ( altFire )
|
|
{
|
|
FX_BryarAltHitPlayer( origin, dir, humanoid );
|
|
}
|
|
else
|
|
{
|
|
FX_BryarHitPlayer( origin, dir, humanoid );
|
|
}
|
|
break;
|
|
|
|
case WP_TURRET:
|
|
FX_TurretHitPlayer( origin, dir, humanoid );
|
|
break;
|
|
|
|
case WP_BLASTER:
|
|
FX_BlasterWeaponHitPlayer( origin, dir, humanoid );
|
|
break;
|
|
|
|
case WP_DISRUPTOR:
|
|
FX_DisruptorAltHit( origin, dir);
|
|
break;
|
|
|
|
case WP_BOWCASTER:
|
|
FX_BowcasterHitPlayer( origin, dir, humanoid );
|
|
break;
|
|
|
|
case WP_REPEATER:
|
|
if ( altFire )
|
|
{
|
|
FX_RepeaterAltHitPlayer( origin, dir, humanoid );
|
|
}
|
|
else
|
|
{
|
|
FX_RepeaterHitPlayer( origin, dir, humanoid );
|
|
}
|
|
break;
|
|
|
|
case WP_DEMP2:
|
|
// Do a full body effect here for some more feedback
|
|
// NOTENOTE The chaining of the demp2 is not yet implemented.
|
|
/*
|
|
if ( other )
|
|
{
|
|
other->s.powerups |= ( 1 << PW_DISINT_1 );
|
|
other->client->ps.powerups[PW_DISINT_1] = cg.time + 650;
|
|
}
|
|
*/
|
|
if (altFire)
|
|
{
|
|
trap_FX_PlayEffectID(cgs.effects.mAltDetonate, origin, dir, -1, -1);
|
|
}
|
|
else
|
|
{
|
|
FX_DEMP2_HitPlayer( origin, dir, humanoid );
|
|
}
|
|
break;
|
|
|
|
case WP_FLECHETTE:
|
|
FX_FlechetteWeaponHitPlayer( origin, dir, humanoid );
|
|
break;
|
|
|
|
case WP_ROCKET_LAUNCHER:
|
|
FX_RocketHitPlayer( origin, dir, humanoid );
|
|
break;
|
|
|
|
case WP_THERMAL:
|
|
trap_FX_PlayEffectID( cgs.effects.thermalExplosionEffect, origin, dir, -1, -1 );
|
|
trap_FX_PlayEffectID( cgs.effects.thermalShockwaveEffect, origin, up, -1, -1 );
|
|
break;
|
|
case WP_EMPLACED_GUN:
|
|
//FIXME: Its own effect?
|
|
FX_BlasterWeaponHitPlayer( origin, dir, humanoid );
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
============================================================================
|
|
|
|
BULLETS
|
|
|
|
============================================================================
|
|
*/
|
|
|
|
|
|
/*
|
|
======================
|
|
CG_CalcMuzzlePoint
|
|
======================
|
|
*/
|
|
qboolean CG_CalcMuzzlePoint( int entityNum, vec3_t muzzle ) {
|
|
vec3_t forward, right;
|
|
vec3_t gunpoint;
|
|
centity_t *cent;
|
|
int anim;
|
|
|
|
if ( entityNum == cg.snap->ps.clientNum )
|
|
{ //I'm not exactly sure why we'd be rendering someone else's crosshair, but hey.
|
|
int weapontype = cg.snap->ps.weapon;
|
|
vec3_t weaponMuzzle;
|
|
centity_t *pEnt = &cg_entities[cg.predictedPlayerState.clientNum];
|
|
|
|
VectorCopy(WP_MuzzlePoint[weapontype], weaponMuzzle);
|
|
|
|
if (weapontype == WP_DISRUPTOR || weapontype == WP_STUN_BATON || weapontype == WP_MELEE || weapontype == WP_SABER)
|
|
{
|
|
VectorClear(weaponMuzzle);
|
|
}
|
|
|
|
if (cg.renderingThirdPerson)
|
|
{
|
|
VectorCopy( pEnt->lerpOrigin, gunpoint );
|
|
AngleVectors( pEnt->lerpAngles, forward, right, NULL );
|
|
}
|
|
else
|
|
{
|
|
VectorCopy( cg.refdef.vieworg, gunpoint );
|
|
AngleVectors( cg.refdef.viewangles, forward, right, NULL );
|
|
}
|
|
|
|
if (weapontype == WP_EMPLACED_GUN && cg.snap->ps.emplacedIndex)
|
|
{
|
|
centity_t *gunEnt = &cg_entities[cg.snap->ps.emplacedIndex];
|
|
|
|
if (gunEnt)
|
|
{
|
|
vec3_t pitchConstraint;
|
|
|
|
VectorCopy(gunEnt->lerpOrigin, gunpoint);
|
|
gunpoint[2] += 46;
|
|
|
|
if (cg.renderingThirdPerson)
|
|
{
|
|
VectorCopy(pEnt->lerpAngles, pitchConstraint);
|
|
}
|
|
else
|
|
{
|
|
VectorCopy(cg.refdef.viewangles, pitchConstraint);
|
|
}
|
|
|
|
if (pitchConstraint[PITCH] > 40)
|
|
{
|
|
pitchConstraint[PITCH] = 40;
|
|
}
|
|
AngleVectors( pitchConstraint, forward, right, NULL );
|
|
}
|
|
}
|
|
|
|
VectorCopy(gunpoint, muzzle);
|
|
|
|
VectorMA(muzzle, weaponMuzzle[0], forward, muzzle);
|
|
VectorMA(muzzle, weaponMuzzle[1], right, muzzle);
|
|
|
|
if (weapontype == WP_EMPLACED_GUN && cg.snap->ps.emplacedIndex)
|
|
{
|
|
//Do nothing
|
|
}
|
|
else if (cg.renderingThirdPerson)
|
|
{
|
|
muzzle[2] += cg.snap->ps.viewheight + weaponMuzzle[2];
|
|
}
|
|
else
|
|
{
|
|
muzzle[2] += weaponMuzzle[2];
|
|
}
|
|
|
|
return qtrue;
|
|
}
|
|
|
|
cent = &cg_entities[entityNum];
|
|
if ( !cent->currentValid ) {
|
|
return qfalse;
|
|
}
|
|
|
|
VectorCopy( cent->currentState.pos.trBase, muzzle );
|
|
|
|
AngleVectors( cent->currentState.apos.trBase, forward, NULL, NULL );
|
|
anim = cent->currentState.legsAnim;
|
|
if ( anim == BOTH_CROUCH1WALK || anim == BOTH_CROUCH1IDLE ) {
|
|
muzzle[2] += CROUCH_VIEWHEIGHT;
|
|
} else {
|
|
muzzle[2] += DEFAULT_VIEWHEIGHT;
|
|
}
|
|
|
|
VectorMA( muzzle, 14, forward, muzzle );
|
|
|
|
return qtrue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
|
|
// create one instance of all the weapons we are going to use so we can just copy this info into each clients gun ghoul2 object in fast way
|
|
static void *g2WeaponInstances[MAX_WEAPONS];
|
|
|
|
void CG_InitG2Weapons(void)
|
|
{
|
|
int i = 0;
|
|
gitem_t *item;
|
|
memset(g2WeaponInstances, 0, sizeof(g2WeaponInstances));
|
|
for ( item = bg_itemlist + 1 ; item->classname ; item++ )
|
|
{
|
|
if ( item->giType == IT_WEAPON )
|
|
{
|
|
assert(item->giTag < MAX_WEAPONS);
|
|
|
|
// initialise model
|
|
trap_G2API_InitGhoul2Model(&g2WeaponInstances[/*i*/item->giTag], item->world_model[0], 0, 0, 0, 0, 0);
|
|
// trap_G2API_InitGhoul2Model(&g2WeaponInstances[i], item->world_model[0],G_ModelIndex( item->world_model[0] ) , 0, 0, 0, 0);
|
|
if (g2WeaponInstances[/*i*/item->giTag])
|
|
{
|
|
// indicate we will be bolted to model 0 (ie the player) on bolt 0 (always the right hand) when we get copied
|
|
trap_G2API_SetBoltInfo(g2WeaponInstances[/*i*/item->giTag], 0, 0);
|
|
// now set up the gun bolt on it
|
|
if (item->giTag == WP_SABER)
|
|
{
|
|
trap_G2API_AddBolt(g2WeaponInstances[/*i*/item->giTag], 0, "*blade1");
|
|
}
|
|
else
|
|
{
|
|
trap_G2API_AddBolt(g2WeaponInstances[/*i*/item->giTag], 0, "*flash");
|
|
}
|
|
i++;
|
|
}
|
|
if (i == MAX_WEAPONS)
|
|
{
|
|
assert(0);
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
// clean out any g2 models we instanciated for copying purposes
|
|
void CG_ShutDownG2Weapons(void)
|
|
{
|
|
int i;
|
|
for (i=0; i<MAX_WEAPONS; i++)
|
|
{
|
|
trap_G2API_CleanGhoul2Models(&g2WeaponInstances[i]);
|
|
}
|
|
}
|
|
|
|
void *CG_G2WeaponInstance(centity_t *cent, int weapon)
|
|
{
|
|
clientInfo_t *ci = NULL;
|
|
|
|
if (weapon != WP_SABER)
|
|
{
|
|
return g2WeaponInstances[weapon];
|
|
}
|
|
|
|
if (cent->currentState.eType != ET_PLAYER &&
|
|
cent->currentState.eType != ET_NPC)
|
|
{
|
|
return g2WeaponInstances[weapon];
|
|
}
|
|
|
|
if (cent->currentState.eType == ET_NPC)
|
|
{
|
|
ci = cent->npcClient;
|
|
}
|
|
else
|
|
{
|
|
ci = &cgs.clientinfo[cent->currentState.number];
|
|
}
|
|
|
|
if (!ci)
|
|
{
|
|
return g2WeaponInstances[weapon];
|
|
}
|
|
|
|
//Try to return the custom saber instance if we can.
|
|
if (ci->saber[0].model[0] &&
|
|
ci->ghoul2Weapons[0])
|
|
{
|
|
return ci->ghoul2Weapons[0];
|
|
}
|
|
|
|
//If no custom then just use the default.
|
|
return g2WeaponInstances[weapon];
|
|
}
|
|
|
|
// what ghoul2 model do we want to copy ?
|
|
void CG_CopyG2WeaponInstance(centity_t *cent, int weaponNum, void *toGhoul2)
|
|
{
|
|
//rww - the -1 is because there is no "weapon" for WP_NONE
|
|
assert(weaponNum < MAX_WEAPONS);
|
|
if (CG_G2WeaponInstance(cent, weaponNum/*-1*/))
|
|
{
|
|
if (weaponNum == WP_SABER)
|
|
{
|
|
clientInfo_t *ci = NULL;
|
|
|
|
if (cent->currentState.eType == ET_NPC)
|
|
{
|
|
ci = cent->npcClient;
|
|
}
|
|
else
|
|
{
|
|
ci = &cgs.clientinfo[cent->currentState.number];
|
|
}
|
|
|
|
if (!ci)
|
|
{
|
|
trap_G2API_CopySpecificGhoul2Model(CG_G2WeaponInstance(cent, weaponNum/*-1*/), 0, toGhoul2, 1);
|
|
}
|
|
else
|
|
{ //Try both the left hand saber and the right hand saber
|
|
int i = 0;
|
|
|
|
while (i < MAX_SABERS)
|
|
{
|
|
if (ci->saber[i].model[0] &&
|
|
ci->ghoul2Weapons[i])
|
|
{
|
|
trap_G2API_CopySpecificGhoul2Model(ci->ghoul2Weapons[i], 0, toGhoul2, i+1);
|
|
}
|
|
else if (ci->ghoul2Weapons[i])
|
|
{ //if the second saber has been removed, then be sure to remove it and free the instance.
|
|
qboolean g2HasSecondSaber = trap_G2API_HasGhoul2ModelOnIndex(&(toGhoul2), 2);
|
|
|
|
if (g2HasSecondSaber)
|
|
{ //remove it now since we're switching away from sabers
|
|
trap_G2API_RemoveGhoul2Model(&(toGhoul2), 2);
|
|
}
|
|
trap_G2API_CleanGhoul2Models(&ci->ghoul2Weapons[i]);
|
|
}
|
|
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
qboolean g2HasSecondSaber = trap_G2API_HasGhoul2ModelOnIndex(&(toGhoul2), 2);
|
|
|
|
if (g2HasSecondSaber)
|
|
{ //remove it now since we're switching away from sabers
|
|
trap_G2API_RemoveGhoul2Model(&(toGhoul2), 2);
|
|
}
|
|
|
|
if (weaponNum == WP_EMPLACED_GUN)
|
|
{ //a bit of a hack to remove gun model when using an emplaced weap
|
|
if (trap_G2API_HasGhoul2ModelOnIndex(&(toGhoul2), 1))
|
|
{
|
|
trap_G2API_RemoveGhoul2Model(&(toGhoul2), 1);
|
|
}
|
|
}
|
|
else if (weaponNum == WP_MELEE)
|
|
{ //don't want a weapon on the model for this one
|
|
if (trap_G2API_HasGhoul2ModelOnIndex(&(toGhoul2), 1))
|
|
{
|
|
trap_G2API_RemoveGhoul2Model(&(toGhoul2), 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
trap_G2API_CopySpecificGhoul2Model(CG_G2WeaponInstance(cent, weaponNum/*-1*/), 0, toGhoul2, 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CG_CheckPlayerG2Weapons(playerState_t *ps, centity_t *cent)
|
|
{
|
|
if (!ps)
|
|
{
|
|
assert(0);
|
|
return;
|
|
}
|
|
|
|
if (ps->pm_flags & PMF_FOLLOW)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (cent->currentState.eType == ET_NPC)
|
|
{
|
|
assert(0);
|
|
return;
|
|
}
|
|
|
|
// should we change the gun model on this player?
|
|
if (cent->currentState.saberInFlight)
|
|
{
|
|
cent->ghoul2weapon = CG_G2WeaponInstance(cent, WP_SABER);
|
|
}
|
|
|
|
if (cent->currentState.eFlags & EF_DEAD)
|
|
{ //no updating weapons when dead
|
|
cent->ghoul2weapon = NULL;
|
|
return;
|
|
}
|
|
|
|
if (cent->torsoBolt)
|
|
{ //got our limb cut off, no updating weapons until it's restored
|
|
cent->ghoul2weapon = NULL;
|
|
return;
|
|
}
|
|
|
|
if (cgs.clientinfo[ps->clientNum].team == TEAM_SPECTATOR ||
|
|
ps->persistant[PERS_TEAM] == TEAM_SPECTATOR)
|
|
{
|
|
cent->ghoul2weapon = cg_entities[ps->clientNum].ghoul2weapon = NULL;
|
|
cent->weapon = cg_entities[ps->clientNum].weapon = 0;
|
|
return;
|
|
}
|
|
|
|
if (cent->ghoul2 && cent->ghoul2weapon != CG_G2WeaponInstance(cent, ps->weapon) &&
|
|
ps->clientNum == cent->currentState.number) //don't want spectator mode forcing one client's weapon instance over another's
|
|
{
|
|
CG_CopyG2WeaponInstance(cent, ps->weapon, cent->ghoul2);
|
|
cent->ghoul2weapon = CG_G2WeaponInstance(cent, ps->weapon);
|
|
if (cent->weapon == WP_SABER && cent->weapon != ps->weapon && !ps->saberHolstered)
|
|
{ //switching away from the saber
|
|
//trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, trap_S_RegisterSound( "sound/weapons/saber/saberoffquick.wav" ));
|
|
if (cgs.clientinfo[ps->clientNum].saber[0].soundOff && !ps->saberHolstered)
|
|
{
|
|
trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, cgs.clientinfo[ps->clientNum].saber[0].soundOff);
|
|
}
|
|
|
|
if (cgs.clientinfo[ps->clientNum].saber[1].soundOff &&
|
|
cgs.clientinfo[ps->clientNum].saber[1].model[0] &&
|
|
!ps->saberHolstered)
|
|
{
|
|
trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, cgs.clientinfo[ps->clientNum].saber[1].soundOff);
|
|
}
|
|
}
|
|
else if (ps->weapon == WP_SABER && cent->weapon != ps->weapon && !cent->saberWasInFlight)
|
|
{ //switching to the saber
|
|
//trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, trap_S_RegisterSound( "sound/weapons/saber/saberon.wav" ));
|
|
if (cgs.clientinfo[ps->clientNum].saber[0].soundOn)
|
|
{
|
|
trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, cgs.clientinfo[ps->clientNum].saber[0].soundOn);
|
|
}
|
|
|
|
if (cgs.clientinfo[ps->clientNum].saber[1].soundOn)
|
|
{
|
|
trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, cgs.clientinfo[ps->clientNum].saber[1].soundOn);
|
|
}
|
|
|
|
BG_SI_SetDesiredLength(&cgs.clientinfo[ps->clientNum].saber[0], 0, -1);
|
|
BG_SI_SetDesiredLength(&cgs.clientinfo[ps->clientNum].saber[1], 0, -1);
|
|
}
|
|
cent->weapon = ps->weapon;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|