g_reaction.cpp

Go to the documentation of this file.

 
/*
Copyright (C) 2002-2025 UFO: Alien Invasion.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
*/
 
#include "g_reaction.h"
#include "g_actor.h"
#include "g_client.h"
#include "g_combat.h"
#include "g_edicts.h"
#include "g_match.h"
#include "g_vis.h"
 
#define MAX_RF_TARGETS 10
#define MAX_RF_DATA 128
 
#define DEBUG_RF 0

class ReactionFireTarget
{
public:
    Edict const* target;
    int triggerTUs;     /* the amount of TUS of the target(!) at which the reaction takes place */
};
 
#define RF_NO_ENTNUM -1

class ReactionFireTargetList
{
public:
    int entnum;
    int count;
    ReactionFireTarget targets[MAX_RF_TARGETS];
 
    ReactionFireTargetList () {
        OBJZERO(targets);
        init();
    }
 
    inline void init (void) {
        entnum = RF_NO_ENTNUM;
        count = 0;
    }
 
    inline void reset (void) {
        count = 0;
    }
};

class ReactionFireTargets
{
public:
    void init();
    void add(const Edict* shooter, const Edict* target, const int tusForShot);
    void remove(const Edict* shooter, const Edict* target);
    bool hasExpired(const Edict* shooter, const Edict* target, const int tusTarget);
    int getTriggerTUs(const Edict* shooter, const Edict* target);
    void advance(const Edict* shooter, const int tusShot);
    void reset();
    void notifyClientMove(const Edict* target, int step, bool startMove);
    void notifyClientOnStep(const Edict* target, int step);
    void create(const Edict* shooter);
    void destroy(const Edict* shooter);
    void resetTargetList(const Edict* shooter);
    void notifyClientOnShot(const Edict* target, int step);
    void notifyClientRFAborted(const Edict* shooter, const Edict* target, int step);
 
private:
    ReactionFireTargetList rfData[MAX_RF_DATA];
    ReactionFireTargetList* find (const Edict* shooter);
};
 
static ReactionFireTargets rft;

void ReactionFireTargets::init (void)
{
    for (int i = 0; i < MAX_RF_DATA; i++) {
        rfData[i].init();
    }
}

void ReactionFireTargets::reset (void)
{
    for (int i = 0; i < MAX_RF_DATA; i++) {
        rfData[i].reset();
    }
}
 
void ReactionFireTargets::notifyClientOnStep (const Edict* target, int step)
{
    for (int i = 0; i < MAX_RF_DATA; i++) {
        ReactionFireTargetList* rfts = &rfData[i];
        if (rfts->entnum == RF_NO_ENTNUM)
            continue;
        const Edict* shooter = G_EdictsGetByNum(rfts->entnum);
        for (int j = 0; j < rfts->count; j++) {
            ReactionFireTarget& t = rfts->targets[j];
            if (t.target != target)
                continue;
            const int tus = std::max(0, target->TU - t.triggerTUs);
            G_EventReactionFireTargetUpdate(*shooter, *target, tus, step);
        }
    }
}
 
void ReactionFireTargets::notifyClientOnShot (const Edict* target, int tusTarget)
{
    for (int i = 0; i < MAX_RF_DATA; i++) {
        ReactionFireTargetList* rfts = &rfData[i];
        if (rfts->entnum == RF_NO_ENTNUM)
            continue;
        const Edict* shooter = G_EdictsGetByNum(rfts->entnum);
        for (int j = 0; j < rfts->count; j++) {
            ReactionFireTarget& t = rfts->targets[j];
            if (t.target != target)
                continue;
            const int tus = std::max(0, target->TU - tusTarget - t.triggerTUs);
            G_EventReactionFireTargetUpdate(*shooter, *target, tus, MAX_ROUTE);
        }
    }
}
 
