public void rotateToFace(HyperDirection hyperDirection) { float x = 0; float y = 0; float z = 0; switch (hyperDirection.standing) { case Direction.east: z = 90.0f; break; case Direction.west: z = -90.0f; break; case Direction.north: x = 90.0f; break; case Direction.south: x = -90.0f; break; } transform.rotation = Quaternion.Euler(x, y, z); }
public void TestWalkForward() { // Given HyperGrid hyperGrid = new HyperGrid(8, 8, 8, 8); HyperPosition playerPosition = new HyperPosition(0, 1, 0, 3); HyperDirection playerDirection = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left); Player player = new Player(playerPosition, playerDirection); Game game = new Game(player, hyperGrid); for (int x = 0; x < 7; x++) { hyperGrid.setBlocked(x, 0, 0, 3); } //When game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(1, 1, 0, 3), player.position, player.position.printOut()); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(2, 1, 0, 3), player.position, player.position.printOut()); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(3, 1, 0, 3), player.position, player.position.printOut()); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(4, 1, 0, 3), player.position, player.position.printOut()); //Then Assert.AreEqual(new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left), player.direction); }
public Player move(MoveResult moveResult) { switch (moveResult) { case MoveResult.upward: this.direction = this.direction.rotate(PlayerRotation.toSky); break; case MoveResult.forward: this.position = position.move(direction.facing); break; case MoveResult.downward: this.position = position.move(direction.facing).move(direction.standing, -1); this.direction = direction.rotate(PlayerRotation.toGround); break; case MoveResult.toLeftSide: this.direction = direction.rotate(PlayerRotation.toLeftSide); break; case MoveResult.toRightSide: this.direction = direction.rotate(PlayerRotation.toRightSide); break; case MoveResult.toUnseenLeft: this.direction = direction.rotate(PlayerRotation.toUnseenLeft); break; case MoveResult.toUnseenRight: this.direction = direction.rotate(PlayerRotation.toUnseenRight); break; } return(this); }
public void TestCanCreateHyperPositionXYZW() { HyperDirection pos = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left); Assert.AreEqual(Direction.east, pos.facing); Assert.AreEqual(Direction.up, pos.standing); Assert.AreEqual(Direction.north, pos.toSide); Assert.AreEqual(Direction.left, pos.unSeen); }
public void CanCreateHyperDirection() { HyperDirection dir = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left); Assert.AreEqual(dir.facing, Direction.east); Assert.AreEqual(dir.standing, Direction.up); Assert.AreEqual(dir.toSide, Direction.north); Assert.AreEqual(dir.unSeen, Direction.left); }
public void RotateDirectionManyTime() { HyperDirection dir = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left); for (int i = 0; i < 1024; i++) { dir = dir.rotate(PlayerRotation.toRightSide); } Assert.AreEqual(dir.facing, Direction.east); }
public void RotateDirection() { HyperDirection dir = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left); HyperDirection newDir = dir.rotate(PlayerRotation.toRightSide); Assert.AreEqual(dir.facing, Direction.east); Assert.AreEqual(newDir.standing, Direction.up); Assert.AreEqual(newDir.facing, Direction.north); Assert.AreEqual(newDir.toSide, Direction.west); }
public void RotateDownFromLeft() { //Given HyperDirection dir = new HyperDirection(Direction.left, Direction.west, Direction.south, Direction.down); //When HyperDirection actual = dir.rotate(PlayerRotation.toGround); HyperDirection expected = new HyperDirection(Direction.east, Direction.left, Direction.south, Direction.down); //Then Assert.AreEqual(expected, actual); }
public void RotateSkyFromStanding() { //Given HyperDirection dir = new HyperDirection(Direction.east, Direction.up, Direction.south, Direction.left); //When HyperDirection actual = dir.rotate(PlayerRotation.toSky); HyperDirection expected = new HyperDirection(Direction.up, Direction.west, Direction.south, Direction.left); //Then Assert.AreEqual(expected, actual); }
public void RotatingPlayerDoesntChangePosition() { //Given HyperDirection dir = new HyperDirection(Direction.north, Direction.right, Direction.east, Direction.down); HyperPosition pos = new HyperPosition(3, 3, 23, 1); Player player = new Player(pos, dir); //When player.move(MoveResult.toRightSide).move(MoveResult.toUnseenLeft).move(MoveResult.toRightSide).move(MoveResult.toRightSide).move(MoveResult.toUnseenLeft).move(MoveResult.toUnseenLeft).move(MoveResult.toLeftSide); //Then Assert.AreEqual(new HyperPosition(3, 3, 23, 1), player.position); }
public void RotateLeftRight() { HyperDirection dir = new HyperDirection(Direction.left, Direction.north, Direction.up, Direction.east); HyperDirection newDir1 = dir.rotate(PlayerRotation.toRightSide); Assert.AreEqual(newDir1.facing, Direction.up); Assert.AreEqual(newDir1.toSide, Direction.right); HyperDirection newDir2 = newDir1.rotate(PlayerRotation.toRightSide); Assert.AreEqual(newDir2.facing, Direction.right); Assert.AreEqual(newDir2.toSide, Direction.down); }
public void RotateDirectionForwardBack() { HyperDirection dir = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left); HyperDirection newDir1 = dir.rotate(PlayerRotation.toRightSide); HyperDirection newDir2 = newDir1.rotate(PlayerRotation.toLeftSide); HyperDirection newDir3 = newDir2.rotate(PlayerRotation.toLeftSide); HyperDirection newDir4 = newDir3.rotate(PlayerRotation.toRightSide); Assert.AreEqual(newDir1.facing, Direction.north); Assert.AreEqual(newDir2.facing, Direction.east); Assert.AreEqual(newDir3.facing, Direction.south); Assert.AreEqual(newDir4.facing, Direction.east); }
public void MovePlayerNorth() { //Given HyperDirection dir = new HyperDirection(Direction.north, Direction.up, Direction.west, Direction.left); HyperPosition pos = new HyperPosition(6, 2, 1, 1); Player player = new Player(pos, dir); Assert.AreEqual(player.position.z, 1); //When player.move(MoveResult.forward); //Then Assert.AreEqual(player.position.z, 2); }
public void PlayerMoveForwardTwiceTurnLeftAndThenUp() { //Given HyperDirection startingDirection = new HyperDirection(Direction.north, Direction.right, Direction.east, Direction.down); HyperPosition pos = new HyperPosition(4, 0, 0, 0); Player player = new Player(pos, startingDirection); player.move(MoveResult.forward).move(MoveResult.forward).move(MoveResult.toLeftSide).move(MoveResult.upward); HyperPosition expectedPosition = new HyperPosition(4, 0, 2, 0); HyperDirection expectedRotation = new HyperDirection(Direction.right, Direction.east, Direction.north, Direction.down); Assert.AreEqual(expectedPosition, player.position); Assert.AreEqual(expectedRotation, player.direction, player.direction.discription()); }
public void PlayerMoveIntoUnseen() { //Given HyperDirection startingDirection = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.right); HyperPosition pos = new HyperPosition(0, 0, 0, 0); Player player = new Player(pos, startingDirection); player.move(MoveResult.toUnseenRight).move(MoveResult.forward).move(MoveResult.forward).move(MoveResult.forward).move(MoveResult.forward); HyperPosition expectedPosition = new HyperPosition(0, 0, 0, -4); HyperDirection expectedRotation = new HyperDirection(Direction.right, Direction.up, Direction.north, Direction.west); Assert.AreEqual(expectedPosition, player.position); Assert.AreEqual(expectedRotation, player.direction); }
public void MoveDownChangesPositionAndRotation() { //Given HyperDirection dir = new HyperDirection(Direction.east, Direction.up, Direction.south, Direction.left); HyperPosition pos = new HyperPosition(5, 2, 20, 8); Player player = new Player(pos, dir); //When player.move(MoveResult.downward); //Then HyperPosition expectedPosition = new HyperPosition(6, 1, 20, 8); HyperDirection expectedRotation = new HyperDirection(Direction.down, Direction.east, Direction.south, Direction.left); Assert.AreEqual(expectedPosition, player.position); Assert.AreEqual(expectedRotation, player.direction); }
public void MoveUpWallChangesDirectionNotPosition() { //Given HyperDirection dir = new HyperDirection(Direction.up, Direction.west, Direction.south, Direction.left); HyperPosition pos = new HyperPosition(3, 2, 1, 1); Player player = new Player(pos, dir); //When player.move(MoveResult.upward); //Then HyperPosition expectedPosition = new HyperPosition(3, 2, 1, 1); HyperDirection expectedRotation = new HyperDirection(Direction.west, Direction.down, Direction.south, Direction.left); Assert.AreEqual(expectedPosition, player.position); Assert.AreEqual(expectedRotation, player.direction); }
public void TestGameMovesPlayerDownAndForward() { // Given HyperGrid hyperGrid = new HyperGrid(5, 5, 5, 5); HyperPosition playerPosition = new HyperPosition(0, 1, 0, 0); HyperDirection playerDirection = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left); Player player = new Player(playerPosition, playerDirection); Game game = new Game(player, hyperGrid); hyperGrid.setBlocked(0, 0, 0, 0); //When game.process(MoveIntent.forward); //Then Assert.AreEqual(new HyperPosition(1, 0, 0, 0), player.position); }
public void MovePlayerForwardFourTimes() { //Given HyperDirection dir = new HyperDirection(Direction.up, Direction.west, Direction.south, Direction.left); HyperPosition pos = new HyperPosition(3, 2, 1, 1); Player player = new Player(pos, dir); Assert.AreEqual(player.position.y, 2); //When player.move(MoveResult.forward); player.move(MoveResult.forward); player.move(MoveResult.forward); player.move(MoveResult.forward); //Then Assert.AreEqual(player.position.y, 6); }
public void CreatePlayerWithPosition() { //Given HyperDirection dir = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left); HyperPosition pos = new HyperPosition(0, 5, 0, 4); Player player = new Player(pos, dir); //Then Assert.AreEqual(player.position.x, 0); Assert.AreEqual(player.position.y, 5); Assert.AreEqual(player.position.z, 0); Assert.AreEqual(player.position.w, 4); Assert.AreEqual(player.direction.facing, Direction.east); Assert.AreEqual(player.direction.standing, Direction.up); Assert.AreEqual(player.direction.toSide, Direction.north); Assert.AreEqual(player.direction.unSeen, Direction.left); }
public void RotatingPlayerFourTimesIsSameSpot() { //Given HyperDirection startingDirection = new HyperDirection(Direction.north, Direction.right, Direction.east, Direction.down); HyperPosition pos = new HyperPosition(3, 3, 23, 1); Player player = new Player(pos, startingDirection); player.move(MoveResult.toRightSide).move(MoveResult.toRightSide).move(MoveResult.toRightSide).move(MoveResult.toRightSide); Assert.AreEqual(startingDirection, player.direction); player.move(MoveResult.toLeftSide).move(MoveResult.toLeftSide).move(MoveResult.toLeftSide).move(MoveResult.toLeftSide); Assert.AreEqual(startingDirection, player.direction); player.move(MoveResult.toUnseenLeft).move(MoveResult.toUnseenLeft).move(MoveResult.toUnseenLeft).move(MoveResult.toUnseenLeft); Assert.AreEqual(startingDirection, player.direction); player.move(MoveResult.toUnseenRight).move(MoveResult.toUnseenRight).move(MoveResult.toUnseenRight).move(MoveResult.toUnseenRight); Assert.AreEqual(startingDirection, player.direction); }
public void RotateSkyFromLeftMultiple() { //Given HyperDirection dir = new HyperDirection(Direction.left, Direction.up, Direction.south, Direction.left); //When HyperDirection actual1 = dir.rotate(PlayerRotation.toSky); HyperDirection expected1 = new HyperDirection(Direction.up, Direction.right, Direction.south, Direction.left); HyperDirection actual2 = actual1.rotate(PlayerRotation.toSky); HyperDirection expected2 = new HyperDirection(Direction.right, Direction.down, Direction.south, Direction.left); HyperDirection actual3 = actual2.rotate(PlayerRotation.toSky); HyperDirection expected3 = new HyperDirection(Direction.down, Direction.left, Direction.south, Direction.left); //Then Assert.AreEqual(expected1, actual1); Assert.AreEqual(expected2, actual2); Assert.AreEqual(expected3, actual3); }
public GridSlice orientationForDirection(HyperDirection hyperDirection, HyperPosition hyperPosition) { switch (hyperDirection.unSeen) { case Direction.left: case Direction.right: return(new GridSlice(WorldOrientation.xyz, hyperPosition.w)); case Direction.north: case Direction.south: return(new GridSlice(WorldOrientation.xyw, hyperPosition.z)); case Direction.east: case Direction.west: return(new GridSlice(WorldOrientation.yzw, hyperPosition.x)); case Direction.up: case Direction.down: return(new GridSlice(WorldOrientation.xzw, hyperPosition.y)); } return(new GridSlice(WorldOrientation.xyz, hyperPosition.w)); }
public void TestGameMovesPlayerFourTimes() { // Given HyperGrid hyperGrid = new HyperGrid(10, 10, 10, 10); HyperPosition playerPosition = new HyperPosition(5, 5, 5, 5); HyperDirection playerDirection = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left); Player player = new Player(playerPosition, playerDirection); Game game = new Game(player, hyperGrid); hyperGrid.setBlocked(5, 4, 5, 5); // When game.process(MoveIntent.forward); game.process(MoveIntent.forward); game.process(MoveIntent.forward); //Then Assert.AreEqual(new HyperPosition(4, 4, 5, 5), player.position); Assert.AreEqual(new HyperDirection(Direction.up, Direction.west, Direction.north, Direction.left), player.direction); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(5, 5, 5, 5), player.position); }
public void TestPlayerMovesUp() { // Given HyperGrid hyperGrid = new HyperGrid(10, 10, 10, 10); HyperPosition playerPosition = new HyperPosition(2, 2, 2, 0); HyperDirection playerDirection = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left); Player player = new Player(playerPosition, playerDirection); Game game = new Game(player, hyperGrid); hyperGrid.setBlocked(2, 1, 2, 0); hyperGrid.setBlocked(3, 1, 2, 0); hyperGrid.setBlocked(4, 2, 2, 0); hyperGrid.setBlocked(4, 3, 2, 0); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(3, 2, 2, 0), player.position, player.position.printOut()); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(3, 2, 2, 0), player.position, player.position.printOut()); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(3, 3, 2, 0), player.position, player.position.printOut()); }
public void RotateMultipleDirections() { //Given HyperDirection dir = new HyperDirection(Direction.left, Direction.up, Direction.south, Direction.east); //When HyperDirection actual1 = dir.rotate(PlayerRotation.toGround); HyperDirection expected1 = new HyperDirection(Direction.down, Direction.left, Direction.south, Direction.east); HyperDirection actual2 = actual1.rotate(PlayerRotation.toRightSide); HyperDirection expected2 = new HyperDirection(Direction.south, Direction.left, Direction.up, Direction.east); HyperDirection actual3 = actual2.rotate(PlayerRotation.toSky); HyperDirection expected3 = new HyperDirection(Direction.left, Direction.north, Direction.up, Direction.east); HyperDirection actual4 = actual3.rotate(PlayerRotation.toLeftSide); HyperDirection expected4 = new HyperDirection(Direction.down, Direction.north, Direction.left, Direction.east); //Then Assert.AreEqual(expected1, actual1); Assert.AreEqual(expected2, actual2); Assert.AreEqual(expected3, actual3); Assert.AreEqual(expected4, actual4); }
public void RotateToUnseenRight() { //Given HyperDirection dir = new HyperDirection(Direction.left, Direction.up, Direction.south, Direction.east); //When HyperDirection actual1 = dir.rotate(PlayerRotation.toUnseenRight); HyperDirection expected1 = new HyperDirection(Direction.east, Direction.up, Direction.south, Direction.right); HyperDirection actual2 = actual1.rotate(PlayerRotation.toUnseenRight); HyperDirection expected2 = new HyperDirection(Direction.right, Direction.up, Direction.south, Direction.west); HyperDirection actual3 = actual2.rotate(PlayerRotation.toUnseenRight); HyperDirection expected3 = new HyperDirection(Direction.west, Direction.up, Direction.south, Direction.left); HyperDirection actual4 = actual3.rotate(PlayerRotation.toUnseenRight); HyperDirection expected4 = new HyperDirection(Direction.left, Direction.up, Direction.south, Direction.east); //Then Assert.AreEqual(expected1, actual1); Assert.AreEqual(expected2, actual2); Assert.AreEqual(expected3, actual3); Assert.AreEqual(expected4, actual4); }
public Player(HyperPosition position, HyperDirection direction) { this.position = position; this.direction = direction; }
public void TestWalkInCircle() { // Given HyperGrid hyperGrid = new HyperGrid(10, 10, 10, 10); HyperPosition playerPosition = new HyperPosition(2, 2, 2, 0); HyperDirection playerDirection = new HyperDirection(Direction.east, Direction.up, Direction.north, Direction.left); Player player = new Player(playerPosition, playerDirection); Game game = new Game(player, hyperGrid); hyperGrid.setBlocked(2, 1, 2, 0); hyperGrid.setBlocked(3, 1, 2, 0); hyperGrid.setBlocked(4, 1, 2, 0); hyperGrid.setBlocked(5, 1, 2, 0); hyperGrid.setBlocked(5, 1, 3, 0); hyperGrid.setBlocked(5, 1, 4, 0); hyperGrid.setBlocked(5, 1, 5, 0); hyperGrid.setBlocked(5, 1, 6, 0); hyperGrid.setBlocked(4, 1, 6, 0); hyperGrid.setBlocked(3, 1, 6, 0); hyperGrid.setBlocked(2, 1, 6, 0); hyperGrid.setBlocked(1, 1, 6, 0); hyperGrid.setBlocked(1, 1, 5, 0); hyperGrid.setBlocked(1, 1, 4, 0); hyperGrid.setBlocked(1, 1, 3, 0); hyperGrid.setBlocked(1, 1, 2, 0); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(3, 2, 2, 0), player.position, player.position.printOut()); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(4, 2, 2, 0), player.position, player.position.printOut()); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(5, 2, 2, 0), player.position, player.position.printOut()); game.process(MoveIntent.turnRightSide); Assert.AreEqual(new HyperPosition(5, 2, 2, 0), player.position, player.position.printOut()); Assert.AreEqual(new HyperDirection(Direction.north, Direction.up, Direction.west, Direction.left), player.direction); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(5, 2, 3, 0), player.position, player.position.printOut()); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(5, 2, 4, 0), player.position, player.position.printOut()); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(5, 2, 5, 0), player.position, player.position.printOut()); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(5, 2, 6, 0), player.position, player.position.printOut()); game.process(MoveIntent.turnRightSide); Assert.AreEqual(new HyperPosition(5, 2, 6, 0), player.position, player.position.printOut()); Assert.AreEqual(new HyperDirection(Direction.west, Direction.up, Direction.south, Direction.left), player.direction); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(4, 2, 6, 0), player.position, player.position.printOut()); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(3, 2, 6, 0), player.position, player.position.printOut()); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(2, 2, 6, 0), player.position, player.position.printOut()); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(1, 2, 6, 0), player.position, player.position.printOut()); game.process(MoveIntent.turnRightSide); Assert.AreEqual(new HyperPosition(1, 2, 6, 0), player.position, player.position.printOut()); Assert.AreEqual(new HyperDirection(Direction.south, Direction.up, Direction.east, Direction.left), player.direction); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(1, 2, 5, 0), player.position, player.position.printOut()); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(1, 2, 4, 0), player.position, player.position.printOut()); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(1, 2, 3, 0), player.position, player.position.printOut()); game.process(MoveIntent.forward); Assert.AreEqual(new HyperPosition(1, 2, 2, 0), player.position, player.position.printOut()); }