private void SetAdjacency(int roomNum, CardinalDirections roomDir, ref Room <T> room, ref Room <T> lastRoom)
{
if (roomNum != 1)
{
switch (roomDir)
{
case CardinalDirections.NORTH:
room.SouthID = lastRoom.ID;
lastRoom.NorthID = room.ID;
break;
case CardinalDirections.SOUTH:
room.NorthID = lastRoom.ID;
lastRoom.SouthID = room.ID;
break;
case CardinalDirections.EAST:
room.WestID = lastRoom.ID;
lastRoom.EastID = room.ID;
break;
case CardinalDirections.WEST:
room.EastID = lastRoom.ID;
lastRoom.WestID = room.ID;
break;
}
}
else
{
lastRoom = room;
}
}
public static Vector2 DirectionToVector(CardinalDirections Direction)
{
switch (Direction)
{
case CardinalDirections.West:
return(Vector2.left);
case CardinalDirections.NorthWest:
return(new Vector2(-1, 1).normalized);
case CardinalDirections.North:
return(Vector2.up);
case CardinalDirections.NorthEast:
return(new Vector2(1, 1).normalized);
case CardinalDirections.East:
return(Vector2.right);
case CardinalDirections.SouthEast:
return(new Vector2(1, -1).normalized);
case CardinalDirections.South:
return(Vector2.down);
case CardinalDirections.SouthWest:
return(new Vector2(-1, -1).normalized);
default:
return(Vector2.zero);
}
}
private bool valid_tangent(Vector2 node, Vector2 dest, Vector2 best_dest, CardinalDirections dir)
{
// If the current destination is closer than the best destination in the travelled direction, it's fine
if (destination_correct_direction(dest, best_dest, dir))
{
return(true);
}
// Otherwise the current destination has to at least be closet in tangential directions
switch (dir)
{
case CardinalDirections.Down:
case CardinalDirections.Up:
if (dest.X < node.X)
{
return(best_dest.X < dest.X);
}
else
{
return(best_dest.X > dest.X);
}
case CardinalDirections.Left:
case CardinalDirections.Right:
if (dest.Y < node.Y)
{
return(best_dest.Y < dest.Y);
}
else
{
return(best_dest.Y > dest.Y);
}
}
throw new ArgumentException();
}
private void HighlightAttack(bool highlight, Point position)
{
CardinalDirections direction = Direction.GetCardinalDirection(this.Unit.GetPosition(), position);
List <Point> pointsInLine = GetPointsInLine(direction);
pointsInLine?.ForEach(p => SimulateAttack(highlight, p, this.DeltaHealth, this.Knockback, true));
}
public Ballv5d4d3()
{
showBallPositionRect = false;
showHeadingMarker = false;
visible = true;
rectCollisionSide = CardinalDirections.NotSet;
}
private List <Point> GetPointsInLine(CardinalDirections direction)
{
if (Board == null)
{
return(new List <Point>());
}
Point unit = this.Unit.GetPosition();
List <Point> points = new List <Point>();
switch (direction)
{
case CardinalDirections.North:
points = Board.Where(point => point.x == unit.x && point.z > unit.z).ToList();
break;
case CardinalDirections.South:
points = Board.Where(point => point.x == unit.x && point.z < unit.z).ToList();
break;
case CardinalDirections.East:
points = Board.Where(point => point.z == unit.z && point.x > unit.x).ToList();
break;
case CardinalDirections.West:
points = Board.Where(point => point.z == unit.z && point.x < unit.x).ToList();
break;
}
return(points);
}
public IEnumerator Refresh_AttributesArgAllLocationsSizes_DoesNotThrowException(
[ValueSource(typeof(ValueSourceCommon), "AllViewLocations")]
CardinalDirections location,
[ValueSource(typeof(ValueSourceCommon), "AllViewSizes")]
ViewSizes size
)
{
// Set Up
SetUpCommon.CreateTestCamera();
SetUpCommon.CreateTestNameCanvas(TestContext.CurrentContext.Test.Name);
SubjectDetailView detailView =
SubjectDetailView.GetView(
SetUpCommon.GetUICanvas(),
size,
location
);
IAttributeData aData = ValueSourceCommon.GetMockAttributeData();
// Assert
Assert.DoesNotThrow(() => {
detailView.Refresh(aData);
});
yield return(new WaitForSeconds(VisualTimer));
// Tear Down
TearDownCommon.DestroyAllGameObjects();
}
internal bool move_node(CardinalDirections dir)
{
if (ActiveNodeIndex == -1)
{
return(false);
}
var destination = Destinations.destination(
NodeOriginalLocations[ActiveNode], dir);
// Vertical wrap
if (destination.IsNothing && WrapVerticalSameColumn)
{
destination = move_vertical_wrap(dir, destination, true);
}
else if (destination.IsNothing && WrapVerticalMove)
{
destination = move_vertical_wrap(dir, destination);
}
if (destination.IsNothing)
{
return(false);
}
set_active_node(node_from_location(destination));
return(true);
}
public RoverBase(string name, CardinalDirections cardinalDirection = CardinalDirections.N, int speed = 1)
{
Name = name;
CardinalDirection = cardinalDirection;
Speed = speed;
Position = new CartesianCoordinate();
}
private List <Point> GetRowsToAttack(Point target)
{
Point neoSatanPosition = this.Unit.GetPosition();
cardinalDirection = Direction.GetCardinalDirection(this.Unit.GetPosition(), target);
List <Point> rowsToAttack = new List <Point>();
switch (cardinalDirection)
{
case CardinalDirections.South:
case CardinalDirections.East:
case CardinalDirections.SouthWest:
case CardinalDirections.NorthEast:
cardinalDirectionToRotate = CardinalDirections.South;
rowsToAttack = this.ValidPositions.Where(p => p.z < neoSatanPosition.z && p.x >= neoSatanPosition.x - 1 && p.x <= neoSatanPosition.x + 1).ToList();
break;
case CardinalDirections.North:
case CardinalDirections.West:
case CardinalDirections.NorthWest:
case CardinalDirections.SouthEast:
cardinalDirectionToRotate = CardinalDirections.West;
rowsToAttack = this.ValidPositions.Where(p => p.x < neoSatanPosition.x && p.z >= neoSatanPosition.z - 1 && p.z <= neoSatanPosition.z + 1).ToList();
break;
}
return(rowsToAttack);
}
public Vector Move(CardinalDirections direction, int distance)
{
var heading = this.Heading;
switch (direction)
{
case CardinalDirections.Right:
heading += 90;
break;
case CardinalDirections.Back:
heading += 180;
break;
case CardinalDirections.Left:
heading += 270;
break;
}
var radians = heading * Math.PI / 180;
var adjacent = Math.Cos(radians) * distance;
var opposite = Math.Sin(radians) * distance;
return(new Vector(this.Heading, Math.Round(this.X + adjacent, 2), Math.Round(this.Y + opposite, 2)));
}
public GenerationConnectionID(CardinalDirections entry, CardinalDirections exit, ConnectionID enID, ConnectionID exID)
{
this.entry.dir = entry;
this.entry.id = enID;
this.exit.dir = exit;
this.exit.id = exID;
}
} // end of function SetRectangleCollisionSide(Blockv0d1 b)
private void SetRectangleCollisionSide(Blockv0d2 b, CollisionCheckMarkerv0d1 cc)
{
//float angleToRectCenter = AngleBetween2(b.center, cc.position);
if (cc.position.X < b.position.X + b.size.Width && cc.position.X > b.center.X &&
cc.position.Y > b.position.Y && cc.position.Y < b.position.Y + b.size.Height)
{
rectCollisionSide = CardinalDirections.East;
}
if (cc.position.X > b.position.X && cc.position.X < b.position.X + b.size.Width &&
cc.position.Y < b.position.Y + b.size.Height && cc.position.Y > b.center.Y)
{
rectCollisionSide = CardinalDirections.South;
}
if (cc.position.X > b.position.X && cc.position.X < b.center.X &&
cc.position.Y > b.position.Y &&
cc.position.Y < b.position.Y + b.size.Height)
{
rectCollisionSide = CardinalDirections.West;
}
if (cc.position.X > b.position.X && cc.position.X < b.position.X + b.size.Width &&
cc.position.Y > b.position.Y && cc.position.Y < b.center.Y)
{
rectCollisionSide = CardinalDirections.North;
}
} // end of function SetRectangleCollisionSide(Blockv0d2 b, CollisionCheckMarkerv0d1 cc)
private Vector3 GetPositionOffset(CardinalDirections direction, float yOffset)
{
float offset = 0.5f;
switch (direction)
{
case CardinalDirections.North:
return(new Vector3(0, yOffset, offset));
case CardinalDirections.NorthEast:
return(new Vector3(offset, yOffset, offset));
case CardinalDirections.NorthWest:
return(new Vector3(-offset, yOffset, offset));
case CardinalDirections.East:
return(new Vector3(offset, yOffset, 0));
case CardinalDirections.SouthEast:
return(new Vector3(offset, yOffset, -offset));
case CardinalDirections.SouthWest:
return(new Vector3(-offset, yOffset, -offset));
case CardinalDirections.West:
return(new Vector3(0, yOffset, -offset));
case CardinalDirections.South:
return(new Vector3(0, yOffset, -offset));
default:
return(new Vector3(0, -yOffset, 0));
}
}
public GridPoint GetAdjGridPt(GridPoint gridPt, CardinalDirections direction)
{
GridPointMatrix matrix = gridPt.ParentGrid;
switch (direction)
{
case CardinalDirections.N:
return(matrix[gridPt.GridCoordinatesAbs.X, gridPt.GridCoordinatesAbs.Y - 1]);
case CardinalDirections.NE:
return(matrix[gridPt.GridCoordinatesAbs.X - 1, gridPt.GridCoordinatesAbs.Y - 1]);
case CardinalDirections.E:
return(matrix[gridPt.GridCoordinatesAbs.X + 1, gridPt.GridCoordinatesAbs.Y]);
case CardinalDirections.SE:
return(matrix[gridPt.GridCoordinatesAbs.X + 1, gridPt.GridCoordinatesAbs.Y + 1]);
case CardinalDirections.S:
return(matrix[gridPt.GridCoordinatesAbs.X, gridPt.GridCoordinatesAbs.Y + 1]);
case CardinalDirections.SW:
return(matrix[gridPt.GridCoordinatesAbs.X - 1, gridPt.GridCoordinatesAbs.Y + 1]);
case CardinalDirections.W:
return(matrix[gridPt.GridCoordinatesAbs.X - 1, gridPt.GridCoordinatesAbs.Y]);
case CardinalDirections.NW:
return(matrix[gridPt.GridCoordinatesAbs.X - 1, gridPt.GridCoordinatesAbs.Y - 1]);
default:
return(null);
}
}
void changeFaceDirection(CardinalDirections new_direction)
{
if (face_direction != new_direction)
{
face_direction = new_direction;
}
}
private void SetBallHeadingv2()
{
if (velocity.X > 0 && velocity.Y > 0)
{
ballHeading = CardinalDirections.SouthEast;
}
if (velocity.X < 0 && velocity.Y > 0)
{
ballHeading = CardinalDirections.SouthWest;
}
if (velocity.X < 0 && velocity.Y < 0)
{
ballHeading = CardinalDirections.NorthWest;
}
if (velocity.X > 0 && velocity.Y < 0)
{
ballHeading = CardinalDirections.NorthEast;
}
if (velocity.X == 0 && velocity.Y < 0)
{
ballHeading = CardinalDirections.North;
}
if (velocity.X == 0 && velocity.Y > 0)
{
ballHeading = CardinalDirections.South;
}
if (velocity.X < 0 && velocity.Y == 0)
{
ballHeading = CardinalDirections.West;
}
if (velocity.X > 0 && velocity.Y == 0)
{
ballHeading = CardinalDirections.East;
}
} // end of function SetBallHeading()
public async Task <IActionResult> Edit(int id, [Bind("ShaftId,Ylower,Yupper,North,Xlower,Xupper,East,Subplot")] ShaftLocation shaftLocation)
{
if (id != shaftLocation.ShaftId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
shaftLocation.Lookup = $"{shaftLocation.Xlower}/{shaftLocation.Xupper} {shaftLocation.North} {shaftLocation.Ylower}/{shaftLocation.Yupper} {shaftLocation.East} {shaftLocation.Subplot}";
_context.Update(shaftLocation);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ShaftLocationExists(shaftLocation.ShaftId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewBag.NorthSouth = new SelectList(CardinalDirections.NorthSouth(), shaftLocation.North);
ViewBag.EastWest = new SelectList(CardinalDirections.EastWest(), shaftLocation.East);
ViewBag.Subplots = new SelectList(CardinalDirections.SubPlots(), shaftLocation.Subplot);
return(View(shaftLocation));
}
public GridPoint GetAdjGridPt(GridPoint gridPt, CardinalDirections direction)
{
GridPointMatrix matrix = gridPt.ParentGrid;
switch (direction)
{
case CardinalDirections.N:
return matrix[gridPt.GridCoordinatesAbs.X, gridPt.GridCoordinatesAbs.Y - 1];
case CardinalDirections.NE:
return matrix[gridPt.GridCoordinatesAbs.X - 1, gridPt.GridCoordinatesAbs.Y - 1];
case CardinalDirections.E:
return matrix[gridPt.GridCoordinatesAbs.X + 1, gridPt.GridCoordinatesAbs.Y];
case CardinalDirections.SE:
return matrix[gridPt.GridCoordinatesAbs.X + 1, gridPt.GridCoordinatesAbs.Y + 1];
case CardinalDirections.S:
return matrix[gridPt.GridCoordinatesAbs.X, gridPt.GridCoordinatesAbs.Y + 1];
case CardinalDirections.SW:
return matrix[gridPt.GridCoordinatesAbs.X - 1, gridPt.GridCoordinatesAbs.Y + 1];
case CardinalDirections.W:
return matrix[gridPt.GridCoordinatesAbs.X - 1, gridPt.GridCoordinatesAbs.Y];
case CardinalDirections.NW:
return matrix[gridPt.GridCoordinatesAbs.X - 1, gridPt.GridCoordinatesAbs.Y - 1];
default:
return null;
}
}
internal static IEnumerable <CardinalDirections> tangent_directions(
CardinalDirections dir)
{
switch (dir)
{
case CardinalDirections.Down:
case CardinalDirections.Up:
yield return(CardinalDirections.Left);
yield return(CardinalDirections.Right);
break;
case CardinalDirections.Left:
case CardinalDirections.Right:
yield return(CardinalDirections.Down);
yield return(CardinalDirections.Up);
break;
default:
yield break;
}
}
public void MoveLastPointAndAnchor(Vector3 pos, Vector3 anchorPos, CardinalDirections dir, Vector2 dims)
{
Vector3 relativePosForRot = rotationAnchors[rotationAnchors.Length - 1] - points[points.Length - 1];
points[points.Length - 1] = transform.InverseTransformPoint(pos);
Vector3 newAnchorPos = transform.InverseTransformPoint(pos + (anchorPos.normalized * 5f));
switch (dir)
{
case CardinalDirections.North:
newAnchorPos.z = dims.y * 0.5f - dims.y * 0.35f;
break;
case CardinalDirections.East:
newAnchorPos.x = dims.x * 0.5f - dims.x * 0.35f;
break;
case CardinalDirections.South:
newAnchorPos.z = dims.y * 0.5f - dims.y * 0.65f;
break;
case CardinalDirections.West:
newAnchorPos.x = dims.x * 0.5f - dims.x * 0.65f;
break;
}
points[points.Length - 2] = newAnchorPos;
rotationAnchors[rotationAnchors.Length - 1] = points[points.Length - 1] + relativePosForRot;
}
private void Move()
{
float horizontalOffset = Input.GetAxis("Horizontal");
float verticalOffset = Input.GetAxis("Vertical");
// Translates the player to a new position, at a given speed.
Vector2 newPos = new Vector2(transform.position.x + horizontalOffset * m_speed,
transform.position.y + verticalOffset * m_speed);
m_rb2D.MovePosition(newPos);
// Computes the player main direction (North, Sound, East, West)
if (Mathf.Abs(horizontalOffset) > Mathf.Abs(verticalOffset))
{
if (horizontalOffset > 0)
{
m_direction = CardinalDirections.CARDINAL_E;
}
else
{
m_direction = CardinalDirections.CARDINAL_W;
}
}
else if (Mathf.Abs(horizontalOffset) < Mathf.Abs(verticalOffset))
{
if (verticalOffset > 0)
{
m_direction = CardinalDirections.CARDINAL_N;
}
else
{
m_direction = CardinalDirections.CARDINAL_S;
}
}
}
} // end of function BounceV1
float SetMinBounceAngle(CardinalDirections gh, float angle)
{
float minangle = 0;
switch (gh)
{
case CardinalDirections.East:
break;
case CardinalDirections.SouthEast:
break;
case CardinalDirections.SouthWest:
break;
case CardinalDirections.West:
break;
case CardinalDirections.NorthWest:
break;
case CardinalDirections.North:
break;
case CardinalDirections.NorthEast:
break;
default:
break;
}
return(minangle);
}
public async void Flip(CardinalDirections direction)
{
if (this.CanManeuver)
{
await this.messenger.SendAsync(Commands.Flip, (char)(CardinalDirection)direction);
}
}
} // end of function DrawDebugInfo(Graphics g, ref PointF textPos)
#region moved to v5.4 07/18/2017
private void SetBallHeading()
{
if (angle < pi / 2)
{
ballHeading = CardinalDirections.SouthEast;
}
if (angle < pi && angle >= pi / 2)
{
ballHeading = CardinalDirections.SouthWest;
}
if (angle < 3 * pi / 2 && angle >= pi)
{
ballHeading = CardinalDirections.NorthWest;
}
if (angle < 2 * pi && angle >= 3 * pi / 2)
{
ballHeading = CardinalDirections.NorthEast;
}
if (angle == 2 * pi || angle == 0)
{
ballHeading = CardinalDirections.East;
}
if (angle == pi / 2)
{
ballHeading = CardinalDirections.South;
}
if (angle == pi)
{
ballHeading = CardinalDirections.West;
}
if (angle == 3 * pi / 2)
{
ballHeading = CardinalDirections.North;
}
} // end of function SetBallHeading()
public IEnumerator HideDetail_WithDescriptionDataAllLocationsSizes_DoesNotThrowException(
[ValueSource(typeof(ValueSourceCommon), "AllViewLocations")]
CardinalDirections location,
[ValueSource(typeof(ValueSourceCommon), "AllViewSizes")]
ViewSizes size
)
{
// Set Up
SetUpCommon.CreateTestCamera();
SetUpCommon.CreateTestNameCanvas(
TestContext.CurrentContext.Test.Name
);
Subject subjectUnderTest = new Subject(
SetUpCommon.GetUICanvas()
);
subjectUnderTest.TryAddData(
ValueSourceCommon.GetMockDescriptionData()
);
subjectUnderTest.ShowDetail(location, size);
// Assert
yield return(new WaitForSeconds(VisualTimer * .5f));
Assert.DoesNotThrow(() => {
subjectUnderTest.HideDetail();
});
yield return(new WaitForSeconds(VisualTimer * .5f));
// Tear Down
TearDownCommon.DestroyAllGameObjects();
}
public static Quaternion GetRotation(CardinalDirections direction, float xRotation, float zRotation)
{
switch (direction)
{
case CardinalDirections.North:
return(Quaternion.Euler(xRotation, 0f, zRotation));
case CardinalDirections.NorthEast:
return(Quaternion.Euler(xRotation, 45f, zRotation));
case CardinalDirections.NorthWest:
return(Quaternion.Euler(xRotation, 315f, zRotation));
case CardinalDirections.East:
return(Quaternion.Euler(xRotation, 90f, zRotation));
case CardinalDirections.SouthEast:
return(Quaternion.Euler(xRotation, 135f, zRotation));
case CardinalDirections.SouthWest:
return(Quaternion.Euler(xRotation, 225f, zRotation));
case CardinalDirections.West:
return(Quaternion.Euler(xRotation, 270f, zRotation));
case CardinalDirections.South:
default:
return(Quaternion.Euler(xRotation, 180f, zRotation));
}
}
void SpawnCharacters()
{
Vector3[] spawnPoints = m_map.GetSpawnPoints(10);
Vector3 playerSpawnPoint, exitSpawnPoint;
Helper.FindFurthestPoints(spawnPoints, out playerSpawnPoint, out exitSpawnPoint);
// playerSpawnPoint = spawnPoints[0];
// exitSpawnPoint = spawnPoints[1];
m_player = Instantiate(m_playerPrefab, playerSpawnPoint, Quaternion.identity);
m_player.m_map = m_map;
m_exit = Instantiate(m_exitPrefab, exitSpawnPoint, Quaternion.identity);
List <Ant> ants = new List <Ant>();
foreach (Vector3 spawn in spawnPoints)
{
if (spawn != playerSpawnPoint && spawn != exitSpawnPoint)
{
CardinalDirections randomDirection = (CardinalDirections)Random.Range(0, (int)CardinalDirections.END);
Debug.Log(spawn);
Debug.Log(randomDirection);
Ant newAnt = Instantiate(m_antPrefab, spawn, Quaternion.Euler(0, (int)randomDirection * -90, 0));
m_map.WorldToGrid(spawn, out newAnt.m_row, out newAnt.m_col);
newAnt.m_direction = randomDirection;
ants.Add(newAnt);
}
}
m_ants = new Ant[ants.Count];
ants.CopyTo(m_ants);
}
} // end of function Reset()
private void LocalLoadAndReset()
{
collisionDetected = false;
rectCollisionSide = CardinalDirections.NotSet;
IsLaunched = false;
initialLaunch = true;
} // end of function LocalLoadAndReset()
public IEnumerator Refresh_LocationAbilitiesArg_DoesNotThrowException(
[ValueSource(typeof(ValueSourceCommon), "AllViewLocations")]
CardinalDirections location,
[ValueSource(typeof(ValueSourceCommon), "AllViewSizes")]
ViewSizes size
)
{
// Set Up
SetUpCommon.CreateTestCamera();
SetUpCommon.CreateTestNameCanvas(
TestContext.CurrentContext.Test.Name
);
SetUpCommon.CreateEventSystem();
ActionBarView abView =
ActionBarView.GetView(
SetUpCommon.GetUICanvas(),
size,
location
);
// Assert
Assert.DoesNotThrow(() => {
abView.Refresh(
null,
ValueSourceCommon.StubV3ArgActionDict(5)
);
});
yield return(new WaitForSeconds(VisualTimer));
// Tear Down
TearDownCommon.DestroyAllGameObjects();
}
public override string ToString()
{
CardinalDirections orientationValue = (CardinalDirections)myOrientation;
string directionValue = orientationValue.ToString();
return(String.Format("{0} {1} {2}", myX, myY, directionValue));
}
public static string GetPreSuffixFromOrientation(CardinalDirections orientation)
{
switch (orientation) {
case CardinalDirections.N:
return "Back";
break;
case CardinalDirections.S:
return "Front";
break;
default:
return "Right";
}
}
public static string GetPostSuffixFromFaceDirection(CardinalDirections face_direction)
{
switch (face_direction) {
case CardinalDirections.N:
return "Back";
break;
case CardinalDirections.S:
return "Front";
break;
default:
return "Right";
}
}
public string getSuffix(CardinalDirections orientation)
{
string clipSuffix = "";
string separator = "";
List<string> post_suffixes;
if(getObj().resource_identifiers.Second.Count > 1) {
clipSuffix = GetPreSuffixFromOrientation (orientation);
}
getObj().resource_identifiers.Second.TryGetValue (orientation, out post_suffixes);
if(post_suffixes.Count > 1 && getObj().resource_identifiers.Second.Count > 1) {
separator = "-";
}
clipSuffix = clipSuffix + separator + post_suffixes [UnityEngine.Random.Range (0, post_suffixes.Count)];
return clipSuffix;
}
// DETECT COLLISIONS, RAYCAST FORWARD
// CENTIPEDE PATTERN
// if collision forward look down, if locked down collision "fall"
// if hit bottom, invert to up, if locked up "float"
public void fakeUpdate()
{
float rayDepth = 0.2f,
horizontalX,
horizontalY,
verticalX,
verticalY;
List<RaycastHit2D> hits = new List<RaycastHit2D>();
horizontalX = go.transform.localScale.x/2f;
horizontalY = go.transform.localScale.y/3f;
verticalX = go.transform.localScale.x/3f;
verticalY = go.transform.localScale.y/2f;
switch(direction){
default:
case CardinalDirections.North:
// raycast up
// cast up right
hits.AddRange(
Physics2D.RaycastAll(
go.transform.position + new Vector3(verticalX, verticalY, 0f),
Vector2.up,
rayDepth)
);
Debug.DrawRay(
go.transform.position + new Vector3(verticalX, verticalY, 0f),
Vector2.up * rayDepth
);
// cast up left
hits.AddRange(
Physics2D.RaycastAll(
go.transform.position + new Vector3(-verticalX, verticalY, 0f),
Vector2.up,
rayDepth)
);
Debug.DrawRay(
go.transform.position + new Vector3(-verticalX, verticalY, 0f),
Vector2.up * rayDepth
);
// check hits
foreach ( RaycastHit2D hit in hits ){
if ( hit.collider != null && hit.collider.gameObject != go ) {
direction = CardinalDirections.East;
}
}
break;
case CardinalDirections.South:
// raycast down
// cast down right
hits.AddRange(
Physics2D.RaycastAll(
go.transform.position + new Vector3(verticalX, -verticalY, 0f),
-Vector2.up,
rayDepth)
);
Debug.DrawRay(
go.transform.position + new Vector3(verticalX, -verticalY, 0f),
-Vector2.up * rayDepth
);
// cast updownleft
hits.AddRange(
Physics2D.RaycastAll(
go.transform.position + new Vector3(-verticalX, -verticalY, 0f),
-Vector2.up,
rayDepth)
);
Debug.DrawRay(
go.transform.position + new Vector3(-verticalX, -verticalY, 0f),
-Vector2.up * rayDepth
);
// check hits
foreach ( RaycastHit2D hit in hits ){
if ( hit.collider != null && hit.collider.gameObject != go ) {
direction = CardinalDirections.West;
}
}
break;
case CardinalDirections.East:
// raycast right
// cast right top
hits.AddRange(
Physics2D.RaycastAll(
go.transform.position + new Vector3(horizontalX, horizontalY, 0f),
Vector2.right,
rayDepth)
);
Debug.DrawRay(
go.transform.position + new Vector3(horizontalX, horizontalY, 0f),
Vector2.right * rayDepth
);
// cast right bottom
hits.AddRange(
Physics2D.RaycastAll(
go.transform.position + new Vector3(horizontalX, -horizontalY, 0f),
Vector2.right,
rayDepth)
);
Debug.DrawRay(
go.transform.position + new Vector3(horizontalX, -horizontalY, 0f),
Vector2.right * rayDepth
);
// check hits
foreach ( RaycastHit2D hit in hits ){
if ( hit.collider != null && hit.collider.gameObject != go ) {
direction = CardinalDirections.South;
}
}
break;
case CardinalDirections.West:
// raycast left
// cast left top
hits.AddRange(
Physics2D.RaycastAll(
go.transform.position + new Vector3(-horizontalX, horizontalY, 0f),
-Vector2.right,
rayDepth)
);
Debug.DrawRay(
go.transform.position + new Vector3(-horizontalX, horizontalY, 0f),
-Vector2.right * rayDepth
);
// cast left bottom
hits.AddRange(
Physics2D.RaycastAll(
go.transform.position + new Vector3(horizontalX, -horizontalY, 0f),
-Vector2.right,
rayDepth)
);
Debug.DrawRay(
go.transform.position + new Vector3(-horizontalX, -horizontalY, 0f),
-Vector2.right * rayDepth
);
foreach ( RaycastHit2D hit in hits ){
if ( hit.collider != null && hit.collider.gameObject != go ) {
direction = CardinalDirections.North;
}
}
break;
}
}
void changeFaceDirection(CardinalDirections new_direction) {
if (face_direction != new_direction) {
face_direction = new_direction;
}
}
void checkPosUpdate() {
Vector2 vec = new Vector2(transform.position.x, transform.position.y) - last_position;
if (vec != Vector2.zero) { // if it has moved
stall = 4;
// set movement direction
if(vec.y != 0) {
if(vec.y < 0) {
face_direction = CardinalDirections.S;
}
else if(vec.y > 0) {
face_direction = CardinalDirections.N;
}
}
if(vec.x != 0) {
if(vec.x > 0) {
if(face_direction != CardinalDirections.E) {
FlipHScale (CardinalDirections.E);
}
face_direction = CardinalDirections.E;
}
else if(vec.x < 0) {
if(face_direction != CardinalDirections.W) {
FlipHScale (CardinalDirections.W);
}
face_direction = CardinalDirections.W;
}
}
startAction("running");
last_position = transform.position;
}
else {
stall--;
if(stall <= 0) {
stopAction("running");
}
}
}
void FlipHScale(CardinalDirections direction) {
if(direction == CardinalDirections.E) {
transform.localScale = new Vector3 (1, 1, 1);
}
else if (direction == CardinalDirections.W) {
transform.localScale = new Vector3 (-1, 1, 1);
}
}
public GridPoint GetAdjGridPt(GridPoint gridPt, CardinalDirections direction)
{
throw new NotImplementedException();
}
private void CreateNewBackground(SpriteRenderer lastBackground, CardinalDirections direction)
{
Vector2 lastBackgroundIndex = new Vector2(Mathf.Round((lastBackground.transform.position.x - _initalBackgroundPos.x) / (lastBackground.bounds.extents.x * 2)),
Mathf.Round((lastBackground.transform.position.y - _initalBackgroundPos.y) / (lastBackground.bounds.extents.y * 2))),
newBackgroundIndex;
GameObject newBackground,
backgroundToLoad;
int backgroundType = Random.Range(1, 3),
backgroundRotation = 90 * Random.Range(0, 4);
if (backgroundType < 2)
backgroundToLoad = Background1;
else
backgroundToLoad = Background2;
switch (direction)
{
case CardinalDirections.UP:
newBackgroundIndex = new Vector2(lastBackgroundIndex.x, lastBackgroundIndex.y + 1);
if (!_activeBackgrounds.Contains(newBackgroundIndex))
{
if (_allBackgrounds.ContainsKey(newBackgroundIndex))
{
if (_allBackgrounds[newBackgroundIndex][0] < 2)
backgroundToLoad = Background1;
else
backgroundToLoad = Background2;
newBackground = (GameObject)Instantiate(backgroundToLoad, new Vector3(lastBackground.transform.position.x, lastBackground.transform.position.y + (lastBackground.bounds.extents.y * 2), 0), Quaternion.AngleAxis(_allBackgrounds[newBackgroundIndex][1], Vector3.forward));
}
else
{
newBackground = (GameObject)Instantiate(backgroundToLoad, new Vector3(lastBackground.transform.position.x, lastBackground.transform.position.y + (lastBackground.bounds.extents.y * 2), 0), Quaternion.AngleAxis(backgroundRotation, Vector3.forward));
_allBackgrounds.Add(newBackgroundIndex, new int[2] { backgroundType, backgroundRotation });
}
_allBackgroundSprites.Add(newBackground.GetComponent<SpriteRenderer>());
_activeBackgrounds.Add(newBackgroundIndex);
}
break;
case CardinalDirections.DOWN:
newBackgroundIndex = new Vector2(lastBackgroundIndex.x, lastBackgroundIndex.y - 1);
if (!_activeBackgrounds.Contains(newBackgroundIndex))
{
if (_allBackgrounds.ContainsKey(newBackgroundIndex))
{
if (_allBackgrounds[newBackgroundIndex][0] < 2)
backgroundToLoad = Background1;
else
backgroundToLoad = Background2;
newBackground = (GameObject)Instantiate(backgroundToLoad, new Vector3(lastBackground.transform.position.x, lastBackground.transform.position.y - (lastBackground.bounds.extents.y * 2), 0), Quaternion.AngleAxis(_allBackgrounds[newBackgroundIndex][1], Vector3.forward));
}
else
{
newBackground = (GameObject)Instantiate(backgroundToLoad, new Vector3(lastBackground.transform.position.x, lastBackground.transform.position.y - (lastBackground.bounds.extents.y * 2), 0), Quaternion.AngleAxis(backgroundRotation, Vector3.forward));
_allBackgrounds.Add(newBackgroundIndex, new int[2] { backgroundType, backgroundRotation });
}
_allBackgroundSprites.Add(newBackground.GetComponent<SpriteRenderer>());
_activeBackgrounds.Add(newBackgroundIndex);
}
break;
case CardinalDirections.LEFT:
newBackgroundIndex = new Vector2(lastBackgroundIndex.x - 1, lastBackgroundIndex.y);
if (!_activeBackgrounds.Contains(new Vector2(lastBackgroundIndex.x - 1, lastBackgroundIndex.y)))
{
if (_allBackgrounds.ContainsKey(newBackgroundIndex))
{
if (_allBackgrounds[newBackgroundIndex][0] < 2)
backgroundToLoad = Background1;
else
backgroundToLoad = Background2;
newBackground = (GameObject)Instantiate(backgroundToLoad, new Vector3(lastBackground.transform.position.x - (lastBackground.bounds.extents.x * 2), lastBackground.transform.position.y, 0), Quaternion.AngleAxis(_allBackgrounds[newBackgroundIndex][1], Vector3.forward));
}
else
{
newBackground = (GameObject)Instantiate(backgroundToLoad, new Vector3(lastBackground.transform.position.x - (lastBackground.bounds.extents.x * 2), lastBackground.transform.position.y, 0), Quaternion.AngleAxis(backgroundRotation, Vector3.forward));
_allBackgrounds.Add(newBackgroundIndex, new int[2] { backgroundType, backgroundRotation });
}
_allBackgroundSprites.Add(newBackground.GetComponent<SpriteRenderer>());
_activeBackgrounds.Add(newBackgroundIndex);
}
break;
case CardinalDirections.RIGHT:
newBackgroundIndex = new Vector2(lastBackgroundIndex.x + 1, lastBackgroundIndex.y);
if (!_activeBackgrounds.Contains(new Vector2(lastBackgroundIndex.x + 1, lastBackgroundIndex.y)))
{
if (_allBackgrounds.ContainsKey(newBackgroundIndex))
{
if (_allBackgrounds[newBackgroundIndex][0] < 2)
backgroundToLoad = Background1;
else
backgroundToLoad = Background2;
newBackground = (GameObject)Instantiate(backgroundToLoad, new Vector3(lastBackground.transform.position.x + (lastBackground.bounds.extents.x * 2), lastBackground.transform.position.y, 0), Quaternion.AngleAxis(_allBackgrounds[newBackgroundIndex][1], Vector3.forward));
}
else
{
newBackground = (GameObject)Instantiate(backgroundToLoad, new Vector3(lastBackground.transform.position.x + (lastBackground.bounds.extents.x * 2), lastBackground.transform.position.y, 0), Quaternion.AngleAxis(backgroundRotation, Vector3.forward));
_allBackgrounds.Add(newBackgroundIndex, new int[2] { backgroundType, backgroundRotation });
}
_allBackgroundSprites.Add(newBackground.GetComponent<SpriteRenderer>());
_activeBackgrounds.Add(newBackgroundIndex);
}
break;
default:
break;
}
}
public void Interpret()
{
string currentToken = GetToken(currentX, currentY); //retrieves the current token
if (currentToken == null) //does nothing if the token is null
return;
if ("0123456789".IndexOf(currentToken) != -1) { //pushes the integer representation of the token to the stack
interpreter.Push(Int32.Parse(currentToken));
return;
}
else if ("abcdef".IndexOf(currentToken) != -1) { //pushes the integer representation of the token to the stack
interpreter.Push(10 + (int)(currentToken[0]) - 97);
return;
}
switch (currentToken) { //performs the correct operation based on the current token
case "+": //performs the addition operation of the interpreter
interpreter.Add();
break;
case "-": //performs the subtraction operation of the interpreter
interpreter.Subtract();
break;
case "*": //performs the multiplication operation of the interpreter
interpreter.Multiply();
break;
case "/": //performs the division operation of the interpreter
interpreter.Divide();
break;
case "%": //performs the modulus operation of the interpreter
interpreter.Modulo();
break;
case "!": //performs the logical not operation of the interpreter
interpreter.NOT();
break;
case "`": //performs the greater than operation of the interpreter
interpreter.GreaterThan();
break;
case ">": //sets the current direction of the pointer to right
currentDir = CardinalDirections.RIGHT;
break;
case "<": //sets the current direction of the pointer to left
currentDir = CardinalDirections.LEFT;
break;
case "v": //sets the current direction of the pointer to down
currentDir = CardinalDirections.DOWN;
break;
case "^": //sets the current direction of the pointer to up
currentDir = CardinalDirections.UP;
break;
case "?": //sets the current direction of the pointer to a random direction
int rand = (int)(rng.NextDouble() * 4);
currentDir = (new CardinalDirections[] {CardinalDirections.RIGHT, CardinalDirections.DOWN,
CardinalDirections.LEFT, CardinalDirections.UP})[rand];
break;
case "[": //sets the current direction of the pointer to one clockwise rotation of the current direction
currentDir = NewDirection(-1);
break;
case "]": //sets the current direction of the pointer to one counter-clockwise rotation of the current direction
currentDir = NewDirection(1);
break;
case "x": //moves the pointer to the location at <x, y> where x and y are popped from the stack
int newY = interpreter.Pop();
int newX = interpreter.Pop();
SetCurrentX(newX);
SetCurrentY(newY);
currentDir = NewDirection(2);
Advance();
currentDir = NewDirection(2);
break;
case "_": //sets the current direction of the pointer to right if the top element of the stack is 0, left otherwise
if (interpreter.Pop() == 0) {
currentDir = CardinalDirections.RIGHT;
}
else {
currentDir = CardinalDirections.LEFT;
}
break;
case "|": //sets the current direction of the pointer to down if the top element of the stack is 0, up otherwise
if (interpreter.Pop() == 0) {
currentDir = CardinalDirections.DOWN;
}
else {
currentDir = CardinalDirections.UP;
}
break;
case "w": //performs a clockwise rotation of the pointer if the second element of the stack is larger than the first,
//counter-clockwise if otherwise
int b = interpreter.Pop();
int a = interpreter.Pop();
if (a < b) {
currentDir = NewDirection(-1);
}
else if (a > b) {
currentDir = NewDirection(1);
}
break;
case @"""": //pushes the string in the playfield onto the stack
InterpretString();
break;
case ":": //duplicates the value on the top of the stack
interpreter.Duplicate();
break;
case @"\": //swaps the values on the top of the stack
interpreter.Swap();
break;
case "$": //disposes of the top value of the stack
interpreter.Pop();
break;
case "n": //clears the stack
while (!interpreter.GetStack().IsEmpty()) {
interpreter.Pop();
}
break;
case ".": //outputs the top element of the stack as an integer
PushOutput(interpreter.Pop() + " ");
break;
case ",": //outputs the top element of the stack as an ASCII character
PushOutput(((char)interpreter.Pop()).ToString());
break;
case "#": //skips the next character
Jump(1);
break;
case "p": //puts a value in the playfield
Put(interpreter.Pop(), interpreter.Pop(), interpreter.Pop());
updateNeeded = true;
break;
case "g": //retrieves a value from the playfield
interpreter.Push(Get(interpreter.Pop(), interpreter.Pop()));
break;
case "&": //pushes user input the the stack as an integer
interpreter.Push(Int32.Parse(Prompt(false)));
break;
case "~": //pushes user input the the stack as an ASCII character
interpreter.Push((int)(Prompt(true)[0]));
break;
case ";": //jumps over all tokens until the next semicolon
JumpOver();
break;
case "j": //jumps i tokens, where i is the top element of the stack
Jump(interpreter.Pop());
break;
case "k": // interprets the next token n times, where n is the top element of the stack
int n = interpreter.Pop();
Advance();
for (int i = 0; i < n; i++) {
Interpret();
}
break;
case "@": //stops the program
running = false;
break;
default: //does nothing
break;
}
}
public void FakeUpdate()
{
if ( Input.GetKeyDown(KeyCode.UpArrow) ) {
current = CardinalDirections.North;
}
if ( Input.GetKeyDown(KeyCode.DownArrow) ) {
current = CardinalDirections.South;
}
if ( Input.GetKeyDown(KeyCode.RightArrow) ) {
current = CardinalDirections.East;
}
if ( Input.GetKeyDown(KeyCode.LeftArrow) ) {
current = CardinalDirections.West;
}
}
private void Jump(int num)
{
if (num < 0) {
currentDir = NewDirection(2);
}
for (int i = 0; i < num; i++) {
Advance();
}
if (num < 0) {
currentDir = NewDirection(2);
}
}