void ReactionFireTargets::notifyClientMove (const Edict* target, int step, bool startMove)
{
    for (int i = 0; i < MAX_RF_DATA; i++) {
        ReactionFireTargetList* rfts = &rfData[i];
        if (rfts->entnum == RF_NO_ENTNUM)
            continue;
        const Edict* shooter = G_EdictsGetByNum(rfts->entnum);
        for (int j = 0; j < rfts->count; j++) {
            if (rfts->targets[j].target != target)
                continue;
            if (startMove) {
                const int tus = std::max(0, target->TU - rfts->targets[j].triggerTUs);
                G_EventReactionFireAddTarget(*shooter, *target, tus, step);
            } else {
                G_EventReactionFireRemoveTarget(*shooter, *target, step);
            }
        }
    }
}
 
void ReactionFireTargets::notifyClientRFAborted (const Edict* shooter, const Edict* target, int step)
{
    ReactionFireTargetList* rfts = find(shooter);
    assert(rfts);
 
    for (int i = 0; i < rfts->count; i++) {
        ReactionFireTarget& t = rfts->targets[i];
        if (t.target != target)
            continue;
        G_EventReactionFireAbortShot(*shooter, *target, step);
    }
}

ReactionFireTargetList* ReactionFireTargets::find (const Edict* shooter)
{
    for (int i = 0; i < MAX_RF_DATA; i++) {
        ReactionFireTargetList* rfts = &rfData[i];
        if (rfts->entnum == shooter->getIdNum()) {
            return rfts;
        }
    }
    return nullptr;
}
 

void ReactionFireTargets::create (const Edict* shooter)
{
    const ReactionFireTargetList* rfts = find(shooter);
 
    if (rfts)
        gi.Error("Entity already has rfData");
 
    for (int i = 0; i < MAX_RF_DATA; i++) {
        ReactionFireTargetList& data = rfData[i];
        if (data.entnum != RF_NO_ENTNUM)
            continue;
        data.entnum = shooter->getIdNum();
        return;
    }
 
    gi.Error("Not enough rfData");
}

void ReactionFireTargets::destroy (const Edict* shooter)
{
    ReactionFireTargetList* rfts = find(shooter);
 
    if (!rfts) {
        gi.DPrintf("Entity doesn't have rfData");
        return;
    }
 
    rfts->init();
}

void ReactionFireTargets::add (const Edict* shooter, const Edict* target, const int tusForShot)
{
    int i;
    ReactionFireTargetList* rfts = find(shooter);
 
    assert(rfts);
    assert(target);
 
    for (i = 0; i < rfts->count; i++) {
        /* check if shooter already knows that target */
        if (rfts->targets[i].target == target)
            return;
    }
    if (i >= MAX_RF_TARGETS)
        return;
    rfts->targets[i].target = target;
    rfts->targets[i].triggerTUs = target->TU - tusForShot;
    rfts->count++;
    G_EventReactionFireAddTarget(*shooter, *target, tusForShot, target->moveinfo.steps - 1);
#if DEBUG_RF
    if (!(G_IsAlien(shooter) || G_IsCivilian(shooter)))
        Com_Printf("S%i: added\n", shooter->number);
#endif
}

void ReactionFireTargets::remove (const Edict* shooter, const Edict* target)
{
    ReactionFireTargetList* rfts = find(shooter);
 
    assert(rfts);
    assert(target);
 
    for (int i = 0; i < rfts->count; i++) {
        ReactionFireTarget& t = rfts->targets[i];
        if (t.target != target)
            continue;
 
        /* not the last one? */
        if (i != rfts->count - 1) {
            t.target = rfts->targets[rfts->count - 1].target;
            t.triggerTUs = rfts->targets[rfts->count - 1].triggerTUs;
        }
        rfts->count--;
        G_EventReactionFireRemoveTarget(*shooter, *target, target->moveinfo.steps - 1);
#if DEBUG_RF
        if (!(G_IsAlien(shooter) || G_IsCivilian(shooter)))
            Com_Printf("S%i: removed\n", shooter->number);
#endif
    }
}
 
