|
public static Vec2DDistance ( |
||
| v1 | ||
| v2 | ||
| 리턴 | double | |
/// <summary>
/// Given a force and a distance to cover given by two vectors, this
/// method calculates how long it will take the ball to travel between
/// the two points
///
/// </summary>
/// <param name="A"></param>
/// <param name="B"></param>
/// <param name="force"></param>
/// <returns></returns>
public double CalucateTimeToCoverDistance(Vector2D A,
Vector2D B,
double force)
{
//this will be the velocity of the ball in the next time step *if*
//the player was to make the pass.
double speed = force / Mass;
//calculate the velocity at B using the equation
//
// v^2 = u^2 + 2as
//
//first calculate s (the distance between the two positions)
double DistanceToCover = Vector2D.Vec2DDistance(A, B);
double term = speed * speed + 2.0 * DistanceToCover * ParameterManager.Instance.Friction;
//if (u^2 + 2as) is negative it means the ball cannot reach point B.
if (term <= 0.0)
{
return(-1.0);
}
double v = Math.Sqrt(term);
//it IS possible for the ball to reach B and we know its speed when it
//gets there, so now it's easy to calculate the time using the equation
//
// t = v-u
// ---
// a
//
return((v - speed) / ParameterManager.Instance.Friction);
}
/// <summary>
/// Given a line segment AB and a point P, this function calculates the
/// perpendicular distance between them
/// </summary>
/// <param name="A"></param>
/// <param name="B"></param>
/// <param name="P"></param>
/// <returns></returns>
public static double DistToLineSegment(Vector2D A,
Vector2D B,
Vector2D P)
{
//if the angle is obtuse between PA and AB is obtuse then the closest
//vertex must be A
double dotA = (P.X - A.X) * (B.X - A.X) + (P.Y - A.Y) * (B.Y - A.Y);
if (dotA <= 0)
{
return(Vector2D.Vec2DDistance(A, P));
}
//if the angle is obtuse between PB and AB is obtuse then the closest
//vertex must be B
double dotB = (P.X - B.X) * (A.X - B.X) + (P.Y - B.Y) * (A.Y - B.Y);
if (dotB <= 0)
{
return(Vector2D.Vec2DDistance(B, P));
}
//calculate the point along AB that is the closest to P
Vector2D Point = A + ((B - A) * dotA) / (dotA + dotB);
//calculate the distance P-Point
return(Vector2D.Vec2DDistance(P, Point));
}
/// <summary>
/// Given 2 lines in 2D space AB, CD this returns true if an
/// intersection occurs and sets dist to the distance the intersection
/// occurs along AB. Also sets the 2d vector point to the point of
/// intersection
///
/// </summary>
/// <param name="A"></param>
/// <param name="B"></param>
/// <param name="C"></param>
/// <param name="D"></param>
/// <param name="dist"></param>
/// <param name="point"></param>
/// <returns></returns>
public static bool LineIntersection2D(Vector2D A,
Vector2D B,
Vector2D C,
Vector2D D,
ref double dist,
ref Vector2D point)
{
double rTop = (A.Y - C.Y) * (D.X - C.X) - (A.X - C.X) * (D.Y - C.Y);
double rBot = (B.X - A.X) * (D.Y - C.Y) - (B.Y - A.Y) * (D.X - C.X);
double sTop = (A.Y - C.Y) * (B.X - A.X) - (A.X - C.X) * (B.Y - A.Y);
double sBot = (B.X - A.X) * (D.Y - C.Y) - (B.Y - A.Y) * (D.X - C.X);
if ((rBot == 0) || (sBot == 0))
{
//lines are parallel
return(false);
}
double r = rTop / rBot;
double s = sTop / sBot;
if ((r > 0) && (r < 1) && (s > 0) && (s < 1))
{
dist = Vector2D.Vec2DDistance(A, B) * r;
point = A + r * (B - A);
return(true);
}
else
{
dist = 0;
return(false);
}
}
/// <summary>
/// Given 2 lines in 2D space AB, CD this returns true if an
/// intersection occurs and sets dist to the distance the intersection
/// occurs along AB
///
/// </summary>
/// <param name="A"></param>
/// <param name="B"></param>
/// <param name="C"></param>
/// <param name="D"></param>
/// <param name="dist"></param>
/// <returns></returns>
public static bool LineIntersection2D(Vector2D A,
Vector2D B,
Vector2D C,
Vector2D D,
ref double dist)
{
double rTop = (A.Y - C.Y) * (D.X - C.X) - (A.X - C.X) * (D.Y - C.Y);
double sTop = (A.Y - C.Y) * (B.X - A.X) - (A.X - C.X) * (B.Y - A.Y);
double Bot = (B.X - A.X) * (D.Y - C.Y) - (B.Y - A.Y) * (D.X - C.X);
if (Bot == 0)//parallel
{
if (Math.Abs(rTop) > Geometry.MinPrecision && Math.Abs(sTop) > Geometry.MinPrecision)
{
return(true);
}
return(false);
}
double r = rTop / Bot;
double s = sTop / Bot;
if ((r > 0) && (r < 1) && (s > 0) && (s < 1))
{
dist = Vector2D.Vec2DDistance(A, B) * r;
return(true);
}
else
{
dist = 0;
return(false);
}
}
public Vector2D DetermineBestSupportingPosition()
{
//only update the spots every few frames
if (!_regulator.IsReady /* && _bestSupportingSpot != null */)
{
return(_bestSupportingSpot.m_vPos);
}
//reset the best supporting spot
_bestSupportingSpot = null;
double BestScoreSoFar = 0.0;
for (int spotIndex = 0; spotIndex < _supportSpots.Count; spotIndex++)
{
//first remove any previous score. (the score is set to one so that
//the viewer can see the positions of all the spots if he has the
//aids turned on)
_supportSpots[spotIndex].m_dScore = 1.0;
//Test 1. is it possible to make a safe pass from the ball's position
//to this position?
if (_team.IsPassSafeFromAllOpponents(_team.ControllingPlayer.Position,
_supportSpots[spotIndex].m_vPos,
null,
ParameterManager.Instance.MaxPassingForce))
{
_supportSpots[spotIndex].m_dScore += ParameterManager.Instance.SpotPassSafeScore;
}
Vector2D shotTarget = new Vector2D();
//Test 2. Determine if a goal can be scored from this position.
if (_team.CanShoot(_supportSpots[spotIndex].m_vPos,
ParameterManager.Instance.MaxShootingForce, ref shotTarget))
{
_supportSpots[spotIndex].m_dScore += ParameterManager.Instance.SpotCanScoreFromPositionScore;
}
//Test 3. calculate how far this spot is away from the controlling
//player. The further away, the higher the score. Any distances further
//away than OptimalDistance pixels do not receive a score.
if (_team.SupportingPlayer != null)
{
const double OptimalDistance = 200.0;
double dist = Vector2D.Vec2DDistance(_team.ControllingPlayer.Position,
_supportSpots[spotIndex].m_vPos);
double temp = Math.Abs(OptimalDistance - dist);
if (temp < OptimalDistance)
{
//normalize the distance and add it to the score
_supportSpots[spotIndex].m_dScore += ParameterManager.Instance.SpotDistFromControllingPlayerScore *
(OptimalDistance - temp) / OptimalDistance;
}
}
//check to see if this spot has the highest score so far
if (_supportSpots[spotIndex].m_dScore > BestScoreSoFar)
{
BestScoreSoFar = _supportSpots[spotIndex].m_dScore;
_bestSupportingSpot = _supportSpots[spotIndex];
}
}
return(_bestSupportingSpot.m_vPos);
}