public JsonResult getGridBounds(string value)
{
GridBounds result = new GridBounds();
result = value.ToGridBounds();
return(Json(result, JsonRequestBehavior.AllowGet));
}
public override IExplicitShape <GridPoint3> Transform(IExplicitShape <GridPoint3> input)
{
var offset1 = offset.GetGridPoint();
var shape = input.Translate(offset1);
var storageRect = GridBounds.Translate(input.Bounds, offset1);
return(shape.ToExplicit(storageRect));
}
public void ConstructorTest(float size)
{
var gridBounds = new GridBounds(size);
Assert.AreEqual(gridBounds.minX, gridBounds.minZ);
Assert.AreEqual(gridBounds.maxX, gridBounds.maxZ);
Assert.IsTrue(Mathf.Approximately(gridBounds.minX + gridBounds.maxX, 0));
Assert.IsTrue(Mathf.Approximately(gridBounds.minZ + gridBounds.maxZ, 0));
}
protected override IExplicitShape <GridPoint3> Generate()
{
var shapes = baseShape.Select(g => g.GetShape());
var boundingPlane = shapes.Select(s => (GridRect)s.Bounds).Aggregate(GridRect.UnionBoundingBox);
var shape = ImplicitShape.Layer(shapes.Select(p => (IImplicitShape <GridPoint2>)p));
var boundingShape = new GridBounds(boundingPlane.Point.To3DXY(0), boundingPlane.Size.To3DXY(baseShape.Count));
return(shape.ToExplicit(boundingShape));
}
public IEnumerator SetSizeTest()
{
var gridBound = new GridBounds(1);
var bounds = new Bounds(new Vector3(1, 1, 1), new Vector3(5, 5, 5));
gridBound.SetSize(bounds);
Assert.IsTrue(gridBound.minX < -1);
Assert.IsTrue(gridBound.maxX > 1);
Assert.IsTrue(gridBound.minZ < -1);
Assert.IsTrue(gridBound.maxZ > 1);
return(null);
}
protected bool InvalidTarget(float distance, float radiusSquared, Invader target, GsRectangle targetBounds)
{
// if the target isn't our specialty
bool notOurSpecialty = !InvaderMatchesSpecialty(target);
if (notOurSpecialty)
{
return(true);
}
// if we can't see the target, then return true
bool cantSeeTarget = distance > radiusSquared;
if (cantSeeTarget)
{
return(true);
}
// if the target reached the end, then return true
bool targetReachedDestination = (target.TargetCell == null);
if (targetReachedDestination)
{
return(true);
}
// if the target cell hasn't even started yet
bool targetNotStartedYet = !GridBounds.Contains(targetBounds);
if (targetNotStartedYet)
{
return(true);
}
// if the target is moving too fast, then return true
bool targetMovingTooFast = Calculator.ComputeDirection(this, target) == GsVector.Zero;
if (targetMovingTooFast)
{
return(true);
}
// return false if we get here
return(false);
}
public override List <IExplicitShape <GridPoint3> > Execute(IEnumerable <IExplicitShape <GridPoint3> > input)
{
var inputList = input.ToList();
var shape1 = inputList[0];
var shape2 = inputList[1];
var scale = scaleFactor.GetGridPoint();
var shape = shape1.Product(shape2, scale);
var storageRect = new GridBounds(
shape1.Bounds.Point.Mul(scale) - shape2.Bounds.Size,
shape1.Bounds.Size.Mul(scale) + shape2.Bounds.Size * 2);
return(new List <IExplicitShape <GridPoint3> >
{
shape.ToExplicit(storageRect)
});
}
protected override IExplicitShape <GridPoint3> Generate()
{
var shape1 = shape2Graph1.GetShape();
var shape2 = shape2Graph2.GetShape();
var shape3 = shape2Graph3.GetShape();
var bounds12 = GridRect.UnionBoundingBox(shape1.Bounds, shape2.Bounds);
var bounds13 = GridRect.UnionBoundingBox(shape1.Bounds, shape3.Bounds);
var bounds23 = GridRect.UnionBoundingBox(shape2.Bounds, shape3.Bounds);
var layer1 = shape1.Layer(bounds23.Size.Y);
var layer2 = shape2.Layer(bounds13.Size.X);
var layer3 = shape3.Layer(bounds12.Size.Y);
layer2 = layer2.SwapToXZY();
layer3 = layer3.SwapToZYX();
var layer1Translation = new GridPoint3(0, 0, bounds23.Point.Y);
var layer2Translation = new GridPoint3(0, 0, bounds13.Point.X);
var layer3Translation = new GridPoint3(0, 0, bounds12.Point.Y);
var bound1 = new GridBounds(layer1.Bounds.Point + layer1Translation, layer1.Bounds.Size);
var bound2 = new GridBounds(layer2.Bounds.Point + layer2Translation, layer2.Bounds.Size);
var bound3 = new GridBounds(layer3.Bounds.Point + layer3Translation, layer3.Bounds.Size);
var fixedLayer1 = layer1.Translate(layer1Translation);
var fixedLayer2 = layer2.Translate(layer2Translation);
var fixedLayer3 = layer3.Translate(layer3Translation);
var fixedLayer12 = ImplicitShape.Intersection(fixedLayer1, fixedLayer2);
var fixedLayer123 = ImplicitShape.Intersection(fixedLayer12, fixedLayer3);
var bound12 = GridBounds.Intersection(bound1, bound2);
var bound123 = GridBounds.Intersection(bound12, bound3);
return(fixedLayer123.ToExplicit(bound123));
}
/// <summary>
/// To cast the string value to grid bounds model
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static GridBounds ToGridBounds(this string value)
{
//Declarations
GridBounds g = new GridBounds();
int indexOfWhiteSpace = 0;
List <string> values = new List <string>();
try
{
indexOfWhiteSpace = value.IndexOf <char>(c => !char.IsWhiteSpace(c));
if (indexOfWhiteSpace > 0)
{
//Split the string value by space
values = value.Split(' ', (char)StringSplitOptions.RemoveEmptyEntries).ToList();
}
else
{
//Split the string value by chars
values = value.Split().ToList();
}
//If the total of values aren't equals to 2, thrown an error
if (values.Count != 2)
{
return(new GridBounds("Error: The typed values aren't a correct coordinate, please try again!"));
}
else
{
g = new GridBounds(values[0].ToInteger(), values[1].ToInteger());
}
}
catch (Exception ex)
{
}
return(g);
}
// constructors
internal GridUnpopulatedLeafNode(GridInternalNode parent, GridBounds rectangle)
{
this.Parent = parent;
this.Rectangle = rectangle;
this.BoundingRectangle = GridBounds.Uninitialized;
this.VisibleLeafNodes = null;
}
// constructors
internal GridPopulatedLeafNode(GridInternalNode parent, GridBounds rectangle, StaticOpaqueObject initialStaticOpaqueObject)
{
this.Parent = parent;
this.Rectangle = rectangle;
this.BoundingRectangle = GridBounds.Uninitialized;
this.VisibleLeafNodes = null;
if (initialStaticOpaqueObject != null) {
this.StaticOpaqueObjects = new StaticOpaqueObject[] { initialStaticOpaqueObject };
this.StaticOpaqueObjectCount = 1;
} else {
this.StaticOpaqueObjects = new StaticOpaqueObject[] { null };
this.StaticOpaqueObjectCount = 0;
}
this.DisplayList = new DisplayList();
this.TransparentFaces = new object[1];
this.TransparentFaceCount = 0;
}
// constructors
internal GridInternalNode(GridInternalNode parent, GridBounds rectangle, GridNode[] children)
{
this.Parent = parent;
this.Rectangle = rectangle;
this.BoundingRectangle = GridBounds.Uninitialized;
this.Children = children;
}
/// <summary>
/// Cast the string value to a Movement model, the movement coordinates are breadcrumbs
/// </summary>
/// <param name="value">string with the instructions</param>
/// <param name="initialize">Starting coordinates, I mea, last coordinate of the rover</param>
/// <param name="limits">Grid bounds</param>
/// <returns></returns>
private static Movement ToMovement(this string value, Coordinate initialize, GridBounds limits)
{
//Declarations
Movement result = new Movement(initialize.X, initialize.Y, initialize.Z);
string direction = initialize.Z;
try
{
//This loop completes the rotation before the movement is made
foreach (char v in value)
{
switch (v)
{
case 'L':
direction = getLeftCardinalDirection(direction);
break;
case 'R':
direction = getRightCardinalDirection(direction);
break;
}
}
//This cases are in order to decide the correct direction of the movement and do it.
//ASSUMPTION: The rovers can't go outside of the grid bounds, but the movements continue.
//If the movement exceeds the grid bounds, the movement is not performed and the error message will be displayed.
switch (direction)
{
case "N":
result.currentAxis = "N";
result.currentValueXAxis = result.lastValueXAxis;
if ((result.lastValueYAxis + 1) > limits.Y)
{
result.currentValueXAxis = result.lastValueXAxis;
result.error = "You cannot move the rover out of bounds because it can get lost.";
result.done = false;
}
else
{
result.currentValueYAxis = result.lastValueYAxis + 1;
result.done = true;
}
break;
case "O":
result.currentAxis = "O";
if ((result.lastValueXAxis - 1) < 0)
{
result.currentValueYAxis = result.lastValueYAxis;
result.error = "You cannot move the rover out of bounds because it can get lost.";
result.done = false;
}
else
{
result.currentValueXAxis = result.lastValueXAxis - 1;
result.done = true;
}
result.currentValueYAxis = result.lastValueYAxis;
break;
case "S":
result.currentAxis = "S";
result.currentValueXAxis = result.lastValueXAxis;
if ((result.lastValueYAxis - 1) < 0)
{
result.lastValueYAxis = result.lastValueYAxis;
result.error = "You cannot move the rover out of bounds because it can get lost.";
result.done = false;
}
else
{
result.currentValueYAxis = result.lastValueYAxis - 1;
result.done = true;
}
break;
case "E":
result.currentAxis = "E";
if ((result.lastValueXAxis + 1) > limits.X)
{
result.currentValueXAxis = result.lastValueXAxis;
result.error = "You cannot move the rover out of bounds because it can get lost.";
result.done = false;
}
else
{
result.currentValueXAxis = result.lastValueXAxis + 1;
result.done = true;
}
result.currentValueYAxis = result.lastValueYAxis;
break;
}
}
catch (Exception ex)
{
}
return(result);
}
/// <summary>
/// Get the list of movements from the instructions
/// </summary>
/// <param name="value">instructions text</param>
/// <param name="initialize">information of the axis (X & Y) and the Cardinal Direction </param>
/// <param name="limits">Limits of the axis (X & Y)</param>
/// <returns></returns>
public static List <Movement> ToMovements(this string value, Coordinate initialize, GridBounds limits)
{
//Declarations
List <Movement> g = new List <Movement>();
Coordinate currentPosition = initialize;
string helper = value;
string instructions = "";
int indexOfM = 0;
try
{
//Do the action while the helper has text
while (helper.Length > 0)
{
indexOfM = helper.IndexOf('M');
//Get the movement instructions, I mean, get the rotation instructions (can be more than 1) and the movement instruction
instructions = helper.Substring(0, indexOfM);
//Split the text into instructions in order to do the movements requested
string[] directions = instructions.Trim().Split();
foreach (string direction in directions)
{
Movement result = direction.ToMovement(currentPosition, limits);
result.Input = instructions + "M";
g.Add(result);
//re-init the values of the last coordinate to re-use on the next movement
initialize.X = result.currentValueXAxis;
initialize.Y = result.currentValueYAxis;
initialize.Z = result.currentAxis;
}
helper = helper.Substring(indexOfM + 1, helper.Length - (indexOfM + 1));
}
}
catch (Exception ex)
{
}
return(g);
}
