Differential D1903 Diff 8042 source/simulation2/components/CCmpUnitMotion.cpp

Changeset View

Standalone View

source/simulation2/components/CCmpUnitMotion.cpp

Show First 20 Lines • Show All 140 Lines • ▼ Show 20 Lines	public:

entity_pos_t m_Clearance;		entity_pos_t m_Clearance;

// cached for efficiency		// cached for efficiency
fixed m_WalkSpeed, m_RunMultiplier;		fixed m_WalkSpeed, m_RunMultiplier;

bool m_FacePointAfterMove;		bool m_FacePointAfterMove;

enum PathState		struct Ticket {
		StanUnsubmitted Not Done Inline Actions Why not Request and m_RequestId ? or PathComputeRequest but that's a bit long. Stan: Why not Request and m_RequestId ? or PathComputeRequest but that's a bit long.
{		u32 m_Ticket = 0; // asynchronous request ID we're waiting for, or 0 if none
/*		enum Type {
* There is no path.		SHORT_PATH,
* (This should only happen in IDLE and STOPPING.)		LONG_PATH
*/		} m_Type;
PATHSTATE_NONE,

/*
* We have an outstanding long path request.
* No paths are usable yet, so we can't move anywhere.
*/
PATHSTATE_WAITING_REQUESTING_LONG,

/*
* We have an outstanding short path request.
* m_LongPath is valid.
* m_ShortPath is not yet valid, so we can't move anywhere.
*/
PATHSTATE_WAITING_REQUESTING_SHORT,

/*
* We are following our path, and have no path requests.
* m_LongPath and m_ShortPath are valid.
*/
PATHSTATE_FOLLOWING,

/*
* We are following our path, and have an outstanding long path request.
* (This is because our target moved a long way and we need to recompute
* the whole path).
* m_LongPath and m_ShortPath are valid.
*/
PATHSTATE_FOLLOWING_REQUESTING_LONG,

/*
* We are following our path, and have an outstanding short path request.
* (This is because our target moved and we've got a new long path
* which we need to follow).
* m_LongPath is valid; m_ShortPath is valid but obsolete.
*/
PATHSTATE_FOLLOWING_REQUESTING_SHORT,

PATHSTATE_MAX
};
u8 m_PathState;

u32 m_ExpectedPathTicket; // asynchronous request ID we're waiting for, or 0 if none		void clear() { m_Ticket = 0; }
		} m_ExpectedPathTicket;

struct MoveRequest {		struct MoveRequest {
enum Type {		enum Type {
NONE,		NONE,
POINT,		POINT,
ENTITY,		ENTITY,
OFFSET		OFFSET
} m_Type = NONE;		} m_Type = NONE;
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines	if (cmpPathfinder)
m_PassClass = cmpPathfinder->GetPassabilityClass(m_PassClassName);		m_PassClass = cmpPathfinder->GetPassabilityClass(m_PassClassName);
m_Clearance = cmpPathfinder->GetClearance(m_PassClass);		m_Clearance = cmpPathfinder->GetClearance(m_PassClass);

CmpPtr<ICmpObstruction> cmpObstruction(GetEntityHandle());		CmpPtr<ICmpObstruction> cmpObstruction(GetEntityHandle());
if (cmpObstruction)		if (cmpObstruction)
cmpObstruction->SetUnitClearance(m_Clearance);		cmpObstruction->SetUnitClearance(m_Clearance);
}		}

m_PathState = PATHSTATE_NONE;

m_ExpectedPathTicket = 0;

m_Tries = 0;		m_Tries = 0;

m_DebugOverlayEnabled = false;		m_DebugOverlayEnabled = false;
}		}

virtual void Deinit()		virtual void Deinit()
{		{
}		}

