public void SolvePart1() { Coord coord = new Coord(0, 0); string[] directions = InputParser.ReadToStringArr(Day); char orientation = 'E'; foreach (string direction in directions) { (char dir, int val) = DirUtils.ParseDir(direction); if (DirUtils.CardinalKeys.Contains(dir)) { CardinalDir step = DirUtils.dirLkup[dir]; coord.X += (val * step.dx); coord.Y += (val * step.dy); } else if (DirUtils.Turns.Contains(dir)) { for (int i = 0; i < (val / 90); i++) { orientation = DirUtils.turnLkp[dir][orientation]; } } else if (dir == 'F') { CardinalDir step = DirUtils.dirLkup[orientation]; coord.X += (val * step.dx); coord.Y += (val * step.dy); } } int solution = Math.Abs(coord.X) + Math.Abs(coord.Y); Console.WriteLine($"Manhattan Distance: {solution}"); }
public static Vector3 ToVector3(this CardinalDir dir) { switch (dir) { case CardinalDir.NORTH: return(new Vector3(0, 0, 1)); case CardinalDir.SOUTH: return(new Vector3(0, 0, -1)); case CardinalDir.EAST: return(new Vector3(1, 0, 0)); case CardinalDir.WEST: return(new Vector3(-1, 0, 0)); case CardinalDir.UP: return(new Vector3(0, 1, 0)); case CardinalDir.DOWN: return(new Vector3(0, -1, 0)); default: return(new Vector3(0, 0, 0)); } }
/// <summary>Returns the CardinalAxis of the given direction.</summary> public static CardinalAxis Axis(this CardinalDir direction) { if (direction == CardinalDir.Up || direction == CardinalDir.Down) { return(CardinalAxis.Vertical); } return(CardinalAxis.Horizontal); }
/// <summary>Change a Coord2Range that is relative to some direction into a global Coord2Range relative to 'up'.</summary> public Coord2Range RelativeToGlobal(CardinalDir forDirection) { Coord2Range rotated = this; for (int i = 0; i < (int)forDirection; i++) { rotated = rotated.rotatedClockwise; } return(rotated); }
/// <summary>Change a Coord2 that is relative to some direction into a global Coord2 relative to 'up'.</summary> public Coord2 RelativeToGlobal(CardinalDir facing) { Coord2 rotated = this; for (int i = 0; i < (int)facing; i++) { rotated = rotated.rotatedClockwise; } return(rotated); }
/// <param name="rightTurns">1 = turn right, 2 = turn around, -1 = turn left. Works with any integer.</param> /// <remarks>Does not support input directions of UP or DOWN.</remarks> public static CardinalDir Turn(this CardinalDir dir, int rightTurns) { int directionIndex = (int)dir; if (directionIndex > 3) { return(dir); //input is UP or DOWN, not supported. } return((CardinalDir)Mathf.Repeat(directionIndex + rightTurns, 4)); }
/// <summary><para>Change a Coord3 that is relative to 'up' into a local Coord3 relative to the given cardinal X-Y direction.</para> /// Note that this operation ignores the Z axis.</summary> public Coord3 GlobalToRelative(CardinalDir facing) { Coord3 rotated = this; for (int i = 4; i > (int)facing; i--) { rotated = rotated.rotatedClockwise; } return(rotated); }
public Rectangle PuyoSrcRect(Puyo puyo, CardinalDir connections) { int x = (int)connections; int y = (int)puyo - 1; if (puyo == Puyo.NUISANCE) { throw new NotImplementedException(); } return(new Rectangle(x * TILE_SIZE, y * TILE_SIZE, TILE_SIZE, TILE_SIZE)); }
public void SolveTest() { Coord shipLoc = new Coord(0, 0); Coord waypoint = new Coord(1, 10); string[] directions = InputParser.ReadToStringArr(Day, "Test"); char orientation = 'E'; foreach (string direction in directions) { (char dir, int val) = DirUtils.ParseDir(direction); if (DirUtils.CardinalKeys.Contains(dir)) { CardinalDir step = DirUtils.dirLkup[dir]; waypoint.X += (val * step.dx); waypoint.Y += (val * step.dy); } else if (DirUtils.Turns.Contains(dir)) { for (int i = 0; i < (val / 90); i++) { if (dir == 'R') { int x = waypoint.X; int y = waypoint.Y; waypoint.X = y; waypoint.Y = -x; } if (dir == 'L') { int x = waypoint.X; int y = waypoint.Y; waypoint.X = -y; waypoint.Y = x; } } } else if (dir == 'F') { CardinalDir step = DirUtils.dirLkup[orientation]; for (int i = 0; i < val; i++) { shipLoc.X += waypoint.X; shipLoc.Y += waypoint.Y; } } } int solution = Math.Abs(shipLoc.X) + Math.Abs(shipLoc.Y); Console.WriteLine($"Manhattan Distance: {solution}"); }
/// <summary>Returns a Coord2 pointing in the given direction.</summary> public static Coord2 RelativeCoord2(this CardinalDir direction) { switch (direction) { case CardinalDir.Up: { return(new Coord2(0, 1)); } case CardinalDir.Right: { return(new Coord2(1, 0)); } case CardinalDir.Down: { return(new Coord2(0, -1)); } case CardinalDir.Left: { return(new Coord2(-1, 0)); } } return(Coord2.zero); }
/// <summary>Returns a rotation pointing in the given direction.</summary> public static Quaternion Rotation(this CardinalDir direction) { switch (direction) { case CardinalDir.Up: { return(Quaternion.Euler(0.0f, 0.0f, 0.0f)); } case CardinalDir.Right: { return(Quaternion.Euler(0.0f, 90.0f, 0.0f)); } case CardinalDir.Down: { return(Quaternion.Euler(0.0f, 180.0f, 0.0f)); } case CardinalDir.Left: { return(Quaternion.Euler(0.0f, -90.0f, 0.0f)); } } return(Quaternion.identity); }
// Check if the space is traversible public bool IsTraversible(GridWorldSpace space, CardinalDir dir) { int[] coord = { space.Row, space.Column }; switch (dir) { case CardinalDir.UP: if (coord[0] - 1 < 0) { return(false); } else { return(spaces[coord[0], coord[1]].isTraversible()); } case CardinalDir.DOWN: if (coord[0] + 1 > rows - 1) { return(false); } else { return(spaces[coord[0], coord[1]].isTraversible()); } case CardinalDir.LEFT: if (coord[1] - 1 < 0) { return(false); } else { return(spaces[coord[0], coord[1]].isTraversible()); } case CardinalDir.RIGHT: if (coord[1] + 1 > columns - 1) { return(false); } else { return(spaces[coord[0], coord[1]].isTraversible()); } default: return(false); } }
public abstract void UpdateVisuals(); //Recommend to call CleanTile in implementation of this. /// <summary> /// Returns false if that side of the tile is obstructed or OOB /// </summary> public bool IsFaceVisible(CardinalDir face) { IntVec checkPos = pos + (IntVec)face; if (map.IsPosOOB(checkPos)) { return(false); //Out of bounds - treated as opaque, since these walls need not be rendered. } Tile checkTile = map.TileAtPos(checkPos); if (checkTile == null) { return(true); //Face is touching air } else if (!checkTile.hidesAdjacentFaces && //Or face is touching non-occluding tile !(face == CardinalDir.UP && checkTile is GroundTile)) { return(true); //And face is not underneath a ground tile } return(false); //Otherwise, face is hidden by adjacent tile. }
private static CardinalDir Rotate(this CardinalDir cardinal, int diff) { CardinalDir rotated = 0; for (int i = 0; i < cardinalDirs.Length; i++) { if (cardinal.HasFlag(cardinalDirs[i])) { int newDir = i + diff; if (newDir >= cardinalDirs.Length) { newDir = 0; } if (newDir < 0) { newDir = cardinalDirs.Length - 1; } rotated |= cardinalDirs[newDir]; } } return(rotated); }
public static (int x, int y) Offset(this CardinalDir cardinal) { int x = 0; int y = 0; if (cardinal.HasFlag(CardinalDir.NORTH)) { y += 1; } if (cardinal.HasFlag(CardinalDir.EAST)) { x += 1; } if (cardinal.HasFlag(CardinalDir.SOUTH)) { y -= 1; } if (cardinal.HasFlag(CardinalDir.WEST)) { x -= 1; } return(x, y); }
private GridWorldSpace GetAdjacentSpace(GridWorldSpace space, CardinalDir dir) { int[] coord = { space.Row, space.Column }; switch (dir) { case CardinalDir.UP: coord[0] = coord[0] - 1; break; case CardinalDir.DOWN: coord[0] = coord[0] + 1; break; case CardinalDir.LEFT: coord[1] = coord[1] - 1; break; case CardinalDir.RIGHT: coord[1] = coord[1] + 1; break; } return(world.GetSpaceByCoord(coord)); }
/// <summary>Returns the next direction anticlockwise from the given direction.</summary> public static CardinalDir NextAnticlockwise(this CardinalDir direction) { return((CardinalDir)(((int)direction + 1) % 4)); }
public static CardinalDir RotateRight(this CardinalDir cardinal) { return(cardinal.Rotate(1)); }
public static CardinalDir RotateLeft(this CardinalDir cardinal) { return(cardinal.Rotate(-1)); }
/// <summary>Returns the opposite of the given direction.</summary> public static CardinalDir Reverse(this CardinalDir direction) { return((CardinalDir)(((int)direction + 2) % 4)); }
public ActionTurn(IEntityDirectional actionPerformer, CardinalDir newForward) : base(actionPerformer) { newDirection = newForward; }
/// <summary>Returns this direction relative to the given forward direction.</summary> public static CardinalDir RelativeTo(this CardinalDir dir, CardinalDir forward) { return((CardinalDir)(((int)dir - (int)forward).Ring(4, 0))); }
/// <summary>Returns true if the other direction is immediately clockwise or counterclockwise of this one.</summary> public static bool IsAdjacent(this CardinalDir direction, CardinalDir other) { return(direction.Axis() != other.Axis()); }
/// <summary>Returns true if the other direction is opposite to this one this one.</summary> public static bool IsOpposite(this CardinalDir direction, CardinalDir other) { return(direction != other && direction.Axis() == other.Axis()); }