public static Point2D GetNewPosition(Point2D oldPosition, GameAngle angle, float speed)
{
var rad = angle.RadianValue;
var result = oldPosition + new Vector2D(speed * rad.Cos(), speed * rad.Sin());
return(result);
}
public static MoveDirection GetBestMoveDirection(Point2D position, GameAngle beakAngle, Point2D targetPoint)
{
if (position.GetDistanceSquared(targetPoint).IsZero())
{
return(MoveDirection.None);
}
//// TODO [vmcl] Use computed MoveDirection instead of one of predefined ones
var resultProxy = Tuple.Create(MoveDirection.None, float.MaxValue);
foreach (var item in BasicMoveDirectionsField)
{
var potentialMovePoint = GetNewPosition(
position,
beakAngle,
item,
GameConstants.ChickenUnit.DefaultRectilinearSpeed);
var distanceSquared = targetPoint.GetDistanceSquared(potentialMovePoint);
if (distanceSquared < resultProxy.Item2)
{
resultProxy = Tuple.Create(item, distanceSquared);
}
}
return(resultProxy.Item1);
}
public static BeakTurn GetBestBeakTurnNormalized(Point2D position, GameAngle beakAngle, Point2D targetPoint)
{
var absoluteBeakTurn = GetBestBeakTurn(position, beakAngle, targetPoint);
var result = NormalizeBeakTurn(absoluteBeakTurn);
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="ChickenElement"/> class.
/// </summary>
internal ChickenElement(Point2D position, GameAngle beakAngle)
: base(position)
{
this.BeakAngle = beakAngle;
_roughPrimitives = new List <ICollidablePrimitive>(1)
{
new CirclePrimitive(position, GameConstants.ChickenUnit.BeakOffset)
}
.AsReadOnly();
var defaultBeakPolygonPoints = new[]
{
new Point2D(position.X, position.Y - GameConstants.ChickenUnit.BeakRayOffset),
new Point2D(position.X + GameConstants.ChickenUnit.BeakOffset, position.Y),
new Point2D(position.X, position.Y + GameConstants.ChickenUnit.BeakRayOffset)
};
var beakPolygonPoints = defaultBeakPolygonPoints.Rotate(Position, beakAngle);
_primitives = new List <ICollidablePrimitive>(2)
{
new CirclePrimitive(position, GameConstants.ChickenUnit.BodyCircleRadius),
new ConvexPolygonPrimitive(beakPolygonPoints)
}
.AsReadOnly();
}
public static float GetBestBeakTurn(Point2D position, GameAngle beakAngle, Point2D targetPoint)
{
var targetOffset = targetPoint - position;
var targetAngle = GameAngle.FromRadians((float)Math.Atan2(targetOffset.Y, targetOffset.X));
var result = GetBeakTurn(beakAngle, targetAngle);
return(result);
}
public static GameAngle GetNewBeakAngle(GameAngle oldBeakAngle, BeakTurn beakTurn)
{
var beakMovement = GetBeakMovement(beakTurn);
var result = oldBeakAngle + beakMovement;
return(result);
}
public static Vector2D GetMovement(GameAngle angle, float speed)
{
var rad = angle.RadianValue;
var result = new Vector2D(speed * rad.Cos(), speed * rad.Sin());
return(result);
}
public static AngleMovementAndPosition GetBeakMovementAndNewAngle(
GameAngle oldBeakAngle,
BeakTurn beakTurn)
{
var beakMovement = GetBeakMovement(beakTurn);
var newAngle = oldBeakAngle + beakMovement;
return(new AngleMovementAndPosition(beakMovement, newAngle));
}
internal void SetMovement(Vector2D movement, GameAngle beakMovement)
{
this.Movement = movement;
this.NextPosition = this.Position + this.Movement;
this.BeakMovement = beakMovement;
this.NextBeakAngle = this.BeakAngle + this.BeakMovement;
ResetCachedElement();
}
public static GameAngle GetBeakMovement(BeakTurn beakTurn)
{
if (beakTurn.Value.IsZero())
{
return(GameAngle.Zero);
}
var degreeAngle = GameConstants.ChickenUnit.DefaultAngularSpeed * beakTurn.Value;
return(GameAngle.FromDegrees(degreeAngle));
}
public static MovementAndPosition GetMovementAndNewPosition(
Point2D oldPosition,
GameAngle currentAngle,
MoveDirection direction,
float speed)
{
var movement = GetMovement(currentAngle, direction, speed);
var newPosition = GetNewPositionInternal(oldPosition, movement);
return(new MovementAndPosition(movement, newPosition));
}
internal void ResetPosition(Point2D position, GameAngle beakAngle)
{
this.Position = position;
this.Movement = Vector2D.Zero;
this.NextPosition = this.Position;
this.BeakAngle = beakAngle;
this.BeakMovement = GameAngle.Zero;
this.NextBeakAngle = this.BeakAngle;
ResetCachedElement();
}
public static Point2D GetNewPosition(
Point2D oldPosition,
GameAngle currentAngle,
MoveDirection direction,
float speed)
{
var movement = GetMovement(currentAngle, direction, speed);
var result = GetNewPositionInternal(oldPosition, movement);
return(result);
}
public static Vector2D GetMovement(
GameAngle currentAngle,
MoveDirection direction,
float speed)
{
if (direction.IsNone)
{
return(Vector2D.Zero);
}
var relativeAngle = Vector2D.UnitY.GetAngle(direction.NormalizedDirection);
var actualAngle = currentAngle + relativeAngle;
var actualSpeed = Math.Min(direction.NormalizedDirection.GetLength(), 1f) * speed;
var result = GetMovement(actualAngle, actualSpeed);
return(result);
}
public static void PositionRandomly(
[NotNull] GamePositionEventArgs eventArgs,
[CanBeNull] Random randomGenerator)
{
#region Argument Check
if (eventArgs == null)
{
throw new ArgumentNullException("eventArgs");
}
#endregion
var actualRandomGenerator = randomGenerator ?? DefaultRandomGenerator;
for (var index = 0; index < eventArgs.UnitStates.Count; index++)
{
var unitState = eventArgs.UnitStates[index];
Point2D position;
do
{
var nominalPosition = new Point(
actualRandomGenerator.Next(eventArgs.Data.NominalSize.Width),
actualRandomGenerator.Next(eventArgs.Data.NominalSize.Height));
position = GameHelper.NominalToReal(nominalPosition);
}while (eventArgs.UnitStates.Take(index).Any(
item =>
eventArgs.GetPosition(item).Position.GetDistance(position) < GameConstants.NominalCellSize));
var plainAngle = (float)Math.Floor(
MathHelper.HalfRevolutionDegrees
- actualRandomGenerator.NextDouble() * MathHelper.RevolutionDegrees);
var angle = GameAngle.FromDegrees(plainAngle);
eventArgs.SetPosition(unitState, new DirectionalPosition(position, angle));
}
}
public static BeakTurn GetBeakTurnNormalized(GameAngle currentAngle, GameAngle targetAngle)
{
var absoluteBeakTurn = GetBeakTurn(currentAngle, targetAngle);
return(NormalizeBeakTurn(absoluteBeakTurn));
}
/// <summary>
/// Initializes a new instance of the <see cref="AngleMovementAndPosition"/> class.
/// </summary>
internal AngleMovementAndPosition(GameAngle movement, GameAngle position)
: this()
{
this.Movement = movement;
this.Position = position;
}
public static Point2D GetBeakTipPosition(Point2D position, GameAngle beakAngle)
{
return(position
.OffsetX(GameConstants.ChickenUnit.BeakOffset)
.Rotate(position, beakAngle));
}
public static Vector2D GetChickenViewDirection(Point2D position, GameAngle beakAngle)
{
var beakTipPosition = GetBeakTipPosition(position, beakAngle);
return(beakTipPosition - position);
}
public static float GetBeakTurn(GameAngle currentAngle, GameAngle targetAngle)
{
var difference = (targetAngle - currentAngle).DegreeValue;
return(difference / GameConstants.ChickenUnit.DefaultAngularSpeed);
}
public static float GetDistanceToLine(Point2D point, Point2D linePoint, GameAngle lineAngle)
{
return(GetDistanceToLineInternal(lineAngle.ToUnitVector(), point - linePoint));
}
public static Point2D[] Rotate(this IEnumerable <Point2D> values, Point2D center, GameAngle angle)
{
return(Point2D.Rotate(values, center, angle));
}
