aicode.cpp

Go to the documentation of this file.

/*
 * Copyright (C) Volition, Inc. 1999.  All rights reserved.
 *
 * All source code herein is the property of Volition, Inc. You may not sell 
 * or otherwise commercially exploit the source or things you created based on the 
 * source.
 *
*/



#include "ai/ai.h"
#include "ai/ai_profiles.h"
#include "ai/aibig.h"
#include "ai/aigoals.h"
#include "ai/aiinternal.h"
#include "asteroid/asteroid.h"
#include "autopilot/autopilot.h"
#include "cmeasure/cmeasure.h"
#include "debugconsole/console.h"
#include "freespace2/freespace.h"
#include "gamesequence/gamesequence.h"
#include "gamesnd/gamesnd.h"
#include "globalincs/linklist.h"
#include "hud/hud.h"
#include "hud/hudets.h"
#include "hud/hudlock.h"
#include "iff_defs/iff_defs.h"
#include "io/joy_ff.h"
#include "io/timer.h"
#include "localization/localize.h"
#include "math/fvi.h"
#include "math/staticrand.h"
#include "mission/missiongoals.h"
#include "mission/missionlog.h"
#include "mission/missionmessage.h"
#include "mission/missionparse.h"
#include "mission/missiontraining.h"
#include "model/model.h"
#include "network/multi.h"
#include "network/multimsgs.h"
#include "network/multiutil.h"
#include "object/deadobjectdock.h"
#include "object/objcollide.h"
#include "object/object.h"
#include "object/objectdock.h"
#include "object/objectshield.h"
#include "object/waypoint.h"
#include "parse/parselo.h"
#include "physics/physics.h"
#include "playerman/player.h"
#include "render/3d.h"
#include "ship/afterburner.h"
#include "ship/awacs.h"
#include "ship/ship.h"
#include "ship/shipfx.h"
#include "ship/shiphit.h"
#include "weapon/beam.h"
#include "weapon/flak.h"
#include "weapon/swarm.h"
#include "weapon/weapon.h"
#include <map>
#include <limits.h>


#ifdef _MSC_VER
#pragma optimize("", off)
#pragma auto_inline(off)
#endif

#define UNINITIALIZED_VALUE     -99999.9f

#define INSTRUCTOR_SHIP_NAME NOX("instructor")

#define AICODE_SMALL_MAGNITUDE  0.001f          // cosider a vector NULL if mag is less than this

#define NEXT_REARM_TIMESTAMP (60*1000)                  //      Ships will re-request rearm, typically, after this long.

#define CIRCLE_STRAFE_MAX_DIST 300.0f   //Maximum distance for circle strafe behavior.

// AIM_CHASE submode defines
// SM_STEALTH_FIND
#define SM_SF_AHEAD             0
#define SM_SF_BEHIND    1
#define SM_SF_BAIL              2

// SM_STEALTH_SWEEP
#define SM_SS_SET_GOAL  -1
#define SM_SS_BOX0              0
#define SM_SS_LR                        1
#define SM_SS_UL                        2
#define SM_SS_BOX1              3
#define SM_SS_UR                        4
#define SM_SS_LL                        5
#define SM_SS_BOX2              6
#define SM_SS_DONE              7

//XSTR:OFF

char *Mode_text[MAX_AI_BEHAVIORS] = {
        "CHASE",
        "EVADE",
        "GET_BEHIND",
        "CHASE_LONG",
        "SQUIGGLE",
        "GUARD",
        "AVOID",
        "WAYPOINTS",
        "DOCK",
        "NONE",
        "BIGSHIP",
        "PATH",
        "BE_REARMED",
        "SAFETY",
        "EV_WEAPON",
        "STRAFE",
        "PLAY_DEAD",
        "BAY_EMERGE",
        "BAY_DEPART",
        "SENTRYGUN",
        "WARP_OUT",
};

//      Submode text is only valid for CHASE mode.
char *Submode_text[] = {
"undefined",
"CONT_TURN",
"ATTACK   ",
"E_SQUIG  ",
"E_BRAKE  ",
"EVADE    ",
"SUP_ATTAK",
"AVOID    ",
"BEHIND   ",
"GET_AWAY ",
"E_WEAPON ",
"FLY_AWAY ",
"ATK_4EVER",
"STLTH_FND",
"STLTH_SWP",
"BIG_APPR",
"BIG_CIRC",
"BIG_PARL"
};

char *Strafe_submode_text[5] = {
"ATTACK",
"AVOID",
"RETREAT1",
"RETREAT2",
"POSITION"
};
//XSTR:ON

// few forward decs i needed - kazan
object * get_wing_leader(int wingnum);
int get_wing_index(object *objp, int wingnum);

control_info    AI_ci;

object *Pl_objp;
object *En_objp;

#define REARM_SOUND_DELAY               (3*F1_0)                //      Amount of time to delay rearm/repair after mode start
#define REARM_BREAKOFF_DELAY    (3*F1_0)                //      Amount of time to wait after fully rearmed to breakoff.

#define MIN_DIST_TO_WAYPOINT_GOAL       5.0f
#define MAX_GUARD_DIST                                  250.0f
#define BIG_GUARD_RADIUS                                500.0f

#define MAX_EVADE_TIME                  (15 * 1000)     //      Max time to evade a weapon.

// defines for repair ship stuff.
#define MAX_REPAIR_SPEED                        25.0f
#define MAX_UNDOCK_ABORT_SPEED  2.0f

// defines for EMP effect stuff
#define MAX_EMP_INACCURACY              50.0f

// defines for stealth
#define MAX_STEALTH_INACCURACY  50.0f           // at max view dist
#define STEALTH_MAX_VIEW_DIST   400             // dist at which 1) stealth no longer visible 2) firing inaccuracy is greatest
#define STEALTH_VIEW_CONE_DOT   0.707           // (half angle of 45 degrees)

ai_class *Ai_classes = NULL;
int     Ai_firing_enabled = 1;
int     Num_ai_classes;
int Num_alloced_ai_classes;

int     AI_FrameCount = 0;
int     AI_watch_object = 0; // Debugging, object to spew debug info for.
int     Mission_all_attack = 0;                                 //      !0 means all teams attack all teams.

//      Constant for flag,                              Name of flag,                           In flags or flags2
ai_flag_name Ai_flag_names[] = {
        {AIF_NO_DYNAMIC,                                "no-dynamic",                                   1,      },
        {AIF_FREE_AFTERBURNER_USE,              "free-afterburner-use",                 1,      },
};

const char *Skill_level_names(int level, int translate)
{
        const char *str = NULL;

        #if NUM_SKILL_LEVELS != 5
        #error Number of skill levels is wrong!
        #endif

        if(translate){
                switch( level ) {
                case 0:
                        str = XSTR("Very Easy", 469);
                        break;
                case 1:
                        str = XSTR("Easy", 470);
                        break;
                case 2:
                        str = XSTR("Medium", 471);
                        break;
                case 3:
                        str = XSTR("Hard", 472);
                        break;
                case 4:
                        str = XSTR("Insane", 473);
                        break;
                default:        
                        Int3();
                }
        } else {
                switch( level ) {
                case 0:
                        str = NOX("Very Easy");
                        break;
                case 1:
                        str = NOX("Easy");
                        break;
                case 2:
                        str = NOX("Medium");
                        break;
                case 3:
                        str = NOX("Hard");
                        break;
                case 4:
                        str = NOX("Insane");
                        break;
                default:        
                        Int3();
                }
        }

        return str;
}

#define DELAY_TARGET_TIME       (12*1000)               //      time in milliseconds until a ship can target a new enemy after an order.

pnode           Path_points[MAX_PATH_POINTS];
pnode           *Ppfp;                  //      Free pointer in path points.

float   AI_frametime;

char** Ai_class_names = NULL;

typedef struct {
        int team;
        int weapon_index;
        int max_fire_count;
        char    *shipname;
} huge_fire_info;

SCP_vector<huge_fire_info> Ai_huge_fire_info;

int Ai_last_arrive_path;        // index of ship_bay path used by last arrival from a fighter bay

// forward declarations
int     ai_return_path_num_from_dockbay(object *dockee_objp, int dockbay_index);
void create_model_exit_path(object *pl_objp, object *mobjp, int path_num, int count=1);
void copy_xlate_model_path_points(object *objp, model_path *mp, int dir, int count, int path_num, pnode *pnp, int randomize_pnt=-1);
void ai_cleanup_rearm_mode(object *objp);
void ai_cleanup_dock_mode_subjective(object *objp);
void ai_cleanup_dock_mode_objective(object *objp);

// The object that is declared to be the leader of the group formation for
// the "autopilot"
object *Autopilot_flight_leader = NULL;

void ai_set_rearm_status(int team, int time)
{
        Assert( time >= 0 );

        Iff_info[team].ai_rearm_timestamp = timestamp(time * 1000);
}

int ai_good_time_to_rearm(object *objp)
{
        int team;

        Assert(objp->type == OBJ_SHIP);
        team = Ships[objp->instance].team;
        
        return timestamp_valid(Iff_info[team].ai_rearm_timestamp);
}

void ai_good_secondary_time( int team, int weapon_index, int max_fire_count, char *shipname )
{
        Assert(shipname != NULL);
        int index;
        huge_fire_info new_info; 

        new_info.weapon_index = weapon_index;
        new_info.team = team;
        new_info.max_fire_count = max_fire_count;

        new_info.shipname = ai_get_goal_target_name( shipname, &index );

        Ai_huge_fire_info.push_back(new_info);
}

int is_preferred_weapon(int weapon_num, object *firer_objp, object *target_objp)
{
        int firer_team, target_signature;
        ship *firer_ship;
        SCP_vector<huge_fire_info>::iterator hfi;

        Assert( firer_objp->type == OBJ_SHIP );
        firer_ship = &Ships[firer_objp->instance];
        firer_team = firer_ship->team;

        // get target object's signature and try to find it in the list.
        target_signature = target_objp->signature;
        for (hfi = Ai_huge_fire_info.begin();hfi != Ai_huge_fire_info.end(); ++hfi ) {
                int ship_index, signature;

                if ( hfi->weapon_index == -1 )
                        continue;

                ship_index = ship_name_lookup( hfi->shipname );
                if ( ship_index == -1 )
                        continue;

                signature = Objects[Ships[ship_index].objnum].signature;

                // sigatures, weapon_index, and team must match
                if ( (signature == target_signature) && (hfi->weapon_index == weapon_num) && (hfi->team == firer_team) )
                        break;
        }

        // return -1 if not found
        if ( hfi == Ai_huge_fire_info.end() )
                return -1;

        // otherwise, we can return the max number of weapons we can fire against target_objps
        return hfi->max_fire_count;
}

void ai_init_secondary_info()
{
        Ai_huge_fire_info.clear();
}

void garbage_collect_path_points()
{
        int     i;
        int     pp_xlate[MAX_PATH_POINTS];
        object  *A;
        ship_obj        *so;

        //      Scan all objects and create Path_points xlate table.
        for (i=0; i<MAX_PATH_POINTS; i++)
                pp_xlate[i] = 0;

        //      in pp_xlate, mark all used Path_point records
        for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
                A = &Objects[so->objnum];
                ship    *shipp = &Ships[A->instance];
                if (shipp->ai_index != -1) {
                        ai_info *aip = &Ai_info[shipp->ai_index];

                        if ((aip->path_length > 0) && (aip->path_start > -1)) {

                                for (i=aip->path_start; i<aip->path_start + aip->path_length; i++) {
                                        Assert(pp_xlate[i] == 0);       //      If this is not 0, then two paths use this point!
                                        pp_xlate[i] = 1;
                                }
                        }
                }
        }

        //      Now, stuff xlate index in pp_xlate.  This is the number to translate any path_start
        //      or path_cur index to.
        int     xlt = 0;
        for (i=0; i<MAX_PATH_POINTS; i++) {
                int     t = pp_xlate[i];

                pp_xlate[i] = xlt;
                if (t != 0)
                        xlt++;
        }
        
        //      Update global Path_points free pointer.
        Ppfp = &Path_points[xlt];

        //      Now, using pp_xlate, fixup all aip->path_cur and aip->path_start indices
        for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
                A = &Objects[so->objnum];
                ship    *shipp = &Ships[A->instance];
                if (shipp->ai_index != -1) {
                        ai_info *aip = &Ai_info[shipp->ai_index];

                        if ((aip->path_length > 0) && (aip->path_start > -1)) {
                                Assert(aip->path_start < MAX_PATH_POINTS);
                                aip->path_start = pp_xlate[aip->path_start];

                                Assert((aip->path_cur >= 0) && (aip->path_cur < MAX_PATH_POINTS));
                                aip->path_cur = pp_xlate[aip->path_cur];
                        }
                }
        }

        //      Now, compress the buffer.
        for (i=0; i<MAX_PATH_POINTS; i++)
                if (i != pp_xlate[i])
                        Path_points[pp_xlate[i]] = Path_points[i];

}

int hash(unsigned int curval, int newval)
{
        int     addval = curval & 1;

        curval >>= 1;
        if (addval)
                curval |= 0x80000000;
        curval ^= newval;

        return curval;
}

int create_object_hash(object *objp)
{
        int     *ip;
        unsigned int    hashval = 0;
        int     i;

        ip = (int *) &objp->orient;

        for (i=0; i<9; i++) {
                hashval = hash(hashval, *ip);
                ip++;
        }

        ip = (int *) &objp->pos;

        for (i=0; i<3; i++) {
                hashval = hash(hashval, *ip);
                ip++;
        }

        return hashval;
}

void free_ai_stuff()
{
        if(Ai_classes != NULL)
                vm_free(Ai_classes);
        
        if(Ai_class_names != NULL)
                vm_free(Ai_class_names);
}

void init_ai_class(ai_class *aicp)
{
        int i;
        for (i = 0; i < NUM_SKILL_LEVELS; i++)
        {
                aicp->ai_cmeasure_fire_chance[i] = FLT_MIN;
                aicp->ai_in_range_time[i] = FLT_MIN;
                aicp->ai_link_ammo_levels_maybe[i] = FLT_MIN;
                aicp->ai_link_ammo_levels_always[i] = FLT_MIN;
                aicp->ai_primary_ammo_burst_mult[i] = FLT_MIN;
                aicp->ai_link_energy_levels_maybe[i] = FLT_MIN;
                aicp->ai_link_energy_levels_always[i] = FLT_MIN;
                aicp->ai_predict_position_delay[i] = INT_MIN;
                aicp->ai_shield_manage_delay[i] = FLT_MIN;
                aicp->ai_ship_fire_delay_scale_friendly[i] = FLT_MIN;
                aicp->ai_ship_fire_delay_scale_hostile[i] = FLT_MIN;
                aicp->ai_ship_fire_secondary_delay_scale_friendly[i] = FLT_MIN;
                aicp->ai_ship_fire_secondary_delay_scale_hostile[i] = FLT_MIN;
                aicp->ai_turn_time_scale[i] = FLT_MIN;
                aicp->ai_glide_attack_percent[i] = FLT_MIN;
                aicp->ai_circle_strafe_percent[i] = FLT_MIN;
                aicp->ai_glide_strafe_percent[i] = FLT_MIN;
                aicp->ai_random_sidethrust_percent[i] = FLT_MIN;
                aicp->ai_stalemate_time_thresh[i] = FLT_MIN;
                aicp->ai_stalemate_dist_thresh[i] = FLT_MIN;
                aicp->ai_chance_to_use_missiles_on_plr[i] = INT_MIN;
                aicp->ai_max_aim_update_delay[i] = FLT_MIN;
                aicp->ai_turret_max_aim_update_delay[i] = FLT_MIN;
        }
        aicp->ai_profile_flags = 0;
        aicp->ai_profile_flags_set = 0;
        aicp->ai_profile_flags2 = 0;
        aicp->ai_profile_flags2_set = 0;

        //AI Class autoscale overrides
        //INT_MIN and FLT_MIN represent the "not set" state
        for (i = 0; i < NUM_SKILL_LEVELS; i++)
        {
                aicp->ai_aburn_use_factor[i] = INT_MIN;
                aicp->ai_shockwave_evade_chance[i] = FLT_MIN;
                aicp->ai_get_away_chance[i] = FLT_MIN;
                aicp->ai_secondary_range_mult[i] = FLT_MIN;
        }
        aicp->ai_class_autoscale = true;        //Retail behavior is to do the stupid autoscaling
}

void set_aic_flag(ai_class *aicp, char *name, int flag, int type)
{
        int* flags = (type == AIP_FLAG) ? &(aicp->ai_profile_flags) : &(aicp->ai_profile_flags2);
        int* set = (type == AIP_FLAG) ? &(aicp->ai_profile_flags_set) : &(aicp->ai_profile_flags2_set);

        if (optional_string(name))
        {
                bool val;
                stuff_boolean(&val);

                if (val)
                        *flags |= flag;
                else
                        *flags &= ~flag;

                *set |= flag;
        }
        else
                *set &= ~flag;
}

void parse_ai_class()
{
        ai_class        *aicp = &Ai_classes[Num_ai_classes];

        init_ai_class(aicp);

        required_string("$Name:");
        stuff_string(aicp->name, F_NAME, NAME_LENGTH);

        Ai_class_names[Num_ai_classes] = aicp->name;

        required_string("$accuracy:");
        parse_float_list(aicp->ai_accuracy, NUM_SKILL_LEVELS);

        required_string("$evasion:");
        parse_float_list(aicp->ai_evasion, NUM_SKILL_LEVELS);

        required_string("$courage:");
        parse_float_list(aicp->ai_courage, NUM_SKILL_LEVELS);

        required_string("$patience:");
        parse_float_list(aicp->ai_patience, NUM_SKILL_LEVELS);

        if (optional_string("$Afterburner Use Factor:"))
                parse_int_list(aicp->ai_aburn_use_factor, NUM_SKILL_LEVELS);

        if (optional_string("$Shockwave Evade Chances Per Second:"))
                parse_float_list(aicp->ai_shockwave_evade_chance, NUM_SKILL_LEVELS);

        if (optional_string("$Get Away Chance:"))
                parse_float_list(aicp->ai_get_away_chance, NUM_SKILL_LEVELS);

        if (optional_string("$Secondary Range Multiplier:"))
                parse_float_list(aicp->ai_secondary_range_mult, NUM_SKILL_LEVELS);

        if (optional_string("$Autoscale by AI Class Index:"))
                stuff_boolean(&aicp->ai_class_autoscale);

        //Parse optional values for stuff imported from ai_profiles
        if (optional_string("$AI Countermeasure Firing Chance:"))
                parse_float_list(aicp->ai_cmeasure_fire_chance, NUM_SKILL_LEVELS);

        if (optional_string("$AI In Range Time:"))
                parse_float_list(aicp->ai_in_range_time, NUM_SKILL_LEVELS);

        if (optional_string("$AI Always Links Ammo Weapons:"))
                parse_float_list(aicp->ai_link_ammo_levels_always, NUM_SKILL_LEVELS);

        if (optional_string("$AI Maybe Links Ammo Weapons:"))
                parse_float_list(aicp->ai_link_ammo_levels_maybe, NUM_SKILL_LEVELS);

        if (optional_string("$Primary Ammo Burst Multiplier:"))
                parse_float_list(aicp->ai_primary_ammo_burst_mult, NUM_SKILL_LEVELS);

        if (optional_string("$AI Always Links Energy Weapons:"))
                parse_float_list(aicp->ai_link_energy_levels_always, NUM_SKILL_LEVELS);

        if (optional_string("$AI Maybe Links Energy Weapons:"))
                parse_float_list(aicp->ai_link_energy_levels_maybe, NUM_SKILL_LEVELS);

        // represented in fractions of F1_0
        if (optional_string("$Predict Position Delay:")) {
                int iLoop;
                float temp_list[NUM_SKILL_LEVELS];
                parse_float_list(temp_list, NUM_SKILL_LEVELS);
                for (iLoop = 0; iLoop < NUM_SKILL_LEVELS; iLoop++)
                        aicp->ai_predict_position_delay[iLoop] = fl2f(temp_list[iLoop]);
        }

        if (optional_string("$AI Shield Manage Delay:") || optional_string("$AI Shield Manage Delays:"))
                parse_float_list(aicp->ai_shield_manage_delay, NUM_SKILL_LEVELS);

        if (optional_string("$Friendly AI Fire Delay Scale:"))
                parse_float_list(aicp->ai_ship_fire_delay_scale_friendly, NUM_SKILL_LEVELS);

        if (optional_string("$Hostile AI Fire Delay Scale:"))
                parse_float_list(aicp->ai_ship_fire_delay_scale_hostile, NUM_SKILL_LEVELS);

        if (optional_string("$Friendly AI Secondary Fire Delay Scale:"))
                parse_float_list(aicp->ai_ship_fire_secondary_delay_scale_friendly, NUM_SKILL_LEVELS);

        if (optional_string("$Hostile AI Secondary Fire Delay Scale:"))
                parse_float_list(aicp->ai_ship_fire_secondary_delay_scale_hostile, NUM_SKILL_LEVELS);

        if (optional_string("$AI Turn Time Scale:"))
                parse_float_list(aicp->ai_turn_time_scale, NUM_SKILL_LEVELS);

        if (optional_string("$Glide Attack Percent:")) {
                parse_float_list(aicp->ai_glide_attack_percent, NUM_SKILL_LEVELS);
                for (int i = 0; i < NUM_SKILL_LEVELS; i++) {
                        if (aicp->ai_glide_attack_percent[i] < 0.0f || aicp->ai_glide_attack_percent[i] > 100.0f) {
                                aicp->ai_glide_attack_percent[i] = 0.0f;
                                Warning(LOCATION, "$Glide Attack Percent should be between 0 and 100.0 (read %f). Setting to 0.", aicp->ai_glide_attack_percent[i]);
                        }
                        aicp->ai_glide_attack_percent[i] /= 100.0;
                }

        }

        if (optional_string("$Circle Strafe Percent:")) {
                parse_float_list(aicp->ai_circle_strafe_percent, NUM_SKILL_LEVELS);
                for (int i = 0; i < NUM_SKILL_LEVELS; i++) {
                        if (aicp->ai_circle_strafe_percent[i] < 0.0f || aicp->ai_circle_strafe_percent[i] > 100.0f) {
                                aicp->ai_circle_strafe_percent[i] = 0.0f;
                                Warning(LOCATION, "$Circle Strafe Percent should be between 0 and 100.0 (read %f). Setting to 0.", aicp->ai_circle_strafe_percent[i]);
                        }
                        aicp->ai_circle_strafe_percent[i] /= 100.0;
                }
        }

        if (optional_string("$Glide Strafe Percent:")) {
                parse_float_list(aicp->ai_glide_strafe_percent, NUM_SKILL_LEVELS);
                for (int i = 0; i < NUM_SKILL_LEVELS; i++) {
                        if (aicp->ai_glide_strafe_percent[i] < 0.0f || aicp->ai_glide_strafe_percent[i] > 100.0f) {
                                aicp->ai_glide_strafe_percent[i] = 0.0f;
                                Warning(LOCATION, "$Glide Strafe Percent should be between 0 and 100.0 (read %f). Setting to 0.", aicp->ai_glide_strafe_percent[i]);
                        }
                        aicp->ai_glide_strafe_percent[i] /= 100.0;
                }
        }

        if (optional_string("$Random Sidethrust Percent:")) {
                parse_float_list(aicp->ai_random_sidethrust_percent, NUM_SKILL_LEVELS);
                for (int i = 0; i < NUM_SKILL_LEVELS; i++) {
                        if (aicp->ai_random_sidethrust_percent[i] < 0.0f || aicp->ai_random_sidethrust_percent[i] > 100.0f) {
                                aicp->ai_random_sidethrust_percent[i] = 0.0f;
                                Warning(LOCATION, "$Random Sidethrust Percent should be between 0 and 100.0 (read %f). Setting to 0.", aicp->ai_random_sidethrust_percent[i]);
                        }
                        aicp->ai_random_sidethrust_percent[i] /= 100.0;
                }
        }

        if (optional_string("$Stalemate Time Threshold:"))
                parse_float_list(aicp->ai_stalemate_time_thresh, NUM_SKILL_LEVELS);

        if (optional_string("$Stalemate Distance Threshold:"))
                parse_float_list(aicp->ai_stalemate_dist_thresh, NUM_SKILL_LEVELS);

        if (optional_string("$Chance AI Has to Fire Missiles at Player:"))
                parse_int_list(aicp->ai_chance_to_use_missiles_on_plr, NUM_SKILL_LEVELS);

        if (optional_string("$Max Aim Update Delay:"))
                parse_float_list(aicp->ai_max_aim_update_delay, NUM_SKILL_LEVELS);

        if (optional_string("$Turret Max Aim Update Delay:"))
                parse_float_list(aicp->ai_turret_max_aim_update_delay, NUM_SKILL_LEVELS);

        set_aic_flag(aicp, "$big ships can attack beam turrets on untargeted ships:", AIPF_BIG_SHIPS_CAN_ATTACK_BEAM_TURRETS_ON_UNTARGETED_SHIPS, AIP_FLAG);

        set_aic_flag(aicp, "$smart primary weapon selection:", AIPF_SMART_PRIMARY_WEAPON_SELECTION, AIP_FLAG);

        set_aic_flag(aicp, "$smart secondary weapon selection:", AIPF_SMART_SECONDARY_WEAPON_SELECTION, AIP_FLAG);

        set_aic_flag(aicp, "$smart shield management:", AIPF_SMART_SHIELD_MANAGEMENT, AIP_FLAG);

        set_aic_flag(aicp, "$smart afterburner management:", AIPF_SMART_AFTERBURNER_MANAGEMENT, AIP_FLAG);

        set_aic_flag(aicp, "$allow rapid secondary dumbfire:", AIPF_ALLOW_RAPID_SECONDARY_DUMBFIRE, AIP_FLAG);
        
        set_aic_flag(aicp, "$huge turret weapons ignore bombs:", AIPF_HUGE_TURRET_WEAPONS_IGNORE_BOMBS, AIP_FLAG);

        set_aic_flag(aicp, "$don't insert random turret fire delay:", AIPF_DONT_INSERT_RANDOM_TURRET_FIRE_DELAY, AIP_FLAG);

        set_aic_flag(aicp, "$prevent turrets targeting too distant bombs:", AIPF_PREVENT_TARGETING_BOMBS_BEYOND_RANGE, AIP_FLAG);

        set_aic_flag(aicp, "$smart subsystem targeting for turrets:", AIPF_SMART_SUBSYSTEM_TARGETING_FOR_TURRETS, AIP_FLAG);

        set_aic_flag(aicp, "$allow turrets target weapons freely:", AIPF_ALLOW_TURRETS_TARGET_WEAPONS_FREELY, AIP_FLAG);

        set_aic_flag(aicp, "$allow vertical dodge:", AIPF_ALLOW_VERTICAL_DODGE, AIP_FLAG);

        set_aic_flag(aicp, "$no extra collision avoidance vs player:", AIPF2_NO_SPECIAL_PLAYER_AVOID, AIP_FLAG2);

        set_aic_flag(aicp, "$all ships manage shields:", AIPF2_ALL_SHIPS_MANAGE_SHIELDS, AIP_FLAG2);
}

