public void DefaultConstructorCorrectlyPlacesPlayer()
{
PlacedPlayer placedPlayer = new PlacedPlayer();
Location expectedLocation = new Location(0, 0);
Assert.Equal(expectedLocation, placedPlayer.location);
}
public void OverrideConstructorCorrectlyPlacesPlayer_01()
{
PlacedPlayer placedPlayer = new PlacedPlayer(7, -5);
Location expectedLocation = new Location(7, -5);
Assert.Equal(expectedLocation, placedPlayer.location);
}
public IPlacementRule GetPlacementRule(FormationRule formationRule, PlacedFormation placedFormation)
{
string relativeTypeString = formationRule.GetParameterValue("relativeType");
string playerRelativeString = formationRule.GetParameterValue("playerRelative");
string distanceString = formationRule.GetParameterValue("distance");
RelativeType relativeType;
switch (relativeTypeString)
{
case "Left":
relativeType = RelativeType.Left;
break;
case "Right":
relativeType = RelativeType.Right;
break;
case "Inside":
relativeType = RelativeType.Inside;
break;
case "Outside":
relativeType = RelativeType.Outside;
break;
default:
throw new FormationException("Relative type must be Left/Right/Inside/Outside.");
}
int distance = int.Parse(distanceString);
PlacedPlayer playerRelative = placedFormation.GetPlayerByTag(playerRelativeString);
return(new RelativeToPlayerHorizontally(playerRelative, distance, relativeType));
}
public void PlacesPlayerCorrectlyOutsideOther(PlacedPlayer playerToBeOutside, PlacedPlayer playerToPlace,
int distanceOutside, Location expectedLocation)
{
IPlacementRule placementRule = new RelativeToPlayerHorizontally(playerToBeOutside, distanceOutside, RelativeType.Outside);
playerToPlace = placementRule.Place(playerToPlace);
Assert.Equal <Location>(expectedLocation, playerToPlace.location);
}
public void PlacesPlayerCorrectlyToLeftOfOther(PlacedPlayer playerToBeToLeftOf, PlacedPlayer playerToPlace,
int distanceToLeft, Location expectedLocation)
{
IPlacementRule placementRule = new RelativeToPlayerHorizontally(playerToBeToLeftOf, distanceToLeft, RelativeType.Left);
playerToPlace = placementRule.Place(playerToPlace);
Assert.Equal <Location>(expectedLocation, playerToPlace.location);
}
public void addIslandAt(int i, int j, int p)
{
PlacedPlayer newCurrentPlayer;
Vector3 noise = new Vector3(Random.Range(-maxNoise, maxNoise), 0, Random.Range(-maxNoise, maxNoise));
GameObject newObject = (GameObject)Instantiate(islandPrefab);
CompoundIsland newIsland = newObject.GetComponent <CompoundIsland> ();
newIsland.init();
// check group
int gr = controlHub.gameController.playerDict.ElementAt(p).Value.group;
if (controlHub.gameController.playerGroup == gr)
{
newIsland.disableIsland();
}
newIsland.setLabelColor(controlHub.menuController.groupColor [gr]);
newObject.transform.localPosition = new Vector3(j * gridSize + noise.x, 0, i * gridSize + noise.y);
newObject.transform.Rotate(new Vector3(0, Random.Range(0.0f, 360.0f), 0));
string nick = controlHub.gameController.playerDict.ElementAt(p).Value.nickname; //.playerList [p].nickname;
if (nick.Equals(""))
{
nick = controlHub.gameController.playerDict.ElementAt(p).Value.login;
}
newIsland.island1.setLabel(nick);
newIsland.island1.billboard.cam = cam;
newIsland.island1.owner = controlHub.gameController.playerDict.ElementAt(p).Value.login;
newIsland.island1.seekPlayerController = this;
newIsland.island1.camera = cam;
newIsland.island2.setLabel(nick);
newIsland.island2.billboard.cam = cam;
newIsland.island2.owner = controlHub.gameController.playerDict.ElementAt(p).Value.login;
newIsland.island2.seekPlayerController = this;
newIsland.island2.camera = cam;
GameObject newDotGO = (GameObject)Instantiate(dotPrefab);
newDotGO.transform.localPosition =
new Vector3(newObject.transform.localPosition.x,
-5000.0f,
newObject.transform.localPosition.z);
newDotGO.transform.parent = matrixParent.transform;
subIslandMatrix [i, j] = newDotGO;
islandMatrix [i, j] = newObject;
newCurrentPlayer = new PlacedPlayer();
newCurrentPlayer.player = controlHub.gameController.playerDict.ElementAt(p).Value;
newCurrentPlayer.i = i;
newCurrentPlayer.j = j;
currentPlayers.Add(controlHub.gameController.playerDict.ElementAt(p).Key,
newCurrentPlayer);
}
public void GetsCorrectPlayerFromInsideOut(PlacedFormation placedFormation, int number, int expectedPlayerIndex)
{
PlacedPlayer expectedPlayer = placedFormation.skillPlayers[expectedPlayerIndex];
PlacedPlayer returnedPlayer = placedFormation.GetNumberedSkillLeft(FlowDirection.InsideOut, number);
bool samePlayer = ReferenceEquals(expectedPlayer, returnedPlayer);
Assert.True(samePlayer);
}
public void PlacingPlayerOutsidePlayerInMiddleThrowsExceptionWithProperMessage()
{
PlacedPlayer playerToBeOutside = new PlacedPlayer();
PlacedPlayer playerToPlace = new PlacedPlayer(3, 3);
IPlacementRule placementRule = new RelativeToPlayerHorizontally(playerToBeOutside, 1, RelativeType.Outside);
PlacementException ex = Assert.Throws <PlacementException>(() => playerToPlace = placementRule.Place(playerToPlace));
Assert.Equal("Can't place player inside/outside another player who is in center of formation.", ex.Message);
}
public void PlacingPlayerNegativeUnitsToRightOfThrowsException()
{
PlacedPlayer playerToBeToRightOf = new PlacedPlayer();
PlacedPlayer playerToPlace = new PlacedPlayer();
IPlacementRule placementRule = new RelativeToPlayerHorizontally(playerToBeToRightOf, -7, RelativeType.Right);
PlacementException ex = Assert.Throws <PlacementException>(() => playerToPlace = placementRule.Place(playerToPlace));
Assert.Equal("Can't place player negative distance relative.", ex.Message);
}
public IPlacementRule GetPlacementRule(FormationRule formationRule, PlacedFormation placedFormation)
{
string behindTagParameter = formationRule.GetParameterValue("playerBehindTag");
string distanceBehindString = formationRule.GetParameterValue("distanceBehind");
int distanceBehind = int.Parse(distanceBehindString);
PlacedPlayer playerBehind = placedFormation.GetPlayerByTag(behindTagParameter);
return(new BehindPlayer(playerBehind, distanceBehind));
}
public void PlacingPlayerZeroUnitsToLeftThrowsException()
{
PlacedPlayer playerToBeToLeftOf = new PlacedPlayer();
PlacedPlayer playerToPlace = new PlacedPlayer(3, 3);
IPlacementRule placementRule = new RelativeToPlayerHorizontally(playerToBeToLeftOf, 0, RelativeType.Left);
PlacementException ex = Assert.Throws <PlacementException>(() => playerToPlace = placementRule.Place(playerToPlace));
Assert.Equal("Can't place 0 units relative.", ex.Message);
}
public void PlacingPlayerZeroUnitsInsideThrowsExceptionWithProperMessage()
{
PlacedPlayer playerToBeInside = new PlacedPlayer();
PlacedPlayer playerToPlace = new PlacedPlayer(3, 3);
IPlacementRule placementRule = new RelativeToPlayerHorizontally(playerToBeInside, 0, RelativeType.Inside);
PlacementException ex = Assert.Throws <PlacementException>(() => playerToPlace = placementRule.Place(playerToPlace));
Assert.Equal("Can't place 0 units relative.", ex.Message);
}
public void PlacingPlayerNegativeUnitsOutsideThrowsExceptionWithProperMessage()
{
PlacedPlayer playerToBeOutside = new PlacedPlayer();
PlacedPlayer playerToPlace = new PlacedPlayer(3, 3);
IPlacementRule placementRule = new RelativeToPlayerHorizontally(playerToBeOutside, -4, RelativeType.Outside);
PlacementException ex = Assert.Throws <PlacementException>(() => playerToPlace = placementRule.Place(playerToPlace));
Assert.Equal("Can't place player negative distance relative.", ex.Message);
}
public void PlacingPlayerNegativeUnitsBehindThrowsExceptionWithProperMessage()
{
PlacedPlayer playerToBeBehind = new PlacedPlayer();
PlacedPlayer playerToPlace = new PlacedPlayer();
IPlacementRule placementRule = new BehindPlayer(playerToBeBehind, -6);
PlacementException ex = Assert.Throws <PlacementException>(() => placementRule.Place(playerToPlace));
Assert.Equal("Can't place player negative units behind player.", ex.Message);
}
public void PlacesPlayerCorrectlyOnLine(int startingXPosition, int startingYPosition)
{
PlacedPlayer playerToPlace = new PlacedPlayer(startingXPosition, startingYPosition);
Location expectedLocation = new Location(startingXPosition, 0);
IPlacementRule placementRule = new OnLineOfScrimmage();
playerToPlace = placementRule.Place(playerToPlace);
Assert.Equal <Location>(expectedLocation, playerToPlace.location);
}
public void GetsCorrectPlayerFromOutsideIn(PlacedFormation placedFormation, Direction strongDirection,
int number, int expectedPlayerIndex)
{
placedFormation.strongSide = strongDirection;
PlacedPlayer expectedPlayer = placedFormation.skillPlayers[expectedPlayerIndex];
PlacedPlayer returnedPlayer = placedFormation.GetNumberedSkillWeak(FlowDirection.OutsideIn, number);
bool samePlayer = ReferenceEquals(expectedPlayer, returnedPlayer);
Assert.True(samePlayer);
}
public void ReturnsLeftTackleIfStrongSideIsRight()
{
PlacedFormation placedFormation = new PlacedFormation();
PlacedPlayer expectedPlayer = placedFormation.leftTackle;
placedFormation.strongSide = Direction.Right;
PlacedPlayer returnedPlayer = placedFormation.GetWeakTackle();
bool samePlayer = ReferenceEquals(returnedPlayer, expectedPlayer);
Assert.True(samePlayer);
}
public void ReturnsRightGuardIfStrongSideIsLeft()
{
PlacedFormation placedFormation = new PlacedFormation();
PlacedPlayer expectedPlayer = placedFormation.rightGuard;
placedFormation.strongSide = Direction.Left;
PlacedPlayer returnedPlayer = placedFormation.GetWeakGuard();
bool samePlayer = ReferenceEquals(returnedPlayer, expectedPlayer);
Assert.True(samePlayer);
}
public void PlacesPlayerCorrectlyBehindOther_02()
{
PlacedPlayer playerToBeBehind = new PlacedPlayer(7, 2);
PlacedPlayer playerToPlace = new PlacedPlayer();
Location expectedLocation = new Location(7, 5);
IPlacementRule placementRule = new BehindPlayer(playerToBeBehind, 3);
playerToPlace = placementRule.Place(playerToPlace);
Assert.Equal <Location>(expectedLocation, playerToPlace.location);
}
public void GetsThePlayerWithTheProperTag_02()
{
PlacedFormation placedFormation = new PlacedFormation();
placedFormation.leftTackle.tag = "LT";
placedFormation.skillPlayers[2].tag = "X";
PlacedPlayer expectedPlayer = placedFormation.leftTackle;
PlacedPlayer returnedPlayer = placedFormation.GetPlayerByTag("LT");
bool sameObject = ReferenceEquals(expectedPlayer, returnedPlayer);
Assert.True(sameObject);
}
public PlacedPlayer Place(PlacedPlayer placedPlayer)
{
if (_distanceBehind == 0)
{
throw new PlacementException("Can't place 0 units behind.");
}
if (_distanceBehind < 0)
{
throw new PlacementException("Can't place player negative units behind player.");
}
return(new PlacedPlayer(
_playerBehind.location.x,
_playerBehind.location.y + _distanceBehind
));
}
public PlacedPlayer Place(PlacedPlayer placedPlayer)
{
if (_distance == 0)
{
throw new PlacementException("Can't place 0 units relative.");
}
if (_distance < 0)
{
throw new PlacementException("Can't place player negative distance relative.");
}
int offset = GetRelativeOffset();
return(new PlacedPlayer(
_playerRelative.location.x + offset,
placedPlayer.location.y
));
}
public RelativeToPlayerHorizontally(PlacedPlayer playerRelative, int distance, RelativeType relativeType)
{
_playerRelative = playerRelative;
_distance = distance;
_relativeType = relativeType;
}
public PlacedPlayer Place(PlacedPlayer placedPlayer)
{
return(new PlacedPlayer());
}
public PlacedPlayer Place(PlacedPlayer placedPlayer)
{
return(new PlacedPlayer(placedPlayer.location.x, 0));
}
public BehindPlayer(PlacedPlayer playerBehind, int distanceBehind)
{
_playerBehind = playerBehind;
_distanceBehind = distanceBehind;
}