template<typename S>		template<typename S>
void SerializeCommon(S& serialize)		void SerializeCommon(S& serialize)
{		{
serialize.NumberU8("path state", m_PathState, 0, PATHSTATE_MAX-1);

serialize.StringASCII("pass class", m_PassClassName, 0, 64);		serialize.StringASCII("pass class", m_PassClassName, 0, 64);

serialize.NumberU32_Unbounded("ticket", m_ExpectedPathTicket);		serialize.NumberU32_Unbounded("ticket", m_ExpectedPathTicket.m_Ticket);
		SerializeU8_Enum<Ticket::Type, Ticket::Type::LONG_PATH>()(serialize, "ticket type", m_ExpectedPathTicket.m_Type);

m_MoveRequest.Serialize(serialize);		m_MoveRequest.Serialize(serialize);

serialize.NumberFixed_Unbounded("speed multiplier", m_SpeedMultiplier);		serialize.NumberFixed_Unbounded("speed multiplier", m_SpeedMultiplier);

serialize.NumberFixed_Unbounded("current speed", m_CurSpeed);		serialize.NumberFixed_Unbounded("current speed", m_CurSpeed);

serialize.Bool("facePointAfterMove", m_FacePointAfterMove);		serialize.Bool("facePointAfterMove", m_FacePointAfterMove);
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines	if (m_FacePointAfterMove)
{		{
CFixedVector2D targetPos;		CFixedVector2D targetPos;
if (ComputeTargetPosition(targetPos))		if (ComputeTargetPosition(targetPos))
FaceTowardsPointFromPos(cmpPosition->GetPosition2D(), targetPos.X, targetPos.Y);		FaceTowardsPointFromPos(cmpPosition->GetPosition2D(), targetPos.X, targetPos.Y);
}		}
}		}

m_MoveRequest = MoveRequest();		m_MoveRequest = MoveRequest();
m_ExpectedPathTicket = 0;		m_ExpectedPathTicket.clear();
m_PathState = PATHSTATE_NONE;
m_LongPath.m_Waypoints.clear();		m_LongPath.m_Waypoints.clear();
m_ShortPath.m_Waypoints.clear();		m_ShortPath.m_Waypoints.clear();
}		}

virtual entity_pos_t GetUnitClearance() const		virtual entity_pos_t GetUnitClearance() const
{		{
return m_Clearance;		return m_Clearance;
}		}
Show All 10 Lines	bool IsFormationMember() const
return m_MoveRequest.m_Type == MoveRequest::OFFSET;		return m_MoveRequest.m_Type == MoveRequest::OFFSET;
}		}

entity_id_t GetGroup() const		entity_id_t GetGroup() const
{		{
return IsFormationMember() ? m_MoveRequest.m_Entity : GetEntityId();		return IsFormationMember() ? m_MoveRequest.m_Entity : GetEntityId();
}		}

bool HasValidPath() const
{
return m_PathState == PATHSTATE_FOLLOWING
\|\| m_PathState == PATHSTATE_FOLLOWING_REQUESTING_LONG
\|\| m_PathState == PATHSTATE_FOLLOWING_REQUESTING_SHORT;
}

void MoveFailed()		void MoveFailed()
{		{
CMessageMotionChanged msg(true);		CMessageMotionChanged msg(true);
GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);		GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
}		}

void MoveSucceeded()		void MoveSucceeded()
{		{
▲ Show 20 Lines • Show All 149 Lines • ▼ Show 20 Lines	private:
void RenderSubmit(SceneCollector& collector);		void RenderSubmit(SceneCollector& collector);
};		};

REGISTER_COMPONENT_TYPE(UnitMotion)		REGISTER_COMPONENT_TYPE(UnitMotion)

