src/hcode/btech/mech.events.c File Reference

#include <math.h>
#include "mech.events.h"
#include "mech.notify.h"
#include "p.aero.move.h"
#include "p.mech.utils.h"
#include "p.mech.update.h"
#include "p.mech.los.h"
#include "p.btechstats.h"
#include "p.mech.sensor.h"
#include "p.mech.partnames.h"
#include "p.mech.combat.misc.h"

Include dependency graph for mech.events.c:

Go to the source code of this file.

Data Structures
struct	foo
Functions
void	mech_heartbeat (MECH *mech)
static int	factoral (int n)
void	mech_standfail_event (MUXEVENT *e)
void	mech_fall_event (MUXEVENT *e)
void	mech_lock_event (MUXEVENT *e)
void	mech_stabilizing_event (MUXEVENT *e)
void	mech_jump_event (MUXEVENT *e)
void	mech_recovery_event (MUXEVENT *e)
void	ProlongUncon (MECH *mech, int len)
void	mech_lateral_event (MUXEVENT *e)
void	mech_move_event (MUXEVENT *e)
void	mech_stand_event (MUXEVENT *e)
void	mech_plos_event (MUXEVENT *e)
void	aero_move_event (MUXEVENT *e)
void	very_fake_func (MUXEVENT *e)
void	mech_crewstun_event (MUXEVENT *e)
void	unstun_crew_event (MUXEVENT *e)
void	mech_unjam_ammo_event (MUXEVENT *objEvent)
void	check_stagger_event (MUXEVENT *event)
int	calcStaggerBTHMod (MECH *mech)
Variables
int	PilotStatusRollNeeded []
foo	lateral_modes []

---

Function Documentation

void aero_move_event

(

MUXEVENT *

e

)

Definition at line 282 of file mech.events.c.

References aero_move_event(), aero_UpdateHeading(), aero_UpdateSpeed(), my_event_type::data, DS_BlastNearbyMechsAndTrees(), EVENT_MOVE, Fallen, FuelCheck(), IsDS, Landed, MechDesiredFacing, MechDesiredSpeed, MechElevation, MECHEVENT, MechFacing, MechSpeed, MechStartFZ, MechZ, move_mech(), MOVE_TICK, muxevent_tick, RollingT, Started, UpdateHeading(), UpdateSpeed(), and WEAPON_TICK.

Referenced by aero_move_event().

{
        MECH *mech = (MECH *) e->data;

        if(!Landed(mech)) {
                /* Returns 1 only if we
                   1) Ran out of fuel, and
                   2) Were VTOL, and
                   3) Crashed 
                 */
                if(FuelCheck(mech))
                        return;
                /* Genuine CHEAT :-) */
                if(Started(mech)) {
                        aero_UpdateHeading(mech);
                        aero_UpdateSpeed(mech);
                }
                if(Fallen(mech))
                        MechStartFZ(mech) = MechStartFZ(mech) - 1;
                move_mech(mech);
                if(IsDS(mech) && MechZ(mech) <= (MechElevation(mech) + 5) &&
                   ((muxevent_tick / WEAPON_TICK) % 10) == 0)
                        DS_BlastNearbyMechsAndTrees(mech,
                                                                                "You are hit by the DropShip's plasma exhaust!",
                                                                                "is hit directly by DropShip's exhaust!",
                                                                                "You are hit by the DropShip's plasma exhaust!",
                                                                                "is hit by DropShip's exhaust!",
                                                                                "light up and burn.", 8);
                MECHEVENT(mech, EVENT_MOVE, aero_move_event, MOVE_TICK, 0);
        } else if(Landed(mech) && !Fallen(mech) && RollingT(mech)) {
                UpdateHeading(mech);
                UpdateSpeed(mech);
                move_mech(mech);
                if(fabs(MechSpeed(mech)) > 0.0 ||
                   fabs(MechDesiredSpeed(mech)) > 0.0 ||
                   MechDesiredFacing(mech) != MechFacing(mech))
                        if(!FuelCheck(mech))
                                MECHEVENT(mech, EVENT_MOVE, aero_move_event, MOVE_TICK, 0);
        }
}

