src/hcode/btech/mech.c3i.c

Go to the documentation of this file.

/*
 * $Id: mech.c3i.c,v 1.1.1.1 2005/01/11 21:18:12 kstevens Exp $
 *
 * 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.c3i.h"
#include "p.mech.c3.misc.h"
#include "p.mech.utils.h"
#include "p.mech.los.h"
#include "p.mech.contacts.h"

#define C3_POS_IN_NETWORK -1
#define C3_POS_NO_ROOM          -2

int getFreeC3iNetworkPos(MECH * mech, MECH * mechToAdd)
{
        int i;
        dbref otherRef;

        validateC3iNetwork(mech);

        for(i = 0; i < C3I_NETWORK_SIZE; i++) {
                otherRef = MechC3iNetworkElem(mech, i);

                if(otherRef > 0) {
                        if(otherRef == mechToAdd->mynum)
                                return C3_POS_IN_NETWORK;
                } else
                        return i;
        }

        return C3_POS_NO_ROOM;
}

void replicateC3iNetwork(MECH * mechSrc, MECH * mechDest)
{
        int i;
        dbref otherRef;

        debugC3(tprintf("REPLICATE: %d's C3i network to %d", mechSrc->mynum,
                                        mechDest->mynum));

        clearC3iNetwork(mechDest, 0);

        MechC3iNetworkElem(mechDest, 0) = mechSrc->mynum;
        MechC3iNetworkSize(mechDest) = 1;

        for(i = 0; i < C3I_NETWORK_SIZE; i++) {
                otherRef = MechC3iNetworkElem(mechSrc, i);

                if(otherRef != mechDest->mynum) {
                        MechC3iNetworkElem(mechDest, MechC3iNetworkSize(mechDest)) =
                                otherRef;
                        MechC3iNetworkSize(mechDest) += 1;
                }
        }

        validateC3iNetwork(mechDest);
}

void addMechToC3iNetwork(MECH * mech, MECH * mechToAdd)
{
        MECH *otherMech;
        MECH *otherNotifyMech;
        dbref otherRef;
        int i;
        int wPos = -1;

        debugC3(tprintf("ADD: %d to the C3i network of %d", mechToAdd->mynum,
                                        mech->mynum));

        /* Find a position to add the new mech into my network */
        wPos = getFreeC3iNetworkPos(mech, mechToAdd);

        /* If we have a number that's less than 0, then we have an invalid position. Either we're already in the network or there's not enough room */
        if(wPos < 0)
                return;

        /* Well, we have a valid position, so let's put this mech in the network */
        MechC3iNetworkElem(mech, wPos) = mechToAdd->mynum;
        MechC3iNetworkSize(mech) += 1;

        mech_notify(mech, MECHALL,
                                tprintf("%s connects to your C3i network.",
                                                GetMechToMechID(mech, mechToAdd)));

        /* Now let's replicate the new network across the system so that everyone has the same network settings */
        for(i = 0; i < C3I_NETWORK_SIZE; i++) {
                otherRef = MechC3iNetworkElem(mech, i);

                otherMech = getOtherMechInNetwork(mech, i, 0, 0, 0, 0);

                if(!otherMech)
                        continue;

                if(!Good_obj(otherMech->mynum))
                        continue;

                if(otherRef != mechToAdd->mynum) {
                        otherNotifyMech = getOtherMechInNetwork(mech, i, 1, 1, 1, 0);

                        if(otherNotifyMech)
                                mech_notify(otherNotifyMech, MECHALL,
                                                        tprintf("%s connects to your C3i network.",
                                                                        GetMechToMechID(otherNotifyMech,
                                                                                                        mechToAdd)));
                }

                replicateC3iNetwork(mech, otherMech);
        }

        /* Last, but not least, one final validation of the network */
        validateC3iNetwork(mech);
}

void clearMechFromC3iNetwork(dbref refToClear, MECH * mech)
{
        int i;

        debugC3(tprintf("CLEAR: %d from the C3i network of %d", refToClear,
                                        mech->mynum));

        if(!MechC3iNetworkSize(mech))
                return;

        for(i = 0; i < C3I_NETWORK_SIZE; i++) {
                if(MechC3iNetworkElem(mech, i) == refToClear)
                        MechC3iNetworkElem(mech, i) = -1;
        }

        validateC3iNetwork(mech);
}

void clearC3iNetwork(MECH * mech, int tClearFromOthers)
{
        MECH *otherMech;
        int i;

        debugC3(tprintf("CLEAR: %d's C3i network", mech->mynum));

        for(i = 0; i < C3I_NETWORK_SIZE; i++) {
                otherMech = getOtherMechInNetwork(mech, i, 0, 0, 0, 0);

                MechC3iNetworkElem(mech, i) = -1;

                if(tClearFromOthers) {
                        if(!otherMech)
                                continue;

                        if(!Good_obj(otherMech->mynum))
                                continue;

                        clearMechFromC3iNetwork(mech->mynum, otherMech);
                }
        }

        MechC3iNetworkSize(mech) = 0;
}

