public void DeployRoverExpectValidLocationOrThrows(string deployRoverCommandText)
{
var splittedRoverInfo = deployRoverCommandText.Split(' ');
ICommand <Rover> roverDeployCommand = new RoverDeployCommand(Plateau);
if (splittedRoverInfo.Length == 3)
{
var isRoverLocationXParsedSuccessfully = int.TryParse(splittedRoverInfo[0], out var roverX);
var isRoverLocationYParsedSuccessfully = int.TryParse(splittedRoverInfo[1], out var roverY);
if (!isRoverLocationXParsedSuccessfully)
{
var ex = Assert.Throws <InvalidCastException>(() =>
roverDeployCommand.Execute(deployRoverCommandText));
Assert.AreEqual("Invalid argument value for parsing upper value of x.", ex.Message);
}
else if (!isRoverLocationYParsedSuccessfully)
{
var ex = Assert.Throws <InvalidCastException>(() =>
roverDeployCommand.Execute(deployRoverCommandText));
Assert.That(ex.Message, Is.EqualTo("Invalid argument value for parsing upper value of y."));
}
else if (!Plateau.ContainsKey(new Block {
X = roverX, Y = roverY
}) || Plateau[new Block {
X = roverX, Y = roverY
}] != null)
{
var ex = Assert.Throws <ArgumentException>(() => roverDeployCommand.Execute(deployRoverCommandText));
Assert.AreEqual("The location is not valid for deploying.", ex.Message);
}
else
{
var roverDirection = EnumHelper.GetValueFromDescription <DirectionType>(splittedRoverInfo[2]);
if (roverDirection == DirectionType.None)
{
var ex = Assert.Throws <InvalidEnumArgumentException>(() => roverDeployCommand.Execute(deployRoverCommandText));
Assert.AreEqual("roverDirection", ex.ParamName);
}
else
{
var rover = roverDeployCommand.Execute(deployRoverCommandText);
Assert.NotNull(rover);
Assert.AreEqual(roverDirection, rover.Direction);
var roverLocation = new Block {
X = roverX, Y = roverY
};
Assert.AreSame(Plateau[roverLocation], rover);
}
}
}
else
{
var ex = Assert.Throws <TargetParameterCountException>(() => roverDeployCommand.Execute(deployRoverCommandText));
Assert.That(ex.Message, Is.EqualTo($"{deployRoverCommandText} is not a valid deploy command, please give the order in \"x(1) y(2) direction(N)\" format."));
}
}
public void MoveRoverExpectValidPositionOrThrows(string deployRoverCommandText, string moveRoverCommandText, string expectedPositionText)
{
ICommand <Rover> roverDeployCommand = new RoverDeployCommand(Plateau);
var deployedRover = roverDeployCommand.Execute(deployRoverCommandText);
ICommand <Rover> roverMoveCommand = new RoverMoveCommand(deployedRover, Plateau);
var regexMoveCommandPattern = new Regex("^[LRM]+$");
if (regexMoveCommandPattern.IsMatch(moveRoverCommandText))
{
var splittedPosition = expectedPositionText.Split(' ');
int.TryParse(splittedPosition[0], out var expectedRoverXLocation);
int.TryParse(splittedPosition[1], out var expectedRoverYLocation);
var expectedRoverDirection = EnumHelper.GetValueFromDescription <DirectionType>(splittedPosition[2]);
var expectedPosition = new Block {
X = expectedRoverXLocation, Y = expectedRoverYLocation
};
if (Plateau.ContainsKey(expectedPosition) && Plateau[expectedPosition] == null)
{
var movedRover = roverMoveCommand.Execute(moveRoverCommandText);
Assert.AreSame(deployedRover, movedRover);
var actualPosition = Plateau.GetRoverLocation(movedRover);
Assert.AreEqual(expectedRoverXLocation, actualPosition.X);
Assert.AreEqual(expectedRoverYLocation, actualPosition.Y);
Assert.AreEqual(expectedRoverDirection, movedRover.Direction);
}
else
{
var ex = Assert.Throws <ArgumentException>(() => roverMoveCommand.Execute(moveRoverCommandText));
Assert.AreEqual($"Direction of {expectedRoverDirection} at order {deployedRover.Order} rover's move command is not valid!", ex.Message);
}
}
else
{
var ex = Assert.Throws <ArgumentException>(() => roverMoveCommand.Execute(moveRoverCommandText));
Assert.AreEqual($"Invalid character(s) in \"{moveRoverCommandText}\" text for move command.", ex.Message);
}
}
/// <summary>
/// Deplace un batiment de deux cases en ligne droite dans n'importe quelle direction, vers une case libre constructible. La case sautée peu être de n'importe quel type. La case d'arrivée ne doit pas obligatoirement être adjacente à un des batiments du joueur.
/// </summary>
/// <param name="coordonneeDepart">Coordonnées de la maison à déplacer</param>
/// <param name="coordonneeArrivee">Coordonnées de la case où déplacer la maison</param>
/// <param name="joueur">Joueur qui lance le bonus</param>
/// <param name="plateau">Plateau de jeu</param>
/// <returns>True si bonus bien activé, false sinon.</returns>
public static bool Enclos(Coordonnee coordonneeDepart, Coordonnee coordonneeArrivee, Joueur joueur, Plateau plateau)
{
if (coordonneeDepart == null || coordonneeArrivee == null)
{
return(false);
}
if (!joueur.ListeBonus.Contains(TypeTerrain.ENCLOS))
{
return(false);
}
if (plateau[coordonneeDepart].Couleur != joueur.Couleur)
{
return(false);
}
if (plateau[coordonneeArrivee].Type != TypeTerrain.PRAIRIE && plateau[coordonneeArrivee].Type != TypeTerrain.FORET &&
plateau[coordonneeArrivee].Type != TypeTerrain.FLEUR && plateau[coordonneeArrivee].Type != TypeTerrain.DESERT &&
plateau[coordonneeArrivee].Type != TypeTerrain.CANYON)
{
return(false);
}
if (plateau[coordonneeArrivee].Couleur != Couleur.AUCUNE)
{
return(false);
}
List <Coordonnee> m_listeTerrainPosable = new List <Coordonnee>();
m_listeTerrainPosable.Add(new Coordonnee(coordonneeDepart.X + 2, coordonneeDepart.Y));
m_listeTerrainPosable.Add(new Coordonnee(coordonneeDepart.X - 2, coordonneeDepart.Y));
m_listeTerrainPosable.Add(new Coordonnee(coordonneeDepart.X - 1, coordonneeDepart.Y - 2));
m_listeTerrainPosable.Add(new Coordonnee(coordonneeDepart.X + 1, coordonneeDepart.Y - 2));
m_listeTerrainPosable.Add(new Coordonnee(coordonneeDepart.X - 1, coordonneeDepart.Y + 2));
m_listeTerrainPosable.Add(new Coordonnee(coordonneeDepart.X + 1, coordonneeDepart.Y + 2));
for (int i = 0; i < m_listeTerrainPosable.Count; i++)
{
if (!plateau.ContainsKey(m_listeTerrainPosable[i]))
{
m_listeTerrainPosable.RemoveAt(i);
i--;
}
}
foreach (Coordonnee coordcourante in m_listeTerrainPosable)
{
if (coordcourante.Equals(coordonneeArrivee))
{
plateau[coordonneeArrivee].Couleur = joueur.Couleur;
plateau[coordonneeDepart].Couleur = Couleur.AUCUNE;
joueur.m_maisonsPlacees.Remove(coordonneeDepart);
joueur.m_maisonsPlacees.Add(coordonneeArrivee);
return(true);
}
}
return(false);
}
/// <summary>
/// Balayage horizontal du plateau concernant l'algorithme du bonus "TAVERNE".
/// </summary>
/// <param name="plateau">Plateau du jeu</param>
/// <param name="joueur">Joueur qui utilise le bonus</param>
/// <returns>Liste de coordonnees éligibles du bonus TAVERNE</returns>
private static List <Coordonnee> BalayageHorizontale(Plateau plateau, Joueur joueur)
{
// On crée la liste des coordonnées posables. C'est cette liste qu'on retournera à la fin.
List <Coordonnee> terrainPosable = new List <Coordonnee>();
// On crée une coordonnée origine, pour se souvenir de la première extrémité d'une suite de maison.
Coordonnee coordOrig = new Coordonnee(-1, -1);
// Compteur
int compteurMaison = 0;
// On parcours chaque lignes du plateau de gauche à droite.
for (int y = 1; y <= Constante.Y_PLATEAU_MAX; y++)
{
for (int x = 1; x <= Constante.X_PLATEAU_MAX; x++)
{
Coordonnee coordCourante = new Coordonnee(x, y);
// Si on trouve une maison du joueur, on teste si ses voisins de droite sont aussi des maisons du joueurs.
// Au cas où une ligne de 3 maisons ou plus est detectée, les deux extrémitées, si elles sont vide, sont a ajouter a la Liste des terrain posables.
// Si notre coordOrig est vide
if (coordOrig.Item1 == -1 && coordOrig.Item2 == -1)
{
// Si on trouve une maison du joueur
if (plateau[coordCourante].Couleur == joueur.Couleur)
{
// On remplit la coordOrig de la coordonnée précédente : il s'agit de l'extrémité d'origine
coordOrig = new Coordonnee(coordCourante.Item1 - 1, coordCourante.Item2);
// Nous avons une premiere maison dans l'alignement
compteurMaison++;
}
}
else // Si notre coordOrig n'est pas vide
{
// Si on tombe sur une coordonnée où ya pas de maison du joueur
if (plateau[coordCourante].Couleur != joueur.Couleur)
{
// On regarde si on a un compteur supérieure ou égale a 3 maisons alignés
if (compteurMaison >= 3)
{
// On ajoute la coordonnée de l'extrémité d'origine et la coordonnée courante (qui est donc l'extrémité de destination) dans la liste
if (plateau.ContainsKey(coordOrig) && plateau[coordOrig].Couleur == Couleur.AUCUNE)
{
terrainPosable.Add(coordOrig);
}
if (plateau.ContainsKey(coordOrig) && plateau[coordCourante].Couleur == Couleur.AUCUNE)
{
terrainPosable.Add(coordCourante);
}
}
coordOrig = new Coordonnee(-1, -1);
compteurMaison = 0;
}
else // Si on tombe sur une coordonnée occupée par une maison du joueur
{
// Une maison supplémentaire dans l'alignement
compteurMaison++;
}
}
}
}
return(terrainPosable);
}
public bool PlacerMaison(Coordonnee coordonnee, Plateau plateau)
{
// Pour savoir si c'est pas a NULL
if (coordonnee == null)
{
return(false);
}
// Si la coordonnée existe dans le plateau
if (!plateau.ContainsKey(coordonnee))
{
return(false);
}
// Si c'est bien un terrain de sa carte terrain
if (plateau[coordonnee].Type != m_carteTerrain)
{
return(false);
}
// Pour verifier si il y a pas déjà une maison dessus.
if (plateau[coordonnee].Couleur != Couleur.AUCUNE)
{
return(false);
}
// Pour savoir si il y a encore des maisons de dispo
if (m_nbMaisons == 0)
{
return(false);
}
// TEST MAISON ADJACENTE
List <Coordonnee> m_listeTerrainObligatoire = new List <Coordonnee>();
List <Coordonnee> m_listeTerrainSecondaire = new List <Coordonnee>();
List <Coordonnee> m_listeTerrainTernaire = new List <Coordonnee>();
// On parcours notre liste de maison deja placees et on ajoute a notre liste ternaire les terrains ou il est possible de poser une maison
foreach (Coordonnee coord in m_maisonsPlacees)
{
m_listeTerrainTernaire.AddRange(plateau.Adjacent(coord));
}
for (int i = 0; i < m_listeTerrainTernaire.Count; i++)
{
if (plateau[m_listeTerrainTernaire[i]].Type != m_carteTerrain || plateau[m_listeTerrainTernaire[i]].Couleur != Couleur.AUCUNE)
{
m_listeTerrainTernaire.RemoveAt(i);
i--;
}
}
// On parcours tout le plateau a la recherche d'adjacences des maisons déjà posées. Il existera des doublons dans la
// Collection.
foreach (KeyValuePair <Coordonnee, Terrain> terrain in plateau)
{
if (terrain.Value.Couleur == m_couleur && terrain.Value.Type == m_carteTerrain)
{
m_listeTerrainObligatoire.AddRange(plateau.Adjacent(terrain.Key));
}
if (terrain.Value.Type == m_carteTerrain && terrain.Value.Couleur == Couleur.AUCUNE)
{
m_listeTerrainSecondaire.Add(terrain.Key);
}
}
// On parcours notre liste d'adjacence et on retire les terrains qui ne sont pas concernés.
for (int i = 0; i < m_listeTerrainObligatoire.Count; i++)
{
if (plateau[m_listeTerrainObligatoire[i]].Type != m_carteTerrain || plateau[m_listeTerrainObligatoire[i]].Couleur != Couleur.AUCUNE)
{
m_listeTerrainObligatoire.RemoveAt(i);
i--;
}
}
if (m_listeTerrainObligatoire.Count == 0)
{
if (m_listeTerrainTernaire.Count == 0)
{
foreach (Coordonnee coord in m_listeTerrainSecondaire)
{
if (coord.Equals(coordonnee))
{
plateau[coordonnee].Couleur = m_couleur;
m_maisonsPlacees.Add(coordonnee);
m_nbMaisons--;
return(true);
}
}
}
else
{
foreach (Coordonnee coord in m_listeTerrainTernaire)
{
if (coord.Equals(coordonnee))
{
plateau[coordonnee].Couleur = m_couleur;
m_maisonsPlacees.Add(coordonnee);
m_nbMaisons--;
return(true);
}
}
}
}
else // sinon on voit si la coordonnee de destination correspond a un des terrains adjacents
{
foreach (Coordonnee coord in m_listeTerrainTernaire)
{
if (coord.Equals(coordonnee))
{
plateau[coordonnee].Couleur = m_couleur;
m_maisonsPlacees.Add(coordonnee);
m_nbMaisons--;
return(true);
}
}
foreach (Coordonnee coord in m_listeTerrainObligatoire)
{
if (coord.Equals(coordonnee))
{
plateau[coordonnee].Couleur = m_couleur;
m_maisonsPlacees.Add(coordonnee);
m_nbMaisons--;
return(true);
}
}
}
return(false);
}