int calcStaggerBTHMod

(

MECH *

mech

)

Definition at line 534 of file mech.events.c.

References MechTons, StaggerLevel, and Started.

Referenced by check_stagger_event(), LandMech(), and mech_jump().

{
        int bthMod = 0;
        int tonnageMod = 0;

        if(!Started(mech)) {
                bthMod = 999;
        } else {
                bthMod = StaggerLevel(mech);

                if(MechTons(mech) <= 35)
                        tonnageMod = 1;
                else if(MechTons(mech) <= 55)
                        tonnageMod = 0;
                else if(MechTons(mech) <= 75)
                        tonnageMod = -1;
                else
                        tonnageMod = -2;

                bthMod += tonnageMod;
        }

        return bthMod;
}

void check_stagger_event

(

MUXEVENT *

event

)

Definition at line 426 of file mech.events.c.

References calcStaggerBTHMod(), CLASS_MECH, my_event_type::data, Fallen, Jumping, MadePilotSkillRoll(), mech_notify(), MECHALL, MechFalls(), MechLOSBroadcast(), MechType, MECH::mynum, MECH::rd, SendDebug, mech_rd::staggerDamage, StaggerLevel, StopStaggerCheck, and tprintf().

{
        MECH *mech = (MECH *) event->data;      /* get the mech */

        SendDebug(tprintf("Triggered stagger check for %d.", mech->mynum));

        if((StaggerLevel(mech) < 1) || Fallen(mech) ||
           (MechType(mech) != CLASS_MECH)) {
                StopStaggerCheck(mech);
                return;
        }

        if(Jumping(mech)) {
                return;
        }

        mech_notify(mech, MECHALL, "You stagger from the damage!");
        if(!MadePilotSkillRoll(mech, calcStaggerBTHMod(mech))) {
                mech_notify(mech, MECHALL,
                                        "You loose the battle with gravity and tumble over!!");
                MechLOSBroadcast(mech, "tumbles over, staggered by the damage!");
                MechFalls(mech, 1, 0);
        }

        StopStaggerCheck(mech);
        /* Since stagger rolls happen much more often now, this adds 10 damage
         * points of 'buffer' to mech that was just forced to make a stager roll.
         * Mechs whose damage accumulation times out without making a roll (<20
         * damage) don't get this help. This 10 points of damage assistance slowly
         * times out in CheckDamage, or can be erased by weapons fire */
        mech->rd.staggerDamage = -10;
}

static int factoral

(

int

n

)

[static]

Definition at line 30 of file mech.events.c.

Referenced by mech_fall_event().

{
        int i, j = 0;

        for(i = 1; i <= n; i++)
                j += i;
        return j;
}

void mech_crewstun_event

(

MUXEVENT *

e

)

Definition at line 331 of file mech.events.c.

References CLASS_MECH, my_event_type::data, Destroyed, mech_notify(), MECH_STUNNED, MECHALL, MechCritStatus, MechType, and Started.

Referenced by ModifyHeadHit().

{
        MECH *mech = (MECH *) e->data;

        if(!mech)
                return;
        if(!Started(mech) || Destroyed(mech)) {
                if(MechCritStatus(mech) & MECH_STUNNED)
                        MechCritStatus(mech) &= ~MECH_STUNNED;
                return;
        }
        if(MechType(mech) != CLASS_MECH)
                mech_notify(mech, MECHALL,
                                        "%ch%cgThe crew recovers from their bewilderment!%cn");
        else
                mech_notify(mech, MECHALL,
                                        "%ch%cgYou recover from your stunning experience!%cn");

        if(MechCritStatus(mech) & MECH_STUNNED)
                MechCritStatus(mech) &= ~MECH_STUNNED;
}

void mech_fall_event

(

MUXEVENT *

e

)

Definition at line 47 of file mech.events.c.

