#include <docking.h>

Inheritance diagram for Orders::DockingOps:

Public Member Functions
QVector	Movement (Unit *utdw)

	DockingOps (Unit unitToDockWith, Order oldstate, bool physicallyDock, bool keeptrying)

virtual void	SetParent (Unit *par)
	Sets the parent of this Unit. Any virtual functions must call this one. More...

void	Execute ()
	The function that gets called and executes all queued suborders. More...

bool	RequestClearence (Unit *)

bool	DockToTarget (Unit *)

bool	PerformDockingOperations (Unit *)

bool	Undock (Unit *)

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...

void	RestoreOldAI ()

Public Member Functions inherited from Orders::MoveTo
void	SetAfterburn (bool tf)
	The last_velocity keeps track of the previous velocity so the script may determine if it has crossed over 0 this frame or not. More...

	MoveTo (const QVector &target, bool aft, unsigned char switchbacks, bool terminating=true)
	takes in the destination target, whether afterburners should be applied, and the ammount of accuracy (how many times it shoudl miss destination and come back) should be used More...

void	SetDest (const QVector &)

virtual	~MoveTo ()

virtual string	getOrderDescription ()

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...

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 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 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

Definition at line 4 of file docking.h.

Constructor & Destructor Documentation

Orders::DockingOps::DockingOps	(	Unit *	unitToDockWith,
		Order *	oldstate,
		bool	physicallyDock,
		bool	keeptrying
	)

Definition at line 23 of file docking.cpp.

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

                                                                                                : MoveTo( QVector( 0, 0, 1 ),
                                                                                                            false,
                                                                                                            10, false )
     , docking( unitToDockWith )
     , state( GETCLEARENCE )
     , oldstate( ai )
 {
     formerOwnerDoNotDereference = NULL;
     this->keeptrying = keeptrying;
     facedtarget = false;
     physicallyDock   = true;
     port  = -1;
     static float temptimer = XMLSupport::parse_float( vs_config->getVariable( "physics", "docking_time", "10" ) );
     timer = temptimer;
 }

Member Function Documentation

void Orders::DockingOps::Destroy ( )

virtual

The virutal function that unrefs all memory then calls Destruct () which takes care of unreffing this or calling delete on this.

Reimplemented from Order.

Definition at line 86 of file docking.cpp.

References Order::Destroy(), Order::parent, Unit::SetOwner(), and UnitContainer::SetUnit().

Referenced by Execute().

 {
     if (parent) {
         if (oldstate)
             oldstate->Destroy();
         oldstate = NULL;
         if (formerOwnerDoNotDereference) {
             parent->SetOwner( (Unit*) formerOwnerDoNotDereference );             //set owner will not deref
             formerOwnerDoNotDereference = NULL;
         }
     }
     docking.SetUnit( NULL );
 }

bool Orders::DockingOps::DockToTarget ( Unit * utdw)

Definition at line 150 of file docking.cpp.

References Unit::Dock(), DockedScript(), Unit::DockingPortLocations(), VegaConfig::getVariable(), Unit::isUnit(), Movement(), Order::parent, XMLSupport::parse_float(), PLANETPTR, Unit::Position(), QVector, Unit::RefillWarpEnergy(), Unit::rSize(), UnitContainer::SetUnit(), SIMULATION_ATOM, vs_config, and Unit::WarpCapData().

Referenced by Execute().

 {
     if (utdw->DockingPortLocations()[port].IsOccupied()) {
         if (keeptrying) {
             state = GETCLEARENCE;
             return false;
         } else {
             docking.SetUnit( NULL );
             state = GETCLEARENCE;
             return false;
         }
     }
     QVector loc      = Movement( utdw );
     float   rad      = utdw->DockingPortLocations()[port].GetRadius() + parent->rSize();
     float   diss     = (parent->Position()-loc).MagnitudeSquared()-.1;
     bool    isplanet = utdw->isUnit() == PLANETPTR;
     static float MinimumCapacityToRefuelOnLand =
         XMLSupport::parse_float( vs_config->getVariable( "physics", "MinimumWarpCapToRefuelDockeesAutomatically", "0" ) );
     if ( diss <= ( isplanet ? rad*rad : parent->rSize()*parent->rSize() ) ) {
         DockedScript( parent, utdw );
         if (physicallyDock) {
             return parent->Dock( utdw );
         } else {
             float maxWillingToRefill = utdw->WarpCapData();
             if (maxWillingToRefill >= MinimumCapacityToRefuelOnLand)
                 parent->RefillWarpEnergy();                  //BUCO! This needs its own units.csv column to see how much we refill!
             return true;
         }
     } else if (diss <= 1.2*rad*rad) {
         timer += SIMULATION_ATOM;
         static float tmp = XMLSupport::parse_float( vs_config->getVariable( "physics", "docking_time", "10" ) );
         if (timer >= 1.5*tmp) {
             if (physicallyDock) {
                 return parent->Dock( utdw );
             } else {
                 float maxWillingToRefill = utdw->WarpCapData();
                 if (maxWillingToRefill >= MinimumCapacityToRefuelOnLand)
                     parent->RefillWarpEnergy();                      //BUCO! This needs its own units.csv column to see how much we refill!
                 return true;
             }
         }
     }
     return false;
 }

void Orders::DockingOps::Execute ( )

virtual

The function that gets called and executes all queued suborders.

Reimplemented from Orders::MoveTo.

Definition at line 46 of file docking.cpp.

