public void ReturnsTriangleAtGivenGridReference()
{
var moqGridReference = new Mock <IGridReference>();
moqGridReference.Setup(x => x.Column)
.Returns(() => 2);
moqGridReference.Setup(x => x.Row)
.Returns(() => 'C');
moqGridReference.Setup(x => x.GetNumericRow())
.Returns(() => 3);
var moqFactory = new Mock <ITriangleCalculatorFactory>();
moqFactory.Setup(x => x.Make(moqGridReference.Object))
.Returns(new RightTriangleCalculator());
var moqGrid = new Mock <IGrid>();
moqGrid.Setup(x => x.CellSize)
.Returns(() => 10);
TriangleByGridReferenceCalculator calculator = new TriangleByGridReferenceCalculator(moqFactory.Object);
IGridShape triangle = calculator.Calculate(moqGrid.Object, moqGridReference.Object);
Assert.Equal(3, triangle.Coordinates.Count);
Assert.Contains(triangle.Coordinates, (c) => c.X == 0 && c.Y == 20);
Assert.Contains(triangle.Coordinates, (c) => c.X == 10 && c.Y == 20);
Assert.Contains(triangle.Coordinates, (c) => c.X == 10 && c.Y == 30);
}
private void UpdateShapeSprite()
{
_shape = _shapes[_currentShape];
switch (_shape)
{
case GridRectangle r:
r.Width = _radius;
break;
case GridAASegment aaSegment when _rotateSegment:
aaSegment.Rotate(new GridRotation(1));
break;
case GridSegment s when _rotateSegment:
s.Rotate(new GridRotation(1));
break;
case GridCircle c:
c.Radius = _radius;
break;
case GridFan f:
f.Radius = _radius;
f.Direction = _direction8;
break;
}
_rotateSegment = false;
_shapeSprite = new ShapeSprite(_shape, Scale, _graphics.GraphicsDevice);
}
private void Canvas_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
var xPos = e.GetPosition(cnvMain).X;
var yPos = e.GetPosition(cnvMain).Y;
var keys = Keyboard.Modifiers;
var controlKey = (keys & ModifierKeys.Control) != 0;
var shiftKey = (keys & ModifierKeys.Shift) != 0;
if (controlKey)
{
_gridManager.Block(cnvMain, (int)xPos, (int)yPos);
return;
}
if (shiftKey)
{
var square = _gridManager.HighlightShape(cnvMain, (int)xPos, (int)yPos);
var neighbours = _gridManager.GetNeighbours(square);
_gridManager.HighlightGridShape(cnvMain, neighbours);
return;
}
if (_start == null)
{
_start = _gridManager.HighlightShape(cnvMain, (int)xPos, (int)yPos);
return;
}
_end = _gridManager.HighlightShape(cnvMain, (int)xPos, (int)yPos);
// rough calculation of time spent
// can't use Diagnostics.Stopwatch in SL2.0 :(
var startTime = DateTime.Now;
var path = _gridManager.CalculatePath(_start, _end);
var endTime = DateTime.Now;
var span = new TimeSpan(endTime.Ticks - startTime.Ticks);
Log(String.Format("Seconds taken : {0}", span.TotalSeconds) + Environment.NewLine);
////TODO: reverse iterate from _end of list to draw actual path
_gridManager.HighlightGridShape(cnvMain, path);
}
public Feature(IGridShape shape)
{
Shape = shape;
FieldGraph = new AdjacencyGraph <SquareMapField, Edge <SquareMapField> >();
foreach (var coords in Shape.Interior)
{
var field = new SquareMapField(coords, this);
_fields[coords] = field;
FieldGraph.AddVertex(field);
}
foreach (var field in _fields.Values)
{
foreach (var adjacentField in FindAdjacentFields(field.Coordinates))
{
FieldGraph.AddEdge(new Edge <SquareMapField>(field, adjacentField));
}
}
}
public void FindsLeftTriangleAtF12()
{
var moqGridReference = new Mock <IGridReference>();
moqGridReference.Setup(x => x.Column)
.Returns(() => 12);
moqGridReference.Setup(x => x.GetNumericRow())
.Returns(() => 6);
var moqGrid = new Mock <IGrid>();
moqGrid.Setup(x => x.CellSize)
.Returns(() => 10);
RightTriangleCalculator rightTriangleFinder = new RightTriangleCalculator();
IGridShape triangle = rightTriangleFinder.Calculate(moqGrid.Object, moqGridReference.Object);
Assert.Equal(3, triangle.Coordinates.Count);
Assert.Contains(triangle.Coordinates, (c) => c.X == 50 && c.Y == 50);
Assert.Contains(triangle.Coordinates, (c) => c.X == 60 && c.Y == 50);
Assert.Contains(triangle.Coordinates, (c) => c.X == 60 && c.Y == 60);
}
public ShapeSprite(IGridShape shape, int scale, GraphicsDevice gd)
{
_shape = shape;
_scale = scale;
UpdateTexture(gd);
}
public List<PathNode> Calculate(IGridShape start, IGridShape end, IGridManager gridManager)
{
var startNode = new PathNode {Position = start};
startNode = CalculateFGH(startNode, startNode, end);
_openList.Add(startNode);
while (true)
{
_openList.Sort();
if (_openList.Count == 0)
//_openList.Add(_closedList[0]);
return _closedList;
var current = _openList[0];
if (current.Position.Equals(end))
return _closedList;
_closedList.Add(current);
_openList.Remove(current);
var neighbours = gridManager.GetNeighbours(current.Position);
foreach (var g in neighbours)
{
if (g == null) continue;
var c1 = _closedList.Where(x => x.Position.Equals(g)).FirstOrDefault();
if (!g.Blocked && (c1 == null))
{
var newNode = new PathNode { Position = g, Parent = current };
newNode = CalculateFGH(current, newNode, end);
if (!_openList.Contains(newNode))
{
newNode.Parent = current;
newNode = CalculateFGH(current, newNode, end);
_openList.Add(newNode);
}
else
{
var existingNode = _openList.First(x => x.Position.Id == newNode.Position.Id);
if (newNode.G < existingNode.G)
{
_openList.Remove(existingNode);
existingNode.Parent = current;
existingNode = CalculateFGH(current, existingNode, end);
_openList.Add(existingNode);
_openList.Sort();
}
}
}
//if (!g.Blocked && (c1 != null))
//{
// var newNode = new PathNode { Position = g, Parent = current };
// newNode = CalculateFGH(current, newNode, end);
// if (newNode.G < c1.G)
// {
// _openList.Remove(c1);
// _openList.Add(newNode);
// }
//}
}
}
}
private static PathNode CalculateFGH(PathNode currentNode, PathNode proposedNode, IGridShape endNode)
{
proposedNode.G = currentNode.G + CalculateCost(currentNode, proposedNode);
proposedNode.H = 10 * (CalculateDistance(endNode.Y2 , proposedNode.Position.Y2 ) +
CalculateDistance(endNode.X2 , proposedNode.Position.X2 ));
return proposedNode;
}