References AeroFreeFuel, AeroFuel, CLASS_VTOL, my_event_type::data, my_event_type::data2, EVENT_FALL, factoral(), FALL_ACCEL, FALL_TICK, FlyingT, JUMPING, MarkForLOSUpdate(), mech_fall_event(), mech_notify(), MECHALL, MECHEVENT, MechFalls(), MechFZ, MechLOSBroadcast(), MechsElevation, MechStatus, MechType, MechZ, ROTOR, SectIsDestroyed, Started, and ZSCALE.

Referenced by cause_armordamage(), char_disembark(), FuelCheck(), mech_dropoff(), mech_fall_event(), mech_ood_damage(), mech_shutdown(), and StartVTOLCrash().

{
        MECH *mech = (MECH *) e->data;
        int fallspeed = (int) e->data2;
        int fallen_elev;

        if(Started(mech) && fallspeed >= 0)
                return;
        if(fallspeed <= 0 && (!Started(mech) || !(FlyingT(mech)) ||
                                                  ((AeroFuel(mech) <= 0) && !AeroFreeFuel(mech)) ||
                                                  ((MechType(mech) == CLASS_VTOL) &&
                                                   (SectIsDestroyed(mech, ROTOR)))))
                fallspeed -= FALL_ACCEL;
        else
                fallspeed += FALL_ACCEL;
        MarkForLOSUpdate(mech);
        if(MechsElevation(mech) > abs(fallspeed)) {
                MechZ(mech) -= abs(fallspeed);
                MechFZ(mech) = MechZ(mech) * ZSCALE;
                MECHEVENT(mech, EVENT_FALL, mech_fall_event, FALL_TICK, fallspeed);
                return;
        }
        /* Time to hit da ground */
        fallen_elev = factoral(abs(fallspeed));
        mech_notify(mech, MECHALL, "You hit the ground!");
        MechLOSBroadcast(mech, "hits the ground!");
        MechFalls(mech, fallen_elev, 0);
        MechStatus(mech) &= ~JUMPING;
}

void mech_heartbeat

(

MECH *

mech

)

Definition at line 25 of file mech.events.c.

References UpdateRecycling.

Referenced by heartbeat_dispatch().

                                {
    UpdateRecycling(mech);
    return;
}

void mech_jump_event

(

MUXEVENT *

e

)

Definition at line 113 of file mech.events.c.

References my_event_type::data, EVENT_JUMP, JUMP_TICK, Jumping, mech_jump_event(), MECHEVENT, move_mech(), and StopJump.

Referenced by mech_jump(), and mech_jump_event().

{
        MECH *mech = (MECH *) e->data;

        MECHEVENT(mech, EVENT_JUMP, mech_jump_event, JUMP_TICK, 0);
        move_mech(mech);
        if(!Jumping(mech))
                StopJump(mech);
}

void mech_lateral_event

(

MUXEVENT *

e

)

Definition at line 188 of file mech.events.c.

References my_event_type::data, my_event_type::data2, EVENT_SIDESLIP, full, mech_printf(), MECHALL, MECHEVENT, MechLateral, MechMove, MOVE_QUAD, foo::ofs, SideSlipping, Started, and StopSideslip.

Referenced by mech_lateral().

{
        MECH *mech = (MECH *) e->data;
        int latmode = (int) e->data2;

        if(!mech || !Started(mech))
                return;
        mech_printf(mech, MECHALL,
                                "Lateral movement mode change to %s completed.",
                                lateral_modes[latmode].full);
        MechLateral(mech) = lateral_modes[latmode].ofs;
#ifdef BT_MOVEMENT_MODES
        if(MechMove(mech) != MOVE_QUAD) {
                if(MechLateral(mech) == 0)
                        StopSideslip(mech);
                else if(!(SideSlipping(mech)))
                        MECHEVENT(mech, EVENT_SIDESLIP, mech_sideslip_event, 1, 0);
        }
#endif
}

void mech_lock_event