void ReactionFireTargets::resetTargetList (const Edict* shooter)
{
    ReactionFireTargetList* rfts = find(shooter);
    for (int i = rfts->count - 1; i >= 0; --i)
        remove(shooter, rfts->targets[i].target);
 
    rfts->reset();
}

int ReactionFireTargets::getTriggerTUs (const Edict* shooter, const Edict* target)
{
    const ReactionFireTargetList* rfts = find(shooter);
 
    if (!rfts)
        return -2;  /* the shooter doesn't aim at anything */
 
    assert(target);
 
    for (int i = 0; i < rfts->count; i++) {
        const ReactionFireTarget& t = rfts->targets[i];
        if (t.target == target)
            return t.triggerTUs;
    }
 
    return -1;  /* the shooter doesn't aim at this target */
}
 

bool ReactionFireTargets::hasExpired (const Edict* shooter, const Edict* target, const int tusTarget)
{
    const ReactionFireTargetList* rfts = find(shooter);
 
    if (!rfts)
        return false;   /* the shooter doesn't aim at anything */
 
    assert(target);
 
    for (int i = 0; i < rfts->count; i++) {
        const ReactionFireTarget& t = rfts->targets[i];
        if (t.target == target)
            return t.triggerTUs >= target->TU - tusTarget;
    }
 
    return false;   /* the shooter doesn't aim at this target */
}
 

void ReactionFireTargets::advance (const Edict* shooter, const int tusShot)
{
    ReactionFireTargetList* rfts = find(shooter);
    assert(rfts);
 
    for (int i = 0; i < rfts->count; i++) {
        ReactionFireTarget& t = rfts->targets[i];
        t.triggerTUs -= tusShot;
    }
}

void G_ReactionFireTargetsInit (void)
{
    rft.init();
}

void G_ReactionFireTargetsCreate (const Edict* shooter)
{
    rft.create(shooter);
}

void G_ReactionFireTargetsDestroy (const Edict* shooter)
{
    rft.destroy(shooter);
}
 
class ReactionFire
{
private:
    bool isEnemy(const Actor* shooter, const Edict* target) const;
    bool canReact(Actor* shooter, const Edict* target) const;
    bool canSee(const Actor* shooter, const Edict* target) const;
    bool shoot(Actor* shooter, const pos3_t at, shoot_types_t type, fireDefIndex_t firemode);
    bool isPossible(Actor* shooter, const Edict* target) const;
public:
    void notifyClientOnStep(const Edict* target, int step);
    bool checkExecution(const Edict* target, int step);
    void updateAllTargets(const Edict* target);
    bool tryToShoot(Actor* shooter, const Edict* target);
    bool isInWeaponRange(const Actor* shooter, const Edict* target, const fireDef_t* fd) const;
    const fireDef_t* getFireDef(const Actor* shooter) const;
    void resetTargets(const Edict* shooter);
    void notifyClientOnShot(const Edict* target, int tusTarget);
};
static ReactionFire rf;

const fireDef_t* ReactionFire::getFireDef (const Actor* shooter) const
{
    const FiremodeSettings* fmSetting = &shooter->chr.RFmode;
    if (!fmSetting->isSaneFiremode())
        return nullptr;
 
    const Item* weapon = shooter->getHandItem(fmSetting->getHand());
 
    if (weapon && weapon->ammoDef() && weapon->isWeapon() && !weapon->mustReload()) {
        const fireDef_t* fdArray = weapon->getFiredefs();
        if (fdArray == nullptr)
            return nullptr;
 
        const fireDefIndex_t fmIdx = fmSetting->getFmIdx();
        return &fdArray[fmIdx];
    }
    return nullptr;
}
 
bool ReactionFire::isInWeaponRange (const Actor* shooter, const Edict* target, const fireDef_t* fd) const
{
    assert(fd);
    return fd->range >= VectorDist(shooter->origin, target->origin);
}

