src/hcode/btech/autopilot_core.c

Go to the documentation of this file.

/*
 * Author: Markus Stenberg <fingon@iki.fi>
 *
 *  Copyright (c) 1996 Markus Stenberg
 *  Copyright (c) 1998-2002 Thomas Wouters
 *  Copyright (c) 2000-2002 Cord Awtry
 *       All rights reserved
 *
 */

#include "mech.h"
#include "mech.events.h"
#include "autopilot.h"
#include "coolmenu.h"
#include "mycool.h"
#include "p.mech.utils.h"

extern ACOM acom[AUTO_NUM_COMMANDS + 1];
extern char *muxevent_names[];

#define AI_COMMAND_DLLIST_START     51  /* Tag for start of saved command list */
#define AI_COMMAND_DLLIST_END       63  /* Tag for end of saved command list */

#define outbyte(a) tmpb=(a); fwrite(&tmpb, 1, 1, file);

#define CHESA(a,b,c,d) if ((tmpb=fwrite(a,b,c,d)) != c) \
    { fprintf (stderr, "Error writing dllist\n"); \
      fflush(stderr); exit(1); }

#define CHELO(a,b,c,d) if ((tmpb=fread(a,b,c,d)) != c) \
    { fprintf (stderr, "Error loading dllist\n"); \
      fflush(stderr); exit(1); }

/*
 * Creates a new command_node for the AI's
 * command list
 */
static command_node *auto_create_command_node()
{

        command_node *temp;

        temp = malloc(sizeof(command_node));
        if(temp == NULL)
                return NULL;

        memset(temp, 0, sizeof(command_node));
        temp->ai_command_function = NULL;

        return temp;

}

/*
 * Destroys a command_node
 */
void auto_destroy_command_node(command_node * node)
{

        int i;

        /* Free the args */
        for(i = 0; i < AUTOPILOT_MAX_ARGS; i++) {
                if(node->args[i]) {
                        free(node->args[i]);
                        node->args[i] = NULL;
                }
        }

        /* Free the node */
        free(node);

        return;

}

/*
 * Writes a command_node to the file specified by f. Used to
 * save AI command list to the hcode.db file
 */
static void auto_write_command_node(FILE * file, command_node * node)
{

        unsigned char size;                     /* Number of Arguments to save */
        char buf[MBUF_SIZE];            /* Buffer to write the strings */
        int i;                                          /* Counter */
        unsigned short tmpb;            /* Store the number of bytes written */

        /* Zero the Buffer */
        memset(buf, '\0', sizeof(buf));

        /* Write the Number of Arguments we're storing */
        size = node->argcount;
        CHESA(&size, 1, sizeof(size), file);

        /* Loop through the args and write them */
        for(i = 0; i <= size; i++) {
                strncpy(buf, node->args[i], MBUF_SIZE);
                CHESA(&buf, 1, sizeof(buf), file);
        }

        return;

}

/*
 * Reads the data for a command_node from a file. Used
 * to load the AI command list from hcode.db
 */
static command_node *auto_read_command_node(FILE * file)
{

        unsigned char size;                     /* Number of Arguments to read */
        char buf[MBUF_SIZE];            /* Buffer to store the strings */
        int i;                                          /* Counter */
        unsigned short tmpb;            /* Store the number of bytes read */

        command_node *temp_command_node;

        /* Allocate a command node */
        temp_command_node = auto_create_command_node();

        /* Zero the Buffer */
        memset(buf, '\0', sizeof(buf));

        /* Read the Number of Arguments we're storing */
        CHELO(&size, 1, sizeof(size), file);
        temp_command_node->argcount = size;

        /* Loop through the arguments and store them */
        for(i = 0; i <= size; i++) {

                CHELO(&buf, 1, sizeof(buf), file);
                temp_command_node->args[i] = strndup(buf, MBUF_SIZE);

        }

        /* Make sure there is a command */
        if(!temp_command_node->args[0]) {
                fprintf(stderr, "Error loading command node from file - "
                                "no command found\n");
                exit(1);
        }

        /* Get the command_enum and the command_function */
        for(i = 0; acom[i].name; i++) {
                if((!strncmp(temp_command_node->args[0], acom[i].name,
                                         strlen(temp_command_node->args[0]))) &&
                   (!strncmp(acom[i].name, temp_command_node->args[0],
                                         strlen(acom[i].name))))
                        break;
        }

        if(!acom[i].name) {
                fprintf(stderr, "Error loading command node from file - "
                                "Invalid Command\n");
                exit(1);
        }

        temp_command_node->command_enum = acom[i].command_enum;
        temp_command_node->ai_command_function = acom[i].ai_command_function;

        return temp_command_node;

}

/* 
 * Saves the current command list from the AI to
 * a file.  Called by SaveSpecialObjects from
 * glue.c
 */
void auto_save_commands(FILE * file, AUTO * autopilot)
{

        int i;                                          /* Our Counter */
        unsigned char tmpb;                     /* Our temp int we use when writing */
        unsigned int size;                      /* The size of our command list */

        command_node *temp_command_node;

        /* Print the Start Code */
        outbyte(AI_COMMAND_DLLIST_START);

        /* Write the size of our list */
        size = dllist_size(autopilot->commands);
        CHESA(&size, sizeof(size), 1, file);

        /* Check the size of the list, if there are commands save them */
        if(dllist_size(autopilot->commands) > 0) {

                /* Ok there stuff here so lets write it */
                for(i = 1; i <= dllist_size(autopilot->commands); i++) {
                        temp_command_node =
                                (command_node *) dllist_get_node(autopilot->commands, i);
                        auto_write_command_node(file, temp_command_node);
                }

        }

        /* Print the Stop Code */
        outbyte(AI_COMMAND_DLLIST_END);

        return;

}

/*
 * Loads an AI's saved command list from
 * a file.  Called by load_xcode in glue.c
 */
void auto_load_commands(FILE * file, AUTO * autopilot)
{

        int i;                                          /* Our Counter */
        unsigned char tmpb;                     /* Our temp int we use when reading */
        unsigned int size;                      /* The size of our command list */

        dllist_node *temp_dllist_node;
        command_node *temp_command_node;

        /* Alloc a dllist to the AI for commands */
        autopilot->commands = dllist_create_list();

        /* If we can't even read the file don't bother
         * with the rest */
        if(feof(file))
                return;

        /* Loop for the beginning tag */
        fread(&tmpb, 1, 1, file);
        if(tmpb != AI_COMMAND_DLLIST_START) {
                fprintf(stderr, "Unable to locate START for reading data"
                                " for AI #%d\n", autopilot->mynum);
                fflush(stderr);
                exit(1);
        }

        /* Read in size of dllist */
        CHELO(&size, sizeof(size), 1, file);

        /* if size is bigger then zero means we have to read
         * in some command nodes */
        if(size > 0) {

                /* Loop through the list and add the nodes */
                for(i = 1; i <= size; i++) {

                        temp_command_node = auto_read_command_node(file);
                        temp_dllist_node = dllist_create_node(temp_command_node);
                        dllist_insert_end(autopilot->commands, temp_dllist_node);

                }

        }

        /* Look for the end tag */
        fread(&tmpb, 1, 1, file);
        if(tmpb != AI_COMMAND_DLLIST_END) {
                fprintf(stderr, "Unable to locate END for reading data"
                                " for AI #%d\n", autopilot->mynum);
                fflush(stderr);
                exit(1);
        }

        return;

}

/* 
   The Autopilot command interface

   addcommand <name> [args]
   delcommand <num>
   listcommands
   engage
   disengage
   jump

 */

/*
 * The commands that are on the XCODE Object along
 * with some helper commands for modifying the state
 * of the AI
 */