void CCmpUnitMotion::PathResult(u32 ticket, const WaypointPath& path)		void CCmpUnitMotion::PathResult(u32 ticket, const WaypointPath& path)
{		{
// Ignore obsolete path requests		// Ignore obsolete path requests
if (ticket != m_ExpectedPathTicket)		if (ticket != m_ExpectedPathTicket.m_Ticket)
return;		return;

m_ExpectedPathTicket = 0; // we don't expect to get this result again		m_ExpectedPathTicket.m_Ticket = 0; // Keep ticket metadata

// Check that we are still able to do something with that path		// Check that we are still able to do something with that path
CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());		CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
if (!cmpPosition \|\| !cmpPosition->IsInWorld())		if (!cmpPosition \|\| !cmpPosition->IsInWorld())
{		{
// We will probably fail to move so inform components but keep on trying anyways.		// We will probably fail to move so inform components but keep on trying anyways.
MoveFailed();		MoveFailed();
return;		return;
}		}

if (m_PathState == PATHSTATE_WAITING_REQUESTING_LONG \|\| m_PathState == PATHSTATE_FOLLOWING_REQUESTING_LONG)		if (m_ExpectedPathTicket.m_Type == Ticket::LONG_PATH)
{		{
m_LongPath = path;		m_LongPath = path;

// If we are following a path, leave the old m_ShortPath so we can carry on following it
// until a new short path has been computed
if (m_PathState == PATHSTATE_WAITING_REQUESTING_LONG)
m_ShortPath.m_Waypoints.clear();		m_ShortPath.m_Waypoints.clear();

// If there's no waypoints then we couldn't get near the target.		// If there's no waypoints then we couldn't get near the target.
// Sort of hack: Just try going directly to the goal point instead		// Sort of hack: Just try going directly to the goal point instead
// (via the short pathfinder), so if we're stuck and the user clicks		// (via the short pathfinder), so if we're stuck and the user clicks
// close enough to the unit then we can probably get unstuck		// close enough to the unit then we can probably get unstuck
if (m_LongPath.m_Waypoints.empty())		if (m_LongPath.m_Waypoints.empty())
{		{
CFixedVector2D targetPos;		CFixedVector2D targetPos;
if (ComputeTargetPosition(targetPos))		if (ComputeTargetPosition(targetPos))
m_LongPath.m_Waypoints.emplace_back(Waypoint{ targetPos.X, targetPos.Y });		m_LongPath.m_Waypoints.emplace_back(Waypoint{ targetPos.X, targetPos.Y });
}		}

m_PathState = PATHSTATE_FOLLOWING;
}		}
else if (m_PathState == PATHSTATE_WAITING_REQUESTING_SHORT \|\| m_PathState == PATHSTATE_FOLLOWING_REQUESTING_SHORT)		else
{		{
m_ShortPath = path;		m_ShortPath = path;

// If there's no waypoints then we couldn't get near the target		// If there's no waypoints then we couldn't get near the target
if (m_ShortPath.m_Waypoints.empty())		if (m_ShortPath.m_Waypoints.empty())
{		{
// If we're globally following a long path, try to remove the next waypoint, it might be obstructed		// If we're globally following a long path, try to remove the next waypoint, it might be obstructed (e.g. by idle entities)
// If not, and we are not in a formation, retry		// If not, and we are not in a formation, retry
// unless we are close to our target and we don't have a target entity.		// unless we are close to our target and we don't have a target entity.
// This makes sure that units don't clump too much when they are not in a formation and tasked to move.		// This makes sure that units don't clump too much when they are not in a formation and tasked to move.
if (m_LongPath.m_Waypoints.size() > 1)		if (m_LongPath.m_Waypoints.size() > 1)
m_LongPath.m_Waypoints.pop_back();		m_LongPath.m_Waypoints.pop_back();
else if (IsFormationMember())		else if (IsFormationMember())
{		{
CMessageMotionChanged msg(true);		CMessageMotionChanged msg(true);
Show All 14 Lines	if (m_ShortPath.m_Waypoints.empty())
{		{
MoveSucceeded();		MoveSucceeded();
return;		return;
}		}

PathGoal goal;		PathGoal goal;
ComputeGoal(goal, m_MoveRequest);		ComputeGoal(goal, m_MoveRequest);
RequestLongPath(pos, goal);		RequestLongPath(pos, goal);
m_PathState = PATHSTATE_WAITING_REQUESTING_LONG;
return;		return;
}		}

// else we could, so reset our number of tries.		// else we could, so reset our number of tries.
m_Tries = 0;		m_Tries = 0;

m_PathState = PATHSTATE_FOLLOWING;
}		}
else
LOGWARNING("unexpected PathResult (%u %d)", GetEntityId(), m_PathState);
}		}

void CCmpUnitMotion::Move(fixed dt)		void CCmpUnitMotion::Move(fixed dt)
{		{
PROFILE("Move");		PROFILE("Move");

// If we were idle and will still be, we can return.		// If we were idle and will still be, we can return.
// TODO: this will need to be removed if pushing is implented.		// TODO: this will need to be removed if pushing is implented.
if (m_CurSpeed == fixed::Zero() && m_MoveRequest.m_Type == MoveRequest::NONE)		if (m_CurSpeed == fixed::Zero() && m_MoveRequest.m_Type == MoveRequest::NONE)
return;		return;

if (m_PathState == PATHSTATE_FOLLOWING && PossiblyAtDestination())		if (PossiblyAtDestination())
MoveSucceeded();		MoveSucceeded();

CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());		CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
if (!cmpPosition \|\| !cmpPosition->IsInWorld())		if (!cmpPosition \|\| !cmpPosition->IsInWorld())
return;		return;

CFixedVector2D initialPos = cmpPosition->GetPosition2D();		CFixedVector2D initialPos = cmpPosition->GetPosition2D();

// Keep track of the current unit's position during the update		// Keep track of the current unit's position during the update
CFixedVector2D pos = initialPos;		CFixedVector2D pos = initialPos;

// If we're chasing a potentially-moving unit and are currently close		// If we're chasing a potentially-moving unit and are currently close
// enough to its current position, and we can head in a straight line		// enough to its current position, and we can head in a straight line
// to it, then throw away our current path and go straight to it		// to it, then throw away our current path and go straight to it
if (m_PathState == PATHSTATE_FOLLOWING \|\|
m_PathState == PATHSTATE_FOLLOWING_REQUESTING_SHORT \|\|
m_PathState == PATHSTATE_FOLLOWING_REQUESTING_LONG)
TryGoingStraightToTargetEntity(initialPos);		TryGoingStraightToTargetEntity(initialPos);

bool wasObstructed = PerformMove(dt, m_ShortPath, m_LongPath, pos);		bool wasObstructed = PerformMove(dt, m_ShortPath, m_LongPath, pos);

// Update our speed over this turn so that the visual actor shows the correct animation.		// Update our speed over this turn so that the visual actor shows the correct animation.
if (pos == initialPos)		if (pos == initialPos)
UpdateMovementState(fixed::Zero());		UpdateMovementState(fixed::Zero());
else		else
{		{
// Update the Position component after our movement (if we actually moved anywhere)		// Update the Position component after our movement (if we actually moved anywhere)
CFixedVector2D offset = pos - initialPos;		CFixedVector2D offset = pos - initialPos;

// Face towards the target		// Face towards the target
entity_angle_t angle = atan2_approx(offset.X, offset.Y);		entity_angle_t angle = atan2_approx(offset.X, offset.Y);
cmpPosition->MoveAndTurnTo(pos.X,pos.Y, angle);		cmpPosition->MoveAndTurnTo(pos.X,pos.Y, angle);

// Calculate the mean speed over this past turn.		// Calculate the mean speed over this past turn.
UpdateMovementState(offset.Length() / dt);		UpdateMovementState(offset.Length() / dt);
}		}

if (wasObstructed && HandleObstructedMove())		if (wasObstructed && HandleObstructedMove())
return;		return;

if (m_PathState == PATHSTATE_FOLLOWING)
{
// We may need to recompute our path sometimes (e.g. if our target moves).		// We may need to recompute our path sometimes (e.g. if our target moves).
// Since we request paths asynchronously anyways, this does not need to be done before moving.		// Since we request paths asynchronously anyways, this does not need to be done before moving.
if (CheckTargetMovement())		if (CheckTargetMovement())
{		{
PathGoal goal;		PathGoal goal;
ComputeGoal(goal, m_MoveRequest);		ComputeGoal(goal, m_MoveRequest);
RequestLongPath(pos, goal);		RequestLongPath(pos, goal);
m_PathState = PATHSTATE_FOLLOWING_REQUESTING_LONG;
}
}		}
}		}