void reset_ai_class_names()
{
        ai_class *aicp;

        for (int i = 0; i < Num_ai_classes; i++) {
                aicp = &Ai_classes[i];

                Ai_class_names[i] = aicp->name;
        }
}

#define AI_CLASS_INCREMENT              10
void parse_aitbl()
{
        read_file_text("ai.tbl", CF_TYPE_TABLES);
        reset_parse();

        //Just in case parse_aitbl is called twice
        free_ai_stuff();
        
        Num_ai_classes = 0;
        Num_alloced_ai_classes = AI_CLASS_INCREMENT;
        Ai_classes = (ai_class*) vm_malloc(Num_alloced_ai_classes * sizeof(ai_class));
        Ai_class_names = (char**) vm_malloc(Num_alloced_ai_classes * sizeof(char*));
        
        required_string("#AI Classes");

        while (required_string_either("#End", "$Name:")) {

                parse_ai_class();

                Num_ai_classes++;

                if(Num_ai_classes >= Num_alloced_ai_classes)
                {
                        Num_alloced_ai_classes += AI_CLASS_INCREMENT;
                        Ai_classes = (ai_class*) vm_realloc(Ai_classes, Num_alloced_ai_classes * sizeof(ai_class));

                        // Ai_class_names doesn't realloc all that well so we have to do it the hard way.
                        // Luckily, it's contents can be easily replaced so we don't have to save anything.
                        vm_free(Ai_class_names);
                        Ai_class_names = (char **) vm_malloc(Num_alloced_ai_classes * sizeof(char*));
                        reset_ai_class_names();
                }
        }
        
        atexit(free_ai_stuff);
}

LOCAL int ai_inited = 0;

//========================= BOOK-KEEPING FUNCTIONS =======================

void ai_init()
{
        if ( !ai_inited )       {
                // Do the first time initialization stuff here          
                try
                {
                        parse_aitbl();
                }
                catch (const parse::ParseException& e)
                {
                        mprintf(("TABLES: Unable to parse '%s'!  Error message = %s.\n", "ai.tbl", e.what()));
                }

                ai_inited = 1;
        }

        init_semirand();
        
        ai_level_init();
}

void ai_level_init()
{
        int i;
 
        // Do the stuff to reset all ai stuff here
        for (i=0; i<MAX_AI_INFO ; i++) {
                Ai_info[i].shipnum = -1;
        }

        Ai_goal_signature = 0;

        for (i = 0; i < Num_iffs; i++)
                Iff_info[i].ai_rearm_timestamp = timestamp(-1);

        // clear out the stuff needed for AI firing powerful secondary weapons
        ai_init_secondary_info();

        Ai_last_arrive_path=0;
}

// BEGIN STEALTH
// -----------------------------------------------------------------------------

bool is_object_stealth_ship(object* objp)
{
        if (objp->type == OBJ_SHIP) {
                if (Ships[objp->instance].flags2 & SF2_STEALTH) {
                        return true;
                }
        }

        // not stealth ship
        return false;
}

void init_ai_stealth_info(ai_info *aip, object *stealth_objp)
{
        Assert(is_object_stealth_ship(stealth_objp));

        // set necessary ai info for new stealth target
        aip->stealth_last_pos = stealth_objp->pos;
        aip->stealth_velocity = stealth_objp->phys_info.vel;
        aip->stealth_last_visible_stamp = timestamp();
}

// -----------------------------------------------------------------------------
// Check whether Pl_objp can see a stealth ship object
#define STEALTH_NOT_IN_FRUSTUM                  0
#define STEALTH_IN_FRUSTUM                              1
#define STEALTH_FULLY_TARGETABLE        2

float get_skill_stealth_dist_scaler()
{
        switch (Game_skill_level) {
        case 0: // very easy
                return 0.65f;

        case 1: // easy
                return 0.9f;

        case 2: // medium
                return 1.0f;

        case 3: // hard
                return 1.1f;

        case 4: // insane
                return 1.3f;

        default:
                Int3();
        }

        return 1.0f;
}

float get_skill_stealth_dot_scaler()
{
        switch (Game_skill_level) {
        case 0: // very easy
                return 1.3f;

        case 1: // easy
                return 1.1f;

        case 2: // medium
                return 1.0f;

        case 3: // hard
                return 0.9f;

        case 4: // insane
                return 0.7f;

        default:
                Int3();
        }

        return 1.0f;
}

int ai_is_stealth_visible(object *viewer_objp, object *stealth_objp)
{
        ship *shipp;
        vec3d vec_to_stealth;
        float dot_to_stealth, dist_to_stealth, max_stealth_dist;

        Assert(stealth_objp->type == OBJ_SHIP);
        shipp = &Ships[stealth_objp->instance];
        Assert(viewer_objp->type == OBJ_SHIP);

        // check if stealth ship
        Assert(shipp->flags2 & SF2_STEALTH);

        // check if in neb and below awac level for visible
        if ( !ship_is_visible_by_team(stealth_objp, &Ships[viewer_objp->instance]) ) {
                vm_vec_sub(&vec_to_stealth, &stealth_objp->pos, &viewer_objp->pos);
                dist_to_stealth = vm_vec_mag_quick(&vec_to_stealth);
                dot_to_stealth = vm_vec_dot(&viewer_objp->orient.vec.fvec, &vec_to_stealth) / dist_to_stealth;

                // get max dist at which stealth is visible
                max_stealth_dist = get_skill_stealth_dist_scaler() * STEALTH_MAX_VIEW_DIST;

                // now check if within view frustum
                float needed_dot_to_stealth;
                if (dist_to_stealth < 100) {
                        needed_dot_to_stealth = 0.0f;
                } else {
                        needed_dot_to_stealth = get_skill_stealth_dot_scaler() * float(STEALTH_VIEW_CONE_DOT) * (dist_to_stealth / max_stealth_dist);
                }
                if (dot_to_stealth > needed_dot_to_stealth) {
                        if (dist_to_stealth < max_stealth_dist) {
                                return STEALTH_IN_FRUSTUM;
                        }
                }

                // not within frustum
                return STEALTH_NOT_IN_FRUSTUM;
        }

        // visible by awacs level
        return STEALTH_FULLY_TARGETABLE;
}

// END STEALTH

float compute_dots(object *objp, object *other_objp, float *to_dot, float *from_dot)
{
        vec3d   v2o;
        float           dist;

        dist = vm_vec_normalized_dir(&v2o, &other_objp->pos, &objp->pos);

        *to_dot = vm_vec_dot(&objp->orient.vec.fvec, &v2o);

        if (from_dot != NULL)
                *from_dot = - vm_vec_dot(&other_objp->orient.vec.fvec, &v2o);

        return dist;
}

void update_ai_stealth_info_with_error(ai_info *aip)
{
        object *stealth_objp;

        // make sure I am targeting a stealth ship
        Assert( is_object_stealth_ship(&Objects[aip->target_objnum]) );
        stealth_objp = &Objects[aip->target_objnum];

        // if update is due to weapon fire, get exact stealth position
        aip->stealth_last_pos = stealth_objp->pos;
        aip->stealth_velocity = stealth_objp->phys_info.vel;
        aip->stealth_last_visible_stamp = timestamp();
}

void ai_update_danger_weapon(int attacked_objnum, int weapon_objnum)
{
        object  *objp, *weapon_objp;
        ai_info *aip;
        float           old_dist, new_dist;
        float           old_dot, new_dot;
        object  *old_weapon_objp = NULL;

        if ((attacked_objnum == -1) || (weapon_objnum == -1)) {
                return;
        }

        objp = &Objects[attacked_objnum];

        // AL 2-24-98: If this isn't a ship, we don't need to worry about updating weapon_objnum (ie it would be
        //                                      an asteroid or bomb).
        if ( objp->type != OBJ_SHIP ) {
                return;
        }

        weapon_objp = &Objects[weapon_objnum];

        aip = &Ai_info[Ships[objp->instance].ai_index];

        // if my target is a stealth ship and is not visible
        if (aip->target_objnum >= 0) {
                if ( is_object_stealth_ship(&Objects[aip->target_objnum]) ) {
                        if ( ai_is_stealth_visible(objp, &Objects[aip->target_objnum]) == STEALTH_NOT_IN_FRUSTUM ) {
                                // and the weapon is coming from that stealth ship
                                if (weapon_objp->parent == aip->target_objnum) {
                                        // update my position estimate for stealth ship
                                        update_ai_stealth_info_with_error(aip);
                                }
                        }
                }
        }

        if (aip->danger_weapon_objnum != -1) {
                old_weapon_objp = &Objects[aip->danger_weapon_objnum];
                if ((old_weapon_objp->type == OBJ_WEAPON) && (old_weapon_objp->signature == aip->danger_weapon_signature)) {
                        ;
                } else {
                        aip->danger_weapon_objnum = -1;
                }
        }

        new_dist = compute_dots(weapon_objp, objp, &new_dot, NULL);

        if (aip->danger_weapon_objnum == -1) {
                if (new_dist < 1500.0f) {
                        if (new_dot > 0.5f) {
                                aip->danger_weapon_objnum = weapon_objnum;
                                aip->danger_weapon_signature = weapon_objp->signature;
                        }
                }
        } else {
                Assert(old_weapon_objp != NULL);
                old_dist = compute_dots(old_weapon_objp, objp, &old_dot, NULL);
        
                if (old_dot < 0.5f) {
                        aip->danger_weapon_objnum = -1;
                        old_dist = 9999.9f;
                }

                if ((new_dot > 0.5f) && (new_dot > old_dot-0.01f)) {
                        if (new_dist < old_dist) {
                                aip->danger_weapon_objnum = weapon_objnum;
                                aip->danger_weapon_signature = weapon_objp->signature;
                        }
                }
        }
}

//      If rvec != NULL, use it to match bank by calling vm_matrix_interpolate.
//      (rvec defaults to NULL)
void ai_turn_towards_vector(vec3d *dest, object *objp, float frametime, float turn_time, vec3d *slide_vec, vec3d *rel_pos, float bank_override, int flags, vec3d *rvec, int sexp_flags)
{
        matrix  curr_orient;
        vec3d   vel_in, vel_out, desired_fvec, src;
        float           delta_time;
        physics_info    *pip;
        vec3d   vel_limit, acc_limit;
        float           delta_bank;

        //      Don't allow a ship to turn if it has no engine strength.
        // AL 3-12-98: objp may not always be a ship!
        if ( (objp->type == OBJ_SHIP) && !(sexp_flags & AITTV_VIA_SEXP) ) {
                if (ship_get_subsystem_strength(&Ships[objp->instance], SUBSYSTEM_ENGINE) <= 0.0f)
                        return;
        }

        pip = &objp->phys_info;

        vel_in = pip->rotvel;
        curr_orient = objp->orient;
        delta_time = flFrametime;

        if(turn_time > 0.0f)
        {
                //      Scale turn_time based on skill level and team.
                if (!(flags & AITTV_FAST) && !(sexp_flags & AITTV_VIA_SEXP) ){
                        if (objp->type == OBJ_SHIP){
                                if (iff_x_attacks_y(Player_ship->team, Ships[objp->instance].team)) {
                                        turn_time *= Ai_info[Ships[objp->instance].ai_index].ai_turn_time_scale;
                                }
                        }
                }

                //      Set max turn rate.
                vel_limit.xyz.x = PI2/turn_time;
                vel_limit.xyz.y = PI2/turn_time;
                vel_limit.xyz.z = PI2/turn_time;
        }
        else
        {
                vm_vec_zero(&vel_limit);
        }

        //      Set rate at which ship can accelerate to its rotational velocity.
        //      For now, weapons just go much faster.
        acc_limit = vel_limit;
        if (objp->type == OBJ_WEAPON)
                vm_vec_scale(&acc_limit, 8.0f);

        src = objp->pos;

        if (rel_pos != NULL) {
                vec3d   gun_point;
                vm_vec_unrotate(&gun_point, rel_pos, &objp->orient);
                vm_vec_add2(&src, &gun_point);
        }

        vm_vec_normalized_dir(&desired_fvec, dest, &src);

        //      Since ship isn't necessarily moving in the direction it's pointing, sometimes it's better
        //      to be moving towards goal rather than just pointing.  So, if slide_vec is !NULL, try to
        //      make ship move towards goal, not point at goal.
        if (slide_vec != NULL) {
                vm_vec_add2(&desired_fvec, slide_vec);
                vm_vec_normalize(&desired_fvec);
        }

        //      Should be more general case here.  Currently, anything that is not a weapon will bank when it turns.
        // Goober5000 - don't bank if sexp says not to
        if ( (objp->type == OBJ_WEAPON) || (sexp_flags & AITTV_IGNORE_BANK ) )
                delta_bank = 0.0f;
        else if ((bank_override) && (iff_x_attacks_y(Ships[objp->instance].team, Player_ship->team))) { //      Theoretically, this will only happen for Shivans.
                delta_bank = bank_override;
        } else {
                delta_bank = vm_vec_dot(&curr_orient.vec.rvec, &objp->last_orient.vec.rvec);
                delta_bank = 100.0f * (1.0f - delta_bank);
                if (vm_vec_dot(&objp->last_orient.vec.fvec, &objp->orient.vec.rvec) < 0.0f)
                        delta_bank = -delta_bank;
        }

        //      Dave Andsager: The non-indented lines here are debug code to help you track down the problem in the physics
        //      that is causing ships to inexplicably rotate very far.  If you hit the Int3(), set the next statement to be
        //      the one marked "HERE".  (Do this clicking the cursor there, then right clicking.  Choose the right option.)
        //      This will allow you to rerun vm_forward_interpolate() with the values that caused the error.
        //      Note, you'll need to enable the Int3() about ten lines below.
#ifndef NDEBUG
vec3d tvec = objp->orient.vec.fvec;
vec3d   vel_in_copy;
matrix  objp_orient_copy;

vel_in_copy = vel_in;
objp_orient_copy = objp->orient;

vel_in = vel_in_copy;   //      HERE //-V587
objp->orient = objp_orient_copy; //-V587
#endif
        
        if (rvec != NULL) {
                matrix  out_orient, goal_orient;

                vm_vector_2_matrix(&goal_orient, &desired_fvec, NULL, rvec);
                vm_matrix_interpolate(&goal_orient, &curr_orient, &vel_in, delta_time, &out_orient, &vel_out, &vel_limit, &acc_limit);
                objp->orient = out_orient;
        } else {
                vm_forward_interpolate(&desired_fvec, &curr_orient, &vel_in, delta_time, delta_bank, &objp->orient, &vel_out, &vel_limit, &acc_limit);
        }
        
#ifndef NDEBUG
if (!((objp->type == OBJ_WEAPON) && (Weapon_info[Weapons[objp->instance].weapon_info_index].subtype == WP_MISSILE))) {
        Assertion(!(delta_time < 0.25f && vm_vec_dot(&objp->orient.vec.fvec, &tvec) < 0.1f), "A ship rotated too far. Offending vessel is %s, please investigate.\n", Ships[objp->instance].ship_name);
}
#endif

        pip->rotvel = vel_out;
}

//      Set aip->target_objnum to objnum
//      Update aip->previous_target_objnum.
//      If new target (objnum) is different than old target, reset target_time.
int set_target_objnum(ai_info *aip, int objnum)
{
        if ((aip != Player_ai) && (!timestamp_elapsed(aip->ok_to_target_timestamp))) {
                return aip->target_objnum;
        }

        if (aip->target_objnum == objnum) {
                aip->previous_target_objnum = aip->target_objnum;
        } else {
                aip->previous_target_objnum = aip->target_objnum;

                // ignore this assert if a multiplayer observer
                if((Game_mode & GM_MULTIPLAYER) && (aip == Player_ai) && (Player_obj->type == OBJ_OBSERVER)){
                } else {
                        Assert(objnum != Ships[aip->shipnum].objnum);   //      make sure not targeting self
                }

                // if stealth target, init ai_info for stealth
                if ( (objnum >= 0) && is_object_stealth_ship(&Objects[objnum]) ) {
                        init_ai_stealth_info(aip, &Objects[objnum]);
                }

                aip->target_objnum = objnum;
                aip->target_time = 0.0f;
                aip->time_enemy_near = 0.0f;                            //SUSHI: Reset the "time near" counter whenever the target is changed
                aip->last_hit_target_time = Missiontime;        //Also, the "last hit target" time should be reset when the target changes
                aip->target_signature = (objnum >= 0) ? Objects[objnum].signature : -1;
                // clear targeted subsystem
                set_targeted_subsys(aip, NULL, -1);
        }
        
        return aip->target_objnum;
}

int ai_select_primary_weapon(object *objp, object *other_objp, int flags);

ship_subsys *set_targeted_subsys(ai_info *aip, ship_subsys *new_subsys, int parent_objnum)
{
        Assert(aip != NULL);

        aip->last_subsys_target = aip->targeted_subsys;
        aip->targeted_subsys = new_subsys;
        aip->targeted_subsys_parent = parent_objnum;

        if ( new_subsys ) {
                // Make new_subsys target
                if (new_subsys->system_info->type == SUBSYSTEM_ENGINE) {
                        if ( aip != Player_ai ) {
                                Assert( aip->shipnum >= 0 );
                                ai_select_primary_weapon(&Objects[Ships[aip->shipnum].objnum], &Objects[parent_objnum], WIF_PUNCTURE);
                                ship_primary_changed(&Ships[aip->shipnum]);     // AL: maybe send multiplayer information when AI ship changes primaries
                        }
                }

                if ( aip == Player_ai ) {
                        hud_lock_reset(0.5f);
                }

        } else {
                // Cleanup any subsys path information if it exists
                ai_big_subsys_path_cleanup(aip);
        }
        
        return aip->targeted_subsys;
}                                                                                         

void ai_object_init(object * obj, int ai_index)
{
        ai_info *aip;
        Assert(ai_index >= 0 && ai_index < MAX_AI_INFO);

        aip = &Ai_info[ai_index];

        aip->type = 0;          //      0 means not in use.
        aip->wing = -1;         //      Member of what wing? -1 means none.
        aip->ai_class = Ship_info[Ships[obj->instance].ship_info_index].ai_class;
        aip->behavior = AIM_NONE;
}

void adjust_accel_for_docking(ai_info *aip)
{
        object *objp = &Objects[Ships[aip->shipnum].objnum];

        if (object_is_docked(objp))
        {
                float ratio = objp->phys_info.mass / dock_calc_total_docked_mass(objp);

                // put cap on how much ship can slow down
                if ( (ratio < 0.8f) && !(The_mission.ai_profile->flags & AIPF_NO_MIN_DOCK_SPEED_CAP) ) {
                        ratio = 0.8f;
                }

                // make sure we at least some velocity
                if (ratio < 0.1f) {
                        ratio = 0.1f;
                }

                if (AI_ci.forward > ratio) {
                        AI_ci.forward = ratio;
                }
        }
}

void accelerate_ship(ai_info *aip, float accel)
{
        aip->prev_accel = accel;
        AI_ci.forward = accel;
        adjust_accel_for_docking(aip);
}

void change_acceleration(ai_info *aip, float delta_accel)
{
        float   new_accel;

        if (delta_accel < 0.0f) {
                if (aip->prev_accel > 0.0f)
                        aip->prev_accel = 0.0f;
        } else if (aip->prev_accel < 0.0f)
                aip->prev_accel = 0.0f;

        new_accel = aip->prev_accel + delta_accel * flFrametime;

        if (new_accel > 1.0f)
                new_accel = 1.0f;
        else if (new_accel < -1.0f)
                new_accel = -1.0f;
        
        aip->prev_accel = new_accel;

        AI_ci.forward = new_accel;
        adjust_accel_for_docking(aip);
}

void set_accel_for_target_speed(object *objp, float tspeed)
{
        float   max_speed;
        ai_info *aip;

        aip = &Ai_info[Ships[objp->instance].ai_index];

        max_speed = Ships[objp->instance].current_max_speed;

        if (max_speed > 0.0f) {
                AI_ci.forward = tspeed/max_speed;
        } else {
                AI_ci.forward = 0.0f;
        }

        aip->prev_accel = AI_ci.forward;

        adjust_accel_for_docking(aip);
}

void project_point_to_perimeter(vec3d *perim_point, vec3d *pos, float radius, vec3d *vp)
{
        vec3d   v1;
        float           mag;

        vm_vec_sub(&v1, vp, pos);
        mag = vm_vec_mag(&v1);

        if (mag == 0.0f) {
                Warning(LOCATION, "projectable point is at center of sphere.");
                vm_vec_make(&v1, 0.0f, radius, 0.0f);
        } else {
                vm_vec_normalize(&v1);
                vm_vec_scale(&v1, 1.1f * radius + 10.0f);
        }

        vm_vec_add2(&v1, pos);
        *perim_point = v1;
}

void get_tangent_point(vec3d *tan1, vec3d *p0, vec3d *centerp, vec3d *p1, float radius)
{
        vec3d   dest_vec, v2c, perp_vec, temp_vec, v2;
        float           dist, ratio;

        //      Detect condition of point inside sphere.
        if (vm_vec_dist(p0, centerp) < radius)
                project_point_to_perimeter(tan1, centerp, radius, p0);
        else {
                vm_vec_normalized_dir(&v2c, centerp, p0);

                //      Compute perpendicular vector using p0, centerp, p1
                vm_vec_normal(&temp_vec, p0, centerp, p1);
                vm_vec_sub(&v2, centerp, p0);
                vm_vec_cross(&perp_vec, &temp_vec, &v2);

                vm_vec_normalize(&perp_vec);

                dist = vm_vec_dist_quick(p0, centerp);
                ratio = dist / radius;

                if (ratio < 2.0f)
                        vm_vec_scale_add(&dest_vec, &perp_vec, &v2c, ratio-1.0f);
                else
                        vm_vec_scale_add(&dest_vec, &v2c, &perp_vec, (1.0f + 1.0f/ratio));

                vm_vec_scale_add(tan1, p0, &dest_vec, dist + radius);
        }
}

void turn_towards_point(object *objp, vec3d *point, vec3d *slide_vec, float bank_override)
{
        ai_info *aip;
        aip = &Ai_info[Ships[Pl_objp->instance].ai_index];
        
        // check if in formation and if not leader, don't change rotvel.z (bank to match leader elsewhere)
        if (aip->ai_flags & AIF_FORMATION) {
                if (&Objects[aip->goal_objnum] != objp) {
                        float rotvel_z = objp->phys_info.rotvel.xyz.z;
                        ai_turn_towards_vector(point, objp, flFrametime, Ship_info[Ships[objp->instance].ship_info_index].srotation_time, slide_vec, NULL, bank_override, 0);
                        objp->phys_info.rotvel.xyz.z = rotvel_z;
                }
        } else {
                // normal turn
                ai_turn_towards_vector(point, objp, flFrametime, Ship_info[Ships[objp->instance].ship_info_index].srotation_time, slide_vec, NULL, bank_override, 0);
        }
}

void turn_away_from_point(object *objp, vec3d *point, float bank_override)
{
        vec3d   opposite_point;

        vm_vec_sub(&opposite_point, &objp->pos, point);
        vm_vec_add2(&opposite_point, &objp->pos);

        ai_turn_towards_vector(&opposite_point, objp, flFrametime, Ship_info[Ships[objp->instance].ship_info_index].srotation_time, NULL, NULL, bank_override, AITTV_FAST);
}


//      --------------------------------------------------------------------------
//      Given an object and a point, turn tangent to the point, resulting in
// a circling behavior.
//      Make object *objp turn around the point *point with a radius of radius.
//      Note that this isn't the same as following a circle of radius radius with
//      center *point, but it should be adequate.
//      Note that if you want to circle an object without hitting it, you should use
//      about twice that object's radius for radius, else you'll certainly bump into it.
//      Return dot product to goal point.
float turn_towards_tangent(object *objp, vec3d *point, float radius)
{
        vec3d   vec_to_point;
        vec3d   goal_point;
        vec3d   perp_point;                             //      point radius away from *point on vector to objp->pos
        vec3d   up_vec, perp_vec;
        vec3d   v2g;

        vm_vec_normalized_dir(&vec_to_point, point, &objp->pos);
        vm_vec_cross(&up_vec, &vec_to_point, &objp->orient.vec.fvec);
        vm_vec_cross(&perp_vec, &vec_to_point, &up_vec);

        vm_vec_scale_add(&perp_point, point, &vec_to_point, -radius);
        if (vm_vec_dot(&objp->orient.vec.fvec, &perp_vec) > 0.0f) {
                vm_vec_scale_add(&goal_point, &perp_point, &perp_vec, radius);
        } else {
                vm_vec_scale_add(&goal_point, &perp_point, &perp_vec, -radius);
        }

        turn_towards_point(objp, &goal_point, NULL, 0.0f);

        vm_vec_normalized_dir(&v2g, &goal_point, &objp->pos);
        return vm_vec_dot(&objp->orient.vec.fvec, &v2g);
}

float turn_toward_tangent_with_axis(object *objp, object *center_objp, float radius)
{
        vec3d r_vec, theta_vec;
        vec3d center_vec, vec_on_cylinder, sph_r_vec;
        float center_obj_z;

        // find closest z of center objp
        vm_vec_sub(&sph_r_vec, &objp->pos, &center_objp->pos);
        center_obj_z = vm_vec_dot(&sph_r_vec, &center_objp->orient.vec.fvec);

        // find pt on axis with closest z
        vm_vec_scale_add(&center_vec, &center_objp->pos, &center_objp->orient.vec.fvec, center_obj_z);

        // get r_vec
        vm_vec_sub(&r_vec, &objp->pos, &center_vec);

        Assert( (vm_vec_dot(&r_vec, &center_objp->orient.vec.fvec) < 0.0001));

        // get theta vec - perp to r_vec and z_vec
        vm_vec_cross(&theta_vec, &center_objp->orient.vec.fvec, &r_vec);

#ifndef NDEBUG
        float mag;
        mag = vm_vec_normalize(&theta_vec);
        Assert(mag > 0.9999 && mag < 1.0001);
#endif

        vec3d temp;
        vm_vec_cross(&temp, &r_vec, &theta_vec);

#ifndef NDEBUG
        float dot;
        dot = vm_vec_dot(&temp, &center_objp->orient.vec.fvec);
        Assert( dot >0.9999 && dot < 1.0001);
#endif

        // find pt on clylinder with closest z
        vm_vec_scale_add(&vec_on_cylinder, &center_vec, &r_vec, radius);

        vec3d goal_pt, v2g;
        vm_vec_scale_add(&goal_pt, &vec_on_cylinder, &theta_vec, radius);

        turn_towards_point(objp, &goal_pt, NULL, 0.0f);

        vm_vec_normalized_dir(&v2g, &goal_pt, &objp->pos);
        return vm_vec_dot(&objp->orient.vec.fvec, &v2g);
}

void get_tangent_point(vec3d *goal_point, object *objp, vec3d *point, float radius)
{
        vec3d   vec_to_point;
        vec3d   perp_point;                             //      point radius away from *point on vector to objp->pos
        vec3d   up_vec, perp_vec;

        vm_vec_normalized_dir(&vec_to_point, point, &objp->pos);
        vm_vec_cross(&up_vec, &vec_to_point, &objp->orient.vec.fvec);
        
        while (IS_VEC_NULL(&up_vec)) {
                vec3d   rnd_vec;

                vm_vec_rand_vec_quick(&rnd_vec);
                vm_vec_add2(&rnd_vec, &objp->orient.vec.fvec);
                vm_vec_cross(&up_vec, &vec_to_point, &rnd_vec);
        }

        vm_vec_cross(&perp_vec, &vec_to_point, &up_vec);
        vm_vec_normalize(&perp_vec);

        vm_vec_scale_add(&perp_point, point, &vec_to_point, -radius);

        if (vm_vec_dot(&objp->orient.vec.fvec, &perp_vec) > 0.0f) {
                vm_vec_scale_add(goal_point, &perp_point, &perp_vec, radius);
        } else {
                vm_vec_scale_add(goal_point, &perp_point, &perp_vec, -radius);
        }
}

int     Player_attacking_enabled = 1;

int object_is_targetable(object *target, ship *viewer)
{
        // if target is ship, check if visible by team
        if (target->type == OBJ_SHIP)
        {
                if (ship_is_visible_by_team(target, viewer)) {
                        return 1;
                }

                // for AI partially targetable works as fully targetable, except for stealth ship
                if (Ships[target->instance].flags2 & SF2_STEALTH) {
                        // if not team targetable, check if within frustum
                        if ( ai_is_stealth_visible(&Objects[viewer->objnum], target) == STEALTH_IN_FRUSTUM ) {
                                return 1;
                        } else {
                                return 0;
                        }
                }
        }

        // if not fully targetable by team, check awacs level with viewer
        // allow targeting even if only only partially targetable to player
        float radar_return = awacs_get_level(target, viewer);
        if ( radar_return > 0.4 ) {
                return 1;
        } else {
                return 0;
        }
}

int num_enemies_attacking(int objnum)
{
        object          *objp;
        ship                    *sp;
        ship_subsys     *ssp;
        ship_obj                *so;
        int                     count;

        count = 0;

        for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
                objp = &Objects[so->objnum];
                Assert(objp->instance != -1);
                sp = &Ships[objp->instance];

                if (Ai_info[sp->ai_index].target_objnum == objnum)
                        count++;

                // consider turrets that may be attacking objnum (but only turrets on SIF_BIG_SHIP ships)
                if ( Ship_info[sp->ship_info_index].flags & SIF_BIG_SHIP ) {

                        // loop through all the subsystems, check if turret has objnum as a target
                        ssp = GET_FIRST(&sp->subsys_list);
                        while ( ssp != END_OF_LIST( &sp->subsys_list ) ) {

                                if ( ssp->system_info->type == SUBSYSTEM_TURRET ) {
                                        if ( (ssp->turret_enemy_objnum == objnum) && (ssp->current_hits > 0) ) {
                                                count++;
                                        }
                                }
                                ssp = GET_NEXT( ssp );
                        } // end while
                }
        }

        return count;
}

float get_wing_lowest_max_speed(object *objp)
{
        ship            *shipp;
        ai_info *aip;
        float           lowest_max_speed;
        int             wingnum;
        object  *o;
        ship_obj        *so;

        Assert(objp->type == OBJ_SHIP);
        Assert((objp->instance >= 0) && (objp->instance < MAX_OBJECTS));
        shipp = &Ships[objp->instance];
        Assert((shipp->ai_index >= 0) && (shipp->ai_index < MAX_AI_INFO));
        aip = &Ai_info[shipp->ai_index];

        wingnum = aip->wing;

        lowest_max_speed = shipp->current_max_speed;

        if ( wingnum == -1 )
                return lowest_max_speed;

        Assert(wingnum >= 0);

        for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
                o = &Objects[so->objnum];
                ship    *oshipp = &Ships[o->instance];
                ai_info *oaip = &Ai_info[oshipp->ai_index];

                if ((oaip->mode == AIM_WAYPOINTS) && (oaip->wing == wingnum)) {
                        //      Note: If a ship in the wing has a super low max speed, probably its engines are disabled.  So, fly along and
                        //      ignore the poor guy.
                        float   cur_max = oshipp->current_max_speed;

                        if (object_is_docked(o)) {
                                cur_max *= o->phys_info.mass / dock_calc_total_docked_mass(o);
                        }
                                                        
                        if ((oshipp->current_max_speed > 5.0f) && (cur_max < lowest_max_speed)) {
                                lowest_max_speed = cur_max;
                        }
                }
        }

        return lowest_max_speed;
}

float get_wing_lowest_av_ab_speed(object *objp)
{
        ship            *shipp;
        ai_info *aip;
        float           lowest_max_av_ab_speed;
        float recharge_scale;
        int             wingnum;
        object  *o;
        ship_obj        *so;
        ship_info *sip;

        Assert(objp->type == OBJ_SHIP);
        Assert((objp->instance >= 0) && (objp->instance < MAX_OBJECTS));
        shipp = &Ships[objp->instance];
        Assert((shipp->ai_index >= 0) && (shipp->ai_index < MAX_AI_INFO));
        aip = &Ai_info[shipp->ai_index];
        sip = &Ship_info[shipp->ship_info_index];

        wingnum = aip->wing;

        if (((shipp->flags2 & SF2_AFTERBURNER_LOCKED) || !(sip->flags & SIF_AFTERBURNER)) || (shipp->current_max_speed < 5.0f) || (objp->phys_info.afterburner_max_vel.xyz.z <= shipp->current_max_speed) || !(aip->ai_flags & AIF_FREE_AFTERBURNER_USE))       {
                lowest_max_av_ab_speed = shipp->current_max_speed;
        }
        else
        {
                recharge_scale = Energy_levels[shipp->engine_recharge_index] * 2.0f * The_mission.ai_profile->afterburner_recharge_scale[Game_skill_level];
                recharge_scale = sip->afterburner_recover_rate * recharge_scale / (sip->afterburner_burn_rate + sip->afterburner_recover_rate * recharge_scale);
                lowest_max_av_ab_speed = recharge_scale * (objp->phys_info.afterburner_max_vel.xyz.z - shipp->current_max_speed) + shipp->current_max_speed;
        }
        

        if ( wingnum == -1 )
                return lowest_max_av_ab_speed;

        Assert(wingnum >= 0);

        for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
                o = &Objects[so->objnum];
                ship    *oshipp = &Ships[o->instance];
                ai_info *oaip = &Ai_info[oshipp->ai_index];
                ship_info *osip = &Ship_info[oshipp->ship_info_index];

                if ((oaip->mode == AIM_WAYPOINTS) && (oaip->wing == wingnum) && (oaip->ai_flags & AIF_FORMATION)) {
                        
                        float cur_max;
                        if ((oshipp->flags2 & SF2_AFTERBURNER_LOCKED) || !(osip->flags & SIF_AFTERBURNER) || (o->phys_info.afterburner_max_vel.xyz.z <= oshipp->current_max_speed) || !(oaip->ai_flags & AIF_FREE_AFTERBURNER_USE)) {
                                cur_max = oshipp->current_max_speed;
                        }
                        else
                        {
                                recharge_scale = Energy_levels[shipp->engine_recharge_index] * 2.0f * The_mission.ai_profile->afterburner_recharge_scale[Game_skill_level];
                                recharge_scale = osip->afterburner_recover_rate * recharge_scale / (osip->afterburner_burn_rate + osip->afterburner_recover_rate * recharge_scale);
                                cur_max = recharge_scale * (o->phys_info.afterburner_max_vel.xyz.z - oshipp->current_max_speed) + oshipp->current_max_speed;
                        }

                        if (object_is_docked(o)) {
                                cur_max *= o->phys_info.mass / dock_calc_total_docked_mass(o);
                        }
                        //      Note: If a ship in the wing has a super low max speed, probably its engines are disabled.  So, fly along and
                        //      ignore the poor guy.                            
                        if ((oshipp->current_max_speed > 5.0f) && (cur_max < lowest_max_av_ab_speed)) {
                                lowest_max_av_ab_speed = cur_max;
                        }
                }
        }

        return lowest_max_av_ab_speed;
}

int is_ignore_object_sub(int *ignore_objnum, int *ignore_signature, int objnum)
{
        // Not ignoring anything.
        if (*ignore_objnum == UNUSED_OBJNUM)
        {
                return 0;                                                                       
        }
        // This means it's ignoring an object, not a wing.
        else if (*ignore_objnum >= 0)
        {
                // see if this object became invalid
                if (Objects[*ignore_objnum].signature != *ignore_signature)
                {
                        // reset
                        *ignore_objnum = UNUSED_OBJNUM;
                }
                // objects and signatures match
                else if (*ignore_objnum == objnum)
                {
                        // found it
                        return 1;
                }

                return 0;
        }
        // Ignoring a wing.
        else
        {
                Int3(); // Should never happen.  I thought I removed this behavior! -- MK, 5/17/98
                return 0;
        }
}

// Goober5000
int find_ignore_new_object_index(ai_info *aip, int objnum)
{
        int i;

        for (i = 0; i < MAX_IGNORE_NEW_OBJECTS; i++)
        {
                if (is_ignore_object_sub(&aip->ignore_new_objnums[i], &aip->ignore_new_signatures[i], objnum))
                        return i;
        }

        return -1;
}

// Goober5000
int is_ignore_object(ai_info *aip, int objnum, int just_the_original = 0)
{
        // check original (retail) ignore
        if (is_ignore_object_sub(&aip->ignore_objnum, &aip->ignore_signature, objnum))
                return 1;

        // check new ignore
        if (!just_the_original)
        {
                if (find_ignore_new_object_index(aip, objnum) >= 0)
                        return 1;
        }

        return 0;
}




typedef struct eval_nearest_objnum {
        int     objnum;
        object *trial_objp;
        int     enemy_team_mask;
        int     enemy_wing;
        float   range;
        int     max_attackers;
        int     nearest_objnum;
        float   nearest_dist;
        int     check_danger_weapon_objnum;
} eval_nearest_objnum;


void evaluate_object_as_nearest_objnum(eval_nearest_objnum *eno)
{
        ai_info *aip;
        ship_subsys     *attacking_subsystem;
        ship *shipp = &Ships[eno->trial_objp->instance];

        aip = &Ai_info[Ships[Objects[eno->objnum].instance].ai_index];

        attacking_subsystem = aip->targeted_subsys;

        if ((attacking_subsystem != NULL) || !(eno->trial_objp->flags & OF_PROTECTED)) {
                if ( OBJ_INDEX(eno->trial_objp) != eno->objnum ) {
#ifndef NDEBUG
                        if (!Player_attacking_enabled && (eno->trial_objp == Player_obj))
                                return;
#endif
                        //      If only supposed to attack ship in a specific wing, don't attack other ships.
                        if ((eno->enemy_wing != -1) && (shipp->wingnum != eno->enemy_wing))
                                return;

                        //      Don't keep firing at a ship that is in its death throes.
                        if (shipp->flags & SF_DYING)
                                return;

                        if (is_ignore_object(aip, OBJ_INDEX(eno->trial_objp)))
                                return;

                        if (eno->trial_objp->flags & OF_PROTECTED)
                                return;

                        if (shipp->flags & SF_ARRIVING)
                                return;

                        ship_info *sip = &Ship_info[shipp->ship_info_index];

                        if (sip->flags & (SIF_NO_SHIP_TYPE | SIF_NAVBUOY))
                                return;

                        if (iff_matches_mask(shipp->team, eno->enemy_team_mask)) {
                                float   dist;
                                int     num_attacking;

                                // Allow targeting of stealth in nebula by his firing at me
                                // This is done for a specific ship, not generally.
                                if ( !eno->check_danger_weapon_objnum ) {
                                        // check if can be targeted if inside nebula
                                        if ( !object_is_targetable(eno->trial_objp, &Ships[Objects[eno->objnum].instance]) ) {
                                                // check if stealth ship is visible, but not "targetable"
                                                if ( !((shipp->flags2 & SF2_STEALTH) && ai_is_stealth_visible(&Objects[eno->objnum], eno->trial_objp)) ) {
                                                        return;
                                                }
                                        }
                                }

                                // if objnum is BIG or HUGE, find distance to bbox
                                if (sip->flags & (SIF_BIG_SHIP | SIF_HUGE_SHIP)) {
                                        vec3d box_pt;
                                        // check if inside bbox
                                        int inside = get_nearest_bbox_point(eno->trial_objp, &Objects[eno->objnum].pos, &box_pt);
                                        if (inside) {
                                                dist = 10.0f;
                                                // on the box
                                        } else {
                                                dist = vm_vec_dist_quick(&Objects[eno->objnum].pos, &box_pt);
                                        }
                                } else {
                                        dist = vm_vec_dist_quick(&Objects[eno->objnum].pos, &eno->trial_objp->pos);
                                }
                                
                                //      Make it more likely that fighters (or bombers) will be picked as an enemy by scaling up distance for other types.
                                if ((Ship_info[shipp->ship_info_index].flags & (SIF_FIGHTER | SIF_BOMBER))) {
                                        dist = dist * 0.5f;
                                }

                                num_attacking = num_enemies_attacking(OBJ_INDEX(eno->trial_objp));
                                if ((sip->flags & (SIF_BIG_SHIP | SIF_HUGE_SHIP)) || (num_attacking < eno->max_attackers)) {
                                        if (!(sip->flags & (SIF_BIG_SHIP | SIF_HUGE_SHIP))){
                                                dist *= (float) (num_attacking+2)/2.0f;                         //      prevents lots of ships from attacking same target
                                        }

                                        if (eno->trial_objp->flags & OF_PLAYER_SHIP){
                                                dist *= 1.0f + (NUM_SKILL_LEVELS - Game_skill_level - 1)/NUM_SKILL_LEVELS;      //      Favor attacking non-players based on skill level.
                                        }

                                        if (dist < eno->nearest_dist) {
                                                eno->nearest_dist = dist;
                                                eno->nearest_objnum = OBJ_INDEX(eno->trial_objp);
                                        }
                                }
                        }
                }
        }

}


int get_nearest_objnum(int objnum, int enemy_team_mask, int enemy_wing, float range, int max_attackers)
{
        object  *danger_weapon_objp;
        ai_info *aip;
        ship_obj        *so;

        // initialize eno struct
        eval_nearest_objnum eno;
        eno.enemy_team_mask = enemy_team_mask;
        eno.enemy_wing = enemy_wing;
        eno.max_attackers = max_attackers;
        eno.objnum = objnum;
        eno.range = range;
        eno.nearest_dist = range;
        eno.nearest_objnum = -1;
        eno.check_danger_weapon_objnum = 0;

        // go through the list of all ships and evaluate as potential targets
        for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
                eno.trial_objp = &Objects[so->objnum];
                evaluate_object_as_nearest_objnum(&eno);
        }

        // check if danger_weapon_objnum has will show a stealth ship
        aip = &Ai_info[Ships[Objects[objnum].instance].ai_index];
        if (aip->danger_weapon_objnum >= 0) {
                danger_weapon_objp = &Objects[aip->danger_weapon_objnum];
                // validate weapon
                if (danger_weapon_objp->signature == aip->danger_weapon_signature) {
                        Assert(danger_weapon_objp->type == OBJ_WEAPON);
                        // check if parent is a ship
                        if (danger_weapon_objp->parent >= 0) {
                                if ( is_object_stealth_ship(&Objects[danger_weapon_objp->parent]) ) {
                                        // check if stealthy
                                        if ( ai_is_stealth_visible(&Objects[objnum], &Objects[danger_weapon_objp->parent]) != STEALTH_FULLY_TARGETABLE ) {
                                                // check if weapon is laser
                                                if (Weapon_info[Weapons[danger_weapon_objp->instance].weapon_info_index].subtype == WP_LASER) {
                                                        // check stealth ship by its laser fire
                                                        eno.check_danger_weapon_objnum = 1;
                                                        eno.trial_objp = &Objects[danger_weapon_objp->parent];
                                                        evaluate_object_as_nearest_objnum(&eno);
                                                }
                                        }
                                }
                        }
                }
        }

        //      If only looking for target in certain wing and couldn't find anything in
        //      that wing, look for any object.
        if ((eno.nearest_objnum == -1) && (enemy_wing != -1)) {
                return get_nearest_objnum(objnum, enemy_team_mask, -1, range, max_attackers);
        }

        return eno.nearest_objnum;
}

int find_nearby_threat(int objnum, int enemy_team_mask, float range, int *count)
{
        int             nearest_objnum;
        float           nearest_dist;
        object  *objp;
        ship_obj        *so;

        nearest_objnum = -1;
        nearest_dist = range;

        *count = 0;

        for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
                objp = &Objects[so->objnum];

                if ( OBJ_INDEX(objp) != objnum ) {
                        if (Ships[objp->instance].flags & SF_DYING)
                                continue;

                        if (Ship_info[Ships[objp->instance].ship_info_index].flags & (SIF_NO_SHIP_TYPE | SIF_NAVBUOY))
                                continue;

                        if (iff_matches_mask(Ships[objp->instance].team, enemy_team_mask)) {
                                float   dist;

                                dist = vm_vec_dist_quick(&Objects[objnum].pos, &objp->pos) - objp->radius*0.75f;
                                
                                if (dist < range) {
                                        (*count)++;

                                        if (dist < nearest_dist) {
                                                nearest_dist = dist;
                                                nearest_objnum = OBJ_INDEX(objp);
                                        }
                                }
                        }
                }
        }

        return nearest_objnum;
}

int num_turrets_attacking(object *turret_parent, int target_objnum) 
{
        ship_subsys *ss;
        ship *shipp;
        int count = 0;
        shipp = &Ships[turret_parent->instance];

        Assert(turret_parent->type == OBJ_SHIP);

        for (ss=GET_FIRST(&shipp->subsys_list); ss!=END_OF_LIST(&shipp->subsys_list); ss=GET_NEXT(ss)) {
                // check if subsys is alive
                if (ss->current_hits <= 0.0f) {
                        continue;
                }

                // check if it's a turret
                if (ss->system_info->type != SUBSYSTEM_TURRET) {
                        continue;
                }

                // if the turret is locked
                if(ss->weapons.flags & SW_FLAG_TURRET_LOCK){
                        continue;
                }               

                // check if turret is targeting target_objnum
                if (ss->turret_enemy_objnum == target_objnum) {
                        count++;
                }
        }

        return count;
}

int get_enemy_timestamp()
{
        return (NUM_SKILL_LEVELS - Game_skill_level) * ( (myrand() % 500) + 500);
}

int find_enemy(int objnum, float range, int max_attackers)
{
        int     enemy_team_mask;

        if (objnum < 0)
                return -1;

        enemy_team_mask = iff_get_attackee_mask(obj_team(&Objects[objnum]));

        //      if target_objnum != -1, use that as goal.
        ai_info *aip = &Ai_info[Ships[Objects[objnum].instance].ai_index];
        if (timestamp_elapsed(aip->choose_enemy_timestamp)) {
                aip->choose_enemy_timestamp = timestamp(get_enemy_timestamp());
                if (aip->target_objnum != -1) {
                        int     target_objnum = aip->target_objnum;

                        // DKA don't undo object as target in nebula missions.
                        // This could cause attack on ship on fringe on nebula to stop if attackee moves our of nebula range.  (BAD)
                        if ( Objects[target_objnum].signature == aip->target_signature ) {
                                if (iff_matches_mask(Ships[Objects[target_objnum].instance].team, enemy_team_mask)) {
                                        if (!(Objects[target_objnum].flags & OF_PROTECTED)) {
                                                return target_objnum;
                                        }
                                }
                        } else {
                                aip->target_objnum = -1;
                                aip->target_signature = -1;
                        }
                }
                
                return get_nearest_objnum(objnum, enemy_team_mask, aip->enemy_wing, range, max_attackers);
                
        } else {
                aip->target_objnum = -1;
                aip->target_signature = -1;
                return -1;
        }
}

void ai_set_goal_maybe_abort_dock(object *objp, ai_info *aip)
{
        if (aip->ai_flags & AIF_AWAITING_REPAIR) {
                object  *repair_obj;

                if (aip->support_ship_objnum == -1) {
                        repair_obj = NULL;
                } else {
                        repair_obj = &Objects[aip->support_ship_objnum];
                }
                ai_do_objects_repairing_stuff( objp, repair_obj, REPAIR_INFO_ABORT );
        }
        aip->next_rearm_request_timestamp = timestamp(NEXT_REARM_TIMESTAMP);    //      Might request again after 30 seconds.
}

void force_avoid_player_check(object *objp, ai_info *aip)
{
        if (Ships[objp->instance].team == Player_ship->team){
                aip->avoid_check_timestamp = timestamp(0);              //      Force a check for collision next frame.
        }
}

void ai_attack_object(object *attacker, object *attacked, ship_subsys *ssp)
{
        int temp;
        ai_info *aip;

        Assert(attacker != NULL);
        Assert(attacker->instance != -1);
        Assert(Ships[attacker->instance].ai_index != -1);

        aip = &Ai_info[Ships[attacker->instance].ai_index];
        force_avoid_player_check(attacker, aip);

        aip->ok_to_target_timestamp = timestamp(0);             //      Guarantee we can target.

        if (attacker == attacked) {
                Int3();         //      Bogus!  Who tried to get me to attack myself!  Trace out and fix!
                return;
        }

        //      Only set to chase if a fighter or bomber, otherwise just return.
        if (!(Ship_info[Ships[attacker->instance].ship_info_index].flags & SIF_SMALL_SHIP) && (attacked != NULL)) {
                nprintf(("AI", "AI ship %s is large ship ordered to attack %s\n", Ships[attacker->instance].ship_name, Ships[attacked->instance].ship_name));
        }

        //      This is how "engage enemy" gets processed
        if (attacked == NULL) {
                aip->choose_enemy_timestamp = timestamp(0);
                // nebula safe
                set_target_objnum(aip, find_enemy(OBJ_INDEX(attacker), 99999.9f, 4));
        } else {
                // check if we can see atacked in nebula
                if (aip->target_objnum != OBJ_INDEX(attacked)) {
                        aip->aspect_locked_time = 0.0f;
                }
                set_target_objnum(aip, OBJ_INDEX(attacked));
        }

        ai_set_goal_maybe_abort_dock(attacker, aip);
        aip->ok_to_target_timestamp = timestamp(DELAY_TARGET_TIME);     //      No dynamic targeting for 7 seconds.

        // Goober5000
        temp = find_ignore_new_object_index(aip, aip->target_objnum);
        if (temp >= 0)
        {
                aip->ignore_new_objnums[temp] = UNUSED_OBJNUM;
        }
        else if (is_ignore_object(aip, aip->target_objnum, 1))
        {
                aip->ignore_objnum = UNUSED_OBJNUM;
        }

        aip->mode = AIM_CHASE;
        aip->submode = SM_ATTACK;                               // AL 12-15-97: need to set submode?  I got an assert() where submode was bogus
        aip->submode_start_time = Missiontime;  // for AIM_CHASE... it may have been not set correctly here

        if (ssp == NULL) {
                set_targeted_subsys(aip, NULL, -1);
                if (aip->target_objnum != -1) {
                        Objects[aip->target_objnum].flags &= ~OF_PROTECTED;     //      If ship had been protected, unprotect it.
                }
        } else {
                Int3(); //      Not supported yet!
        }
}

void ai_attack_wing(object *attacker, int wingnum)
{
        ai_info *aip;

        Assert(attacker != NULL);
        Assert(attacker->instance != -1);
        Assert(Ships[attacker->instance].ai_index != -1);

        aip = &Ai_info[Ships[attacker->instance].ai_index];

        aip->enemy_wing = wingnum;
        aip->mode = AIM_CHASE;
        aip->submode = SM_ATTACK;                               // AL 12-15-97: need to set submode?  I got an assert() where submode was bogus
        aip->submode_start_time = Missiontime;  // for AIM_CHASE... it may have been not set correctly here

        aip->ok_to_target_timestamp = timestamp(0);             //      Guarantee we can target.

        int count = Wings[wingnum].current_count;
        if (count > 0) {
                int     index;

                index = (int) (frand() * count);

                if (index >= count)
                        index = 0;

                set_target_objnum(aip, Ships[Wings[wingnum].ship_index[index]].objnum);

                ai_set_goal_maybe_abort_dock(attacker, aip);
                aip->ok_to_target_timestamp = timestamp(DELAY_TARGET_TIME);     //      No dynamic targeting for 7 seconds.
        }
}

void ai_evade_object(object *evader, object *evaded)
{
        ai_info *aip;

        Assert(evader != NULL);
        Assert(evaded != NULL);
        Assert(evader->instance != -1);
        Assert(Ships[evader->instance].ai_index != -1);

        if (evaded == evader) {
                Int3(); //      Bogus!  Who tried to get me to evade myself!  Trace out and fix!
                return;
        }

        aip = &Ai_info[Ships[evader->instance].ai_index];

        set_target_objnum(aip, OBJ_INDEX(evaded));
        aip->mode = AIM_EVADE;

}

int compact_ignore_new_objects(ai_info *aip, int force = 0)
{
        if (force)
                aip->ignore_new_objnums[0] = UNUSED_OBJNUM;

        for (int current_index = 0; current_index < MAX_IGNORE_NEW_OBJECTS; current_index++)
        {
                int next_occupied_index = -1;

                // skip occupied slots
                if (aip->ignore_new_objnums[current_index] != UNUSED_OBJNUM)
                {
                        // prune invalid objects
                        if (Objects[aip->ignore_new_objnums[current_index]].signature != aip->ignore_new_signatures[current_index])
                                aip->ignore_new_objnums[current_index] = UNUSED_OBJNUM;
                        else
                                continue;
                }

                // find an index to move downward
                for (int i = current_index + 1; i < MAX_IGNORE_NEW_OBJECTS; i++)
                {
                        // skip empty slots
                        if (aip->ignore_new_objnums[i] == UNUSED_OBJNUM)
                                continue;

                        // found one
                        next_occupied_index = i;
                        break;
                }

                // are all higher slots empty?
                if (next_occupied_index < 0)
                        return current_index;

                // move the occupied slot down to this one
                aip->ignore_new_objnums[current_index] = aip->ignore_new_objnums[next_occupied_index];
                aip->ignore_new_signatures[current_index] = aip->ignore_new_signatures[next_occupied_index];

                // empty the occupied slot
                aip->ignore_new_objnums[next_occupied_index] = UNUSED_OBJNUM;
                aip->ignore_new_signatures[next_occupied_index] = -1;
        }

        // all slots are occupied
        return MAX_IGNORE_NEW_OBJECTS;
}

void ai_ignore_object(object *ignorer, object *ignored, int ignore_new)
{
        ai_info *aip;

        Assert(ignorer != NULL);
        Assert(ignored != NULL);
        Assert(ignorer->instance != -1);
        Assert(Ships[ignorer->instance].ai_index != -1);
        Assert(ignorer != ignored);

        aip = &Ai_info[Ships[ignorer->instance].ai_index];

        // Goober5000 - new behavior
        if (ignore_new)
        {
                int num_objects;

                // compact the array
                num_objects = compact_ignore_new_objects(aip);

                // make sure we're not adding a duplicate
                if (find_ignore_new_object_index(aip, OBJ_INDEX(ignored)) >= 0)
                        return;

                // if we can't add a new one; "forget" one
                if (num_objects >= MAX_IGNORE_NEW_OBJECTS)
                        num_objects = compact_ignore_new_objects(aip, 1);

                // add it
                aip->ignore_new_objnums[num_objects] = OBJ_INDEX(ignored);
                aip->ignore_new_signatures[num_objects] = ignored->signature;
        }
        // retail behavior
        else
        {
                aip->ignore_objnum = OBJ_INDEX(ignored);
                aip->ignore_signature = ignored->signature;
                aip->ai_flags &= ~AIF_TEMPORARY_IGNORE;
                ignored->flags |= OF_PROTECTED;                                 // set protected bit of ignored ship.
        }
}

void ai_ignore_wing(object *ignorer, int wingnum)
{
        ai_info *aip;

        Assert(ignorer != NULL);
        Assert(ignorer->instance != -1);
        Assert(Ships[ignorer->instance].ai_index != -1);
        Assert((wingnum >= 0) && (wingnum < MAX_WINGS));

        aip = &Ai_info[Ships[ignorer->instance].ai_index];

        aip->ignore_objnum = -(wingnum +1);
        aip->ai_flags &= ~AIF_TEMPORARY_IGNORE;
}


void add_path_point(vec3d *pos, int path_num, int path_index, int modify_index)
{
        pnode   *pnp;

        if (modify_index == -1) {
                Assert(Ppfp-Path_points < MAX_PATH_POINTS-1);
                pnp = Ppfp;
                Ppfp++;
        } else {
                Assert((modify_index >= 0) && (modify_index < MAX_PATH_POINTS-1));
                pnp = &Path_points[modify_index];
        }

        pnp->pos = *pos;
        pnp->path_num = path_num;
        pnp->path_index = path_index;
}

void bisect_chord(vec3d *p0, vec3d *p1, vec3d *centerp, float radius)
{
        vec3d   tvec;
        vec3d   new_pnt;

        vm_vec_add(&tvec, p0, p1);
        vm_vec_sub2(&tvec, centerp);
        vm_vec_sub2(&tvec, centerp);
        if (vm_vec_mag_quick(&tvec) < 0.1f) {
                vm_vec_sub(&tvec, p0, p1);
                if (fl_abs(tvec.xyz.x) <= fl_abs(tvec.xyz.z)){
                        tvec.xyz.x = -tvec.xyz.z;
                } else {
                        tvec.xyz.y = -tvec.xyz.x;
                }
        }

        vm_vec_normalize(&tvec);
        vm_vec_scale(&tvec, radius);
        vm_vec_add(&new_pnt, centerp, &tvec);

        add_path_point(&new_pnt, -1, -1, -1);
}
                        
void create_path_to_point(vec3d *curpos, vec3d *goalpos, object *curobjp, object *goalobjp, int subsys_path)
{
        //      If can't cast vector to goalpos, then create an intermediate point.
        if (pp_collide(curpos, goalpos, goalobjp, curobjp->radius)) {
                vec3d   tan1;
                float           radius;

                // If this is a path to a subsystem, use SUBSYS_PATH_DIST as the radius for the object you are
                // trying to avoid.  This is needed since subsystem paths extend out to SUBSYS_PATH_DIST, and we
                // want ships to reach their path destination without flying to points that sit on the radius of
                // a small ship
                radius = goalobjp->radius;
                if (subsys_path) {
                        if ( SUBSYS_PATH_DIST > goalobjp->radius ) {
                                radius = SUBSYS_PATH_DIST;
                        }
                }

                //      The intermediate point is at the intersection of:
                //              tangent to *goalobjp sphere at point *goalpos
                //              tangent to *goalobjp sphere through point *curpos in plane defined by *curpos, *goalpos, goalobjp->pos
                //      Note, there are two tangents through *curpos, unless *curpos is on the
                //      sphere.  The tangent that causes the nearer intersection (to *goalpos) is chosen.
                get_tangent_point(&tan1, curpos, &goalobjp->pos, goalpos, radius);

                //      If we can't reach tan1 from curpos, insert a new point.
                if (pp_collide(&tan1, curpos, goalobjp, curobjp->radius))
                        bisect_chord(curpos, &tan1, &goalobjp->pos, radius);

                add_path_point(&tan1, -1, -1, -1);

                //      If we can't reach goalpos from tan1, insert a new point.
                if (pp_collide(goalpos, &tan1, goalobjp, curobjp->radius))
                        bisect_chord(goalpos, &tan1, &goalobjp->pos, radius);
        }

}

void copy_xlate_model_path_points(object *objp, model_path *mp, int dir, int count, int path_num, pnode *pnp, int randomize_pnt)
{
        polymodel *pm;
        int             i, modelnum, model_instance_num;
        vec3d   v1;
        int             pp_index;               //      index in Path_points at which to store point, if this is a modify-in-place (pnp ! NULL)
        int             start_index, finish_index;
        vec3d submodel_offset, local_vert;
        bool rotating_submodel;
        
        //      Initialize pp_index.
        //      If pnp == NULL, that means we're creating new points.  If not NULL, then modify in place.
        if (pnp == NULL)
                pp_index = -1;                  //      This tells add_path_point to create a new point.
        else
                pp_index = 0;                   //      pp_index will get assigned to index in Path_points to reuse.

        if (dir == 1) {
                start_index = 0;
                finish_index = MIN(count, mp->nverts);
        } else {
                Assert(dir == -1);      //      direction must be up by 1 or down by 1 and it's neither!
                start_index = mp->nverts-1;
                finish_index = MAX(-1, mp->nverts-1-count);
        }

        // Goober5000 - check for rotating submodels
        modelnum = Ship_info[Ships[objp->instance].ship_info_index].model_num;
        model_instance_num = Ships[objp->instance].model_instance_num;
        pm = model_get(modelnum);
        if ((mp->parent_submodel >= 0) && (pm->submodel[mp->parent_submodel].movement_type >= 0))
        {
                rotating_submodel = true;

                model_find_submodel_offset(&submodel_offset, modelnum, mp->parent_submodel);
        }
        else
        {
                rotating_submodel = false;
        }

        int offset = 0;
        for (i=start_index; i != finish_index; i += dir)
        {
                //      Globalize the point.
                // Goober5000 - handle rotating submodels
                if (rotating_submodel)
                {
                        // movement... find location of point like with docking code and spark generation
                        vm_vec_sub(&local_vert, &mp->verts[i].pos, &submodel_offset);
                        model_instance_find_world_point(&v1, &local_vert, model_instance_num, mp->parent_submodel, &objp->orient, &objp->pos);
                }
                else
                {
                        // no movement... calculate as in original code
                        vm_vec_unrotate(&v1, &mp->verts[i].pos, &objp->orient);
                        vm_vec_add2(&v1, &objp->pos);
                }

                if ( randomize_pnt == i ) {
                        vec3d v_rand;
                        static_randvec(OBJ_INDEX(objp), &v_rand);
                        vm_vec_scale(&v_rand, 30.0f);
                        vm_vec_add2(&v1, &v_rand);
                }

                if (pp_index != -1)
                        pp_index = pnp-Path_points + offset;

                add_path_point(&v1, path_num, i, pp_index);
                offset++;
        }
}


void create_model_path(object *pl_objp, object *mobjp, int path_num, int subsys_path)
{       
        ship                    *shipp = &Ships[pl_objp->instance];
        ai_info         *aip = &Ai_info[shipp->ai_index];

        ship_info       *osip = &Ship_info[Ships[mobjp->instance].ship_info_index];
        polymodel       *pm = model_get(Ship_info[Ships[mobjp->instance].ship_info_index].model_num);
        int                     num_points;
        model_path      *mp;
        pnode                   *ppfp_start = Ppfp;
        vec3d           gp0;

        Assert(path_num >= 0);

        //      Do garbage collection if necessary.
        if (Ppfp-Path_points + 64 > MAX_PATH_POINTS) {
                garbage_collect_path_points();
                ppfp_start = Ppfp;
        }

        aip->path_start = Ppfp - Path_points;
        Assert(path_num < pm->n_paths);
        
        mp = &pm->paths[path_num];
        num_points = mp->nverts;

        Assert(Ppfp-Path_points + num_points + 4 < MAX_PATH_POINTS);

        vm_vec_unrotate(&gp0, &mp->verts[0].pos, &mobjp->orient);
        vm_vec_add2(&gp0, &mobjp->pos);

        if (pp_collide(&pl_objp->pos, &gp0, mobjp, pl_objp->radius)) {
                vec3d   perim_point1;
                vec3d   perim_point2;

                perim_point2 = pl_objp->pos;
                
                //      If object that wants to dock is inside bounding sphere of object it wants to dock with, make it fly out.
                //      Assume it can fly "straight" out to the bounding sphere.
                if (vm_vec_dist_quick(&pl_objp->pos, &mobjp->pos) < mobjp->radius) {
                        project_point_to_perimeter(&perim_point2, &mobjp->pos, mobjp->radius, &pl_objp->pos);
                        add_path_point(&perim_point2, path_num, -1, -1);
                }

                //      If last point on pre-defined path is inside bounding sphere, create a new point on the surface of the sphere.
                if (vm_vec_dist_quick(&mobjp->pos, &gp0) < mobjp->radius) {
                        project_point_to_perimeter(&perim_point1, &mobjp->pos, mobjp->radius, &gp0);
                        create_path_to_point(&perim_point2, &perim_point1, pl_objp, mobjp, subsys_path);
                        add_path_point(&perim_point1, path_num, -1, -1);
                } else {                //      The predefined path extends outside the sphere.  Create path to that point.
                        create_path_to_point(&perim_point2, &gp0, pl_objp, mobjp, subsys_path);
                }
        }

        // AL 12-31-97: If following a subsystem path, add random vector to second last path point
        if ( subsys_path ) {
                copy_xlate_model_path_points(mobjp, mp, 1, mp->nverts, path_num, NULL, mp->nverts-2);
        } else {
                copy_xlate_model_path_points(mobjp, mp, 1, mp->nverts, path_num, NULL);
        }

        aip->path_cur = aip->path_start;
        aip->path_dir = PD_FORWARD;
        aip->path_objnum = OBJ_INDEX(mobjp);
        aip->mp_index = path_num;
        aip->path_length = Ppfp - ppfp_start;
        aip->path_next_check_time = timestamp(1);

        aip->path_goal_obj_hash = create_object_hash(&Objects[aip->path_objnum]);

        aip->path_next_create_time = timestamp(1000);   //      OK to try to create one second later
        aip->path_create_pos = pl_objp->pos;
        aip->path_create_orient = pl_objp->orient;
        
        //Get path departure orientation from ships.tbl if it exists, otherwise zero it
        SCP_string pathName(mp->name);
        if (osip->pathMetadata.find(pathName) != osip->pathMetadata.end() && !IS_VEC_NULL(&osip->pathMetadata[pathName].departure_rvec))
        {
                vm_vec_copy_normalize(&aip->path_depart_orient, &osip->pathMetadata[pathName].departure_rvec);
        }
        else
        {
                vm_vec_zero(&aip->path_depart_orient);
        }

        aip->ai_flags &= ~AIF_USE_EXIT_PATH;                    // ensure this flag is cleared
}

void create_model_exit_path(object *pl_objp, object *mobjp, int path_num, int count)
{       
        ship                    *shipp = &Ships[pl_objp->instance];
        ai_info         *aip = &Ai_info[shipp->ai_index];

        polymodel       *pm = model_get(Ship_info[Ships[mobjp->instance].ship_info_index].model_num);
        int                     num_points;
        model_path      *mp;
        pnode                   *ppfp_start = Ppfp;

        Assert(path_num >= 0);

        //      Do garbage collection if necessary.
        if (Ppfp-Path_points + 64 > MAX_PATH_POINTS) {
                garbage_collect_path_points();
                ppfp_start = Ppfp;
        }

        aip->path_start = Ppfp - Path_points;
        Assert(path_num < pm->n_paths);
        
        mp = &pm->paths[path_num];
        num_points = mp->nverts;

        Assert(Ppfp-Path_points + num_points + 4 < MAX_PATH_POINTS);

        copy_xlate_model_path_points(mobjp, mp, -1, count, path_num, NULL);

        aip->path_cur = aip->path_start;
        aip->path_dir = PD_FORWARD;
        aip->path_objnum = OBJ_INDEX(mobjp);
        aip->mp_index = path_num;
        aip->path_length = Ppfp - ppfp_start;
        aip->path_next_check_time = timestamp(1);

        aip->ai_flags |= AIF_USE_EXIT_PATH;             // mark as exit path, referenced in maybe
}

int pp_collide_any(vec3d *curpos, vec3d *goalpos, float radius, object *ignore_objp1, object *ignore_objp2, int big_only_flag)
{
        ship_obj        *so;    

        for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
                object *objp = &Objects[so->objnum];

                if (big_only_flag) {
                        if (!(Ship_info[Ships[objp->instance].ship_info_index].flags & (SIF_BIG_SHIP | SIF_HUGE_SHIP)))
                                continue;
                }

                if ((objp != ignore_objp1) && (objp != ignore_objp2)) {
                        if (pp_collide(curpos, goalpos, objp, radius))
                                return OBJ_INDEX(objp);
                }
        }

        return -1;
}

//      Used to create docking paths and other pre-defined paths through ships.
//      Creates a path in absolute space.
//      Create a path into the object objnum.
//
// input:
//      pl_objp:                        object that will use the path
//      objnum:                 Object to find path to.
//      path_num:               model path index to use
//      exit_flag:              true means this is an exit path in the model
// subsys_path: optional param (default 0) that indicates this is a path to a subsystem
//      Exit:
//      ai_info struct in Pl_objp gets stuffed with information to enable Pl_objp to fly the path.
void ai_find_path(object *pl_objp, int objnum, int path_num, int exit_flag, int subsys_path)
{
        ai_info *aip = &Ai_info[Ships[pl_objp->instance].ai_index];

        Assert(path_num >= 0);

        //      This is test code, find an object with paths.
        if (objnum != -1) {
                object  *objp = &Objects[objnum];

                if (objp->type == OBJ_SHIP) {
                        polymodel *pm;

                        ship    *shipp = &Ships[objp->instance];
                        pm = model_get(Ship_info[shipp->ship_info_index].model_num);
                        if(path_num >= pm->n_paths)
                                Error(LOCATION,"ai_find_path tring to find a path (%d) that doesn't exist, on ship %s", path_num, shipp->ship_name);

                        aip->goal_objnum = objnum;
                        aip->goal_signature = objp->signature;
                        if (exit_flag)
                                create_model_exit_path(pl_objp, objp, path_num);
                        else
                                create_model_path(pl_objp, objp, path_num, subsys_path);
                        return;
                }

        }
}

extern int vector_object_collision(vec3d *start_pos, vec3d *end_pos, object *objp, float radius_scale);

//      Maybe make *objp avoid a player object.
//      For now, 4/6/98, only check Player_obj.
//      If player collision would occur, set AIF_AVOIDING_SMALL_SHIP bit in ai_flags.
//      Set aip->avoid_goal_point
int maybe_avoid_player(object *objp, vec3d *goal_pos)
{
        ai_info *aip;
        vec3d   cur_pos, new_goal_pos;
        object  *player_objp;
        vec3d   n_vec_to_goal, n_vec_to_player;

        aip = &Ai_info[Ships[objp->instance].ai_index];

        if (!timestamp_elapsed(aip->avoid_check_timestamp))
                return 0;

        player_objp = Player_obj;

        float   speed_time;

        //      How far two ships could be apart and still collide within one second.
        speed_time = player_objp->phys_info.speed + objp->phys_info.speed;

        float   obj_obj_dist;

        obj_obj_dist = vm_vec_dist_quick(&player_objp->pos, &objp->pos);

        if (obj_obj_dist > speed_time*2.0f)
                return 0;

        cur_pos = objp->pos;

        new_goal_pos = *goal_pos;

        float dist = vm_vec_normalized_dir(&n_vec_to_goal, goal_pos, &objp->pos);
        vm_vec_normalized_dir(&n_vec_to_player, &player_objp->pos, &objp->pos);

        if (dist > speed_time*2.0f) {
                vm_vec_scale_add(&new_goal_pos, &objp->pos, &n_vec_to_goal, 200.0f);
        }

        if (vector_object_collision(&objp->pos, &new_goal_pos, player_objp, 1.5f)) {
                aip->ai_flags |= AIF_AVOIDING_SMALL_SHIP;

                vec3d   avoid_vec;

                vm_vec_sub(&avoid_vec, &n_vec_to_goal, &n_vec_to_player);
                if (vm_vec_mag_quick(&avoid_vec) < 0.01f) {
                        vm_vec_copy_scale(&avoid_vec, &objp->orient.vec.rvec, frand()-0.5f);
                        vm_vec_scale_add2(&avoid_vec, &objp->orient.vec.uvec, frand()-0.5f);
                        vm_vec_normalize(&avoid_vec);
                } else {
                        vec3d   tvec1;
                        vm_vec_normalize(&avoid_vec);
                        vm_vec_cross(&tvec1, &n_vec_to_goal, &avoid_vec);
                        vm_vec_cross(&avoid_vec, &tvec1, &n_vec_to_player);
                }

                //      Now, avoid_vec is a vector perpendicular to the vector to the player and the direction *objp
                //      should fly in to avoid the player while still approaching its goal.
                vm_vec_scale_add(&aip->avoid_goal_point, &player_objp->pos, &avoid_vec, 400.0f);

                aip->avoid_check_timestamp = timestamp(1000);

                return 1;
        } else {
                aip->ai_flags &= ~AIF_AVOIDING_SMALL_SHIP;
                aip->avoid_check_timestamp = timestamp((int) (obj_obj_dist/200.0f) + 500);

                return 0;
        }
}

//      Make object *still_objp enter AIM_STILL mode.
//      Make it point at view_pos.
void ai_stay_still(object *still_objp, vec3d *view_pos)
{
        ship    *shipp;
        ai_info *aip;

        Assert(still_objp->type == OBJ_SHIP);
        Assert((still_objp->instance >= 0) && (still_objp->instance < MAX_OBJECTS));

        shipp = &Ships[still_objp->instance];
        Assert((shipp->ai_index >= 0) && (shipp->ai_index < MAX_AI_INFO));

        aip = &Ai_info[shipp->ai_index];

        aip->mode = AIM_STILL;

        //      If view_pos not NULL, point at that point.  Else, point at a point directly in front of ship.  Ie, don't turn.
        if (view_pos != NULL)
                aip->goal_point = *view_pos;
        else
                vm_vec_scale_add(&aip->goal_point, &still_objp->pos, &still_objp->orient.vec.fvec, 100.0f);
}

// code which is called from ai_dock_with_object and ai_dock to set flags and apprioriate variable
// when two objects have completed docking.  used because we can dock object initially at misison load
// time (meaning that ai_dock() might never get called).  docker has docked with dockee (i.e. docker
// would be a freighter and dockee would be a cargo).
void ai_do_objects_docked_stuff(object *docker, int docker_point, object *dockee, int dockee_point, bool update_clients)
{
        Assert((docker != NULL) && (dockee != NULL));

        // make sure they're not already docked!
        if (dock_check_find_direct_docked_object(docker, dockee))
        {
                Warning(LOCATION, "Call to ai_do_objects_docked_stuff when objects are already docked!  Trace out and fix!\n");
                return;
        }

        // link the two objects
        dock_dock_objects(docker, docker_point, dockee, dockee_point);

        if (docker->type == OBJ_SHIP && dockee->type == OBJ_SHIP)
        {
                // maybe set support ship info
                if ((Ship_info[Ships[docker->instance].ship_info_index].flags & SIF_SUPPORT)
                        || (Ship_info[Ships[dockee->instance].ship_info_index].flags & SIF_SUPPORT))
                {
                        ai_info *docker_aip = &Ai_info[Ships[docker->instance].ai_index];
                        ai_info *dockee_aip = &Ai_info[Ships[dockee->instance].ai_index];

#ifndef NDEBUG
                        // support ship can only dock with one thing at a time
                        if (Ship_info[Ships[docker->instance].ship_info_index].flags & SIF_SUPPORT)
                                Assert(docker->dock_list->next == NULL);
                        else
                                Assert(dockee->dock_list->next == NULL);
#endif

                        // set stuff for both objects
                        docker_aip->support_ship_objnum = OBJ_INDEX(dockee);
                        dockee_aip->support_ship_objnum = OBJ_INDEX(docker);
                        docker_aip->support_ship_signature = dockee->signature;
                        dockee_aip->support_ship_signature = docker->signature;
                }
        }

        // add multiplayer hook here to deal with docked objects.  
        if ( MULTIPLAYER_MASTER && update_clients)
                send_ai_info_update_packet( docker, AI_UPDATE_DOCK, dockee );
}

// code which is called when objects become undocked. Equivalent of above function.
// Goober5000 - dockee must always be non-NULL
void ai_do_objects_undocked_stuff( object *docker, object *dockee )
{
        Assert((docker != NULL) && (dockee != NULL));

        // make sure they're not already undocked!
        if (!dock_check_find_direct_docked_object(docker, dockee))
        {
                Warning(LOCATION, "Call to ai_do_objects_undocked_stuff when objects are already undocked!  Trace out and fix!\n");
                return;
        }

        // add multiplayer hook here to deal with undocked objects.  Do it before we
        // do anything else.  We don't need to send info for both objects, since multi
        // only supports one docked object
        if ( MULTIPLAYER_MASTER )
                send_ai_info_update_packet( docker, AI_UPDATE_UNDOCK, dockee );

        if (docker->type == OBJ_SHIP && dockee->type == OBJ_SHIP)
        {
                ai_info *docker_aip = &Ai_info[Ships[docker->instance].ai_index];
                ai_info *dockee_aip = &Ai_info[Ships[dockee->instance].ai_index];

                // clear stuff for both objects
                docker_aip->ai_flags &= ~AIF_BEING_REPAIRED;
                dockee_aip->ai_flags &= ~AIF_BEING_REPAIRED;
                docker_aip->support_ship_objnum = -1;
                dockee_aip->support_ship_objnum = -1;
                docker_aip->support_ship_signature = -1;
                dockee_aip->support_ship_signature = -1;
        }

        // unlink the two objects
        dock_undock_objects(docker, dockee);
}


//      --------------------------------------------------------------------------
//      Interface from goals code to AI.
//      Cause *docker to dock with *dockee.
//      priority is priority of goal from goals code.
//      dock_type is:
//              AIDO_DOCK               set goal of docking
//              AIDO_DOCK_NOW   immediately dock, used for ships that need to be docked at mission start
//              AIDO_UNDOCK             set goal of undocking
void ai_dock_with_object(object *docker, int docker_index, object *dockee, int dockee_index, int dock_type)
{
        Assert(docker != NULL);
        Assert(dockee != NULL);
        Assert(docker->type == OBJ_SHIP);
        Assert(dockee->type == OBJ_SHIP);
        Assert(docker->instance >= 0);
        Assert(dockee->instance >= 0);
        Assert(Ships[docker->instance].ai_index >= 0);
        Assert(Ships[dockee->instance].ai_index >= 0);
        Assert(docker_index >= 0);
        Assert(dockee_index >= 0);

        ai_info *aip = &Ai_info[Ships[docker->instance].ai_index];

        aip->goal_objnum = OBJ_INDEX(dockee);
        aip->goal_signature = dockee->signature;

        aip->mode = AIM_DOCK;

        switch (dock_type) {
        case AIDO_DOCK:
                aip->submode = AIS_DOCK_0;
                aip->submode_start_time = Missiontime;
                break;
        case AIDO_DOCK_NOW:
                aip->submode = AIS_DOCK_4A;
                aip->submode_start_time = Missiontime;
                break;
        case AIDO_UNDOCK:
                aip->submode = AIS_UNDOCK_0;
                aip->submode_start_time = Missiontime;
                break;
        default:
                Int3();         //      Bogus dock_type.
        }

        // Goober5000 - we no longer need to set dock_path_index because it's easier to grab the path from the dockpoint
        // a debug check would be a good thing here, though
#ifndef NDEBUG
        if (dock_type == AIDO_UNDOCK)
        {
                polymodel       *pm = model_get(Ship_info[Ships[dockee->instance].ship_info_index].model_num);
                Assert( pm->docking_bays[dockee_index].num_spline_paths > 0 );
        }
#endif

        // dock instantly
        if (dock_type == AIDO_DOCK_NOW)
        {
                // set model animations correctly
                // (fortunately, this function is called AFTER model_anim_set_initial_states in the sea of ship creation
                // functions, which is necessary for model animations to start from t=0 at the correct positions)
                ship *shipp = &Ships[docker->instance];
                ship *goal_shipp = &Ships[dockee->instance];
                model_anim_start_type(shipp, TRIGGER_TYPE_DOCKING_STAGE_1, docker_index, 1, true);
                model_anim_start_type(goal_shipp, TRIGGER_TYPE_DOCKING_STAGE_1, dockee_index, 1, true);
                model_anim_start_type(shipp, TRIGGER_TYPE_DOCKING_STAGE_2, docker_index, 1, true);
                model_anim_start_type(goal_shipp, TRIGGER_TYPE_DOCKING_STAGE_2, dockee_index, 1, true);
                model_anim_start_type(shipp, TRIGGER_TYPE_DOCKING_STAGE_3, docker_index, 1, true);
                model_anim_start_type(goal_shipp, TRIGGER_TYPE_DOCKING_STAGE_3, dockee_index, 1, true);
                model_anim_start_type(shipp, TRIGGER_TYPE_DOCKED, docker_index, 1, true);
                model_anim_start_type(goal_shipp, TRIGGER_TYPE_DOCKED, dockee_index, 1, true);

                dock_orient_and_approach(docker, docker_index, dockee, dockee_index, DOA_DOCK_STAY);
                ai_do_objects_docked_stuff( docker, docker_index, dockee, dockee_index, false );
        }
        // pick a path to use to start docking
        else
        {
                int path_num = ai_return_path_num_from_dockbay(dockee, dockee_index);

                // make sure we have a path
                if (path_num < 0)
                {
                        Error(LOCATION, "Cannot find a dock path for ship %s, dock index %d.  Aborting dock.\n", Ships[dockee->instance].ship_name, dockee_index);
                        ai_mission_goal_complete(aip);
                        return;
                }

                ai_find_path(docker, OBJ_INDEX(dockee), path_num, 0);
        }
}


/*
 * Cause a ship to fly toward a ship.
 */
void ai_start_fly_to_ship(object *objp, int shipnum)
{
        ai_info *aip;

        aip = &Ai_info[Ships[objp->instance].ai_index];

        if (The_mission.flags & MISSION_FLAG_USE_AP_CINEMATICS && AutoPilotEngaged)
        {
                aip->ai_flags &= ~AIF_FORMATION_WING;
                aip->ai_flags &= ~AIF_FORMATION_OBJECT;
        }
        else
        {
                aip->ai_flags |= AIF_FORMATION_WING;
                aip->ai_flags &= ~AIF_FORMATION_OBJECT;
        }

        aip->mode = AIM_FLY_TO_SHIP;
        aip->submode_start_time = Missiontime;

        aip->target_objnum = Ships[shipnum].objnum;     

        Assert(aip->active_goal != AI_ACTIVE_GOAL_DYNAMIC);
}


//      Cause a ship to fly its waypoints.
//      flags tells:
//              WPF_REPEAT      Set -> repeat waypoints.
void ai_start_waypoints(object *objp, waypoint_list *wp_list, int wp_flags)
{
        ai_info *aip;
        Assert(wp_list != NULL);

        aip = &Ai_info[Ships[objp->instance].ai_index];

        if ( (aip->mode == AIM_WAYPOINTS) && (aip->wp_list == wp_list) )
        {
                if (aip->wp_index == INVALID_WAYPOINT_POSITION)
                {
                        Warning(LOCATION, "aip->wp_index should have been assigned already!");
                        aip->wp_index = 0;
                }
                return;
        }

        if (The_mission.flags & MISSION_FLAG_USE_AP_CINEMATICS && AutoPilotEngaged)
        {
                aip->ai_flags &= ~AIF_FORMATION_WING;
                aip->ai_flags &= ~AIF_FORMATION_OBJECT;
        }
        else
        {
                aip->ai_flags |= AIF_FORMATION_WING;
                aip->ai_flags &= ~AIF_FORMATION_OBJECT;
        }

        aip->wp_list = wp_list;
        aip->wp_index = 0;
        aip->wp_flags = wp_flags;
        aip->mode = AIM_WAYPOINTS;

        Assert(aip->active_goal != AI_ACTIVE_GOAL_DYNAMIC);
}

void ai_do_stay_near(object *objp, object *other_objp, float dist)
{
        ai_info *aip;

        Assert(objp != other_objp);             //      Bogus!  Told to stay near self.
        Assert(objp->type == OBJ_SHIP);
        Assert((objp->instance >= 0) && (objp->instance < MAX_SHIPS));

        aip = &Ai_info[Ships[objp->instance].ai_index];

        aip->mode = AIM_STAY_NEAR;
        aip->submode = -1;
        aip->submode_start_time = Missiontime;
        aip->stay_near_distance = dist;
        aip->goal_objnum = OBJ_INDEX(other_objp);
        aip->goal_signature = other_objp->signature;
}

//      Goober5000 - enter safety mode (used by support ships, now possibly by fighters too)
void ai_do_safety(object *objp)
{
        ai_info *aip;

        Assert(objp->type == OBJ_SHIP);
        Assert((objp->instance >= 0) && (objp->instance < MAX_SHIPS));

        aip = &Ai_info[Ships[objp->instance].ai_index];

        aip->mode = AIM_SAFETY;
        aip->submode = AISS_1;
        aip->submode_start_time = Missiontime;
}

void ai_form_on_wing(object *objp, object *goal_objp)
{
        ai_info *aip;
        ship                    *shipp;
        ship_info       *sip;

        // objp == goal_objp sometimes in multiplayer when someone leaves a game -- make a simple
        // out for this case.
        if ( Game_mode & GM_MULTIPLAYER ) {
                if ( objp == goal_objp ) {
                        return;
                }
        }

        Assert(objp != goal_objp);              //      Bogus!  Told to form on own's wing!

        shipp = &Ships[objp->instance];
        sip = &Ship_info[shipp->ship_info_index];

        //      Only fighters or bombers allowed to form on wing.
        if (!(sip->flags & (SIF_FIGHTER | SIF_BOMBER))) {
                nprintf(("AI", "Warning: Ship %s tried to form on player's wing, but not fighter or bomber.\n", shipp->ship_name));
                return;
        }


        aip = &Ai_info[Ships[objp->instance].ai_index];

        aip->ai_flags &= ~AIF_FORMATION_WING;
        aip->ai_flags |= AIF_FORMATION_OBJECT;

        aip->goal_objnum = OBJ_INDEX(goal_objp);
        ai_set_goal_maybe_abort_dock(objp, aip);
        aip->ok_to_target_timestamp = timestamp(DELAY_TARGET_TIME*4);           //      Super extra long time until can target another ship.

}

int ai_formation_object_get_slotnum(int objnum, object *objp)
{
        int     slotnum = 1;                    //      Note: Slot #0 means leader, which isn't someone who was told to form-on-wing.

        object *o;
        for ( o = GET_FIRST(&obj_used_list); o != END_OF_LIST(&obj_used_list); o = GET_NEXT(o) ) {
                if (objp == o)
                        break;
                else if (o->type == OBJ_SHIP)
                        if (Ai_info[Ships[o->instance].ai_index].ai_flags & AIF_FORMATION_OBJECT)
                                if (Ai_info[Ships[o->instance].ai_index].goal_objnum == objnum)
                                        slotnum++;
        }

        Assert(o != END_OF_LIST(&obj_used_list));       //      Didn't find objp in list of used ships.  Impossible!

        return slotnum;
}

#define BIGNUM  100000.0f

int Debug_k = 0;

float compute_collision_time(vec3d *targpos, vec3d *targvel, vec3d *attackpos, float weapon_speed)
{
        vec3d   vec_to_target;
        float           pos_dot_vel;
        float           vel_sqr;
        float           discrim;

        vm_vec_sub(&vec_to_target, targpos, attackpos);
        pos_dot_vel = vm_vec_dot(&vec_to_target, targvel);
        vel_sqr = vm_vec_dot(targvel, targvel) - weapon_speed*weapon_speed;
        discrim = pos_dot_vel*pos_dot_vel - vel_sqr*vm_vec_dot(&vec_to_target, &vec_to_target);

        if (discrim > 0.0f) {
                float   t1, t2, t_solve;

                t1 = (-pos_dot_vel + fl_sqrt(discrim)) / vel_sqr;
                t2 = (-pos_dot_vel - fl_sqrt(discrim)) / vel_sqr;

                t_solve = BIGNUM;

                if (t1 > 0.0f)
                        t_solve = t1;
                if ((t2 > 0.0f) && (t2 < t_solve))
                        t_solve = t2;

                if (t_solve < BIGNUM-1.0f) {
                        return t_solve + Debug_k * flFrametime;
                }
        }

        return 0.0f;
}


//      --------------------------------------------------------------------------
//      If far away, use player's speed.
//      If in between, lerp between player and laser speed
//      If close, use laser speed.
// Want to know how much time it will take to get to the enemy.
// This function doesn't account for the fact that by the time the player
// (or his laser) gets to the current enemy position, the enemy will have moved.
// This is dealt with in polish_predicted_enemy_pos.
float compute_time_to_enemy(float dist_to_enemy, object *pobjp)
{
        float   time_to_enemy;
        float   pl_speed = pobjp->phys_info.speed;
        float   max_laser_distance, max_laser_speed;
        int     bank_num, weapon_num;
        ship    *shipp = &Ships[pobjp->instance];

        bank_num = shipp->weapons.current_primary_bank;
        weapon_num = shipp->weapons.primary_bank_weapons[bank_num];
        max_laser_speed = Weapon_info[weapon_num].max_speed;
        max_laser_distance = MIN((max_laser_speed * Weapon_info[weapon_num].lifetime), Weapon_info[weapon_num].weapon_range);

        //      If pretty far away, use player's speed to predict position, else
        //      use laser's speed because when close, we care more about hitting
        //      with a laser than about causing ship:ship rendezvous.
        if (dist_to_enemy > 1.5 * max_laser_distance) {
                if (pl_speed > 0.0f)
                        time_to_enemy = dist_to_enemy/pl_speed;
                else
                        time_to_enemy = 1.0f;
        } else if (dist_to_enemy > 1.1*max_laser_distance) {
                if (pl_speed > 0.1f) {
                        float   scale;

                        scale = (float) ((dist_to_enemy - max_laser_distance) / max_laser_distance);
                
                        time_to_enemy = (float) (dist_to_enemy/(pl_speed * scale + max_laser_speed * (1.0f - scale)));
                } else
                        time_to_enemy = 2.0f;
        } else
                time_to_enemy = (float) (dist_to_enemy/max_laser_speed);

        return time_to_enemy + flFrametime;
}

//      Stuff *dot and *tts.
//      *dot is always computed.  If dot is less than zero, the magnitude is
//      incorrect, not having been divided by distance.
//      If *dot is > 0.0f, then tts is computed.  This is the time it will take object
//      *objp to get to *pos, assuming it moves right at it.
void fds_aux(float *dot, float *tts, vec3d *pos, float dtime, object *objp)
{
        vec3d   v2s;

        vm_vec_sub(&v2s, pos, &objp->pos);
        *dot = vm_vec_dot(&v2s, &objp->orient.vec.fvec);

        if (*dot > 0.0f) {
                float   dist;

                dist = vm_vec_dist(&objp->pos, pos);

                if (dist > 0.1f)
                        *dot /= dist;
                else
                        *dot = 1.0f;

                if (objp->phys_info.speed > 0.1f)
                        *tts = dist / objp->phys_info.speed;
                else
                        *tts = dist * 100.0f;
        }
}

//      --------------------------------------------------------------------------
void ai_set_positions(object *pl_objp, object *en_objp, ai_info *aip, vec3d *player_pos, vec3d *enemy_pos)
{
        *player_pos = pl_objp->pos;

        if (aip->next_predict_pos_time > Missiontime) {
                *enemy_pos = aip->last_predicted_enemy_pos;
        } else {
                *enemy_pos = en_objp->pos;

                aip->next_predict_pos_time = Missiontime + aip->ai_predict_position_delay;
                aip->last_predicted_enemy_pos = *enemy_pos;
        }


}

void ai_update_aim(ai_info *aip)
{
        if (Missiontime >= aip->next_aim_pos_time)
        {
                aip->last_aim_enemy_pos = En_objp->pos;
                aip->last_aim_enemy_vel = En_objp->phys_info.vel;
                aip->next_aim_pos_time = Missiontime + fl2f(frand_range(0.0f, aip->ai_max_aim_update_delay));
        }
        else
        {
                //Update the position based on the velocity (assume no velocity vector change)
                vm_vec_scale_add2(&aip->last_aim_enemy_pos, &aip->last_aim_enemy_vel, flFrametime);
        }
}

//      Given an ai_info struct, by reading current goal and path information,
//      extract base path information and return in pmp and pmpv.
//      Return true if found, else return false.
//      false means the current point is not on the original path.
int get_base_path_info(int path_cur, int goal_objnum, model_path **pmp, mp_vert **pmpv)
{
        pnode                   *pn = &Path_points[path_cur];
        ship *shipp = &Ships[Objects[goal_objnum].instance];
        polymodel       *pm = model_get(Ship_info[shipp->ship_info_index].model_num);
        
        *pmpv = NULL;
        *pmp = NULL;

        if (pn->path_num != -1) {
                *pmp = &pm->paths[pn->path_num];
                if (pn->path_index != -1)
                        *pmpv = &(*pmp)->verts[pn->path_index];
                else
                        return 0;
        } else
                return 0;

        return 1;
}

//      Modify, in place, the points in a global model path.
//      Only modify those points that are defined in the model path.  Don't modify the
//      leadin points, such as those that are necessary to get the model on the path.
void modify_model_path_points(object *objp)
{       
        ai_info         *aip = &Ai_info[Ships[objp->instance].ai_index];
        object          *mobjp = &Objects[aip->path_objnum];
        polymodel       *pm = model_get(Ship_info[Ships[mobjp->instance].ship_info_index].model_num);
        pnode                   *pnp;
        int                     path_num, dir;

        Assert((aip->path_start >= 0) && (aip->path_start < MAX_PATH_POINTS));

        pnp = &Path_points[aip->path_start];
        while ((pnp->path_index == -1) && (pnp-Path_points - aip->path_start < aip->path_length))
                pnp++;

        path_num = pnp->path_num;
        Assert((path_num >= 0) && (path_num < pm->n_paths));
        
        Assert(pnp->path_index != -1);  //      If this is -1, that means we never found the model path points

        dir = 1;
        if ( aip->ai_flags & AIF_USE_EXIT_PATH ) {
                dir = -1;
        }

        copy_xlate_model_path_points(mobjp, &pm->paths[path_num], dir, pm->paths[path_num].nverts, path_num, pnp);
}

//      Return an indication of the distance between two matrices.
//      This is the sum of the distances of their dot products from 1.0f.
float ai_matrix_dist(matrix *mat1, matrix *mat2)
{
        float   t;

        t =  1.0f - vm_vec_dot(&mat1->vec.fvec, &mat2->vec.fvec);
        t += 1.0f - vm_vec_dot(&mat1->vec.uvec, &mat2->vec.uvec);
        t += 1.0f - vm_vec_dot(&mat1->vec.rvec, &mat2->vec.rvec);

        return t;
}


//      Paths are created in absolute space, so a moving object needs to have model paths within it recreated.
//      This uses the hash functions which means the slightest movement will cause a recreate, though the timestamp
//      prevents this from happening too often.
//      force_recreate_flag TRUE means to recreate regardless of timestamp.
//      Returns TRUE if path recreated.
float maybe_recreate_path(object *objp, ai_info *aip, int force_recreate_flag, int override_hash = 0)
{
        int     hashval;

        Assert(&Ai_info[Ships[objp->instance].ai_index] == aip);

        if ((aip->mode == AIM_BAY_EMERGE) || (aip->mode == AIM_BAY_DEPART))
                if ((OBJ_INDEX(objp) % 4) == (Framecount % 4))
                        force_recreate_flag = 1;

        //      If no path, that means we don't need one.
        if (aip->path_start == -1)
                return 0.0f;

        // AL 11-12-97: If AIF_USE_STATIC_PATH is set, don't try to recreate.  This is needed when ships
        //                                  emerge from fighter bays.  We don't need to recreate the path.. and in case the 
        //              parent ship dies, we still want to be able to continue on the path
        if ( aip->ai_flags & AIF_USE_STATIC_PATH ) 
                return 0.0f;

        if (force_recreate_flag || timestamp_elapsed(aip->path_next_create_time)) {
                object  *path_objp;

                path_objp = &Objects[aip->path_objnum];
                hashval = create_object_hash(path_objp);

                if (override_hash || (hashval != aip->path_goal_obj_hash)) {
                        float dist;
                        
                        dist = vm_vec_dist_quick(&path_objp->pos, &aip->path_create_pos);
                        dist += ai_matrix_dist(&path_objp->orient, &aip->path_create_orient) * 25.0f;

                        if (force_recreate_flag || (dist > 2.0f)) {
                                aip->path_next_create_time = timestamp(1000);   //      Update again in as little as 1000 milliseconds, ie 1 second.
                                aip->path_goal_obj_hash = hashval;
                                modify_model_path_points(objp);

                                aip->path_create_pos = path_objp->pos;
                                aip->path_create_orient = path_objp->orient;
                
                                //Get path departure orientation from ships.tbl if it exists, otherwise zero it
                                ship_info *osip = &Ship_info[Ships[path_objp->instance].ship_info_index];
                                model_path      *mp = &model_get(osip->model_num)->paths[aip->mp_index];
                                SCP_string pathName(mp->name);
                                if (osip->pathMetadata.find(pathName) != osip->pathMetadata.end() && !IS_VEC_NULL(&osip->pathMetadata[pathName].departure_rvec))
                                {
                                        vm_vec_copy_normalize(&aip->path_depart_orient, &osip->pathMetadata[pathName].departure_rvec);
                                }
                                else
                                {
                                        vm_vec_zero(&aip->path_depart_orient);
                                }

                                return dist;
                        }
                }
        }

        return 0.0f;
}

void set_accel_for_docking(object *objp, ai_info *aip, float dot, float dot_to_next, float dist_to_next, float dist_to_goal, ship_info *sip, float max_allowed_speed, object *gobjp)
{
        float prev_dot_to_goal = aip->prev_dot_to_goal;
        
        aip->prev_dot_to_goal = dot;

        if (objp->phys_info.speed < 0.0f) {
                accelerate_ship(aip, 1.0f/32.0f);
        } else if ((prev_dot_to_goal-dot) > 0.01) {
                if (prev_dot_to_goal > dot + 0.05f) {
                        accelerate_ship(aip, 0.0f);
                } else {
                        change_acceleration(aip, -1.0f);        //      -1.0f means subtract off flFrametime from acceleration value in 0.0..1.0
                }
        } else {
                float max_bay_speed = sip->max_speed;

                // Maybe gradually ramp up/down the speed of a ship flying a fighterbay path
                if (aip->mode == AIM_BAY_EMERGE || (aip->mode == AIM_BAY_DEPART && aip->path_cur != aip->path_start)) {
                        ship_info *gsip = &Ship_info[Ships[gobjp->instance].ship_info_index];
                        polymodel *pm = model_get(gsip->model_num);
                        SCP_string pathName(pm->paths[Path_points[aip->path_start].path_num].name);
                        float speed_mult = FLT_MIN;

                        if (aip->mode == AIM_BAY_EMERGE) { // Arriving
                                if (gsip->pathMetadata.find(pathName) != gsip->pathMetadata.end()) {
                                        speed_mult = gsip->pathMetadata[pathName].arrive_speed_mult;
                                }

                                if (speed_mult == FLT_MIN) {
                                        speed_mult = The_mission.ai_profile->bay_arrive_speed_mult;
                                }
                        } else { // Departing
                                if (gsip->pathMetadata.find(pathName) != gsip->pathMetadata.end()) {
                                        speed_mult = gsip->pathMetadata[pathName].depart_speed_mult;
                                }

                                if (speed_mult == FLT_MIN) {
                                        speed_mult = The_mission.ai_profile->bay_depart_speed_mult;
                                }
                        }

                        if (speed_mult != FLT_MIN && speed_mult != 1.0f) {
                                // We use the distance between the first and last point on the path here; it's not accurate
                                // if the path is not straight, but should be good enough usually; can be changed if necessary.
                                float total_path_length = vm_vec_dist_quick(&Path_points[aip->path_start].pos, &Path_points[aip->path_start + aip->path_length - 1].pos);
                                float dist_to_end;

                                if (aip->mode == AIM_BAY_EMERGE) { // Arriving
                                        dist_to_end = vm_vec_dist_quick(&Pl_objp->pos, &Path_points[aip->path_start].pos);
                                } else { // Departing
                                        dist_to_end = vm_vec_dist_quick(&Pl_objp->pos, &Path_points[aip->path_start + aip->path_length - 1].pos);
                                }

                                // Calculate max speed, but respect the waypoint speed cap if it's lower
                                max_bay_speed = sip->max_speed * (speed_mult + (1.0f - speed_mult) * (dist_to_end / total_path_length));
                        }
                }

                // Cap speed to max_allowed_speed, if it's set
                if (max_allowed_speed <= 0)
                        max_allowed_speed = max_bay_speed;
                else
                        max_allowed_speed = MIN(max_allowed_speed, max_bay_speed);

                if ((aip->mode == AIM_DOCK) && (dist_to_next < 150.0f) && (aip->path_start + aip->path_length - 2 == aip->path_cur)) {
                        set_accel_for_target_speed(objp, max_allowed_speed * MAX(dist_to_next/500.0f, 1.0f));
                } else if ((dot_to_next >= dot * .9) || (dist_to_next > 100.0f)) {
                        if (dist_to_goal > 200.0f) {
                                set_accel_for_target_speed(objp, max_allowed_speed * (dot + 1.0f) / 2.0f);
                        }
                        else {
                                float   xdot;

                                xdot = (dot_to_next + dot)/2.0f;
                                if (xdot < 0.0f)
                                        xdot = 0.0f;

                                // AL: if following a path not in dock mode, move full speed
                                if (( aip->mode != AIM_DOCK ) && (dot > 0.9f)) {
                                        set_accel_for_target_speed(objp, max_allowed_speed*dot*dot*dot);
                                } else {
                                        if ((aip->path_cur - aip->path_start < aip->path_length-2) && (dist_to_goal < 2*objp->radius)) {
                                                set_accel_for_target_speed(objp, dist_to_goal/8.0f + 2.0f);
                                        } else {
                                                set_accel_for_target_speed(objp, max_allowed_speed * (2*xdot + 0.25f)/4.0f);
                                        }
                                }
                        }
                } else {
                        float   xdot;

                        xdot = MAX(dot_to_next, 0.1f);
                        if ( aip->mode != AIM_DOCK ) {
                                set_accel_for_target_speed(objp, max_allowed_speed);
                        } else {
                                float   speed;
                                if ((aip->path_cur - aip->path_start < aip->path_length-2) && (dist_to_goal < 2*objp->radius)) {
                                        speed = dist_to_goal/8.0f + 2.0f;
                                } else if (dist_to_goal < 4*objp->radius + 50.0f) {
                                        speed = dist_to_goal/4.0f + 4.0f;
                                } else {
                                        speed = max_allowed_speed * (3*xdot + 1.0f)/4.0f;
                                }
                                if (aip->mode == AIM_DOCK) {
                                        speed = speed * 2.0f + 1.0f;
                                        if (aip->goal_objnum != -1) {
                                                speed += Objects[aip->goal_objnum].phys_info.speed;
                                        }
                                }

                                set_accel_for_target_speed(objp, speed);
                        }
                }
        }
}

//      --------------------------------------------------------------------------
//      Follow a path associated with a large object, such as a capital ship.
//      The points defined on the path are in the object's reference frame.
//      The object of interest is goal_objnum.
//      The paths are defined in the model.  The path of interest is wp_list.
//      The next goal point in the path is wp_index.
//      wp_flags contain special information specific to the path.

// The path vertices are defined by model_path structs:
//              typedef struct model_path {
//                      char            name[MAX_NAME_LEN];                                     // name of the subsystem.  Probably displayed on HUD
//                      int             nverts;
//                      vec3d   *verts;
//              } model_path;

//      The polymodel struct for the object contains the following:
//              int                     n_paths;
//              model_path      *paths;

//      Returns distance to goal point.
float ai_path_0()
{
        int             num_points;
        float           dot, dist_to_goal, dist_to_next, dot_to_next;
        ship            *shipp = &Ships[Pl_objp->instance];
        ship_info       *sip = &Ship_info[shipp->ship_info_index];
        ai_info *aip;
        vec3d   nvel_vec;
        float           mag;
        vec3d   temp_vec, *slop_vec;
        object  *gobjp;
        vec3d   *cvp, *nvp, next_vec, gcvp, gnvp;               //      current and next vertices in global coordinates.

        aip = &Ai_info[Ships[Pl_objp->instance].ai_index];

        Assert(aip->goal_objnum != -1);
        Assert(Objects[aip->goal_objnum].type == OBJ_SHIP);

        gobjp = &Objects[aip->goal_objnum];

        if (aip->path_start == -1) {
                Assert(aip->goal_objnum >= 0 && aip->goal_objnum < MAX_OBJECTS);
                int path_num;
                Assert(aip->active_goal >= 0);
                ai_goal *aigp = &aip->goals[aip->active_goal];
                Assert(aigp->flags & AIGF_DOCK_INDEXES_VALID);

                path_num = ai_return_path_num_from_dockbay(&Objects[aip->goal_objnum], aigp->dockee.index);
                ai_find_path(Pl_objp, aip->goal_objnum, path_num, 0);
        }

        maybe_recreate_path(Pl_objp, aip, 0);

        num_points = aip->path_length;

        //      Set cvp and nvp as pointers to current and next vertices of interest on path.
        cvp = &Path_points[aip->path_cur].pos;
        if ((aip->path_cur + aip->path_dir - aip->path_start < num_points) || (aip->path_cur + aip->path_dir < aip->path_start))
                nvp = &Path_points[aip->path_cur + aip->path_dir].pos;
        else {
                //      If this is 0, then path length must be 1 which means we have no direction!
                Assert((aip->path_cur - aip->path_dir >= aip->path_start) && (aip->path_cur - aip->path_dir - aip->path_start < num_points));
                //      Cleanup for above Assert() which we hit too near release. -- MK, 5/24/98.
                if (aip->path_cur - aip->path_dir - aip->path_start >= num_points) {
                        if (aip->path_dir == 1)
                                aip->path_cur = aip->path_start;
                        else
                                aip->path_cur = aip->path_start + num_points - 1;
                }

                vec3d   delvec;
                vm_vec_sub(&delvec, cvp, &Path_points[aip->path_cur - aip->path_dir].pos);
                vm_vec_normalize(&delvec);
                vm_vec_scale_add(&next_vec, cvp, &delvec, 10.0f);
                nvp = &next_vec;
        }

        //      See if can reach next point (as opposed to current point)
        //      However, don't do this if docking and next point is last point.
        //      That is, we don't want to pursue the last point under control of the
        //      path code.  In docking, this is a special hack.
        if ((aip->mode != AIM_DOCK) || ((aip->path_cur-aip->path_start) < num_points - 2)) {
                if ((aip->path_cur + aip->path_dir > aip->path_start) && (aip->path_cur + aip->path_dir < aip->path_start + num_points-2)) {
                        if ( timestamp_elapsed(aip->path_next_check_time)) {
                                aip->path_next_check_time = timestamp( 3000 );
                                if (!pp_collide(&Pl_objp->pos, nvp, gobjp, 1.1f * Pl_objp->radius)) {
                                        cvp = nvp;
                                        aip->path_cur += aip->path_dir;
                                        nvp = &Path_points[aip->path_cur].pos;
                                }
                        }
                }
        }

        gcvp = *cvp;
        gnvp = *nvp;

        dist_to_goal = vm_vec_dist_quick(&Pl_objp->pos, &gcvp);
        dist_to_next = vm_vec_dist_quick(&Pl_objp->pos, &gnvp);
        //      Can't use fvec, need to use velocity vector because we aren't necessarily
        //      moving in the direction we're facing.

        if ( vm_vec_mag_quick(&Pl_objp->phys_info.vel) < AICODE_SMALL_MAGNITUDE ) {
                mag = 0.0f;
                vm_vec_zero(&nvel_vec);
        } else
                mag = vm_vec_copy_normalize(&nvel_vec, &Pl_objp->phys_info.vel);

        //      If moving not-very-slowly and sliding, then try to slide at goal, rather than
        //      point at goal.
        slop_vec = NULL;
        if (mag < 1.0f)
                nvel_vec = Pl_objp->orient.vec.fvec;
        else if (mag > 5.0f) {
                float   nv_dot;
                nv_dot = vm_vec_dot(&Pl_objp->orient.vec.fvec, &nvel_vec);
                if ((nv_dot > 0.5f) && (nv_dot < 0.97f)) {
                        slop_vec = &temp_vec;
                        vm_vec_sub(slop_vec, &nvel_vec, &Pl_objp->orient.vec.fvec);
                }
        }

        if (dist_to_goal > 0.1f)
                ai_turn_towards_vector(&gcvp, Pl_objp, flFrametime, sip->srotation_time, slop_vec, NULL, 0.0f, 0);

        //      Code to control speed is MUCH less forgiving in path following than in waypoint
        //      following.  Must be very close to path or might hit objects.
        dot = vm_vec_dot_to_point(&nvel_vec, &Pl_objp->pos, &gcvp);
        dot_to_next = vm_vec_dot_to_point(&nvel_vec, &Pl_objp->pos, &gnvp);

        set_accel_for_docking(Pl_objp, aip, dot, dot_to_next, dist_to_next, dist_to_goal, sip, 0, gobjp);
        aip->prev_dot_to_goal = dot;

        //      If moving at a non-tiny velocity, detect attaining path point by its being close to
        //      line between previous and current object location.
        if ((dist_to_goal < MIN_DIST_TO_WAYPOINT_GOAL) || (vm_vec_dist_quick(&Pl_objp->last_pos, &Pl_objp->pos) > 0.1f)) {
                vec3d   nearest_point;
                float           r, min_dist_to_goal;

                r = find_nearest_point_on_line(&nearest_point, &Pl_objp->last_pos, &Pl_objp->pos, &gcvp);

                //      Set min_dist_to_goal = how close must be to waypoint to pick next one.
                //      If docking and this is the second last waypoint, must be very close.
                if ((aip->mode == AIM_DOCK) && (aip->path_cur >= aip->path_length-2))
                        min_dist_to_goal = MIN_DIST_TO_WAYPOINT_GOAL;
                else
                        min_dist_to_goal = MIN_DIST_TO_WAYPOINT_GOAL + Pl_objp->radius;

                if ( (vm_vec_dist_quick(&Pl_objp->pos, &gcvp) < min_dist_to_goal) ||
                        (((r >= 0.0f) && (r <= 1.0f)) && (vm_vec_dist_quick(&nearest_point, &gcvp) < (MIN_DIST_TO_WAYPOINT_GOAL + Pl_objp->radius)))) {
                        aip->path_cur += aip->path_dir;
                        if (((aip->path_cur - aip->path_start) > (num_points+1)) || (aip->path_cur < aip->path_start)) {
                                Assert(aip->mode != AIM_DOCK);          //      If docking, should never get this far, getting to last point handled outside ai_path()
                                aip->path_dir = -aip->path_dir;
                        }
                }
        }

        return dist_to_goal;
}

//      --------------------------------------------------------------------------
//      Alternate version of ai_path
//  1. 
float ai_path_1()
{
        int             num_points;
        float           dot, dist_to_goal, dist_to_next, dot_to_next;
        ship            *shipp = &Ships[Pl_objp->instance];
        ship_info       *sip = &Ship_info[shipp->ship_info_index];
        ai_info *aip;
        vec3d   nvel_vec;
        float           mag;
        object  *gobjp;
        vec3d   *pvp, *cvp, *nvp, next_vec, gpvp, gcvp, gnvp;           //      previous, current and next vertices in global coordinates.

        aip = &Ai_info[Ships[Pl_objp->instance].ai_index];

        Assert(aip->goal_objnum != -1);
        Assert(Objects[aip->goal_objnum].type == OBJ_SHIP);

        gobjp = &Objects[aip->goal_objnum];

        if (aip->path_start == -1) {
                Assert(aip->goal_objnum >= 0 && aip->goal_objnum < MAX_OBJECTS);
                int path_num;
                Assert(aip->active_goal >= 0);
                ai_goal *aigp = &aip->goals[aip->active_goal];
                Assert(aigp->flags & AIGF_DOCK_INDEXES_VALID);

                path_num = ai_return_path_num_from_dockbay(&Objects[aip->goal_objnum], aigp->dockee.index);
                ai_find_path(Pl_objp, aip->goal_objnum, path_num, 0);
        }

        maybe_recreate_path(Pl_objp, aip, 0);

        num_points = aip->path_length;

        //      Set cvp and nvp as pointers to current and next vertices of interest on path.
        cvp = &Path_points[aip->path_cur].pos;
        if ((aip->path_cur + aip->path_dir - aip->path_start < num_points) || (aip->path_cur + aip->path_dir < aip->path_start))
                nvp = &Path_points[aip->path_cur + aip->path_dir].pos;
        else {
                //      If this is 0, then path length must be 1 which means we have no direction!
                Assert((aip->path_cur - aip->path_dir >= aip->path_start) && (aip->path_cur - aip->path_dir - aip->path_start < num_points));
                //      Cleanup for above Assert() which we hit too near release. -- MK, 5/24/98.
                if (aip->path_cur - aip->path_dir - aip->path_start >= num_points) {
                        if (aip->path_dir == 1)
                                aip->path_cur = aip->path_start;
                        else
                                aip->path_cur = aip->path_start + num_points - 1;
                }

                vec3d   delvec;
                vm_vec_sub(&delvec, cvp, &Path_points[aip->path_cur - aip->path_dir].pos);
                vm_vec_normalize(&delvec);
                vm_vec_scale_add(&next_vec, cvp, &delvec, 10.0f);
                nvp = &next_vec;
        }
        // Set pvp to the previous vertex of interest on the path (if there is one)
        int prev_point = aip->path_cur - aip->path_dir;
        if (prev_point >= aip->path_start && prev_point <= aip->path_start + num_points)
                pvp = &Path_points[prev_point].pos;
        else
                pvp = NULL;

        gpvp = (pvp != NULL) ? *pvp : *cvp;
        gcvp = *cvp;
        gnvp = *nvp;

        dist_to_goal = vm_vec_dist_quick(&Pl_objp->pos, &gcvp);
        dist_to_next = vm_vec_dist_quick(&Pl_objp->pos, &gnvp);

        //      Can't use fvec, need to use velocity vector because we aren't necessarily
        //      moving in the direction we're facing.
        if ( vm_vec_mag_quick(&Pl_objp->phys_info.vel) < AICODE_SMALL_MAGNITUDE ) {
                mag = 0.0f;
                vm_vec_zero(&nvel_vec);
        } else
                mag = vm_vec_copy_normalize(&nvel_vec, &Pl_objp->phys_info.vel);

        if (mag < 1.0f)
                nvel_vec = Pl_objp->orient.vec.fvec;

        // For departures, optionally rotate so the ship is pointing the correct direction
        // (so you can always have "wheels-down" landings)
        vec3d rvec;
        vec3d *prvec = NULL;
        if ( aip->mode == AIM_BAY_DEPART && !IS_VEC_NULL(&aip->path_depart_orient) ) {
                vm_vec_unrotate(&rvec, &aip->path_depart_orient, &Objects[aip->path_objnum].orient);
                prvec = &rvec;
        }

        // Turn toward a point between where we are on the path and the goal. This helps keep the ship flying
        // "down the line"
        if (dist_to_goal > 0.1f) {
                //Get nearest point on line between current and previous path points
                vec3d closest_point;
                float r = find_nearest_point_on_line(&closest_point, &gpvp, &gcvp, &Pl_objp->pos);
 
                //Turn towards the 1/3 point between the closest point on the line and the current goal point 
                //(unless we are already past the current goal)
                if (r <= 1.0f) {
                        vec3d midpoint;
                        vm_vec_avg3(&midpoint, &gcvp, &closest_point, &closest_point);
                        ai_turn_towards_vector(&midpoint, Pl_objp, flFrametime, sip->srotation_time, NULL, NULL, 0.0f, 0, prvec);
                }
                else {
                        ai_turn_towards_vector(&gcvp, Pl_objp, flFrametime, sip->srotation_time, NULL, NULL, 0.0f, 0, prvec);
                }
        }

        //      Code to control speed is MUCH less forgiving in path following than in waypoint
        //      following.  Must be very close to path or might hit objects.
        dot = vm_vec_dot_to_point(&nvel_vec, &Pl_objp->pos, &gcvp);
        dot_to_next = vm_vec_dot_to_point(&nvel_vec, &Pl_objp->pos, &gnvp);

        // This path mode respects the "cap-waypoint-speed" SEXP
        float max_allowed_speed = 0.0f;
        if ( aip->waypoint_speed_cap > 0) {
                max_allowed_speed = (float) aip->waypoint_speed_cap;
        }

        set_accel_for_docking(Pl_objp, aip, dot, dot_to_next, dist_to_next, dist_to_goal, sip, max_allowed_speed, gobjp);
        aip->prev_dot_to_goal = dot;

        //      If moving at a non-tiny velocity, detect attaining path point by its being close to
        //      line between previous and current object location.
        if ((dist_to_goal < MIN_DIST_TO_WAYPOINT_GOAL) || (vm_vec_dist_quick(&Pl_objp->last_pos, &Pl_objp->pos) > 0.1f)) {
                vec3d   nearest_point;
                float           r, min_dist_to_goal;

                r = find_nearest_point_on_line(&nearest_point, &Pl_objp->last_pos, &Pl_objp->pos, &gcvp);

                //      Set min_dist_to_goal = how close must be to waypoint to pick next one.
                //      If docking and this is the second last waypoint, must be very close.
                if ((aip->mode == AIM_DOCK) && (aip->path_cur - aip->path_start >= aip->path_length-1)) {
                        min_dist_to_goal = MIN_DIST_TO_WAYPOINT_GOAL;
                }
                //  If this is not the last waypoint, include a term to compensate for inertia
                else if (aip->path_cur - aip->path_start < aip->path_length - (aip->mode == AIM_DOCK ? 0 : 1)) {
                        vec3d cp_rel;
                        vm_vec_sub(&cp_rel, &gcvp, &Pl_objp->pos);
                        float goal_mag = 0.0f;
                        if (vm_vec_mag(&cp_rel) > 0.0f) {
                                vm_vec_normalize(&cp_rel);
                                goal_mag = vm_vec_dot(&Pl_objp->phys_info.vel, &cp_rel);
                        }
                        min_dist_to_goal = MIN_DIST_TO_WAYPOINT_GOAL + Pl_objp->radius + (goal_mag * sip->damp);
                }
                else {
                        min_dist_to_goal = MIN_DIST_TO_WAYPOINT_GOAL + Pl_objp->radius;
                }

                if ( (vm_vec_dist_quick(&Pl_objp->pos, &gcvp) < min_dist_to_goal) ||
                        (((r >= 0.0f) && (r <= 1.0f)) && (vm_vec_dist_quick(&nearest_point, &gcvp) < (MIN_DIST_TO_WAYPOINT_GOAL + Pl_objp->radius)))) {
                        aip->path_cur += aip->path_dir;
                        if (((aip->path_cur - aip->path_start) > (num_points+1)) || (aip->path_cur < aip->path_start)) {
                                Assert(aip->mode != AIM_DOCK);          //      If docking, should never get this far, getting to last point handled outside ai_path()
                                aip->path_dir = -aip->path_dir;
                        }
                }
        }

        return dist_to_goal;
}

float ai_path()
{
        switch (The_mission.ai_profile->ai_path_mode)
        {
        case AI_PATH_MODE_NORMAL:
                return ai_path_0();
                break;
        case AI_PATH_MODE_ALT1:
                return ai_path_1();
                break;
        default:
                Error(LOCATION, "Invalid path mode found: %d\n", The_mission.ai_profile->ai_path_mode);
                return ai_path_0();
        }
}

// Only needed because CLAMP() doesn't handle pointers
void update_min_max(float val, float *min, float *max)
{
        if (val < *min)
                *min = val;
        else if (val > *max)
                *max = val;
}

//      Stuff bounding box of all enemy objects within "range" units of object *my_objp.
//      Stuff ni min_vec and max_vec.
//      Return value: Number of enemy objects in bounding box.
int get_enemy_team_range(object *my_objp, float range, int enemy_team_mask, vec3d *min_vec, vec3d *max_vec)
{
        object  *objp;
        ship_obj        *so;
        int             count = 0;

        for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
                objp = &Objects[so->objnum];
                if (iff_matches_mask(Ships[objp->instance].team, enemy_team_mask)) {
                        if (Ship_info[Ships[objp->instance].ship_info_index].flags & (SIF_FIGHTER | SIF_BOMBER | SIF_CRUISER | SIF_CAPITAL | SIF_SUPERCAP | SIF_DRYDOCK | SIF_CORVETTE | SIF_AWACS | SIF_GAS_MINER))
                                if (vm_vec_dist_quick(&my_objp->pos, &objp->pos) < range) {
                                        if (count == 0) {
                                                *min_vec = objp->pos;
                                                *max_vec = objp->pos;
                                                count++;
                                        } else {
                                                update_min_max(objp->pos.xyz.x, &min_vec->xyz.x, &max_vec->xyz.x);
                                                update_min_max(objp->pos.xyz.y, &min_vec->xyz.y, &max_vec->xyz.y);
                                                update_min_max(objp->pos.xyz.z, &min_vec->xyz.z, &max_vec->xyz.z);
                                        }
                                }

                }
        }

        return count;
}

//      Pick a relatively safe spot for objp to fly to.
//      Problem:
//              Finds a spot away from any enemy within a bounding box.
//              Doesn't verify that "safe spot" is not near some other enemy.
void ai_safety_pick_spot(object *objp)
{
        int             objnum;
        int             enemy_team_mask;
        vec3d   min_vec, max_vec;
        vec3d   vec_to_center, center;
        vec3d   goal_pos;

        objnum = OBJ_INDEX(objp);

        enemy_team_mask = iff_get_attacker_mask(obj_team(&Objects[objnum]));

        if (get_enemy_team_range(objp, 1000.0f, enemy_team_mask, &min_vec, &max_vec)) {
                vm_vec_avg(&center, &min_vec, &max_vec);
                vm_vec_normalized_dir(&vec_to_center, &center, &objp->pos);

                vm_vec_scale_add(&goal_pos, &center, &vec_to_center, 2000.0f);
        } else
                vm_vec_scale_add(&goal_pos, &objp->pos, &objp->orient.vec.fvec, 100.0f);

        Ai_info[Ships[objp->instance].ai_index].goal_point = goal_pos;
}

//      Fly to desired safe point.
// Returns distance to that point.
float ai_safety_goto_spot(object *objp)
{
        float   dot, dist;
        ai_info *aip;
        vec3d   vec_to_goal;
        ship_info       *sip;
        float   dot_val;

        sip = &Ship_info[Ships[objp->instance].ship_info_index];

        aip = &Ai_info[Ships[objp->instance].ai_index];
        dist = vm_vec_normalized_dir(&vec_to_goal, &aip->goal_point, &objp->pos);
        dot = vm_vec_dot(&vec_to_goal, &objp->orient.vec.fvec);

        dot_val = (1.1f + dot) / 2.0f;
        if (dist > 200.0f) {
                set_accel_for_target_speed(objp, sip->max_speed * dot_val);
        } else
                set_accel_for_target_speed(objp, sip->max_speed * dot_val * (dist/200.0f + 0.2f));

        return dist;
}

void ai_safety_circle_spot(object *objp)
{
        vec3d   goal_point;
        ship_info       *sip;
        float           dot;

        sip = &Ship_info[Ships[objp->instance].ship_info_index];

        goal_point = Ai_info[Ships[objp->instance].ai_index].goal_point;
        dot = turn_towards_tangent(objp, &goal_point, 250.0f);  //      Increased from 50 to 250 to make circling not look so wacky.

        set_accel_for_target_speed(objp, 0.5f * (1.0f + dot) * sip->max_speed/4.0f);
}

//      --------------------------------------------------------------------------
void ai_safety()
{
        ai_info *aip;

        aip = &Ai_info[Ships[Pl_objp->instance].ai_index];

        switch (aip->submode) {
        case AISS_1:
                ai_safety_pick_spot(Pl_objp);
                aip->submode = AISS_2;
                aip->submode_start_time = Missiontime;
                break;
        case AISS_1a:   //      Pick a safe point because we just got whacked!
                Int3();
                break;
        case AISS_2:
                if (ai_safety_goto_spot(Pl_objp) < 25.0f) {
                        aip->submode = AISS_3;
                        aip->submode_start_time = Missiontime;
                }
                break;
        case AISS_3:
                ai_safety_circle_spot(Pl_objp);
                break;
        default:
                Int3();         //      Illegal submode for ai_safety();
                break;
        }
}


//      --------------------------------------------------------------------------
// make Pl_objp fly to its target's position
// optionally returns true if Pl_objp (pl_done_p) has reached the target position (can be NULL)
// optionally returns true if Pl_objp's (pl_treat_as_ship_p) fly to order was issued to him directly,
// or if the order was issued to his wing (returns false) (can be NULL, and result is only
// valid if Pl_done_p was not NULL and was set true by function.
void ai_fly_to_target_position(vec3d* target_pos, bool* pl_done_p=NULL, bool* pl_treat_as_ship_p=NULL)
{
        float           dot, dist_to_goal;
        ship            *shipp = &Ships[Pl_objp->instance];
        ship_info       *sip = &Ship_info[shipp->ship_info_index];
        ai_info *aip;
        vec3d   nvel_vec;
        float           mag;
        float           prev_dot_to_goal;
        vec3d   temp_vec;
        vec3d   *slop_vec;
        int j;
        bool ab_allowed = true;

        Assert( target_pos != NULL );

        if ( pl_done_p != NULL ) {
                // initialize this to false now incase we leave early so that that
                // the caller of this function doesn't get any funny ideas about
                // the status of the waypoint
                *pl_done_p = false;
        }

        aip = &Ai_info[Ships[Pl_objp->instance].ai_index];

        /* I shouldn't be flying to position for what ever called me any more.
        Set mode to none so that default dynamic behaviour gets started up again. */
        if ( (aip->active_goal == AI_GOAL_NONE) || (aip->active_goal == AI_ACTIVE_GOAL_DYNAMIC) ) {
                aip->mode = AIM_NONE;
        }

        dist_to_goal = vm_vec_dist_quick(&Pl_objp->pos, target_pos);

        //      Can't use fvec, need to use velocity vector because we aren't necessarily
        //      moving in the direction we're facing.
        // AL 23-3-98: Account for very small velocities by checking result of vm_vec_mag().
        //                                      If we don't vm_vec_copy_normalize() will think it is normalizing a null vector.
        if ( vm_vec_mag_quick(&Pl_objp->phys_info.vel) < AICODE_SMALL_MAGNITUDE ) {
                mag = 0.0f;
                vm_vec_zero(&nvel_vec);
        } else {
                mag = vm_vec_copy_normalize(&nvel_vec, &Pl_objp->phys_info.vel);
        }

        //      If moving not-very-slowly and sliding, then try to slide at goal, rather than
        //      point at goal.
        slop_vec = NULL;
        if (mag < 1.0f) {
                nvel_vec = Pl_objp->orient.vec.fvec;
        } else if (mag > 5.0f) {
                float   nv_dot;
                nv_dot = vm_vec_dot(&Pl_objp->orient.vec.fvec, &nvel_vec);
                if ((nv_dot > 0.5f) && (nv_dot < 0.97f)) {
                        slop_vec = &temp_vec;
                        vm_vec_sub(slop_vec, &nvel_vec, &Pl_objp->orient.vec.fvec);
                }
        }

        //      If a wing leader, take turns more slowly, based on size of wing.
        int     scale;

        if (aip->wing >= 0) {
                scale = Wings[aip->wing].current_count;
                scale = (int) ((scale+1)/2);
        } else {
                scale = 1;
        }

        // ----------------------------------------------
        // if in autopilot mode make sure to not collide
        // and "keep reasonable distance" 
        // this needs to be done for ALL SHIPS not just capships STOP CHANGING THIS
        // ----------------------------------------------

        vec3d perp, goal_point;

        bool carry_flag = ((shipp->flags2 & SF2_NAVPOINT_CARRY) || ((shipp->wingnum >= 0) && (Wings[shipp->wingnum].flags & WF_NAV_CARRY)));

        if (AutoPilotEngaged)
                ab_allowed = false;

        if (AutoPilotEngaged
                && timestamp_elapsed(LockAPConv)
                && carry_flag
                && ((The_mission.flags & MISSION_FLAG_USE_AP_CINEMATICS) || (Pl_objp != Autopilot_flight_leader)) )
        {
                Assertion( Autopilot_flight_leader != NULL, "When under autopilot there must be a flight leader" );
                // snap wings into formation them into formation
                if (The_mission.flags & MISSION_FLAG_USE_AP_CINEMATICS) {
                        if (aip->wing != -1) {
                                int wing_index = get_wing_index(Pl_objp, aip->wing);
                                object *wing_leader = get_wing_leader(aip->wing);

                                if (wing_leader != Pl_objp) {
                                        // not wing leader.. get my position relative to wing leader
                                        get_absolute_wing_pos_autopilot(&goal_point, wing_leader, wing_index, aip->ai_flags & AIF_FORMATION_OBJECT);
                                } else {
                                        // Am wing leader.. get the wings position relative to the flight leader
                                        j = 1+int( (float)floor(double(autopilot_wings[aip->wing]-1)/2.0) );

                                        switch (autopilot_wings[aip->wing] % 2) {
                                                case 1: // back-left
                                                        vm_vec_copy_normalize(&perp, &Autopilot_flight_leader->orient.vec.rvec);
                                                        vm_vec_scale(&perp, -166.0f*j); // 166m is supposedly the optimal range according to tolwyn
                                                        vm_vec_add(&goal_point, &Autopilot_flight_leader->pos, &perp);
                                                        break;

                                                default: //back-right
                                                case 0:
                                                        vm_vec_copy_normalize(&perp, &Autopilot_flight_leader->orient.vec.rvec);
                                                        vm_vec_scale(&perp, 166.0f*j);
                                                        vm_vec_add(&goal_point, &Autopilot_flight_leader->pos, &perp);
                                                        break;
                                        }

                                }

                                Pl_objp->pos = goal_point;
                        }

                        vm_vec_sub(&perp, Navs[CurrentNav].GetPosition(), &Autopilot_flight_leader->pos);
                        vm_vector_2_matrix(&Pl_objp->orient, &perp, NULL, NULL);
                } else {
                        vm_vec_scale_add(&perp, &Pl_objp->pos, &Autopilot_flight_leader->phys_info.vel, 1000.0f);
                        ai_turn_towards_vector(&perp, Pl_objp, flFrametime, sip->srotation_time*3.0f*scale, slop_vec, NULL, 0.0f, 0);
                }
        } else {
                if (dist_to_goal > 0.1f) {
                        ai_turn_towards_vector(target_pos, Pl_objp, flFrametime, sip->srotation_time*3.0f*scale, slop_vec, NULL, 0.0f, 0);
                }
        }

        // ----------------------------------------------

        prev_dot_to_goal = aip->prev_dot_to_goal;
        dot = vm_vec_dot_to_point(&nvel_vec, &Pl_objp->pos, target_pos);
        aip->prev_dot_to_goal = dot;

        if (Pl_objp->phys_info.speed < 0.0f) {
                accelerate_ship(aip, 1.0f/32);
                ab_allowed = false;
        } else if (prev_dot_to_goal > dot+0.01f) {
                //      We are further from pointing at our goal this frame than last frame, so slow down.
                set_accel_for_target_speed(Pl_objp, Pl_objp->phys_info.speed * 0.95f);
                ab_allowed = false;
        } else if (dist_to_goal < 100.0f) {
                float slew_dot = vm_vec_dot(&Pl_objp->orient.vec.fvec, &nvel_vec);
                if (fl_abs(slew_dot) < 0.9f) {
                        accelerate_ship(aip, 0.0f);
                } else if (dot < 0.88f + 0.1f*(100.0f - dist_to_goal)/100.0f) {
                        accelerate_ship(aip, 0.0f);
                } else {
                        accelerate_ship(aip, 0.5f * dot * dot);
                }
                ab_allowed = false;
        } else {
                float   dot1;
                if (dist_to_goal < 250.0f) {
                        dot1 = dot*dot*dot;                             //      Very important to be pointing towards goal when nearby.  Note, cubing preserves sign.
                } else {
                        if (dot > 0.0f) {
                                dot1 = dot*dot;
                        } else {
                                dot1 = dot;
                        }
                }

                if (dist_to_goal > 100.0f + Pl_objp->radius * 2) {
                        if (dot < 0.2f) {
                                dot1 = 0.2f;
                        }
                }

                if (sip->flags & SIF_SMALL_SHIP) {
                        set_accel_for_target_speed(Pl_objp, dot1 * dist_to_goal/5.0f);
                } else {
                        set_accel_for_target_speed(Pl_objp, dot1 * dist_to_goal/10.0f);
                }
                if (dot1 < 0.8f)
                        ab_allowed = false;
        }

        if (!(sip->flags & SIF_AFTERBURNER) || (shipp->flags2 & SF2_AFTERBURNER_LOCKED) || !(aip->ai_flags & AIF_FREE_AFTERBURNER_USE)) {
                ab_allowed = false;
        }

        //      Make sure not travelling too fast for someone to keep up.
        float   max_allowed_speed = 9999.9f;
        float   max_allowed_ab_speed = 10000.1f;
        float   self_ab_speed = 10000.0f;

        if (shipp->wingnum != -1) {
                max_allowed_speed = 0.9f * get_wing_lowest_max_speed(Pl_objp);
                max_allowed_ab_speed = 0.95f * get_wing_lowest_av_ab_speed(Pl_objp);
                if (ab_allowed) {
                        float self_ab_scale = Energy_levels[shipp->engine_recharge_index] * 2.0f * The_mission.ai_profile->afterburner_recharge_scale[Game_skill_level];
                        self_ab_scale = sip->afterburner_recover_rate * self_ab_scale / (sip->afterburner_burn_rate + sip->afterburner_recover_rate * self_ab_scale);
                        self_ab_speed = 0.95f * (self_ab_scale * (Pl_objp->phys_info.afterburner_max_vel.xyz.z - shipp->current_max_speed) + shipp->current_max_speed);
                }
        }

        // check if waypoint speed cap is set and adjust max speed
        if (aip->waypoint_speed_cap > 0) {
                max_allowed_speed = (float) aip->waypoint_speed_cap;
                max_allowed_ab_speed = max_allowed_speed;
        }

        if ((self_ab_speed < 5.0f) || (max_allowed_ab_speed < 5.0f)){ // || ((shipp->wingnum != -1) && (dist_to_goal / max_allowed_ab_speed < 5.0f))){
                ab_allowed = false;
        } else if (max_allowed_ab_speed < shipp->current_max_speed) {
                if (max_allowed_speed < max_allowed_ab_speed) {
                        max_allowed_speed = max_allowed_ab_speed;
                } else {
                        ab_allowed = false;
                }
        }

        
        if (ab_allowed) {
                if (self_ab_speed <= (1.001 * max_allowed_ab_speed)){
                        if (!(Pl_objp->phys_info.flags & PF_AFTERBURNER_ON )) {
                                float percent_left = 100.0f * shipp->afterburner_fuel / sip->afterburner_fuel_capacity;
                                if (percent_left > 30.0f) {
                                        afterburners_start(Pl_objp);
                                        aip->afterburner_stop_time = Missiontime + 5 * F1_0;
                                }
                        }
                } else {
                        float switch_value;
                        if ((self_ab_speed - max_allowed_ab_speed) > (0.2f * max_allowed_ab_speed)) {
                                switch_value = 0.2f * max_allowed_ab_speed;
                        } else {
                                switch_value = self_ab_speed - max_allowed_ab_speed;
                        }
                        if (!(Pl_objp->phys_info.flags & PF_AFTERBURNER_ON )) {
                                float percent_left = 100.0f * shipp->afterburner_fuel / sip->afterburner_fuel_capacity;
                                if ((Pl_objp->phys_info.speed < (max_allowed_ab_speed - switch_value)) && (percent_left > 30.0f)){
                                        afterburners_start(Pl_objp);
                                        aip->afterburner_stop_time = Missiontime + 5 * F1_0;
                                }
                        } else {
                                if (Pl_objp->phys_info.speed > (max_allowed_ab_speed + 0.9 * switch_value)){
                                        afterburners_stop(Pl_objp);
                                }
                        }
                }

                if (!(Pl_objp->phys_info.flags & PF_AFTERBURNER_ON )) {
                        if (aip->prev_accel * shipp->current_max_speed > max_allowed_ab_speed) {
                                accelerate_ship(aip, max_allowed_ab_speed / shipp->current_max_speed);
                        }
                }
        } else {
                if (Pl_objp->phys_info.flags & PF_AFTERBURNER_ON ) {
                        afterburners_stop(Pl_objp);
                }
                if (aip->prev_accel * shipp->current_max_speed > max_allowed_speed) {
                        accelerate_ship(aip, max_allowed_speed / shipp->current_max_speed);
                }
        }

        if ( (dist_to_goal < MIN_DIST_TO_WAYPOINT_GOAL) || (vm_vec_dist_quick(&Pl_objp->last_pos, &Pl_objp->pos) > 0.1f) ) {
                vec3d   nearest_point;
                float           r;

                r = find_nearest_point_on_line(&nearest_point, &Pl_objp->last_pos, &Pl_objp->pos, target_pos);

                if ( (dist_to_goal < (MIN_DIST_TO_WAYPOINT_GOAL + fl_sqrt(Pl_objp->radius) + vm_vec_dist_quick(&Pl_objp->pos, &Pl_objp->last_pos)))
                        || (((r >= 0.0f) && (r <= 1.0f)) && (vm_vec_dist_quick(&nearest_point, target_pos) < (MIN_DIST_TO_WAYPOINT_GOAL + fl_sqrt(Pl_objp->radius)))))
                {
                                int treat_as_ship;

                                // we must be careful when dealing with wings.  A ship in a wing might be completing
                                // a waypoint for for the entire wing, or it might be completing a goal for itself.  If
                                // for itself and in a wing, treat the completion as we would a ship
                                treat_as_ship = 1;
                                if ( Ships[Pl_objp->instance].wingnum != -1 ) {
                                        int type;

                                        // protect array access from invalid indexes
                                        if ((aip->active_goal >= 0) && (aip->active_goal < MAX_AI_GOALS)) {
                                                type = aip->goals[aip->active_goal].type;
                                                if ( (type == AIG_TYPE_EVENT_WING) || (type == AIG_TYPE_PLAYER_WING) ) {
                                                        treat_as_ship = 0;
                                                } else {
                                                        treat_as_ship = 1;
                                                }
                                        }
                                }
                                // setup out parameters
                                if ( pl_done_p != NULL ) {
                                        *pl_done_p = true;
                                        if ( pl_treat_as_ship_p != NULL ) {
                                                if ( treat_as_ship ) {
                                                        *pl_treat_as_ship_p = true;
                                                } else {
                                                        *pl_treat_as_ship_p = false;
                                                }
                                        }
                                } else {
                                        Assertion( pl_treat_as_ship_p != NULL,
                                                "pl_done_p cannot be NULL while pl_treat_as_ship_p is not NULL" );
                                }
                }
        }
}

//      --------------------------------------------------------------------------
//      make Pl_objp fly waypoints.
void ai_waypoints()
{
        ai_info *aip = &Ai_info[Ships[Pl_objp->instance].ai_index];

        // sanity checking for stuff that should never happen
        if (aip->wp_index == INVALID_WAYPOINT_POSITION) {
                if (aip->wp_list == NULL) {
                        Warning(LOCATION, "Waypoints should have been assigned already!");
                        ai_start_waypoints(Pl_objp, &Waypoint_lists.front(), WPF_REPEAT);
                } else {
                        Warning(LOCATION, "Waypoints should have been started already!");
                        ai_start_waypoints(Pl_objp, aip->wp_list, WPF_REPEAT);
                }
        }
        
        Assert(!aip->wp_list->get_waypoints().empty()); // What? Is this zero? Probably never got initialized!

        bool done, treat_as_ship;
        ai_fly_to_target_position(aip->wp_list->get_waypoints()[aip->wp_index].get_pos(), &done, &treat_as_ship);

        if ( done ) {
                // go on to next waypoint in path
                ++aip->wp_index;

                if ( aip->wp_index == aip->wp_list->get_waypoints().size() ) {
                        // have reached the last waypoint.  Do I repeat?
                        if ( aip->wp_flags & WPF_REPEAT ) {
                                 // go back to the start.
                                aip->wp_index = 0;
                        } else {
                                // stay on the last waypoint.
                                --aip->wp_index;

                                // Log a message that the wing or ship reached his waypoint and
                                // remove the goal from the AI goals of the ship pr wing, respectively.
                                // Whether we should treat this as a ship or a wing is determined by
                                // ai_fly_to_target_position when it marks the AI directive as complete
                                if ( treat_as_ship ) {
                                        ai_mission_goal_complete( aip );                                        // this call should reset the AI mode
                                        mission_log_add_entry( LOG_WAYPOINTS_DONE, Ships[Pl_objp->instance].ship_name, aip->wp_list->get_name(), -1 );
                                } else {
                                        ai_mission_wing_goal_complete( Ships[Pl_objp->instance].wingnum, &(aip->goals[aip->active_goal]) );
                                        mission_log_add_entry( LOG_WAYPOINTS_DONE, Wings[Ships[Pl_objp->instance].wingnum].name, aip->wp_list->get_name(), -1 );
                                }
                        }
                }
        }
}