int auto_valid_progline(AUTO * a, int p)
{
        int i;
#if 0
        for(i = 0; i < a->first_free; i += (acom[a->commands[i]].argcount + 1))
                if(i == p)
                        return 1;
#endif
        return 0;
}

/*
 * Internal function to return a string that
 * displays a command from a command_node
 */
static char *auto_show_command(command_node * node)
{

        static char buf[MBUF_SIZE];
        int i;

        snprintf(buf, MBUF_SIZE, "%-10s", node->args[0]);

        /* Loop through the args and print the commands */
        for(i = 1; i < AUTOPILOT_MAX_ARGS; i++)
                if(node->args[i]) {
                        strncat(buf, " ", MBUF_SIZE);
                        strncat(buf, node->args[i], MBUF_SIZE);
                }

        return buf;

}

/*
 * Removes a command from the AI's command list
 */
void auto_delcommand(dbref player, void *data, char *buffer)
{

        int p, i;
        AUTO *autopilot = (AUTO *) data;
        int remove_all_commands = 0;
        command_node *temp_command_node;
        char error_buf[MBUF_SIZE];

        /* Make sure they specified an argument */
        if(!*buffer) {
                notify(player, "No argument used : Usage delcommand [num]\n");
                notify_printf(player, "Must be within the range"
                                          " 1 to %d or -1 for all\n",
                                          dllist_size(autopilot->commands));
                return;
        }

        /* Make sure its a number */
        if(Readnum(p, buffer)) {
                notify_printf(player, "Invalid Argument : Must be within the range"
                                          " 1 to %d or -1 for all\n",
                                          dllist_size(autopilot->commands));
                return;
        }

        /* Check if its a valid command position
         * If its -1 means remove all */
        if(p == -1) {
                remove_all_commands = 1;
        } else if((p > dllist_size(autopilot->commands)) || (p < 1)) {
                notify_printf(player, "Invalid Argument : Must be within the range"
                                          " 1 to %d or -1 for all\n",
                                          dllist_size(autopilot->commands));
                return;
        }

        /* Now remove the node(s) */
        if(!remove_all_commands) {

                /* Remove the node at pos */
                temp_command_node =
                        (command_node *) dllist_remove_node_at_pos(autopilot->commands,
                                                                                                           p);

                if(!temp_command_node) {
                        snprintf(error_buf, MBUF_SIZE,
                                         "Internal AI Error: Trying to remove"
                                         " Command #%d from AI #%d but the command node doesn't exist\n",
                                         p, autopilot->mynum);
                        SendAI(error_buf);
                }

                /* Destroy the command_node */
                auto_destroy_command_node(temp_command_node);

                notify_printf(player, "Command #%d Successfully Removed\n", p);

        } else {

                /* Remove ALL the commands */
                while (dllist_size(autopilot->commands)) {

                        /* Remove the first node on the list and get the data
                         * from it */
                        temp_command_node =
                                (command_node *) dllist_remove(autopilot->commands,
                                                                                           dllist_head(autopilot->
                                                                                                                   commands));

                        /* Make sure the command node exists */
                        if(!temp_command_node) {

                                snprintf(error_buf, MBUF_SIZE,
                                                 "Internal AI Error: Trying to remove"
                                                 " the first command from AI #%d but the command node doesn't exist\n",
                                                 autopilot->mynum);
                                SendAI(error_buf);

                        } else {

                                /* Destroy the command node */
                                auto_destroy_command_node(temp_command_node);

                        }

                }

                notify(player, "All the commands have been removed.\n");

        }

}

/*
 * Jump to a specific command location in the AI's
 * command list
 */
void auto_jump(dbref player, void *data, char *buffer)
{
        int p;
        AUTO *a = (AUTO *) data;

        notify(player, "jump has been temporarly disabled till I can figure out"
                   " how I want to change it - Dany");
#if 0
        skipws(buffer);
        DOCHECK(!*buffer, "Argument expected!");
        DOCHECK(Readnum(p, buffer), "Invalid argument - single number expected.");
        /* Find out if it's valid position */
        DOCHECK(!auto_valid_progline(a, p),
                        "Invalid : Argument out of range, or argument, not command.");
        PG(a) = p;
        notify_printf(player, "Program Counter set to #%d.", p);
#endif
}