bool CCmpUnitMotion::PossiblyAtDestination() const		bool CCmpUnitMotion::PossiblyAtDestination() const
{		{
if (m_MoveRequest.m_Type == MoveRequest::NONE)		if (m_MoveRequest.m_Type == MoveRequest::NONE)
return false;		return false;

Show All 28 Lines	bool CCmpUnitMotion::PossiblyAtDestination() const
if (distance >= m_MoveRequest.m_MinRange && (distance <= m_MoveRequest.m_MaxRange \|\| m_MoveRequest.m_MaxRange < fixed::Zero()))		if (distance >= m_MoveRequest.m_MinRange && (distance <= m_MoveRequest.m_MaxRange \|\| m_MoveRequest.m_MaxRange < fixed::Zero()))
return true;		return true;

return false;		return false;
}		}

bool CCmpUnitMotion::PerformMove(fixed dt, WaypointPath& shortPath, WaypointPath& longPath, CFixedVector2D& pos) const		bool CCmpUnitMotion::PerformMove(fixed dt, WaypointPath& shortPath, WaypointPath& longPath, CFixedVector2D& pos) const
{		{
if (m_PathState != PATHSTATE_FOLLOWING &&		if (shortPath.m_Waypoints.empty() && longPath.m_Waypoints.empty())
m_PathState != PATHSTATE_FOLLOWING_REQUESTING_SHORT &&
m_PathState != PATHSTATE_FOLLOWING_REQUESTING_LONG)
return false;		return false;

// TODO: there's some asymmetry here when units look at other		// TODO: there's some asymmetry here when units look at other
// units' positions - the result will depend on the order of execution.		// units' positions - the result will depend on the order of execution.
// Maybe we should split the updates into multiple phases to minimise		// Maybe we should split the updates into multiple phases to minimise
// that problem.		// that problem.

CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());		CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines	if (CloseEnoughFromDestinationToStop(pos))
return true;		return true;
}		}

