Orders::FireAt Class Reference

#include <fire.h>

Inheritance diagram for Orders::FireAt:

Public Member Functions
virtual void	ChooseTarget ()
	this function calls the destructor (needs to be overridden for python; More...
void	PossiblySwitchTarget (bool istargetjumpableplanet)
virtual bool	PursueTarget (Unit *, bool leader)
void	AddReplaceLastOrder (bool replace)
void	ExecuteLastScriptFor (float time)
void	FaceTarget (bool end)
void	FaceTargetITTS (bool end)
void	MatchLinearVelocity (bool terminate, Vector vec, bool afterburn, bool local)
void	MatchAngularVelocity (bool terminate, Vector vec, bool local)
void	ChangeHeading (QVector vec)
void	ChangeLocalDirection (Vector vec)
void	MoveTo (QVector, bool afterburn)
void	MatchVelocity (bool terminate, Vector vec, Vector angvel, bool afterburn, bool local)
void	Cloak (bool enable, float seconds)
void	FormUp (QVector pos)
void	FormUpToOwner (QVector pos)
void	FaceDirection (float distToMatchFacing, bool finish)
void	XMLScript (std::string script)
void	LastPythonScript ()
virtual void	SetParent (Unit *parent)
	Sets the parent of this Unit. Any virtual functions must call this one. More...
Unit *	GetParent ()
	FireAt (float aggressivitylevel)
	FireAt ()
virtual void	Execute ()
	The function that gets called and executes all queued suborders. More...
virtual std::string	Pickle ()
virtual void	UnPickle (std::string)
virtual	~FireAt ()
Public Member Functions inherited from CommunicatingAI
virtual void	Destroy ()
	The virutal function that unrefs all memory then calls Destruct () which takes care of unreffing this or calling delete on this. More...
virtual float	getMood ()
Unit *	GetRandomUnit (float PlayerProbability, float TargetProbability)
void	RandomInitiateCommunication (float PlayerProbability, float TargetProbability)
void	TerminateContrabandSearch (bool foundcontraband)
void	InitiateContrabandSearch (float PlayerProbability, float TargetProbability)
void	UpdateContrabandSearch ()
	CommunicatingAI (int ttype, int stype, float mood=0, float anger=-666, float appeasement=666, float moodswingyness=666, float randomnessresponse=666)
virtual void	ProcessCommMessage (class CommunicationMessage &c)
	processes a single message...generally called by the Messages() func More...
virtual void	AdjustRelationTo (Unit *un, float factor)
virtual	~CommunicatingAI ()
virtual int	selectCommunicationMessage (class CommunicationMessage &c, Unit *)
virtual int	selectCommunicationMessageMood (CommunicationMessage &c, float mood)
Public Member Functions inherited from Order
void	ClearMessages ()
	clears the messasges of this order More...
	Order ()
	The default constructor setting everything to NULL and no dependency on order. More...
	Order (int type, int subtype)
	The constructor that specifies what order dependencies this order has. More...
Order *	queryType (unsigned int type)
	returns a pointer to the first order that may be bitwised ored with that type More...
Order *	queryAny (unsigned int type)
	returns a pointer to the first order that may be bitwise ored with any type More...
void	eraseType (unsigned int type)
	Erases all orders that bitwise OR with that type. More...
bool	AttachOrder (Unit *targets)
	Attaches a group of targets to this order (used for strategery-type games) More...
bool	AttachOrder (QVector target)
	Attaches a navigation point to this order. More...
bool	AttachSelfOrder (Unit *targets)
	Attaches a group (form up) to this order. More...
Order *	EnqueueOrder (Order *ord)
	Enqueues another order that will be executed (in parallel perhaps) when next void Execute() is called. More...
Order *	ReplaceOrder (Order *ord)
	Replaces the first order of that type in the order queue. More...
bool	Done ()
int	getType ()
int	getSubType ()
Unit *	GetParent () const
virtual void	Communicate (const class CommunicationMessage &c)
	Sends a communication message from the Unit (encapulated in c) to this unit. More...
virtual void	ProcessCommunicationMessages (float CommRepsonseTime, bool RemoveMessageProcessed)
	responds (or does not) to certain messages in the message queue More...
Order *	findOrder (Order *ord)
	return pointer to order or NULL if not found More...
void	eraseOrder (Order *ord)
	erase that order from the list More...
Order *	EnqueueOrderFirst (Order *ord)
	enqueue order as first order More...
virtual olist_t *	getOrderList ()
	returns the orderlist (NULL for orders that haven't got any) More...
virtual std::string	getOrderDescription ()
Order *	findOrderList ()
	searches the suborders recursively for the first order that has an orderlist More...
std::string	createFullOrderDescription (int level=0)
void	setActionString (std::string astring)
std::string	getActionString ()

Protected Member Functions
bool	ShouldFire (Unit *targ, bool &missilelock)
void	FireWeapons (bool shouldfire, bool lockmissile)
virtual void	ChooseTargets (int num, bool force=false)
bool	isJumpablePlanet (Unit *)
void	ReInit (float agglevel)
virtual void	SignalChosenTarget ()
Protected Member Functions inherited from CommunicatingAI
void	GetMadAt (Unit *which, int howMad)
Protected Member Functions inherited from Order
virtual	~Order ()
virtual void	Destructor ()
	changes the local relation of this unit to another...may inform superiors about "good" or bad! behavior depending on the AI More...

Protected Attributes
float	missileprobability
float	lastmissiletime
float	delay
float	agg
float	distance
float	lastchangedtarg
bool	had_target
Protected Attributes inherited from CommunicatingAI
float	anger
float	appease
float	moodswingyness
float	randomresponse
float	mood
UnitContainer	contraband_searchee
Vector	SpeedAndCourse
int	which_cargo_item
Protected Attributes inherited from Order
Unit *	parent
	The unit this order is attached to. More...
unsigned int	type
	The bit code (from ORDERTYPES) that this order is (for parallel execution) More...
unsigned int	subtype
bool	done
	Whether or not this order is done. More...
UnitContainer	group
	If this order applies to a group of units (as in form up with this group) More...
QVector	targetlocation
	If this order applies to a physical location in world space. More...
std::vector< Order * >	suborders
	The queue of suborders that will be executed in parallel according to bit code. More...
std::list< class CommunicationMessage * >	messagequeue
	a bunch of communications that have not been answered CommunicationMessages are actually containing reference to a nice Finite State Machine that can allow a player to have a reasonable conversation with an AI More...
std::string	actionstring

Additional Inherited Members
Public Types inherited from Order
enum	ORDERTYPES {   MOVEMENT =1, FACING =2, WEAPON =4, CLOAKING =8,   ALLTYPES =(1|2|4|8) }
	The varieties of order types MOVEMENT,FACING, and WEAPON orders may not be mutually executed (lest one engine goes left, the other right) More...
enum	SUBORDERTYPES { SLOCATION =1, STARGET =2, SSELF =4 }

Detailed Description

Definition at line 10 of file fire.h.

Constructor & Destructor Documentation

FireAt::FireAt

(

float

aggressivitylevel)

Definition at line 114 of file fire.cpp.

References ReInit().

                                        : CommunicatingAI( WEAPON, STARGET )
{
    ReInit( aggressivitylevel );
}

FireAt::FireAt

(

)

Definition at line 119 of file fire.cpp.

References VegaConfig::getVariable(), XMLSupport::parse_float(), ReInit(), and vs_config.

               : CommunicatingAI( WEAPON, STARGET )
{
    static float aggr = XMLSupport::parse_float( vs_config->getVariable( "AI", "Firing", "Aggressivity", "15" ) );
    ReInit( aggr );
}

FireAt::~FireAt ( )

virtual

Definition at line 631 of file fire.cpp.

References VSFileSystem::vs_fprintf().

{
#ifdef ORDERDEBUG
    VSFileSystem::vs_fprintf( stderr, "fire%x\n", this );
    fflush( stderr );
#endif
}

Member Function Documentation

void FireAt::AddReplaceLastOrder

(

bool

replace)

Definition at line 48 of file hard_coded_scripts.cpp.

References AddOrd(), Order::parent, and ReplaceOrd().

{
    if (lastOrder) {
        if (replace)
            ReplaceOrd( this, parent, lastOrder );
        else
            AddOrd( this, parent, lastOrder );
        lastOrder = NULL;
    }
}

void FireAt::ChangeHeading

(

QVector

vec)

Definition at line 80 of file hard_coded_scripts.cpp.

{
    lastOrder = new Orders::ChangeHeading( vec, 3 );
}

void FireAt::ChangeLocalDirection

(

Vector

vec)

Definition at line 84 of file hard_coded_scripts.cpp.

References Order::parent, Unit::Position(), and Unit::ToWorldCoordinates().

{
    lastOrder = new Orders::ChangeHeading( ( ( parent->Position().Cast() )+parent->ToWorldCoordinates( vec ) ).Cast(), 3 );
}

virtual void Orders::FireAt::ChooseTarget ( )

inlinevirtual

this function calls the destructor (needs to be overridden for python;

Reimplemented from Order.

Definition at line 28 of file fire.h.

References ChooseTargets().

    {
        ChooseTargets( 1, true );
    }

void FireAt::ChooseTargets ( int  num, bool  force = false  )

protectedvirtual

Definition at line 424 of file fire.cpp.

References _Universe, Universe::AccessCockpit(), Universe::activeStarSystem(), AssignTBin(), Unit::attackPreference(), StarSystem::collidemap, Flightgroup::directive, findObjects(), float_to_int(), UnitUtil::getDistance(), UnitUtil::getFlightgroupLeader(), UniverseUtil::GetGameTime(), Cockpit::GetParent(), ROLES::getRole(), Unit::getSubUnits(), VegaConfig::getVariable(), i, k, Universe::numPlayers(), numpolled, numprocessed, XMLSupport::parse_bool(), XMLSupport::parse_float(), XMLSupport::parse_int(), pollindex, prevpollindex, queryTime(), Unit::Target(), targetpick, targrand, Unit::Threat(), VSRandom::uniformInc(), Unit::UNIT_ONLY, and vs_config.

Referenced by ChooseTarget().

{
    float gunspeed, gunrange, missilerange;
    parent->getAverageGunSpeed( gunspeed, gunrange, missilerange );
    static float  targettimer = UniverseUtil::GetGameTime();    //timer used to determine passage of physics frames
    static float  mintimetoswitch =
        XMLSupport::parse_float( vs_config->getVariable( "AI", "Targetting", "MinTimeToSwitchTargets", "3" ) );
    static float  minnulltimetoswitch    =
        XMLSupport::parse_float( vs_config->getVariable( "AI", "Targetting", "MinNullTimeToSwitchTargets", "5" ) );
    static int    minnumpollers          =
        float_to_int( XMLSupport::parse_float( vs_config->getVariable( "AI", "Targetting", "MinNumberofpollersperframe", "5" ) ) );                    //maximum number of vessels allowed to search for a target in a given physics frame
    static int    maxnumpollers          =
        float_to_int( XMLSupport::parse_float( vs_config->getVariable( "AI", "Targetting", "MaxNumberofpollersperframe", "49" ) ) );                    //maximum number of vessels allowed to search for a target in a given physics frame
    static int    numpollers[2]          = {maxnumpollers, maxnumpollers};

    static float  nextframenumpollers[2] = {maxnumpollers, maxnumpollers};
    if (lastchangedtarg+mintimetoswitch > 0)
        return;          //don't switch if switching too soon

    Unit *curtarg = parent->Target();
    int   hastarg = (curtarg == NULL) ? 0 : 1;
    //Following code exists to limit the number of craft polling for a target in a given frame - this is an expensive operation, and needs to be spread out, or there will be pauses.
    static float simatom = XMLSupport::parse_float( vs_config->getVariable( "general", "simulation_atom", "0.1" ) );
    if ( ( UniverseUtil::GetGameTime() )-targettimer >= simatom*.99 ) {
        //Check if one or more physics frames have passed
        numpolled[0] = numpolled[1] = 0;         //reset counters
        prevpollindex[0]   = pollindex[0];
        prevpollindex[1]   = pollindex[1];
        pollindex[hastarg] = 0;
        targettimer = UniverseUtil::GetGameTime();
        numpollers[0]      = float_to_int( nextframenumpollers[0] );
        numpollers[1]      = float_to_int( nextframenumpollers[1] );
    }
    pollindex[hastarg]++;     //count number of craft touched - will use in the next physics frame to spread out the vessels actually chosen to be processed among all of the vessels being touched
    if (numpolled[hastarg] > numpollers[hastarg])      //over quota, wait until next physics frame
        return;
    if ( !( pollindex[hastarg]%( (prevpollindex[hastarg]/numpollers[hastarg])+1 ) ) )      //spread out, in modulo fashion, the possibility of changing one's target. Use previous physics frame count of craft to estimate current number of craft
        numpolled[hastarg]++;          //if a more likely candidate, we're going to search for a target.
    else
        return;          //skipped to achieve better fairness - see comment on modulo distribution above
    if (curtarg)
        if ( isJumpablePlanet( curtarg ) )
            return;
    bool wasnull    = (curtarg == NULL);
    Flightgroup *fg = parent->getFlightgroup();
    lastchangedtarg = 0+targrand.uniformInc( 0, 1 )*mintimetoswitch;     //spread out next valid time to switch targets - helps to ease per-frame loads.
    if (fg) {
        if ( !fg->directive.empty() )
            if ( curtarg != NULL && ( *fg->directive.begin() ) == toupper( *fg->directive.begin() ) )
                return;
    }
    //not   allowed to switch targets
    numprocessed++;
    vector< TurretBin >tbin;
    Unit   *su = NULL;
    un_iter subun    = parent->getSubUnits();
    for (; (su = *subun) != NULL; ++subun) {
        static unsigned int inert    = ROLES::getRole( "INERT" );
        static unsigned int pointdef = ROLES::getRole( "POINTDEF" );
        static bool assignpointdef   =
            XMLSupport::parse_bool( vs_config->getVariable( "AI", "Targetting", "AssignPointDef", "true" ) );
        if ( (su->attackPreference() != pointdef) || assignpointdef ) {
            if (su->attackPreference() != inert) {
                AssignTBin( su, tbin );
            } else {
                Unit *ssu = NULL;
                for (un_iter subturret = su->getSubUnits(); ( ssu = (*subturret) ); ++subturret)
                    AssignTBin( ssu, tbin );
            }
        }
    }
    std::sort( tbin.begin(), tbin.end() );
    float efrel = 0;
    float mytargrange    = FLT_MAX;
    static float unitRad =
        XMLSupport::parse_float( vs_config->getVariable( "AI", "Targetting", "search_extra_radius", "1000" ) );                 //Maximum target radius that is guaranteed to be detected
    static char  maxrolepriority =
        XMLSupport::parse_int( vs_config->getVariable( "AI", "Targetting", "search_max_role_priority", "16" ) );
    static int   maxtargets = XMLSupport::parse_int( vs_config->getVariable( "AI", "Targetting", "search_max_candidates", "64" ) );   //Cutoff candidate count (if that many hostiles found, stop search - performance/quality tradeoff, 0=no cutoff)
    UnitWithinRangeLocator< ChooseTargetClass< 2 > >unitLocator( parent->GetComputerData().radar.maxrange, unitRad );
    StaticTuple< float, 2 >maxranges;

    maxranges[0] = gunrange;
    maxranges[1] = missilerange;
    if ( tbin.size() )
        maxranges[0] = (tbin[0].maxrange > gunrange ? tbin[0].maxrange : gunrange);
    double     pretable = queryTime();
    unitLocator.action.init( this, parent, gunrange, &tbin, maxranges, maxrolepriority, maxtargets );
    static int gcounter = 0;
    static int min_rechoose_interval = XMLSupport::parse_int( vs_config->getVariable( "AI", "min_rechoose_interval", "128" ) );
    if (curtarg) {
        if (gcounter++ < min_rechoose_interval || rand()/8 < RAND_MAX/9) {
            //in this case only look at potentially *interesting* units rather than huge swaths of nearby units...including target, threat, players, and leader's target
            unitLocator.action.ShouldTargetUnit( curtarg, UnitUtil::getDistance( parent, curtarg ) );
            unsigned int np = _Universe->numPlayers();
            for (unsigned int i = 0; i < np; ++i) {
                Unit *playa = _Universe->AccessCockpit( i )->GetParent();
                if (playa)
                    unitLocator.action.ShouldTargetUnit( playa, UnitUtil::getDistance( parent, playa ) );
            }
            Unit *lead   = UnitUtil::getFlightgroupLeader( parent );
            if (lead != NULL && lead != parent && ( lead = lead->Target() ) != NULL)
                unitLocator.action.ShouldTargetUnit( lead, UnitUtil::getDistance( parent, lead ) );
            Unit *threat = parent->Threat();
            if (threat)
                unitLocator.action.ShouldTargetUnit( threat, UnitUtil::getDistance( parent, threat ) );
        } else {
            gcounter = 0;
        }
    }
    if (unitLocator.action.mytarg == NULL)      //decided to rechoose or did not have initial target
        findObjects(
            _Universe->activeStarSystem()->collidemap[Unit::UNIT_ONLY], parent->location[Unit::UNIT_ONLY], &unitLocator );
    Unit *mytarg = unitLocator.action.mytarg;
    targetpick += queryTime()-pretable;
    if (mytarg) {
        efrel = parent->getRelation( mytarg );
        mytargrange = UnitUtil::getDistance( parent, mytarg );
    }
    TargetAndRange my_target( mytarg, mytargrange, efrel );
    for (vector< TurretBin >::iterator k = tbin.begin(); k != tbin.end(); ++k)
        k->AssignTargets( my_target, parent->cumulative_transformation_matrix );
    parent->LockTarget( false );
    if (wasnull) {
        if (mytarg) {
            nextframenumpollers[hastarg] += 2;
            if (nextframenumpollers[hastarg] > maxnumpollers)
                nextframenumpollers[hastarg] = maxnumpollers;
        } else {
            lastchangedtarg += targrand.uniformInc( 0, 1 )*minnulltimetoswitch;
            nextframenumpollers[hastarg] -= .05;
            if (nextframenumpollers[hastarg] < minnumpollers)
                nextframenumpollers[hastarg] = minnumpollers;
        }
    } else {
        if (parent->Target() != mytarg) {
            nextframenumpollers[hastarg] += 2;
            if (nextframenumpollers[hastarg] > maxnumpollers)
                nextframenumpollers[hastarg] = maxnumpollers;
        } else {
            nextframenumpollers[hastarg] -= .01;
            if (nextframenumpollers[hastarg] < minnumpollers)
                nextframenumpollers[hastarg] = minnumpollers;
        }
    }
    parent->Target( mytarg );
    parent->LockTarget( true );
    SignalChosenTarget();
}

void FireAt::Cloak	(	bool	enable,
		float	seconds
	)

Definition at line 99 of file hard_coded_scripts.cpp.

{
    lastOrder = new CloakFor( enable, seconds );
}

void FireAt::Execute ( )

virtual

The function that gets called and executes all queued suborders.

Reimplemented from Order.

Reimplemented in Orders::AggressiveAI, and Orders::Ikarus.

Definition at line 700 of file fire.cpp.

References Unit::CloakVisible(), done, Order::Execute(), float, Unit::GetHull(), VegaConfig::getVariable(), int, XMLSupport::parse_float(), SIMULATION_ATOM, Unit::Target(), UNITPTR, and vs_config.

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

{
    lastchangedtarg -= SIMULATION_ATOM;
    bool missilelock = false;
    bool tmp = done;
    Order::Execute();
    done = tmp;
    Unit *targ;
    if (parent->isUnit() == UNITPTR) {
        static float cont_update_time   = XMLSupport::parse_float( vs_config->getVariable( "AI", "ContrabandUpdateTime", "1" ) );
        if (rand() < RAND_MAX*SIMULATION_ATOM/cont_update_time)
            UpdateContrabandSearch();
        static float cont_initiate_time = XMLSupport::parse_float( vs_config->getVariable( "AI", "CommInitiateTime", "300" ) );
        if ( (float) rand() < ( (float) RAND_MAX*(SIMULATION_ATOM/cont_initiate_time) ) ) {
            static float contraband_initiate_time =
                XMLSupport::parse_float( vs_config->getVariable( "AI", "ContrabandInitiateTime", "3000" ) );
            static float comm_to_player = XMLSupport::parse_float( vs_config->getVariable( "AI", "CommToPlayerPercent", ".05" ) );
            static float comm_to_target = XMLSupport::parse_float( vs_config->getVariable( "AI", "CommToTargetPercent", ".25" ) );
            static float contraband_to_player =
                XMLSupport::parse_float( vs_config->getVariable( "AI", "ContrabandToPlayerPercent", ".98" ) );
            static float contraband_to_target =
                XMLSupport::parse_float( vs_config->getVariable( "AI", "ContrabandToTargetPercent", "0.001" ) );

            unsigned int modulo = ( (unsigned int) (contraband_initiate_time/cont_initiate_time) );
            if (modulo < 1)
                modulo = 1;
            if (rand()%modulo)
                RandomInitiateCommunication( comm_to_player, comm_to_target );
            else
                InitiateContrabandSearch( contraband_to_player, contraband_to_target );
        }
    }
    bool shouldfire = false;
    bool istargetjumpableplanet = false;
    if ( ( targ = parent->Target() ) ) {
        istargetjumpableplanet = isJumpablePlanet( targ );
        if (targ->CloakVisible() > .8 && targ->GetHull() >= 0) {
            had_target = true;
            if (parent->GetNumMounts() > 0)
                if (!istargetjumpableplanet)
                    shouldfire |= ShouldFire( targ, missilelock );
        } else {
            if (had_target) {
                had_target = false;
                lastchangedtarg = -100000;
            }
            ChooseTarget();
        }
    } else if (had_target) {
        had_target = false;
        lastchangedtarg = -100000;
    }
    PossiblySwitchTarget( istargetjumpableplanet );
    if ( (!istargetjumpableplanet) && parent->GetNumMounts() > 0 )
        FireWeapons( shouldfire, missilelock );
}

void FireAt::ExecuteLastScriptFor

(

float

time)

Definition at line 58 of file hard_coded_scripts.cpp.

{
    if (lastOrder)
        lastOrder = new ExecuteFor( lastOrder, time );
}

void FireAt::FaceDirection	(	float	distToMatchFacing,
		bool	finish
	)

Definition at line 111 of file hard_coded_scripts.cpp.

{
    lastOrder = new Orders::FaceDirection( distToMatchFacing, finish, 3 );
}

void FireAt::FaceTarget

(

bool

end)

Definition at line 63 of file hard_coded_scripts.cpp.

References FaceTarget().

{
    lastOrder = new Orders::FaceTarget( end, 4 );
}

void FireAt::FaceTargetITTS

(

bool

end)

Definition at line 67 of file hard_coded_scripts.cpp.

{
    lastOrder = new Orders::FaceTargetITTS( end, 4 );
}

void FireAt::FireWeapons ( bool  shouldfire, bool  lockmissile  )

protected

Definition at line 660 of file fire.cpp.

References FireBitmask(), UniverseUtil::GetGameTime(), VegaConfig::getVariable(), XMLSupport::parse_float(), SIMULATION_ATOM, and vs_config.

{
    static float missiledelay     = XMLSupport::parse_float( vs_config->getVariable( "AI", "MissileGunDelay", "4" ) );
    bool fire_missile = lockmissile && rand() < RAND_MAX*missileprobability*SIMULATION_ATOM;
    delay += SIMULATION_ATOM;
    if ( shouldfire && delay < parent->pilot->getReactionTime() )
        return;
    else if (!shouldfire)
        delay = 0;
    if (fire_missile)
        lastmissiletime = UniverseUtil::GetGameTime();
    else if (UniverseUtil::GetGameTime()-lastmissiletime < missiledelay && !fire_missile)
        return;
    parent->Fire( FireBitmask( parent, shouldfire, fire_missile ), true );
}

void FireAt::FormUp

(

QVector

pos)

Definition at line 103 of file hard_coded_scripts.cpp.

{
    lastOrder = new Orders::FormUp( pos );
}

void FireAt::FormUpToOwner

(

QVector

pos)

Definition at line 107 of file hard_coded_scripts.cpp.

{
    lastOrder = new Orders::FormUpToOwner( pos );
}

Unit* Orders::FireAt::GetParent ( )

inline

Definition at line 55 of file fire.h.

References Order::GetParent().

    {
        return CommunicatingAI::GetParent();
    }

bool FireAt::isJumpablePlanet ( Unit *  targ)

protected

Definition at line 676 of file fire.cpp.

References Unit::isUnit(), and PLANETPTR.

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

{
    bool istargetjumpableplanet = targ->isUnit() == PLANETPTR;
    if (istargetjumpableplanet) {
        istargetjumpableplanet = ( !( (Planet*) targ )->GetDestinations().empty() ) && (parent->GetJumpStatus().drive >= 0);
    }
    return istargetjumpableplanet;
}

void FireAt::LastPythonScript

(

)

Definition at line 119 of file hard_coded_scripts.cpp.

References PythonAI< SuperClass >::LastPythonClass().

{
    lastOrder = PythonAI< Orders::FireAt >::LastPythonClass();
}

void FireAt::MatchAngularVelocity	(	bool	terminate,
		Vector	vec,
		bool	local
	)

Definition at line 76 of file hard_coded_scripts.cpp.

References Unit::ClampAngVel(), Order::parent, and BriefingUtil::terminate().

{
    lastOrder = new Orders::MatchAngularVelocity( parent->ClampAngVel( vec ), local, terminate );
}

void FireAt::MatchLinearVelocity	(	bool	terminate,
		Vector	vec,
		bool	afterburn,
		bool	local
	)

Definition at line 71 of file hard_coded_scripts.cpp.

References Unit::ClampVelocity(), Order::parent, BriefingUtil::terminate(), and useAfterburner().

{
    afterburn = afterburn && useAfterburner();
    lastOrder = new Orders::MatchLinearVelocity( parent->ClampVelocity( vec, afterburn ), local, afterburn, terminate );
}

void FireAt::MatchVelocity	(	bool	terminate,
		Vector	vec,
		Vector	angvel,
		bool	afterburn,
		bool	local
	)

Definition at line 93 of file hard_coded_scripts.cpp.

References Unit::ClampAngVel(), Unit::ClampVelocity(), MatchVelocity, Order::parent, BriefingUtil::terminate(), and useAfterburner().

{
    afterburn = afterburn && useAfterburner();
    lastOrder = new Orders::MatchVelocity( parent->ClampVelocity( vec, afterburn ), parent->ClampAngVel(
                                               angvel ), local, afterburn, terminate );
}

void FireAt::MoveTo	(	QVector	vec,
		bool	afterburn
	)

Definition at line 88 of file hard_coded_scripts.cpp.

References MoveTo, and useAfterburner().

{
    afterburn = afterburn && useAfterburner();
    lastOrder = new Orders::MoveTo( vec, afterburn, 3 );
}

virtual std::string Orders::FireAt::Pickle ( )

inlinevirtual

Definition at line 62 of file fire.h.

    {
        return std::string();
    }                                                 //these are to serialize this AI

void FireAt::PossiblySwitchTarget

(

bool

istargetjumpableplanet)

Definition at line 686 of file fire.cpp.

References Flightgroup::directive, VegaConfig::getVariable(), XMLSupport::parse_float(), SIMULATION_ATOM, VSRandom::uniformInc(), vs_config, and vsrandom.

{
    static float targettime = XMLSupport::parse_float( vs_config->getVariable( "AI", "Targetting", "TimeUntilSwitch", "20" ) );
    if ( (targettime <= 0) || (vsrandom.uniformInc( 0, 1 ) < SIMULATION_ATOM/targettime) ) {
        bool ct = true;
        Flightgroup *fg;
        if ( ( fg = parent->getFlightgroup() ) )
            if (fg->directive.find( "." ) != string::npos)
                ct = (parent->Target() == NULL);
        if (ct)
            ChooseTarget();
    }
}

bool FireAt::PursueTarget ( Unit *  un, bool  leader  )

virtual

Reimplemented from Order.

Definition at line 66 of file fire.cpp.

References Unit::getRelation(), Order::parent, and Unit::Target().

{
    if (leader)
        return true;
    if ( un == parent->Target() )
        return rand() < .9*RAND_MAX;
    if (parent->getRelation( un ) < 0)
        return rand() < .2*RAND_MAX;
    return false;
}

void FireAt::ReInit ( float  agglevel)

protected

Definition at line 99 of file fire.cpp.

References agg, delay, distance, UniverseUtil::GetGameTime(), VegaConfig::getVariable(), had_target, lastchangedtarg, lastmissiletime, missileprobability, XMLSupport::parse_float(), targrand, VSRandom::uniformInc(), and vs_config.

Referenced by FireAt().

{
    static float missileprob     = XMLSupport::parse_float( vs_config->getVariable( "AI", "Firing", "MissileProbability", ".01" ) );
    static float mintimetoswitch =
        XMLSupport::parse_float( vs_config->getVariable( "AI", "Targetting", "MinTimeToSwitchTargets", "3" ) );
    lastmissiletime    = UniverseUtil::GetGameTime()-65536.;
    missileprobability = missileprob;
    delay = 0;
    agg = aggressivitylevel;
    distance   = 1;
    //JS --- spreading target switch times
    lastchangedtarg = 0.0-targrand.uniformInc( 0, 1 )*mintimetoswitch;
    had_target = false;
}

virtual void Orders::FireAt::SetParent ( Unit *  parent1)

inlinevirtual

Sets the parent of this Unit. Any virtual functions must call this one.

Reimplemented from Order.

Reimplemented in Orders::AggressiveAI.

Definition at line 51 of file fire.h.

References Order::SetParent().

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

    {
        CommunicatingAI::SetParent( parent );
    }

bool FireAt::ShouldFire ( Unit *  targ, bool &  missilelock  )

protected

Definition at line 574 of file fire.cpp.

References _Universe, UniverseUtil::cos(), f, float, VSRandom::genrand_int31(), Unit::GetComputerData(), UniverseUtil::GetGameTime(), VegaConfig::getVariable(), VSRandom::init_genrand(), int, Universe::isPlayerStarship(), Unit::isUnit(), Unit::Computer::itts, M_PI, Cockpit::number_of_attackers, XMLSupport::parse_float(), XMLSupport::parse_int(), PLANETPTR, Unit::Target(), test, Unit::Threaten(), Cockpit::tooManyAttackers(), vs_config, and VSFileSystem::vs_fprintf().

{
    float dist;
    if (!targ) {
        return false;

        static int test = 0;
        if (test++%1000 == 1)
            VSFileSystem::vs_fprintf( stderr, "lost target" );
    }
    float gunspeed, gunrange, missilerange;
    parent->getAverageGunSpeed( gunspeed, gunrange, missilerange );
    float angle = parent->cosAngleTo( targ, dist, parent->GetComputerData().itts ? gunspeed : FLT_MAX, gunrange, false );
    missilelock = false;
    targ->Threaten( parent, angle/(dist < .8 ? .8 : dist) );
    if ( targ == parent->Target() )
        distance = dist;
    static float firewhen = XMLSupport::parse_float( vs_config->getVariable( "AI", "Firing", "InWeaponRange", "1.2" ) );
    static float fireangle_minagg =
        (float) cos( M_PI*XMLSupport::parse_float( vs_config->getVariable( "AI",
                                                                           "Firing",
                                                                           "MaximumFiringAngle.minagg",
                                                                           "10" ) )/180. );                                                                      //Roughly 10 degrees
    static float fireangle_maxagg =
        (float) cos( M_PI*XMLSupport::parse_float( vs_config->getVariable( "AI",
                                                                           "Firing",
                                                                           "MaximumFiringAngle.maxagg",
                                                                           "18" ) )/180. );                                                                      //Roughly 18 degrees
    float temp   = parent->TrackingGuns( missilelock );
    bool  isjumppoint = targ->isUnit() == PLANETPTR && ( (Planet*) targ )->GetDestinations().empty() == false;
    float fangle = (fireangle_minagg+fireangle_maxagg*agg)/(1.0f+agg);
    bool retval  =
        ( (dist < firewhen)
         && ( (angle > fangle) || ( temp && (angle > temp) ) || ( missilelock && (angle > 0) ) ) ) && !isjumppoint;
    if (retval) {
        if ( Cockpit::tooManyAttackers() ) {
            Cockpit *player = _Universe->isPlayerStarship( targ );
            if (player) {
                static int max_attackers = XMLSupport::parse_int( vs_config->getVariable( "AI", "max_player_attackers", "0" ) );
                int attackers = player->number_of_attackers;
                if (attackers > max_attackers && max_attackers > 0) {
                    static float attacker_switch_time =
                        XMLSupport::parse_float( vs_config->getVariable( "AI", "attacker_switch_time", "15" ) );
                    int curtime = (int) fmod( floor( UniverseUtil::GetGameTime()/attacker_switch_time ), (float) (1<<24) );
                    int seed    = ( ( ( (size_t) parent )&0xffffffff )^curtime );
                    static VSRandom decide( seed );
                    decide.init_genrand( seed );
                    if (decide.genrand_int31()%attackers >= max_attackers) {
                        return false;
                    }
                }
            }
        }
    }
    return retval;
}

void FireAt::SignalChosenTarget ( )

protectedvirtual

Reimplemented in Orders::AggressiveAI.

Definition at line 125 of file fire.cpp.

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

{}

virtual void Orders::FireAt::UnPickle ( std::string  )

inlinevirtual

Definition at line 66 of file fire.h.

{}

void FireAt::XMLScript

(

std::string

script)

Definition at line 115 of file hard_coded_scripts.cpp.

{
    lastOrder = new AIScript( script.c_str() );
}

Member Data Documentation

float Orders::FireAt::agg

protected

Definition at line 17 of file fire.h.

Referenced by ReInit().

float Orders::FireAt::delay

protected

Definition at line 16 of file fire.h.

Referenced by ReInit().

float Orders::FireAt::distance

protected

Definition at line 18 of file fire.h.

Referenced by Orders::AggressiveAI::ProcessLogicItem(), and ReInit().

bool Orders::FireAt::had_target

protected

Definition at line 20 of file fire.h.

Referenced by ReInit().

float Orders::FireAt::lastchangedtarg

protected

Definition at line 19 of file fire.h.

Referenced by ReInit().

float Orders::FireAt::lastmissiletime

protected

Definition at line 15 of file fire.h.

Referenced by ReInit().

float Orders::FireAt::missileprobability

protected

Definition at line 14 of file fire.h.

Referenced by ReInit().

---

The documentation for this class was generated from the following files:

• src/cmd/ai/fire.h
• src/cmd/ai/fire.cpp
• src/cmd/ai/hard_coded_scripts.cpp