src/hcode/btech/autopilot_radio.c

Go to the documentation of this file.

/*
 * $Id: autopilot_command.c,v 1.4 2005/08/10 14:09:34 av1-op Exp $
 *
 * Author: Markus Stenberg <fingon@iki.fi>
 *
 *  Copyright (c) 1997 Markus Stenberg
 *  Copyright (c) 1998-2002 Thomas Wouters
 *  Copyright (c) 2000-2002 Cord Awtry
 *       All rights reserved
 *
 * Created: Tue Sep 23 20:33:33 1997 fingon
 * Last modified: Sat Jun  6 21:47:38 1998 fingon
 *
 */

/* Most of the BattleSheep(tm) code is here.. */

#include <math.h>
#include "mech.h"
#include "autopilot.h"
#include "spath.h"
#include "mech.notify.h"
#include "p.mech.utils.h"
#include "p.mech.sensor.h"
#include "p.mech.los.h"
#include "p.mech.startup.h"
#include "p.mech.maps.h"
#include "p.ds.bay.h"
#include "p.mech.maps.h"
#include "p.bsuit.h"
#include "p.glue.h"

void sendchannelstuff(MECH * mech, int freq, char *msg);

#define Clear(a) \
    auto_disengage(a->mynum, a, ""); \
    auto_delcommand(a->mynum, a, "-1"); \
    if (a->target >= -1) { \
        if (AssignedTarget(a) && a->target != -1) { \
            snprintf(buffer, SBUF_SIZE, "autogun target %d", a->target); \
        } else { \
            snprintf(buffer, SBUF_SIZE, "autogun on"); \
        } \
        auto_addcommand(a->mynum, autopilot, buffer); \
    } \

#define BACMD(name) char * name (AUTO *autopilot, MECH *mech, char **args, int argc, int chn)
#define ACMD(name) static BACMD(name)

/* 
 * Master list of AI - radio commands
 */
struct {
        char *sho;
        char *name;
        int args;
        int silent;
        void (*fun) (AUTO * autopilot, MECH * mech, char **args, int argc,
                                 char *mesg);
} auto_cmds[] = {
        {
        "auto", "autogun", 1, 0, auto_radio_command_autogun}, {
        "auto", "autogun", 2, 0, auto_radio_command_autogun}, {
#if 0
        "att", "attackleg", 1, 0, auto_attackleg}, {
        "chanf", "chanfreq", 2, 0, auto_setchanfreq}, {
        "chanm", "chanmode", 2, 0, auto_setchanmode}, {
#endif
        "chase", "chasetarg", 1, 0, auto_radio_command_chasetarg}, {
#if 0
        "cm", "cmode", 2, 0, auto_cmode}, {
#endif
        "dfo", "dfollow", 1, 0, auto_radio_command_dfollow}, {
        "dgo", "dgoto", 2, 0, auto_radio_command_dgoto}, {
#if 0
        "dr", "drally", 2, 0, auto_drally}, {
        "dr", "drally", 3, 0, auto_drally}, {
#endif
        "drop", "dropoff", 0, 0, auto_radio_command_dropoff}, {
        "emb", "embark", 1, 0, auto_radio_command_embark}, {
        "en", "enterbase", 0, 0, auto_radio_command_enterbase}, {
        "en", "enterbase", 1, 0, auto_radio_command_enterbase}, {
#if 0
        "en", "enterbay", 0, 0, auto_enterbay}, {
        "en", "enterbay", 1, 0, auto_enterbay}, {
#endif
        "fo", "follow", 1, 0, auto_radio_command_follow}, {
#if 0
        "fr", "freq", 1, 0, auto_freq}, {
#endif
        "go", "goto", 2, 0, auto_radio_command_goto}, {
        "he", "heading", 1, 0, auto_radio_command_heading}, {
        "he", "help", 0, 1, auto_radio_command_help}, {
        "hi", "hide", 0, 0, auto_radio_command_hide}, {
        "jump", "jumpjet", 1, 0, auto_radio_command_jumpjet}, {
        "jump", "jumpjet", 2, 0, auto_radio_command_jumpjet}, {
        "le", "leavebase", 1, 0, auto_radio_command_leavebase}, {
#if 0
        "nog", "nogun", 0, 0, auto_nogun}, {
        "not", "notarget", 0, 0, auto_notarget}, {
#endif
        "ogo", "ogoto", 2, 0, auto_radio_command_ogoto}, {
        "pick", "pickup", 1, 0, auto_radio_command_pickup}, {
        "pos", "position", 2, 0, auto_radio_command_position}, {
        "pr", "prone", 0, 0, auto_radio_command_prone}, {
#if 0
        "ra", "rally", 2, 0, auto_rally}, {
        "ra", "rally", 3, 0, auto_rally}, {
#endif
        "re", "report", 0, 1, auto_radio_command_report}, {
        "reset", "reset", 0, 0, auto_radio_command_reset}, {
#if 0
        "roam", "roammode", 1, 0, auto_roammode}, {
#endif
        "se", "sensor", 2, 0, auto_radio_command_sensor}, {
        "se", "sensor", 0, 0, auto_radio_command_sensor}, {
        "sh", "shutdown", 0, 0, auto_radio_command_shutdown}, {
        "sp", "speed", 1, 0, auto_radio_command_speed}, {
        "st", "stand", 0, 0, auto_radio_command_stand}, {
        "st", "startup", 0, 0, auto_radio_command_startup}, {
        "st", "startup", 1, 0, auto_radio_command_startup}, {
        "st", "stop", 0, 0, auto_radio_command_stop}, {
        "sw", "sweight", 2, 1, auto_radio_command_sweight}, {
#if 0
        "swa", "swarm", 1, 0, auto_swarm}, {
        "swarmc", "swarmcharge", 1, 0, auto_swarmcharge}, {
        "swarmm", "swarmmode", 1, 0, auto_swarmmode}, {
#endif
        "ta", "target", 1, 0, auto_radio_command_target}, {
#if 0
        "ta", "target", 2, 0, auto_target}, {
#endif
        NULL, NULL, 0, 0, NULL}
};

