public void ShouldGetDirectionsInClockwiseOrder() { var actual = DirectionExtensions.GetDirections(start: Direction.North, clockWise: true).ToArray(); var expected = new[] { Direction.North, Direction.East, Direction.South, Direction.West, }; actual.Should().BeEquivalentTo(expected); }
private void MoveMissile(Missile missile, Actor shooter, Point point, bool keepMoving) { var direction = DirectionExtensions.GetDirection(missile.Location, point); missile.Orientation = direction switch { Direction.Left => Orientation.Horizontal, Direction.Right => Orientation.Horizontal, _ => Orientation.Vertical }; missile.Location = point; var actor = actors.SingleOrDefault(a => a.Location == point && a != shooter); if (actor != null) { missile.Moving = false; var action = actor.GetAction(mapConsole.map, Direction.None); var result = action.Perform(player); logConsole.Log(result.Message); } missile.Moving = missile.Moving && keepMoving; if (!missile.Moving) { ActivateActors(); } }
private void FindBlockingTiles() { Bounds = boundsCalc.GetComponent <MeshRenderer>().bounds; foreach (var tile in MapTile.All) { if (tile.MapPosX < Bounds.min.x || tile.MapPosX > Bounds.max.x) { continue; } if (tile.MapPosZ < Bounds.min.z || tile.MapPosZ > Bounds.max.z) { continue; } tile.TileProp = this; var adjTiles = tile.GetAdjacentTiles(false); foreach (var adjTile in adjTiles) { adjTile.Value.SetBlocks(DirectionExtensions.Reverse(adjTile.Key), coverType, moveBlocker); } } boundsCalc.GetComponent <MeshRenderer>().enabled = false; }
//Blasting public void BlockBreaker(Vector3i Pos, Vector3 Dir) // consider making this a bool to facilitate feedback? { //get collar position and facing direction Vector3i rung = Pos; Vector3i facing = StyleSet(this.style, Dir); //determine blast radius and depth if (this.Explosive.Fuel < 5) { //ChatManager.ServerMessageToAll("Column Mode", false); //step to next block until reach bottom - may want to invert this so that it blasts from the bottom up for (int a = 0; a < this.blastingDepth; a = a + 1) { rung = rung + facing; //break if mineable and replace with rubble Block block = World.GetBlock(rung); if (block.Is <Minable>()) { World.DeleteBlock(rung); RubbleObject.TrySpawnFromBlock(block.GetType(), rung); } } } else if (this.Explosive.Fuel > 5) { //ChatManager.ServerMessageToAll("cylinder Mode", false); DirectionAxis dir = LookupDirectionAxis(facing); for (int a = 0; a < this.blastingDepth; a = a + 1) { rung = rung + facing; Vector3i[] ring = DirectionExtensions.Get8Edges(dir); //break if mineable and replace with rubble Block block = World.GetBlock(rung); if (block.Is <Minable>()) { World.DeleteBlock(rung); RubbleObject.TrySpawnFromBlock(block.GetType(), rung); } foreach (Vector3i neighbour in ring) { // ChatManager.ServerMessageToAll("neighbour mode", false); Vector3i tar = rung + neighbour; block = World.GetBlock(tar); if (block.Is <Minable>()) { World.DeleteBlock(tar); RubbleObject.TrySpawnFromBlock(block.GetType(), tar); } } } } else { return; } }
public static void ApplyTurn(GameState state, string cmds) { //Backup var backup = new Backup(state); string pat = @"o\s(\d+)\s(\d+)\s(\w)"; Regex r = new Regex(pat, RegexOptions.IgnoreCase); Match m = r.Match(cmds); while (m.Success) { int row = int.Parse(m.Groups[1].Captures[0].Value); int col = int.Parse(m.Groups[2].Captures[0].Value); var ant = new Ant(row, col, 0); var dir = DirectionExtensions.FromChar(m.Groups[3].Captures[0].Value[0]); MoveAnt(backup, state, ant, dir); m = m.NextMatch(); } backup.Restore(state); }
private static Direction SelectDetour(Ship ship, Direction direction, Position target) { var right_direction = DirectionExtensions.TurnRight(direction); var right_position = game.gameMap.GetTargetPosition(ship.position, right_direction); var right_blocked = HasBlockingShip(ship.owner.id, right_position); var left_direction = DirectionExtensions.TurnLeft(direction); var left_position = game.gameMap.GetTargetPosition(ship.position, left_direction); var left_blocked = HasBlockingShip(ship.owner.id, left_position); if (right_blocked && left_blocked) { return(Direction.STILL); // no detour avaialable } // define detour direction to cell closest to target or highest halite value. var detour_direction = Direction.STILL; if (right_blocked == false && left_blocked == true) { detour_direction = right_direction; } if (right_blocked == true && left_blocked == false) { detour_direction = left_direction; } if (right_blocked == false && left_blocked == false) { var right_distance = game.gameMap.CalculateDistance(right_position, target); var left_distance = game.gameMap.CalculateDistance(left_position, target); if (right_distance < left_distance) { detour_direction = right_direction; } if (left_distance < right_distance) { detour_direction = left_direction; } if (right_distance == left_distance) { if (game.gameMap.At(right_position).halite >= game.gameMap.At(left_position).halite) { detour_direction = right_direction; } else { detour_direction = left_direction; } } } // give a continuation move to avoid coming back to current square if (detour_next_move.ContainsKey(ship.id.id)) { detour_next_move.Remove(ship.id.id); } detour_next_move.Add(ship.id.id, direction); return(detour_direction); }
public void SetRandomLocation() { var randomLocation = Maze.GetRandomLocation(); Location.Row = randomLocation.Row; Location.Column = randomLocation.Column; _currentDirection = DirectionExtensions.GetRandomDirection(); }
public override Direction Flow(Direction comingFrom, int value) { Value = value; List <Direction> remainingSpot = _holeDict.Keys.ToList(); remainingSpot.Remove(DirectionExtensions.GetOppositeDirection(comingFrom)); return(remainingSpot[0]); }
public void CheckSurrounding() { Direction missedHole = Direction.None; foreach (Direction hole in _holeLocations) { Point targetPoint = DirectionExtensions.GetDirectionPoint(hole); GameObject side = GridLevelManager.Instance.GetCircleData(targetPoint.X + GetPoint().X, targetPoint.Y + GetPoint().Y); if (side != null) { CircleData sideData = side.GetComponent <CircleData>(); if (sideData != null) { if (sideData.MatchConnectingHole(hole)) { if (sideData.LightOn()) { sideData.SetNextCircleData(this); TurnLightOn(); if (missedHole != Direction.None) { targetPoint = DirectionExtensions.GetDirectionPoint(missedHole); side = GridLevelManager.Instance.GetCircleData(targetPoint.X + GetPoint().X, targetPoint.Y + GetPoint().Y); sideData = side.GetComponent <CircleData>(); sideData.CheckSurrounding(); } } else if (LightOn()) { sideData.CheckSurrounding(); } else { missedHole = hole; } } } } } if (GridLevelManager.Instance.CheckWinTile(GetPoint())) { if (_lightUp) { foreach (Direction hole in _holeLocations) { if (GridLevelManager.Instance.DirectionFacingGoal(hole, GetPoint().X, GetPoint().Y)) { GridLevelManager.Instance.ExecuteWin(); } } } } }
public static bool IfLookDirection(this Block block, Direction dir) { Direction[] Directionslist = block.Directionslist(); Direction oppdir = DirectionExtensions.GetOppositeDir(dir); if (oppdir == Directionslist[0] || oppdir == Directionslist[1] || oppdir == Directionslist[2] || oppdir == Directionslist[3]) { return(true); } return(false); }
void Move() { if (Random.Range(0f, 1f) >= chanceToMove) { return; } if (Random.Range(0f, 1f) >= chanceToMoveTowards) { Direction direction = DirectionExtensions.GetRandomDirection(); transform.Translate(Constants.GridSize * direction.GetVector().x, Constants.GridSize * direction.GetVector().y, 0); } }
public bool DirectionFacingGoal(Direction d, int x, int y) { Point dirFace = DirectionExtensions.GetDirectionPoint(d); int xFace = dirFace.X + x; int yFace = dirFace.Y + y; if (xFace == _endNode.X && yFace == _endNode.Y) { return(true); } return(false); }
public bool MatchConnectingHole(Direction directionFrom) { Direction opposite = DirectionExtensions.GetOppositeDirection(directionFrom); foreach (Direction hole in _holeLocations) { if (hole == opposite) { return(true); } } return(false); }
/// <summary> /// Moves Drone towards Queen /// </summary> /// <returns>Returns Position</returns> public Position MoveTowardsQueen() { var nextPosition = Coordinates.NextCoordinatesInDirection(DirectionExtensions.GetRandomDirection()); var queenPosition = AntColony.GetTheQueen().GetPosition(); while (nextPosition.DistanceToCoordinate(queenPosition) > Coordinates.DistanceToCoordinate(queenPosition)) { nextPosition = Coordinates.NextCoordinatesInDirection(DirectionExtensions.GetRandomDirection()); } Coordinates = nextPosition; return(Coordinates); }
public bool CheckWinTile(Point point) { Point dir = DirectionExtensions.GetDirectionPoint(DirectionExtensions.GetOppositeDirection(_endNode.Direction)); int x = dir.X + _endNode.X; int y = dir.Y + _endNode.Y; if (point.X == x && point.Y == y) { return(true); } return(false); }
public void BlockMovement(Vector3Int origin) { //print("Blocking " + origin); var movement = movementLookup[origin]; if (movement.Blocked) { return; } // Keep a stack of blocks that need to be checked Stack <Vector3Int> originsToBeProcessed = new Stack <Vector3Int>(64); originsToBeProcessed.Push(origin); movement.Blocked = true; // Process all blocks in chain while (originsToBeProcessed.Count > 0) { // Pop movement off the stack origin = originsToBeProcessed.Pop(); movement = movementLookup[origin]; // Check for blocking in each direction foreach (var dir in DirectionExtensions.Directions()) { // Ignore blocking in the direction we're going if (movement.Direction == dir) { continue; } //print("Checking " + (origin + dir.Vector3Int())); var behindOrigin = origin + dir.Vector3Int(); if (movementDependency.ContainsKey(behindOrigin)) { var behindMovement = movementLookup[behindOrigin]; //print("Found dependency: " + behindMovement.Direction + " " + behindMovement.Blocked + " " + dir.Opposite()); // If it's moving to us, then it needs to be blocked if (behindMovement.Direction == dir.Opposite() && !behindMovement.Blocked) { //print("Blocking " + behindOrigin); behindMovement.Blocked = true; originsToBeProcessed.Push(behindOrigin); } } } } }
public List <(AbstractField, int, Direction)> GetNeighbours(AbstractField field, AbstractField[][] board, int height, int width) { int[] center = field.GetPosition(); List <(AbstractField, int, Direction)> neighbours = new List <(AbstractField, int, Direction)>(); var neighbourCoordinates = DirectionExtensions.GetCoordinatesAroundCenter(center); for (int i = 0; i < neighbourCoordinates.Length; i++) { var(dir, y, x) = neighbourCoordinates[i]; if (y >= 0 && y < height && x >= 0 && x < width) { neighbours.Add((board[y][x], int.MaxValue, dir)); } } return(neighbours); }
public void Explore() { _moveTimeLeft = _moveCoolDown; Direction direction = _currentDirection; Direction direction2; if (CanMove(direction)) { direction2 = DirectionExtensions.GetRandomDirection(); if (CanMove(direction2) && !direction2.IsOpppositeDirection(direction)) { direction = direction2; } } else { bool turnRight = Random.Range(0, 2) == 1; direction2 = (Direction)(((int)direction + (turnRight ? 1 : 3)) % 4); if (CanMove(direction2)) { direction = direction2; } else { direction2 = (Direction)(((int)direction2 + 2) % 4); if (CanMove(direction2)) { direction = direction2; } else { direction = (Direction)(((int)direction + 2) % 4); } } } if (CanMove(direction)) { _currentDirection = direction; Move(); } }
public List <MapTile> CornerPeakFrom() { var peakList = new List <MapTile>(); foreach (var cardinal in DirectionExtensions.GetCardinals()) { foreach (var rightAngleDirection in DirectionExtensions.GetRightAngleDirections(cardinal)) { if (MoveBlocked[cardinal] && !GetAdjacentTile(rightAngleDirection).MoveBlocked[cardinal]) { peakList.Add(GetAdjacentTile(DirectionExtensions .GetDiagonalFromCardinals(cardinal, rightAngleDirection))); } } } return(peakList); }
public override void RotateClockwise() { transform.Rotate(Vector3.forward, -90); for (int i = 0; i < _holeLocations.Length; i++) { _holeLocations[i] = DirectionExtensions.RotateClockwise(_holeLocations[i]); } Dictionary <Direction, AbstractTube> temp = new Dictionary <Direction, AbstractTube>(); foreach (Direction dir in _holeDict.Keys) { temp.Add(DirectionExtensions.RotateClockwise(dir), _holeDict[dir]); //Debug.Log(string.Format("Dir: {0} => {1}", dir, DirectionExtensions.RotateClockwise(dir))); } _holeDict = temp; }
private void MoveTo(Actor actor, Point target) { Point nextStep; bool isNextToTarget = actor.Location.IsAdjacent(target); if (!isNextToTarget) { nextStep = mapConsole.GetNextStep(actor, actors, target); } else { nextStep = target; } var direction = DirectionExtensions.GetDirection(actor.Location, nextStep); MoveOrAct(actor, direction); }
//rewrite too lazy to check all given path now public override bool Valid() { foreach (Direction hole in _holeDict.Keys) { Point targetPoint = GetPoint().AddPoint(DirectionExtensions.GetDirectionPoint(hole)); GameObject obj = LevelManager_v2.Instance.GetTubePositioning(targetPoint); if (obj != null) { if (obj.tag.ToLower().Contains("operator")) { return(false); } } } return(true); }
public Command GetMove() { var dirs = valuer.Target.position.GetAllDirectionsTo(ship.position); dirs = dirs.OrderBy(d => GameInfo.CellAt(ship.position.DirectionalOffset(d)).halite).ToList(); if (dirs.Count == 1 && GameInfo.Distance(ship, valuer.Target.position) > 1) { var extraDirs = DirectionExtensions.GetLeftRightDirections(dirs[0]); dirs.AddRange(extraDirs); } foreach (var d in dirs) { var cell = GameInfo.CellAt(ship, d); if (Safety.IsSafeAndAvoids2Cells(ship, d) && Navigation.IsAccessible(cell.position, valuer.Target.position)) { return(ship.Move(d, $"moving towards best projection {valuer.Target.position.ToString()}... Expected turns: {numTurns}")); } } return(null); }
public void TestGetCoordinatesAroundCenterMiddleField() { // Arrange (int y, int x)center = (5, 4); // Act var result = DirectionExtensions.GetCoordinatesAroundCenter(center); // Assert Assert.Equal(9, result.Length); Assert.Contains((Direction.SW, center.y - 1, center.x - 1), result); Assert.Contains((Direction.S, center.y - 1, center.x), result); Assert.Contains((Direction.SE, center.y - 1, center.x + 1), result); Assert.Contains((Direction.W, center.y, center.x - 1), result); Assert.Contains((Direction.FromCurrent, center.y, center.x), result); Assert.Contains((Direction.E, center.y, center.x + 1), result); Assert.Contains((Direction.NW, center.y + 1, center.x - 1), result); Assert.Contains((Direction.N, center.y + 1, center.x), result); Assert.Contains((Direction.NE, center.y + 1, center.x + 1), result); }
public static MazeGrid CreateMaze(Options options) { int width = options.Width; int height = options.Height; bool[,] verticalWalls = CreateVerticalWalls(width, height); bool[,] horizontalWalls = CreateHorizontalWalls(width, height); int[] sets = CreateSets(width, height); Direction direction = 0; int cellIndex = 0; while (!AreAllSameSet(sets)) { while (true) { cellIndex = UnityEngine.Random.Range(0, sets.Length); direction = DirectionExtensions.GetRandomDirection(); if (!IsValidDirection(direction, cellIndex, width, height)) { continue; } GetSets(direction, sets, cellIndex, width, out int classe1, out int classe2); if (classe1 == classe2) { continue; } RemoveWall(direction, verticalWalls, horizontalWalls, cellIndex, width); UnionSets(sets, classe1, classe2); break; } } return(new MazeGrid(options, verticalWalls, horizontalWalls)); }
private void Update() { /* * Basic movement */ //Do not move if game is finished or you are stunned if (!this.GetGameManager().GetComponent <Level>().GameRunning || Stunned) { return; } //Get movement axis Vector2 axis = new Vector2( x: Input.GetAxis(HorizontalAxis), y: Input.GetAxis(VerticalAxis) ); //Store direction of the player if (axis != Vector2.zero) { Direction = DirectionExtensions.Construct(axis.x, axis.y); } //Apply movement to player if (GetComponentInChildren <Grabber>().IsGrabbing) { Move(axis, MoveSpeed * GetComponentInChildren <Grabber>().GrabbedItems.Average(i => i.GetComponent <Junk>().SpeedMultipler)); } else { Move(axis, MoveSpeed); } //Rotate the player transform.SetEuler2D(CommonExtensions.RealAngleBetween(transform.Position2D(), transform.Position2D() + Direction.ToVector2())); }
public Turn OnTurn() { var steps = new List <Step>(); if (CurrentHp > 0) { //Direction? direction = DirectionExtensions.RelativeDirection(controller.Row, controller.Col, player.Row, player.Col); Direction?direction = DirectionExtensions.RelativeDirection(transform.position, player.transform.position); if (direction == null) { if (controller.Elevation > player.Elevation && player.IsClimbing && player.Climbing == controller.Climbing) { direction = controller.Climbing.Value.Opposite(); } else { direction = player.Climbing; } } if (direction != null) { Step moveStep = controller.Move(direction.Value); if (moveStep != null) { steps.Add(moveStep); } } if (!controller.IsClimbing) { steps.Add(AttackMyTile()); } } return(new Turn(steps, GameManager.standardTurnTime)); }
public void ExecuteCommand(string command) { if (command == null) { ThrowArgumentNullExceptionOnNullArgument(nameof(command), nameof(ExecuteCommand)); } //Ignore not relevant spaces and case command = command.Trim().ToUpperInvariant(); if (command.StartsWith(SimulatorCommands.Place)) { var parts = command.Split(' '); if (parts.Length == 2 && parts[0] == SimulatorCommands.Place) { var parameters = parts[1].Split(','); if (parameters.Length != 3) { ThrowArgumentExceptionOnInvalidCommand(command, nameof(ExecuteCommand), null); } else { try { int x = int.Parse(parameters[0].Trim()); int y = int.Parse(parameters[1].Trim()); var position = new Point.Point(x, y); var direction = DirectionExtensions.ConvertStringToDirection(parameters[2].Trim()); Robot.Place(Table, position, direction); } catch (InvalidOperationException ioe) { // Handle exceptions from Robot.Place LogNotAllowedCommand(command, ioe); } catch (Exception e) when(e is FormatException || e is OverflowException || e is ArgumentOutOfRangeException) { // Handle exceptions from parameters parsing ThrowArgumentExceptionOnInvalidCommand(command, nameof(ExecuteCommand), e); } } } else { ThrowArgumentExceptionOnInvalidCommand(command, nameof(ExecuteCommand), null); } } else { try { switch (command) { case SimulatorCommands.Move: Robot.Move(); break; case SimulatorCommands.Left: Robot.RotateToTheLeft(); break; case SimulatorCommands.Right: Robot.RotateToTheRight(); break; case SimulatorCommands.Report: var robotStatus = Robot.GetStatus(); MainTextWriter.WriteLine($"{robotStatus.Position.x},{robotStatus.Position.y},{robotStatus.Direction.ToString().ToUpperInvariant()}"); break; default: ThrowArgumentExceptionOnInvalidCommand(command, nameof(ExecuteCommand), null); break; } } catch (InvalidOperationException ioe) { LogNotAllowedCommand(command, ioe); } } }
public void An_Empty_Direction_Cannot_Be_Converted_Into_An_Arrow() { Action action = () => DirectionExtensions.ToArrow(null); action.Should().Throw <ArgumentNullException>(); }
public void Cannot_Convert_SecondaryInterCardinalDirection_Into_Arrow() { Action action = () => DirectionExtensions.ToArrow("NNE"); action.Should().Throw <ArgumentException>(); }