aggressive.cpp File Reference

#include "config.h"
#include "aggressive.h"
#include "event_xml.h"
#include "script.h"
#include <list>
#include <vector>
#include "vs_globals.h"
#include "config_xml.h"
#include "xml_support.h"
#include "cmd/unit_generic.h"
#include "communication.h"
#include "cmd/script/flightgroup.h"
#include "flybywire.h"
#include "hard_coded_scripts.h"
#include "cmd/script/mission.h"
#include "gfx/cockpit_generic.h"
#include "lin_time.h"
#include "faction_generic.h"
#include "cmd/role_bitmask.h"
#include "cmd/unit_util.h"
#include "warpto.h"
#include "cmd/csv.h"
#include "universe_util.h"
#include "vs_random.h"
#include "python/python_compile.h"
#include "cmd/unit_find.h"
#include "docking.h"

Go to the source code of this file.

Classes
class	FlyTo

Functions
bool	CheckAccessory (Unit *tur)
static void	TurretFAW (Unit *parent)
static vsUMap< string, string >	getAITypes ()
static string	select_from_space_list (string inp, unsigned int seed)
static AIEvents::ElemAttrMap *	getLogicOrInterrupt (string name, int faction, string unittype, vsUMap< string, AIEvents::ElemAttrMap * > &mymap, int personalityseed)
static AIEvents::ElemAttrMap *	getProperLogicOrInterruptScript (string name, int faction, string unittype, bool interrupt, int personalityseed)
static AIEvents::ElemAttrMap *	getProperScript (Unit *me, Unit *targ, bool interrupt, int personalityseed)
std::string	GetRelationshipColor (float rel)
unsigned int	DoSpeech (Unit *un, Unit *player_un, const FSM::Node &node)
void	LeadMe (Unit *un, string directive, string speech, bool changetarget)
Unit *	GetThreat (Unit *parent, Unit *leader)
static bool	overridable (const std::string &s)
static Unit *	GetRandomNav (vector< UnitContainer >navs[3], unsigned int randnum)
static std::string	insysString ("Insys")
static std::string	arrowString ("->")
static Unit *	ChooseNavPoint (Unit *parent, Unit **otherdest, float *lurk_on_arrival)
static Unit *	ChooseNearNavPoint (Unit *parent, Unit *suggestion, QVector location, float locradius)
bool	CloseEnoughToNavOrDest (Unit *parent, Unit *navUnit, QVector nav)
static Vector	randVector ()
static void	GoTo (AggressiveAI *ai, Unit *parent, const QVector &nav, float creationtime, bool boonies=false, Unit *destUnit=NULL)

Variables
double	aggfire
const EnumMap::Pair	element_names []
const EnumMap	AggressiveAIel_map (element_names, 25)
vsUMap< string, AIEvents::ElemAttrMap * >	logic
static float	aggressivity = 2.01
static int	randomtemp
volatile Unit *	uoif
volatile Unit *	uoi
AggressiveAI *	DONOTUSEAG = NULL

Function Documentation

static std::string arrowString ( "->"  )

static

Referenced by ChooseNavPoint().

bool CheckAccessory

(

Unit *

tur)

Definition at line 1348 of file unit_generic.cpp.

Referenced by AddSubUnits(), Unit::LoadRow(), Unit::SetTurretAI(), TurretFAW(), and Unit::TurretFAW().

{
    bool accessory = tur->name.get().find( "accessory" ) != string::npos;
    if (accessory) {
        tur->SetAngularVelocity( tur->DownCoordinateLevel( Vector( tur->GetComputerData().max_pitch_up,
                                                                   tur->GetComputerData().max_yaw_right,
                                                                   tur->GetComputerData().max_roll_right ) ) );
    }
    return accessory;
}

static Unit* ChooseNavPoint ( Unit *  parent, Unit **  otherdest, float *  lurk_on_arrival  )

static

Definition at line 1240 of file aggressive.cpp.

