src/hcode/btech/mech.ammodump.c

Go to the documentation of this file.

/*
 * Author: Cord Awtry <kipsta@mediaone.net>
 * Author: Cord Awtry <kipsta@mediaone.net>
 *  Copyright (c) 2000-2002 Cord Awtry
 *       All rights reserved
 *
 * Based on work that was:
 *  Copyright (c) 1997 Markus Stenberg
 *  Copyright (c) 1998-2000 Thomas Wouters
 */

#include "mech.h"
#include "mech.events.h"
#include "p.mech.ammodump.h"
#include "p.mech.build.h"
#include "p.mech.combat.misc.h"
#include "p.mech.damage.h"
#include "p.mech.partnames.h"
#include "p.mech.utils.h"

static void mech_dump_event(MUXEVENT * ev)
{
        MECH *mech = (MECH *) ev->data;
        int arg = (int) ev->data2;
        int loc;
        int i, l;
        int d, e = 0;
        char buf[SBUF_SIZE];
        int weapindx;

        if(!Started(mech))
                return;
        i = MechType(mech) == CLASS_MECH ? 7 : 5;
        /* Global ammo droppage */
        if(!arg) {
                for(; i >= 0; i--)
                        for(l = CritsInLoc(mech, i) - 1; l >= 0; l--)
                                if(IsAmmo(GetPartType(mech, i, l)))
                                        if(GetPartData(mech, i, l))
                                                Dump_Decrease(mech, i, l, &e);
                if(e > 1)
                        MECHEVENT(mech, EVENT_DUMP, mech_dump_event, DUMP_GRAD_TICK, arg);
                else {
                        mech_notify(mech, MECHALL, "All ammunition dumped.");
                        MechLOSBroadcast(mech,
                                                         "no longer has ammo dumping from hatches on its back.");
                }
                return;
        }
        if(arg < 256) {
                loc = arg - 1;
                l = CritsInLoc(mech, loc);
                for(i = 0; i < l; i++)
                        if(IsAmmo(GetPartType(mech, loc, i)))
                                if(!PartIsNonfunctional(mech, loc, i))
                                        if((d = GetPartData(mech, loc, i)))
                                                Dump_Decrease(mech, loc, i, &e);
                if(e > 1)
                        MECHEVENT(mech, EVENT_DUMP, mech_dump_event, DUMP_GRAD_TICK, arg);
                else if(e == 1 && Started(mech)) {
                        ArmorStringFromIndex(loc, buf, MechType(mech), MechMove(mech));
                        mech_printf(mech, MECHALL, "All ammunition in %s dumped.", buf);
                        MechLOSBroadcast(mech,
                                                         "no longer has ammo dumping from hatches on its back.");
                }
                return;
        }
        if(arg < 65536) {
                weapindx = (arg / 256) - 1;
                for(; i >= 0; i--)
                        for(l = CritsInLoc(mech, i) - 1; l >= 0; l--)
                                if(IsAmmo(GetPartType(mech, i, l)))
                                        if(Ammo2WeaponI(GetPartType(mech, i, l)) == weapindx)
                                                if(GetPartData(mech, i, l))
                                                        Dump_Decrease(mech, i, l, &e);
                if(e > 1)
                        MECHEVENT(mech, EVENT_DUMP, mech_dump_event, DUMP_GRAD_TICK, arg);
                else {
                        mech_printf(mech, MECHALL, "Ammunition for %s dumped!",
                                                get_parts_long_name(I2Weapon(weapindx), 0));
                        MechLOSBroadcast(mech,
                                                         "no longer has ammo dumping from hatches on its back.");
                }
                return;
        }
        l = ((arg >> 16) & 0xFF) - 1;
        i = ((arg >> 24) & 0xFF) - 1;
        e = 0;
        if(GetPartData(mech, l, i))
                Dump_Decrease(mech, l, i, &e);
        if(e > 1) {
                MECHEVENT(mech, EVENT_DUMP, mech_dump_event, DUMP_GRAD_TICK, arg);
        } else {
                ArmorStringFromIndex(l, buf, MechType(mech), MechMove(mech));
                mech_printf(mech, MECHALL,
                                        "Ammunition in %s crit %i dumped!", buf, i + 1);
                MechLOSBroadcast(mech,
                                                 "no longer has ammo dumping from hatches on its back.");
        }
}