(

MUXEVENT *

e

)

Definition at line 78 of file mech.events.c.

References my_event_type::data, FindObjectsData(), FlMechRange, getMap(), GetMechToMechID(), InLineOfSight(), mech_printf(), MECHALL, MechTarget, MechTargX, MechTargY, MechX, and MechY.

Referenced by mech_settarget().

{
        MECH *mech = (MECH *) e->data;
        MAP *map;
        MECH *target;

        if(MechTarget(mech) >= 0) {
                map = getMap(mech->mapindex);
                target = FindObjectsData(MechTarget(mech));
                if(!target)
                        return;
                if(!InLineOfSight(mech, target, MechX(target), MechY(target),
                                                  FlMechRange(map, mech, target)))
                        return;
                mech_printf(mech, MECHALL,
                                        "The sensors acquire a stable lock on %s.",
                                        GetMechToMechID(mech, target));
        } else if(MechTargX(mech) >= 0 && MechTargY(mech) >= 0)
                mech_printf(mech, MECHALL,
                                        "The sensors acquire a stable lock on (%d,%d).",
                                        MechTargX(mech), MechTargY(mech));

}

void mech_move_event

(

MUXEVENT *

e

)

Definition at line 209 of file mech.events.c.

References BRIDGE, CLASS_VEH_NAVAL, CLASS_VTOL, my_event_type::data, EVENT_MOVE, FuelCheck(), ICE, IsMechLegLess(), Jumping, Landed, mech_move_event(), MechDesiredFacing, MechDesiredSpeed, MECHEVENT, MechFacing, MechMove, MechRTerrain, MechSpeed, MechType, MechVerticalSpeed, move_mech(), MOVE_SUB, MOVE_TICK, OODing, UpdateHeading(), UpdateSpeed(), and WATER.

Referenced by mech_move_event().

{
        MECH *mech = (MECH *) e->data;

        if(MechType(mech) == CLASS_VTOL)
                if(Landed(mech) || FuelCheck(mech))
                        return;
        UpdateHeading(mech);
        if((IsMechLegLess(mech)) || Jumping(mech) || OODing(mech)) {
                if(MechDesiredFacing(mech) != MechFacing(mech))
                        MECHEVENT(mech, EVENT_MOVE, mech_move_event, MOVE_TICK, 0);
                return;
        }
        UpdateSpeed(mech);
        move_mech(mech);

        if(mech->mapindex < 0)
                return;

        if(MechType(mech) == CLASS_VEH_NAVAL && MechRTerrain(mech) != BRIDGE &&
           MechRTerrain(mech) != ICE && MechRTerrain(mech) != WATER)
                return;

        if(MechSpeed(mech) || MechDesiredSpeed(mech) ||
           MechDesiredFacing(mech) != MechFacing(mech) ||
           ((MechType(mech) == CLASS_VTOL || MechMove(mech) == MOVE_SUB) &&
                MechVerticalSpeed(mech)))
                MECHEVENT(mech, EVENT_MOVE, mech_move_event, MOVE_TICK, 0);
}

void mech_plos_event

(

MUXEVENT *

e

)

Definition at line 248 of file mech.events.c.

References AA_TECH, my_event_type::data, EVENT_PLOS, FindObjectsData(), FlMechRange, getMap(), MECH::mapindex, MECH::mapnumber, mech_plos_event(), MECHEVENT, MECHLOSFLAG_SEEN, MechPNumSeen, MechSpecials, MECH::mynum, PLOS_TICK, Sensor_DoWeSeeNow(), and Started.

Referenced by mech_plos_event().