/*
 * The autogun radio interface
 */
void auto_radio_command_autogun(AUTO * autopilot, MECH * mech,
                                                                char **args, int argc, char *mesg)
{

        int threshold;

        if(strcmp(args[1], "on") == 0) {

                autopilot->target = -1;
                autopilot->target_score = 0;
                autopilot->target_update_tick = AUTO_GUN_UPDATE_TICK;

                /* Reset the Assigned target flag */
                if(AssignedTarget(autopilot)) {
                        UnassignTarget(autopilot);
                }

                if(Gunning(autopilot)) {
                        DoStopGun(autopilot);
                }
                DoStartGun(autopilot);

                snprintf(mesg, LBUF_SIZE, "shooting at whatever I want");
                return;

        } else if(strcmp(args[1], "off") == 0) {

                /* Reset the AI */
                autopilot->target = -2;
                autopilot->target_score = 0;
                autopilot->target_update_tick = 0;

                /* Reset this flag since we don't want to be shooting anything */
                if(AssignedTarget(autopilot)) {
                        UnassignTarget(autopilot);
                }

                if(Gunning(autopilot))
                        DoStopGun(autopilot);

                snprintf(mesg, LBUF_SIZE, "powering down weapons");
                return;

        } else if(strcmp(args[1], "threshold") == 0) {

                /* Ok user specifying a threshold" */
                /* Right now we're only going to allow them to specify a value
                 * between 0 and 100 - basicly how much percentage wise over
                 * the current value does the new target have to be to switch */
                if(argc == 3 && !Readnum(threshold, args[2]) &&
                   threshold >= 0 && threshold <= 100) {

                        /* Set the new threshold value */
                        autopilot->target_threshold = threshold;

                        snprintf(mesg, LBUF_SIZE, "new threshold set to %d%%", threshold);
                        return;

                } else {

                        /* Bad value for threshold */
                        snprintf(mesg, LBUF_SIZE, "!Invalid value used with threshold: "
                                         "Usage autogun threshold [0-100]");
                        return;

                }

        }

        snprintf(mesg, LBUF_SIZE, "!Invalid Input for autogun:"
                         " use 'on' or 'off'");

}

/*
 * Tell the AI to chase whatever its targeting
 */
void auto_radio_command_chasetarg(AUTO * autopilot, MECH * mech,
                                                                  char **args, int argc, char *mesg)
{

        if(strcmp(args[1], "on") == 0) {

                auto_set_chasetarget_mode(autopilot, AUTO_CHASETARGET_ON);
                snprintf(mesg, LBUF_SIZE, "Chase Target Mode is Activated");
                return;

        } else if(strcmp(args[1], "off") == 0) {

                auto_set_chasetarget_mode(autopilot, AUTO_CHASETARGET_OFF);
                snprintf(mesg, LBUF_SIZE, "Chase Target Mode is Deactivated");
                return;
        }
        snprintf(mesg, LBUF_SIZE,
                         "!Invalid Input for chasetarg: use 'on' or 'off'");

}

/*
 * Radio command to force AI to [dumbly] follow a given target
 */
void auto_radio_command_dfollow(AUTO * autopilot, MECH * mech,
                                                                char **args, int argc, char *mesg)
{

        dbref targetref;
        char buffer[SBUF_SIZE];

        targetref = FindTargetDBREFFromMapNumber(mech, args[1]);
        if(targetref <= 0) {
                snprintf(mesg, LBUF_SIZE, "!Invalid target to follow");
                return;
        }

        Clear(autopilot);

        snprintf(buffer, SBUF_SIZE, "dumbfollow %d", targetref);
        auto_addcommand(autopilot->mynum, autopilot, buffer);
        auto_engage(autopilot->mynum, autopilot, "");
        snprintf(mesg, LBUF_SIZE, "following %s [dumbly] (%d degrees, %d away)",
                         args[1], autopilot->ofsx, autopilot->ofsy);
}

/*
 * Radio command to force AI to [dumbly] goto a given hex
 */
void auto_radio_command_dgoto(AUTO * autopilot, MECH * mech,
                                                          char **args, int argc, char *mesg)
{

        int x, y;
        char buffer[SBUF_SIZE];

        if(Readnum(x, args[1])) {
                snprintf(mesg, LBUF_SIZE, "!First number not an integer");
                return;
        }
        if(Readnum(y, args[2])) {
                snprintf(mesg, LBUF_SIZE, "!First number not an integer");
                return;
        }

        Clear(autopilot);

        snprintf(buffer, SBUF_SIZE, "dumbgoto %d %d", x, y);
        auto_addcommand(autopilot->mynum, autopilot, buffer);
        auto_engage(autopilot->mynum, autopilot, "");
        snprintf(mesg, LBUF_SIZE, "going [dumbly] to %d,%d", x, y);

}

/*
 * Radio command to force AI to drop whatever its carrying
 */
