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