public void ParseObject()
{
object value = "{X=1,Y=2}";
var actual = PointExtensions.Parse(value);
Assert.AreEqual(new Point(1, 2), actual);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value is not MouseEventArgs e)
{
throw new Exception("Wrong value type");
}
System.Windows.Point p = e.GetPosition((IInputElement)e.Source);
bool modKey = Keyboard.Modifiers.HasFlag(ModifierKeys.Shift);
if (value is MouseButtonEventArgs b)
{
if (b.LeftButton == MouseButtonState.Pressed)
{
return(new CanvasEventArgs(PointExtensions.CreateFromPoint(p), MouseState.DOWN, modKey));
}
if (b.LeftButton == MouseButtonState.Released)
{
return(new CanvasEventArgs(PointExtensions.CreateFromPoint(p), MouseState.UP, modKey));
}
}
return(new CanvasEventArgs(PointExtensions.CreateFromPoint(p), MouseState.MOVE, modKey));
}
public void GetHashCodeTest3()
{
var pointA = new Point(0, (1 << 16) + 1);
var pointB = new Point(0, 1);
Assert.AreNotEqual(PointExtensions.GetHashCode(pointA), PointExtensions.GetHashCode(pointB));
}
public void PolarToCartesian_Returns()
{
var angle = 22.6;
var radius = 13;
var expectedPoint = new Point(12, 5);
Assert.AreEqual(expectedPoint, PointExtensions.PolarToCartesian(angle, radius));
}
public void GetHashCodeTest1()
{
Point point = new Point();
int expected = 0;
int actual;
actual = PointExtensions.GetHashCode(point);
Assert.AreEqual(expected, actual);
}
public void AreCollinearTest1()
{
Point[] points = null;
bool expected = true;
bool actual;
actual = PointExtensions.AreCollinear(points);
Assert.AreEqual(expected, actual);
}
public void AreCollinearTest3()
{
Point[] points = new Point[] { new Point(0, 0), new Point(1, 1), new Point(2, 2) };
bool expected = true;
bool actual;
actual = PointExtensions.AreCollinear(points);
Assert.AreEqual(expected, actual);
}
private List <DPoint> GetHullPoints(PointLabels[] include, PointLabels[] exclude)
{
var result = new List <DPoint>();
var exclusionZones = GetExclusionPolygons();
for (int y = 0; y < Space.StandardHeight; y++)
{
for (int x = 0; x < Space.StandardWidth; x++)
{
var addPt = false;
//Check if included
for (int inc = 0; inc < include.Length; inc++)
{
if (PointExtensions.IsInConvexPolygon(x, y, ConvexHullsStandard[include[inc]]))
{
addPt = true;
break;
}
}
//Check if excluded
if (addPt)
{
for (int exc = 0; exc < exclude.Length; exc++)
{
if (PointExtensions.IsInConvexPolygon(x, y, ConvexHullsStandard[exclude[exc]]))
{
addPt = false;
break;
}
}
}
//Check if in one of the user exclusion zones
if (addPt)
{
for (int exc = 0; exc < exclusionZones.Count; exc++)
{
if (PointExtensions.IsPointInPolygon(x, y, exclusionZones[exc]))
{
addPt = false;
break;
}
}
}
if (addPt)
{
result.Add(new DPoint(x, y));
}
}
}
return(result);
}
public void EqualsTest1()
{
Point pointA = new Point();
Point pointB = new Point();
bool expected = true;
bool actual;
actual = PointExtensions.Equals(pointA, pointB);
Assert.AreEqual(expected, actual);
}
public void EqualsTest3()
{
Point pointA = new Point(1, 0);
Point pointB = new Point(0, 1);
bool expected = false;
bool actual;
actual = PointExtensions.Equals(pointA, pointB);
Assert.AreEqual(expected, actual);
}
public void Given_CollinearPointsOnDiagonal_When_ArePointsCollinearCalled_Then_ResultIsTrue()
{
//given
var p1 = new Point(0, 0, PointType.Golfer);
var p2 = new Point(1, 1, PointType.Golfer);
var p3 = new Point(10, 10, PointType.Hole);
//when
var result = PointExtensions.ArePointsCollinear(p1, p2, p3);
//then
Assert.IsTrue(result);
}
public void Given_NoncollinearPoints_When_ArePointsCollinearCalled_Then_ResultIsFalse()
{
//given
var p1 = new Point(0, 0, PointType.Golfer);
var p2 = new Point(1, 0, PointType.Golfer);
var p3 = new Point(10, 7.5, PointType.Hole);
//when
var result = PointExtensions.ArePointsCollinear(p1, p2, p3);
//then
Assert.IsFalse(result);
}
private Texture2D GetScreenshot(string filePath)
{
Texture2D texture = null;
var completed = false;
var timeout = DateTime.Now.AddMilliseconds(FileTimeOutMilliseconds);
while (!completed)
{
if (!File.Exists(filePath))
{
return(null);
}
try {
using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read)) {
using (var source = Image.FromStream(fs)) {
var maxWidth = GameService.Graphics.Resolution.X - 100;
var maxHeight = GameService.Graphics.Resolution.Y - 100;
var(width, height) = PointExtensions.ResizeKeepAspect(
new Point(source.Width, source.Height), maxWidth,
maxHeight);
using (var target = new Bitmap(source, width, height)) {
using (var graphic = Graphics.FromImage(target)) {
graphic.CompositingQuality = CompositingQuality.HighSpeed;
graphic.InterpolationMode = InterpolationMode.HighQualityBicubic;
graphic.SmoothingMode = SmoothingMode.HighSpeed;
graphic.DrawImage(target, 0, 0, width, height);
}
using (var textureStream = new MemoryStream()) {
target.Save(textureStream, ImageFormat.Jpeg);
var buffer = new byte[textureStream.Length];
textureStream.Position = 0;
textureStream.Read(buffer, 0, buffer.Length);
texture = Texture2D.FromStream(GameService.Graphics.GraphicsDevice, textureStream);
}
}
}
}
completed = true;
} catch (IOException e) {
if (DateTime.Now < timeout)
{
continue;
}
Logger.Error(e.Message + e.StackTrace);
return(null);
}
}
return(texture);
}
/// <summary>
/// Initializes a discrete grid using the information provided.
/// </summary>
/// <param name="startPoint">The point to start the route at</param>
/// <param name="endPoint">The point to end the route at</param>
/// <param name="field">The field that needs to be discretised</param>
/// <param name="gridSize">The size of the grid to be palced placed over <paramref name="field"/></param>
/// <param name="movingObject">The object that will be moving.</param>
/// <returns>A GridSquare array, initialized to represent <paramref name="field"/>.</returns>
///
/// Produces a GridSquare array that is set up for use by <see cref="FindPath"/>.
///
/// Uses the ObjectClearance and <paramref name="movingObject" />'s <see cref="IPositionedObject.Size"/> property to determine the
/// apparent size of opponents, and marks the squares that contain them as <see cref="SquareType.Obstacle"/>.
///
/// Marks the square that contains <paramref name="endPoint" /> as <see cref="SquareType.Destination"/>.
///
/// Marks the square that contains <paramref name="startPoint" /> as <see cref="SquareType.Origin"/>.
///
/// Works in parallel as far as possible, using the Microsoft Task Parallel Library (http://msdn.microsoft.com/en-us/library/dd460717.aspx).
protected GridSquare[] InitGrid(PointF startPoint, PointF endPoint, Field field, Size gridSize, IPositionedObject movingObject)
{
var playersize = (movingObject.Size + new Size(ObjectClearance, ObjectClearance)).Scale(Resolution).Scale(2.0f).Ceiling();
var clearance = Math.Max(playersize.Width, playersize.Height); // The amount to increase an obstacle's size by to allow for the player's size
var grid = new GridSquare[gridSize.Height * gridSize.Width];
// Initialize the grid
Parallel.For(0, grid.Length, i => {
grid[i] = new GridSquare
{
Location = PointExtensions.FromIndex(i, gridSize.Width)
};
});
Parallel.ForEach(from p in field.Players where p.Team == Team.Opposition select p, player =>
{
var centerGridPoint = player.Position.Scale(Resolution).Floor();
var minX = Math.Max(0, centerGridPoint.X - playersize.Width - clearance);
var maxX = Math.Min(centerGridPoint.X + playersize.Width + clearance, gridSize.Width);
var minY = Math.Max(0, centerGridPoint.Y - playersize.Height - clearance);
var maxY = Math.Min(centerGridPoint.Y + playersize.Height + clearance, gridSize.Height);
for (var i = minX; i < maxX; i++)
{
for (var j = minY; j < maxY; j++)
{
if (i < 0 || j < 0)
{
continue;
}
var gridPoint = new Point(i, j);
grid[gridPoint.ToIndex(gridSize.Width)].Type = SquareType.Obstacle;
}
}
});
var gridEndPoint = endPoint.Scale(Resolution).Floor();
grid[gridEndPoint.ToIndex(gridSize.Width)].Type = SquareType.Destination;
var gridStartPoint = startPoint.Scale(Resolution).Floor();
grid[gridStartPoint.ToIndex(gridSize.Width)].Type = SquareType.Origin;
return(grid);
}
public void ParseEmptyString()
{
var actual = PointExtensions.Parse(String.Empty);
Assert.AreEqual(Point.Empty, actual);
}
public void ParseNull()
{
var actual = PointExtensions.Parse(null);
Assert.AreEqual(Point.Empty, actual);
}
public void ParsePositives()
{
var actual = PointExtensions.Parse("{X=1,Y=2}");
Assert.AreEqual(new Point(1, 2), actual);
}
public void ParseZeroes()
{
var actual = PointExtensions.Parse("{X=0,Y=0}");
Assert.AreEqual(Point.Empty, actual);
}
public void ParseManyDigits()
{
var actual = PointExtensions.Parse("{X=12345,Y=67890}");
Assert.AreEqual(new Point(12345, 67890), actual);
}
public void ParseNegatives()
{
var actual = PointExtensions.Parse("{X=-1,Y=-2}");
Assert.AreEqual(new Point(-1, -2), actual);
}
public void ParseOneNegativeOnePositive()
{
Assert.AreEqual(new Point(1, -2), PointExtensions.Parse("{X=1,Y=-2}"));
Assert.AreEqual(new Point(-1, 2), PointExtensions.Parse("{X=-1,Y=2}"));
}
public void ParseWithSpaceAfterComma()
{
var actual = PointExtensions.Parse("{X=1, Y=2}");
Assert.AreEqual(new Point(1, 2), actual);
}
/// <summary>
/// TODO: write documentation
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="C"></typeparam>
/// <param name="xValues"></param>
/// <param name="yValues"></param>
/// <returns></returns>
public static Vector <T, C> EstimateLeastSquaresCoefficients <T, C>(IList <T> xValues, IList <T> yValues) where C : ICalc <T>, new()
{
return(EstimateLeastSquaresCoefficients <T, C>(PointExtensions.convertToListOfPairs(xValues, yValues)));
}