References Destroy(), DockToTarget(), Order::done, UnitContainer::GetUnit(), Order::parent, PerformDockingOperations(), RequestClearence(), RestoreOldAI(), Unit::SetAngularVelocity(), Undock(), and Vector.

 {
     Unit *utdw = docking.GetUnit();
     if (parent == utdw || utdw == NULL) {
         RestoreOldAI();
         Destroy();
         return;
     }
     switch (state)
     {
     case GETCLEARENCE:
         if ( !RequestClearence( utdw ) ) {
             if (!keeptrying) {
                 RestoreOldAI();
                 Destroy();
                 return;
             }
         } else {
             state = DOCKING;
             //no break
         }
     case DOCKING:
         if ( DockToTarget( utdw ) )
             state = DOCKED;
         break;
     case DOCKED:
         if ( PerformDockingOperations( utdw ) )
             state = UNDOCKING;
         break;
     case UNDOCKING:
         if ( Undock( utdw ) ) {
             RestoreOldAI();
             Destroy();
             return;
         }
         break;
     }
     parent->SetAngularVelocity( Vector( 0, 0, 0 ) );     //FIXME if you want it to turn to dock point
     done = false;
 }

QVector Orders::DockingOps::Movement ( Unit * utdw)

Definition at line 135 of file docking.cpp.

References DistanceWarrantsTravelTo(), Unit::DockingPortLocations(), Order::EnqueueOrder(), Orders::MoveTo::Execute(), Unit::GetTransformation(), Magnitude(), Order::parent, Unit::Position(), QVector, Orders::MoveTo::SetAfterburn(), Orders::MoveTo::SetDest(), Transform(), and WarpToP().

Referenced by DockToTarget(), and PerformDockingOperations().

 {
     const QVector loc( Transform( utdw->GetTransformation(), utdw->DockingPortLocations()[port].GetPosition().Cast() ) );
     SetDest( loc );
 
     SetAfterburn( DistanceWarrantsTravelTo( parent, ( loc-parent->Position() ).Magnitude(), true ) );
     if (!facedtarget) {
         facedtarget = true;
         EnqueueOrder( new ChangeHeading( loc, 4, 1, true ) );
     }
     MoveTo::Execute();
     if (rand()%256 == 0)
         WarpToP( parent, utdw, true );
     return loc;
 }

bool Orders::DockingOps::PerformDockingOperations ( Unit * utdw)

Definition at line 194 of file docking.cpp.

References Order::EnqueueOrder(), Orders::MoveTo::Execute(), VegaConfig::getVariable(), Unit::isUnit(), Movement(), Order::parent, XMLSupport::parse_float(), PLANETPTR, Unit::Position(), QVector, Orders::MoveTo::SetDest(), SIMULATION_ATOM, Unit::UnDock(), up, and vs_config.

Referenced by Execute().

 {
     timer -= SIMULATION_ATOM;
     bool isplanet = utdw->isUnit() == PLANETPTR;
     if (timer < 0) {
         static float tmp = XMLSupport::parse_float( vs_config->getVariable( "physics", "un_docking_time", "180" ) );
         timer = tmp;
         EnqueueOrder( new ChangeHeading( parent->Position()*2-utdw->Position(), 4, 1, true ) );
         if (physicallyDock)
             return parent->UnDock( utdw );
         else
             return true;
     } else if (!physicallyDock) {
         if (isplanet) {
             //orbit;
             QVector cur = utdw->Position()-parent->Position();
             QVector up  = QVector( 0, 1, 0 );
             if (up.i == cur.i && up.j == cur.j && up.k == cur.k)
                 up = QVector( 0, 0, 1 );
             SetDest( cur.Cross( up )*10000 );
             MoveTo::Execute();
         } else {
             Movement( utdw );
         }
     }
     return false;
 }

bool Orders::DockingOps::RequestClearence ( Unit * utdw)

Definition at line 126 of file docking.cpp.

References Order::parent, Unit::RequestClearance(), and Orders::SelectDockPort().

Referenced by Execute().

 {
     if ( physicallyDock && !utdw->RequestClearance( parent ) )
         return false;
     port = SelectDockPort( utdw, parent );
     if (port == -1)
         return false;
     return true;
 }

void Orders::DockingOps::RestoreOldAI ( )

Definition at line 99 of file docking.cpp.

References Unit::aistate, Order::parent, and Unit::SetOwner().

Referenced by Execute().

 {
     if (parent) {
         parent->aistate = oldstate;         //that's me!
         if (formerOwnerDoNotDereference) {
             parent->SetOwner( (Unit*) formerOwnerDoNotDereference );
             formerOwnerDoNotDereference = NULL;
         }
         oldstate = NULL;
     }
 }

void Orders::DockingOps::SetParent ( Unit * parent1)

virtual

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

Reimplemented from Order.

Definition at line 38 of file docking.cpp.

References UnitContainer::GetUnit(), Unit::owner, Order::parent, Unit::SetOwner(), and Order::SetParent().

 {
     MoveTo::SetParent( par );
     if (parent) {
         formerOwnerDoNotDereference = parent->owner;
         parent->SetOwner( docking.GetUnit() );
     }
 }

bool Orders::DockingOps::Undock ( Unit * utdw)

Definition at line 221 of file docking.cpp.

References Order::done, Orders::MoveTo::Execute(), Order::parent, Unit::Position(), QVector, Unit::rSize(), Orders::MoveTo::SetDest(), and SIMULATION_ATOM.

Referenced by Execute().

 {
     //this is a good heuristic... find the location where you are.compare with center...then fly the fuck away
     QVector awaydir = parent->Position()-utdw->Position();
     float   len     = ( (utdw->rSize()+parent->rSize()*2)/awaydir.Magnitude() );
     awaydir *= len;
     SetDest( awaydir+utdw->Position() );
     MoveTo::Execute();
     timer   -= SIMULATION_ATOM;
     return (len < 1) || done || timer < 0;
 }

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

src/cmd/ai/docking.h
src/cmd/ai/docking.cpp

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation