/**
* @brief Changes the state of a player/soldier.
* @param[in,out] player The player who controlls the actor
* @param[in] ent the edict to perform the state change for
* @param[in] reqState The bit-map of the requested state change
* @param[in] checkaction only activate the events - network stuff is handled in the calling function
* don't even use the G_ActionCheckForCurrentTeam function
* @note Use checkaction true only for e.g. spawning values
*/
void G_ClientStateChange (const player_t* player, edict_t* ent, int reqState, bool checkaction)
{
/* Check if any action is possible. */
if (checkaction && !G_ActionCheckForCurrentTeam(player, ent, 0))
return;
if (!reqState)
return;
switch (reqState) {
case STATE_CROUCHED: /* Toggle between crouch/stand. */
/* Check if player has enough TUs (TU_CROUCH TUs for crouch/uncrouch). */
if (!checkaction || G_ActionCheckForCurrentTeam(player, ent, TU_CROUCH)) {
if (G_IsCrouched(ent)) {
if (!gi.CanActorStandHere(ent->fieldSize, ent->pos))
break;
}
G_ToggleCrouched(ent);
G_ActorUseTU(ent, TU_CROUCH);
G_ActorSetMaxs(ent);
}
break;
case ~STATE_REACTION: /* Request to turn off reaction fire. */
if (G_IsReaction(ent)) {
if (G_IsShaken(ent)) {
G_ClientPrintf(player, PRINT_HUD, _("Currently shaken, won't let their guard down."));
} else {
/* Turn off reaction fire. */
G_RemoveReaction(ent);
G_ActorReserveTUs(ent, 0, ent->chr.reservedTus.shot, ent->chr.reservedTus.crouch);
}
}
break;
/* Request to turn on multi- or single-reaction fire mode. */
case STATE_REACTION:
/* Disable reaction fire. */
G_RemoveReaction(ent);
if (G_ReactionFireSettingsReserveTUs(ent)) {
/* Enable requested reaction fire. */
G_SetState(ent, reqState);
}
break;
default:
gi.DPrintf("G_ClientStateChange: unknown request %i, ignoring\n", reqState);
return;
}
/* Only activate the events - network stuff is handled in the calling function */
if (!checkaction)
return;
G_ClientStateChangeUpdate(ent);
}
/**
* @brief Check whether ent can reaction fire at target, i.e. that it can see it and neither is dead etc.
* @param[in] ent The entity that might be firing
* @param[in] target The entity that might be fired at
* @return @c true if 'ent' can actually fire at 'target', @c false otherwise
*/
static bool G_ReactionFireIsPossible (Edict *ent, const Edict *target)
{
/* an entity can't reaction fire at itself */
if (ent == target)
return false;
/* Don't react in your own turn */
if (ent->team == level.activeTeam)
return false;
/* ent can't use RF if is in STATE_DAZED (flashbang impact) */
if (G_IsDazed(ent))
return false;
if (G_IsDead(target))
return false;
/* check ent has reaction fire enabled */
if (!G_IsReaction(ent))
return false;
/* check ent has weapon in RF hand */
if (!ent->getHandItem(ent->chr.RFmode.getHand())) {
/* print character info if this happens, for now */
gi.DPrintf("Reaction fire enabled but no weapon for hand (name=%s,entnum=%i,hand=%i,fmIdx=%i)\n",
ent->chr.name, ent->number, ent->chr.RFmode.getHand(), ent->chr.RFmode.getFmIdx());
G_RemoveReaction(ent);
return false;
}
if (!G_IsVisibleForTeam(target, ent->team))
return false;
/* If reaction fire is triggered by a friendly unit
* and the shooter is still sane, don't shoot;
* well, if the shooter isn't sane anymore... */
if (G_IsCivilian(target) || target->team == ent->team)
if (!G_IsShaken(ent) || (float) ent->morale / mor_shaken->value > frand())
return false;
/* check in range and visible */
const int spotDist = G_VisCheckDist(ent);
if (VectorDistSqr(ent->origin, target->origin) > spotDist * spotDist)
return false;
const bool frustum = G_FrustumVis(ent, target->origin);
if (!frustum)
return false;
const float actorVis = G_ActorVis(ent->origin, ent, target, true);
if (actorVis <= 0.2)
return false;
/* okay do it then */
return true;
}
/**
* @brief Deals damage of a give type and amount to a target.
* @param[in,out] target What we want to damage.
* @param[in] fd The fire definition that defines what type of damage is dealt.
* @param[in] damage The value of the damage.
* @param[in] attacker The attacker.
* @param[in] mock pseudo shooting - only for calculating mock values - NULL for real shots
* @param[in] impact impact location - @c NULL for splash damage
* @sa G_SplashDamage
* @sa G_TakeDamage
* @sa G_PrintActorStats
*/
static void G_Damage (edict_t *target, const fireDef_t *fd, int damage, edict_t *attacker, shot_mock_t *mock, const vec3_t impact)
{
const bool stunEl = (fd->obj->dmgtype == gi.csi->damStunElectro);
const bool stunGas = (fd->obj->dmgtype == gi.csi->damStunGas);
const bool shock = (fd->obj->dmgtype == gi.csi->damShock);
const bool smoke = (fd->obj->dmgtype == gi.csi->damSmoke);
bool isRobot;
assert(target);
/* Breakables */
if (G_IsBrushModel(target) && G_IsBreakable(target)) {
/* Breakables are immune to stun & shock damage. */
if (stunEl || stunGas || shock || mock || smoke)
return;
if (damage >= target->HP) {
/* don't reset the HP value here, this value is used to distinguish
* between triggered destroy and a shoot */
assert(target->destroy);
target->destroy(target);
/* maybe the attacker is seeing something new? */
G_CheckVisTeamAll(attacker->team, 0, attacker);
/* check if attacker appears/perishes for any other team */
G_CheckVis(attacker);
} else {
G_TakeDamage(target, damage);
}
return;
}
/* Actors don't die again. */
if (!G_IsLivingActor(target))
return;
/* only actors after this point - and they must have a teamdef */
assert(target->chr.teamDef);
isRobot = CHRSH_IsTeamDefRobot(target->chr.teamDef);
/* Apply armour effects. */
if (damage > 0) {
damage = G_ApplyProtection(target, fd->dmgweight, damage);
} else if (damage < 0) {
/* Robots can't be healed. */
if (isRobot)
return;
}
Com_DPrintf(DEBUG_GAME, " Total damage: %d\n", damage);
/* Apply difficulty settings. */
if (sv_maxclients->integer == 1) {
if (G_IsAlien(attacker) && !G_IsAlien(target))
damage *= pow(1.18, g_difficulty->value);
else if (!G_IsAlien(attacker) && G_IsAlien(target))
damage *= pow(1.18, -g_difficulty->value);
}
assert(attacker->team >= 0 && attacker->team < MAX_TEAMS);
assert(target->team >= 0 && target->team < MAX_TEAMS);
if (g_nodamage != NULL && !g_nodamage->integer) {
/* hit */
if (mock) {
G_UpdateShotMock(mock, attacker, target, damage);
} else if (stunEl) {
target->STUN += damage;
} else if (stunGas) {
if (!isRobot) /* Can't stun robots with gas */
target->STUN += damage;
} else if (shock) {
/* Only do this if it's not one from our own team ... they should have known that there was a flashbang coming. */
if (!isRobot && target->team != attacker->team) {
/** @todo there should be a possible protection, too */
/* dazed entity wont reaction fire */
G_RemoveReaction(target);
G_ActorReserveTUs(target, 0, target->chr.reservedTus.shot, target->chr.reservedTus.crouch);
/* flashbangs kill TUs */
G_ActorSetTU(target, 0);
G_SendStats(target);
/* entity is dazed */
G_SetDazed(target);
G_ClientPrintf(G_PLAYER_FROM_ENT(target), PRINT_HUD, _("Soldier is dazed!\nEnemy used flashbang!"));
return;
}
} else {
if (damage < 0) {
/* The 'attacker' is healing the target. */
G_TreatActor(target, fd, damage, attacker->team);
} else {
/* Real damage was dealt. */
G_DamageActor(target, damage, impact);
/* Update overall splash damage for stats/score. */
if (!mock && damage > 0 && fd->splrad) /**< Check for >0 and splrad to not count this as direct hit. */
G_UpdateHitScore(attacker, target, fd, damage);
}
}
}
if (mock)
return;
G_CheckDeathOrKnockout(target, attacker, fd, damage);
}
