be_ai_goal.c

Go to the documentation of this file.

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

/*****************************************************************************
 * name:        be_ai_goal.c
 *
 * desc:        goal AI
 *
 * $Archive: /MissionPack/code/botlib/be_ai_goal.c $
 *
 *****************************************************************************/

#include "../game/q_shared.h"
#include "l_utils.h"
#include "l_libvar.h"
#include "l_memory.h"
#include "l_log.h"
#include "l_script.h"
#include "l_precomp.h"
#include "l_struct.h"
#include "aasfile.h"
#include "../game/botlib.h"
#include "../game/be_aas.h"
#include "be_aas_funcs.h"
#include "be_interface.h"
#include "be_ai_weight.h"
#include "../game/be_ai_goal.h"
#include "../game/be_ai_move.h"

//#define DEBUG_AI_GOAL
#ifdef RANDOMIZE
#define UNDECIDEDFUZZY
#endif //RANDOMIZE
#define DROPPEDWEIGHT
//minimum avoid goal time
#define AVOID_MINIMUM_TIME      10
//default avoid goal time
#define AVOID_DEFAULT_TIME      30
//avoid dropped goal time
#define AVOID_DROPPED_TIME      10
//
#define TRAVELTIME_SCALE        0.01
//item flags
#define IFL_NOTFREE             1       //not in free for all
#define IFL_NOTTEAM             2       //not in team play
#define IFL_NOTSINGLE           4       //not in single player
#define IFL_NOTBOT              8       //bot should never go for this
#define IFL_ROAM                16      //bot roam goal

//location in the map "target_location"
typedef struct maplocation_s
{
    vec3_t origin;
    int areanum;
    char name[MAX_EPAIRKEY];
    struct maplocation_s *next;
} maplocation_t;

//camp spots "info_camp"
typedef struct campspot_s
{
    vec3_t origin;
    int areanum;
    char name[MAX_EPAIRKEY];
    float range;
    float weight;
    float wait;
    float random;
    struct campspot_s *next;
} campspot_t;

//FIXME: these are game specific
typedef enum {
    GT_FFA,             // free for all
    GT_TOURNAMENT,      // one on one tournament
    GT_SINGLE_PLAYER,   // single player tournament

    //-- team games go after this --

    GT_TEAM,            // team deathmatch
    GT_CTF,             // capture the flag
#ifdef MISSIONPACK
    GT_1FCTF,
    GT_OBELISK,
    GT_HARVESTER,
#endif
    GT_MAX_GAME_TYPE
} gametype_t;

typedef struct levelitem_s
{
    int number;                         //number of the level item
    int iteminfo;                       //index into the item info
    int flags;                          //item flags
    float weight;                       //fixed roam weight
    vec3_t origin;                      //origin of the item
    int goalareanum;                    //area the item is in
    vec3_t goalorigin;                  //goal origin within the area
    int entitynum;                      //entity number
    float timeout;                      //item is removed after this time
    struct levelitem_s *prev, *next;
} levelitem_t;

typedef struct iteminfo_s
{
    char classname[32];                 //classname of the item
    char name[MAX_STRINGFIELD];         //name of the item
    char model[MAX_STRINGFIELD];        //model of the item
    int modelindex;                     //model index
    int type;                           //item type
    int index;                          //index in the inventory
    float respawntime;                  //respawn time
    vec3_t mins;                        //mins of the item
    vec3_t maxs;                        //maxs of the item
    int number;                         //number of the item info
} iteminfo_t;

#define ITEMINFO_OFS(x) (int)&(((iteminfo_t *)0)->x)

fielddef_t iteminfo_fields[] =
{
{"name", ITEMINFO_OFS(name), FT_STRING},
{"model", ITEMINFO_OFS(model), FT_STRING},
{"modelindex", ITEMINFO_OFS(modelindex), FT_INT},
{"type", ITEMINFO_OFS(type), FT_INT},
{"index", ITEMINFO_OFS(index), FT_INT},
{"respawntime", ITEMINFO_OFS(respawntime), FT_FLOAT},
{"mins", ITEMINFO_OFS(mins), FT_FLOAT|FT_ARRAY, 3},
{"maxs", ITEMINFO_OFS(maxs), FT_FLOAT|FT_ARRAY, 3},
{0, 0, 0}
};

structdef_t iteminfo_struct =
{
    sizeof(iteminfo_t), iteminfo_fields
};

