Orders::AutoLongHaul Class Reference

#include <navigation.h>

Inheritance diagram for Orders::AutoLongHaul:

Public Member Functions
	AutoLongHaul (bool fini=false, int accuracy=1)
virtual void	Execute ()
	The function that gets called and executes all queued suborders. More...
virtual void	SetParent (Unit *parent1)
	Sets the parent of this Unit. Any virtual functions must call this one. More...
virtual string	getOrderDescription ()
virtual	~AutoLongHaul ()
Public Member Functions inherited from Orders::ChangeHeading
	ChangeHeading (const QVector &final_heading, int switchback, float turning_speed=1, bool term=false)
	takes in the destination target, and the ammount of accuracy (how many times it should miss destination and come back) should be used More...
void	SetDest (const QVector &)
virtual	~ChangeHeading ()
Public Member Functions inherited from Order
virtual void	ChooseTarget ()
	this function calls the destructor (needs to be overridden for python; More...
virtual bool	PursueTarget (Unit *, bool isleader)
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...
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...
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	ProcessCommMessage (class CommunicationMessage &c)
	processes a single message...generally called by the Messages() func 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 void	AdjustRelationTo (Unit *un, float factor)
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 ()
virtual float	getMood ()

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 }
Protected Member Functions inherited from Orders::ChangeHeading
void	ResetDone ()
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

Detailed Description

This class analyzes a Unit's position and adjusts ChangeHeading to SPEC towards target

Definition at line 137 of file navigation.h.

Constructor & Destructor Documentation

AutoLongHaul::AutoLongHaul	(	bool	fini = false,
		int	accuracy = 1
	)

Definition at line 438 of file navigation.cpp.

References Order::FACING, Order::MOVEMENT, Order::STARGET, Order::subtype, and Order::type.

                                                    : ChangeHeading( QVector( 0, 0, 1 ), accuracy )
    , finish( fini )
{
    type    = FACING|MOVEMENT;
    subtype = STARGET;
    deactivatewarp      = false;
    StraightToTarget    = true;
    inside_landing_zone = false;
}

AutoLongHaul::~AutoLongHaul ( )

virtual

Definition at line 646 of file navigation.cpp.

References VSFileSystem::vs_fprintf().

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

Member Function Documentation

void AutoLongHaul::Execute ( )

virtual

The function that gets called and executes all queued suborders.

Reimplemented from Orders::ChangeHeading.

Definition at line 511 of file navigation.cpp.

References Unit::autopilotactive, CalculateNearestWarpUnit(), Unit::Computer::combat_mode, UniverseUtil::cos(), Unit::cumulative_transformation_matrix, DistanceWarrantsWarpTo(), Order::done, Orders::ChangeHeading::Execute(), Unit::Limits::forward, Unit::GetComputerData(), Unit::GetMass(), Matrix::getR(), UnitUtil::getSignificantDistance(), UnitContainer::GetUnit(), VegaConfig::getVariable(), Unit::graphicOptions, Order::group, Unit::graphic_options::InWarp, Unit::isSubUnit(), Unit::Limits::lateral, Unit::limits, Unit::LocalPosition(), Unit::Computer::max_combat_ab_speed, mymax(), mymin, XMLSupport::parse_bool(), XMLSupport::parse_float(), Unit::Position(), QVector, Unit::graphic_options::RampCounter, Orders::ChangeHeading::ResetDone(), Unit::Limits::retro, Unit::rSize(), Orders::ChangeHeading::SetDest(), UnitContainer::SetUnit(), speed, Unit::Target(), useJitteryAutopilot(), Unit::Limits::vertical, vs_config, Unit::graphic_options::WarpFieldStrength, and Unit::graphic_options::WarpRamping.

