navigation.h

Go to the documentation of this file.

#ifndef _CMD_NAVIGATION_ORDERS_H_
#define _CMD_NAVIGATION_ORDERS_H_

#include "order.h"
#include "vegastrike.h"
#include "vs_globals.h"

namespace Orders
{
const float bleed_threshold = 0.0001;
const float THRESHOLD = 0.01;

class MoveToParent
{
    bool afterburn;
    unsigned char switchbacks;
    unsigned char terminatingX;
    unsigned char terminatingY;
    unsigned char terminatingZ;
    Vector last_velocity;
    bool OptimizeSpeed( Unit *parent, float v, float &a, float max_speed );
    bool Done( const Vector& );
    bool   selfterminating;
public:
    void SetAfterburn( bool tf )
    {
        afterburn = tf;
    }
 MoveToParent( bool aft, unsigned char switchbacks, bool terminating = true )
     : afterburn(aft)
     , switchbacks(switchbacks)
     , terminatingX( 0 )
     , terminatingY( 0 )
     , terminatingZ( 0 )
     , last_velocity( 0, 0, 0 )
     , selfterminating( terminating ) {}
    bool Execute( Unit *parent, const QVector &targetlocation );
};
class MoveTo : public Order
{
    MoveToParent m;
public:
    void SetAfterburn( bool tf )
    {
        m.SetAfterburn( tf );
    }
    MoveTo( const QVector &target, bool aft, unsigned char switchbacks, bool terminating = true ) : Order( MOVEMENT,
                                                                                                              SLOCATION )
        , m( aft, switchbacks, terminating )
    {
        targetlocation = target;
        done = false;
    }
    void SetDest( const QVector& );
    virtual void Execute();
    virtual ~MoveTo();
    virtual string getOrderDescription()
    {
        return "moveto";
    }
};
class ChangeHeading : public Order
{
    float turningspeed;
    unsigned char switchbacks;
    unsigned char terminatingX;
    unsigned char terminatingY;
    Vector  last_velocity;
    QVector final_heading;
    bool    terminating;
    bool OptimizeAngSpeed( float limitpos, float limitneg, float v, float &a );
    bool Done( const Vector& );
    void TurnToward( float angle, float ang_vel, float &torque );
protected:
    void ResetDone()
    {
        done = false;
        terminatingX = terminatingY = 0;
    }

public:
    ChangeHeading( const QVector &final_heading, int switchback, float turning_speed = 1, bool term = false ) : Order( FACING,
                                                                                                                       SLOCATION )
        , turningspeed( turning_speed )
        , switchbacks( switchback )
        , terminatingX( 0 )
        , terminatingY( 0 )
        , last_velocity( 0, 0, 0 )
        , final_heading( final_heading )
        , terminating( term ) {}
    void SetDest( const QVector& );
    virtual void Execute();
    virtual string getOrderDescription()
    {
        return "chhead";
    }
    virtual ~ChangeHeading();
};
class FaceTarget : public ChangeHeading
{
    bool finish;
public: FaceTarget( bool fini = false, int accuracy = 3 );
    virtual void Execute();
    virtual string getOrderDescription()
    {
        return "facet";
    }
    virtual ~FaceTarget();
};
class AutoLongHaul : public ChangeHeading
{
    bool finish;
    bool deactivatewarp;
    bool StraightToTarget;
    bool inside_landing_zone;

    void MakeLinearVelocityOrder();
    bool InsideLandingPort( const Unit *obstacle ) const;
    QVector NewDestination( const QVector &curnewdestination, double magnitude );
public: AutoLongHaul( bool fini = false, int accuracy = 1 );
    virtual void Execute();
    virtual void SetParent( Unit *parent1 );
    virtual string getOrderDescription()
    {
        return "ASAP";
    }
    virtual ~AutoLongHaul();
};
class FaceTargetITTS : public ChangeHeading
{
    bool  finish;
    float speed;
    bool  useitts;
public: FaceTargetITTS( bool fini = false, int accuracy = 3 );
    virtual void Execute();
    virtual string getOrderDescription()
    {
        return "faceitts";
    }
    virtual ~FaceTargetITTS();
};
class FormUp : public MoveTo
{
    QVector Pos;
public: FormUp( const QVector &Position );
    void SetPos( const QVector& );
    virtual void SetParent( Unit *parent1 );
    virtual void Execute();
    virtual string getOrderDescription()
    {
        return "formup";
    }
    virtual ~FormUp();
};
class FormUpToOwner : public MoveTo
{
    QVector Pos;
public: FormUpToOwner( const QVector &Position );
    void SetPos( const QVector& );
    virtual void SetParent( Unit *parent1 );
    virtual void Execute();
    virtual string getOrderDescription()
    {
        return "formuptoowner";
    }
    virtual ~FormUpToOwner();
};
class FaceDirection : public ChangeHeading
{
    bool  finish;
    float dist;
public: FaceDirection( float distToMatchFacing, bool fini = false, int accuracy = 3 );
    virtual void SetParent( Unit *parent1 );
    virtual void Execute();
    virtual string getOrderDescription()
    {
        return "facedir";
    }
    virtual ~FaceDirection();
};
}
#endif