typedef struct itemconfig_s
{
    int numiteminfo;
    iteminfo_t *iteminfo;
} itemconfig_t;

//goal state
typedef struct bot_goalstate_s
{
    struct weightconfig_s *itemweightconfig;    //weight config
    int *itemweightindex;                       //index from item to weight
    //
    int client;                                 //client using this goal state
    int lastreachabilityarea;                   //last area with reachabilities the bot was in
    //
    bot_goal_t goalstack[MAX_GOALSTACK];        //goal stack
    int goalstacktop;                           //the top of the goal stack
    //
    int avoidgoals[MAX_AVOIDGOALS];             //goals to avoid
    float avoidgoaltimes[MAX_AVOIDGOALS];       //times to avoid the goals
} bot_goalstate_t;

bot_goalstate_t *botgoalstates[MAX_CLIENTS + 1]; // bk001206 - FIXME: init?
//item configuration
itemconfig_t *itemconfig = NULL; // bk001206 - init
//level items
levelitem_t *levelitemheap = NULL; // bk001206 - init
levelitem_t *freelevelitems = NULL; // bk001206 - init
levelitem_t *levelitems = NULL; // bk001206 - init
int numlevelitems = 0;
//map locations
maplocation_t *maplocations = NULL; // bk001206 - init
//camp spots
campspot_t *campspots = NULL; // bk001206 - init
//the game type
int g_gametype = 0; // bk001206 - init
//additional dropped item weight
libvar_t *droppedweight = NULL; // bk001206 - init

