src/hcode/btech/autopilot_core.c File Reference

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

Include dependency graph for autopilot_core.c:

Go to the source code of this file.

Defines
#define	AI_COMMAND_DLLIST_START   51
#define	AI_COMMAND_DLLIST_END   63
#define	outbyte(a)   tmpb=(a); fwrite(&tmpb, 1, 1, file);
#define	CHESA(a, b, c, d)
#define	CHELO(a, b, c, d)
#define	SPECIAL_FREE   0
#define	SPECIAL_ALLOC   1
Functions
static command_node *	auto_create_command_node ()
void	auto_destroy_command_node (command_node *node)
static void	auto_write_command_node (FILE *file, command_node *node)
static command_node *	auto_read_command_node (FILE *file)
void	auto_save_commands (FILE *file, AUTO *autopilot)
void	auto_load_commands (FILE *file, AUTO *autopilot)
int	auto_valid_progline (AUTO *a, int p)
static char *	auto_show_command (command_node *node)
void	auto_delcommand (dbref player, void *data, char *buffer)
void	auto_jump (dbref player, void *data, char *buffer)
void	auto_addcommand (dbref player, void *data, char *buffer)
void	auto_listcommands (dbref player, void *data, char *buffer)
void	auto_eventstats (dbref player, void *data, char *buffer)
static int	auto_pilot_on (AUTO *autopilot)
void	auto_stop_pilot (AUTO *autopilot)
void	auto_set_comtitle (AUTO *autopilot, MECH *mech)
void	auto_init (AUTO *autopilot, MECH *mech)
void	auto_engage (dbref player, void *data, char *buffer)
void	auto_disengage (dbref player, void *data, char *buffer)
void	auto_goto_next_command (AUTO *autopilot, int time)
char *	auto_get_command_arg (AUTO *autopilot, int command_number, int arg_number)
int	auto_get_command_enum (AUTO *autopilot, int command_number)
void	auto_newautopilot (dbref key, void **data, int selector)
void	auto_heartbeat (AUTO *autopilot)
Variables
ACOM	acom [AUTO_NUM_COMMANDS+1]
char *	muxevent_names []
unsigned int	global_tick

---

Define Documentation

#define AI_COMMAND_DLLIST_END   63

Definition at line 22 of file autopilot_core.c.

Referenced by auto_load_commands(), and auto_save_commands().

#define AI_COMMAND_DLLIST_START   51

Definition at line 21 of file autopilot_core.c.

Referenced by auto_load_commands(), and auto_save_commands().

#define CHELO	(	a,
		b,
		c,
		d		)

Value:

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

Definition at line 30 of file autopilot_core.c.

Referenced by auto_load_commands(), auto_read_command_node(), load_mapdynamic(), loadrepairs(), and map_load_bits().

#define CHESA	(	a,
		b,
		c,
		d		)

Value:

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

Definition at line 26 of file autopilot_core.c.

Referenced by auto_save_commands(), auto_write_command_node(), map_save_bits(), save_event(), save_mapdynamic(), and saverepairs().

#define outbyte

(

a

)

tmpb=(a); fwrite(&tmpb, 1, 1, file);

Definition at line 24 of file autopilot_core.c.

Referenced by auto_save_commands(), map_save_bits(), save_mapdynamic(), and save_mapobjs().

#define SPECIAL_ALLOC   1

Definition at line 876 of file autopilot_core.c.

Referenced by auto_newautopilot(), newfreemap(), newfreemech(), newfreemechrep(), NewSpecialObject(), and newturret().

#define SPECIAL_FREE   0

Definition at line 875 of file autopilot_core.c.

Referenced by auto_newautopilot(), DisposeSpecialObject(), newfreemap(), and newfreemech().

---

Function Documentation

void auto_addcommand	(	dbref	player,
		void *	data,
		char *	buffer
	)

Definition at line 449 of file autopilot_core.c.