void mech_dump(dbref player, void *data, char *buffer)
{
        MECH *mech = (MECH *) data;
        int argc;
        char *args[2];
        int weapnum;
        int weapindx;
        int section;
        int critical;
        int ammoLoc;
        int ammoCrit;
        int loc;
        int i, l, count = 0, d;
        char buf[MBUF_SIZE];
        int type = 0;

        cch(MECH_USUAL);
        argc = mech_parseattributes(buffer, args, 2);
        DOCHECK(argc < 1, "Not enough arguments to the function");
        weapnum = atoi(args[0]);

        DOCHECKMA(Jumping(mech), "You can't dump ammo while jumping!");
        DOCHECKMA(IsRunning(MechDesiredSpeed(mech), MMaxSpeed(mech)),
                          "You can't dump ammo while running!");

        if(!strcasecmp(args[0], "stop")) {
                DOCHECKMA(!Dumping(mech), "You aren't dumping anything!");
                mech_notify(mech, MECHALL, "Ammo dumping halted.");
                StopDump(mech);
                MechLOSBroadcast(mech,
                                                 "no longer has ammo dumping from hatches on its back.");
                return;
        } else if(!strcasecmp(args[0], "all")) {
                count = 0;
                i = MechType(mech) == CLASS_MECH ? 7 : 5;
                for(; i >= 0; i--)
                        for(l = CritsInLoc(mech, i) - 1; l >= 0; l--)
                                if(IsAmmo(GetPartType(mech, i, l)))
                                        if(GetPartData(mech, i, l))
                                                count++;
                DOCHECKMA(!count, "You have no ammo to dump!");
                DOCHECKMA(Dumping_Type(mech, 0), "You're already dumping your ammo!");
                StopDump(mech);
                mech_notify(mech, MECHALL, "Starting dumping of all ammunition..");
                MechLOSBroadcast(mech,
                                                 "starts dumping ammo from hatches on its back.");
                MECHEVENT(mech, EVENT_DUMP, mech_dump_event, DUMP_GRAD_TICK, 0);
                return;
        } else if(!weapnum && strcmp(args[0], "0")) {
                /* Try to find hitloc instead */
                DOCHECKMA(Dumping(mech), "You're already dumping some ammo!");
                loc = ArmorSectionFromString(MechType(mech), MechMove(mech), args[0]);
                DOCHECK(loc < 0, "Invalid location or weapon number!");
                ArmorStringFromIndex(loc, buf, MechType(mech), MechMove(mech));
                if(args[1]) {
                        i = atoi(args[1]);
                        i--;
                        if(i >= 0 && i < 12) {
                                if(IsAmmo(GetPartType(mech, loc, i)))
                                        if(!PartIsNonfunctional(mech, loc, i))
                                                if((d = GetPartData(mech, loc, i)))
                                                        count++;
                                DOCHECKMA(!count,
                                                  tprintf("There is no ammunition in %s crit %i!",
                                                                  buf, i + 1));
                                type = (((i + 1) << 8) | (loc + 1));
                                DOCHECKMA(type & ~0xFFFF,
                                                  "Internal inconsistency, dump failed!");
                                type = type << 16;
                                mech_printf(mech, MECHALL,
                                                        "Starting dumping of ammunition in %s crit %i..",
                                                        buf, i + 1);
                                MechLOSBroadcast(mech,
                                                                 "starts dumping ammo from hatches on its back.");
                                MECHEVENT(mech, EVENT_DUMP, mech_dump_event,
                                                  DUMP_GRAD_TICK, type);
                                return;
                        }
                }
                l = CritsInLoc(mech, loc);
                for(i = 0; i < l; i++)
                        if(IsAmmo(GetPartType(mech, loc, i)))
                                if(!PartIsNonfunctional(mech, loc, i))
                                        if((d = GetPartData(mech, loc, i)))
                                                count++;
                DOCHECKMA(!count, tprintf("There is no ammunition in %s!", buf));
                type = loc + 1;
                mech_printf(mech, MECHALL,
                                        "Starting dumping of ammunition in %s..", buf);
                MechLOSBroadcast(mech,
                                                 "starts dumping ammo from hatches on its back.");
                MECHEVENT(mech, EVENT_DUMP, mech_dump_event, DUMP_GRAD_TICK, type);
                return;
        }
        weapindx = FindWeaponIndex(mech, weapnum);
        if(weapnum < 0)
                SendError(tprintf
                                  ("CHEATER: #%d tried to crash mux with command 'dump %d'!",
                                   (int) player, weapnum));
        DOCHECKMA(Dumping(mech), "You're already dumping some ammo!");
        DOCHECK(weapindx < 0, "Invalid weapon number!");
        FindWeaponNumberOnMech(mech, weapnum, &section, &critical);
        DOCHECK(MechWeapons[weapindx].type == TBEAM ||
                        MechWeapons[weapindx].type == THAND,
                        "That weapon doesn't use ammunition!");
        DOCHECK(!FindAmmoForWeapon_sub(mech, -1, -1, weapindx, 0, &ammoLoc,
                                                                   &ammoCrit, 0, 0),
                        "You don't have any ammunition for that weapon stored on this mech!");
        DOCHECK(GetPartData(mech, ammoLoc, ammoCrit) == 0,
                        "You are out of ammunition for that weapon already!");
        type = 256 * (weapindx + 1);
        mech_printf(mech, MECHALL, "Starting dumping %s ammunition..",
                                get_parts_long_name(I2Weapon(weapindx), 0));
        MechLOSBroadcast(mech, "starts dumping ammo from hatches on its back.");
        MECHEVENT(mech, EVENT_DUMP, mech_dump_event, DUMP_GRAD_TICK, type);
#if 0
        while (FindAmmoForWeapon(mech, weapindx, 0, &ammoLoc, &ammoCrit))
                GetPartData(mech, ammoLoc, ammoCrit) = 0;
        mech_printf(mech, MECHALL, "Ammunition for %s dumped!",
                                get_parts_long_name(I2Weapon(weapindx), 0));
#endif
}

int Dump_Decrease(MECH * mech, int loc, int pos, int *hm)
{
        int c, index, weapindx, rem;

#define RUP(a) { if (*hm < a) *hm = a; return a; }
        /* It _is_ ammo, and contains something */

        if(IsAmmo((index = GetPartType(mech, loc, pos))))
                if(!PartIsNonfunctional(mech, loc, pos))
                        if((c = GetPartData(mech, loc, pos))) {
                                weapindx = Ammo2WeaponI(index);
                                if(MechWeapons[weapindx].ammoperton < DUMP_SPEED) {
                                        if((muxevent_tick % (DUMP_SPEED /
                                                                                 MechWeapons[weapindx].ammoperton)))
                                                RUP(2);
                                        /* fine, we remove 1 */
                                        rem = 1;
                                } else
                                        rem =
                                                MIN(c, MechWeapons[weapindx].ammoperton / DUMP_SPEED);
                                ammo_expedinture_check(mech, weapindx, rem - 1);
                                SetPartData(mech, loc, pos, c - rem);
                                if(c <= rem)
                                        RUP(1);
                                RUP(2);
                        }
        return 0;
}

/*
 * The function is for blowing up some of the ammo that's being dumped from
 * a mech when it takes a rear torso shot.
 *
 * FASA rules state that if a mech takes a rear torso shot while dumping ammo,
 * all the dumping ammo explodes and goes to the armor of that location. That's
 * a bit harsh in RS as getting behind someone ain't that hard. So what we do is
 * if you're dumping ammo and take a rear torso shot, we, on a roll of 7 or less, 
 * call this BlowDumpingAmmo function. This function finds all the ammo you're dumping
 * and blows up ONE ROUND of one type, randomly. If you're dumping a lot and get hit
 * a few times (like from an LRM) you could get a bunch of little booms which
 * could really ruin your day.
 */

