public void descendreTest()
{
Carre carre = new Carre();
ArrayList yBefore = new ArrayList(); // Les deux listes font la même tailles
ArrayList yAfter = new ArrayList();
for (int i = 0; i < carre.hauteurPiece; i++)
{
for (int j = 0; j < carre.largeurPiece; j++)
{
yBefore.Add(carre.representation[j, i].y); // Stocke les ordonnées avant la descente
}
}
carre.descendre();
for (int i = 0; i < carre.hauteurPiece; i++)
{
for (int j = 0; j < carre.largeurPiece; j++)
{
yAfter.Add(carre.representation[j, i].y); // Stocke les ordonnées après la descente
}
}
for (int i = 0; i < yBefore.Count; i++)
{
Assert.AreEqual((int)yBefore[i] + 1, (int)yAfter[i]); // Teste que l'ordonnée d'avant + 1 est égal à l'ordonnée d'après
}
}
public void deplacerTest()
{
Carre carre = new Carre();
ArrayList xAvantDeplacement = new ArrayList(); // Les listes font la même taille
ArrayList xApresDeplacement = new ArrayList();
for (int i = 0; i < carre.hauteurPiece; i++)
{
for (int j = 0; j < carre.largeurPiece; j++)
{
xAvantDeplacement.Add(carre.representation[j, i].x); // Stocke l'abscisse avant déplacement
}
}
carre.deplacer(1);
for (int i = 0; i < carre.hauteurPiece; i++)
{
for (int j = 0; j < carre.largeurPiece; j++)
{
xApresDeplacement.Add(carre.representation[j, i].x); // Stocke l'abscisse après déplacement
}
}
for (int i = 0; i < xAvantDeplacement.Count; i++)
{
Assert.AreEqual(xAvantDeplacement[i], xApresDeplacement[i]); // Test que la pièce n'a pas bougée
}
}
public void CarreTest()
{
Carre carre = new Carre();
Assert.AreEqual(0, carre.sens);
Assert.AreEqual(6, carre.offsetPieceHorizontal);
Assert.AreEqual(0, carre.offsetPieceVertical);
Assert.AreEqual(4, carre.hauteurPiece);
Assert.AreEqual(4, carre.largeurPiece);
Assert.AreSame(new Case[carre.hauteurPiece, carre.largeurPiece].GetType(), carre.representation.GetType());
}
public void decolorerPieceTest()
{
Carre carre = new Carre();
carre.decolorerPiece();
for (int i = 0; i < carre.hauteurPiece; i++)
{
for (int j = 0; j < carre.largeurPiece; j++)
{
Assert.AreEqual(false, carre.representation[j, i].estColore); // On s'assure que la pièce est décolorée
}
}
}
// Génére une nouvelle pièce de façon aléatoire
public Piece pieceSuivante()
{
// Nouvelle piece
Piece piece = null;
int numPiece = randNum.Next(1, 8);
if (numPiece == 1)
{
piece = new Barre();
}
if (numPiece == 2)
{
piece = new T();
}
if (numPiece == 3)
{
piece = new L();
}
if (numPiece == 4)
{
piece = new Carre();
}
if (numPiece == 5)
{
piece = new LInversee();
}
if (numPiece == 6)
{
piece = new S();
}
if (numPiece == 7)
{
piece = new Z();
}
return piece;
}
public Grille(int[,] map, float tailleCarre) {
int nbNodeX = map.GetLength(0);
int nbNodeY = map.GetLength(1);
float largeurMap = nbNodeX * tailleCarre;
float hauteurMap = nbNodeY * tailleCarre;
/* On met sur la grille l'ensemble des nodes de controles*/
ControlNode[,] controlNodes = new ControlNode[nbNodeX, nbNodeY];
for (int x = 0; x < nbNodeX; x ++) {
for (int y = 0; y < nbNodeY; y ++) {
Vector3 pos = new Vector3(-largeurMap/2 + x * tailleCarre + tailleCarre/2, 0, -hauteurMap/2 + y * tailleCarre + tailleCarre/2);
controlNodes[x,y] = new ControlNode(pos,map[x,y] == 1, tailleCarre);
}
}
/* Puis les carrés contenant les nodes simple */
carres = new Carre[nbNodeX -1,nbNodeY -1];
for (int x = 0; x < nbNodeX-1; x ++) {
for (int y = 0; y < nbNodeY-1; y ++) {
carres[x,y] = new Carre(controlNodes[x,y+1], controlNodes[x+1,y+1], controlNodes[x+1,y], controlNodes[x,y]);
}
}
}
/* Creer les colliders pour une version 2D */
/* void Generate2DColliders() {
EdgeCollider2D[] currentColliders = gameObject.GetComponents<EdgeCollider2D> ();
for (int i = 0; i < currentColliders.Length; i++) {
Destroy(currentColliders[i]);
}
CalculateMeshOutlines ();
foreach (List<int> outline in contours) {
EdgeCollider2D edgeCollider = gameObject.AddComponent<EdgeCollider2D>();
Vector2[] edgePoints = new Vector2[outline.Count];
for (int i =0; i < outline.Count; i ++) {
edgePoints[i] = new Vector2(vertices[outline[i]].x,vertices[outline[i]].z);
}
edgeCollider.points = edgePoints;
}
}
*/
/* A partir d'un carre et de ses node on construit des triangles en liants les nodes actives entre elles pour avoir une meilleur qualité de map */
void TriangulationCarre(Carre carre) {
/* Chaque configuration des carrés reprensente toutes les combinaisons possible avec 4 nodes de controles
* Une node active signifira qu'il y a mur pres de celle-ci et donc on on entourera cette node on liant les nodes autours entre elles
* Cela va former plusieurs triangle au sein du carré et donc obtenir des formes interessantes pour une cave.
* meshAvecNode va creer ces triangle en fonction des node selectionnés
*/
switch (carre.configuration) {
case 0:
break;
/* 1 points */
case 1:
mesh2DAvecNode(carre.centreGauche, carre.centreBas, carre.basGauche);
break;
case 2:
mesh2DAvecNode(carre.basDroit, carre.centreBas, carre.centreDroit);
break;
case 4:
mesh2DAvecNode(carre.hautDroit, carre.centreDroit, carre.centreHaut);
break;
case 8:
mesh2DAvecNode(carre.hautGauche, carre.centreHaut, carre.centreGauche);
break;
/* 2 points */
case 3:
mesh2DAvecNode(carre.centreDroit, carre.basDroit, carre.basGauche, carre.centreGauche);
break;
case 6:
mesh2DAvecNode(carre.centreHaut, carre.hautDroit, carre.basDroit, carre.centreBas);
break;
case 9:
mesh2DAvecNode(carre.hautGauche, carre.centreHaut, carre.centreBas, carre.basGauche);
break;
case 12:
mesh2DAvecNode(carre.hautGauche, carre.hautDroit, carre.centreDroit, carre.centreGauche);
break;
case 5:
mesh2DAvecNode(carre.centreHaut, carre.hautDroit, carre.centreDroit, carre.centreBas, carre.basGauche, carre.centreGauche);
break;
case 10:
mesh2DAvecNode(carre.hautGauche, carre.centreHaut, carre.centreDroit, carre.basDroit, carre.centreBas, carre.centreGauche);
break;
/* 3 points */
case 7:
mesh2DAvecNode(carre.centreHaut, carre.hautDroit, carre.basDroit, carre.basGauche, carre.centreGauche);
break;
case 11:
mesh2DAvecNode(carre.hautGauche, carre.centreHaut, carre.centreDroit, carre.basDroit, carre.basGauche);
break;
case 13:
mesh2DAvecNode(carre.hautGauche, carre.hautDroit, carre.centreDroit, carre.centreBas, carre.basGauche);
break;
case 14:
mesh2DAvecNode(carre.hautGauche, carre.hautDroit, carre.basDroit, carre.centreBas, carre.centreGauche);
break;
/* 4 points: */
case 15:
mesh2DAvecNode(carre.hautGauche, carre.hautDroit, carre.basDroit, carre.basGauche);
/* Comme il s'agit d'un pur carre de mur (et donc aucun contact avec une piece), ce ne peut etre un contour*/
sommetsVus.Add(carre.hautGauche.sommetIndex);
sommetsVus.Add(carre.hautDroit.sommetIndex);
sommetsVus.Add(carre.basDroit.sommetIndex);
sommetsVus.Add(carre.basGauche.sommetIndex);
break;
}
}
public void initialiserPieceTest()
{
Carre carre = new Carre();
for (int i = 0; i < carre.hauteurPiece; i++)
{
for (int j = 0; j < carre.largeurPiece; j++)
{
if (i == 1 || i == 2)
{
if (j > 0 && j < 3)
{
Assert.AreEqual(true, carre.representation[j, i].estColore);
}
}
}
}
}
public void TournerTest()
{
Carre carre = new Carre();
carre.Tourner(); // La méthode tourner n'a rien fait normalement
for (int i = 0; i < carre.hauteurPiece; i++)
{
for (int j = 0; j < carre.largeurPiece; j++)
{
// Les cases colorées sont normalement les même qu'a l'initialisation
if (i == 1 || i == 2)// Je test que la pièce n'a pas tournée
{
if (j > 0 && j < 3)
{
Assert.AreEqual(true, carre.representation[j, i].estColore);
}
}
}
}
}
public void peuxTournerTest()
{
Carre carre = new Carre();
bool reponse = carre.peuxTourner(2); // Je vérifie que la pièce ne peux pas tourner si le plateau n'existe pas
Assert.AreEqual(false, reponse);
}
public void PeuxDescendreTest()
{
Carre carre = new Carre();
Assert.AreEqual(false, carre.PeuxDescendre()); // On ne peux pas descendre la pièce si le plateau est null (n'existe pas)
}
public void peuxDeplacerTest()
{
Carre carre = new Carre();
Assert.AreEqual(false, carre.peuxDeplacer(-1)); // On ne peux pas déplacer la pièce si le plateau n'existe pas
Assert.AreEqual(false, carre.peuxDeplacer(1));
}