static int G_ReactionFireGetTUsForItem (const Actor* shooter, const Edict* target)
{
    const fireDef_t* fd = rf.getFireDef(shooter);
    if (!fd)
        return -1;
 
    const int tus = G_ActorGetModifiedTimeForFiredef(shooter, fd, true);
 
    if (tus <= shooter->TU && rf.isInWeaponRange(shooter, target, fd)) {
        return tus;
    }
 
    return -1;
}

static bool G_ActorHasWorkingFireModeSet (const Edict* actor)
{
    const FiremodeSettings* fmSettings = &actor->chr.RFmode;
    if (!fmSettings->isSaneFiremode())  /* just checks for valid values */
        return false;
 
    const Item* weapon = actor->getHandItem(fmSettings->getHand());
    if (!weapon)
        return false;
    const fireDef_t* fd = weapon->getFiredefs();
    if (fd == nullptr)
        return false;
 
    if (fd->obj->weapons[fd->weapFdsIdx] == fmSettings->getWeapon()
        && fmSettings->getFmIdx() < fd->obj->numFiredefs[fd->weapFdsIdx]) {
        return true;
    }
 
    return false;
}

void G_ReactionFireSettingsUpdate (Actor* actor, fireDefIndex_t fmIdx, actorHands_t hand, const objDef_t* od)
{
    actor->chr.RFmode.set(hand, fmIdx, od); /* FiremodeSettings */
 
    if (!G_ActorHasWorkingFireModeSet(actor)) {
        /* Disable reaction fire if no valid firemode was found. */
        G_ClientStateChange(actor->getPlayer(), actor, ~STATE_REACTION, false);
        G_EventReactionFireChange(*actor);
        G_EventSendState(G_VisToPM(actor->visflags), *actor);
        return;
    }
 
    G_EventReactionFireChange(*actor);
 
    /* If reaction fire is active, update the reserved TUs */
    if (actor->isReaction()) {
        G_ReactionFireSettingsReserveTUs(actor);
    }
}

static bool G_ActorHasEnoughTUsReactionFire (const Edict* ent)
{
    const int TUs = G_ActorGetTUForReactionFire(ent);
    const chrReservations_t* res = &ent->chr.reservedTus;
    return ent->TU - TUs >= res->shot + res->crouch;
}

static bool G_ReactionFireSettingsSetDefault (Edict* ent)
{
    if (G_ActorHasWorkingFireModeSet(ent))
        return true;
 
    actorHands_t hand = ACTOR_HAND_RIGHT;
    const Item* item = ent->getHandItem(hand);
    if (!item) {
        hand = ACTOR_HAND_LEFT;
        item = ent->getHandItem(hand);
    }
 
    if (!item)
        return false;
 
    const objDef_t* weapon = item->getReactionFireWeaponType();
    if (!weapon)
        return false;
 
    ent->chr.RFmode.set(hand, 0, weapon);   /* no special firemode */
 
    if (!G_ActorHasWorkingFireModeSet(ent))
        return false;
 
    if (!G_IsAI(ent))
        G_EventReactionFireChange(*ent);
 
    return true;
}

static bool G_ReactionFireCanBeEnabled (const Edict* ent)
{
    /* check ent is a suitable shooter */
    if (!ent->inuse || !G_IsLivingActor(ent))
        return false;
 
    if (G_MatchIsRunning() && ent->getTeam() != level.activeTeam)
        return false;
 
    /* actor may not carry weapons at all - so no further checking is needed */
    if (!ent->chr.teamDef->weapons && !ent->chr.teamDef->onlyWeapon)
        return false;
 
    if (!ent->chr.inv.holdsReactionFireWeapon()) {
        G_ClientPrintf(ent->getPlayer(), PRINT_HUD, _("No reaction fire enabled weapon."));
        return false;
    }
 
    if (!G_ActorHasWorkingFireModeSet(ent)) {
        G_ClientPrintf(ent->getPlayer(), PRINT_HUD, _("No fire mode selected for reaction fire."));
        return false;
    }
 
    if (!G_ActorHasEnoughTUsReactionFire(ent)) {
        G_ClientPrintf(ent->getPlayer(), PRINT_HUD, _("Not enough TUs left for activating reaction fire."));
        return false;
    }
 
    return true;
}