References acom, ACOM::ai_command_function, command_node_t::ai_command_function, ACOM::argcount, command_node_t::argcount, command_node_t::args, args, auto_create_command_node(), auto_show_command(), AUTOPILOT_MAX_ARGS, ACOM::command_enum, command_node_t::command_enum, AUTO::commands, dllist_create_node(), dllist_insert_end(), DOCHECK, first_parseattribute(), name, ACOM::name, notify, notify_printf(), and proper_explodearguments().

Referenced by auto_com_event(), auto_radio_command_dfollow(), auto_radio_command_dgoto(), auto_radio_command_dropoff(), auto_radio_command_embark(), auto_radio_command_enterbase(), auto_radio_command_follow(), auto_radio_command_goto(), auto_radio_command_leavebase(), auto_radio_command_ogoto(), and auto_radio_command_pickup().

{

        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));

}

static command_node* auto_create_command_node

(

)

[static]

Definition at line 38 of file autopilot_core.c.

References command_node_t::ai_command_function.

Referenced by auto_addcommand(), and auto_read_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;

}

void auto_delcommand	(	dbref	player,
		void *	data,
		char *	buffer
	)

Definition at line 326 of file autopilot_core.c.

References auto_destroy_command_node(), AUTO::commands, dllist_head(), dllist_remove(), dllist_remove_node_at_pos(), dllist_size(), MBUF_SIZE, AUTO::mynum, notify, notify_printf(), Readnum, and SendAI.

Referenced by auto_radio_command_reset().

{

        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");

        }

}

void auto_destroy_command_node

(

command_node *

node

)

Definition at line 57 of file autopilot_core.c.

References command_node_t::args, and AUTOPILOT_MAX_ARGS.

Referenced by auto_delcommand(), auto_goto_next_command(), auto_newautopilot(), and newfreemech().

{

        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;

}

void auto_disengage	(	dbref	player,
		void *	data,
		char *	buffer
	)

Definition at line 722 of file autopilot_core.c.

References auto_pilot_on(), auto_stop_pilot(), DOCHECK, and notify.

Referenced by auto_radio_command_reset().

{

        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;

}

void auto_engage	(	dbref	player,
		void *	data,
		char *	buffer
	)

Definition at line 689 of file autopilot_core.c.

References auto_com_event(), auto_init(), auto_pilot_on(), auto_set_comtitle(), AUTOEVENT, AUTOPILOT_NC_DELAY, DOCHECK, EVENT_AUTOCOM, getMech(), Location, MECH::mapindex, AUTO::mapindex, MechAuto, AUTO::mymech, AUTO::mymechnum, AUTO::mynum, and notify.

Referenced by auto_radio_command_dfollow(), auto_radio_command_dgoto(), auto_radio_command_dropoff(), auto_radio_command_embark(), auto_radio_command_enterbase(), auto_radio_command_follow(), auto_radio_command_goto(), auto_radio_command_heading(), auto_radio_command_leavebase(), auto_radio_command_ogoto(), auto_radio_command_pickup(), auto_radio_command_reset(), and auto_radio_command_stop().

{

        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;

}

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

Definition at line 578 of file autopilot_core.c.

References FIRST_AUTO_EVENT, LAST_AUTO_EVENT, muxevent_count_type_data(), muxevent_names, notify, notify_printf(), and total.

{

        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);
        }

}

char* auto_get_command_arg	(	AUTO *	autopilot,
		int	command_number,
		int	arg_number
	)

Definition at line 777 of file autopilot_core.c.

References command_node_t::args, AUTOPILOT_MAX_ARGS, AUTO::commands, dllist_get_node(), dllist_size(), MBUF_SIZE, AUTO::mynum, SendAI, and strndup().

Referenced by auto_astar_follow_event(), auto_astar_goto_event(), auto_command_autogun(), auto_command_embark(), auto_command_pickup(), auto_command_roam(), auto_command_speed(), auto_dumbfollow_event(), auto_dumbgoto_event(), auto_enter_event(), auto_goto_event(), and auto_leave_event().