void auto_radio_command_dropoff(AUTO * autopilot, MECH * mech,
                                                                char **args, int argc, char *mesg)
{

        char buffer[SBUF_SIZE];

        Clear(autopilot);

        snprintf(buffer, SBUF_SIZE, "dropoff");
        auto_addcommand(autopilot->mynum, autopilot, buffer);
        auto_engage(autopilot->mynum, autopilot, "");
        snprintf(mesg, LBUF_SIZE, "dropping off");

}

/*
 * Radio command to force AI to embark a carrier
 */
void auto_radio_command_embark(AUTO * autopilot, MECH * mech,
                                                           char **args, int argc, char *mesg)
{

        dbref targetref;
        char buffer[SBUF_SIZE];

        targetref = FindTargetDBREFFromMapNumber(mech, args[1]);
        if(targetref <= 0) {
                snprintf(mesg, LBUF_SIZE, "!Invalid target to embark");
                return;
        }

        Clear(autopilot);
        snprintf(buffer, SBUF_SIZE, "embark %d", targetref);
        auto_addcommand(autopilot->mynum, autopilot, buffer);
        auto_engage(autopilot->mynum, autopilot, "");
        snprintf(mesg, LBUF_SIZE, "embarking %s", args[1]);
        return;

}

/*
 * Radio command to force AI to enterbase
 */
void auto_radio_command_enterbase(AUTO * autopilot, MECH * mech,
                                                                  char **args, int argc, char *mesg)
{

        char buffer[SBUF_SIZE];

        if(argc - 1) {
                snprintf(buffer, SBUF_SIZE, "enterbase %s", args[1]);
                snprintf(mesg, LBUF_SIZE, "entering base (%s side)", args[1]);
        } else {
                strncpy(buffer, "enterbase n", SBUF_SIZE);
                snprintf(mesg, LBUF_SIZE, "entering base");
        }

        Clear(autopilot);
        auto_addcommand(autopilot->mynum, autopilot, buffer);
        auto_engage(autopilot->mynum, autopilot, "");

}

/*
 * New smart follow system based on A*'s goto
 */
void auto_radio_command_follow(AUTO * autopilot, MECH * mech,
                                                           char **args, int argc, char *mesg)
{

        char buffer[SBUF_SIZE];
        dbref targetref;

        targetref = FindTargetDBREFFromMapNumber(mech, args[1]);
        if(targetref <= 0) {
                snprintf(mesg, LBUF_SIZE, "!Invalid target to follow");
                return;
        }

        Clear(autopilot);

        snprintf(buffer, SBUF_SIZE, "follow %d", targetref);
        auto_addcommand(autopilot->mynum, autopilot, buffer);
        auto_engage(autopilot->mynum, autopilot, "");
        snprintf(mesg, LBUF_SIZE, "following %s (%d degrees, %d away)", args[1],
                         autopilot->ofsx, autopilot->ofsy);

}

/*
 * Smart goto system based on Astar path finding
 */
void auto_radio_command_goto(AUTO * autopilot, MECH * mech,
                                                         char **args, int argc, char *mesg)
{

        int x, y;
        char buffer[SBUF_SIZE];
    MAP *map;

        if(Readnum(x, args[1])) {
                snprintf(mesg, LBUF_SIZE, "!First number not integer");
                return;
        }
        if(Readnum(y, args[2])) {
                snprintf(mesg, LBUF_SIZE, "!Second number not integer");
                return;
        }

        if(MechX(mech) == x && MechY(mech) == y) {
                snprintf(mesg, LBUF_SIZE, "!Already in that hex");
                return;
        }

    map = getMap(mech->mapindex);

    if (x < 0 || y < 0 || x >= map->map_width || y >= map->map_height) {
        snprintf(mesg, LBUF_SIZE, "!Bad hex to travel to");
        return;
    }

        Clear(autopilot);

        snprintf(buffer, SBUF_SIZE, "goto %d %d", x, y);
        auto_addcommand(autopilot->mynum, autopilot, buffer);
        auto_engage(autopilot->mynum, autopilot, "");
        snprintf(mesg, LBUF_SIZE, "going to %d,%d", x, y);

}

/*
 * Radio command to alter an AI's heading
 */
void auto_radio_command_heading(AUTO * autopilot, MECH * mech,
                                                                char **args, int argc, char *mesg)
{

        int heading;
        char buffer[SBUF_SIZE];

        if(Readnum(heading, args[1])) {
                snprintf(mesg, LBUF_SIZE, "!Number not integer");
                return;
        }

        Clear(autopilot);
        auto_engage(autopilot->mynum, autopilot, "");
        snprintf(buffer, SBUF_SIZE, "%d", heading);
        mech_heading(autopilot->mynum, mech, buffer);
        strcpy(buffer, "0");
        mech_speed(autopilot->mynum, mech, buffer);
        snprintf(buffer, LBUF_SIZE, "stopped and heading changed to %d", heading);

}

/*
 * Help message, lists the various commands for the AI
 */
void auto_radio_command_help(AUTO * autopilot, MECH * mech,
                                                         char **args, int argc, char *mesg)
{

        int i;

        snprintf(mesg, LBUF_SIZE, "The following commands are possible:");

        for(i = 0; auto_cmds[i].name; i++) {
                if(i > 0 && !strcmp(auto_cmds[i].name, auto_cmds[i - 1].name))
                        continue;
                strncat(mesg, " ", LBUF_SIZE);
                strncat(mesg, auto_cmds[i].name, LBUF_SIZE);
        }

        auto_reply(mech, mesg);

}

/*
 * Radio command to force AI to try and hide itself
 */