bool G_ReactionFireSettingsReserveTUs (Actor* ent)
{
    if (G_ReactionFireSettingsSetDefault(ent) && G_ReactionFireCanBeEnabled(ent)) {
        const int TUs = G_ActorGetTUForReactionFire(ent);
        /* Enable requested reaction fire. */
        G_ActorReserveTUs(ent, TUs, ent->chr.reservedTus.shot, ent->chr.reservedTus.crouch);
        return true;
    }
 
    G_ActorReserveTUs(ent, 0, ent->chr.reservedTus.shot, ent->chr.reservedTus.crouch);
    return false;
}
 
inline bool ReactionFire::isPossible (Actor* shooter, const Edict* target) const
{
    return isEnemy(shooter, target) && canReact(shooter, target) && canSee(shooter, target);
}

bool ReactionFire::isEnemy (const Actor* shooter, const Edict* target) const
{
    /* an entity can't reaction fire at itself */
    if (shooter == target)
        return false;
 
    /* Don't react in your own turn */
    if (shooter->getTeam() == level.activeTeam)
        return false;
 
    if (G_IsDead(target))
        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->isSameTeamAs(shooter))
        if (!shooter->isShaken() || (float) shooter->morale / mor_shaken->value > frand())
            return false;
 
    return true;
}

bool ReactionFire::canReact (Actor* shooter, const Edict* target) const
{
    /* shooter can't use RF if is in STATE_DAZED (flashbang impact) */
    if (shooter->isDazed())
        return false;
 
    /* check shooter has reaction fire enabled */
    if (!shooter->isReaction())
        return false;
 
    /* check shooter has weapon in RF hand */
    if (!shooter->getHandItem(shooter->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",
                shooter->chr.name, shooter->getIdNum(), shooter->chr.RFmode.getHand(), shooter->chr.RFmode.getFmIdx());
        shooter->removeReaction();
        return false;
    }
    return true;
}

bool ReactionFire::canSee (const Actor* shooter, const Edict* target) const
{
    if (!G_IsVisibleForTeam(target, shooter->getTeam()))
        return false;
 
    /* check in range and visible */
    const int spotDist = G_VisCheckDist(shooter);
    if (VectorDistSqr(shooter->origin, target->origin) > spotDist * spotDist)
        return false;
 
    const bool frustum = G_FrustumVis(shooter, target->origin);
    if (!frustum)
        return false;
 
    const float actorVis = G_ActorVis(shooter, target, true);
    if (actorVis < ACTOR_VIS_10)
        return false;
 
    return true;
}

void ReactionFire::updateAllTargets (const Edict* target)
{
    Actor* shooter = nullptr;
 
    /* check all possible shooters */
    while ((shooter = G_EdictsGetNextLivingActor(shooter))) {
        /* check whether reaction fire is possible (friend/foe, LoS) */
        if (isPossible(shooter, target)) {
            const int TUs = G_ReactionFireGetTUsForItem(shooter, target);
            if (TUs < 0)
                continue;   /* no suitable weapon */
            rft.add(shooter, target, TUs);
        } else {
            rft.remove(shooter, target);
        }
    }
}
 
void ReactionFire::resetTargets (const Edict* shooter)
{
    rft.resetTargetList(shooter);
}