{

        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;

}

int auto_get_command_enum	(	AUTO *	autopilot,
		int	command_number
	)

Definition at line 826 of file autopilot_core.c.

References AUTO_NUM_COMMANDS, command_node_t::command_enum, AUTO::commands, dllist_get_node(), dllist_size(), MBUF_SIZE, AUTO::mynum, and SendAI.

Referenced by auto_astar_follow_event(), auto_astar_goto_event(), auto_astar_roam_event(), auto_cal_mapindex(), auto_com_event(), auto_dumbfollow_event(), auto_dumbgoto_event(), auto_enter_event(), and auto_leave_event().

{

        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;

}

void auto_goto_next_command	(	AUTO *	autopilot,
		int	time
	)

Definition at line 740 of file autopilot_core.c.

References AUTO_COM, auto_destroy_command_node(), AUTO::commands, dllist_head(), dllist_remove(), dllist_size(), MBUF_SIZE, AUTO::mynum, and SendAI.

Referenced by auto_astar_follow_event(), auto_astar_goto_event(), auto_astar_roam_event(), auto_com_event(), auto_command_roam(), auto_command_startup(), auto_dumbfollow_event(), auto_dumbgoto_event(), auto_enter_event(), auto_goto_event(), and auto_leave_event().

{

        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);

}

void auto_heartbeat

(

AUTO *

autopilot

)

Definition at line 966 of file autopilot_core.c.

References auto_gun_event(), AUTO_PROFILE_TICK, auto_sensor_event(), auto_update_profile_event(), global_tick, AUTO::mymech, and AUTO::weaplist.

Referenced by heartbeat_dispatch().

                                     {
    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);
}

void auto_init	(	AUTO *	autopilot,
		MECH *	mech
	)

Todo:

{Make this smarter and check some of these}

Definition at line 659 of file autopilot_core.c.

References AUTO::auto_cdist, AUTO::auto_cmode, AUTO::auto_fweight, AUTO::auto_goweight, AUTO_GUN_UPDATE_TICK, AUTO::auto_nervous, AUTOPILOT_CHASETARG_UPDATE_TICK, AUTOPILOT_FOLLOW_UPDATE_TICK, AUTO::chase_target, AUTO::chasetarg_update_tick, AUTO::flags, AUTO::follow_update_tick, AUTO::ofsx, AUTO::ofsy, AUTO::speed, AUTO::target, AUTO::target_score, AUTO::target_threshold, and AUTO::target_update_tick.

Referenced by auto_engage(), and auto_radio_command_reset().

{

        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;

}

void auto_jump	(	dbref	player,
		void *	data,
		char *	buffer
	)

Definition at line 427 of file autopilot_core.c.

References auto_valid_progline(), DOCHECK, notify, notify_printf(), PG, Readnum, and skipws.

{
        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
}

void auto_listcommands	(	dbref	player,
		void *	data,
		char *	buffer
	)

Definition at line 532 of file autopilot_core.c.

References addline, auto_show_command(), c, AUTO::commands, dllist_get_node(), dllist_size(), AUTO::flags, KillCoolMenu(), Location, AUTO::mapindex, MBUF_SIZE, AUTO::mymechnum, AUTO::mynum, Name(), ShowCoolMenu(), AUTO::speed, and vsi.

{

        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_load_commands	(	FILE *	file,
		AUTO *	autopilot
	)

Definition at line 211 of file autopilot_core.c.

References AI_COMMAND_DLLIST_END, AI_COMMAND_DLLIST_START, auto_read_command_node(), CHELO, AUTO::commands, dllist_create_list(), dllist_create_node(), dllist_insert_end(), and AUTO::mynum.

{

        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;

}

void auto_newautopilot	(	dbref	key,
		void **	data,
		int	selector
	)

Definition at line 882 of file autopilot_core.c.

References AUTO::astar_path, auto_destroy_astar_path(), auto_destroy_command_node(), auto_destroy_weaplist(), AUTO_PROFILE_MAX_SIZE, auto_stop_pilot(), AUTO::commands, dllist_create_list(), dllist_destroy_list(), dllist_head(), dllist_remove(), dllist_size(), getMech(), MechAuto, AUTO::mymechnum, AUTO::mynum, AUTO::profile, rb_destroy(), SPECIAL_ALLOC, SPECIAL_FREE, AUTO::speed, and AUTO::weaplist.

{

        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;

        }

}

static int auto_pilot_on

(

AUTO *

autopilot

)

[static]

Definition at line 608 of file autopilot_core.c.

References AUTOPILOT_AUTOGUN, AUTOPILOT_GUNZOMBIE, AUTOPILOT_PILZOMBIE, FIRST_AUTO_EVENT, LAST_AUTO_EVENT, and muxevent_count_type_data().

Referenced by auto_disengage(), and auto_engage().

{

        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;

}

static command_node* auto_read_command_node

(

FILE *

file

)

[static]

Definition at line 110 of file autopilot_core.c.

References acom, ACOM::ai_command_function, command_node_t::ai_command_function, command_node_t::argcount, command_node_t::args, auto_create_command_node(), CHELO, ACOM::command_enum, command_node_t::command_enum, MBUF_SIZE, name, ACOM::name, and strndup().

Referenced by auto_load_commands().

{

        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;

}

void auto_save_commands	(	FILE *	file,
		AUTO *	autopilot
	)

Definition at line 172 of file autopilot_core.c.

References AI_COMMAND_DLLIST_END, AI_COMMAND_DLLIST_START, auto_write_command_node(), CHESA, AUTO::commands, dllist_get_node(), dllist_size(), and outbyte.

Referenced by save_autopilot_data().

{

        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;

}

void auto_set_comtitle	(	AUTO *	autopilot,
		MECH *	mech
	)

Definition at line 645 of file autopilot_core.c.

References LBUF_SIZE, mech_set_channeltitle(), MechIDS(), MechType_Ref, and AUTO::mynum.

Referenced by auto_engage().

{

        char buf[LBUF_SIZE];

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

}

static char* auto_show_command

(

command_node *

node

)

[static]

Todo:

{Maybe re-write this so doesn't use a static buffer}

Definition at line 304 of file autopilot_core.c.

References command_node_t::args, AUTOPILOT_MAX_ARGS, and MBUF_SIZE.

Referenced by auto_addcommand(), and auto_listcommands().

{

        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;

}

void auto_stop_pilot

(

AUTO *

autopilot

)

Definition at line 629 of file autopilot_core.c.

References AUTOPILOT_AUTOGUN, AUTOPILOT_GUNZOMBIE, AUTOPILOT_PILZOMBIE, FIRST_AUTO_EVENT, AUTO::flags, LAST_AUTO_EVENT, and muxevent_remove_type_data().

Referenced by auto_disengage(), auto_newautopilot(), and newfreemech().

{

        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);

}

int auto_valid_progline	(	AUTO *	a,
		int	p
	)

Todo:

{See if we need this function and remove it if not}

Definition at line 288 of file autopilot_core.c.

References acom, ACOM::argcount, and AUTO::commands.

Referenced by auto_com_event(), and auto_jump().

{
        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;
}

static void auto_write_command_node	(	FILE *	file,
		command_node *	node
	)			[static]

Definition at line 81 of file autopilot_core.c.

References command_node_t::argcount, command_node_t::args, CHESA, and MBUF_SIZE.

Referenced by auto_save_commands().

{

        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;

}

---

Variable Documentation

ACOM acom[AUTO_NUM_COMMANDS+1]

Definition at line 40 of file autopilot_commands.c.

Referenced by auto_addcommand(), auto_read_command_node(), and auto_valid_progline().

unsigned int global_tick

Definition at line 27 of file tick.c.

Referenced by auto_heartbeat(), and heartbeat_run().

char* muxevent_names[]

Referenced by auto_eventstats(), and debug_EventTypes().

---