// If we still have long waypoints, try and compute a short path		// If we still have long waypoints, try and compute a short path
if (!m_LongPath.m_Waypoints.empty())		if (!m_LongPath.m_Waypoints.empty())
{		{
PathGoal goal = { PathGoal::POINT, m_LongPath.m_Waypoints.back().x, m_LongPath.m_Waypoints.back().z };		PathGoal goal = { PathGoal::POINT, m_LongPath.m_Waypoints.back().x, m_LongPath.m_Waypoints.back().z };
RequestShortPath(pos, goal, true);		RequestShortPath(pos, goal, true);
m_PathState = PATHSTATE_WAITING_REQUESTING_SHORT;
return true;		return true;
}		}

// Else, just entirely recompute		// Else, just entirely recompute
PathGoal goal;		PathGoal goal;
ComputeGoal(goal, m_MoveRequest);		ComputeGoal(goal, m_MoveRequest);
BeginPathing(pos, goal);		BeginPathing(pos, goal);

▲ Show 20 Lines • Show All 315 Lines • ▼ Show 20 Lines	bool CCmpUnitMotion::ShouldTreatTargetAsCircle(entity_pos_t range, entity_pos_t circleRadius) const
// Previously, we used the shape that minimized the worst-case error.		// Previously, we used the shape that minimized the worst-case error.
// However that is unsage in some situations. So let's be less clever and		// However that is unsage in some situations. So let's be less clever and
// just check if our range is at least three times bigger than the circleradius		// just check if our range is at least three times bigger than the circleradius
return (range > circleRadius*3);		return (range > circleRadius*3);
}		}