void auto_radio_command_hide(AUTO * autopilot, MECH * mech,
                                                         char **args, int argc, char *mesg)
{

        if((HasCamo(mech)) ?
           0 : MechType(mech) != CLASS_BSUIT && MechType(mech) != CLASS_MW) {
                snprintf(mesg, LBUF_SIZE,
                                 "!Last I checked I was kind of big for that");
                return;
        }

        if(!(MechRTerrain(mech) == HEAVY_FOREST ||
                 MechRTerrain(mech) == LIGHT_FOREST ||
                 MechRTerrain(mech) == ROUGH ||
                 MechRTerrain(mech) == MOUNTAINS ||
                 (MechType(mech) == CLASS_BSUIT ? MechRTerrain(mech) ==
                  BUILDING : 0))) {
                snprintf(mesg, LBUF_SIZE, "!Invalid Terrain");
                return;
        }

        bsuit_hide(autopilot->mynum, mech, "");
        snprintf(mesg, LBUF_SIZE, "Begining to hide");

}

/*
 * Radio command to force AI to jump either on a target or 
 * in a given direction range
 */
void auto_radio_command_jumpjet(AUTO * autopilot, MECH * mech,
                                                                char **args, int argc, char *mesg)
{

        dbref target;
        char buffer[SBUF_SIZE];
        int bear, rng;

        if(!abs(MechJumpSpeed(mech))) {
                snprintf(mesg, LBUF_SIZE, "!I don't do hiphop and jump around");
                return;
        }

        if((argc - 1) == 1) {
                if((target = FindTargetDBREFFromMapNumber(mech, args[1])) <= 0) {
                        snprintf(mesg, LBUF_SIZE, "!Unable to see such a target");
                        return;
                }
                strcpy(buffer, args[1]);
                mech_jump(autopilot->mynum, mech, buffer);
                snprintf(mesg, LBUF_SIZE, "jumping on [%s]", args[1]);
                return;
        } else {
                if(Readnum(bear, args[1])) {
                        snprintf(mesg, LBUF_SIZE, "!Invalid bearing");
                        return;
                }
                if(Readnum(rng, args[2])) {
                        snprintf(mesg, LBUF_SIZE, "!Invalid range");
                        return;
                }
                snprintf(buffer, SBUF_SIZE, "%s %s", args[1], args[2]);
                mech_jump(autopilot->mynum, mech, buffer);
                snprintf(mesg, LBUF_SIZE, "jump %s degrees %s hexes", args[1],
                                 args[2]);
                return;
        }
}

/*
 * Radio command to force AI to leavebase
 */
void auto_radio_command_leavebase(AUTO * autopilot, MECH * mech,
                                                                  char **args, int argc, char *mesg)
{

        char buffer[SBUF_SIZE];
        int direction;

        if(Readnum(direction, args[1])) {
                snprintf(mesg, LBUF_SIZE, "!Invalid value for direction");
                return;
        }

        /* Make sure chasetarget doesn't interfere with this */
        if(ChasingTarget(autopilot)) {
                StopChasingTarget(autopilot);
        }

        Clear(autopilot);

        snprintf(buffer, SBUF_SIZE, "leavebase %d", direction);
        auto_addcommand(autopilot->mynum, autopilot, buffer);
        auto_engage(autopilot->mynum, autopilot, "");
        snprintf(mesg, LBUF_SIZE, "leaving base at %d heading", direction);

}

/*
 * Old goto system - will phase out
 */
void auto_radio_command_ogoto(AUTO * autopilot, MECH * mech,
                                                          char **args, int argc, char *mesg)
{

        int x, y;
        char buffer[SBUF_SIZE];

        if(Readnum(x, args[1])) {
                snprintf(mesg, LBUF_SIZE, "!First number not integer");
                return;
        }
        if(Readnum(y, args[2])) {
                snprintf(mesg, LBUF_SIZE, "!Second number not integer");
                return;
        }

        Clear(autopilot);

        snprintf(buffer, SBUF_SIZE, "oldgoto %d %d", x, y);
        auto_addcommand(autopilot->mynum, autopilot, buffer);
        auto_engage(autopilot->mynum, autopilot, "");
        snprintf(mesg, LBUF_SIZE, "going [old version] to %d,%d", x, y);

}

/*
 * Radio command to force AI to pickup a target
 */
void auto_radio_command_pickup(AUTO * autopilot, MECH * mech,
                                                           char **args, int argc, char *mesg)
{

        dbref targetref;
        char buffer[SBUF_SIZE];

        targetref = FindTargetDBREFFromMapNumber(mech, args[1]);
        if(targetref <= 0) {
                snprintf(mesg, LBUF_SIZE, "!Invalid target to pickup");
                return;
        }

        /* Make sure chasetarget doesn't interfere with this */
        if(ChasingTarget(autopilot)) {
                StopChasingTarget(autopilot);
        }

        Clear(autopilot);

        snprintf(buffer, SBUF_SIZE, "pickup %d", targetref);
        auto_addcommand(autopilot->mynum, autopilot, buffer);
        auto_engage(autopilot->mynum, autopilot, "");
        snprintf(mesg, LBUF_SIZE, "picking up %s", args[1]);

}

/*
 * Radio command to make AI take up a given position (dir & range) from
 * their current target (hex or unit)
 */
void auto_radio_command_position(AUTO * autopilot, MECH * mech,
                                                                 char **args, int argc, char *mesg)
{

        int x, y;

        if(Readnum(x, args[1])) {
                snprintf(mesg, LBUF_SIZE, "!Invalid first int");
                return;
        }
        if(Readnum(y, args[2])) {
                snprintf(mesg, LBUF_SIZE, "!Invalide second int");
                return;
        }

        autopilot->ofsx = x;
        autopilot->ofsy = y;
        snprintf(mesg, LBUF_SIZE, "following %d degrees, %d away", x, y);

}

