anonymous_namespace{autodocking.cpp} Namespace Reference

Functions
boost::optional< size_t >	FindWaypoint (Unit *player, const std::vector< DockingPorts > &dockingPorts, size_t port)
Orders::AutoDocking::DockingPath	FindDockingPort (Unit *player, Unit *station)

Function Documentation

Orders::AutoDocking::DockingPath anonymous_namespace{autodocking.cpp}::FindDockingPort	(	Unit *	player,
		Unit *	station
	)

Definition at line 42 of file autodocking.cpp.

References Unit::DockingPortLocations(), FindWaypoint(), Unit::GetTransformation(), i, Unit::isPlanet(), Magnitude(), max(), Unit::Position(), QVector, Unit::rSize(), second(), and Transform().

Referenced by Orders::AutoDocking::CanDock(), and Orders::AutoDocking::SelectionState().

{
    // FIXME: Prefer outside docking ports (because they are more safe to travel to)
    // FIXME: Ensure line-of-sight to first point
    // FIXME: Start at the closest waypoint (and skip those before it)

    const std::vector<DockingPorts>& dockingPorts = station->DockingPortLocations();

    typedef std::pair<size_t, size_t> PortRange;
    boost::optional<PortRange> candidate;
    float shortestDistance = std::numeric_limits<float>::max();
    const bool isPlanet = station->isPlanet();
    for (size_t i = 0; i < dockingPorts.size(); ++i)
    {
        if (dockingPorts[i].IsOccupied())
            continue;

        // Auto-dockable ports must be marked as connected (even if they have
        // no associated waypoints)
        if (!dockingPorts[i].IsConnected())
            continue;

        // Does our ship fit into the docking port?
        if (dockingPorts[i].GetRadius() < player->rSize())
            continue;

        QVector dockingPosition = Transform(station->GetTransformation(),
                                            dockingPorts[i].GetPosition().Cast());
        float distance = (dockingPosition - player->Position()).Magnitude();
        if (shortestDistance > distance)
        {
            if (isPlanet)
            {
                shortestDistance = distance;
                candidate = PortRange(i, i);
            }
            else
            {
                boost::optional<size_t> waypoint = FindWaypoint(player, dockingPorts, i);
                if (waypoint)
                {
                    shortestDistance = distance;
                    candidate = PortRange(i, *waypoint);
                }
            }
        }
    }

    Orders::AutoDocking::DockingPath result;
    if (candidate)
    {
        assert(candidate->first <= candidate->second);
        for (size_t i = candidate->first; i <= candidate->second; ++i)
        {
            result.push_front(i);
        }
    }
    return result;
}

boost::optional<size_t> anonymous_namespace{autodocking.cpp}::FindWaypoint	(	Unit *	player,
		const std::vector< DockingPorts > &	dockingPorts,
		size_t	port
	)

Definition at line 19 of file autodocking.cpp.

References DockingPorts::GetRadius(), i, DockingPorts::IsDockable(), and Unit::rSize().

Referenced by FindDockingPort().

{
    if (!dockingPorts[port].IsConnected())
        return port;

    // Subsequent waypoints belong to this port and are listed from closest
    // to farthest.
    size_t i = port + 1;
    for (; i < dockingPorts.size(); ++i)
    {
        const DockingPorts& waypoint = dockingPorts[i];
        if (waypoint.IsDockable()) // No further waypoints
            break;
        // Do not use docking port if one of the waypoints are too small
        if (waypoint.GetRadius() < player->rSize())
            return boost::optional<size_t>();
    }
    return i - 1;
}