void CCmpUnitMotion::BeginPathing(const CFixedVector2D& from, const PathGoal& goal)		void CCmpUnitMotion::BeginPathing(const CFixedVector2D& from, const PathGoal& goal)
{		{
m_ExpectedPathTicket = 0;		m_ExpectedPathTicket.clear();

m_PathState = PATHSTATE_NONE;

#if DISABLE_PATHFINDER		#if DISABLE_PATHFINDER
{		{
CmpPtr<ICmpPathfinder> cmpPathfinder (GetSimContext(), SYSTEM_ENTITY);		CmpPtr<ICmpPathfinder> cmpPathfinder (GetSimContext(), SYSTEM_ENTITY);
CFixedVector2D goalPos = m_FinalGoal.NearestPointOnGoal(from);		CFixedVector2D goalPos = m_FinalGoal.NearestPointOnGoal(from);
m_LongPath.m_Waypoints.clear();		m_LongPath.m_Waypoints.clear();
m_ShortPath.m_Waypoints.clear();		m_ShortPath.m_Waypoints.clear();
m_ShortPath.m_Waypoints.emplace_back(Waypoint{ goalPos.X, goalPos.Y });		m_ShortPath.m_Waypoints.emplace_back(Waypoint{ goalPos.X, goalPos.Y });
m_PathState = PATHSTATE_FOLLOWING;
return;		return;
}		}
#endif		#endif

// If we're aiming at a target entity and it's close and we can reach		// If we're aiming at a target entity and it's close and we can reach
// it in a straight line, then we'll just go along the straight line		// it in a straight line, then we'll just go along the straight line
// instead of computing a path.		// instead of computing a path.
if (TryGoingStraightToTargetEntity(from))		if (TryGoingStraightToTargetEntity(from))
{
m_PathState = PATHSTATE_FOLLOWING;
return;		return;
}

// Same thing applies to non-entity points		// Same thing applies to non-entity points
if (TryGoingStraightToGoalPoint(from))		if (TryGoingStraightToGoalPoint(from))
{
m_PathState = PATHSTATE_FOLLOWING;
return;		return;
}

// Otherwise we need to compute a path.		// Otherwise we need to compute a path.

// If it's close then just do a short path, not a long path		// If it's close then just do a short path, not a long path
// TODO: If it's close on the opposite side of a river then we really		// TODO: If it's close on the opposite side of a river then we really
// need a long path, so we shouldn't simply check linear distance		// need a long path, so we shouldn't simply check linear distance
// the check is arbitrary but should be a reasonably small distance.		// the check is arbitrary but should be a reasonably small distance.
if (goal.DistanceToPoint(from) < LONG_PATH_MIN_DIST)		if (goal.DistanceToPoint(from) < LONG_PATH_MIN_DIST)
{		{
// add our final goal as a long range waypoint so we don't forget		// add our final goal as a long range waypoint so we don't forget
// where we are going if the short-range pathfinder returns		// where we are going if the short-range pathfinder returns
// an aborted path.		// an aborted path.
m_LongPath.m_Waypoints.clear();		m_LongPath.m_Waypoints.clear();
CFixedVector2D target = goal.NearestPointOnGoal(from);		CFixedVector2D target = goal.NearestPointOnGoal(from);
m_LongPath.m_Waypoints.emplace_back(Waypoint{ target.X, target.Y });		m_LongPath.m_Waypoints.emplace_back(Waypoint{ target.X, target.Y });
m_PathState = PATHSTATE_WAITING_REQUESTING_SHORT;
RequestShortPath(from, goal, true);		RequestShortPath(from, goal, true);
}		}
else		else
{
m_PathState = PATHSTATE_WAITING_REQUESTING_LONG;
RequestLongPath(from, goal);		RequestLongPath(from, goal);
}		}
}