/*
 * Radio command to force AI to go prone
 */
void auto_radio_command_prone(AUTO * autopilot, MECH * mech,
                                                          char **args, int argc, char *mesg)
{

        mech_drop(autopilot->mynum, mech, "");
        snprintf(mesg, LBUF_SIZE, "hitting the deck");

}

/*
 * Radio command so the AI can report its status
 */
void auto_radio_command_report(AUTO * autopilot, MECH * mech,
                                                           char **args, int argc, char *mesg)
{

        char buffer[MBUF_SIZE];
        MECH *target;

        /* Is the AI moving or something */
        if(Jumping(mech))
                strcpy(buffer, "Jumping");
        else if(Fallen(mech))
                strcpy(buffer, "Prone");
        else if(IsRunning(MechSpeed(mech), MMaxSpeed(mech)))
                strcpy(buffer, "Running");
        else if(MechSpeed(mech) > 1.0)
                strcpy(buffer, "Walking");
        else
                strcpy(buffer, "Standing");

        snprintf(mesg, LBUF_SIZE, "%s at %d, %d", buffer, MechX(mech),
                         MechY(mech));

        /* Which way is the AI going */
        if(MechSpeed(mech) > 1.0) {
                snprintf(buffer, MBUF_SIZE, ", headed %d speed %.2f",
                                 MechFacing(mech), MechSpeed(mech));
                strncat(mesg, buffer, LBUF_SIZE);
        } else {
                snprintf(buffer, MBUF_SIZE, ", headed %d", MechFacing(mech));
                strncat(mesg, buffer, LBUF_SIZE);
        }

        /* Is the AI targeting something */
        if(MechTarget(mech) != -1) {
                target = getMech(MechTarget(mech));

                if(target) {
                        snprintf(buffer, MBUF_SIZE, ", targeting %s %s",
                                         GetMechToMechID(mech, target),
                                         InLineOfSight(mech, target, MechX(target),
                                                                   MechY(target), FaMechRange(mech, target)) ?
                                         "" : "(not in LOS)");
                        strncat(mesg, buffer, LBUF_SIZE);
                }
        }

        /* Send the mesg to the reply system, this is a silent command */
        auto_reply(mech, mesg);

}

/*
 * Radio command to reset the AI's internal flags what not
 */
void auto_radio_command_reset(AUTO * autopilot, MECH * mech,
                                                          char **args, int argc, char *mesg)
{

        char buffer[SBUF_SIZE];

        auto_disengage(autopilot->mynum, autopilot, "");
        auto_delcommand(autopilot->mynum, autopilot, "-1");
        auto_init(autopilot, mech);
        auto_engage(autopilot->mynum, autopilot, "");
        snprintf(mesg, LBUF_SIZE, "all internal events and flags reset!");

}

/*
 * Radio command to alter or let the AI alter
 * its sensors
 */
void auto_radio_command_sensor(AUTO * autopilot, MECH * mech,
                                                           char **args, int argc, char *mesg)
{

        char buf[SBUF_SIZE];

        /* Make sure no sensor event running */
        muxevent_remove_type_data(EVENT_AUTO_SENSOR, autopilot);

        if((argc - 1) == 2) {

                /* Set the user specified sensors */
                snprintf(buf, SBUF_SIZE, "%s %s", args[1], args[2]);
                mech_sensor(autopilot->mynum, mech, buf);
                autopilot->flags |= AUTOPILOT_LSENS;
                snprintf(mesg, LBUF_SIZE, "updated my sensors");
                return;

        }

        /* Let AI decide */
        autopilot->flags &= ~AUTOPILOT_LSENS;
        snprintf(mesg, LBUF_SIZE, "using my own judgement with sensors");
        return;

}

/*
 * Radio command to force AI to shutdown
 */
void auto_radio_command_shutdown(AUTO * autopilot, MECH * mech,
                                                                 char **args, int argc, char *mesg)
{

        mech_shutdown(autopilot->mynum, mech, "");
        snprintf(mesg, LBUF_SIZE, "shutting down");

}

/*
 * Radio command to alter the speed of an AI (% of speed)
 */
void auto_radio_command_speed(AUTO * autopilot, MECH * mech,
                                                          char **args, int argc, char *mesg)
{

        int speed = 100;

        if(Readnum(speed, args[1])) {
                snprintf(mesg, LBUF_SIZE, "!Invalid value - not a number");
                return;
        }

        if(speed < 1 || speed > 100) {
                snprintf(mesg, LBUF_SIZE, "!Invalid speed");
                return;
        }

        autopilot->speed = speed;
        snprintf(mesg, LBUF_SIZE, "setting speed to %d %%", speed);

}

/*
 * Radio Command to force AI to stand
 */
void auto_radio_command_stand(AUTO * autopilot, MECH * mech,
                                                          char **args, int argc, char *mesg)
{

        mech_stand(autopilot->mynum, mech, "");
        snprintf(mesg, LBUF_SIZE, "standing up");

}

/*
 * Radio command to force AI to startup
 */
void auto_radio_command_startup(AUTO * autopilot, MECH * mech,
                                                                char **args, int argc, char *mesg)
{

        if(argc > 1) {
                if(!strncasecmp(args[1], "override", strlen(args[1]))) {
                        mech_startup(autopilot->mynum, mech, "override");
                        snprintf(mesg, LBUF_SIZE, "emergency override startup triggered");
                        return;
                }
        }

        mech_startup(autopilot->mynum, mech, "");
        snprintf(mesg, LBUF_SIZE, "starting up");

}