/*
 * Adds a command to the AI Command List
 */
void auto_addcommand(dbref player, void *data, char *buffer)
{

        AUTO *autopilot = (AUTO *) data;
        char *args[AUTOPILOT_MAX_ARGS]; /* args[0] is the command the rest are 
                                                                           args for the command */
        char *command;                          /* temp string to get the name of the command */
        int argc;
        int i, j;

        command_node *temp_command_node;
        dllist_node *temp_dllist_node;

        /* Clear the Args */
        memset(args, 0, sizeof(char *) * AUTOPILOT_MAX_ARGS);

        command = first_parseattribute(buffer);

        /* Look at the buffer and try and get the command */
        for(i = 0; acom[i].name; i++) {
                if((!strncmp(command, acom[i].name, strlen(command))) &&
                   (!strncmp(acom[i].name, command, strlen(acom[i].name))))
                        break;
        }

        /* Free the command string we dont need it anymore */
        free(command);

        /* Make sure its a valid command */
        DOCHECK(!acom[i].name, "Invalid Command!");

        /* Get the arguments for the command */
        if(acom[i].argcount > 0) {

                /* Parse the buffer for commands
                 * Its argcount + 1 because we are parsing the command + its
                 * arguments */
                argc = proper_explodearguments(buffer, args, acom[i].argcount + 1);

                if(argc != acom[i].argcount + 1) {

                        /* Free the args before we quit */
                        for(j = 0; j < AUTOPILOT_MAX_ARGS; j++) {
                                if(args[j])
                                        free(args[j]);
                        }
                        notify(player, "Not the proper number of arguments!");
                        return;

                }

        } else {

                /* Copy the command to the first arg */
                args[0] = strdup(acom[i].name);

        }

        /* Build the command node */
        temp_command_node = auto_create_command_node();

        for(j = 0; j < AUTOPILOT_MAX_ARGS; j++) {
                if(args[j])
                        temp_command_node->args[j] = args[j];
        }

        temp_command_node->argcount = acom[i].argcount;
        temp_command_node->command_enum = acom[i].command_enum;
        temp_command_node->ai_command_function = acom[i].ai_command_function;

        /* Add the command to the list */
        temp_dllist_node = dllist_create_node(temp_command_node);
        dllist_insert_end(autopilot->commands, temp_dllist_node);

        /* Let the player know it worked */
        notify_printf(player, "Command Added: %s",
                                  auto_show_command(temp_command_node));

}

/*
 * Lists the various settings and commands currently on the AI
 */
void auto_listcommands(dbref player, void *data, char *buffer)
{

        AUTO *autopilot = (AUTO *) data;
        coolmenu *c = NULL;
        char buf[MBUF_SIZE];
        int i, count = 0;

        addline();

        snprintf(buf, MBUF_SIZE, "Autopilot data for %s", Name(autopilot->mynum));
        vsi(buf);

        snprintf(buf, MBUF_SIZE, "Controling unit %s",
                         Name(Location(autopilot->mynum)));
        vsi(buf);

        addline();

        snprintf(buf, MBUF_SIZE, "MyRef: #%d  MechRef: #%d  MapIndex: #%d  "
                         "FSpeed: %d %% (Flag:%d)", autopilot->mynum,
                         autopilot->mymechnum, autopilot->mapindex, autopilot->speed,
                         autopilot->flags);
        vsi(buf);

        addline();

        if(dllist_size(autopilot->commands)) {

                for(i = 1; i <= dllist_size(autopilot->commands); i++) {
                        snprintf(buf, MBUF_SIZE, "#%-3d %s", i,
                                         auto_show_command((command_node *)
                                                                           dllist_get_node(autopilot->commands,
                                                                                                           i)));
                        vsi(buf);
                }

        } else {
                vsi("No commands have been queued to date.");
        }

        addline();
        ShowCoolMenu(player, c);
        KillCoolMenu(c);
}

void auto_eventstats(dbref player, void *data, char *buffer)
{

        AUTO *autopilot = (AUTO *) data;
        int i, j, total;

        notify(player, "Events by type: ");
        notify(player, "-------------------------------");

        total = 0;

        for(i = FIRST_AUTO_EVENT; i <= LAST_AUTO_EVENT; i++) {

                if((j = muxevent_count_type_data(i, (void *) autopilot))) {
                        notify_printf(player, "%-20s%d", muxevent_names[i], j);
                        total += j;
                }

        }

        if(total) {
                notify(player, "-------------------------------");
                notify_printf(player, "%d total", total);
        }

}

/*
 * Turn the autopilot on
 */
static int auto_pilot_on(AUTO * autopilot)
{

        int i, j, count = 0;

        for(i = FIRST_AUTO_EVENT; i <= LAST_AUTO_EVENT; i++)
                if((j = muxevent_count_type_data(i, (void *) autopilot)))
                        count += j;

        if(!count) {
                return autopilot->flags & (AUTOPILOT_AUTOGUN | AUTOPILOT_GUNZOMBIE |
                                                                   AUTOPILOT_PILZOMBIE);
        }

        return count;

}

/*
 * Stop whatever the autopilot is doing
 */
extern void auto_stop_pilot(AUTO * autopilot)
{

        int i;

        autopilot->flags &= ~(AUTOPILOT_AUTOGUN | AUTOPILOT_GUNZOMBIE
                                                  | AUTOPILOT_PILZOMBIE);

        for(i = FIRST_AUTO_EVENT; i <= LAST_AUTO_EVENT; i++)
                muxevent_remove_type_data(i, (void *) autopilot);

}

/*
 * Set the comtitle for the autopilot's unit
 */
void auto_set_comtitle(AUTO * autopilot, MECH * mech)
{

        char buf[LBUF_SIZE];

        snprintf(buf, LBUF_SIZE, "a=%s/%s", MechType_Ref(mech), MechIDS(mech, 1));
        mech_set_channeltitle(autopilot->mynum, mech, buf);

}

/*
 * Set default parameters for the AI
 */
void auto_init(AUTO * autopilot, MECH * mech)
{

        autopilot->ofsx = 0;            /* Positional - angle */
        autopilot->ofsy = 0;            /* Positional - distance */
        autopilot->auto_cmode = 1;      /* CHARGE! */
        autopilot->auto_cdist = 2;      /* Attempt to avoid kicking distance */
        autopilot->auto_nervous = 0;
        autopilot->auto_goweight = 44;  /* We're mainly concentrating on fighting */
        autopilot->auto_fweight = 55;
        autopilot->speed = 100;         /* Reset to full speed */
        autopilot->flags = 0;

        /* Target Stuff */
        autopilot->target = -2;
        autopilot->target_score = 0;
        autopilot->target_threshold = 50;
        autopilot->target_update_tick = AUTO_GUN_UPDATE_TICK;

        /* Follow & Chase target stuff */
        autopilot->chase_target = -10;
        autopilot->chasetarg_update_tick = AUTOPILOT_CHASETARG_UPDATE_TICK;
        autopilot->follow_update_tick = AUTOPILOT_FOLLOW_UPDATE_TICK;

}

/*
 * Setup all the flags and variables to current, then
 * start the AI's first command.
 */
void auto_engage(dbref player, void *data, char *buffer)
{

        AUTO *autopilot = (AUTO *) data;
        MECH *mech;

        autopilot->mymech = mech =
                getMech((autopilot->mymechnum = Location(autopilot->mynum)));
        DOCHECK(!autopilot, "Internal error! - Bad AI object!");
        DOCHECK(!mech, "Error: The autopilot isn't inside a 'mech!");
        DOCHECK(auto_pilot_on(autopilot),
                        "The autopilot's already online! You have to disengage it first.");

        if(MechAuto(mech) <= 0)
                auto_init(autopilot, mech);
        MechAuto(mech) = autopilot->mynum;

        if(MechAuto(mech) > 0)
                auto_set_comtitle(autopilot, mech);

        autopilot->mapindex = mech->mapindex;

        notify(player, "Engaging autopilot...");
        AUTOEVENT(autopilot, EVENT_AUTOCOM, auto_com_event, AUTOPILOT_NC_DELAY,
                          0);

        return;

}

/*
 * Turn off the autopilot
 */
void auto_disengage(dbref player, void *data, char *buffer)
{

        AUTO *autopilot = (AUTO *) data;

        DOCHECK(!auto_pilot_on(autopilot),
                        "The autopilot's already offline! You have to engage it first.");

        auto_stop_pilot(autopilot);
        notify(player, "Autopilot has been disengaged.");

        return;

}

/*
 * Remove the first command_node in the list and go to the next
 */
void auto_goto_next_command(AUTO * autopilot, int time)
{

        command_node *temp_command_node;
        char error_buf[MBUF_SIZE];

        if(dllist_size(autopilot->commands) < 0) {
                snprintf(error_buf, MBUF_SIZE, "Internal AI Error: Trying to remove"
                                 " the first command from AI #%d but the command list is empty\n",
                                 autopilot->mynum);
                SendAI(error_buf);
                return;
        }

        temp_command_node = (command_node *) dllist_remove(autopilot->commands,
                                                                                                           dllist_head(autopilot->
                                                                                                                                   commands));

        if(!temp_command_node) {
                snprintf(error_buf, MBUF_SIZE, "Internal AI Error: Trying to remove"
                                 " the first command from AI #%d but the command node doesn't exist\n",
                                 autopilot->mynum);
                SendAI(error_buf);
                return;
        }

        auto_destroy_command_node(temp_command_node);

        /* Fire off the AUTO_COM event */
        AUTO_COM(autopilot, time);

}

/*
 * Get the argument for a given command position and argument number
 * Remember to free the string that this returns after use 
 */
char *auto_get_command_arg(AUTO * autopilot, int command_number,
                                                   int arg_number)
{

        char *argument;
        command_node *temp_command_node;
        char error_buf[MBUF_SIZE];

        if(command_number > dllist_size(autopilot->commands)) {
                snprintf(error_buf, MBUF_SIZE, "Internal AI Error: Trying to "
                                 "access Command #%d for AI #%d but it doesn't exist",
                                 command_number, autopilot->mynum);
                SendAI(error_buf);
                return NULL;
        }

        if(arg_number >= AUTOPILOT_MAX_ARGS) {
                snprintf(error_buf, MBUF_SIZE, "Internal AI Error: Trying to "
                                 "access Arg #%d for AI #%d Command #%d but its greater"
                                 " then AUTOPILOT_MAX_ARGS (%d)",
                                 arg_number, autopilot->mynum, command_number,
                                 AUTOPILOT_MAX_ARGS);
                SendAI(error_buf);
                return NULL;
        }

        temp_command_node = (command_node *) dllist_get_node(autopilot->commands,
                                                                                                                 command_number);

        if(!temp_command_node->args[arg_number]) {
                snprintf(error_buf, MBUF_SIZE, "Internal AI Error: Trying to "
                                 "access Arg #%d for AI #%d Command #%d but it doesn't exist",
                                 autopilot->mynum, arg_number, command_number);
                SendAI(error_buf);
                return NULL;
        }

        argument = strndup(temp_command_node->args[arg_number], MBUF_SIZE);

        return argument;

}

/*
 * Returns the command_enum value for the given command
 * from the AI command list
 */