{
        MECH *mech = (MECH *) e->data, *target;
        MAP *map;
        int mapvis;
        int maplight;
        float range;
        int i;

        if(!Started(mech))
                return;
        if(!(map = getMap(mech->mapindex)))
                return;
        MECHEVENT(mech, EVENT_PLOS, mech_plos_event, PLOS_TICK, 0);
        if(!MechPNumSeen(mech) && !(MechSpecials(mech) & AA_TECH))
                return;
        mapvis = map->mapvis;
        maplight = map->maplight;
        MechPNumSeen(mech) = 0;
        for(i = 0; i < map->first_free; i++)
                if(map->mechsOnMap[i] > 0 && map->mechsOnMap[i] != mech->mynum)
                        if(!(map->LOSinfo[mech->mapnumber][i] & MECHLOSFLAG_SEEN)) {
                                target = FindObjectsData(map->mechsOnMap[i]);
                                if(!target)
                                        continue;
                                range = FlMechRange(map, mech, target);
                                MechPNumSeen(mech)++;
                                Sensor_DoWeSeeNow(mech, &map->LOSinfo[mech->mapnumber][i],
                                                                  range, -1, -1, target, mapvis, maplight,
                                                                  map->cloudbase, 1, 0);

                        }
}

void mech_recovery_event

(

MUXEVENT *

e

)

Definition at line 125 of file mech.events.c.

References my_event_type::data, Destroyed, handlemwconc(), mech_notify(), MECHALL, MechStatus, Uncon, and UNCONSCIOUS.

Referenced by ProlongUncon().

{
        MECH *mech = (MECH *) e->data;

        if(Destroyed(mech) || !Uncon(mech))
                return;
        if(handlemwconc(mech, 0)) {
                MechStatus(mech) &= ~UNCONSCIOUS;
                mech_notify(mech, MECHALL, "The pilot regains consciousness!");
                return;
        }
}

void mech_stabilizing_event

(

MUXEVENT *

e

)

Definition at line 105 of file mech.events.c.

References my_event_type::data, mech_notify(), and MECHSTARTED.

Referenced by LandMech(), and MechFalls().

{
        MECH *mech = (MECH *) e->data;

        mech_notify(mech, MECHSTARTED,
                                "%cgYou have finally stabilized after your jump.%c");
}

void mech_stand_event

(

MUXEVENT *

e

)

Definition at line 239 of file mech.events.c.

References my_event_type::data, MakeMechStand, mech_notify(), MECHALL, and MechLOSBroadcast().

Referenced by mech_stand().

{
        MECH *mech = (MECH *) e->data;

        MechLOSBroadcast(mech, "stands up!");
        mech_notify(mech, MECHALL, "You have finally finished standing up.");
        MakeMechStand(mech);
}

void mech_standfail_event

(

MUXEVENT *

e

)

Definition at line 39 of file mech.events.c.

References my_event_type::data, mech_notify(), and MECHALL.

Referenced by mech_stand().

{
        MECH *mech = (MECH *) e->data;

        mech_notify(mech, MECHALL,
                                "%cgYou have finally recovered from your attempt to stand.%c");
}

void mech_unjam_ammo_event

(

MUXEVENT *

objEvent

)

Definition at line 365 of file mech.events.c.

References my_event_type::data, my_event_type::data2, decrement_ammunition(), FindAndCheckAmmo(), FindPilotGunnery(), FindWeaponIndex(), FindWeaponNumberOnMech(), get_parts_long_name(), I2Weapon, MadePilotSkillRoll(), mech_notify(), mech_printf(), MECHALL, MechLOSBroadcast(), MECHPILOT, MechWeapons, RAC, Roll(), SetPartTempNuke, Started, TIC_NUM_DESTROYED, and Uncon.

Referenced by mech_unjamammo_func().