/*
 * Radio command to stop the AI
 */
void auto_radio_command_stop(AUTO * autopilot, MECH * mech,
                                                         char **args, int argc, char *mesg)
{

        char buffer[SBUF_SIZE];

        strcpy(buffer, "0");

        /* Turn chasetarget off */
        auto_set_chasetarget_mode(autopilot, AUTO_CHASETARGET_OFF);

        Clear(autopilot);

        auto_engage(autopilot->mynum, autopilot, "");
        mech_speed(autopilot->mynum, mech, buffer);
        snprintf(mesg, LBUF_SIZE, "halting");

}

/*
 * Command for the old goto, will phase it out
 */
void auto_radio_command_sweight(AUTO * autopilot, MECH * mech,
                                                                char **args, int argc, char *mesg)
{

        int x, y;

        if(Readnum(x, args[1])) {
                snprintf(mesg, LBUF_SIZE, "!Invalid first int");
                return;
        }
        if(Readnum(y, args[2])) {
                snprintf(mesg, LBUF_SIZE, "!Invalide second int");
                return;
        }
        x = MAX(1, x);
        y = MAX(1, y);
        autopilot->auto_goweight = x;
        autopilot->auto_fweight = y;
        snprintf(mesg, LBUF_SIZE, "sweight'ed to %d:%d. (go:fight)", x, y);
        return;

}

/*
 * Tell the AI to target a specific unit
 */
void auto_radio_command_target(AUTO * autopilot, MECH * mech,
                                                           char **args, int argc, char *mesg)
{

        dbref targetref;

        if(!strcmp(args[1], "-")) {

                /* Basicly doing the same as 'autogun on' */
                autopilot->target = -1;
                autopilot->target_score = 0;
                autopilot->target_update_tick = AUTO_GUN_UPDATE_TICK;

                if(AssignedTarget(autopilot)) {
                        UnassignTarget(autopilot);
                }

                if(Gunning(autopilot)) {
                        DoStopGun(autopilot);
                }
                DoStartGun(autopilot);

                snprintf(mesg, LBUF_SIZE, "shooting at whatever I want");
                return;

        } else {

                targetref = FindTargetDBREFFromMapNumber(mech, args[1]);
                if(targetref <= 0) {
                        snprintf(mesg, LBUF_SIZE, "!Unable to see such a target");
                        return;
                }

        }

        autopilot->target = targetref;
        autopilot->target_score = 0;
        autopilot->target_update_tick = 0;

        /* Let the AI know its an assigned target */
        if(!AssignedTarget(autopilot)) {
                AssignTarget(autopilot);
        }

        if(Gunning(autopilot)) {
                DoStopGun(autopilot);
        }
        DoStartGun(autopilot);

        snprintf(mesg, LBUF_SIZE, "aiming for [%s] (and ignoring everyone else)",
                         args[1]);

}