int auto_get_command_enum(AUTO * autopilot, int command_number)
{

        int command_enum;
        command_node *temp_command_node;
        char error_buf[MBUF_SIZE];

        /* Make sure there are commands */
        if(dllist_size(autopilot->commands) <= 0) {
                return -1;
        }

        if(command_number <= 0) {
                snprintf(error_buf, MBUF_SIZE, "Internal AI Error: Trying to "
                                 "access a command (%d) for AI #%d that can't be on a list",
                                 command_number, autopilot->mynum);
                SendAI(error_buf);
                return -1;
        }

        /* Make sure the command is on the list */
        if(command_number > dllist_size(autopilot->commands)) {
                snprintf(error_buf, MBUF_SIZE, "Internal AI Error: Trying to "
                                 "access Command #%d for AI #%d but it doesn't exist",
                                 autopilot->mynum, command_number);
                SendAI(error_buf);
                return -1;
        }

        temp_command_node = (command_node *) dllist_get_node(autopilot->commands,
                                                                                                                 command_number);

        command_enum = temp_command_node->command_enum;

        /* If its a bad enum value we have a problem */
        if((command_enum >= AUTO_NUM_COMMANDS) || (command_enum < 0)) {
                snprintf(error_buf, MBUF_SIZE, "Internal AI Error: Command ENUM for"
                                 " AI #%d Command Number #%d doesn't exist\n",
                                 autopilot->mynum, command_number);
                SendAI(error_buf);
                return -1;
        }

        return command_enum;

}

#define SPECIAL_FREE 0
#define SPECIAL_ALLOC 1

/*
 * Called when either creating a new autopilot - SPECIAL_ALLOC
 * or when destroying an autopilot - SPECIAL_FREE
 */
void auto_newautopilot(dbref key, void **data, int selector)
{

        AUTO *autopilot = *data;
        MECH *mech;
        command_node *temp;
        int i;

        switch (selector) {
        case SPECIAL_ALLOC:

                /* Allocate the command list */
                autopilot->commands = dllist_create_list();

                /* Make sure certain things are set NULL */
                autopilot->astar_path = NULL;
                autopilot->weaplist = NULL;

                for(i = 0; i < AUTO_PROFILE_MAX_SIZE; i++) {
                        autopilot->profile[i] = NULL;
                }

                /* And some things not set null */
                autopilot->speed = 100;

                break;

        case SPECIAL_FREE:

                /* Make sure the AI is stopped */
                auto_stop_pilot(autopilot);

                /* Go through the list and remove any leftover nodes */
                while (dllist_size(autopilot->commands)) {

                        /* Remove the first node on the list and get the data
                         * from it */
                        temp = (command_node *) dllist_remove(autopilot->commands,
                                                                                                  dllist_head(autopilot->
                                                                                                                          commands));

                        /* Destroy the command node */
                        auto_destroy_command_node(temp);

                }

                /* Destroy the list */
                dllist_destroy_list(autopilot->commands);
                autopilot->commands = NULL;

                /* Destroy any astar path list thats on the AI */
                auto_destroy_astar_path(autopilot);

                /* Destroy profile array */
                for(i = 0; i < AUTO_PROFILE_MAX_SIZE; i++) {
                        if(autopilot->profile[i]) {
                                rb_destroy(autopilot->profile[i]);
                        }
                        autopilot->profile[i] = NULL;
                }

                /* Destroy weaponlist */
                auto_destroy_weaplist(autopilot);

                /* Finally reset the AI value on its unit if
                 * it needs to */
                if((mech = getMech(autopilot->mymechnum))) {

                        /* Just incase another AI has taken over */
                        if(MechAuto(mech) == autopilot->mynum) {
                                MechAuto(mech) = -1;
                        }

                }

                break;

        }

}

// XXX: put in a header file
extern unsigned int global_tick;

void auto_heartbeat(AUTO *autopilot) {
    if(!autopilot->mymech) return;
    auto_sensor_event(autopilot);
    if(autopilot->weaplist == NULL || global_tick % AUTO_PROFILE_TICK == 0)  
        auto_update_profile_event(autopilot);
    auto_gun_event(autopilot);
}

---