Orders::AutoDocking Class Reference

#include <autodocking.h>

Inheritance diagram for Orders::AutoDocking:

Public Types
typedef std::deque< size_t >	DockingPath
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 }

Public Member Functions
	AutoDocking (Unit *destination)
void	Execute ()
	The function that gets called and executes all queued suborders. More...
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 ()
virtual void	SetParent (Unit *parent1)
	Sets the parent of this Unit. Any virtual functions must call this one. More...
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)
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 ()
virtual float	getMood ()

Static Public Member Functions
static bool	CanDock (Unit *player, Unit *station)

Protected Member Functions
void	InitialState (Unit *player, Unit *station)
void	SelectionState (Unit *, Unit *)
void	ApproachState (Unit *, Unit *)
void	DockingState (Unit *, Unit *)
void	DockedState (Unit *, Unit *)
void	UndockingState (Unit *, Unit *)
void	DepartureState (Unit *, Unit *)
void	AbortState (Unit *, Unit *)
void	EndState (Unit *, Unit *)
void	EnqueuePort (Unit *, Unit *, size_t)
void	EraseOrders ()
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...

Additional Inherited Members
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 55 of file autodocking.h.

Member Typedef Documentation

typedef std::deque<size_t> Orders::AutoDocking::DockingPath

Definition at line 60 of file autodocking.h.

Constructor & Destructor Documentation

Orders::AutoDocking::AutoDocking

(

Unit *

destination)

Definition at line 108 of file autodocking.cpp.

    : Order(MOVEMENT | FACING, SLOCATION),
      state(&AutoDocking::InitialState),
      target(destination)
{
}

Member Function Documentation

void Orders::AutoDocking::AbortState ( Unit *  player, Unit *  station  )

protected

Definition at line 163 of file autodocking.cpp.

References EndState(), EraseOrders(), PRESS, and FlyByKeyboard::StopKey().

Referenced by InitialState(), and SelectionState().

{
    EraseOrders();
    state = &AutoDocking::EndState;
    
    // Safety: full stop on abort
    KBData kbdata;
    FlyByKeyboard::StopKey(kbdata, PRESS);
}

void Orders::AutoDocking::ApproachState ( Unit *  player, Unit *  station  )

protected

Definition at line 205 of file autodocking.cpp.

References Unit::CanDockWithMe(), Unit::DockingPortLocations(), DockingState(), Order::Execute(), and SelectionState().

Referenced by SelectionState().

{
    assert(!dockingPath.empty());

    // Move to docking port
    if (station->DockingPortLocations()[dockingPath.back()].IsOccupied())
    {
        // Another ship has docked at our port. Find a new port.
        state = &AutoDocking::SelectionState;
    }
    else if (station->CanDockWithMe(player) == dockingPath.back())
    {
        state = &AutoDocking::DockingState;
    }
    else
    {
        // FIXME: Request clearance X times with fixed interval to keep capital ship immobile
        Order::Execute();
    }
}

bool Orders::AutoDocking::CanDock ( Unit *  player, Unit *  station  )

static

Definition at line 130 of file autodocking.cpp.

References anonymous_namespace{autodocking.cpp}::FindDockingPort(), UnitUtil::isCapitalShip(), Unit::IsCleared(), UnitUtil::isCloseEnoughToDock(), and UnitUtil::isDockableUnit().

Referenced by FlyByKeyboard::Execute(), InitialState(), and GameCockpit::LookupUnitStat().

{
    if (!station->IsCleared(player))
    {
        return false;
    }
    else if (UnitUtil::isCapitalShip(player))
    {
        // A capital ship must align one of its docking ports with one of the
        // the station's docking ports. This docking script cannot do that.
        return false;
    }
    else if (!UnitUtil::isDockableUnit(station))
    {
        return false;
    }
    else if (!UnitUtil::isCloseEnoughToDock(player, station))
    {
        return false;
    }
    else if (FindDockingPort(player, station).empty())
    {
        return false;
    }
    return true;
}

void Orders::AutoDocking::DepartureState ( Unit *  player, Unit *  station  )

protected

Definition at line 259 of file autodocking.cpp.

References Order::done, Order::Done(), EndState(), EraseOrders(), and Order::Execute().

Referenced by UndockingState().

{
    Order::Execute();
    if (Done())
    {
        EraseOrders();
        done = false;
        state = &AutoDocking::EndState;
    }
}

void Orders::AutoDocking::DockedState ( Unit *  player, Unit *  station  )

protected

Definition at line 234 of file autodocking.cpp.

References EraseOrders(), and UndockingState().

Referenced by DockingState().

{
    EraseOrders();
    state = &AutoDocking::UndockingState;
}

void Orders::AutoDocking::DockingState ( Unit *  player, Unit *  station  )

protected

Definition at line 226 of file autodocking.cpp.

References DockedState(), and Unit::ForceDock().

Referenced by ApproachState().

{
    assert(!dockingPath.empty());

    player->ForceDock(station, dockingPath.back());
    state = &AutoDocking::DockedState;
}