#if 0
ACMD(auto_swarm)
{
        dbref targetref;

        if(!mech || MechType(mech) != CLASS_BSUIT)
                return "!Not a bsuit";
        targetref = FindTargetDBREFFromMapNumber(mech, args[0]);
        if(targetref <= 0)
                return "!Invalid target to swarm";
        Clear(a);
        auto_addcommand(a->mynum, a, tprintf("swarm %d", targetref));
        auto_engage(a->mynum, a, "");
        return tprintf("swarming %s.", args[0]);
}
#endif
#if 0
ACMD(auto_attackleg)
{
        dbref targetref;

        if(!mech || MechType(mech) != CLASS_BSUIT)
                return "!Not a bsuit";
        targetref = FindTargetDBREFFromMapNumber(mech, args[0]);
        if(targetref <= 0)
                return "!Invalid target to attackleg";
        Clear(a);
        auto_addcommand(a->mynum, a, tprintf("attackleg %d", targetref));
        auto_engage(a->mynum, a, "");
        return tprintf("attacklegging %s.", args[0]);
}
#endif
#if 0
ACMD(auto_notarget)
{
        a->targ = -1;
        if(Gunning(a)) {
                DoStopGun(a);
                DoStartGun(a);
        }
        return "shooting at anything that moves";
}
#endif
#if 0
ACMD(auto_nogun)
{
        a->targ = -2;
        if(Gunning(a))
                DoStopGun(a);
        return "powering down weapons";
}
#endif
#if 0
ACMD(auto_rally)
{
        char xb[6], yb[6];
        int x, y, h;

        if(Readnum(x, args[0]))
                return "!Invalid X coord";
        if(Readnum(y, args[1]))
                return "!Invalid Y coord";
        if(argc < 3)
                h = MechFacing(mech);
        else if(Readnum(h, args[2]))
                return "!Invalid heading";
        /* Base things on the <h = heading> */
        x = x + a->ofsy * cos(TWOPIOVER360 * (270 + (a->ofsx + h)));
        y = y + a->ofsy * sin(TWOPIOVER360 * (270 + (a->ofsx + h)));
        sprintf(xb, "%d", x);
        sprintf(yb, "%d", y);
        args[0] = xb;
        args[1] = yb;
        return auto_goto(a, mech, args, 2, chn);
}
#endif
#if 0
ACMD(auto_drally)
{
        char xb[6], yb[6];
        int x, y, h;

        if(Readnum(x, args[0]))
                return "!Invalid X coord";
        if(Readnum(y, args[1]))
                return "!Invalid Y coord";
        if(argc < 3)
                h = MechFacing(mech);
        else if(Readnum(h, args[2]))
                return "!Invalid heading";
        /* Base things on the <h = heading> */
        x = x + a->ofsy * cos(TWOPIOVER360 * (270 + (a->ofsx + h)));
        y = y + a->ofsy * sin(TWOPIOVER360 * (270 + (a->ofsx + h)));
        sprintf(xb, "%d", x);
        sprintf(yb, "%d", y);
        args[0] = xb;
        args[1] = yb;
        return auto_dgoto(a, mech, args, 2, chn);
}
#endif
#if 0
ACMD(auto_roammode)
{
        if(strcmp(args[0], "on") == 0) {
                Clear(a);
                auto_addcommand(a->mynum, a, tprintf("roammode 1"));
                auto_engage(a->mynum, a, "");
                return "Roam mode is ON";
        } else if(strcmp(args[0], "off") == 0) {
                Clear(a);
                auto_addcommand(a->mynum, a, tprintf("roammode 0"));
                auto_engage(a->mynum, a, "");
                return "Roam mode is OFF";
        }
        return "!Invalid input use on or off";
}
#endif
#if 0
ACMD(auto_swarmmode)
{
        if(MechType(mech) != CLASS_BSUIT)
                return "!I am not a battlesuit";

        if(strcmp(args[0], "on") == 0) {
                a->flags |= AUTOPILOT_SWARMCHARGE;
                return "Swarm Mode is ON";
        } else if(strcmp(args[0], "off") == 0) {
                a->flags &= ~AUTOPILOT_SWARMCHARGE;
                return "Swarm Mode is OFF";
        }
        return "!Invalid input use on or off";
}
#endif
#if 0
ACMD(auto_swarmcharge)
{
        dbref targetref;

        if(MechType(mech) != CLASS_BSUIT)
                return "!I am not a battlesuit";

        if(strcmp(args[0], "cancel") == 0) {
                a->flags &= ~AUTOPILOT_SWARMCHARGE;
                return "Canceling swarm charge";
        }

        targetref = FindTargetDBREFFromMapNumber(mech, args[0]);
        if(targetref <= 0)
                return "!Invalid target to swarmcharge";
        Clear(a);
        auto_addcommand(a->mynum, a, tprintf("dumbfollow %d", targetref));
        auto_engage(a->mynum, a, "");
        a->flags |= AUTOPILOT_SWARMCHARGE;
        return tprintf("swarmcharging %s (%d degrees, %d away)", args[0],
                                   a->ofsx, a->ofsy);
}
#endif
#if 0
ACMD(auto_freq)
{
        int freq;

        if(Readnum(freq, args[0]))
                return "!Invalid freq";
        mech_set_channelfreq(a->mynum, mech, tprintf("a=%s", args[0]));
        return "channel changed";
}
#endif
#if 0
ACMD(auto_setchanfreq)
{
        mech_set_channelfreq(a->mynum, mech, tprintf("%s=%s", args[0], args[1]));
        return tprintf("set channelfreq %s=%s", args[0], args[1]);
}
#endif
#if 0
ACMD(auto_setchanmode)
{
        mech_set_channelmode(a->mynum, mech, tprintf("%s=%s", args[0], args[1]));
        return tprintf("set channelmode %s=%s", args[0], args[1]);
}
#endif
#if 0
ACMD(auto_enterbay)
{
        mech_enterbay(a->mynum, mech, argc ? tprintf("%s",
                                                                                                 args[0]) : tprintf(""));
        return argc ? tprintf("entering bay (of %s)", args[0]) : "entering bay";
}
#endif
#if 0
ACMD(auto_cmode)
{
        int mod, ran;
        static char buf[MBUF_SIZE];

        if(Readnum(mod, args[0]))
                return "!Invalid mode [0-2]";
        if(mod < 0 || mod > 2)
                return "!Invalid mode [0-2]";
        if(Readnum(ran, args[1]))
                return "!Invalid range [0-999]";
        if(ran < 0 || ran > 999)
                return "!Invalid range [0-999]";
        a->auto_cdist = ran;
        a->auto_cmode = mod;
        switch (mod) {
        case 0:
                sprintf(buf, "fleeing, at least to range %d {from all foes}", ran);
                break;
        case 1:
                sprintf(buf, "trying to maintain range %d {from all foes}", ran);
                break;
        case 2:
                sprintf(buf, "charging to range %d {from all foes}", ran);
                break;
        }
        return buf;
}
#endif

/*
 * Event to get AI to radio a message
 */
void auto_reply_event(MUXEVENT * muxevent)
{

        MECH *mech = (MECH *) muxevent->data;
        char *buf = (char *) muxevent->data2;
        MAP *map;

        /* Make sure its a mech */
        if(!IsMech(mech->mynum)) {
                free(buf);
                return;
        }

        /* If valid object */
        if(mech)
                if((map = (getMap(mech->mapindex))))
                        sendchannelstuff(mech, 0, buf);

        free(buf);
}

/*
 * Force the AI to reply over radio
 */
void auto_reply(MECH * mech, char *buf)
{

        char *reply;

        /* No zero freq messages */
        if(!mech->freq[0])
                return;

        /* Make sure there is an autopilot */
        if(MechAuto(mech) <= 0)
                return;

        /* Make sure valid objects */
        if(!(FindObjectsData(MechAuto(mech))) ||
           !Good_obj(MechAuto(mech)) || Location(MechAuto(mech)) != mech->mynum) {
                MechAuto(mech) = -1;
                return;
        }

        /* Copy the buffer */
        reply = strdup(buf);

        if(reply) {
                MECHEVENT(mech, EVENT_AUTO_REPLY, auto_reply_event, Number(1, 2),
                                  reply);
        } else {
                SendAI
                        ("Interal AI Error: Attempting to radio reply but unable to copy string");
        }

}

/*
 * Parse an AI radio command
 */
void auto_parse_command(AUTO * autopilot, MECH * mech, int chn, char *buffer)
{

        int argc, cmd;
        char *args[2];
        char *command_args[AUTOPILOT_MAX_ARGS];
        char mech_id[3];
        char message[LBUF_SIZE];
        char reply[LBUF_SIZE];
        int i;

        /* Basic checks */
        if(!autopilot || !mech)
                return;
        if(Destroyed(mech))
                return;

        /* Get the args - just need the first one */
        if(proper_explodearguments(buffer, args, 2) < 2) {
                /* free args */
                for(i = 0; i < 2; i++) {
                        if(args[i])
                                free(args[i]);
                }
                return;
        }

        /* Check to see if the command was given to this AI */
        if(strcmp(args[0], "all")) {
                mech_id[0] = MechID(mech)[0];
                mech_id[1] = MechID(mech)[1];
                mech_id[2] = '\0';

                if(strcasecmp(mech_id, args[0])) {
                        /* free args */
                        for(i = 0; i < 2; i++) {
                                if(args[i])
                                        free(args[i]);
                        }
                        return;
                }

        }

        /* Parse the command */
        cmd = -1;
        argc = proper_explodearguments(args[1], command_args, AUTOPILOT_MAX_ARGS);

        /* Loop through the various possible commands looking for ours */
        for(i = 0; auto_cmds[i].sho; i++) {
                if(!strncmp
                   (auto_cmds[i].sho, command_args[0], strlen(auto_cmds[i].sho)))
                        if(!strncmp
                           (auto_cmds[i].name, command_args[0],
                                strlen(command_args[0]))) {
                                if(argc == (auto_cmds[i].args + 1)) {
                                        cmd = i;
                                        break;
                                }
                        }
        }

        /* Did we find a command */
        if(cmd < 0) {

                snprintf(message, LBUF_SIZE, "Unable to comprehend the command.");
                auto_reply(mech, message);

                /* free args */
                for(i = 0; i < 2; i++) {
                        if(args[i])
                                free(args[i]);
                }
                for(i = 0; i < AUTOPILOT_MAX_ARGS; i++) {
                        if(command_args[i])
                                free(command_args[i]);
                }
                return;

        }

        /* Zero the buffer */
        memset(message, 0, sizeof(message));
        memset(reply, 0, sizeof(reply));

        /* Call the radio command function */
        (*(auto_cmds[cmd].fun)) (autopilot, mech, command_args, argc, message);

        /* If its a silent command there is no reply */
        if(auto_cmds[cmd].silent) {

                /* Free args and exit */
                for(i = 0; i < 2; i++) {
                        if(args[i])
                                free(args[i]);
                }
                for(i = 0; i < AUTOPILOT_MAX_ARGS; i++) {
                        if(command_args[i])
                                free(command_args[i]);
                }
                return;

        }

        /* Check to see if a message was returned */
        if(*message) {

                /* Check if there was an error message
                 * otherwise add a front and back to the message */
                if(message[0] == '!') {
                        snprintf(reply, LBUF_SIZE, "ERROR: %s!", message + 1);
                } else {

                        switch (Number(0, 20)) {
                        case 0:
                        case 1:
                        case 2:
                        case 4:
                                snprintf(reply, LBUF_SIZE, "%s%s%s", "Affirmative, ",
                                                 message, ".");
                                break;
                        case 5:
                                snprintf(reply, LBUF_SIZE, "%s%s%s", "Nod, ", message, ".");
                                break;
                        case 6:
                                snprintf(reply, LBUF_SIZE, "%s%s%s", "Fine, ", message, ".");
                                break;
                        case 7:
                                snprintf(reply, LBUF_SIZE, "%s%s%s", "Aye aye, Captain, ",
                                                 message, "!");
                                break;
                        case 8:
                        case 9:
                        case 10:
                                snprintf(reply, LBUF_SIZE, "%s%s%s", "Da, boss, ",
                                                 message, "!");
                                break;
                        case 11:
                        case 12:
                                snprintf(reply, LBUF_SIZE, "%s%s%s", "Ok, ", message, ".");
                                break;
                        case 13:
                                snprintf(reply, LBUF_SIZE, "%s%s%s", "Okay, okay, ",
                                                 message, ", happy now?");
                                break;
                        case 14:
                                snprintf(reply, LBUF_SIZE, "%s%s%s", "Okidoki, ",
                                                 message, "!");
                                break;
                        case 15:
                        case 16:
                        case 17:
                                snprintf(reply, LBUF_SIZE, "%s%s%s", "Aye, ", message, ".");
                                break;
                        default:
                                snprintf(reply, LBUF_SIZE, "%s%s%s", "Roger, Roger, ",
                                                 message, ".");
                                break;
                        }                                       /* End of switch */

                }

                auto_reply(mech, reply);

        } else if(!auto_cmds[cmd].silent) {

                /* Command isn't silent but it didn't return a message */
                snprintf(reply, LBUF_SIZE, "Ok.");
                auto_reply(mech, reply);

        }

        /* free args */
        for(i = 0; i < 2; i++) {
                if(args[i])
                        free(args[i]);
        }
        for(i = 0; i < AUTOPILOT_MAX_ARGS; i++) {
                if(command_args[i])
                        free(command_args[i]);
        }

}

---