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());
}