References _Universe, a, Universe::activeStarSystem(), arrowString(), b, CompileRunPython(), Unit::UnitJump::drive, StarSystem::Statistics::enemycount, Unit::faction, float, StarSystem::Statistics::friendlycount, VSRandom::genrand_int31(), Unit::GetComputerData(), UnitUtil::getDistance(), StarSystem::getFileName(), UnitUtil::getFlightgroupName(), Unit::GetJumpStatus(), getNewTime(), GetRandomNav(), UnitUtil::getRelationFromFaction(), UniverseUtil::getScratchUnit(), VegaConfig::getVariable(), i, insysString(), int, FactionUtil::isCitizenInt(), StarSystem::Statistics::jumpPoints, k, Unit::Computer::RADARLIM::maxrange, StarSystem::Statistics::navs, XMLSupport::parse_bool(), XMLSupport::parse_float(), XMLSupport::parse_int(), Unit::Computer::radar, UniverseUtil::setScratchUnit(), start, StarSystem::stats, StarSystem::Statistics::system_faction, VSRandom::uniformExc(), vs_config, and vsrandom.

Referenced by Orders::AggressiveAI::ExecuteNoEnemies().

{
    static string script = vs_config->getVariable( "AI", "ChooseDestinationScript", "" );
    *lurk_on_arrival = 0;
    if (script.length() > 0) {
        Unit *ret = NULL;
        UniverseUtil::setScratchUnit( parent );
        CompileRunPython( script );
        ret = UniverseUtil::getScratchUnit();
        UniverseUtil::setScratchUnit( NULL );
        if (ret != NULL && ret != parent)
            return ret;
    }
    StarSystem *ss = _Universe->activeStarSystem();
    StarSystem::Statistics *stats = &ss->stats;

    float sysrel   = UnitUtil::getRelationFromFaction( parent, stats->system_faction );
    static float lurk_time   = XMLSupport::parse_float( vs_config->getVariable( "AI", "lurk_time", "600" ) );
    static float select_time = XMLSupport::parse_float( vs_config->getVariable( "AI", "fg_nav_select_time", "120" ) );
    static float hostile_select_time = XMLSupport::parse_float( vs_config->getVariable( "AI", "pirate_nav_select_time", "400" ) );
    static int   num_ships_per_roid  =
        XMLSupport::parse_int( vs_config->getVariable( "AI", "num_pirates_per_asteroid_field", "12" ) );
    bool  civilian = FactionUtil::isCitizenInt( parent->faction );

    bool  hostile  = sysrel < 0;
    bool  anarchy  = stats->enemycount > stats->friendlycount;
    float timehash = select_time;
    if (hostile && !anarchy)
        timehash = hostile_select_time;
    unsigned int firstRand, thirdRand;
    float secondRand;
    const unsigned int maxrand = 5;
    unsigned int additionalrand[maxrand];
    if (civilian) {
        firstRand  = vsrandom.genrand_int31();
        secondRand = vsrandom.uniformExc( 0, 1 );
        thirdRand  = vsrandom.genrand_int31();
        for (unsigned int i = 0; i < maxrand; ++i)
            additionalrand[i] = thirdRand+i;
    } else {
        int    k   = (int) (getNewTime()/timehash);        //two minutes
        string key = UnitUtil::getFlightgroupName( parent );
        std::string::const_iterator start = key.begin();
        for (; start != key.end(); start++)
            k += (k*128)+*start;
        VSRandom choosePlace( k );
        firstRand  = choosePlace.genrand_int31();
        secondRand = choosePlace.uniformExc( 0, 1 );
        thirdRand  = choosePlace.genrand_int31();
        for (unsigned int i = 0; i < maxrand; ++i)
            additionalrand[i] = choosePlace.genrand_int31();
    }
    bool asteroidhide = false;
    if (stats->friendlycount > 0 && stats->enemycount > 0)
        asteroidhide = (secondRand < stats->enemycount/(float) stats->friendlycount)
                       && (secondRand < num_ships_per_roid*stats->navs[2].size()/(float) stats->enemycount);
    bool   siege = stats->enemycount > 2*stats->friendlycount;       //rough approx
    int    whichlist   = 1;  //friendly
    std::string fgname = UnitUtil::getFlightgroupName( parent );

    bool   insys       = (parent->GetJumpStatus().drive == -2) || fgname.find( insysString ) != std::string::npos;
    std::string::size_type whereconvoy = fgname.find( arrowString );
    bool   convoy      = (whereconvoy != std::string::npos);
    size_t total_size  = stats->navs[0].size()+stats->navs[whichlist].size();     //friendly and neutral
    static bool bad_units_lurk = XMLSupport::parse_bool( vs_config->getVariable( "AI", "hostile_lurk", "true" ) );
    if (hostile && bad_units_lurk) {
        if (anarchy && !siege) {
            whichlist  = 2;
            total_size = stats->navs[0].size()+stats->navs[whichlist].size();             //asteroids and neutrals
        } else {
            whichlist  = 2;
            total_size = stats->navs[whichlist].size();             //just asteroids
        }
    } else if (civilian) {
        if (anarchy || siege) {
            whichlist  = 0;
            total_size = stats->navs[0].size();
        } else if (insys || convoy) {
            whichlist  = 1;
            total_size = stats->navs[1].size();             //don't go to jump point
        }
    }
    if (hostile && ( (anarchy == false && asteroidhide == false) || total_size == 0 ) && civilian == false && bad_units_lurk) {
        //hit and run
        Unit *a = GetRandomNav( stats->navs, firstRand );
        Unit *b = GetRandomNav( stats->navs, thirdRand );
        if (a == b)
            b = GetRandomNav( stats->navs, thirdRand+1 );
        if (a != b) {
            int retrycount = maxrand;
            while ( --retrycount > 0 && (UnitUtil::getDistance( a, b ) < parent->GetComputerData().radar.maxrange*4 || a == b) )
                b = GetRandomNav( stats->navs, additionalrand[retrycount] );
            if (retrycount != 0) {
                *otherdest = b;
                *lurk_on_arrival = lurk_time;
            }
        }
        return a;
    } else {
        if (convoy) {
            std::string srcdst[2] = {fgname.substr( 0, whereconvoy ), fgname.substr( whereconvoy+2 )};
            if ( srcdst[0] == ss->getFileName() )
                srcdst[0] = srcdst[1];
            if ( srcdst[1] == ss->getFileName() )
                srcdst[1] = srcdst[0];
            if (thirdRand < 2) {
                vsUMap< std::string, UnitContainer >::iterator i = stats->jumpPoints.find( srcdst[thirdRand] );
                if ( i != stats->jumpPoints.end() ) {
                    Unit *un = i->second.GetUnit();
                    if (un)
                        return un;
                } else {
                    total_size = stats->navs[whichlist].size()+stats->navs[0].size();                     //no such jump point--have to random-walk it
                    //maybe one day we can incorporate some sort of route planning
                }
            }
        }
        if (total_size > 0) {
            firstRand %= total_size;
            if ( firstRand >= stats->navs[whichlist].size() ) {
                firstRand -= stats->navs[whichlist].size();
                whichlist  = 0;                 //allows you to look for both neutral and ally lists
            }
            return stats->navs[whichlist][firstRand].GetUnit();
        }
    }
    return NULL;
}