bool ReactionFire::shoot (Actor* shooter, const pos3_t at, shoot_types_t type, fireDefIndex_t firemode)
{
    const Item* weapon = nullptr;
    if (IS_SHOT_RIGHT(type)) {
        weapon = shooter->getRightHandItem();
        if (!weapon)
            return false;
    } else {
        weapon = shooter->getLeftHandItem();
        if (!weapon)
            return false;
    }
 
    const fireDef_t* fdArray = weapon->getFiredefs();
    if (!fdArray)
        return false;
 
    /* Adjust the number of samples we take so that we don't end firing thousands of shots
     * in case the fire mode is multi-shot */
    const int shotsPerFD = fdArray[firemode].shots;
    const int samples = std::max(1, 100 / shotsPerFD);
    const Player& player = shooter->getPlayer();
    shot_mock_t mock;
    for (int i = 0; i < samples; ++i)
        if (!G_ClientShoot(player, shooter, at, type, firemode, &mock, false, 0))
            break;
 
    /* this is the max amount of friendly units that were hit during the mock calculation */
    const int maxShots = samples * shotsPerFD;
    int maxff;
    if (shooter->isInsane())
        maxff = maxShots;
    else if (shooter->isRaged())
        maxff = maxShots * 2 / 3;
    else if (shooter->isPanicked())
        maxff = maxShots / 3;
    else if (shooter->isShaken())
        maxff = maxShots / 6;
    else
        maxff = maxShots / 20;
 
    /* calculate the mock values - e.g. how many friendly units we would hit
     * when opening the reaction fire */
    const int ff = mock.friendCount + (G_IsAlien(shooter) ? 0 : mock.civilian);
    const int hits = shooter->isInsane() ? ff + mock.enemyCount : mock.enemyCount;
    if (ff <= maxff && hits > 0)
        return G_ClientShoot(player, shooter, at, type, firemode, nullptr, false, 0);
 
    return false;
}

bool ReactionFire::tryToShoot (Actor* shooter, const Edict* target)
{
    /* check for valid target */
    assert(target);
 
    /* shooter can't take a reaction shot if it's not possible - and check that
     * the target is still alive */
    if (!isPossible(shooter, target)) {
        rft.remove(shooter, target);
        return false;
    }
 
    /* take the shot */
    const actorHands_t hand = shooter->chr.RFmode.getHand();
    const shoot_types_t type = (hand == ACTOR_HAND_RIGHT ? ST_RIGHT_REACTION
            : (hand == ACTOR_HAND_LEFT ? ST_LEFT_REACTION : ST_NUM_SHOOT_TYPES));
    const bool tookShot = rf.shoot(shooter, target->pos, type, shooter->chr.RFmode.getFmIdx());
 
    if (tookShot) {
        /* clear any shakenness */
        shooter->removeShaken();
    }
 
    return tookShot;
}
 
void ReactionFire::notifyClientOnShot (const Edict* target, int tusTarget)
{
    rft.notifyClientOnShot(target, tusTarget);
}
 
void ReactionFire::notifyClientOnStep (const Edict* target, int step)
{
    rft.notifyClientOnStep(target, step);
}

bool ReactionFire::checkExecution (const Edict* target, int step)
{
    Actor* shooter = nullptr;
    bool fired = false;
 
    /* check all possible shooters */
    while ((shooter = G_EdictsGetNextLivingActor(shooter))) {
        const int tus = G_ReactionFireGetTUsForItem(shooter, target);
        /* indicates an RF weapon is there */
        if (tus <= 1)
            continue;
        if (!rft.hasExpired(shooter, target, 0))
            continue;
        if (!rf.tryToShoot(shooter, target)) {
            G_ReactionFireNotifyClientRFAborted(shooter, target, step);
            continue;
        }
        rft.advance(shooter, tus);
        fired |= true;
    }
    return fired;
}
 