//      --------------------------------------------------------------------------
//      make Pl_objp fly toward a ship
void ai_fly_to_ship()
{
        ai_info *aip;
        object* target_p = NULL;

        aip = &Ai_info[Ships[Pl_objp->instance].ai_index];

        if ( aip->mode != AIM_FLY_TO_SHIP ) {
                Warning(LOCATION,
                        "ai_fly_to_ship called for '%s' when ai_info.mode not equal to AIM_FLY_TO_SHIP. Is actually '%d'",
                        Ships[Pl_objp->instance].ship_name,
                        aip->mode);
                aip->mode = AIM_NONE;
                return;
        }
        if ( aip->active_goal < 0 || aip->active_goal >= MAX_AI_GOALS ) {
                Warning(LOCATION,
                        "'%s' is trying to fly-to a ship without an active AI_GOAL\n\n"
                        "Active ai mode is '%d'",
                        Ships[Pl_objp->instance].ship_name,
                        aip->active_goal);
                aip->mode = AIM_NONE;
                return;
        }
        Assert( aip->goals[aip->active_goal].target_name != NULL );
        if ( aip->goals[aip->active_goal].target_name[0] == '\0' ) {
                Warning(LOCATION, "'%s' is trying to fly-to-ship without a name for the ship", Ships[Pl_objp->instance].ship_name);
                aip->mode = AIM_NONE;
                ai_remove_ship_goal( aip, aip->active_goal ); // function sets aip->active_goal to NONE for me
                return;
        }

        for (int j = 0; j < MAX_SHIPS; j++)
        {
                if (Ships[j].objnum != -1 && !stricmp(aip->goals[aip->active_goal].target_name, Ships[j].ship_name))
                {
                        target_p = &Objects[Ships[j].objnum];
                        break;
                }
        }

        if ( target_p == NULL ) {
                #ifndef NDEBUG
                for (int i = 0; i < MAX_AI_GOALS; i++)
                {
                        if (aip->mode == AIM_FLY_TO_SHIP || aip->goals[i].ai_mode == AI_GOAL_FLY_TO_SHIP)
                        {
                                mprintf(("Ship '%s' told to fly to target ship '%s'",
                                        Ships[Pl_objp->instance].ship_name,
                                        aip->goals[i].target_name));
                        }
                }
                #endif
                Warning(LOCATION, "Ship '%s' told to fly to a ship but none of the ships it was told to fly to exist.\n"
                        "See log before this message for list of ships set as fly-to tagets",
                        Ships[Pl_objp->instance].ship_name);
                aip->mode = AIM_NONE;
                ai_remove_ship_goal( aip, aip->active_goal ); // function sets aip->active_goal to NONE for me
                return;
        } else {
                bool done, treat_as_ship;
                ai_fly_to_target_position(&(target_p->pos), &done, &treat_as_ship);

                if ( done ) {
                        // remove the goal from the AI goals of the ship pr wing, respectively.
                        // Wether or not we should treat this as a ship or a wing is determined by
                        // ai_fly_to_target when it marks the AI directive as complete
                        if ( treat_as_ship ) {
                                ai_mission_goal_complete( aip );                                        // this call should reset the AI mode
                        } else {
                                ai_mission_wing_goal_complete( Ships[Pl_objp->instance].wingnum, &(aip->goals[aip->active_goal]) );
                        }
                }
        }
}

//      Make Pl_objp avoid En_objp
//      Not like evading.  This is for avoiding a collision!
//      Note, use sliding if available.
void avoid_ship()
{
        //      To avoid an object, turn towards right or left vector until facing away from object.
        //      To choose right vs. left, pick one that is further from center of avoid object.
        //      Keep turning away from until pointing away from ship.
        //      Stay in avoid mode until at least 3 enemy ship radii away.

        //      Speed setting:
        //      If inside sphere, zero speed and turn towards outside.
        //      If outside sphere, inside 2x sphere, set speed percent of max to:
        //              max(away_dot, (dist-rad)/rad)
        //      where away_dot is dot(Pl_objp->fvec, vec_En_objp_to_Pl_objp)

        vec3d   vec_to_enemy;
        float           away_dot;
        float           dist;
        ship            *shipp = &Ships[Pl_objp->instance];
        ship_info       *sip = &Ship_info[shipp->ship_info_index];
        ai_info *aip = &Ai_info[shipp->ai_index];
        vec3d   player_pos, enemy_pos;

        // if we're avoiding a stealth ship, then we know where he is, update with no error
        if ( is_object_stealth_ship(En_objp) ) {
                update_ai_stealth_info_with_error(aip/*, 1*/);
        }

        ai_set_positions(Pl_objp, En_objp, aip, &player_pos, &enemy_pos);
        vm_vec_sub(&vec_to_enemy, &enemy_pos, &Pl_objp->pos);

        dist = vm_vec_normalize(&vec_to_enemy);
        away_dot = -vm_vec_dot(&Pl_objp->orient.vec.fvec, &vec_to_enemy);
        
        if ((sip->max_vel.xyz.x > 0.0f) || (sip->max_vel.xyz.y > 0.0f)) {
                if (vm_vec_dot(&Pl_objp->orient.vec.rvec, &vec_to_enemy) > 0.0f) {
                        AI_ci.sideways = -1.0f;
                } else {
                        AI_ci.sideways = 1.0f;
                }
                if (vm_vec_dot(&Pl_objp->orient.vec.uvec, &vec_to_enemy) > 0.0f) {
                        AI_ci.vertical = -1.0f;
                } else {
                        AI_ci.vertical = 1.0f;
                }
        }               

        //      If in front of enemy, turn away from it.
        //      If behind enemy, try to get fully behind it.
        if (away_dot < 0.0f) {
                turn_away_from_point(Pl_objp, &enemy_pos, Pl_objp->phys_info.speed);
        } else {
                vec3d   goal_pos;

                vm_vec_scale_add(&goal_pos, &En_objp->pos, &En_objp->orient.vec.fvec, -100.0f);
                turn_towards_point(Pl_objp, &goal_pos, NULL, Pl_objp->phys_info.speed);
        }

        //      Set speed.
        float   radsum = Pl_objp->radius + En_objp->radius;

        if (dist < radsum)
                accelerate_ship(aip, MAX(away_dot, 0.2f));
        else if (dist < 2*radsum)
                accelerate_ship(aip, MAX(away_dot, (dist - radsum) / radsum)+0.2f);
        else
                accelerate_ship(aip, 1.0f);

}

//      Maybe it's time to resume the previous AI mode in aip->previous_mode.
//      Each type of previous_mode has its own criteria on when to resume.
//      Return true if previous mode was resumed.
int maybe_resume_previous_mode(object *objp, ai_info *aip)
{
        //      Only (maybe) resume previous goal if current goal is dynamic.
        if (aip->active_goal != AI_ACTIVE_GOAL_DYNAMIC)
                return 0;

        if (aip->mode == AIM_EVADE_WEAPON) {
                if (timestamp_elapsed(aip->mode_time) || (((aip->nearest_locked_object == -1) || (Objects[aip->nearest_locked_object].type != OBJ_WEAPON)) && (aip->danger_weapon_objnum == -1))) {
                        Assert(aip->previous_mode != AIM_EVADE_WEAPON);
                        aip->mode = aip->previous_mode;
                        aip->submode = aip->previous_submode;
                        aip->submode_start_time = Missiontime;
                        aip->active_goal = AI_GOAL_NONE;
                        aip->mode_time = -1;                    //      Means do forever.
                        return 1;
                }
        } else if ( aip->previous_mode == AIM_GUARD) {
                if ((aip->guard_objnum != -1) && (aip->guard_signature == Objects[aip->guard_objnum].signature)) {
                        object  *guard_objp;
                        float   dist;

                        guard_objp = &Objects[aip->guard_objnum];
                        dist = vm_vec_dist_quick(&guard_objp->pos, &objp->pos);

                        //      If guarding ship is far away from guardee and enemy is far away from guardee,
                        //      then stop chasing and resume guarding.
                        if (dist > (MAX_GUARD_DIST + guard_objp->radius) * 6) {
                                if ((En_objp != NULL) && (En_objp->type == OBJ_SHIP)) {
                                        if (vm_vec_dist_quick(&guard_objp->pos, &En_objp->pos) > (MAX_GUARD_DIST + guard_objp->radius) * 6) {
                                                Assert(aip->previous_mode == AIM_GUARD);
                                                aip->mode = aip->previous_mode;
                                                aip->submode = AIS_GUARD_PATROL;
                                                aip->submode_start_time = Missiontime;
                                                aip->active_goal = AI_GOAL_NONE;
                                                return 1;
                                        }
                                }
                        }
                }
        }

        return 0;

}

//      Call this function if you want something to happen on average every N quarters of a second.
//      The truth value returned by this function will be the same for any given quarter second interval.
//      The value "num" is only passed in to get asynchronous behavior for different objects.
//      modulus == 1 will always return true.
//      modulus == 2 will return true half the time.
//      modulus == 16 will return true for one quarter second interval every four seconds.
int static_rand_timed(int num, int modulus)
{
        if (modulus < 2)
                return 1;
        else {
                int     t;

                t = Missiontime >> 18;          //      Get time in quarters of a second (SUSHI: this comment is wrong! It's actually every 4 seconds!)
                t += num;

                return !(t % modulus);
        }
}

int ai_maybe_fire_afterburner(object *objp, ai_info *aip)
{
        // bail if the ship doesn't even have an afterburner
        if (!(Ship_info[Ships[objp->instance].ship_info_index].flags & SIF_AFTERBURNER)) {
                return 0;
        }
        if (aip->ai_aburn_use_factor == INT_MIN && aip->ai_class == 0) {
                return 0;               //      Lowest level never aburners away (unless ai_aburn_use_factor is specified)
        } 
        else {
                //      Maybe don't afterburner because of a potential collision with the player.
                //      If not multiplayer, near player and player in front, probably don't afterburner.
                if (!(Game_mode & GM_MULTIPLAYER)) {
                        if (Ships[objp->instance].team == Player_ship->team) {
                                float   dist;

                                dist = vm_vec_dist_quick(&objp->pos, &Player_obj->pos) - Player_obj->radius - objp->radius;
                                if (dist < 150.0f) {
                                        vec3d   v2p;
                                        float           dot;

                                        vm_vec_normalized_dir(&v2p, &Player_obj->pos, &objp->pos);
                                        dot = vm_vec_dot(&v2p, &objp->orient.vec.fvec);

                                        if (dot > 0.0f) {
                                                if (dot * dist > 50.0f)
                                                        return 0;
                                        }
                                }
                        }
                }

                if (aip->ai_aburn_use_factor == INT_MIN && aip->ai_class >= Num_ai_classes-2)
                        return 1;               //      Highest two levels always aburner away (unless ai_aburn_use_factor is specified).
                else {
                        //If ai_aburn_use_factor is not specified, calculate a number based on the AI class. Otherwise, use that value.
                        if (aip->ai_aburn_use_factor == INT_MIN)
                                return static_rand_timed(OBJ_INDEX(objp), Num_ai_classes - aip->ai_class);
                        else
                                return static_rand_timed(OBJ_INDEX(objp), aip->ai_aburn_use_factor);
                }
        }
}

void maybe_afterburner_after_ship_hit(object *objp, ai_info *aip, object *en_objp)
{
        //      Only do if facing a little away.
        if (en_objp != NULL) {
                vec3d   v2e;

                vm_vec_normalized_dir(&v2e, &en_objp->pos, &objp->pos);
                if (vm_vec_dot(&v2e, &objp->orient.vec.fvec) > -0.5f)
                        return;
        }

        if (!( objp->phys_info.flags & PF_AFTERBURNER_ON )) {
                if (ai_maybe_fire_afterburner(objp, aip)) {
                        afterburners_start(objp);
                        aip->afterburner_stop_time = Missiontime + F1_0/2;
                }
        }
}

int is_instructor(object *objp)
{
        return !strnicmp(Ships[objp->instance].ship_name, INSTRUCTOR_SHIP_NAME, strlen(INSTRUCTOR_SHIP_NAME));
}

//      Evade the weapon aip->danger_weapon_objnum
//      If it's not valid, do a quick out.
//      Evade by accelerating hard.
//      If necessary, turn hard left or hard right.
void evade_weapon()
{
        object  *weapon_objp = NULL;
        object  *unlocked_weapon_objp = NULL, *locked_weapon_objp = NULL;
        vec3d   weapon_pos, player_pos, goal_point;
        vec3d   vec_from_enemy;
        float           dot_from_enemy, dot_to_enemy;
        float           dist;
        ship            *shipp = &Ships[Pl_objp->instance];
        ai_info *aip = &Ai_info[shipp->ai_index];

        if (is_instructor(Pl_objp))
                return;

        //      Make sure we're actually being attacked.
        //      Favor locked objects.
        if (aip->nearest_locked_object != -1) {
                if (Objects[aip->nearest_locked_object].type == OBJ_WEAPON)
                        locked_weapon_objp = &Objects[aip->nearest_locked_object];
        }
        
        if (aip->danger_weapon_objnum != -1) {
                if (Objects[aip->danger_weapon_objnum].signature == aip->danger_weapon_signature)
                        unlocked_weapon_objp = &Objects[aip->danger_weapon_objnum];
                else
                        aip->danger_weapon_objnum = -1;         //      Signatures don't match, so no longer endangered.
        }

        if (locked_weapon_objp != NULL) {
                if (unlocked_weapon_objp != NULL) {
                        if (vm_vec_dist_quick(&locked_weapon_objp->pos, &Pl_objp->pos) < 1.5f * vm_vec_dist_quick(&unlocked_weapon_objp->pos, &Pl_objp->pos))
                                weapon_objp = locked_weapon_objp;
                        else
                                weapon_objp = unlocked_weapon_objp;
                } else
                        weapon_objp = locked_weapon_objp;
        } else if (unlocked_weapon_objp != NULL)
                weapon_objp = unlocked_weapon_objp;
        else {
                if (aip->mode == AIM_EVADE_WEAPON)
                        maybe_resume_previous_mode(Pl_objp, aip);
                return;
        }

        Assert(weapon_objp != NULL);

        if (weapon_objp->type != OBJ_WEAPON) {
                if (aip->mode == AIM_EVADE_WEAPON)
                        maybe_resume_previous_mode(Pl_objp, aip);
                return;
        }
        
        weapon_pos = weapon_objp->pos;
        player_pos = Pl_objp->pos;

        //      Make speed based on skill level, varying at highest skill level, which is harder to hit.
        accelerate_ship(aip, 1.0f);

        dist = vm_vec_normalized_dir(&vec_from_enemy, &player_pos, &weapon_pos);

        dot_to_enemy = -vm_vec_dot(&Pl_objp->orient.vec.fvec, &vec_from_enemy);
        dot_from_enemy = vm_vec_dot(&weapon_objp->orient.vec.fvec, &vec_from_enemy);

        //      If shot is incoming...
        if (dot_from_enemy < 0.3f) {
                if (weapon_objp == unlocked_weapon_objp)
                        aip->danger_weapon_objnum = -1;
                return;
        } else if (dot_from_enemy > 0.7f) {
                if (dist < 200.0f) {
                        if (!( Pl_objp->phys_info.flags & PF_AFTERBURNER_ON )) {
                                if (ai_maybe_fire_afterburner(Pl_objp, aip)) {
                                        afterburners_start(Pl_objp);
                                        aip->afterburner_stop_time = Missiontime + F1_0/2;
                                }
                        }
                }

                //      If we're sort of pointing towards it...
                if ((dot_to_enemy < -0.5f) || (dot_to_enemy > 0.5f)) {
                        float rdot;
                        float udot;

                        //      Turn hard left or right, depending on which gets out of way quicker.
                        //SUSHI: Also possibly turn up or down. 
                        rdot = vm_vec_dot(&Pl_objp->orient.vec.rvec, &vec_from_enemy);
                        udot = vm_vec_dot(&Pl_objp->orient.vec.uvec, &vec_from_enemy);

                        if (aip->ai_profile_flags & AIPF_ALLOW_VERTICAL_DODGE && fl_abs(udot) > fl_abs(rdot))
                        {
                                if ((udot < -0.5f) || (udot > 0.5f))
                                        vm_vec_scale_add(&goal_point, &Pl_objp->pos, &Pl_objp->orient.vec.uvec, -200.0f);
                                else
                                        vm_vec_scale_add(&goal_point, &Pl_objp->pos, &Pl_objp->orient.vec.uvec, 200.0f);
                        }
                        else
                        {
                                if ((rdot < -0.5f) || (rdot > 0.5f))
                                        vm_vec_scale_add(&goal_point, &Pl_objp->pos, &Pl_objp->orient.vec.rvec, -200.0f);
                                else
                                        vm_vec_scale_add(&goal_point, &Pl_objp->pos, &Pl_objp->orient.vec.rvec, 200.0f);
                        }

                        turn_towards_point(Pl_objp, &goal_point, NULL, 0.0f);
                }
        }

}

//      Use sliding and backwards moving to face enemy.
//      (Coded 2/20/98.  Works fine, but it's hard to see how to integrate it into the AI system.
//       Typically ships are moving so fast that a little sliding isn't enough to gain an advantage.
//       It's currently used to avoid collisions and could be used to evade weapon fire, but the latter
//       would be frustrating, I think.
//       This function is currently not called.)
void slide_face_ship()
{
        ship_info       *sip;

        sip = &Ship_info[Ships[Pl_objp->instance].ship_info_index];

        //      If can't slide, return.
        if ((sip->max_vel.xyz.x == 0.0f) && (sip->max_vel.xyz.y == 0.0f))
                return;

        vec3d   goal_pos;
        float           dot_from_enemy;
        vec3d   vec_from_enemy, vec_to_goal;
        float           dist;
        float           up, right;
        ai_info         *aip;

        aip = &Ai_info[Ships[Pl_objp->instance].ai_index];

        dist = vm_vec_normalized_dir(&vec_from_enemy, &Pl_objp->pos, &En_objp->pos);

        ai_turn_towards_vector(&En_objp->pos, Pl_objp, flFrametime, sip->srotation_time, NULL, NULL, 0.0f, 0);

        dot_from_enemy = vm_vec_dot(&vec_from_enemy, &En_objp->orient.vec.fvec);

        if (vm_vec_dot(&vec_from_enemy, &En_objp->orient.vec.rvec) > 0.0f)
                right = 1.0f;
        else
                right = -1.0f;

        if (vm_vec_dot(&vec_from_enemy, &En_objp->orient.vec.uvec) > 0.0f)
                up = 1.0f;
        else
                up = -1.0f;

        vm_vec_scale_add(&goal_pos, &En_objp->pos, &En_objp->orient.vec.rvec, right * 200.0f);
        vm_vec_scale_add(&goal_pos, &En_objp->pos, &En_objp->orient.vec.uvec, up * 200.0f);

        vm_vec_normalized_dir(&vec_to_goal, &goal_pos, &Pl_objp->pos);

        if (vm_vec_dot(&vec_to_goal, &Pl_objp->orient.vec.rvec) > 0.0f)
                AI_ci.sideways = 1.0f;
        else
                AI_ci.sideways = -1.0f;

        if (vm_vec_dot(&vec_to_goal, &Pl_objp->orient.vec.uvec) > 0.0f)
                AI_ci.vertical = 1.0f;
        else
                AI_ci.vertical = -1.0f;

        if (dist < 200.0f) {
                if (dot_from_enemy < 0.7f)
                        accelerate_ship(aip, -1.0f);
                else
                        accelerate_ship(aip, dot_from_enemy + 0.5f);
        } else {
                if (dot_from_enemy < 0.7f) {
                        accelerate_ship(aip, 0.2f);
                } else {
                        accelerate_ship(aip, 1.0f);
                }
        }
}

//      General code for handling one ship evading another.
//      Problem: This code is also used for avoiding an impending collision.
//      In such a case, it is not good to go to max speed, which is often good
//      for a certain kind of evasion.
void evade_ship()
{
        vec3d   player_pos, enemy_pos, goal_point;
        vec3d   vec_from_enemy;
        float           dot_from_enemy;
        float           dist;
        ship            *shipp = &Ships[Pl_objp->instance];
        ship_info       *sip = &Ship_info[shipp->ship_info_index];
        ai_info *aip = &Ai_info[shipp->ai_index];
        float           bank_override = 0.0f;

        ai_set_positions(Pl_objp, En_objp, aip, &player_pos, &enemy_pos);

        //      Make speed based on skill level, varying at highest skill level, which is harder to hit.
        if (Game_skill_level == NUM_SKILL_LEVELS-1) {
                int     rand_int;
                float   accel_val;

                rand_int = static_rand(OBJ_INDEX(Pl_objp));
                accel_val = (float) (((Missiontime^rand_int) >> 14) & 0x0f)/32.0f + 0.5f;
                accelerate_ship(aip, accel_val);
        } else
                accelerate_ship(aip, (float) (Game_skill_level+2) / (NUM_SKILL_LEVELS+1));

        if ((Missiontime - aip->submode_start_time > F1_0/2) && (sip->afterburner_fuel_capacity > 0.0f)) {
                float percent_left = 100.0f * shipp->afterburner_fuel / sip->afterburner_fuel_capacity;
                if (percent_left > 30.0f + ((OBJ_INDEX(Pl_objp)) & 0x0f)) {
                        afterburners_start(Pl_objp);
                
                        if (aip->ai_profile_flags & AIPF_SMART_AFTERBURNER_MANAGEMENT) {
                                aip->afterburner_stop_time = (fix) (Missiontime + F1_0 + static_randf(OBJ_INDEX(Pl_objp)) * F1_0 / 4);
                        } else {                                
                                aip->afterburner_stop_time = Missiontime + F1_0 + static_rand(OBJ_INDEX(Pl_objp))/4;
                        }
                }
        }

        vm_vec_sub(&vec_from_enemy, &player_pos, &enemy_pos);

        dist = vm_vec_normalize(&vec_from_enemy);
        dot_from_enemy = vm_vec_dot(&En_objp->orient.vec.fvec, &vec_from_enemy);

        if (dist > 250.0f) {
                vec3d   gp1, gp2;
                //      If far away from enemy, circle, going to nearer of point far off left or right wing
                vm_vec_scale_add(&gp1, &enemy_pos, &En_objp->orient.vec.rvec, 250.0f);
                vm_vec_scale_add(&gp2, &enemy_pos, &En_objp->orient.vec.rvec, -250.0f);
                if (vm_vec_dist_quick(&gp1, &Pl_objp->pos) < vm_vec_dist_quick(&gp2, &Pl_objp->pos))
                        goal_point = gp1;
                else
                        goal_point = gp2;
        } else if (dot_from_enemy < 0.1f) {
                //      If already close to behind, goal is to get completely behind.
                vm_vec_scale_add(&goal_point, &enemy_pos, &En_objp->orient.vec.fvec, -1000.0f);
        } else if (dot_from_enemy > 0.9f) {
                //      If enemy pointing almost right at self, and self pointing close to enemy, turn away from
                vec3d   vec_to_enemy;
                float           dot_to_enemy;

                vm_vec_sub(&vec_to_enemy, &enemy_pos, &player_pos);

                vm_vec_normalize(&vec_to_enemy);
                dot_to_enemy = vm_vec_dot(&Pl_objp->orient.vec.fvec, &vec_to_enemy);
                if (dot_to_enemy > 0.75f) {
                        //      Used to go to En_objp's right vector, but due to banking while turning, that
                        //      caused flying in an odd spiral.
                        vm_vec_scale_add(&goal_point, &enemy_pos, &Pl_objp->orient.vec.rvec, 1000.0f);
                        if (dist < 100.0f)
                                bank_override = Pl_objp->phys_info.speed; 
                } else {
                        bank_override = Pl_objp->phys_info.speed;                       //      In enemy's sights, not pointing at him, twirl away.
                        goto evade_ship_l1;
                }
        } else {
evade_ship_l1: ;
                if (aip->ai_evasion > myrand()*100.0f/32767.0f) {
                        int     temp;
                        float   scale;
                        float   psrandval;      //      some value close to zero to choose whether to turn right or left.

                        psrandval = (float) (((Missiontime >> 14) & 0x0f) - 8); //      Value between -8 and 7
                        psrandval = psrandval/16.0f;                                                    //      Value between -1/2 and 1/2 (approx)

                        //      If not close to behind, turn towards his right or left vector, whichever won't cross his path.
                        if (vm_vec_dot(&vec_from_enemy, &En_objp->orient.vec.rvec) > psrandval) {
                                scale = 1000.0f;
                        } else {
                                scale = -1000.0f;
                        }

                        vm_vec_scale_add(&goal_point, &enemy_pos, &En_objp->orient.vec.rvec, scale);

                        temp = ((Missiontime >> 16) & 0x07);
                        temp = ((temp * (temp+1)) % 16)/2 - 4;
                        if ((psrandval == 0) && (temp == 0))
                                temp = 3;

                        scale = 200.0f * temp;

                        vm_vec_scale_add2(&goal_point, &En_objp->orient.vec.uvec, scale);
                } else {
                        //      No evasion this frame, but continue with previous turn.
                        //      Reason: If you don't, you lose rotational momentum.  Turning every other frame,
                        //      and not in between results in a very slow turn because of loss of momentum.
                        if ((aip->prev_goal_point.xyz.x != 0.0f) || (aip->prev_goal_point.xyz.y != 0.0f) || (aip->prev_goal_point.xyz.z != 0.0f))
                                goal_point = aip->prev_goal_point;
                        else
                                vm_vec_scale_add(&goal_point, &enemy_pos, &En_objp->