void validateC3iNetwork(MECH * mech)
{
        MECH *otherMech;
        dbref myTempNetwork[C3I_NETWORK_SIZE];
        int i;
        int networkSize = 0;

        debugC3(tprintf("VALIDATE: %d's C3i network", mech->mynum));

        if(!HasC3i(mech) || Destroyed(mech) || C3iDestroyed(mech)) {
                clearC3iNetwork(mech, 1);

                return;
        }

        if(MechC3iNetworkSize(mech) < 0) {
                clearC3iNetwork(mech, 1);

                return;
        }

        for(i = 0; i < C3I_NETWORK_SIZE; i++) {
                otherMech = getOtherMechInNetwork(mech, i, 0, 0, 0, 0);

                if(!otherMech)
                        continue;

                if(!Good_obj(otherMech->mynum))
                        continue;

                debugC3(tprintf("VALIDATE INFO: %d is now in %d's C3i network",
                                                otherMech->mynum, mech->mynum));

                myTempNetwork[networkSize++] = otherMech->mynum;
        }

        clearC3iNetwork(mech, 0);

        for(i = 0; i < networkSize; i++)
                MechC3iNetworkElem(mech, i) = myTempNetwork[i];

        MechC3iNetworkSize(mech) = networkSize;

        debugC3(tprintf("VALIDATE INFO: %d's C3i network is %d elements",
                                        mech->mynum, MechC3iNetworkSize(mech)));
}

void mech_c3i_join_leave(dbref player, void *data, char *buffer)
{
        MECH *mech = (MECH *) data, *target;
        MAP *objMap;
        char *args[2];
        dbref refTarget;
        int LOS = 1;
        float range = 0.0;

        cch(MECH_USUALO);

        DOCHECK(mech_parseattributes(buffer, args, 2) != 1,
                        "Invalid number of arguments to function!");

        DOCHECK(!HasC3i(mech), "This unit is not equipped with C3i!");
        DOCHECK(C3iDestroyed(mech), "Your C3i system is destroyed!");
        DOCHECK(AnyECMDisturbed(mech),
                        "Your C3i system is not currently operational!");

        validateC3iNetwork(mech);

        /* Clear our C3i Network */
        if(!strcmp(args[0], "-")) {
                if(MechC3iNetworkSize(mech) <= 0) {
                        mech_notify(mech, MECHALL,
                                                "You are not connected to a C3i network!");

                        return;
                }

                clearC3iNetwork(mech, 1);

                mech_notify(mech, MECHALL, "You disconnect from the C3i network.");

                return;
        }

        /* Well, if we're here then we wanna connect to a network */
        /* Let's check to see if we're already in one... can't be in two at the same time */
        DOCHECK(MechC3iNetworkSize(mech) > 0,
                        "You are already in a C3i network!");

        objMap = getMap(mech->mapindex);

        /* Find who we're trying to connect to */
        refTarget = FindTargetDBREFFromMapNumber(mech, args[0]);
        target = getMech(refTarget);

        if(target) {
                LOS =
                        InLineOfSight(mech, target, MechX(target), MechY(target), range);
        } else
                refTarget = 0;

        DOCHECK((refTarget < 1) ||
                        !LOS, "That is not a valid targetID. Try again.");
        DOCHECK(MechTeam(mech) != MechTeam(target),
                        "You can't use the C3i network of unfriendly units!");
        DOCHECK(mech == target, "You can't connect to yourself!");
        DOCHECK(Destroyed(target), "That unit is destroyed!");
        DOCHECK(!Started(target), "That unit is not started!");
        DOCHECK(!HasC3i(target),
                        "That unit does not appear to be equipped with C3i!");

        /* validate the network of our target */
        validateC3iNetwork(target);
        DOCHECK(MechC3iNetworkSize(target) >= C3I_NETWORK_SIZE,
                        "That unit's C3i network is operating at maximum capacity!");

        /* Connect us up */
        mech_notify(mech, MECHALL, tprintf("You connect to %s's C3i network.",
                                                                           GetMechToMechID(mech, target)));

        addMechToC3iNetwork(target, mech);
}

void mech_c3i_message(dbref player, MECH * mech, char *buffer)
{
        cch(MECH_USUALO);

        DOCHECK(!HasC3i(mech), "This unit is not equipped with C3i!");
        DOCHECK(C3iDestroyed(mech), "Your C3i system is destroyed!");
        DOCHECK(AnyECMDisturbed(mech),
                        "Your C3i system is not currently operational!");

        validateC3iNetwork(mech);

        DOCHECK(MechC3iNetworkSize(mech) <= 0,
                        "There are no other units in your C3i network!");

        skipws(buffer);
        DOCHECK(!*buffer, "What do you want to send on the C3i Network?");

        sendNetworkMessage(player, mech, buffer, 0);
}

void mech_c3i_targets(dbref player, MECH * mech, char *buffer)
{
        cch(MECH_USUALO);

        DOCHECK(!HasC3i(mech), "This unit is not equipped with C3i!");
        DOCHECK(C3iDestroyed(mech), "Your C3i system is destroyed!");
        DOCHECK(AnyECMDisturbed(mech),
                        "Your C3i system is not currently operational!");

        validateC3iNetwork(mech);

        DOCHECK(MechC3iNetworkSize(mech) <= 0,
                        "There are no other units in your C3i network!");

        showNetworkTargets(player, mech, 0);
}

void mech_c3i_network(dbref player, MECH * mech, char *buffer)
{
        cch(MECH_USUALO);

        DOCHECK(!HasC3i(mech), "This unit is not equipped with C3i!");
        DOCHECK(C3iDestroyed(mech), "Your C3i system is destroyed!");
        DOCHECK(AnyECMDisturbed(mech),
                        "Your C3i system is not currently operational!");

        validateC3iNetwork(mech);

        DOCHECK(MechC3iNetworkSize(mech) <= 0,
                        "There are no other units in your C3i network!");

        showNetworkData(player, mech, 0);
}

---