static Unit* ChooseNearNavPoint ( Unit *  parent, Unit *  suggestion, QVector  location, float  locradius  )

static

Definition at line 1369 of file aggressive.cpp.

References _Universe, Universe::activeStarSystem(), StarSystem::collidemap, UnitCollection::createIterator(), findObjects(), StarSystem::getUnitList(), i, UnitUtil::isSignificant(), Unit::location, Magnitude(), Unit::Position(), NearestUnitLocator::retval, Unit::rSize(), Collidable::CollideRef::unit, and Unit::UNIT_ONLY.

Referenced by FlyTo::Execute(), and Orders::AggressiveAI::ExecuteNoEnemies().

{
    if (suggestion) return suggestion;
    Unit *candidate = NULL;
    float dist = FLT_MAX;
    Unit *un;
    NearestNavOrCapshipLocator nnl;
    findObjects( _Universe->activeStarSystem()->collidemap[Unit::UNIT_ONLY],
                 parent->location[Unit::UNIT_ONLY],
                 &nnl );
    return nnl.retval.unit;
    //DEAD CODE
    for (un_iter i = _Universe->activeStarSystem()->getUnitList().createIterator();
         (un = *i) != NULL;
         ++i)
        if (UnitUtil::isSignificant( un ) && un != parent) {
            float newdist = ( location-un->Position() ).Magnitude()-un->rSize()-locradius;
            if (candidate == NULL || newdist <= dist) {
                candidate = un;
                dist = newdist;
            }
        }
    return candidate;
    //END DEAD CODE
}

