/// <summary>
/// Pour les changement de direction et pour trouver de quel direction le fantome vient
/// </summary>
/// <param name="déplacement">Le deplacement actuel</param>
protected void TrouverInverse(Déplacement déplacement)
{
switch (déplacement)
{
case Déplacement.Droite:
Origine = Déplacement.Gauche;
break;
case Déplacement.Haut:
Origine = Déplacement.Bas;
break;
case Déplacement.Gauche:
Origine = Déplacement.Droite;
break;
case Déplacement.Bas:
Origine = Déplacement.Haut;
break;
case Déplacement.Arrêt:
break;
default:
throw new ArgumentOutOfRangeException(nameof(déplacement), déplacement, null);
}
}
/// <summary>
/// Instinct de base du fantome, va tente d'aller vers sa destination en trouvant l'axe le plus court
/// </summary>
/// <param name="p_actuel">La position actuel du fantome</param>
/// <param name="p_destination">La Destination du fantome (souvent Pacman)</param>
/// <param name="p_direction">l'orientation du fantome actuel</param>
/// <param name="p_estApeuré">si le fantome est apeure</param>
/// <returns>l'orientation que le fantome doit prendre</returns>
public Déplacement AppliquerInstinct(Coordonnée p_actuel, Coordonnée p_destination, Déplacement p_direction, bool p_estApeuré)
{
Déplacement nouveauDéplacement = AppliquerStratégie(p_actuel, p_destination, p_direction, p_estApeuré);
if (Cadran != DernierCadran && ListeInterdite.Count >= 3)
{
DernierCadran = Cadran;
ListeInterdite.Clear();
}
if (!ListeInterdite.Any())
{
DernierDéplacement = nouveauDéplacement;
}
if (!p_actuel.Equals(DernièreCoordonnée))
{
DernièreCoordonnée = p_actuel;
}
Déplacement déplacementExecuter = CompenserTopographie(p_actuel);
if (Cadran == DernierCadran && DernièreCoordonnée.Equals(p_actuel))
{
ListeInterdite.Clear();
TrouverInverse(déplacementExecuter);
}
return(déplacementExecuter);
}
/// <summary>
/// Permet de calculer dans quel direction se diriger selon la difference en X et Y
/// en etablissant des cadrans comme le plan cartesien
/// La position 0,0 serait la position du fantome sur le plan cartesien
/// et sa destination va etre dans un des 4 cadran
/// (1 = En Haut a Gauche, 2 = En Haut a Droite, 3 = En Bas a Gauche...)
/// </summary>
/// <param name="directionX">La distance en X relative a sa position actuel</param>
/// <param name="directionY">La distance en Y relative a sa position actuel</param>
/// <returns>l'orientation que le fantome doit prendre</returns>
protected Déplacement CalculerOrientation(int directionX, int directionY)
{
Déplacement déplacement = Déplacement.Arrêt;
//Cible Trouvé
if (directionX == 0 && directionY == 0)
{
déplacement = Déplacement.Arrêt;
}
else if (directionX == 0)
{
déplacement = directionY > 0 ? Déplacement.Bas : Déplacement.Haut;
Cadran = 0;
}
else if (directionY == 0)
{
déplacement = directionX > 0 ? Déplacement.Droite : Déplacement.Gauche;
Cadran = 0;
}
//Cadran Supérieur Gauche
else if (directionX < 0 && directionY < 0)
{
déplacement = Math.Abs(directionX) >= Math.Abs(directionY) ? Déplacement.Gauche : Déplacement.Haut;
Cadran = 1;
}
//Cadran Supérieur Droite
else if (directionX > 0 && directionY < 0)
{
déplacement = Math.Abs(directionX) >= Math.Abs(directionY) ? Déplacement.Droite : Déplacement.Haut;
Cadran = 2;
}
//Cadran Inférieur Gauche
else if (directionX < 0 && directionY > 0)
{
déplacement = Math.Abs(directionX) >= Math.Abs(directionY) ? Déplacement.Gauche : Déplacement.Bas;
Cadran = 3;
}
//Cadran Inférieur Droite
else if (directionX > 0 && directionY > 0)
{
déplacement = Math.Abs(directionX) >= Math.Abs(directionY) ? Déplacement.Droite : Déplacement.Bas;
Cadran = 4;
}
return(déplacement);
}
private bool VérifierSiDirectionPlusProbable(Coordonnée p_actuel, Déplacement p_direction)
{
if (ListeInterdite.All(c => c != p_direction) &&
Origine != p_direction &&
VérifierProchaineCase(p_actuel, p_direction))
{
return(true);
}
if (ListeInterdite.All(c => c != p_direction))
{
ListeInterdite.Add(p_direction);
}
return(false);
}
private void DéplacerVoiture()
{
if (DistanceParcourue >= DistanceÀParcourir)
{
++Index;
Déplacement = PointsCentraux[(Index + 1) % PointsCentraux.Count] - PointsCentraux[Index];
DistanceÀParcourir = Déplacement.Length();
DistanceParcourue = 0;
Déplacement = Vector2.Normalize(Déplacement) / 10;
Position = new Vector3(PointsCentraux[Index].X, 0, PointsCentraux[Index].Y);
int signe = Déplacement.Y < 0 ? 0 : 1;
Rotation = new Vector3(0, (float)(Math.Atan(Déplacement.X / Déplacement.Y) + signe * Math.PI), 0);
SphèreDeCollision = new BoundingSphere(Position, RAYON_VOITURE_DUMMY);
}
else
{
Position += new Vector3(Déplacement.X, 0, Déplacement.Y);
SphèreDeCollision = new BoundingSphere(Position, RAYON_VOITURE_DUMMY);
DistanceParcourue += Déplacement.Length();
}
}
private void DessinerAnimable(Déplacement p_déplacement)
{
switch (p_déplacement)
{
case Déplacement.Droite:
{
ListeAnimationDroite[IndiceFrame].MettreAJourCoordonnée(Coordonnée);
ListeAnimationDroite[IndiceFrame].Dessiner();
break;
}
case Déplacement.Haut:
{
ListeAnimationHaut[IndiceFrame].MettreAJourCoordonnée(Coordonnée);
ListeAnimationHaut[IndiceFrame].Dessiner();
break;
}
case Déplacement.Gauche:
{
ListeAnimationGauche[IndiceFrame].MettreAJourCoordonnée(Coordonnée);
ListeAnimationGauche[IndiceFrame].Dessiner();
break;
}
case Déplacement.Bas:
{
ListeAnimationBas[IndiceFrame].MettreAJourCoordonnée(Coordonnée);
ListeAnimationBas[IndiceFrame].Dessiner();
break;
}
default: // On doit tout de meme imprimer meme si on ne bouge pas la droite sera prise dans ce cas
{
ListeAnimationDroite[0].MettreAJourCoordonnée(Coordonnée);
ListeAnimationDroite[0].Dessiner();
break;
}
}
}
/// <summary>
/// Permet de simuler le prochain deplacement et de voir si la
/// prochaine case est valide
/// </summary>
/// <param name="p_actuel">La position actuel</param>
/// <param name="p_déplacement">la direction du deplacement</param>
/// <returns>si le deplacement est valide</returns>
private bool VérifierProchaineCase(Coordonnée p_actuel, Déplacement p_déplacement)
{
int valeurTemp = 0;
switch (p_déplacement)
{
case Déplacement.Droite:
{
valeurTemp = p_actuel.X + TailleCase / 2 + VitesseFantôme;
break;
}
case Déplacement.Haut:
{
valeurTemp = p_actuel.Y - TailleCase / 2 - VitesseFantôme;
break;
}
case Déplacement.Gauche:
{
valeurTemp = p_actuel.X - TailleCase / 2 - VitesseFantôme;
break;
}
case Déplacement.Bas:
{
valeurTemp = p_actuel.Y + TailleCase / 2 + VitesseFantôme;
break;
}
case Déplacement.Arrêt:
break;
default:
throw new ArgumentOutOfRangeException(nameof(p_déplacement), p_déplacement, null);
}
return(Partie.Instance.Grille.VérifierProchaineCaseTraversable(p_actuel, valeurTemp, p_déplacement));
}
/// <summary>
/// Permet d'obtenir la position du pacman dans 4 cases selon sa direction
/// </summary>
/// <param name="p_destination">la position du pacman</param>
/// <param name="p_déplacement">l'orientation du pacman</param>
/// <returns>la position</returns>
private Coordonnée ObtenirCoordonnéeFuture(Coordonnée p_destination, Déplacement p_déplacement)
{
switch (p_déplacement)
{
case Déplacement.Droite:
return(new Coordonnée(p_destination.X + (TailleCase * 4), p_destination.Y));
case Déplacement.Haut:
return(new Coordonnée(p_destination.X, p_destination.Y + (TailleCase * 4)));
case Déplacement.Gauche:
return(new Coordonnée(p_destination.X - (TailleCase * 4), p_destination.Y));
case Déplacement.Bas:
return(new Coordonnée(p_destination.X, p_destination.Y - (TailleCase * 4)));
case Déplacement.Arrêt:
break;
default:
throw new ArgumentOutOfRangeException(nameof(p_déplacement), p_déplacement, null);
}
return(p_destination);
}
/// <summary>
/// Les directives sur l'ordre et les choses a dessiner a chaque Draw()
/// Cache la methode de base pour permettre l'animation de l'intro
/// </summary>
/// <param name="p_cptFrame">le cpt de Frame actuel</param>
public new void DessinerTout(int p_cptFrame)
{
base.DessinerTout(p_cptFrame);
TextFont(CreateFont("PacFont", 40));
m_logoIntro.ForEach(c => c.Dessiner());
TextFont(CreateFont("Microsoft", 40));
Partie.Instance.Pacman.DéplacerPourLogo(p_cptFrame, (m_déplacement));
Partie.Instance.Blinky.DéplacerPourLogo(p_cptFrame, (m_déplacement));
Partie.Instance.Clyde.DéplacerPourLogo(p_cptFrame, (m_déplacement));
Partie.Instance.Pinky.DéplacerPourLogo(p_cptFrame, (m_déplacement));
Partie.Instance.Inky.DéplacerPourLogo(p_cptFrame, (m_déplacement));
if (Partie.Instance.Pacman.Coordonnée.X < -200 || Partie.Instance.Pacman.Coordonnée.X >= Largeur + 200)
{
m_déplacement = (m_déplacement == Déplacement.Droite) ? Déplacement.Gauche : Déplacement.Droite;
bool peur = (m_déplacement == Déplacement.Gauche);
Partie.Instance.Blinky.ModifierÉtatPeur(peur);
Partie.Instance.Clyde.ModifierÉtatPeur(peur);
Partie.Instance.Pinky.ModifierÉtatPeur(peur);
Partie.Instance.Inky.ModifierÉtatPeur(peur);
}
}
/// <summary>
/// Va servir l'animation d'intro (splash) pour faire animer des objets mais de "bypasser" les regles de jeu
/// donc ne verifie pas si le deplacement est valide, va seulement mettre a jour la position
/// </summary>
/// <param name="p_cptFrame">Nombre de fois que Draw() a ete appeler</param>
/// <param name="p_déplacement">La direction du deplacement</param>
public void DéplacerPourLogo(int p_cptFrame, Déplacement p_déplacement)
{
switch (p_déplacement)
{
case Déplacement.Droite:
Coordonnée.X += VitesseDéplacement;
break;
case Déplacement.Haut:
Coordonnée.Y -= VitesseDéplacement;
break;
case Déplacement.Gauche:
Coordonnée.X -= VitesseDéplacement;
break;
case Déplacement.Bas:
Coordonnée.Y += VitesseDéplacement;
break;
case Déplacement.Arrêt:
break;
default:
throw new ArgumentOutOfRangeException(nameof(p_déplacement), p_déplacement, null);
}
if (p_cptFrame % VitesseAnimation == 0)
{
// Remet le cpt a 0 si on depasse le nombre d'animation
// m_listeAnimationHaut pris au hasard etant donner que les 4 listes ont la meme taille
IndiceFrame = ++IndiceFrame % ListeAnimationHaut.Length;
}
DessinerAnimable(p_déplacement);
}
public void Déplacer(Déplacement p_déplacement)
{
ProchainDéplacement = p_déplacement;
}
protected override Déplacement AppliquerStratégie(Coordonnée p_actuel, Coordonnée p_destination, Déplacement p_direction, bool p_estApeuré)
{
int directionX = p_estApeuré ? p_actuel.X - CoordonnéeAléatoire.X : CoordonnéeAléatoire.X - p_actuel.X;
int directionY = p_estApeuré ? p_actuel.Y - CoordonnéeAléatoire.Y : CoordonnéeAléatoire.Y - p_actuel.Y;
if (Math.Abs(directionX) < TailleCase * 4 || Math.Abs(directionY) < TailleCase * 4)
{
CoordonnéeAléatoire = ObtenirPositionAléatoire();
directionX = p_estApeuré ? p_actuel.X - CoordonnéeAléatoire.X : CoordonnéeAléatoire.X - p_actuel.X;
directionY = p_estApeuré ? p_actuel.Y - CoordonnéeAléatoire.Y : CoordonnéeAléatoire.Y - p_actuel.Y;
}
return(CalculerOrientation(directionX, directionY));
}
protected override Déplacement AppliquerStratégie(Coordonnée p_actuel, Coordonnée p_destination, Déplacement p_direction, bool p_estApeuré)
{
int directionX = p_estApeuré ? p_actuel.X - p_destination.X :p_destination.X - p_actuel.X;
int directionY = p_estApeuré ? p_actuel.Y - p_destination.Y : p_destination.Y - p_actuel.Y;
return(CalculerOrientation(directionX, directionY));
}
/// <summary>
/// Va permette de verifier si la prochaine case est une collision avec un objet non traversable comme un mur
/// </summary>
/// <param name="p_coordonnée">les coordonnes actuel de l'objet a verifier</param>
/// <param name="p_valeur">la largeur de son deplacement</param>
/// <param name="p_déplacement">la direction de son deplacement</param>
/// <returns>Si la prochain deplacement est valide, retourne vrai</returns>
public bool VérifierProchaineCaseTraversable(Coordonnée p_coordonnée, int p_valeur, Déplacement p_déplacement)
{
int x = (p_coordonnée.X - (50 + (TailleCase / 2))) / TailleCase;
int y = (p_coordonnée.Y - 90) / TailleCase;
Case prochaineCase;
switch (p_déplacement)
{
case Déplacement.Haut:
{
prochaineCase = m_grille[x][y - 1];
return
(p_coordonnée.X == prochaineCase.ObtenirCoordonnée().X &&
(prochaineCase.EstTraversable || (!prochaineCase.EstTraversable &&
(p_valeur >= (prochaineCase.ObtenirCoordonnée().Y + TailleCase / 2)))));
}
case Déplacement.Bas:
{
prochaineCase = m_grille[x][y + 1];
return
(p_coordonnée.X == prochaineCase.ObtenirCoordonnée().X &&
(prochaineCase.EstTraversable || (!prochaineCase.EstTraversable &&
(p_valeur <= (prochaineCase.ObtenirCoordonnée().Y - TailleCase / 2)))));
}
case Déplacement.Gauche:
{
prochaineCase = m_grille[x - 1][y];
return
(p_coordonnée.Y == prochaineCase.ObtenirCoordonnée().Y &&
(prochaineCase.EstTraversable || (!prochaineCase.EstTraversable &&
(p_valeur >= (prochaineCase.ObtenirCoordonnée().X + TailleCase / 2)))));
}
case Déplacement.Droite:
{
prochaineCase = m_grille[x + 1][y];
return
(p_coordonnée.Y == prochaineCase.ObtenirCoordonnée().Y &&
(prochaineCase.EstTraversable || (!prochaineCase.EstTraversable &&
(p_valeur <= (prochaineCase.ObtenirCoordonnée().X - TailleCase / 2)))));
}
case Déplacement.Arrêt:
break;
default:
throw new ArgumentOutOfRangeException(nameof(p_déplacement), p_déplacement, null);
}
return(false);
}
protected override Déplacement AppliquerStratégie(Coordonnée p_actuel, Coordonnée p_destination, Déplacement p_direction, bool p_estApeuré)
{
if (PositionBoosters == null)
{
GénérerPositionCoin();
}
int directionX = p_estApeuré ? p_actuel.X - PositionBoosters[PositionBoosterActuel].X : PositionBoosters[PositionBoosterActuel].X - p_actuel.X;
int directionY = p_estApeuré ? p_actuel.Y - PositionBoosters[PositionBoosterActuel].Y : PositionBoosters[PositionBoosterActuel].Y - p_actuel.Y;
if (Math.Abs(directionX) < 5 && Math.Abs(directionY) < 5)
{
ProchainePositionChoisit();
directionX = p_estApeuré ? p_actuel.X - PositionBoosters[PositionBoosterActuel].X : PositionBoosters[PositionBoosterActuel].X - p_actuel.X;
directionY = p_estApeuré ? p_actuel.Y - PositionBoosters[PositionBoosterActuel].Y : PositionBoosters[PositionBoosterActuel].Y - p_actuel.Y;
}
return(CalculerOrientation(directionX, directionY));
}
/// <summary>
/// Lorsque le fantome va tenter de se deplacer mais va pris dans un coin
/// En eliminant progressivement les mouvements les plus probables mais impossible
/// on obtient le prochain mouvement valide et on l'execute tant et aussi
/// longtemps que le deplacement de l'instinct de base n'est pas capable d'etre executer
///
/// *** Le retour sur ses pas est toujours l'option la moins probable ***
/// </summary>
/// <param name="p_actuel">La position actuel du fantome</param>
/// <returns>l'orientation que le fantome doit prendre</returns>
public Déplacement CompenserTopographie(Coordonnée p_actuel)
{
if (Origine != DernierDéplacement && !VérifierProchaineCase(p_actuel, DernierDéplacement))
{
switch (DernierDéplacement)
{
case Déplacement.Droite:
{
Déplacement plusProbable = (Cadran == 2) ? Déplacement.Haut : Déplacement.Bas;
Déplacement moinsProbable = (Cadran == 2) ? Déplacement.Bas : Déplacement.Haut;
if (VérifierSiDirectionPlusProbable(p_actuel, plusProbable))
{
return(plusProbable);
}
if (VérifierSiDirectionPlusProbable(p_actuel, moinsProbable))
{
return(moinsProbable);
}
if (VérifierSiDirectionPlusProbable(p_actuel, Déplacement.Gauche))
{
return(Déplacement.Gauche);
}
break;
}
case Déplacement.Haut:
{
Déplacement plusProbable = (Cadran == 1) ? Déplacement.Gauche : Déplacement.Droite;
Déplacement moinsProbable = (Cadran == 1) ? Déplacement.Droite : Déplacement.Gauche;
if (VérifierSiDirectionPlusProbable(p_actuel, plusProbable))
{
return(plusProbable);
}
if (VérifierSiDirectionPlusProbable(p_actuel, moinsProbable))
{
return(moinsProbable);
}
if (VérifierSiDirectionPlusProbable(p_actuel, Déplacement.Bas))
{
return(Déplacement.Bas);
}
break;
}
case Déplacement.Gauche:
{
Déplacement plusProbable = (Cadran == 1) ? Déplacement.Haut : Déplacement.Bas;
Déplacement moinsProbable = (Cadran == 1) ? Déplacement.Bas : Déplacement.Haut;
if (VérifierSiDirectionPlusProbable(p_actuel, plusProbable))
{
return(plusProbable);
}
if (VérifierSiDirectionPlusProbable(p_actuel, moinsProbable))
{
return(moinsProbable);
}
if (VérifierSiDirectionPlusProbable(p_actuel, Déplacement.Droite))
{
return(Déplacement.Droite);
}
break;
}
case Déplacement.Bas:
{
if (VérifierSiDirectionPlusProbable(p_actuel, Déplacement.Haut))
{
return(Déplacement.Haut);
}
Déplacement plusProbable = (Cadran == 3) ? Déplacement.Gauche : Déplacement.Droite;
Déplacement moinsProbable = (Cadran == 3) ? Déplacement.Droite : Déplacement.Gauche;
if (VérifierSiDirectionPlusProbable(p_actuel, plusProbable))
{
return(plusProbable);
}
if (VérifierSiDirectionPlusProbable(p_actuel, moinsProbable))
{
return(moinsProbable);
}
break;
}
case Déplacement.Arrêt:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
else
{
TrouverInverse(DernierDéplacement);
ListeInterdite.Clear();
}
return(DernierDéplacement);
}
public void DéplacerPacMan(Déplacement p_déplacement)
{
Pacman.Déplacer(p_déplacement);
}
/// <summary> /// Chacun des fantomes va devoir appliquer sa propre strategie au deplacement /// </summary> /// <param name="p_actuel">La position actuel du fantome</param> /// <param name="p_destination">La Destination du fantome (souvent Pacman)</param> /// <param name="p_direction">l'orientation du fantome actuel</param> /// <param name="p_estApeuré">si le fantome est apeure</param> /// <returns>l'orientation que le fantome doit prendre</returns> protected abstract Déplacement AppliquerStratégie(Coordonnée p_actuel, Coordonnée p_destination, Déplacement p_direction, bool p_estApeuré);