{
        MECH *objMech = (MECH *) objEvent->data;        /* get the mech */
        int wWeapNum = (int) objEvent->data2;   /* and now the weapon number */
        int wSect, wSlot, wWeapStatus, wWeapIdx;
        int ammoLoc, ammoCrit,ammoLoc1, ammoCrit1;
        int wRoll = 0;
        int wRollNeeded = 0;

        if(Uncon(objMech) || !Started(objMech))
                return;

        wWeapStatus = FindWeaponNumberOnMech(objMech, wWeapNum, &wSect, &wSlot);

        if(wWeapStatus == TIC_NUM_DESTROYED)    /* return if the weapon has been destroyed */
                return;

        wWeapIdx = FindWeaponIndex(objMech, wWeapNum);

        if(!FindAndCheckAmmo(objMech, wWeapIdx, wSect, wSlot, &ammoLoc, &ammoCrit, &ammoLoc1, &ammoCrit1, 0)) {
                SetPartTempNuke(objMech, wSect, wSlot, 0);

                mech_printf(objMech, MECHALL,
                                        "You finish bouncing around and realize you no longer have ammo for your %s!",
                                        get_parts_long_name(I2Weapon(wWeapIdx), 0));
                return;
        }

        if(MechWeapons[wWeapStatus].special & RAC) {
                wRoll = Roll();
                wRollNeeded = FindPilotGunnery(objMech, wWeapStatus) + 3;

                mech_notify(objMech, MECHPILOT,
                                        "You make a roll to unjam the weapon!");
                mech_printf(objMech, MECHPILOT,
                                        "Modified Gunnery Skill: BTH %d\tRoll: %d",
                                        wRollNeeded, wRoll);

                if(wRoll < wRollNeeded) {
                        mech_notify(objMech, MECHALL,
                                                "Your attempt to remove the jammed slug fails. You'll need to try again to clear it.");
                        return;
                }
        } else {
                if(!MadePilotSkillRoll(objMech, 0)) {
                        mech_notify(objMech, MECHALL,
                                                "Your attempt to remove the jammed slug fails. You'll need to try again to clear it.");
                        return;
                }
        }

        SetPartTempNuke(objMech, wSect, wSlot, 0);
        mech_printf(objMech, MECHALL,
                                "You manage to clear the jam on your %s!",
                                get_parts_long_name(I2Weapon(wWeapIdx), 0));
        MechLOSBroadcast(objMech, "ejects a mangled shell!");

        decrement_ammunition(objMech, wWeapNum, wSect, wSlot, ammoLoc, ammoCrit, ammoLoc1, ammoCrit1, 0);

}

void ProlongUncon	(	MECH *	mech,
		int	len
	)

Definition at line 138 of file mech.events.c.

References Destroyed, EVENT_RECOVERY, mech_recovery_event(), MECHEVENT, MechStatus, muxevent_last_type_data(), muxevent_remove_type_data(), Recovering, and UNCONSCIOUS.

Referenced by handlemwconc().

{
        int l;

        if(Destroyed(mech))
                return;
        if(!Recovering(mech)) {
                MechStatus(mech) |= UNCONSCIOUS;
                MECHEVENT(mech, EVENT_RECOVERY, mech_recovery_event, len, 0);
                return;
        }
        l = muxevent_last_type_data(EVENT_RECOVERY, (void *) mech) + len;
        muxevent_remove_type_data(EVENT_RECOVERY, (void *) mech);
        MECHEVENT(mech, EVENT_RECOVERY, mech_recovery_event, l, 0);
}

void unstun_crew_event

(

MUXEVENT *

e

)

Definition at line 353 of file mech.events.c.

References CREW_STUNNED, CrewStunned, my_event_type::data, mech_notify(), MECHALL, and MechTankCritStatus.

{
        MECH *mech = (MECH *) e->data;

        if(CrewStunned(mech) > 1)       /* If we've been stunned again! */
                return;

        mech_notify(mech, MECHALL,
                                "Your head clears and you're able to control your vehicle again.");
        MechTankCritStatus(mech) &= ~CREW_STUNNED;
}

void very_fake_func

(

MUXEVENT *

e

)

Definition at line 323 of file mech.events.c.

Referenced by describe_repairs(), loadrepairs(), muxevent_tickmech_removegun(), muxevent_tickmech_removepart(), and save_event().

{

}

---

Variable Documentation

struct foo lateral_modes[]

Referenced by LateralDesc(), and mech_lateral().

int PilotStatusRollNeeded[]

Definition at line 892 of file btechstats.c.

---