bool CloseEnoughToNavOrDest	(	Unit *	parent,
		Unit *	navUnit,
		QVector	nav
	)

Definition at line 1395 of file aggressive.cpp.

References UnitUtil::getDistance(), VegaConfig::getVariable(), Unit::isUnit(), XMLSupport::parse_float(), PLANETPTR, Unit::Position(), Unit::predicted_priority, Unit::rSize(), and vs_config.

Referenced by FlyTo::Execute(), and Orders::AggressiveAI::ExecuteNoEnemies().

{
    static float how_far_to_stop_moving =
        XMLSupport::parse_float( vs_config->getVariable( "AI", "how_far_to_stop_navigating", "100" ) );
    if (navUnit && navUnit->isUnit() != PLANETPTR) {
        float dist = UnitUtil::getDistance( navUnit, parent );
        if (dist < SIMULATION_ATOM*parent->Velocity.Magnitude()*parent->predicted_priority*how_far_to_stop_moving)
            return true;
    }
    return ( nav-parent->Position() ).MagnitudeSquared() < 4*parent->rSize()*parent->rSize();
}

unsigned int DoSpeech	(	Unit *	un,
		Unit *	player_un,
		const FSM::Node &	node
	)

Definition at line 199 of file aggressive.cpp.

References MessageCenter::add(), Unit::getFgSubnumber(), Unit::getFlightgroup(), Unit::getFullname(), FSM::Node::GetMessage(), Unit::getRelation(), GetRelationshipColor(), Unit::isUnit(), FSM::Node::messagedelta, mission, Mission::msgcenter, Flightgroup::name, Unit::name, PLANETPTR, and XMLSupport::tostring().

Referenced by FireKeyboard::DoSpeechAndAni(), FireKeyboard::Execute(), HelpOut(), LeadMe(), and FireKeyboard::ProcessCommMessage().

{
    unsigned int dummy = 0;
    string speech = node.GetMessage( dummy );
    string myname( "[Static]" );
    if (un != NULL) {
        myname = un->isUnit() == PLANETPTR ? un->name : un->getFullname();
        Flightgroup *fg = un->getFlightgroup();
        if (fg && fg->name != "base" && fg->name != "Base")
            myname = fg->name+" "+XMLSupport::tostring( un->getFgSubnumber() )+", "+un->getFullname();
        else if (myname.length() == 0)
            myname = un->name;
        if (player_un != NULL) {
            if (player_un == un) {
                myname = std::string( "#0033FF" )+myname+"#000000";
            } else {
                float rel = un->getRelation( player_un );
                myname = GetRelationshipColor( rel )+myname+"#000000";
            }
        }
    }
    mission->msgcenter->add( myname, "all", GetRelationshipColor( node.messagedelta*10 )+speech+"#000000" );     //multiply by 2 so colors are easier to tell
    return dummy;
}

static vsUMap< string, string > getAITypes ( )

static

Definition at line 83 of file aggressive.cpp.

References VSFileSystem::AiFile, VSFileSystem::VSFile::Close(), f, VSFileSystem::VSFile::GetRoot(), i, VSFileSystem::Ok, VSFileSystem::VSFile::OpenReadOnly(), and CSVTable::rows.

Referenced by getLogicOrInterrupt().

{
    vsUMap< string, string >ret;
    VSFileSystem::VSFile    f;
    VSError err = f.OpenReadOnly( "VegaPersonalities.csv", AiFile );
    if (err <= Ok) {
        CSVTable table( f, f.GetRoot() );
        vsUMap< std::string, int >::iterator browser = table.rows.begin();
        for (; browser != table.rows.end(); ++browser) {
            string rowname = (*browser).first;
            CSVRow row( &table, rowname );
            for (unsigned int i = 1; i < table.key.size(); ++i) {
                string hasher = rowname;
                if (i != 1)
                    hasher = rowname+"%"+table.key[i];
                string rawrow = row[i];
                if (rawrow.length() > 0)
                    ret[hasher] = rawrow;
            }
        }
        f.Close();
    }
    return ret;
}

static AIEvents::ElemAttrMap* getLogicOrInterrupt ( string  name, int  faction, string  unittype, vsUMap< string, AIEvents::ElemAttrMap * > &  mymap, int  personalityseed  )

static

Definition at line 134 of file aggressive.cpp.

References AggressiveAIel_map, getAITypes(), FactionUtil::GetFaction(), i, AIEvents::LoadAI(), and select_from_space_list().

Referenced by getProperLogicOrInterruptScript().

{
    string append = "agg";
    static vsUMap< string, string >myappend = getAITypes();
    vsUMap< string, string >::iterator iter;
    string factionname = FactionUtil::GetFaction( faction );
    if ( ( iter = myappend.find( factionname+"%"+unittype ) ) != myappend.end() )
        append = select_from_space_list( (*iter).second, personalityseed );
    else if ( ( iter = myappend.find( factionname ) ) != myappend.end() )
        append = select_from_space_list( (*iter).second, personalityseed );
    if (append.length() == 0) append = "agg";
    string hashname = name+"."+append;
    vsUMap< string, AIEvents::ElemAttrMap* >::iterator i = mymap.find( hashname );
    if ( i == mymap.end() ) {
        AIEvents::ElemAttrMap *attr = new AIEvents::ElemAttrMap( AggressiveAIel_map );
        string filename( name+"."+append+".xml" );
        AIEvents::LoadAI( filename.c_str(), *attr, FactionUtil::GetFaction( faction ) );
        mymap.insert( pair< string, AIEvents::ElemAttrMap* > ( hashname, attr ) );
        return attr;
    }
    return i->second;
}

static AIEvents::ElemAttrMap* getProperLogicOrInterruptScript ( string  name, int  faction, string  unittype, bool  interrupt, int  personalityseed  )

static

Definition at line 161 of file aggressive.cpp.

References getLogicOrInterrupt(), and logic.

Referenced by getProperScript().

{
    return getLogicOrInterrupt( name, faction, unittype, logic, personalityseed );
}

static AIEvents::ElemAttrMap* getProperScript ( Unit *  me, Unit *  targ, bool  interrupt, int  personalityseed  )

static

Definition at line 170 of file aggressive.cpp.

References Unit::attackPreference(), Unit::faction, getProperLogicOrInterruptScript(), ROLES::getRoleEvents(), Unit::name, and Unit::unitRole().

Referenced by Orders::AggressiveAI::SignalChosenTarget().

{
    if (!me || !targ) {
        string nam = "eject";
        int    fac = 0;
        if (me) {
            fac = me->faction;
            nam = me->name;
        }
        return getProperLogicOrInterruptScript( "default", fac, nam, interrupt, personalityseed );
    }
    return getProperLogicOrInterruptScript( ROLES::getRoleEvents( me->attackPreference(),
                                                                 targ->unitRole() ), me->faction, me->name, interrupt,
                                            personalityseed );
}