{
    Unit *target = group.GetUnit();
    if (target == NULL) {
        group.SetUnit( parent->Target() );
        done = finish;
        parent->autopilotactive = false;
        return;
    }
    static bool  compensate_for_interdiction =
        XMLSupport::parse_bool( vs_config->getVariable( "physics", "autopilot_compensate_for_interdiction", "false" ) );
    static float enough_warp_for_cruise =
        XMLSupport::parse_float( vs_config->getVariable( "physics", "enough_warp_for_cruise", "1000" ) );
    static float go_perpendicular_speed =
        XMLSupport::parse_float( vs_config->getVariable( "physics", "warp_perpendicular", "80" ) );
    static float min_warp_orbit_radius  =
        XMLSupport::parse_float( vs_config->getVariable( "physics", "min_warp_orbit_radius", "100000000" ) );
    static float warp_orbit_multiplier  =
        XMLSupport::parse_float( vs_config->getVariable( "physics", "warp_orbit_multiplier", "4" ) );
    static float warp_behind_angle =
        cos( 3.1415926536*XMLSupport::parse_float( vs_config->getVariable( "physics", "warp_behind_angle", "150" ) )/180. );
    QVector myposition  = parent->isSubUnit() ? parent->Position() : parent->LocalPosition();     //get unit pos
    QVector destination = target->isSubUnit() ? target->Position() : target->LocalPosition();     //get destination
    QVector destinationdirection = (destination-myposition);       //find vector from us to destination
    double  destinationdistance  = destinationdirection.Magnitude();
    destinationdirection = destinationdirection*(1./destinationdistance);       //this is a direction, so it is normalize
    if (parent->graphicOptions.WarpFieldStrength < enough_warp_for_cruise && parent->graphicOptions.InWarp) {
        //face target unless warp ramping is done and warp is less than some intolerable ammt
        Unit *obstacle = NULL;
        float maxmultiplier = CalculateNearestWarpUnit( parent, FLT_MAX, &obstacle, compensate_for_interdiction );         //find the unit affecting our spec
        bool  currently_inside_landing_zone = false;
        if (obstacle)
            currently_inside_landing_zone = InsideLandingPort( obstacle );
        if (currently_inside_landing_zone != inside_landing_zone) {
            inside_landing_zone = currently_inside_landing_zone;
            MakeLinearVelocityOrder();
        }
        if (maxmultiplier < enough_warp_for_cruise && obstacle != NULL && obstacle != target) {
            //if it exists and is not our destination
            QVector obstacledirection = (obstacle->LocalPosition()-myposition);               //find vector from us to obstacle
            double  obstacledistance  = obstacledirection.Magnitude();

            obstacledirection = obstacledirection*(1./obstacledistance);               //normalize the obstacle direction as well
            float   angle = obstacledirection.Dot( destinationdirection );
            if (obstacledistance-obstacle->rSize() < destinationdistance-target->rSize() && angle > warp_behind_angle) {
                //if our obstacle is closer than obj and the obstacle is not behind us
                QVector planetdest   = destination-obstacle->LocalPosition();                 //find the vector from planet to dest
                QVector planetme     = -obstacledirection;                 //obstacle to me
                QVector planetperp   = planetme.Cross( planetdest );                 //find vector out of that plane
                QVector detourvector = destinationdirection.Cross( planetperp );                 //find vector perpendicular to our desired course emerging from planet
                double  renormalizedetour   = detourvector.Magnitude();
                if (renormalizedetour > .01) detourvector = detourvector*(1./renormalizedetour);                     //normalize it
                double  finaldetourdistance = mymax( obstacle->rSize()*warp_orbit_multiplier, min_warp_orbit_radius );                //scale that direction by some multiplier of obstacle size and a constant
                detourvector = detourvector*finaldetourdistance;                 //we want to go perpendicular to our transit direction by that ammt
                QVector newdestination = NewDestination( obstacle->LocalPosition()+detourvector, finaldetourdistance );                 //add to our position
                float   weight = (maxmultiplier-go_perpendicular_speed)/(enough_warp_for_cruise-go_perpendicular_speed);                   //find out how close we are to our desired warp multiplier and weight our direction by that
                weight *= weight;                 //
                if (maxmultiplier < go_perpendicular_speed) {
                    QVector perpendicular = myposition+planetme*( finaldetourdistance/planetme.Magnitude() );
                    weight = (go_perpendicular_speed-maxmultiplier)/go_perpendicular_speed;
                    destination = weight*perpendicular+(1-weight)*newdestination;
                } else {
                    QVector olddestination = myposition+destinationdirection*finaldetourdistance;                     //destination direction in the same magnitude as the newdestination from the ship
                    destination = newdestination*(1-weight)+olddestination*weight;                       //use the weight to combine our direction and the dest
                }
                StraightToTarget = false;
            } else {
                StraightToTarget = true;
            }
        } else {StraightToTarget = true; }} else if (parent->graphicOptions.WarpFieldStrength >= enough_warp_for_cruise) {
        StraightToTarget = true;
    }
    if (parent->graphicOptions.InWarp == 0 && parent->graphicOptions.RampCounter == 0)
        deactivatewarp = false;
    float mass     = parent->GetMass();
    float minaccel =
        mymin( parent->limits.lateral, mymin( parent->limits.vertical, mymin( parent->limits.forward, parent->limits.retro ) ) );
    if (mass) minaccel /= mass;
    if ( StraightToTarget && useJitteryAutopilot( parent, target, minaccel ) ) {
        QVector cfacing = parent->cumulative_transformation_matrix.getR();         //velocity.Cast();
        float   speed   = cfacing.Magnitude();
        if (speed > .01)
            cfacing = cfacing*(1./speed);
        static float dotLimit =
            cos( 3.1415926536*XMLSupport::parse_float( vs_config->getVariable( "physics",
                                                                               "autopilot_spec_lining_up_angle",
                                                                               "3" ) )/180. );
        if (cfacing.Dot( destinationdirection ) < dotLimit)          //if wanting to face target but overshooting.
            deactivatewarp = true;              //turn off drive
    }
    static bool rampdown = XMLSupport::parse_bool( vs_config->getVariable( "physics", "autopilot_ramp_warp_down", "true" ) );
    if (DistanceWarrantsWarpTo( parent,
                                UnitUtil::getSignificantDistance( parent, target ), false ) && deactivatewarp == false) { \
        if (parent->graphicOptions.InWarp == 0) {
            parent->graphicOptions.InWarp = 1;
            parent->graphicOptions.WarpRamping = 1;
        }
    } else if (parent->graphicOptions.InWarp == 1) {
        parent->graphicOptions.InWarp = 0;
        if (rampdown)
            parent->graphicOptions.WarpRamping = 1;
    }
    SetDest( destination );
    bool combat_mode = parent->GetComputerData().combat_mode;
    parent->GetComputerData().combat_mode = !inside_landing_zone;     //turn off limits in landing zone
    ChangeHeading::Execute();
    parent->GetComputerData().combat_mode = combat_mode;
    if (!finish)
        ResetDone();
    static float distance_to_stop =
        XMLSupport::parse_float( vs_config->getVariable( "physics", "auto_pilot_termination_distance", "6000" ) );
    static float enemy_distance_to_stop =
        XMLSupport::parse_float( vs_config->getVariable( "physics", "auto_pilot_termination_distance_enemy", "24000" ) );
    static bool  do_auto_finish = XMLSupport::parse_bool( vs_config->getVariable( "physics", "autopilot_terminate", "true" ) );
    double dis     = UnitUtil::getSignificantDistance( parent, target );
    bool   stopnow = false;
    float  speed   = parent->GetComputerData().max_combat_ab_speed;
    if (speed && parent->limits.retro) {
        float time_to_destination = dis/speed;         //conservative
        float time_to_stop = speed*mass/parent->limits.retro;
        if (time_to_destination <= time_to_stop)
            stopnow = true;
    }
    if ( do_auto_finish
        && ( stopnow || dis < distance_to_stop || (target->Target() == parent && dis < enemy_distance_to_stop) ) ) {
        parent->autopilotactive = false;
        if (parent->graphicOptions.InWarp == 1) {
            parent->graphicOptions.InWarp = 0;
            if (rampdown)
                parent->graphicOptions.WarpRamping = 1;
        }
        done = true;
    }
}

virtual string Orders::AutoLongHaul::getOrderDescription ( )

inlinevirtual

Reimplemented from Orders::ChangeHeading.

Definition at line 150 of file navigation.h.

    {
        return "ASAP";
    }

void AutoLongHaul::SetParent ( Unit *  parent1)

virtual

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

Reimplemented from Order.

Definition at line 462 of file navigation.cpp.

References Order::group, Order::SetParent(), UnitContainer::SetUnit(), and Unit::Target().

{
    ChangeHeading::SetParent( parent1 );
    group.SetUnit( parent1->Target() );
    inside_landing_zone = false;
    MakeLinearVelocityOrder();
}

---

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

• src/cmd/ai/navigation.h
• src/cmd/ai/navigation.cpp