void BlowDumpingAmmo(MECH * mech, MECH * attacker, int wHitLoc)
{
        struct objDumpingAmmo aobjAmmoItems[MAX_WEAPONS_PER_MECH];
        int wEventData = -1;
        int wSecIter, wSlotIter;
        int wcAmmoItems = 0;
        int wPartType = 0, wPartData = 0;
        int wLoc = 0;
        int wWeapIdx = 0;
        int wRndIdx = 0;
        int wBlowDamage = 0;

        DumpingData(mech, &wEventData);
        if(wEventData < 0)
                return;
        if(!wEventData) {                       /* Global ammo dump */
                for(wSecIter = 7; wSecIter >= 0; wSecIter--)
                        for(wSlotIter = CritsInLoc(mech, wSecIter) - 1;
                                wSlotIter >= 0; wSlotIter--) {
                                wPartType = GetPartType(mech, wSecIter, wSlotIter);
                                if(IsAmmo(wPartType))
                                        if(GetPartData(mech, wSecIter, wSlotIter)) {
                                                aobjAmmoItems[wcAmmoItems].wDamage =
                                                        FindMaxAmmoDamage(Ammo2WeaponI(wPartType));
                                                aobjAmmoItems[wcAmmoItems].wLocation = wSecIter;
                                                aobjAmmoItems[wcAmmoItems].wSlot = wSlotIter;
                                                aobjAmmoItems[wcAmmoItems].wWeapIdx =
                                                        Ammo2WeaponI(wPartType);
                                                aobjAmmoItems[wcAmmoItems].wPartType = wPartType;
                                                wcAmmoItems++;
                                        }
                        }
        } else if(wEventData < 256) {   /* Location specific ammo dump */
                wLoc = wEventData - 1;
                for(wSlotIter = 0; wSlotIter < CritsInLoc(mech, wLoc); wSlotIter++) {
                        wPartType = GetPartType(mech, wLoc, wSlotIter);

/*     wPartType = GetPartType(mech, wSecIter, wSlotIter); */
                        if(IsAmmo(wPartType))
                                if(!PartIsNonfunctional(mech, wLoc, wSlotIter) &&
                                   GetPartData(mech, wLoc, wSlotIter)) {
                                        aobjAmmoItems[wcAmmoItems].wDamage =
                                                FindMaxAmmoDamage(Ammo2WeaponI(wPartType));
                                        aobjAmmoItems[wcAmmoItems].wLocation = wLoc;
                                        aobjAmmoItems[wcAmmoItems].wSlot = wSlotIter;
                                        aobjAmmoItems[wcAmmoItems].wWeapIdx =
                                                Ammo2WeaponI(wPartType);
                                        aobjAmmoItems[wcAmmoItems].wPartType = wPartType;
                                        wcAmmoItems++;
                                }
                }
        } else if(wEventData < 65536) { /* Weapon specific ammo dump */
                wWeapIdx = (wEventData / 256) - 1;
                for(wSecIter = 7; wSecIter >= 0; wSecIter--)
                        for(wSlotIter = CritsInLoc(mech, wSecIter) - 1;
                                wSlotIter >= 0; wSlotIter--) {
                                wPartType = GetPartType(mech, wSecIter, wSlotIter);
                                if(IsAmmo(wPartType) && (Ammo2WeaponI(wPartType) == wWeapIdx)) {
                                        aobjAmmoItems[wcAmmoItems].wDamage =
                                                FindMaxAmmoDamage(Ammo2WeaponI(wPartType));
                                        aobjAmmoItems[wcAmmoItems].wLocation = wSecIter;
                                        aobjAmmoItems[wcAmmoItems].wSlot = wSlotIter;
                                        aobjAmmoItems[wcAmmoItems].wWeapIdx =
                                                Ammo2WeaponI(wPartType);
                                        aobjAmmoItems[wcAmmoItems].wPartType = wPartType;
                                        wcAmmoItems++;
                                }
                        }
        } else {                                        /* crit specific dump */
                wSecIter = ((wEventData >> 16) & 0xFF) - 1;
                wSlotIter = ((wEventData >> 24) & 0xFF) - 1;
                wPartType = GetPartType(mech, wSecIter, wSlotIter);
                aobjAmmoItems[wcAmmoItems].wDamage =
                        FindMaxAmmoDamage(Ammo2WeaponI(wPartType));
                aobjAmmoItems[wcAmmoItems].wLocation = wSecIter;
                aobjAmmoItems[wcAmmoItems].wSlot = wSlotIter;
                aobjAmmoItems[wcAmmoItems].wWeapIdx = Ammo2WeaponI(wPartType);
                aobjAmmoItems[wcAmmoItems].wPartType = wPartType;
                wcAmmoItems++;
        }

        if(wcAmmoItems > 0) {
                wRndIdx = Number(0, wcAmmoItems - 1);
                wBlowDamage = aobjAmmoItems[wRndIdx].wDamage;
                wSecIter = aobjAmmoItems[wRndIdx].wLocation;
                wSlotIter = aobjAmmoItems[wRndIdx].wSlot;
                wWeapIdx = aobjAmmoItems[wRndIdx].wWeapIdx;
                if(wBlowDamage > 0) {
                        MechLOSBroadcast(mech,
                                                         "'s rear armor lights up as ammo being dumped ignites!");
                        mech_printf(mech, MECHALL,
                                                "%%ch%%crSome of the %s ammo dumping out of your mech ignites!%%cn",
                                                get_parts_long_name(I2Weapon(wWeapIdx), 0));
                        DamageMech(mech, attacker, 0, -1, wHitLoc, 1, 0,
                                           wBlowDamage, -1, -1, 0, -1, 0, 1);
                        /*
                         * Decrement the ammo one round
                         */
                        wPartData = GetPartData(mech, wSecIter, wSlotIter);
                        if(wPartData > 0)
                                SetPartData(mech, wSecIter, wSlotIter, wPartData - 1);
                        mech_notify(mech, MECHALL,
                                                "%ch%crAll ammo dumping operations have stopped!%cn");
                        StopDump(mech);
                }
        }
}

int FindMaxAmmoDamage(int wWeapIdx)
{
        int wDamage = MechWeapons[wWeapIdx].damage;
        int wIter = 0;

        if(IsMissile(wWeapIdx) || IsArtillery(wWeapIdx)) {
                for(wIter = 0; MissileHitTable[wIter].key != -1; wIter++)
                        if(MissileHitTable[wIter].key == wWeapIdx)
                                wDamage *= MissileHitTable[wIter].num_missiles[10];
        }

        return wDamage;
}

---