Orders::MoveToParent Class Reference

#include <navigation.h>

Public Member Functions
void	SetAfterburn (bool tf)
	MoveToParent (bool aft, unsigned char switchbacks, bool terminating=true)
bool	Execute (Unit *parent, const QVector &targetlocation)

Detailed Description

The moveto order attempts to calculate the best way to apply thrust (within the computer bound limits) to get a starship to place B and stopped. It uses an integral of acceleration and velocity over time to solve for time when to decelerate. Is inaccurate within 1 physics frame, and must use switchbacks and then once they have been met sets terminating X,Y, and Z to figure out how many switchbacks it has made , missing the target and coming back over it.

Definition at line 22 of file navigation.h.

Constructor & Destructor Documentation

Orders::MoveToParent::MoveToParent ( bool  aft, unsigned char  switchbacks, bool  terminating = true  )

inline

Definition at line 38 of file navigation.h.

     : afterburn(aft)
     , switchbacks(switchbacks)
     , terminatingX( 0 )
     , terminatingY( 0 )
     , terminatingZ( 0 )
     , last_velocity( 0, 0, 0 )
     , selfterminating( terminating ) {}

Member Function Documentation

bool MoveToParent::Execute	(	Unit *	parent,
		const QVector &	targetlocation
	)

Definition at line 128 of file navigation.cpp.

References Unit::Limits::afterburn, Unit::ApplyLocalForce(), CalculateBalancedDecelTime(), CalculateDecelTime(), done, float, Unit::Limits::forward, Unit::GetComputerData(), Unit::GetMass(), Unit::GetVelocity(), Unit::Limits::lateral, Unit::Limits(), Unit::Computer::max_ab_speed(), Unit::Computer::max_speed(), Unit::Position(), Unit::Limits::retro, SIMULATION_ATOM, Orders::THRESHOLD, Unit::ToLocalCoordinates(), Unit::UpCoordinateLevel(), Vector, and Unit::Limits::vertical.

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

{
    bool   done = false;
    Vector local_vel( parent->UpCoordinateLevel( parent->GetVelocity() ) );
    //local location is ued for storing the last velocity;
    terminatingX += ( (local_vel.i > 0) != (last_velocity.i > 0) || (!local_vel.i) );
    terminatingY += ( (local_vel.j > 0) != (last_velocity.j > 0) || (!local_vel.j) );
    terminatingZ += ( (local_vel.k > 0) != (last_velocity.k > 0) || (!local_vel.k) );

    last_velocity = local_vel;
    Vector heading      = parent->ToLocalCoordinates( ( targetlocation-parent->Position() ).Cast() );
    Vector thrust( parent->Limits().lateral, parent->Limits().vertical,
                   afterburn ? parent->Limits().afterburn : parent->Limits().forward );
    float  max_speed    =
        ( afterburn ? parent->GetComputerData().max_ab_speed() : parent->GetComputerData().max_speed() );
    Vector normheading  = heading;
    normheading.Normalize();
    Vector max_velocity = max_speed*normheading;
    max_velocity.Set( fabs( max_velocity.i ),
                     fabs( max_velocity.j ),
                     fabs( max_velocity.k ) );
    if (done) return done;       //unreachable

    if (terminatingX > switchbacks
        && terminatingY > switchbacks
        && terminatingZ > switchbacks) {
        if ( Done( last_velocity ) ) {
            if (selfterminating) {
                done = true;
            } else {
                terminatingX = 0;
                terminatingY = 0;
                terminatingZ = 0;
            }
            return done;
        }
        thrust = (-parent->GetMass()/SIMULATION_ATOM)*last_velocity;
    } else {
        float div  = 1.0f;
        float vdiv = 1.0f;
        if (selfterminating && terminatingX > 8 && terminatingY > 8 && terminatingZ > 8) {
            int tmp = (terminatingX-4);
            if (terminatingY < terminatingX) tmp = terminatingY-4;
            if (terminatingZ < terminatingX && terminatingZ < terminatingY) tmp = terminatingZ-4;
            tmp      /= 4;
            if (tmp > 30) tmp = 30;
            vdiv      = (float) (1<<tmp);
            div       = vdiv;
            thrust.i /= div;
            thrust.j /= div;
            thrust.k /= div;
        }
        //start with Forward/Reverse:
        float t = CalculateDecelTime( heading.k, last_velocity.k, thrust.k, parent->Limits().retro/div, parent->GetMass() );
        if (t < THRESHOLD) {
            thrust.k =
                ( thrust.k > 0 ? -parent->Limits().retro
                 /div : ( afterburn ? parent->Limits().afterburn/div : parent->Limits().forward/div ) );
        } else if (t < SIMULATION_ATOM) {
            thrust.k *= t/SIMULATION_ATOM;
            thrust.k +=
                (SIMULATION_ATOM
                 -t)
                *( thrust.k > 0 ? -parent->Limits().retro
                  /div : ( afterburn ? parent->Limits().afterburn/div : parent->Limits().forward/div ) )/SIMULATION_ATOM;
        }
        OptimizeSpeed( parent, last_velocity.k, thrust.k, max_velocity.k/vdiv );
        t = CalculateBalancedDecelTime( heading.i, last_velocity.i, thrust.i, parent->GetMass() );
        if (t < THRESHOLD)
            thrust.i = -thrust.i;
        else if (t < SIMULATION_ATOM)
            thrust.i *= ( t-(SIMULATION_ATOM-t) )/SIMULATION_ATOM;
        OptimizeSpeed( parent, last_velocity.i, thrust.i, max_velocity.i/vdiv );
        t = CalculateBalancedDecelTime( heading.j, last_velocity.j, thrust.j, parent->GetMass() );
        if (t < THRESHOLD)
            thrust.j = -thrust.j;
        else if (t < SIMULATION_ATOM)
            thrust.j *= ( t-(SIMULATION_ATOM-t) )/SIMULATION_ATOM;
        OptimizeSpeed( parent, last_velocity.j, thrust.j, max_velocity.j/vdiv );
    }
    parent->ApplyLocalForce( thrust );

    return done;
}

void Orders::MoveToParent::SetAfterburn ( bool  tf)

inline

Definition at line 34 of file navigation.h.

Referenced by Orders::MoveTo::SetAfterburn().

    {
        afterburn = tf;
    }

---

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

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