//========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//========================================================================
bot_goalstate_t *BotGoalStateFromHandle(int handle)
{
    if (handle <= 0 || handle > MAX_CLIENTS)
    {
        botimport.Print(PRT_FATAL, "goal state handle %d out of range\n", handle);
        return NULL;
    } //end if
    if (!botgoalstates[handle])
    {
        botimport.Print(PRT_FATAL, "invalid goal state %d\n", handle);
        return NULL;
    } //end if
    return botgoalstates[handle];
} //end of the function BotGoalStateFromHandle
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void BotInterbreedGoalFuzzyLogic(int parent1, int parent2, int child)
{
    bot_goalstate_t *p1, *p2, *c;

    p1 = BotGoalStateFromHandle(parent1);
    p2 = BotGoalStateFromHandle(parent2);
    c = BotGoalStateFromHandle(child);

    InterbreedWeightConfigs(p1->itemweightconfig, p2->itemweightconfig,
                                    c->itemweightconfig);
} //end of the function BotInterbreedingGoalFuzzyLogic
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void BotSaveGoalFuzzyLogic(int goalstate, char *filename)
{
    bot_goalstate_t *gs;

    gs = BotGoalStateFromHandle(goalstate);

    //WriteWeightConfig(filename, gs->itemweightconfig);
} //end of the function BotSaveGoalFuzzyLogic
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void BotMutateGoalFuzzyLogic(int goalstate, float range)
{
    bot_goalstate_t *gs;

    gs = BotGoalStateFromHandle(goalstate);

    EvolveWeightConfig(gs->itemweightconfig);
} //end of the function BotMutateGoalFuzzyLogic
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
itemconfig_t *LoadItemConfig(char *filename)
{
    int max_iteminfo;
    token_t token;
    char path[MAX_PATH];
    source_t *source;
    itemconfig_t *ic;
    iteminfo_t *ii;

    max_iteminfo = (int) LibVarValue("max_iteminfo", "256");
    if (max_iteminfo < 0)
    {
        botimport.Print(PRT_ERROR, "max_iteminfo = %d\n", max_iteminfo);
        max_iteminfo = 256;
        LibVarSet( "max_iteminfo", "256" );
    }

    strncpy( path, filename, MAX_PATH );
    PC_SetBaseFolder(BOTFILESBASEFOLDER);
    source = LoadSourceFile( path );
    if( !source ) {
        botimport.Print( PRT_ERROR, "counldn't load %s\n", path );
        return NULL;
    } //end if
    //initialize item config
    ic = (itemconfig_t *) GetClearedHunkMemory(sizeof(itemconfig_t) +
                                                        max_iteminfo * sizeof(iteminfo_t));
    ic->iteminfo = (iteminfo_t *) ((char *) ic + sizeof(itemconfig_t));
    ic->numiteminfo = 0;
    //parse the item config file
    while(PC_ReadToken(source, &token))
    {
        if (!strcmp(token.string, "iteminfo"))
        {
            if (ic->numiteminfo >= max_iteminfo)
            {
                SourceError(source, "more than %d item info defined\n", max_iteminfo);
                FreeMemory(ic);
                FreeSource(source);
                return NULL;
            } //end if
            ii = &ic->iteminfo[ic->numiteminfo];
            Com_Memset(ii, 0, sizeof(iteminfo_t));
            if (!PC_ExpectTokenType(source, TT_STRING, 0, &token))
            {
                FreeMemory(ic);
                FreeMemory(source);
                return NULL;
            } //end if
            StripDoubleQuotes(token.string);
            strncpy(ii->classname, token.string, sizeof(ii->classname)-1);
            if (!ReadStructure(source, &iteminfo_struct, (char *) ii))
            {
                FreeMemory(ic);
                FreeSource(source);
                return NULL;
            } //end if
            ii->number = ic->numiteminfo;
            ic->numiteminfo++;
        } //end if
        else
        {
            SourceError(source, "unknown definition %s\n", token.string);
            FreeMemory(ic);
            FreeSource(source);
            return NULL;
        } //end else
    } //end while
    FreeSource(source);
    //
    if (!ic->numiteminfo) botimport.Print(PRT_WARNING, "no item info loaded\n");
    botimport.Print(PRT_MESSAGE, "loaded %s\n", path);
    return ic;
} //end of the function LoadItemConfig
//===========================================================================
// index to find the weight function of an iteminfo
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int *ItemWeightIndex(weightconfig_t *iwc, itemconfig_t *ic)
{
    int *index, i;

    //initialize item weight index
    index = (int *) GetClearedMemory(sizeof(int) * ic->numiteminfo);

    for (i = 0; i < ic->numiteminfo; i++)
    {
        index[i] = FindFuzzyWeight(iwc, ic->iteminfo[i].classname);
        if (index[i] < 0)
        {
            Log_Write("item info %d \"%s\" has no fuzzy weight\r\n", i, ic->iteminfo[i].classname);
        } //end if
    } //end for
    return index;
} //end of the function ItemWeightIndex
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void InitLevelItemHeap(void)
{
    int i, max_levelitems;

    if (levelitemheap) FreeMemory(levelitemheap);

    max_levelitems = (int) LibVarValue("max_levelitems", "256");
    levelitemheap = (levelitem_t *) GetClearedMemory(max_levelitems * sizeof(levelitem_t));

    for (i = 0; i < max_levelitems-1; i++)
    {
        levelitemheap[i].next = &levelitemheap[i + 1];
    } //end for
    levelitemheap[max_levelitems-1].next = NULL;
    //
    freelevelitems = levelitemheap;
} //end of the function InitLevelItemHeap
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
levelitem_t *AllocLevelItem(void)
{
    levelitem_t *li;

    li = freelevelitems;
    if (!li)
    {
        botimport.Print(PRT_FATAL, "out of level items\n");
        return NULL;
    } //end if
    //
    freelevelitems = freelevelitems->next;
    Com_Memset(li, 0, sizeof(levelitem_t));
    return li;
} //end of the function AllocLevelItem
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void FreeLevelItem(levelitem_t *li)
{
    li->next = freelevelitems;
    freelevelitems = li;
} //end of the function FreeLevelItem
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void AddLevelItemToList(levelitem_t *li)
{
    if (levelitems) levelitems->prev = li;
    li->prev = NULL;
    li->next = levelitems;
    levelitems = li;
} //end of the function AddLevelItemToList
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void RemoveLevelItemFromList(levelitem_t *li)
{
    if (li->prev) li->prev->next = li->next;
    else levelitems = li->next;
    if (li->next) li->next->prev = li->prev;
} //end of the function RemoveLevelItemFromList
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
void BotFreeInfoEntities(void)
{
    maplocation_t *ml, *nextml;
    campspot_t *cs, *nextcs;

    for (ml = maplocations; ml; ml = nextml)
    {
        nextml = ml->next;
        FreeMemory(ml);
    } //end for
    maplocations = NULL;
    for (cs = campspots; cs; cs = nextcs)
    {
        nextcs = cs->next;
        FreeMemory(cs);
    } //end for
    campspots = NULL;
} //end of the function BotFreeInfoEntities
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
void BotInitInfoEntities(void)
{
    char classname[MAX_EPAIRKEY];
    maplocation_t *ml;
    campspot_t *cs;
    int ent, numlocations, numcampspots;

    BotFreeInfoEntities();
    //
    numlocations = 0;
    numcampspots = 0;
    for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
    {
        if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;

        //map locations
        if (!strcmp(classname, "target_location"))
        {
            ml = (maplocation_t *) GetClearedMemory(sizeof(maplocation_t));
            AAS_VectorForBSPEpairKey(ent, "origin", ml->origin);
            AAS_ValueForBSPEpairKey(ent, "message", ml->name, sizeof(ml->name));
            ml->areanum = AAS_PointAreaNum(ml->origin);
            ml->next = maplocations;
            maplocations = ml;
            numlocations++;
        } //end if
        //camp spots
        else if (!strcmp(classname, "info_camp"))
        {
            cs = (campspot_t *) GetClearedMemory(sizeof(campspot_t));
            AAS_VectorForBSPEpairKey(ent, "origin", cs->origin);
            //cs->origin[2] += 16;
            AAS_ValueForBSPEpairKey(ent, "message", cs->name, sizeof(cs->name));
            AAS_FloatForBSPEpairKey(ent, "range", &cs->range);
            AAS_FloatForBSPEpairKey(ent, "weight", &cs->weight);
            AAS_FloatForBSPEpairKey(ent, "wait", &cs->wait);
            AAS_FloatForBSPEpairKey(ent, "random", &cs->random);
            cs->areanum = AAS_PointAreaNum(cs->origin);
            if (!cs->areanum)
            {
                botimport.Print(PRT_MESSAGE, "camp spot at %1.1f %1.1f %1.1f in solid\n", cs->origin[0], cs->origin[1], cs->origin[2]);
                FreeMemory(cs);
                continue;
            } //end if
            cs->next = campspots;
            campspots = cs;
            //AAS_DrawPermanentCross(cs->origin, 4, LINECOLOR_YELLOW);
            numcampspots++;
        } //end else if
    } //end for
    if (bot_developer)
    {
        botimport.Print(PRT_MESSAGE, "%d map locations\n", numlocations);
        botimport.Print(PRT_MESSAGE, "%d camp spots\n", numcampspots);
    } //end if
} //end of the function BotInitInfoEntities
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
void BotInitLevelItems(void)
{
    int i, spawnflags, value;
    char classname[MAX_EPAIRKEY];
    vec3_t origin, end;
    int ent, goalareanum;
    itemconfig_t *ic;
    levelitem_t *li;
    bsp_trace_t trace;

    //initialize the map locations and camp spots
    BotInitInfoEntities();

    //initialize the level item heap
    InitLevelItemHeap();
    levelitems = NULL;
    numlevelitems = 0;
    //
    ic = itemconfig;
    if (!ic) return;

    //if there's no AAS file loaded
    if (!AAS_Loaded()) return;

    //update the modelindexes of the item info
    for (i = 0; i < ic->numiteminfo; i++)
    {
        //ic->iteminfo[i].modelindex = AAS_IndexFromModel(ic->iteminfo[i].model);
        if (!ic->iteminfo[i].modelindex)
        {
            Log_Write("item %s has modelindex 0", ic->iteminfo[i].classname);
        } //end if
    } //end for

    for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
    {
        if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
        //
        spawnflags = 0;
        AAS_IntForBSPEpairKey(ent, "spawnflags", &spawnflags);
        //
        for (i = 0; i < ic->numiteminfo; i++)
        {
            if (!strcmp(classname, ic->iteminfo[i].classname)) break;
        } //end for
        if (i >= ic->numiteminfo)
        {
            Log_Write("entity %s unknown item\r\n", classname);
            continue;
        } //end if
        //get the origin of the item
        if (!AAS_VectorForBSPEpairKey(ent, "origin", origin))
        {
            botimport.Print(PRT_ERROR, "item %s without origin\n", classname);
            continue;
        } //end else
        //
        goalareanum = 0;
        //if it is a floating item
        if (spawnflags & 1)
        {
            //if the item is not floating in water
            if (!(AAS_PointContents(origin) & CONTENTS_WATER))
            {
                VectorCopy(origin, end);
                end[2] -= 32;
                trace = AAS_Trace(origin, ic->iteminfo[i].mins, ic->iteminfo[i].maxs, end, -1, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
                //if the item not near the ground
                if (trace.fraction >= 1)
                {
                    //if the item is not reachable from a jumppad
                    goalareanum = AAS_BestReachableFromJumpPadArea(origin, ic->iteminfo[i].mins, ic->iteminfo[i].maxs);
                    Log_Write("item %s reachable from jumppad area %d\r\n", ic->iteminfo[i].classname, goalareanum);
                    //botimport.Print(PRT_MESSAGE, "item %s reachable from jumppad area %d\r\n", ic->iteminfo[i].classname, goalareanum);
                    if (!goalareanum) continue;
                } //end if
            } //end if
        } //end if

        li = AllocLevelItem();
        if (!li) return;
        //
        li->number = ++numlevelitems;
        li->timeout = 0;
        li->entitynum = 0;
        //
        li->flags = 0;
        AAS_IntForBSPEpairKey(ent, "notfree", &value);
        if (value) li->flags |= IFL_NOTFREE;
        AAS_IntForBSPEpairKey(ent, "notteam", &value);
        if (value) li->flags |= IFL_NOTTEAM;
        AAS_IntForBSPEpairKey(ent, "notsingle", &value);
        if (value) li->flags |= IFL_NOTSINGLE;
        AAS_IntForBSPEpairKey(ent, "notbot", &value);
        if (value) li->flags |= IFL_NOTBOT;
        if (!strcmp(classname, "item_botroam"))
        {
            li->flags |= IFL_ROAM;
            AAS_FloatForBSPEpairKey(ent, "weight", &li->weight);
        } //end if
        //if not a stationary item
        if (!(spawnflags & 1))
        {
            if (!AAS_DropToFloor(origin, ic->iteminfo[i].mins, ic->iteminfo[i].maxs))
            {
                botimport.Print(PRT_MESSAGE, "%s in solid at (%1.1f %1.1f %1.1f)\n",
                                                classname, origin[0], origin[1], origin[2]);
            } //end if
        } //end if
        //item info of the level item
        li->iteminfo = i;
        //origin of the item
        VectorCopy(origin, li->origin);
        //
        if (goalareanum)
        {
            li->goalareanum = goalareanum;
            VectorCopy(origin, li->goalorigin);
        } //end if
        else
        {
            //get the item goal area and goal origin
            li->goalareanum = AAS_BestReachableArea(origin,
                            ic->iteminfo[i].mins, ic->iteminfo[i].maxs,
                            li->goalorigin);
            if (!li->goalareanum)
            {
                botimport.Print(PRT_MESSAGE, "%s not reachable for bots at (%1.1f %1.1f %1.1f)\n",
                                                classname, origin[0], origin[1], origin[2]);
            } //end if
        } //end else
        //
        AddLevelItemToList(li);
    } //end for
    botimport.Print(PRT_MESSAGE, "found %d level items\n", numlevelitems);
} //end of the function BotInitLevelItems
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void BotGoalName(int number, char *name, int size)
{
    levelitem_t *li;

    if (!itemconfig) return;
    //
    for (li = levelitems; li; li = li->next)
    {
        if (li->number == number)
        {
            strncpy(name, itemconfig->iteminfo[li->iteminfo].name, size-1);
            name[size-1] = '\0';
            return;
        } //end for
    } //end for
    strcpy(name, "");
    return;
} //end of the function BotGoalName
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void BotResetAvoidGoals(int goalstate)
{
    bot_goalstate_t *gs;

    gs = BotGoalStateFromHandle(goalstate);
    if (!gs) return;
    Com_Memset(gs->avoidgoals, 0, MAX_AVOIDGOALS * sizeof(int));
    Com_Memset(gs->avoidgoaltimes, 0, MAX_AVOIDGOALS * sizeof(float));
} //end of the function BotResetAvoidGoals
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void BotDumpAvoidGoals(int goalstate)
{
    int i;
    bot_goalstate_t *gs;
    char name[32];

    gs = BotGoalStateFromHandle(goalstate);
    if (!gs) return;
    for (i = 0; i < MAX_AVOIDGOALS; i++)
    {
        if (gs->avoidgoaltimes[i] >= AAS_Time())
        {
            BotGoalName(gs->avoidgoals[i], name, 32);
            Log_Write("avoid goal %s, number %d for %f seconds", name,
                gs->avoidgoals[i], gs->avoidgoaltimes[i] - AAS_Time());
        } //end if
    } //end for
} //end of the function BotDumpAvoidGoals
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void BotAddToAvoidGoals(bot_goalstate_t *gs, int number, float avoidtime)
{
    int i;

    for (i = 0; i < MAX_AVOIDGOALS; i++)
    {
        //if the avoid goal is already stored
        if (gs->avoidgoals[i] == number)
        {
            gs->avoidgoals[i] = number;
            gs->avoidgoaltimes[i] = AAS_Time() + avoidtime;
            return;
        } //end if
    } //end for

    for (i = 0; i < MAX_AVOIDGOALS; i++)
    {
        //if this avoid goal has expired
        if (gs->avoidgoaltimes[i] < AAS_Time())
        {
            gs->avoidgoals[i] = number;
            gs->avoidgoaltimes[i] = AAS_Time() + avoidtime;
            return;
        } //end if
    } //end for
} //end of the function BotAddToAvoidGoals
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
void BotRemoveFromAvoidGoals(int goalstate, int number)
{
    int i;
    bot_goalstate_t *gs;

    gs = BotGoalStateFromHandle(goalstate);
    if (!gs) return;
    //don't use the goals the bot wants to avoid
    for (i = 0; i < MAX_AVOIDGOALS; i++)
    {
        if (gs->avoidgoals[i] == number && gs->avoidgoaltimes[i] >= AAS_Time())
        {
            gs->avoidgoaltimes[i] = 0;
            return;
        } //end if
    } //end for
} //end of the function BotRemoveFromAvoidGoals
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
float BotAvoidGoalTime(int goalstate, int number)
{
    int i;
    bot_goalstate_t *gs;

    gs = BotGoalStateFromHandle(goalstate);
    if (!gs) return 0;
    //don't use the goals the bot wants to avoid
    for (i = 0; i < MAX_AVOIDGOALS; i++)
    {
        if (gs->avoidgoals[i] == number && gs->avoidgoaltimes[i] >= AAS_Time())
        {
            return gs->avoidgoaltimes[i] - AAS_Time();
        } //end if
    } //end for
    return 0;
} //end of the function BotAvoidGoalTime
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
void BotSetAvoidGoalTime(int goalstate, int number, float avoidtime)
{
    bot_goalstate_t *gs;
    levelitem_t *li;

    gs = BotGoalStateFromHandle(goalstate);
    if (!gs)
        return;
    if (avoidtime < 0)
    {
        if (!itemconfig)
            return;
        //
        for (li = levelitems; li; li = li->next)
        {
            if (li->number == number)
            {
                avoidtime = itemconfig->iteminfo[li->iteminfo].respawntime;
                if (!avoidtime)
                    avoidtime = AVOID_DEFAULT_TIME;
                if (avoidtime < AVOID_MINIMUM_TIME)
                    avoidtime = AVOID_MINIMUM_TIME;
                BotAddToAvoidGoals(gs, number, avoidtime);
                return;
            } //end for
        } //end for
        return;
    } //end if
    else
    {
        BotAddToAvoidGoals(gs, number, avoidtime);
    } //end else
} //end of the function BotSetAvoidGoalTime
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotGetLevelItemGoal(int index, char *name, bot_goal_t *goal)
{
    levelitem_t *li;

    if (!itemconfig) return -1;
    li = levelitems;
    if (index >= 0)
    {
        for (; li; li = li->next)
        {
            if (li->number == index)
            {
                li = li->next;
                break;
            } //end if
        } //end for
    } //end for
    for (; li; li = li->next)
    {
        //
        if (g_gametype == GT_SINGLE_PLAYER) {
            if (li->flags & IFL_NOTSINGLE) continue;
        }
        else if (g_gametype >= GT_TEAM) {
            if (li->flags & IFL_NOTTEAM) continue;
        }
        else {
            if (li->flags & IFL_NOTFREE) continue;
        }
        if (li->flags & IFL_NOTBOT) continue;
        //
        if (!Q_stricmp(name, itemconfig->iteminfo[li->iteminfo].name))
        {
            goal->areanum = li->goalareanum;
            VectorCopy(li->goalorigin, goal->origin);
            goal->entitynum = li->entitynum;
            VectorCopy(itemconfig->iteminfo[li->iteminfo].mins, goal->mins);
            VectorCopy(itemconfig->iteminfo[li->iteminfo].maxs, goal->maxs);
            goal->number = li->number;
            goal->flags = GFL_ITEM;
            if (li->timeout) goal->flags |= GFL_DROPPED;
            //botimport.Print(PRT_MESSAGE, "found li %s\n", itemconfig->iteminfo[li->iteminfo].name);
            return li->number;
        } //end if
    } //end for
    return -1;
} //end of the function BotGetLevelItemGoal
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotGetMapLocationGoal(char *name, bot_goal_t *goal)
{
    maplocation_t *ml;
    vec3_t mins = {-8, -8, -8}, maxs = {8, 8, 8};

    for (ml = maplocations; ml; ml = ml->next)
    {
        if (!Q_stricmp(ml->name, name))
        {
            goal->areanum = ml->areanum;
            VectorCopy(ml->origin, goal->origin);
            goal->entitynum = 0;
            VectorCopy(mins, goal->mins);
            VectorCopy(maxs, goal->maxs);
            return qtrue;
        } //end if
    } //end for
    return qfalse;
} //end of the function BotGetMapLocationGoal
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotGetNextCampSpotGoal(int num, bot_goal_t *goal)
{
    int i;
    campspot_t *cs;
    vec3_t mins = {-8, -8, -8}, maxs = {8, 8, 8};

    if (num < 0) num = 0;
    i = num;
    for (cs = campspots; cs; cs = cs->next)
    {
        if (--i < 0)
        {
            goal->areanum = cs->areanum;
            VectorCopy(cs->origin, goal->origin);
            goal->entitynum = 0;
            VectorCopy(mins, goal->mins);
            VectorCopy(maxs, goal->maxs);
            return num+1;
        } //end if
    } //end for
    return 0;
} //end of the function BotGetNextCampSpotGoal
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
void BotFindEntityForLevelItem(levelitem_t *li)
{
    int ent, modelindex;
    itemconfig_t *ic;
    aas_entityinfo_t entinfo;
    vec3_t dir;

    ic = itemconfig;
    if (!itemconfig) return;
    for (ent = AAS_NextEntity(0); ent; ent = AAS_NextEntity(ent))
    {
        //get the model index of the entity
        modelindex = AAS_EntityModelindex(ent);
        //
        if (!modelindex) continue;
        //get info about the entity
        AAS_EntityInfo(ent, &entinfo);
        //if the entity is still moving
        if (entinfo.origin[0] != entinfo.lastvisorigin[0] ||
                entinfo.origin[1] != entinfo.lastvisorigin[1] ||
                entinfo.origin[2] != entinfo.lastvisorigin[2]) continue;
        //
        if (ic->iteminfo[li->iteminfo].modelindex == modelindex)
        {
            //check if the entity is very close
            VectorSubtract(li->origin, entinfo.origin, dir);
            if (VectorLength(dir) < 30)
            {
                //found an entity for this level item
                li->entitynum = ent;
            } //end if
        } //end if
    } //end for
} //end of the function BotFindEntityForLevelItem
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================

//NOTE: enum entityType_t in bg_public.h
#define ET_ITEM         2

void BotUpdateEntityItems(void)
{
    int ent, i, modelindex;
    vec3_t dir;
    levelitem_t *li, *nextli;
    aas_entityinfo_t entinfo;
    itemconfig_t *ic;

    //timeout current entity items if necessary
    for (li = levelitems; li; li = nextli)
    {
        nextli = li->next;
        //if it is a item that will time out
        if (li->timeout)
        {
            //timeout the item
            if (li->timeout < AAS_Time())
            {
                RemoveLevelItemFromList(li);
                FreeLevelItem(li);
            } //end if
        } //end if
    } //end for
    //find new entity items
    ic = itemconfig;
    if (!itemconfig) return;
    //
    for (ent = AAS_NextEntity(0); ent; ent = AAS_NextEntity(ent))
    {
        if (AAS_EntityType(ent) != ET_ITEM) continue;
        //get the model index of the entity
        modelindex = AAS_EntityModelindex(ent);
        //
        if (!modelindex) continue;
        //get info about the entity
        AAS_EntityInfo(ent, &entinfo);
        //FIXME: don't do this
        //skip all floating items for now
        //if (entinfo.groundent != ENTITYNUM_WORLD) continue;
        //if the entity is still moving
        if (entinfo.origin[0] != entinfo.lastvisorigin[0] ||
                entinfo.origin[1] != entinfo.lastvisorigin[1] ||
                entinfo.origin[2] != entinfo.lastvisorigin[2]) continue;
        //check if the entity is already stored as a level item
        for (li = levelitems; li; li = li->next)
        {
            //if the level item is linked to an entity
            if (li->entitynum && li->entitynum == ent)
            {
                //the entity is re-used if the models are different
                if (ic->iteminfo[li->iteminfo].modelindex != modelindex)
                {
                    //remove this level item
                    RemoveLevelItemFromList(li);
                    FreeLevelItem(li);
                    li = NULL;
                    break;
                } //end if
                else
                {
                    if (entinfo.origin[0] != li->origin[0] ||
                        entinfo.origin[1] != li->origin[1] ||
                        entinfo.origin[2] != li->origin[2])
                    {
                        VectorCopy(entinfo.origin, li->origin);
                        //also update the goal area number
                        li->goalareanum = AAS_BestReachableArea(li->origin,
                                        ic->iteminfo[li->iteminfo].mins, ic->iteminfo[li->iteminfo].maxs,
                                        li->goalorigin);
                    } //end if
                    break;
                } //end else
            } //end if
        } //end for
        if (li) continue;
        //try to link the entity to a level item
        for (li = levelitems; li; li = li->next)
        {
            //if this level item is already linked
            if (li->entitynum) continue;
            //
            if (g_gametype == GT_SINGLE_PLAYER) {
                if (li->flags & IFL_NOTSINGLE) continue;
            }
            else if (g_gametype >= GT_TEAM) {
                if (li->flags & IFL_NOTTEAM) continue;
            }
            else {
                if (li->flags & IFL_NOTFREE) continue;
            }
            //if the model of the level item and the entity are the same
            if (ic->iteminfo[li->iteminfo].modelindex == modelindex)
            {
                //check if the entity is very close
                VectorSubtract(li->origin, entinfo.origin, dir);
                if (VectorLength(dir) < 30)
                {
                    //found an entity for this level item
                    li->entitynum = ent;
                    //if the origin is different
                    if (entinfo.origin[0] != li->origin[0] ||
                        entinfo.origin[1] != li->origin[1] ||
                        entinfo.origin[2] != li->origin[2])
                    {
                        //update the level item origin
                        VectorCopy(entinfo.origin, li->origin);
                        //also update the goal area number
                        li->goalareanum = AAS_BestReachableArea(li->origin,
                                        ic->iteminfo[li->iteminfo].mins, ic->iteminfo[li->iteminfo].maxs,
                                        li->goalorigin);
                    } //end if
#ifdef DEBUG
                    Log_Write("linked item %s to an entity", ic->iteminfo[li->iteminfo].classname);
#endif //DEBUG
                    break;
                } //end if
            } //end else
        } //end for
        if (li) continue;
        //check if the model is from a known item
        for (i = 0; i < ic->numiteminfo; i++)
        {
            if (ic->iteminfo[i].modelindex == modelindex)
            {
                break;
            } //end if
        } //end for
        //if the model is not from a known item
        if (i >= ic->numiteminfo) continue;
        //allocate a new level item
        li = AllocLevelItem();
        //
        if (!li) continue;
        //entity number of the level item
        li->entitynum = ent;
        //number for the level item
        li->number = numlevelitems + ent;
        //set the item info index for the level item
        li->iteminfo = i;
        //origin of the item
        VectorCopy(entinfo.origin, li->origin);
        //get the item goal area and goal origin
        li->goalareanum = AAS_BestReachableArea(li->origin,
                                    ic->iteminfo[i].mins, ic->iteminfo[i].maxs,
                                    li->goalorigin);
        //never go for items dropped into jumppads
        if (AAS_AreaJumpPad(li->goalareanum))
        {
            FreeLevelItem(li);
            continue;
        } //end if
        //time this item out after 30 seconds
        //dropped items disappear after 30 seconds
        li->timeout = AAS_Time() + 30;
        //add the level item to the list
        AddLevelItemToList(li);
        //botimport.Print(PRT_MESSAGE, "found new level item %s\n", ic->iteminfo[i].classname);
    } //end for
    /*
    for (li = levelitems; li; li = li->next)
    {
        if (!li->entitynum)
        {
            BotFindEntityForLevelItem(li);
        } //end if
    } //end for*/
} //end of the function BotUpdateEntityItems
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void BotDumpGoalStack(int goalstate)
{
    int i;
    bot_goalstate_t *gs;
    char name[32];

    gs = BotGoalStateFromHandle(goalstate);
    if (!gs) return;
    for (i = 1; i <= gs->goalstacktop; i++)
    {
        BotGoalName(gs->goalstack[i].number, name, 32);
        Log_Write("%d: %s", i, name);
    } //end for
} //end of the function BotDumpGoalStack
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void BotPushGoal(int goalstate, bot_goal_t *goal)
{
    bot_goalstate_t *gs;

    gs = BotGoalStateFromHandle(goal