int ReflectionLevel(gentity_t*player)
{ //handles all the behavior needed to saber block a blaster bolt.
if(!player || !player->client)
return FORCE_LEVEL_0;
//create the bolt saber block effect
//determine reflection level.
if((BG_SaberInAttack(player->client->ps.saberMove)
|| PM_SaberInStart(player->client->ps.saberMove)
|| PM_SaberInReturn(player->client->ps.saberMove))
&& Q_irand(0, 99) < ManualBoltReflectRate[player->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE]])
{ //manual reflection, bounce to the crosshair, roughly
return FORCE_LEVEL_3;
//otherDefLevel = FORCE_LEVEL_3;
}
else if(Q_irand(0, 99) < NaturalBoltReflectRate[player->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE]])
{ //natural reflection, bounce back to the attacker.
return FORCE_LEVEL_2;
}
else
{ //just deflect the attack
return FORCE_LEVEL_1;
//otherDefLevel = FORCE_LEVEL_1;
}
}
//This void is a mix of requirements to meet for the emote to work, and the custom emote animation itself.
void cm_TheEmote(int animation, gentity_t *ent, qboolean freeze)
{
//OpenRP - Emote + /me support
void G_Say(gentity_t *ent, gentity_t *target, int mode, const char *chatText);
char *msg = ConcatArgs(1);
if (ent->client->sess.spectatorState == SPECTATOR_FOLLOW || ent->client->sess.spectatorState == SPECTATOR_FREE) {
return;
}
if (ent->client->ps.groundEntityNum == ENTITYNUM_NONE){
return;
}
if (ent->client->ps.saberHolstered < 2){
ent->client->ps.saberHolstered = 2;
}
if (BG_SaberInAttack(ent->client->ps.saberMove) || BG_SaberInSpecialAttack(ent->client->ps.saberMove) || ent->client->ps.saberLockTime){
return;
}
if (freeze == qtrue)
{
if (ent->client->ps.forceDodgeAnim == animation)
{
//ent->client->emote_freeze=0;
ent->client->ps.saberCanThrow = qtrue;
ent->client->ps.forceDodgeAnim = 0;
ent->client->ps.forceHandExtendTime = 0;
}
else
{
ent->client->ps.forceHandExtend = HANDEXTEND_TAUNT;
ent->client->ps.forceDodgeAnim = animation;
ent->client->ps.forceHandExtendTime = level.time + Q3_INFINITE;
//ent->client->ps.persistant[PERS_REGEN] = 1;
ent->client->ps.saberCanThrow = qfalse;
//ent->client->emote_freeze=1;
}
}
else
{
StandardSetBodyAnim(ent, animation, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD | SETANIM_FLAG_HOLDLESS);
}
//OpenRP - Emote + /me support
if (trap->Argc() >= 2)
G_Say(ent, NULL, SAY_ME, msg);
trap->SendServerCommand(ent - g_entities, "print \"^3Note: Use the emote's command again to get out of the emote.\n\"");
return;
}
/*
==============
ClientThink
This will be called once for each client frame, which will
usually be a couple times for each server frame on fast clients.
If "g_synchronousClients 1" is set, this will be called exactly
once for each server frame, which makes for smooth demo recording.
==============
*/
void ClientThink_real( gentity_t *ent ) {
gclient_t *client;
pmove_t pm;
int oldEventSequence;
int msec;
int i;
usercmd_t *ucmd;
client = ent->client;
// don't think if the client is not yet connected (and thus not yet spawned in)
if (client->pers.connected != CON_CONNECTED) {
return;
}
// mark the time, so the connection sprite can be removed
ucmd = &ent->client->pers.cmd;
// sanity check the command time to prevent speedup cheating
if ( ucmd->serverTime > level.time + 200 ) {
ucmd->serverTime = level.time + 200;
// G_Printf("serverTime <<<<<\n" );
}
if ( ucmd->serverTime < level.time - 1000 ) {
ucmd->serverTime = level.time - 1000;
// G_Printf("serverTime >>>>>\n" );
}
msec = ucmd->serverTime - client->ps.commandTime;
// following others may result in bad times, but we still want
// to check for follow toggles
if ( msec < 1 && client->sess.spectatorState != SPECTATOR_FOLLOW ) {
return;
}
if ( msec > 200 ) {
msec = 200;
}
if ( pmove_msec.integer < 8 ) {
trap_Cvar_Set("pmove_msec", "8");
}
else if (pmove_msec.integer > 33) {
trap_Cvar_Set("pmove_msec", "33");
}
if ( pmove_fixed.integer || client->pers.pmoveFixed ) {
ucmd->serverTime = ((ucmd->serverTime + pmove_msec.integer-1) / pmove_msec.integer) * pmove_msec.integer;
//if (ucmd->serverTime - client->ps.commandTime <= 0)
// return;
}
//
// check for exiting intermission
//
if ( level.intermissiontime ) {
ClientIntermissionThink( client );
return;
}
// spectators don't do much
if ( client->sess.sessionTeam == TEAM_SPECTATOR ) {
if ( client->sess.spectatorState == SPECTATOR_SCOREBOARD ) {
return;
}
SpectatorThink( ent, ucmd );
return;
}
if (ent && ent->client && (ent->client->ps.eFlags & EF_INVULNERABLE))
{
if (ent->client->invulnerableTimer <= level.time)
{
ent->client->ps.eFlags &= ~EF_INVULNERABLE;
}
}
// check for inactivity timer, but never drop the local client of a non-dedicated server
if ( !ClientInactivityTimer( client ) ) {
return;
}
// clear the rewards if time
if ( level.time > client->rewardTime ) {
client->ps.eFlags &= ~(EF_AWARD_IMPRESSIVE | EF_AWARD_EXCELLENT | EF_AWARD_GAUNTLET | EF_AWARD_ASSIST | EF_AWARD_DEFEND | EF_AWARD_CAP );
}
if ( client->noclip ) {
client->ps.pm_type = PM_NOCLIP;
} else if ( client->ps.eFlags & EF_DISINTEGRATION ) {
client->ps.pm_type = PM_NOCLIP;
} else if ( client->ps.stats[STAT_HEALTH] <= 0 ) {
client->ps.pm_type = PM_DEAD;
} else {
if (client->ps.forceGripChangeMovetype)
{
client->ps.pm_type = client->ps.forceGripChangeMovetype;
}
else
{
client->ps.pm_type = PM_NORMAL;
}
}
client->ps.gravity = g_gravity.value;
// set speed
client->ps.speed = g_speed.value;
client->ps.basespeed = g_speed.value;
if (ent->client->ps.duelInProgress)
{
gentity_t *duelAgainst = &g_entities[ent->client->ps.duelIndex];
//Keep the time updated, so once this duel ends this player can't engage in a duel for another
//10 seconds. This will give other people a chance to engage in duels in case this player wants
//to engage again right after he's done fighting and someone else is waiting.
ent->client->ps.fd.privateDuelTime = level.time + 10000;
if (ent->client->ps.duelTime < level.time)
{
//Bring out the sabers
if (ent->client->ps.weapon == WP_SABER && ent->client->ps.saberHolstered &&
ent->client->ps.duelTime)
{
if (!saberOffSound || !saberOnSound)
{
saberOffSound = G_SoundIndex("sound/weapons/saber/saberoffquick.wav");
saberOnSound = G_SoundIndex("sound/weapons/saber/saberon.wav");
}
ent->client->ps.saberHolstered = qfalse;
G_Sound(ent, CHAN_AUTO, saberOnSound);
G_AddEvent(ent, EV_PRIVATE_DUEL, 2);
ent->client->ps.duelTime = 0;
}
if (duelAgainst && duelAgainst->client && duelAgainst->inuse &&
duelAgainst->client->ps.weapon == WP_SABER && duelAgainst->client->ps.saberHolstered &&
duelAgainst->client->ps.duelTime)
{
if (!saberOffSound || !saberOnSound)
{
saberOffSound = G_SoundIndex("sound/weapons/saber/saberoffquick.wav");
saberOnSound = G_SoundIndex("sound/weapons/saber/saberon.wav");
}
duelAgainst->client->ps.saberHolstered = qfalse;
G_Sound(duelAgainst, CHAN_AUTO, saberOnSound);
G_AddEvent(duelAgainst, EV_PRIVATE_DUEL, 2);
duelAgainst->client->ps.duelTime = 0;
}
}
else
{
client->ps.speed = 0;
client->ps.basespeed = 0;
ucmd->forwardmove = 0;
ucmd->rightmove = 0;
ucmd->upmove = 0;
}
if (!duelAgainst || !duelAgainst->client || !duelAgainst->inuse ||
duelAgainst->client->ps.duelIndex != ent->s.number)
{
ent->client->ps.duelInProgress = 0;
G_AddEvent(ent, EV_PRIVATE_DUEL, 0);
}
else if (duelAgainst->health < 1 || duelAgainst->client->ps.stats[STAT_HEALTH] < 1)
{
ent->client->ps.duelInProgress = 0;
duelAgainst->client->ps.duelInProgress = 0;
G_AddEvent(ent, EV_PRIVATE_DUEL, 0);
G_AddEvent(duelAgainst, EV_PRIVATE_DUEL, 0);
//Winner gets full health.. providing he's still alive
if (ent->health > 0 && ent->client->ps.stats[STAT_HEALTH] > 0)
{
if (ent->health < ent->client->ps.stats[STAT_MAX_HEALTH])
{
ent->client->ps.stats[STAT_HEALTH] = ent->health = ent->client->ps.stats[STAT_MAX_HEALTH];
}
if (g_spawnInvulnerability.integer)
{
ent->client->ps.eFlags |= EF_INVULNERABLE;
ent->client->invulnerableTimer = level.time + g_spawnInvulnerability.integer;
}
}
/*
trap_SendServerCommand( ent-g_entities, va("print \"%s %s\n\"", ent->client->pers.netname, G_GetStripEdString("SVINGAME", "PLDUELWINNER")) );
trap_SendServerCommand( duelAgainst-g_entities, va("print \"%s %s\n\"", ent->client->pers.netname, G_GetStripEdString("SVINGAME", "PLDUELWINNER")) );
*/
//Private duel announcements are now made globally because we only want one duel at a time.
if (ent->health > 0 && ent->client->ps.stats[STAT_HEALTH] > 0)
{
trap_SendServerCommand( -1, va("cp \"%s %s %s!\n\"", ent->client->pers.netname, G_GetStripEdString("SVINGAME", "PLDUELWINNER"), duelAgainst->client->pers.netname) );
}
else
{ //it was a draw, because we both managed to die in the same frame
trap_SendServerCommand( -1, va("cp \"%s\n\"", G_GetStripEdString("SVINGAME", "PLDUELTIE")) );
}
}
else
{
vec3_t vSub;
float subLen = 0;
VectorSubtract(ent->client->ps.origin, duelAgainst->client->ps.origin, vSub);
subLen = VectorLength(vSub);
if (subLen >= 1024)
{
ent->client->ps.duelInProgress = 0;
duelAgainst->client->ps.duelInProgress = 0;
G_AddEvent(ent, EV_PRIVATE_DUEL, 0);
G_AddEvent(duelAgainst, EV_PRIVATE_DUEL, 0);
trap_SendServerCommand( -1, va("print \"%s\n\"", G_GetStripEdString("SVINGAME", "PLDUELSTOP")) );
}
}
}
/*
if ( client->ps.powerups[PW_HASTE] ) {
client->ps.speed *= 1.3;
}
*/
if (client->ps.usingATST && ent->health > 0)
{ //we have special shot clip boxes as an ATST
ent->r.contents |= CONTENTS_NOSHOT;
ATST_ManageDamageBoxes(ent);
}
else
{
ent->r.contents &= ~CONTENTS_NOSHOT;
client->damageBoxHandle_Head = 0;
client->damageBoxHandle_RLeg = 0;
client->damageBoxHandle_LLeg = 0;
}
//rww - moved this stuff into the pmove code so that it's predicted properly
//BG_AdjustClientSpeed(&client->ps, &client->pers.cmd, level.time);
// set up for pmove
oldEventSequence = client->ps.eventSequence;
memset (&pm, 0, sizeof(pm));
if ( ent->flags & FL_FORCE_GESTURE ) {
ent->flags &= ~FL_FORCE_GESTURE;
ent->client->pers.cmd.buttons |= BUTTON_GESTURE;
}
if (ent->client && ent->client->ps.fallingToDeath &&
(level.time - FALL_FADE_TIME) > ent->client->ps.fallingToDeath)
{ //die!
player_die(ent, ent, ent, 100000, MOD_FALLING);
respawn(ent);
ent->client->ps.fallingToDeath = 0;
G_MuteSound(ent->s.number, CHAN_VOICE); //stop screaming, because you are dead!
}
if (ent->client->ps.otherKillerTime > level.time &&
ent->client->ps.groundEntityNum != ENTITYNUM_NONE &&
ent->client->ps.otherKillerDebounceTime < level.time)
{
ent->client->ps.otherKillerTime = 0;
ent->client->ps.otherKiller = ENTITYNUM_NONE;
}
else if (ent->client->ps.otherKillerTime > level.time &&
ent->client->ps.groundEntityNum == ENTITYNUM_NONE)
{
if (ent->client->ps.otherKillerDebounceTime < (level.time + 100))
{
ent->client->ps.otherKillerDebounceTime = level.time + 100;
}
}
// WP_ForcePowersUpdate( ent, msec, ucmd); //update any active force powers
// WP_SaberPositionUpdate(ent, ucmd); //check the server-side saber point, do apprioriate server-side actions (effects are cs-only)
if ((ent->client->pers.cmd.buttons & BUTTON_USE) && ent->client->ps.useDelay < level.time)
{
TryUse(ent);
ent->client->ps.useDelay = level.time + 100;
}
pm.ps = &client->ps;
pm.cmd = *ucmd;
if ( pm.ps->pm_type == PM_DEAD ) {
pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;
}
else if ( ent->r.svFlags & SVF_BOT ) {
pm.tracemask = MASK_PLAYERSOLID | CONTENTS_MONSTERCLIP;
}
else {
pm.tracemask = MASK_PLAYERSOLID;
}
pm.trace = trap_Trace;
pm.pointcontents = trap_PointContents;
pm.debugLevel = g_debugMove.integer;
pm.noFootsteps = ( g_dmflags.integer & DF_NO_FOOTSTEPS ) > 0;
pm.pmove_fixed = pmove_fixed.integer | client->pers.pmoveFixed;
pm.pmove_msec = pmove_msec.integer;
pm.animations = bgGlobalAnimations;//NULL;
pm.gametype = g_gametype.integer;
VectorCopy( client->ps.origin, client->oldOrigin );
if (level.intermissionQueued != 0 && g_singlePlayer.integer) {
if ( level.time - level.intermissionQueued >= 1000 ) {
pm.cmd.buttons = 0;
pm.cmd.forwardmove = 0;
pm.cmd.rightmove = 0;
pm.cmd.upmove = 0;
if ( level.time - level.intermissionQueued >= 2000 && level.time - level.intermissionQueued <= 2500 ) {
trap_SendConsoleCommand( EXEC_APPEND, "centerview\n");
}
ent->client->ps.pm_type = PM_SPINTERMISSION;
}
}
for ( i = 0 ; i < MAX_CLIENTS ; i++ )
{
if (g_entities[i].inuse && g_entities[i].client)
{
pm.bgClients[i] = &g_entities[i].client->ps;
}
}
if (ent->client->ps.saberLockTime > level.time)
{
gentity_t *blockOpp = &g_entities[ent->client->ps.saberLockEnemy];
if (blockOpp && blockOpp->inuse && blockOpp->client)
{
vec3_t lockDir, lockAng;
//VectorClear( ent->client->ps.velocity );
VectorSubtract( blockOpp->r.currentOrigin, ent->r.currentOrigin, lockDir );
//lockAng[YAW] = vectoyaw( defDir );
vectoangles(lockDir, lockAng);
SetClientViewAngle( ent, lockAng );
}
if ( ( ent->client->buttons & BUTTON_ATTACK ) && ! ( ent->client->oldbuttons & BUTTON_ATTACK ) )
{
ent->client->ps.saberLockHits++;
}
if (ent->client->ps.saberLockHits > 2)
{
if (!ent->client->ps.saberLockAdvance)
{
ent->client->ps.saberLockHits -= 3;
}
ent->client->ps.saberLockAdvance = qtrue;
}
}
else
{
ent->client->ps.saberLockFrame = 0;
//check for taunt
if ( (pm.cmd.generic_cmd == GENCMD_ENGAGE_DUEL) && (g_gametype.integer == GT_TOURNAMENT) )
{//already in a duel, make it a taunt command
pm.cmd.buttons |= BUTTON_GESTURE;
}
}
Pmove (&pm);
if (pm.checkDuelLoss)
{
if (pm.checkDuelLoss > 0 && pm.checkDuelLoss <= MAX_CLIENTS)
{
gentity_t *clientLost = &g_entities[pm.checkDuelLoss-1];
if (clientLost && clientLost->inuse && clientLost->client && Q_irand(0, 40) > clientLost->health)
{
vec3_t attDir;
VectorSubtract(ent->client->ps.origin, clientLost->client->ps.origin, attDir);
VectorNormalize(attDir);
VectorClear(clientLost->client->ps.velocity);
clientLost->client->ps.forceHandExtend = HANDEXTEND_NONE;
clientLost->client->ps.forceHandExtendTime = 0;
gGAvoidDismember = 1;
G_Damage(clientLost, ent, ent, attDir, clientLost->client->ps.origin, 9999, DAMAGE_NO_PROTECTION, MOD_SABER);
if (clientLost->health < 1)
{
gGAvoidDismember = 2;
G_CheckForDismemberment(clientLost, clientLost->client->ps.origin, 999, (clientLost->client->ps.legsAnim&~ANIM_TOGGLEBIT));
}
gGAvoidDismember = 0;
}
}
pm.checkDuelLoss = 0;
}
switch(pm.cmd.generic_cmd)
{
case 0:
break;
case GENCMD_SABERSWITCH:
Cmd_ToggleSaber_f(ent);
break;
case GENCMD_ENGAGE_DUEL:
if ( g_gametype.integer == GT_TOURNAMENT )
{//already in a duel, made it a taunt command
}
else
{
Cmd_EngageDuel_f(ent);
}
break;
case GENCMD_FORCE_HEAL:
ForceHeal(ent);
break;
case GENCMD_FORCE_SPEED:
ForceSpeed(ent, 0);
break;
case GENCMD_FORCE_THROW:
ForceThrow(ent, qfalse);
break;
case GENCMD_FORCE_PULL:
ForceThrow(ent, qtrue);
break;
case GENCMD_FORCE_DISTRACT:
ForceTelepathy(ent);
break;
case GENCMD_FORCE_RAGE:
ForceRage(ent);
break;
case GENCMD_FORCE_PROTECT:
ForceProtect(ent);
break;
case GENCMD_FORCE_ABSORB:
ForceAbsorb(ent);
break;
case GENCMD_FORCE_HEALOTHER:
ForceTeamHeal(ent);
break;
case GENCMD_FORCE_FORCEPOWEROTHER:
ForceTeamForceReplenish(ent);
break;
case GENCMD_FORCE_SEEING:
ForceSeeing(ent);
break;
case GENCMD_USE_SEEKER:
if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_SEEKER)) &&
G_ItemUsable(&ent->client->ps, HI_SEEKER) )
{
ItemUse_Seeker(ent);
G_AddEvent(ent, EV_USE_ITEM0+HI_SEEKER, 0);
ent->client->ps.stats[STAT_HOLDABLE_ITEMS] &= ~(1 << HI_SEEKER);
}
break;
case GENCMD_USE_FIELD:
if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_SHIELD)) &&
G_ItemUsable(&ent->client->ps, HI_SHIELD) )
{
ItemUse_Shield(ent);
G_AddEvent(ent, EV_USE_ITEM0+HI_SHIELD, 0);
ent->client->ps.stats[STAT_HOLDABLE_ITEMS] &= ~(1 << HI_SHIELD);
}
break;
case GENCMD_USE_BACTA:
if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_MEDPAC)) &&
G_ItemUsable(&ent->client->ps, HI_MEDPAC) )
{
ItemUse_MedPack(ent);
G_AddEvent(ent, EV_USE_ITEM0+HI_MEDPAC, 0);
ent->client->ps.stats[STAT_HOLDABLE_ITEMS] &= ~(1 << HI_MEDPAC);
}
break;
case GENCMD_USE_ELECTROBINOCULARS:
if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_BINOCULARS)) &&
G_ItemUsable(&ent->client->ps, HI_BINOCULARS) )
{
ItemUse_Binoculars(ent);
if (ent->client->ps.zoomMode == 0)
{
G_AddEvent(ent, EV_USE_ITEM0+HI_BINOCULARS, 1);
}
else
{
G_AddEvent(ent, EV_USE_ITEM0+HI_BINOCULARS, 2);
}
}
break;
case GENCMD_ZOOM:
if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_BINOCULARS)) &&
G_ItemUsable(&ent->client->ps, HI_BINOCULARS) )
{
ItemUse_Binoculars(ent);
if (ent->client->ps.zoomMode == 0)
{
G_AddEvent(ent, EV_USE_ITEM0+HI_BINOCULARS, 1);
}
else
{
G_AddEvent(ent, EV_USE_ITEM0+HI_BINOCULARS, 2);
}
}
break;
case GENCMD_USE_SENTRY:
if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_SENTRY_GUN)) &&
G_ItemUsable(&ent->client->ps, HI_SENTRY_GUN) )
{
ItemUse_Sentry(ent);
G_AddEvent(ent, EV_USE_ITEM0+HI_SENTRY_GUN, 0);
ent->client->ps.stats[STAT_HOLDABLE_ITEMS] &= ~(1 << HI_SENTRY_GUN);
}
break;
case GENCMD_SABERATTACKCYCLE:
Cmd_SaberAttackCycle_f(ent);
break;
default:
break;
}
// save results of pmove
if ( ent->client->ps.eventSequence != oldEventSequence ) {
ent->eventTime = level.time;
}
if (g_smoothClients.integer) {
BG_PlayerStateToEntityStateExtraPolate( &ent->client->ps, &ent->s, ent->client->ps.commandTime, qtrue );
}
else {
BG_PlayerStateToEntityState( &ent->client->ps, &ent->s, qtrue );
}
SendPendingPredictableEvents( &ent->client->ps );
if ( !( ent->client->ps.eFlags & EF_FIRING ) ) {
client->fireHeld = qfalse; // for grapple
}
// use the snapped origin for linking so it matches client predicted versions
VectorCopy( ent->s.pos.trBase, ent->r.currentOrigin );
VectorCopy (pm.mins, ent->r.mins);
VectorCopy (pm.maxs, ent->r.maxs);
ent->waterlevel = pm.waterlevel;
ent->watertype = pm.watertype;
// execute client events
ClientEvents( ent, oldEventSequence );
if ( pm.useEvent )
{
//TODO: Use
// TryUse( ent );
}
// link entity now, after any personal teleporters have been used
trap_LinkEntity (ent);
if ( !ent->client->noclip ) {
G_TouchTriggers( ent );
}
// NOTE: now copy the exact origin over otherwise clients can be snapped into solid
VectorCopy( ent->client->ps.origin, ent->r.currentOrigin );
//test for solid areas in the AAS file
// BotTestAAS(ent->r.currentOrigin);
// touch other objects
ClientImpacts( ent, &pm );
// save results of triggers and client events
if (ent->client->ps.eventSequence != oldEventSequence) {
ent->eventTime = level.time;
}
// swap and latch button actions
client->oldbuttons = client->buttons;
client->buttons = ucmd->buttons;
client->latched_buttons |= client->buttons & ~client->oldbuttons;
// Did we kick someone in our pmove sequence?
if (client->ps.forceKickFlip)
{
gentity_t *faceKicked = &g_entities[client->ps.forceKickFlip-1];
if (faceKicked && faceKicked->client && (!OnSameTeam(ent, faceKicked) || g_friendlyFire.integer) &&
(!faceKicked->client->ps.duelInProgress || faceKicked->client->ps.duelIndex == ent->s.number) &&
(!ent->client->ps.duelInProgress || ent->client->ps.duelIndex == faceKicked->s.number))
{
if ( faceKicked && faceKicked->client && faceKicked->health && faceKicked->takedamage )
{//push them away and do pain
vec3_t oppDir;
int strength = (int)VectorNormalize2( client->ps.velocity, oppDir );
strength *= 0.05;
VectorScale( oppDir, -1, oppDir );
G_Damage( faceKicked, ent, ent, oppDir, client->ps.origin, strength, DAMAGE_NO_ARMOR, MOD_MELEE );
if ( faceKicked->client->ps.weapon != WP_SABER ||
faceKicked->client->ps.fd.saberAnimLevel < FORCE_LEVEL_3 ||
(!BG_SaberInAttack(faceKicked->client->ps.saberMove) && !PM_SaberInStart(faceKicked->client->ps.saberMove) && !PM_SaberInReturn(faceKicked->client->ps.saberMove) && !PM_SaberInTransition(faceKicked->client->ps.saberMove)) )
{
if (faceKicked->health > 0 &&
faceKicked->client->ps.stats[STAT_HEALTH] > 0 &&
faceKicked->client->ps.forceHandExtend != HANDEXTEND_KNOCKDOWN)
{
if (Q_irand(1, 10) <= 3)
{ //only actually knock over sometimes, but always do velocity hit
faceKicked->client->ps.forceHandExtend = HANDEXTEND_KNOCKDOWN;
faceKicked->client->ps.forceHandExtendTime = level.time + 1100;
faceKicked->client->ps.forceDodgeAnim = 0; //this toggles between 1 and 0, when it's 1 we should play the get up anim
}
faceKicked->client->ps.otherKiller = ent->s.number;
faceKicked->client->ps.otherKillerTime = level.time + 5000;
faceKicked->client->ps.otherKillerDebounceTime = level.time + 100;
faceKicked->client->ps.velocity[0] = oppDir[0]*(strength*40);
faceKicked->client->ps.velocity[1] = oppDir[1]*(strength*40);
faceKicked->client->ps.velocity[2] = 200;
}
}
G_Sound( faceKicked, CHAN_AUTO, G_SoundIndex( va("sound/weapons/melee/punch%d", Q_irand(1, 4)) ) );
}
}
client->ps.forceKickFlip = 0;
}
// check for respawning
if ( client->ps.stats[STAT_HEALTH] <= 0 ) {
// wait for the attack button to be pressed
if ( level.time > client->respawnTime && !gDoSlowMoDuel ) {
// forcerespawn is to prevent users from waiting out powerups
if ( g_forcerespawn.integer > 0 &&
( level.time - client->respawnTime ) > g_forcerespawn.integer * 1000 ) {
respawn( ent );
return;
}
// pressing attack or use is the normal respawn method
if ( ucmd->buttons & ( BUTTON_ATTACK | BUTTON_USE_HOLDABLE ) ) {
respawn( ent );
}
}
else if (gDoSlowMoDuel)
{
client->respawnTime = level.time + 1000;
}
return;
}
// perform once-a-second actions
ClientTimerActions( ent, msec );
G_UpdateClientBroadcasts ( ent );
}
/*
==================
TheEmote
MJN/ClanMod
==================
*/
void TheEmote(int anim, gentity_t *ent, qboolean freeze )
{
extern void G_Say( gentity_t *ent, gentity_t *target, int mode, const char *chatText );
char *msg = ConcatArgs(1);
int i = 0;
if ( ent->client->sess.spectatorState == SPECTATOR_FOLLOW || ent->client->sess.spectatorState == SPECTATOR_FREE )
return;
if (ent->client->ps.groundEntityNum == ENTITYNUM_NONE)
return;
if ( ent->client->ps.saberHolstered < 2 )
ent->client->ps.saberHolstered = 2;
if ( BG_SaberInAttack(ent->client->ps.saberMove) || BG_SaberInSpecialAttack(ent->client->ps.saberMove) || ent->client->ps.saberLockTime )
return;
//[OpenRP - Endlessly floating up bug]
if(ent && ent->client && ent->client->forceLifting != -1)
{
g_entities[ent->client->forceLifting].client->ps.forceGripMoveInterval = 0;
g_entities[ent->client->forceLifting].client->ps.forceGripChangeMovetype = PM_NORMAL;
g_entities[ent->client->forceLifting].client->ps.pm_type = PM_NORMAL;
g_entities[ent->client->forceLifting].client->underForceLift=qfalse;
ent->client->forceLifting = -1;
}
//[/OpenRP - Endlessly floating up bug]
ent->client->ps.forceHandExtend = HANDEXTEND_TAUNT;
ent->client->ps.forceDodgeAnim = anim;
// MJN - Entry for emotes
//if (InSpecialEmote( anim ) )
if ( freeze )
{
// MJN - Stop running Forcepowers
while ( i < NUM_FORCE_POWERS )
{
if ( ( ent->client->ps.fd.forcePowersActive & (1 << i) ) && i != FP_LEVITATION )
WP_ForcePowerStop(ent, i);
i++;
}
ent->client->ps.forceHandExtendTime = level.time + 9999999;
ent->client->saberKnockedTime = level.time + 9999999;
ent->client->ps.weaponTime = 99999999;
}
else
{// basejk
ent->client->ps.forceHandExtendTime = level.time + BG_AnimLength(ent->localAnimIndex, (animNumber_t)anim);
}
if ( trap_Argc() >= 2 )
G_Say( ent, NULL, SAY_ME, msg );
return;
/*
if (freeze == qtrue)
{
if (ent->client->ps.forceDodgeAnim == anim)
{
StandardSetBodyAnim(ent, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_HOLDLESS);
ent->client->emote_freeze = qfalse;
ent->client->ps.saberCanThrow = qtrue;
ent->client->ps.forceDodgeAnim = 0;
ent->client->ps.forceHandExtendTime = 0;
ent->client->ps.saberMove = LS_NONE;
ent->client->saberKnockedTime = level.time; // Enable Saber
ent->client->ps.weaponTime = 0; // Enable Weapons
}
else
{
M_HolsterThoseSabers(ent);
ent->client->emote_freeze = qtrue; // MJN 1
ent->client->ps.saberMove = LS_NONE;
ent->client->ps.saberBlocked = 0;
ent->client->ps.saberBlocking = 0;
ent->client->saberKnockedTime = level.time + 9999999; // Disable Saber
ent->client->ps.weaponTime = 99999999; // Disable Weapons
ent->client->ps.saberCanThrow = qfalse;
ent->client->ps.forceHandExtend = HANDEXTEND_TAUNT;
ent->client->ps.forceDodgeAnim = anim;
ent->client->ps.forceHandExtendTime = level.time + Q3_INFINITE;
StandardSetBodyAnim(ent, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_HOLDLESS);
}
}
else
{
StandardSetBodyAnim(ent, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_HOLDLESS);
}
*/
}
//G_MissileImpact now returns qfalse if and only if the player physically dodged the damage.
//this allows G_RunMissile to properly handle he
qboolean G_MissileImpact( gentity_t *ent, trace_t *trace ) {
//void G_MissileImpact( gentity_t *ent, trace_t *trace ) {
//[/DodgeSys]
gentity_t *other;
qboolean isKnockedSaber = qfalse;
//[DodgeSys]
int missileDmg;
//[/DodgeSys]
other = &g_entities[trace->entityNum];
// check for bounce
//[WeaponSys]
//allow thermals to bounce off players and such.
if ( (!other->takedamage || ent->s.weapon == WP_THERMAL) &&
//if ( !other->takedamage &&
//[/WeaponSys]
(ent->bounceCount > 0 || ent->bounceCount == -5) &&
( ent->flags & ( FL_BOUNCE | FL_BOUNCE_HALF ) ) ) {
G_BounceMissile( ent, trace );
G_AddEvent( ent, EV_GRENADE_BOUNCE, 0 );
//[DodgeSys]
return qtrue;
//return;
//[/DodgeSys]
}
else if (ent->neverFree && ent->s.weapon == WP_SABER && (ent->flags & FL_BOUNCE_HALF))
{ //this is a knocked-away saber
if (ent->bounceCount > 0 || ent->bounceCount == -5)
{
G_BounceMissile( ent, trace );
G_AddEvent( ent, EV_GRENADE_BOUNCE, 0 );
//[DodgeSys]
return qtrue;
//return;
//[/DodgeSys]
}
isKnockedSaber = qtrue;
}
// I would glom onto the FL_BOUNCE code section above, but don't feel like risking breaking something else
if (/* (!other->takedamage && (ent->bounceCount > 0 || ent->bounceCount == -5) && ( ent->flags&(FL_BOUNCE_SHRAPNEL) ) ) ||*/ ((trace->surfaceFlags&SURF_FORCEFIELD)&&!ent->splashDamage&&!ent->splashRadius&&(ent->bounceCount > 0 || ent->bounceCount == -5)) )
{
G_BounceMissile( ent, trace );
if ( ent->bounceCount < 1 )
{
ent->flags &= ~FL_BOUNCE_SHRAPNEL;
}
//[DodgeSys]
return qtrue;
//return;
//[/DodgeSys]
}
if ((other->r.contents & CONTENTS_LIGHTSABER) && !isKnockedSaber)
{ //hit this person's saber, so..
gentity_t *otherOwner = &g_entities[other->r.ownerNum];
if (otherOwner->takedamage && otherOwner->client && otherOwner->client->ps.duelInProgress &&
otherOwner->client->ps.duelIndex != ent->r.ownerNum)
{
goto killProj;
}
}
else if (!isKnockedSaber)
{
if (other->takedamage && other->client && other->client->ps.duelInProgress &&
other->client->ps.duelIndex != ent->r.ownerNum)
{
goto killProj;
}
}
if (other->flags & FL_DMG_BY_HEAVY_WEAP_ONLY)
{
if (ent->methodOfDeath != MOD_REPEATER_ALT &&
ent->methodOfDeath != MOD_ROCKET &&
ent->methodOfDeath != MOD_FLECHETTE_ALT_SPLASH &&
ent->methodOfDeath != MOD_ROCKET_HOMING &&
ent->methodOfDeath != MOD_THERMAL &&
ent->methodOfDeath != MOD_THERMAL_SPLASH &&
ent->methodOfDeath != MOD_TRIP_MINE_SPLASH &&
ent->methodOfDeath != MOD_TIMED_MINE_SPLASH &&
ent->methodOfDeath != MOD_DET_PACK_SPLASH &&
ent->methodOfDeath != MOD_VEHICLE &&
ent->methodOfDeath != MOD_CONC &&
ent->methodOfDeath != MOD_CONC_ALT &&
ent->methodOfDeath != MOD_SABER &&
//[Asteroids]
ent->methodOfDeath != MOD_TURBLAST &&
ent->methodOfDeath != MOD_TARGET_LASER)
//[/Asteroids]
{
vec3_t fwd;
if (trace)
{
VectorCopy(trace->plane.normal, fwd);
}
else
{ //oh well
AngleVectors(other->r.currentAngles, fwd, NULL, NULL);
}
G_DeflectMissile(other, ent, fwd);
G_MissileBounceEffect(ent, ent->r.currentOrigin, fwd);
//[DodgeSys]
return qtrue;
//return;
//[/DodgeSys]
}
}
//ROP VEHICLE_IMP START
if((other->s.NPC_class == CLASS_VEHICLE && other->m_pVehicle
&& !other->m_pVehicle->m_pVehicleInfo->AllWeaponsDoDamageToShields
&& other->client->ps.stats[STAT_ARMOR] > 0) || other->flags & FL_SHIELDED)
{
if (ent->s.weapon != WP_ROCKET_LAUNCHER &&
ent->s.weapon != WP_THERMAL &&
ent->s.weapon != WP_GRENADE &&
ent->s.weapon != WP_DET_PACK &&
ent->s.weapon != WP_DEMP2 &&
ent->s.weapon != WP_EMPLACED_GUN &&
ent->s.weapon != WP_TURRET &&
ent->methodOfDeath != MOD_REPEATER_ALT &&
ent->methodOfDeath != MOD_FLECHETTE_ALT_SPLASH &&
ent->methodOfDeath != MOD_TURBLAST &&
ent->methodOfDeath != MOD_VEHICLE &&
ent->methodOfDeath != MOD_CONC &&
ent->methodOfDeath != MOD_CONC_ALT &&
!(ent->dflags&DAMAGE_HEAVY_WEAP_CLASS) )
{
vec3_t fwd;
if (other->client)
{
AngleVectors(other->client->ps.viewangles, fwd, NULL, NULL);
}
else
{
AngleVectors(other->r.currentAngles, fwd, NULL, NULL);
}
G_DeflectMissile(other, ent, fwd);
G_MissileBounceEffect(ent, ent->r.currentOrigin, fwd);
//[DodgeSys]
return qtrue;
//return;
//[/DodgeSys]
}
}
//ROP VEHICLE_IMP END
//[BoltBlockSys]
if (OJP_SaberCanBlock(other, ent, qfalse, trace->endpos, -1, -1))
//[/BoltBlockSys]
{ //only block one projectile per 200ms (to prevent giant swarms of projectiles being blocked)
//[BoltBlockSys]
//racc - missile hit the actual player and it's a type of missile that you can deflect/ref with the saber.
//racc - play projectile block animation
other->client->ps.weaponTime = 0;
WP_SaberBlockNonRandom(other, ent->r.currentOrigin, qtrue);
OJP_HandleBoltBlock(ent, other, trace);
//[DodgeSys]
return qtrue;
//return;
//[/DodgeSys]
//[/BoltBlockSys]
}
else if ((other->r.contents & CONTENTS_LIGHTSABER) && !isKnockedSaber)
{ //hit this person's saber, so..
gentity_t *otherOwner = &g_entities[other->r.ownerNum];
if (otherOwner->takedamage && otherOwner->client &&
ent->s.weapon != WP_TUSKEN_RIFLE &&
ent->s.weapon != WP_ROCKET_LAUNCHER &&
ent->s.weapon != WP_THERMAL &&
ent->s.weapon != WP_GRENADE &&
ent->s.weapon != WP_DET_PACK &&
//[BoltBlockSys]
//ent->s.weapon != WP_DEMP2 &&
//[BoltBlockSys]
ent->methodOfDeath != MOD_REPEATER_ALT &&
ent->methodOfDeath != MOD_FLECHETTE_ALT_SPLASH &&
ent->methodOfDeath != MOD_CONC &&
ent->methodOfDeath != MOD_CONC_ALT /*&&
otherOwner->client->ps.saberBlockTime < level.time*/)
{ //for now still deflect even if saberBlockTime >= level.time because it hit the actual saber
//in this case, deflect it even if we can't actually block it because it hit our saber
//WP_SaberCanBlock(otherOwner, ent->r.currentOrigin, 0, 0, qtrue, 0);
if ((otherOwner->client && !BG_SaberInAttack(otherOwner->client->ps.saberMove))
|| (otherOwner->client && (pm->cmd.buttons & BUTTON_FORCEPOWER || pm->cmd.buttons & BUTTON_FORCEGRIP
|| pm->cmd.buttons & BUTTON_FORCE_LIGHTNING) ))
{ //racc - play projectile block animation even in .
otherOwner->client->ps.weaponTime = 0;
WP_SaberBlockNonRandom(otherOwner, ent->r.currentOrigin, qtrue);
}
//[BoltBlockSys]
OJP_HandleBoltBlock(ent, otherOwner, trace);
//[/BoltBlockSys]
//[DodgeSys]
return qtrue;
//return;
//[/DodgeSys]
}
}
// check for sticking
//[SaberThrowSys]
if ( !other->takedamage && ( ent->s.eFlags & EF_MISSILE_STICK )
&& ent->s.weapon != WP_SABER)
//if ( !other->takedamage && ( ent->s.eFlags & EF_MISSILE_STICK ) )
//[/SaberThrowSys]
{
laserTrapStick( ent, trace->endpos, trace->plane.normal );
G_AddEvent( ent, EV_MISSILE_STICK, 0 );
//[DodgeSys]
return qtrue;
//return;
//[/DodgeSys]
}
// impact damage
if (other->takedamage && !isKnockedSaber) {
//[DodgeSys]
//make players be able to dodge projectiles.
missileDmg = ent->damage;
if(G_DoDodge(other, &g_entities[ent->r.ownerNum], trace->endpos, -1, &missileDmg, ent->methodOfDeath))
{ //player dodged the damage, have missile continue moving.
if(ent->s.weapon == WP_ROCKET_LAUNCHER)
ent->genericValue1 = 0;
return qfalse;
}
//[/DodgeSys]
// FIXME: wrong damage direction?
//[DodgeSys]
if ( missileDmg ) {
//if ( ent->damage ) {
//[/DodgeSys]
vec3_t velocity;
qboolean didDmg = qfalse;
BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );
if ( VectorLength( velocity ) == 0 ) {
velocity[2] = 1; // stepped on a grenade
}
if (ent->s.weapon == WP_BOWCASTER || ent->s.weapon == WP_FLECHETTE ||
ent->s.weapon == WP_ROCKET_LAUNCHER)
{
if (ent->s.weapon == WP_FLECHETTE && (ent->s.eFlags & EF_ALT_FIRING))
{
ent->think(ent);
}
else
{
G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity,
//[DodgeSys]
ent->r.currentOrigin, missileDmg,
//[/DodgeSys]
DAMAGE_HALF_ABSORB, ent->methodOfDeath);
didDmg = qtrue;
}
}
else {
gentity_t *owner = &g_entities[ent->r.ownerNum];
float distance = VectorDistance(owner->r.currentOrigin,other->r.currentOrigin);
if(distance <= 100.0f)
{
G_Damage (other, ent, owner, velocity,
//[DodgeSys]
ent->r.currentOrigin, missileDmg * 2,
//[/DodgeSys]
0, ent->methodOfDeath);
}
else if (distance <= 300.0f)
{
G_Damage (other, ent, owner, velocity,
//[DodgeSys]
ent->r.currentOrigin, missileDmg * 1.5,
//[/DodgeSys]
0, ent->methodOfDeath);
}
else
{
G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity,
//[DodgeSys]
ent->r.currentOrigin, missileDmg,
//[/DodgeSys]
0, ent->methodOfDeath);
}
didDmg = qtrue;
}
if (didDmg && other && other->client)
{ //What I'm wondering is why this isn't in the NPC pain funcs. But this is what SP does, so whatever.
class_t npc_class = other->client->NPC_class;
// If we are a robot and we aren't currently doing the full body electricity...
if ( npc_class == CLASS_SEEKER || npc_class == CLASS_PROBE || npc_class == CLASS_MOUSE ||
npc_class == CLASS_GONK || npc_class == CLASS_R2D2 || npc_class == CLASS_R5D2 || npc_class == CLASS_REMOTE ||
npc_class == CLASS_MARK1 || npc_class == CLASS_MARK2 || //npc_class == CLASS_PROTOCOL ||//no protocol, looks odd
npc_class == CLASS_INTERROGATOR || npc_class == CLASS_ATST || npc_class == CLASS_SENTRY )
{
// special droid only behaviors
if ( other->client->ps.electrifyTime < level.time + 100 )
{
// ... do the effect for a split second for some more feedback
other->client->ps.electrifyTime = level.time + 450;
}
//FIXME: throw some sparks off droids,too
}
}
}
if ( ent->s.weapon == WP_DEMP2 )
{ //a hit with demp2 decloaks people, disables ships
if ( other && other->client && other->client->NPC_class == CLASS_VEHICLE )
{ //hit a vehicle
if ( other->m_pVehicle //valid vehicle ent
&& other->m_pVehicle->m_pVehicleInfo//valid stats
&& (other->m_pVehicle->m_pVehicleInfo->type == VH_SPEEDER//always affect speeders
||(other->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER && ent->classname && Q_stricmp("vehicle_proj", ent->classname ) == 0) )//only vehicle ion weapons affect a fighter in this manner
&& !FighterIsLanded( other->m_pVehicle , &other->client->ps )//not landed
&& !(other->spawnflags&2) )//and not suspended
{ //vehicles hit by "ion cannons" lose control
if ( other->client->ps.electrifyTime > level.time )
{ //add onto it
//FIXME: extern the length of the "out of control" time?
other->client->ps.electrifyTime += Q_irand(200,500);
if ( other->client->ps.electrifyTime > level.time + 4000 )
{ //cap it
other->client->ps.electrifyTime = level.time + 4000;
}
}
else
{ //start it
//FIXME: extern the length of the "out of control" time?
other->client->ps.electrifyTime = level.time + Q_irand(200,500);
}
}
}
else if ( other && other->client && other->client->ps.powerups[PW_CLOAKED] )
{
Jedi_Decloak( other );
if ( ent->methodOfDeath == MOD_DEMP2_ALT )
{ //direct hit with alt disables cloak forever
//permanently disable the saboteur's cloak
other->client->cloakToggleTime = Q3_INFINITE;
}
else
{ //temp disable
other->client->cloakToggleTime = level.time + Q_irand( 3000, 10000 );
}
}
}
}
killProj:
// is it cheaper in bandwidth to just remove this ent and create a new
// one, rather than changing the missile into the explosion?
if ( other->takedamage && other->client && !isKnockedSaber ) {
G_AddEvent( ent, EV_MISSILE_HIT, DirToByte( trace->plane.normal ) );
ent->s.otherEntityNum = other->s.number;
} else if( trace->surfaceFlags & SURF_METALSTEPS ) {
G_AddEvent( ent, EV_MISSILE_MISS_METAL, DirToByte( trace->plane.normal ) );
} else if (ent->s.weapon != G2_MODEL_PART && !isKnockedSaber) {
G_AddEvent( ent, EV_MISSILE_MISS, DirToByte( trace->plane.normal ) );
}
if (!isKnockedSaber)
{
ent->freeAfterEvent = qtrue;
// change over to a normal entity right at the point of impact
ent->s.eType = ET_GENERAL;
}
SnapVectorTowards( trace->endpos, ent->s.pos.trBase ); // save net bandwidth
G_SetOrigin( ent, trace->endpos );
ent->takedamage = qfalse;
// splash damage (doesn't apply to person directly hit)
if ( ent->splashDamage ) {
G_RadiusDamage( trace->endpos, ent->parent, ent->splashDamage, ent->splashRadius,
other, ent, ent->splashMethodOfDeath );
}
if (ent->s.weapon == G2_MODEL_PART)
{
ent->freeAfterEvent = qfalse; //it will free itself
}
trap_LinkEntity( ent );
//[DodgeSys]
return qtrue;
//[/DodgeSys]
}