void Orders::AutoDocking::EndState ( Unit *  player, Unit *  station  )

protected

Definition at line 157 of file autodocking.cpp.

References Unit::autopilotactive, and Order::done.

Referenced by AbortState(), DepartureState(), and UndockingState().

{
    player->autopilotactive = false;
    done = true;
}

void Orders::AutoDocking::EnqueuePort ( Unit *  player, Unit *  station, size_t  port  )

protected

Definition at line 276 of file autodocking.cpp.

References Unit::DockingPortLocations(), Order::EnqueueOrder(), Order::FACING, DockingPorts::GetPosition(), Unit::GetTransformation(), DockingPorts::IsInside(), Order::MOVEMENT, MoveTo, QVector, Transform(), and useAfterburner().

Referenced by SelectionState(), and UndockingState().

{
    // Set the coordinates for the docking port
    const float turningSpeed = 1;
    // If accuracy is too low then the ship does not always turn precisely.
    // An incorrect heading may cause it to fly into corridor walls.
    // If accuracy is too high then the ship turns precisely, but it does
    // not terminate because it is trying to reach a higher accuracy than
    // it can. This causes the ship to freeze.
    const unsigned char accuracy = 7; // Higher means more accurate
    const bool useAfterburner = false;
    const bool terminateAfterUse = true;

    const DockingPorts& currentPort = station->DockingPortLocations()[port];
    QVector position = Transform(station->GetTransformation(),
                                 currentPort.GetPosition().Cast());

    Order *facing = new ChangeHeading(position, accuracy, turningSpeed, terminateAfterUse);
    Order *movement = new MoveTo(position, useAfterburner, accuracy, terminateAfterUse);
    if (currentPort.IsInside())
    {
        // Perform facing and movement sequentially when navigating inside the station
        const unsigned int blockedDuringFacing = MOVEMENT;
        EnqueueOrder(new Sequence(player, facing, blockedDuringFacing));
        const unsigned int blockedDuringMovement = FACING;
        EnqueueOrder(new Sequence(player, movement, blockedDuringMovement));
    }
    else
    {
        // Perform facing and movement simultaneously outside the station
        EnqueueOrder(new Join(player, facing, movement));
    }
}

void Orders::AutoDocking::EraseOrders ( )

protected

Definition at line 270 of file autodocking.cpp.

References Order::eraseType(), Order::FACING, and Order::MOVEMENT.

Referenced by AbortState(), DepartureState(), DockedState(), and SelectionState().

{
    eraseType(FACING);
    eraseType(MOVEMENT);
}

void Orders::AutoDocking::Execute ( )

virtual

The function that gets called and executes all queued suborders.

Reimplemented from Order.

Definition at line 115 of file autodocking.cpp.

References Order::done, Order::GetParent(), and UnitContainer::GetUnit().

{
    Unit *player = GetParent();
    Unit *station = target.GetUnit();
    // Exit if either the ship or the station has been destroyed
    if (player == NULL || station == NULL)
    {
        done = true;
    }
    else
    {
        (this->*state)(player, station);
    }
}

void Orders::AutoDocking::InitialState ( Unit *  player, Unit *  station  )

protected

Definition at line 173 of file autodocking.cpp.

References AbortState(), CanDock(), and SelectionState().

{
    if (CanDock(player, station))
    {
        state = &AutoDocking::SelectionState;
    }
    else
    {
        state = &AutoDocking::AbortState;
    }
}

void Orders::AutoDocking::SelectionState ( Unit *  player, Unit *  station  )

protected

Definition at line 185 of file autodocking.cpp.

References AbortState(), ApproachState(), EnqueuePort(), EraseOrders(), and anonymous_namespace{autodocking.cpp}::FindDockingPort().

Referenced by ApproachState(), and InitialState().

{
    EraseOrders();

    dockingPath = FindDockingPort(player, station);
    if (dockingPath.empty())
    {
        state = &AutoDocking::AbortState;
        return;
    }

    // Enqueue the waypoints from the farthest to the closest.
    for (DockingPath::const_iterator it = dockingPath.begin(); it != dockingPath.end(); ++it)
    {
        EnqueuePort(player, station, *it);
    }

    state = &AutoDocking::ApproachState;
}

void Orders::AutoDocking::UndockingState ( Unit *  player, Unit *  station  )

protected

Definition at line 240 of file autodocking.cpp.

References DepartureState(), Unit::DockingPortLocations(), EndState(), and EnqueuePort().

Referenced by DockedState().

{
    assert(!dockingPath.empty());

    state = &AutoDocking::EndState;

    // Enqueue undocking path if docked at inner port
    if (station->DockingPortLocations()[dockingPath.back()].IsInside())
    {
        DockingPath::reverse_iterator it = dockingPath.rbegin();
        ++it; // Skip the docking port itself
        for (; it != dockingPath.rend(); ++it)
        {
            EnqueuePort(player, station, *it);
            state = &AutoDocking::DepartureState;
        }
    }
}

---

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

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