static Unit* GetRandomNav ( vector< UnitContainer >  navs[3], unsigned int  randnum  )

static

Definition at line 1220 of file aggressive.cpp.

References size.

Referenced by ChooseNavPoint().

{
    size_t total_size = navs[0].size()+navs[1].size()+navs[2].size();
    if (total_size == 0) return NULL;
    randnum %= total_size;
    if ( randnum >= navs[0].size() ) {
        randnum -= navs[0].size();
        if ( randnum >= navs[1].size() ) {
            randnum -= navs[1].size();
            return navs[2][randnum].GetUnit();
        }
        return navs[1][randnum].GetUnit();
    }
    return navs[0][randnum].GetUnit();
}

std::string GetRelationshipColor ( float  rel)

inline

Definition at line 186 of file aggressive.cpp.

Referenced by DoSpeech().

{
    if (rel >= 1)
        return "#00FF00";
    if (rel <= -1)
        return "#FF0000";
    rel += 1.;
    rel /= 2.;
    char str[20];     //Just in case all 8 digits of both #s end up inside the string for some reason.
    sprintf( str, "#%2X%2X00", (int) ( (1-rel)*256 ), (int) (rel*256) );
    return str;
}

Unit* GetThreat	(	Unit *	parent,
		Unit *	leader
	)

Definition at line 574 of file aggressive.cpp.

References _Universe, Universe::activeStarSystem(), UnitCollection::createIterator(), d, Unit::getRelation(), StarSystem::getUnitList(), Magnitude(), Unit::Position(), and Unit::Target().

Referenced by HelpOut(), and Orders::AggressiveAI::ProcessCurrentFgDirective().

{
    Unit *th = NULL;
    Unit *un = NULL;
    bool  targetted = false;
    float mindist   = FLT_MAX;
    for (un_iter ui = _Universe->activeStarSystem()->getUnitList().createIterator();
         (un = *ui);
         ++ui)
        if (parent->getRelation( un ) < 0) {
            float d = ( un->Position()-leader->Position() ).Magnitude();
            bool  thistargetted = (un->Target() == leader);
            if ( !th || (thistargetted && !targetted) || ( ( thistargetted || (!targetted) ) && d < mindist ) ) {
                th = un;
                targetted = thistargetted;
                mindist = d;
            }
        }
    return th;
}

static void GoTo ( AggressiveAI *  ai, Unit *  parent, const QVector &  nav, float  creationtime, bool  boonies = false, Unit *  destUnit = NULL  )

static

Definition at line 1452 of file aggressive.cpp.

References Order::EnqueueOrder(), Order::eraseType(), f, Order::FACING, VegaConfig::getVariable(), Order::MOVEMENT, XMLSupport::parse_bool(), Order::ReplaceOrder(), Order::SetParent(), and vs_config.

Referenced by Orders::AggressiveAI::ExecuteNoEnemies().

{
    static bool can_afterburn = XMLSupport::parse_bool( vs_config->getVariable( "AI", "afterburn_to_no_enemies", "true" ) );
    Order *mt = new FlyTo( nav, can_afterburn, true, creationtime, boonies ? 16 : 6, destUnit );
    Order *ch = new Orders::ChangeHeading( nav, 32, .25f, false );
    ai->eraseType( Order::FACING );
    ai->eraseType( Order::MOVEMENT );
    mt->SetParent( parent );
    ch->SetParent( parent );
    ai->ReplaceOrder( mt );
    ai->EnqueueOrder( ch );
}

static std::string insysString ( "Insys"  )

static

Referenced by ChooseNavPoint(), and Orders::AggressiveAI::ExecuteNoEnemies().

void LeadMe	(	Unit *	un,
		string	directive,
		string	speech,
		bool	changetarget
	)

Definition at line 224 of file aggressive.cpp.

References _Universe, Universe::AccessCockpit(), Flightgroup::directive, DoSpeech(), Unit::getFlightgroup(), Cockpit::GetParent(), UnitContainer::GetUnit(), i, Universe::isPlayerStarship(), Flightgroup::leader, FSM::Node::MakeNode(), Universe::numPlayers(), UnitContainer::SetUnit(), Flightgroup::target, and Unit::Target().

Referenced by FireKeyboard::AttackTarget(), FireKeyboard::BreakFormation(), FireKeyboard::DefendTarget(), FireKeyboard::DockTarget(), FireKeyboard::DockWithMe(), FireKeyboard::EjectKey(), FireKeyboard::FormUp(), FireKeyboard::HelpMeOut(), FireKeyboard::HoldPosition(), LeadMe(), and Orders::AggressiveAI::ReCommandWing().

{
    if (un != NULL) {
        for (unsigned int i = 0; i < _Universe->numPlayers(); i++) {
            Unit *pun = _Universe->AccessCockpit( i )->GetParent();
            if (pun)
                if ( pun->getFlightgroup() == un->getFlightgroup() )
                    DoSpeech( un, pun, FSM::Node::MakeNode( speech, .1 ) );
        }
        Flightgroup *fg = un->getFlightgroup();
        if (fg) {
            if (fg->leader.GetUnit() != un)
                if ( ( !_Universe->isPlayerStarship( fg->leader.GetUnit() ) ) || _Universe->isPlayerStarship( un ) )
                    fg->leader.SetUnit( un );
            fg->directive = directive;
            if (changetarget)
                fg->target.SetUnit( un->Target() );
            if ( (directive == "") )
                fg->target.SetUnit( NULL );
        }
    }
}

static bool overridable ( const std::string &  s)

static

Definition at line 1183 of file aggressive.cpp.

Referenced by Orders::AggressiveAI::ReCommandWing().

{
    if ( s.empty() )
        return true;
    return ( *s.begin() ) != toupper( *s.begin() );
}

static Vector randVector ( )

static

Definition at line 1447 of file aggressive.cpp.

References Vector.

Referenced by Orders::AggressiveAI::ExecuteNoEnemies().

{
    return Vector( (rand()/(float) RAND_MAX)*2-1, (rand()/(float) RAND_MAX)*2-1, (rand()/(float) RAND_MAX)*2-1 );
}

static string select_from_space_list ( string  inp, unsigned int  seed  )

static

Definition at line 108 of file aggressive.cpp.

References i, and j.

Referenced by getLogicOrInterrupt().

{
    if (inp.length() == 0)
        return "";
    int count = 1;
    string::size_type len = inp.length();
    for (unsigned int i = 0; i < len; ++i)
        if (inp[i] == ' ')
            count++;
    count = seed%count;
    int ncount = 0;
    unsigned int j;
    for (j = 0; j < len; ++j) {
        if (inp[j] == ' ')
            ncount++;
        if (ncount >= count)
            break;
    }
    if (inp[j] == ' ')
        j++;
    inp = inp.substr( j );
    if ( ( len = inp.find( " " ) ) != string::npos )
        inp = inp.substr( 0, len );
    return inp;
}

static void TurretFAW ( Unit *  parent)

static

Definition at line 69 of file aggressive.cpp.

References CheckAccessory(), Unit::EnqueueAIFirst(), f, and Unit::getSubUnits().

Referenced by Unit::EjectCargo(), and Orders::AggressiveAI::ProcessCurrentFgDirective().

{
    un_iter iter = parent->getSubUnits();
    Unit   *un;
    while ( NULL != (un = *iter) ) {
        if ( !CheckAccessory( un ) ) {
            un->EnqueueAIFirst( new Orders::FireAt( 15.0f ) );
            un->EnqueueAIFirst( new Orders::FaceTarget( false, 3 ) );
        }
        TurretFAW( un );
        ++iter;
    }
}

Variable Documentation

double aggfire

Definition at line 480 of file star_system_generic.cpp.

Referenced by Orders::AggressiveAI::Execute(), and StarSystem::UpdateUnitPhysics().

const EnumMap AggressiveAIel_map(element_names, 25)

Referenced by getLogicOrInterrupt().

float aggressivity = 2.01

static

Definition at line 247 of file aggressive.cpp.

Referenced by Orders::AggressiveAI::AggressiveAI().

AggressiveAI* DONOTUSEAG = NULL

Definition at line 1712 of file aggressive.cpp.

const EnumMap::Pair element_names[]

Initial value:

= {
    EnumMap::Pair( "AggressiveAI",                AggressiveAI::AGGAI ),
    EnumMap::Pair( "UNKNOWN",                     AggressiveAI::UNKNOWN ),
    EnumMap::Pair( "Distance",                    AggressiveAI::DISTANCE ),
    EnumMap::Pair( "MeterDistance",               AggressiveAI::METERDISTANCE ),
    EnumMap::Pair( "Threat",                      AggressiveAI::THREAT ),
    EnumMap::Pair( "FShield",                     AggressiveAI::FSHIELD ),
    EnumMap::Pair( "LShield",                     AggressiveAI::LSHIELD ),
    EnumMap::Pair( "RShield",                     AggressiveAI::RSHIELD ),
    EnumMap::Pair( "BShield",                     AggressiveAI::BSHIELD ),
    EnumMap::Pair( "Hull",                        AggressiveAI::HULL ),
    EnumMap::Pair( "Facing",                      AggressiveAI::FACING ),
    EnumMap::Pair( "Movement",                    AggressiveAI::MOVEMENT ),
    EnumMap::Pair( "FShield_Heal_Rate",           AggressiveAI::FSHIELD_HEAL_RATE ),
    EnumMap::Pair( "BShield_Heal_Rate",           AggressiveAI::BSHIELD_HEAL_RATE ),
    EnumMap::Pair( "LShield_Heal_Rate",           AggressiveAI::LSHIELD_HEAL_RATE ),
    EnumMap::Pair( "RShield_Heal_Rate",           AggressiveAI::RSHIELD_HEAL_RATE ),
    EnumMap::Pair( "FArmor_Heal_Rate",            AggressiveAI::FARMOR_HEAL_RATE ),
    EnumMap::Pair( "BArmor_Heal_Rate",            AggressiveAI::BARMOR_HEAL_RATE ),
    EnumMap::Pair( "LArmor_Heal_Rate",            AggressiveAI::LARMOR_HEAL_RATE ),
    EnumMap::Pair( "RArmor_Heal_Rate",            AggressiveAI::RARMOR_HEAL_RATE ),
    EnumMap::Pair( "Hull_Heal_Rate",              AggressiveAI::HULL_HEAL_RATE ),
    EnumMap::Pair( "Target_Faces_You",            AggressiveAI::TARGET_FACES_YOU ),
    EnumMap::Pair( "Target_In_Front_Of_You",      AggressiveAI::TARGET_IN_FRONT_OF_YOU ),
    EnumMap::Pair( "Rand",                        AggressiveAI::RANDOMIZ ),
    EnumMap::Pair( "Target_Going_Your_Direction", AggressiveAI::TARGET_GOING_YOUR_DIRECTION )
}

Definition at line 34 of file aggressive.cpp.

vsUMap< string, AIEvents::ElemAttrMap* > logic

Definition at line 65 of file aggressive.cpp.

Referenced by getProperLogicOrInterruptScript().

int randomtemp

static

Definition at line 248 of file aggressive.cpp.

Referenced by Orders::AggressiveAI::AggressiveAI().

volatile Unit* uoi

Definition at line 1582 of file aggressive.cpp.

Referenced by Orders::AggressiveAI::Execute().

volatile Unit* uoif

Definition at line 1407 of file aggressive.cpp.

Referenced by FlyTo::Execute().