#if DEBUG_RF
static void G_ReactionFirePrintSituation (Edict* target)
{
    if (!G_IsAlien(target))
        return;
 
    Com_Printf("Alien %i at %i/%i/%i TU:%i\n", target->number, target->pos[0], target->pos[1], target->pos[2], target->TU);
 
    Actor* shooter = nullptr;
    /* check all possible shooters */
    while ((shooter = G_EdictsGetNextLivingActor(shooter))) {
        if (G_IsAlien(shooter) || G_IsCivilian(shooter))
            continue;
        char msgHdr[100];
        Com_sprintf(msgHdr, sizeof(msgHdr), "S%i: at %i/%i/%i RF: ", shooter->number, shooter->pos[0], shooter->pos[1], shooter->pos[2]);
        int ttus = rft.getTriggerTUs(shooter, target);
        if (ttus == -2)
            Com_Printf("%s not initialized\n", msgHdr);
        if (ttus == -1)
            Com_Printf("%s not aiming\n", msgHdr);
        else if (rft.hasExpired(shooter, target, 0))
            Com_Printf("expired\n", msgHdr);
        else
            Com_Printf("%s not yet: %i\n", msgHdr, ttus);
    }
}
#endif

bool G_ReactionFireOnMovement (Actor* target, int step)
{
#if DEBUG_RF
    G_ReactionFirePrintSituation(target);
#endif
    rf.notifyClientOnStep(target, step);
 
    /* Check to see whether this resolves any reaction fire */
    const bool fired = rf.checkExecution(target, step);
 
    /* Check to see whether this triggers any reaction fire */
    rf.updateAllTargets(target);
 
    return fired;
}
 
static void G_ReactionFireNotifyClientStartShot (const Edict* target)
{
    rft.notifyClientMove(target, MAX_ROUTE, true);
}
 
static void G_ReactionFireNotifyClientEndShot (const Edict* target)
{
    rft.notifyClientMove(target, MAX_ROUTE, false);
}

void G_ReactionFirePreShot (const Actor* target, const int fdTime)
{
    bool repeat = true;
 
    /* Check to see whether this triggers any reaction fire */
    G_ReactionFireNotifyClientStartShot(target);
    rf.updateAllTargets(target);
    rf.notifyClientOnShot(target, fdTime);
 
    /* if any reaction fire occurs, we have to loop through all entities again to allow
     * multiple (fast) RF snap shots before a (slow) aimed shot from the target occurs. */
    while (repeat) {
        Actor* shooter = nullptr;
        repeat = false;
        /* check all ents to see who wins and who loses a draw */
        while ((shooter = G_EdictsGetNextLivingActor(shooter))) {
            const int entTUs = G_ReactionFireGetTUsForItem(shooter, target);
            /* indicates an RF weapon is there */
            if (entTUs < 1)
                continue;
            if (!rft.hasExpired(shooter, target, fdTime))
                continue;
            if (!rf.tryToShoot(shooter, target)) {
                G_ReactionFireNotifyClientRFAborted(shooter, target, MAX_ROUTE);
                continue;
            }
            repeat = true;
            rft.advance(shooter, entTUs);
        }
    }
}

void G_ReactionFireOnDead (const Actor* target)
{
    assert(G_IsDead(target));
    rf.updateAllTargets(target);
    rf.resetTargets(target);
}

void G_ReactionFirePostShot (Actor* target)
{
    /* Check to see whether this resolves any reaction fire */
    rf.notifyClientOnShot(target, 0);
    rf.checkExecution(target, MAX_ROUTE);
    G_ReactionFireNotifyClientEndShot(target);
}

void G_ReactionFireOnEndTurn (void)
{
    /* we explicitly do nothing at end of turn, just reset the table */
    rft.reset();
}

void G_ReactionFireReset (int team)
{
    Actor* actor = nullptr;
 
    while ((actor = G_EdictsGetNextLivingActorOfTeam(actor, team))) {
        actor->removeShaken();
    }
}
 
void G_ReactionFireNotifyClientStartMove (const Actor* target)
{
    /* note that this is sent _before_ the actual move event, so we can't use the step number */
    rft.notifyClientMove(target, MAX_ROUTE, true);
}
 
void G_ReactionFireNotifyClientEndMove (const Actor* target)
{
    rft.notifyClientMove(target, target->moveinfo.steps - 1, false);
}
 
void G_ReactionFireNotifyClientRFAborted (const Actor* shooter, const Edict* target, int step)
{
    rft.notifyClientRFAborted(shooter, target, step);
}