void CCmpUnitMotion::RequestLongPath(const CFixedVector2D& from, const PathGoal& goal)		void CCmpUnitMotion::RequestLongPath(const CFixedVector2D& from, const PathGoal& goal)
{		{
CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());		CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
if (!cmpPathfinder)		if (!cmpPathfinder)
return;		return;

// this is by how much our waypoints will be apart at most.		// this is by how much our waypoints will be apart at most.
// this value here seems sensible enough.		// this value here seems sensible enough.
PathGoal improvedGoal = goal;		PathGoal improvedGoal = goal;
improvedGoal.maxdist = SHORT_PATH_MIN_SEARCH_RANGE - entity_pos_t::FromInt(1);		improvedGoal.maxdist = SHORT_PATH_MIN_SEARCH_RANGE - entity_pos_t::FromInt(1);

cmpPathfinder->SetDebugPath(from.X, from.Y, improvedGoal, m_PassClass);		cmpPathfinder->SetDebugPath(from.X, from.Y, improvedGoal, m_PassClass);

m_ExpectedPathTicket = cmpPathfinder->ComputePathAsync(from.X, from.Y, improvedGoal, m_PassClass, GetEntityId());		m_ExpectedPathTicket.m_Type = Ticket::LONG_PATH;
		m_ExpectedPathTicket.m_Ticket = cmpPathfinder->ComputePathAsync(from.X, from.Y, improvedGoal, m_PassClass, GetEntityId());
}		}

void CCmpUnitMotion::RequestShortPath(const CFixedVector2D &from, const PathGoal& goal, bool avoidMovingUnits)		void CCmpUnitMotion::RequestShortPath(const CFixedVector2D &from, const PathGoal& goal, bool avoidMovingUnits)
{		{
CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());		CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
if (!cmpPathfinder)		if (!cmpPathfinder)
return;		return;

// wrapping around on m_Tries isn't really a problem so don't check for overflow.		// wrapping around on m_Tries isn't really a problem so don't check for overflow.
fixed searchRange = std::max(SHORT_PATH_MIN_SEARCH_RANGE * ++m_Tries, goal.DistanceToPoint(from));		fixed searchRange = std::max(SHORT_PATH_MIN_SEARCH_RANGE * ++m_Tries, goal.DistanceToPoint(from));
if (goal.type != PathGoal::POINT && searchRange < goal.hw && searchRange < SHORT_PATH_MIN_SEARCH_RANGE * 2)		if (goal.type != PathGoal::POINT && searchRange < goal.hw && searchRange < SHORT_PATH_MIN_SEARCH_RANGE * 2)
searchRange = std::min(goal.hw, SHORT_PATH_MIN_SEARCH_RANGE * 2);		searchRange = std::min(goal.hw, SHORT_PATH_MIN_SEARCH_RANGE * 2);
if (searchRange > SHORT_PATH_MAX_SEARCH_RANGE)		if (searchRange > SHORT_PATH_MAX_SEARCH_RANGE)
searchRange = SHORT_PATH_MAX_SEARCH_RANGE;		searchRange = SHORT_PATH_MAX_SEARCH_RANGE;

m_ExpectedPathTicket = cmpPathfinder->ComputeShortPathAsync(from.X, from.Y, m_Clearance, searchRange, goal, m_PassClass, avoidMovingUnits, GetGroup(), GetEntityId());		m_ExpectedPathTicket.m_Type = Ticket::SHORT_PATH;
		m_ExpectedPathTicket.m_Ticket = cmpPathfinder->ComputeShortPathAsync(from.X, from.Y, m_Clearance, searchRange, goal, m_PassClass, avoidMovingUnits, GetGroup(), GetEntityId());
}		}

bool CCmpUnitMotion::MoveToPointRange(entity_pos_t x, entity_pos_t z, entity_pos_t minRange, entity_pos_t maxRange)		bool CCmpUnitMotion::MoveToPointRange(entity_pos_t x, entity_pos_t z, entity_pos_t minRange, entity_pos_t maxRange)
{		{
PROFILE("MoveToPointRange");		PROFILE("MoveToPointRange");

MoveRequest moveRequest(CFixedVector2D(x, z), minRange, maxRange);		MoveRequest moveRequest(CFixedVector2D(x, z), minRange, maxRange);

▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines