private void WhileDeplacement(Axe axe, Tuile tuileCourante, int noSerie)
{
Func <Tuile, int> getCoordFunction;
switch (axe)
{
case Axe.Y:
getCoordFunction = t => t.PositionCourante.Y;
break;
case Axe.X:
getCoordFunction = t => t.PositionCourante.X;
break;
default:
throw new ArgumentOutOfRangeException("Axe");
}
while (getCoordFunction(tuileCourante) != noSerie)
{
this.DeplacerTuileVersDirection(
tuileCourante,
(Direction)(Math.Sign(getCoordFunction(tuileCourante) - noSerie - Convert.ToInt32(getCoordFunction(tuileCourante) < noSerie)) * (int)axe)
);
}
}
private void RapprocherTuileVide(Tuile tuile)
{
int[] coordonnees = new int[2];
int[] coordonneesVide = new int[2];
Direction[] directions = new Direction[2];
if (tuile.PositionCourante.X < ct.PositionVide.X)
{
coordonnees[0] = Math.Min(tuile.PositionCourante.Y + 1, ct.Hauteur - 1);
coordonneesVide[0] = ct.PositionVide.Y;
directions[0] = Direction.Haut;
coordonnees[1] = Math.Min(tuile.PositionCourante.X, ct.Largeur - 1);
coordonneesVide[1] = ct.PositionVide.X;
directions[1] = Direction.Gauche;
}
else
{
coordonnees[0] = Math.Min(tuile.PositionCourante.X + 1, ct.Largeur - 1);
coordonneesVide[0] = ct.PositionVide.X;
directions[0] = Direction.Gauche;
coordonnees[1] = Math.Min(tuile.PositionCourante.Y, ct.Hauteur - 1);
coordonneesVide[1] = ct.PositionVide.Y;
directions[1] = Direction.Haut;
}
for (int i = 0; i < coordonnees.Length; i++)
{
this.RapprocherTuileVideSingleDirection(coordonnees[i], coordonneesVide[i], directions[i], i);
}
}
public void EchangerAvecVide(Position posEchange)
{
Tuile tuileTempo = this[this.PositionVide];
if (tuileTempo.DistanceFrom(posEchange) > 1)
{
throw new InvalidOperationException("On ne peut pas échanger avec la cellule vide une case qui ne se trouve pas à côté de la case vide");
}
if (!this.PositionVide.Equals(posEchange))
{
this[this.PositionVide] = this[posEchange];
this[posEchange] = tuileTempo;
this.PositionVide = posEchange;
if (!this.isShuffling)
{
this.NbDeplacementsResolution++;
if (this.wait > 0)
{
System.Threading.Thread.Sleep(wait);
}
}
}
}
private void RemplirCasseTete()
{
for (int j = 0; j < this.Hauteur; j++)
{
for (int i = 0; i < this.Largeur && j + i < this.Hauteur + this.Largeur - 2; i++)
{
this[j, i] = new Tuile(i, j, this.ObtenirCaractereRangee(i), (ConsoleColor)15 - j % 8, (ConsoleColor)(j / 8));
}
}
this.PositionVide = new Position(this.Largeur - 1, this.Hauteur - 1);
this[this.PositionVide] = new Tuile(this.PositionVide, '☻', ConsoleColor.Black, ConsoleColor.Black);
}
private void DeplacerTuileToPosition(Tuile tuileCourante, int noRangee, int noColonne, bool gererVide = true)
{
if (tuileCourante.PositionCourante.Equals(noColonne, noRangee))
{
return;
}
this.RapprocherTuileVide(tuileCourante);
if (noRangee >= tuileCourante.PositionCourante.Y && gererVide)
{
if (tuileCourante.PositionCourante.X > ct.PositionVide.X)
{
this.EchangerAvecVide(tuileCourante.PositionCourante.Offset(-1, 0));
this.EchangerAvecVide(tuileCourante.PositionCourante);
}
else if (tuileCourante.PositionCourante.Y < ct.PositionVide.Y)
{
this.EchangerAvecVide(Direction.Haut);
}
this.WhileDeplacement(Axe.Y, tuileCourante, noRangee);
this.DeplacerTuileVersDirection(
tuileCourante,
(Direction)(Math.Sign(tuileCourante.PositionCourante.Y - noRangee - 2)),
true
);
}
else if (tuileCourante.PositionCourante.Y > ct.PositionVide.Y)
{
this.EchangerAvecVide(Direction.Bas);
}
this.WhileDeplacement(Axe.X, tuileCourante, noColonne);
if (ct.PositionVide.X == tuileCourante.PositionCourante.X - 1 && tuileCourante.PositionCourante.X == noColonne)
{
this.DeplacerTuileVersDirection(
tuileCourante,
(Direction)(Math.Sign(tuileCourante.PositionCourante.X - noColonne - 2) * 2),
true
);
}
this.WhileDeplacement(Axe.Y, tuileCourante, noRangee);
}
private void DeplacerTuileVersDirection(Tuile tuile, Direction direction, bool tuileImmobile = false)
{
Axe axe = (Axe)Math.Abs((int)direction);
Direction directionPerpendic = PlacerVidePourAxe(axe, tuile.PositionCourante);
if (axe == Axe.Y && tuile.PositionCourante.X == ct.Largeur - 1 ||
axe == Axe.X && tuile.PositionCourante.Y == ct.Hauteur - 1)
{
directionPerpendic = this.InverserDirection(directionPerpendic);
}
Position destination = this.GetPositionRelative(tuile.PositionCourante, direction);
if (destination.Equals(ct.PositionVide))
{
this.EchangerAvecVide(tuile.PositionCourante);
return;
}
if (ct.PositionVide.Equals(this.GetPositionRelative(tuile.PositionCourante, this.InverserDirection(direction))))
{
this.EchangerAvecVide(directionPerpendic);
}
while (!this.VideEstEgalPourAxe(destination, axe))
{
this.EchangerAvecVide(direction);
}
if (!ct.PositionVide.Equals(this.GetPositionRelative(tuile.PositionCourante, direction)))
{
this.EchangerAvecVide(this.InverserDirection(directionPerpendic));
}
if (!tuileImmobile)
{
this.EchangerAvecVide(this.InverserDirection(direction));
}
}
private Tuile PlacerDernieresTuiles(Tuile tuileCourante)
{
Axe axe = (Axe)(Convert.ToInt32(tuileCourante.PositionDepart.X == ct.Largeur - 2) + 1);
Direction perpendic = this.ObtenirDirectionPerpendic(axe);
bool flip = axe != Axe.X;
int tailleCote = (!flip ? ct.Largeur : ct.Hauteur) - 1;
Func <Position, int> getCoord1, getCoord2;
switch (axe)
{
case Axe.X:
getCoord1 = t => t.X;
getCoord2 = t => t.Y;
break;
case Axe.Y:
getCoord1 = t => t.Y;
getCoord2 = t => t.X;
break;
default:
throw new ArgumentOutOfRangeException("Axe");
}
Tuile tuileCourante2 = this.dictTuiles[tuileCourante.PositionDepart.Offset(1, 0, flip)];
if (tuileCourante2.EstBienPlacee() && !tuileCourante.EstBienPlacee())
{
this.DeplacerSerieFromVide(this.InverserDirection((Direction)axe), getCoord1(tuileCourante.PositionDepart) - getCoord1(ct.PositionVide));
this.DeplacerSerieFromVide(perpendic, getCoord2(tuileCourante.PositionDepart.Offset(0, 1, flip)) - getCoord2(ct.PositionVide));
this.RotationCasseTete(1, -1, -3, flip);
}
if (tuileCourante.PositionCourante.Equals(tuileCourante2.PositionDepart))
{
this.DeplacerSerieFromVide(this.InverserDirection((Direction)axe), getCoord1(tuileCourante.PositionDepart) - getCoord1(ct.PositionVide));
this.DeplacerSerieFromVide(perpendic, getCoord2(tuileCourante.PositionDepart) - getCoord2(ct.PositionVide));
this.RotationCasseTete(1, 2, 3, flip);
}
if (tuileCourante.PositionDepart.Equals(ct.PositionVide))
{
if (!tuileCourante2.EstBienPlacee() || !tuileCourante.PositionCourante.Equals(tuileCourante2.PositionDepart.Offset(1, 0, flip)))
{
this.EchangerAvecVide(perpendic);
}
else
{
this.RotationCasseTete(1, 3, -6, flip);
}
}
if (!tuileCourante.EstBienPlacee() || !tuileCourante2.EstBienPlacee())
{
if (tuileCourante.EstBienPlacee())
{
if (ct.PositionVide.Equals(tuileCourante2.PositionDepart))
{
this.RotationCasseTete(-1, 1, -3, flip);
}
else
{
this.DeplacerSerieFromVide(this.InverserDirection((Direction)axe), getCoord1(tuileCourante.PositionDepart) - getCoord1(ct.PositionVide));
this.DeplacerSerieFromVide(perpendic, getCoord2(tuileCourante.PositionDepart) - getCoord2(ct.PositionVide));
}
this.RotationCasseTete(1, 2, 5, flip);
}
this.DeplacerTuileToPosition(tuileCourante2, tuileCourante.PositionDepart);
this.DeplacerTuileToPosition(tuileCourante, tuileCourante.PositionDepart.Offset(0, 1, flip));
if (getCoord1(ct.PositionVide) < tailleCote - 1)
{
this.RotationCasseTete(tailleCote - getCoord1(ct.PositionVide) - 1, 1, getCoord1(ct.PositionVide) - tailleCote, flip);
}
if (getCoord1(ct.PositionVide) == tailleCote)
{
this.DeplacerSerieFromVide(this.InverserDirection(perpendic), getCoord2(ct.PositionVide) - getCoord2(tuileCourante2.PositionDepart) - 1);
this.RotationCasseTete(-1, -1, -3, flip);
}
else
{
this.DeplacerSerieFromVide(this.InverserDirection(perpendic), getCoord2(ct.PositionVide) - getCoord2(tuileCourante.PositionDepart) - 2);
this.RotationCasseTete(1, -2, 5, flip);
}
}
return(tuileCourante2);
}
private void DeplacerTuileToPosition(Tuile tuileCourante, Position positionDestination, bool gererVide = true)
{
this.DeplacerTuileToPosition(tuileCourante, positionDestination.Y, positionDestination.X, gererVide);
}
private void DeplacerTuileToPosition(Tuile tuileCourante, bool gererVide = true)
{
this.DeplacerTuileToPosition(tuileCourante, tuileCourante.PositionDepart, gererVide);
}
