/// <summary>
/// Etat de la main à afficher
/// </summary>
public void ChangerCartes(Joueur expediteur, EtatMain etatDeLaMain)
{
_etatDeLaMain = etatDeLaMain;
_joueur = expediteur.Clone() as Joueur;
ChangerTourDeJeu(_joueur.TourDeJeu);
if (_etatDeLaMain != EtatMain.PasDeCartes)
{
_joueur.Carte1 = expediteur.Carte1;
_joueur.Carte2 = expediteur.Carte2;
}
else
{
// Il faut impérativement enlever le style mis sur la grille sinon les cartes ne veulent pas s'effacer !!!!!
grdCartes.Style = null;
lblDerniereAction.Content = string.Empty;
}
this.lblJoueur.Content = _joueur.Nom;
MettreAJourImageCarteSelonEtat();
try
{
this.lblTapis.Content = string.Format(OutilsTraduction.Traducteur.Traduire("TapisJoueur"), _joueur.TapisJoueur - _joueur.Mise);
this.lblMise.Content = string.Format(OutilsTraduction.Traducteur.Traduire("MiseJoueur"), _joueur.Mise);
}
catch (Exception ex)
{
logClient.Debug("Erreur lors de la traduction des informations du joueur : " + ex.Message);
throw new Exception("Erreur de traduction : ChangerCartes", ex);
}
this.imgDonneur.Visibility = _joueur.EstDealer() ? Visibility.Visible : Visibility.Hidden;
this.imgPetiteBlind.Visibility = _joueur.EstPetiteBlind() ? Visibility.Visible : Visibility.Hidden;
this.imgGrosseBlind.Visibility = _joueur.EstGrosseBlind() ? Visibility.Visible : Visibility.Hidden;
}
private void LancerEvtChangementInfosJoueur(string nom, EtatMain etatDeLaMain, CartePoker carte1, CartePoker carte2, int?pot)
{
if (ChangementInfosJoueur != null)
{
ChangementInfosJoueur(_listeJoueurs[nom], etatDeLaMain, carte1, carte2, pot);
}
}
/// <summary>
/// Réception d'un regard de carte
/// </summary>
/// <param name="joueurRegard">Le joueur regarde sa carte</param>
/// <param name="regard">Début ou fin du regard</param>
public void RecevoirRegard(Joueur expediteur, EtatMain etatDeLaMain)
{
if (Regard != null)
{
Regard(expediteur, etatDeLaMain);
}
}
/// <summary>
/// Changement des infos d'un joueur
/// </summary>
/// <param name="joueurAChanger">Le joueur & ses infos</param>
/// <param name="etatDeLaMain">L'etat de la main à afficher</param>
/// <param name="carte1">Carte1 éventuellement</param>
/// <param name="carte2">Carte2 éventuellement</param>
/// <param name="pot">Le pot</param>
public virtual void ChangerJoueur(Joueur joueurAChanger, EtatMain etatDeLaMain, CartePoker carte1, CartePoker carte2, int?pot)
{
if (joueurAChanger == _bot)
{
_bot.Carte1 = carte1;
_bot.Carte2 = carte2;
}
}
/// <summary>
/// Modification des propriétés d'un joueur
/// </summary>
/// <param name="joueurAChanger">Les nouvelles infos du joueur</param>
/// <param name="etatDeLaMain">Le nouvel etat de sa main</param>
public void ModifierCartesJoueur(Joueur joueurAChanger, EtatMain etatDeLaMain)
{
if (etatDeLaMain == EtatMain.PasDeCartes)
{
_listJoueurs[joueurAChanger].ChangerDerniereAction(string.Empty);
}
else
{
_listJoueurs[joueurAChanger].ChangerDerniereAction(RecupererLibelleDerniereAction(joueurAChanger));
}
_listJoueurs[joueurAChanger].ChangerCartes(joueurAChanger, etatDeLaMain);
}
// Start is called before the first frame update
void Start()
{
controller = new Controller();
currentStateMainD = EtatMain.MAINOUVERTE;
previousStateMainD = EtatMain.MAINOUVERTE;
currentStateMainG = EtatMain.MAINOUVERTE;
previousStateMainG = EtatMain.MAINOUVERTE;
currentPositionMainD = paumeMainD.transform.position;
previousPositionMainD = currentPositionMainD;
currentPositionMainG = paumeMainG.transform.position;
previousPositionMainG = currentPositionMainG;
}
/// <summary>
/// Ajout d'un joueur (pas de changment
/// </summary>
/// <param name="joueurAAjouter">Le joueur à ajouter</param>
public void AjouterJoueur(Joueur joueurAAjouter, EtatMain etatDeLaMain, int positionTable)
{
// Si nécessaire, on modifie toutes les positions des joueurs précédents
foreach (JoueurControl jcJoueur in _listJoueurs.Values)
{
if (positionTable <= jcJoueur.PositionTable)
{
jcJoueur.PositionTable++;
}
}
JoueurControl cntr = new JoueurControl();
cntr.PositionTable = positionTable;
_listJoueurs[joueurAAjouter] = cntr;
cntr.CarteRegardee += new JoueurControl.CarteRegardeeEventHandler(cntr_CarteRegardee);
ModifierJoueur(joueurAAjouter);
this.Children.Add(cntr);
}
/// <summary>
/// Modification des infos d'un joueur + les cartes + le pot
/// </summary>
/// <param name="joueurAChanger"></param>
/// <param name="carte1"></param>
/// <param name="carte2"></param>
/// <param name="pot"></param>
public void ChangerJoueur(Joueur joueurAChanger, EtatMain etatDeLaMain, CartePoker carte1, CartePoker carte2, int?pot)
{
logClient.Debug("Methode 'ChangerJoueur'");
logClient.Debug(" Joueur = " + joueurAChanger.Nom);
logClient.Debug(" DerniereAction = " + joueurAChanger.DerniereAction.ToString());
logClient.Debug(" Tapis = " + joueurAChanger.TapisJoueur.ToString());
logClient.Debug(" JeterCartes = " + joueurAChanger.JeterCartes.ToString());
logClient.Debug(" TourDeJeu = " + joueurAChanger.TourDeJeu.ToString());
logClient.Debug(" EtatMain = " + etatDeLaMain);
logClient.Debug(" Bouton = " + joueurAChanger.Bouton.ToString());
logClient.Debug(" Carte1 = " + carte1);
logClient.Debug(" Carte2 = " + carte2);
if (pot.HasValue)
{
logClient.Debug(" Pot = " + pot.Value.ToString());
}
if (ChangementInfosJoueur != null)
{
ChangementInfosJoueur(joueurAChanger, etatDeLaMain, carte1, carte2, pot);
}
}
/// <summary>
/// Réception d'un regard : on sait quel est le joueur qui regarde ses cartes
/// </summary>
/// <param name="joueurRegard">Le joueur qui regarde</param>
/// <param name="etatDeLaMain"></param>
public virtual void RecevoirRegard(Joueur joueurRegard, EtatMain etatDeLaMain)
{
}
//après avoir déterminer les états des mains, on gère les sorts
public void GestionSort()
{
if (currentStateMainD == EtatMain.ANNULATION)
{
if (currentSpellMainD != null)
{
currentSpellMainD.AnnulationSort();
}
return;
}
if (currentStateMainG == EtatMain.ANNULATION)
{
if (currentSpellMainG != null)
{
currentSpellMainG.AnnulationSort();
}
return;
}
//mains parallèles verticalement
if (currentStateMainD == currentStateMainG && currentStateMainD == EtatMain.MAINSPARALLELESY)
{
if (mainParalleles && hadooken)
{
//instancier le sort dans la main droite
currentSpellMainD = poolingManager.Incantation(Sort.HADOOKEN, paumeMainD, offsetPaumeD);
currentSpellMainD.Incantation();
starterMainD = StarterSpell.SORTPAUME;
currentStateMainD = EtatMain.SORTENCOURS;
}
else
{
if (mainParallelesGauche && hadooken)
{
//instancier le sort dans la main gauche
currentSpellMainG = poolingManager.Incantation(Sort.HADOOKEN, paumeMainG, offsetPaumeG);
currentSpellMainG.Incantation();
starterMainG = StarterSpell.SORTPAUME;
currentStateMainG = EtatMain.SORTENCOURS;
}
}
mainParalleles = false;
mainParallelesGauche = false;
return;
}
//Main Droite
if (currentStateMainD == EtatMain.MAINOUVERTE && previousStateMainD == EtatMain.MAINFERMEE && bouleDeFeu)
{
//instancier le sort dans la main droite
currentSpellMainD = poolingManager.Incantation(Sort.BOULEDEFEU, paumeMainD, offsetPaumeD);
currentSpellMainD.Incantation();
currentStateMainD = EtatMain.SORTENCOURS;
starterMainD = StarterSpell.SORTPAUME;
}
else
{
if (currentStateMainD == EtatMain.INDEXONLY && (previousStateMainD == EtatMain.MAINOUVERTE || previousStateMainD == EtatMain.MAINFERMEE) && bouleDeLaMort)
{
//instancier le sort dans la main droite
currentSpellMainD = poolingManager.Incantation(Sort.BOULEDELAMORT, indexMainD, offsetIndexD);
currentSpellMainD.Incantation();
currentStateMainD = EtatMain.SORTENCOURS;
starterMainD = StarterSpell.SORTINDEX;
}
else
{
if (currentStateMainD == EtatMain.ALLBUTTHUMB && (previousStateMainD == EtatMain.MAINOUVERTE || previousStateMainD == EtatMain.MAINFERMEE) && laser)
{
currentSpellMainD = poolingManager.Incantation(Sort.LASER, paumeMainD, offsetDosMainD);
currentSpellMainD.Incantation();
currentStateMainD = EtatMain.SORTENCOURS;
starterMainD = StarterSpell.SORTDOSMAIN;
}
}
}
//Main Gauche
if (currentStateMainG == EtatMain.MAINOUVERTE && previousStateMainG == EtatMain.MAINFERMEE && bouleDeFeu)
{
//instancier le sort dans la main gauche
currentSpellMainG = poolingManager.Incantation(Sort.BOULEDEFEU, paumeMainG, offsetPaumeG);
currentSpellMainG.Incantation();
currentStateMainG = EtatMain.SORTENCOURS;
starterMainG = StarterSpell.SORTPAUME;
}
else
{
if (currentStateMainG == EtatMain.INDEXONLY && (previousStateMainG == EtatMain.MAINOUVERTE || previousStateMainG == EtatMain.MAINFERMEE) && bouleDeLaMort)
{
//instancier le sort dans la main gauche
currentSpellMainG = poolingManager.Incantation(Sort.BOULEDELAMORT, indexMainG, offsetIndexG);
currentSpellMainG.Incantation();
currentStateMainG = EtatMain.SORTENCOURS;
starterMainG = StarterSpell.SORTINDEX;
}
else
{
if (currentStateMainG == EtatMain.ALLBUTTHUMB && (previousStateMainG == EtatMain.MAINOUVERTE || previousStateMainG == EtatMain.MAINFERMEE) && laser)
{
currentSpellMainG = poolingManager.Incantation(Sort.LASER, paumeMainG, offsetDosMainG);
currentSpellMainG.Incantation();
currentStateMainG = EtatMain.SORTENCOURS;
starterMainG = StarterSpell.SORTDOSMAIN;
}
}
}
}
//fonction pour déterminer l'état de la main
public void DetermineEtatMain(bool droit)
{
//déterminer si les mains sont parallèles et ouvertes
if ((mainParalleles || mainParallelesGauche) && currentStateMainD == EtatMain.MAINOUVERTE && currentStateMainG == EtatMain.MAINOUVERTE)
{
previousStateMainD = currentStateMainD;
currentStateMainD = EtatMain.MAINSPARALLELESY;
previousStateMainG = currentStateMainG;
currentStateMainG = EtatMain.MAINSPARALLELESY;
return;
}
if (droit)
{
if (currentStateMainD == EtatMain.LANCEMENT)
{
if (velociteMainD < seuilVitesseLancement)
{
LancerSort(true);
previousStateMainD = currentStateMainD;
currentStateMainD = EtatMain.ANNULATION;
return;
}
return;
}
//s'il n'y a aucun sort dans la main
if (currentStateMainD != EtatMain.SORTENCOURS)
{
//récupération des distances entre les doigts et le centre de la paume
List <float> listeDistance = new List <float>();
listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, pouceMainD.position));
listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, indexMainD.position));
listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, majeurMainD.position));
listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, annulaireMainD.position));
listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, auriculaireMainD.position));
if (listeDistance[0] > seuilPouce && listeDistance[1] > seuilIndex && listeDistance[2] > seuilMajeur && listeDistance[3] > seuilAnnulaire && listeDistance[4] > seuilAuriculaire)
{
previousStateMainD = currentStateMainD;
currentStateMainD = EtatMain.MAINOUVERTE;
return;
}
else
{
if (listeDistance[0] < seuilPouce && listeDistance[1] > seuilIndex && listeDistance[2] < seuilMajeur && listeDistance[3] < seuilAnnulaire && listeDistance[4] < seuilAuriculaire)
{
//si la main est fermée suite à une annulation, l'état ne change pas
if (currentStateMainD == EtatMain.ANNULATION && (previousStateMainD == EtatMain.ANNULATION || previousStateMainD == EtatMain.SORTENCOURS))
{
return;
}
previousStateMainD = currentStateMainD;
currentStateMainD = EtatMain.INDEXONLY;
return;
}
else
{
if (listeDistance[0] < seuilPouce && listeDistance[1] < seuilIndex && listeDistance[2] < seuilMajeur && listeDistance[3] < seuilAnnulaire && listeDistance[4] < seuilAuriculaire)
{
//si la main est fermée suite à une annulation, l'état ne change pas
if (currentStateMainD == EtatMain.ANNULATION && (previousStateMainD == EtatMain.ANNULATION || previousStateMainD == EtatMain.SORTENCOURS))
{
return;
}
previousStateMainD = currentStateMainD;
currentStateMainD = EtatMain.MAINFERMEE;
return;
}
else
{
if (listeDistance[0] < seuilPouce && listeDistance[1] > seuilIndex && listeDistance[2] > seuilMajeur && listeDistance[3] > seuilAnnulaire && listeDistance[4] > seuilAuriculaire)
{
if (currentStateMainD == EtatMain.ANNULATION && (previousStateMainD == EtatMain.ANNULATION || previousStateMainD == EtatMain.SORTENCOURS))
{
return;
}
previousStateMainD = currentStateMainD;
currentStateMainD = EtatMain.ALLBUTTHUMB;
return;
}
else
{
//par défaut la main est ouverte
previousStateMainD = currentStateMainD;
currentStateMainD = EtatMain.MAINOUVERTE;
return;
}
}
}
}
}
else
{
//s'il y a un sort dans la main droite
//récupération des distances entre les doigts et le centre de la paume
List <float> listeDistance = new List <float>();
listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, pouceMainD.position));
listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, indexMainD.position));
listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, majeurMainD.position));
listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, annulaireMainD.position));
listeDistance.Add(Vector3.Distance(paumeMainD.transform.position, auriculaireMainD.position));
if (listeDistance[0] < seuilPouce && listeDistance[1] < seuilIndex && listeDistance[2] < seuilMajeur && listeDistance[3] < seuilAnnulaire && listeDistance[4] < seuilAuriculaire)
{
previousStateMainD = EtatMain.ANNULATION;
currentStateMainD = EtatMain.ANNULATION;
return;
}
//si on dépasse une certaine vélocité, on passe en lancement
if (velociteMainD > seuilVitesseLancement)
{
previousStateMainD = currentStateMainD;
currentStateMainD = EtatMain.LANCEMENT;
}
}
}
else
{
if (currentStateMainG == EtatMain.LANCEMENT)
{
if (velociteMainG < seuilVitesseDepart)
{
LancerSort(false);
previousStateMainG = currentStateMainG;
currentStateMainG = EtatMain.MAINOUVERTE;
return;
}
return;
}
//s'il n'y a aucun sort dans la main
if (currentStateMainG != EtatMain.SORTENCOURS)
{
//récupération des distances entre les doigts et le centre de la paume
List <float> listeDistance = new List <float>();
listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, pouceMainG.position));
listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, indexMainG.position));
listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, majeurMainG.position));
listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, annulaireMainG.position));
listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, auriculaireMainG.position));
//analyse des résultats
if (listeDistance[0] > seuilPouce && listeDistance[1] > seuilIndex && listeDistance[2] > seuilMajeur && listeDistance[3] > seuilAnnulaire && listeDistance[4] > seuilAuriculaire)
{
previousStateMainG = currentStateMainG;
currentStateMainG = EtatMain.MAINOUVERTE;
return;
}
else
{
if (listeDistance[0] < seuilPouce && listeDistance[1] > seuilIndex && listeDistance[2] < seuilMajeur && listeDistance[3] < seuilAnnulaire && listeDistance[4] < seuilAuriculaire)
{
if (currentStateMainG == EtatMain.ANNULATION && (previousStateMainG == EtatMain.ANNULATION || previousStateMainG == EtatMain.SORTENCOURS))
{
return;
}
previousStateMainG = currentStateMainG;
currentStateMainG = EtatMain.INDEXONLY;
return;
}
else
{
if (listeDistance[0] < seuilPouce && listeDistance[1] < seuilIndex && listeDistance[2] < seuilMajeur && listeDistance[3] < seuilAnnulaire && listeDistance[4] < seuilAuriculaire)
{
if (currentStateMainG == EtatMain.ANNULATION && (previousStateMainG == EtatMain.ANNULATION || previousStateMainG == EtatMain.SORTENCOURS))
{
return;
}
previousStateMainG = currentStateMainG;
currentStateMainG = EtatMain.MAINFERMEE;
return;
}
else
{
if (listeDistance[0] < seuilPouce && listeDistance[1] > seuilIndex && listeDistance[2] > seuilMajeur && listeDistance[3] > seuilAnnulaire && listeDistance[4] > seuilAuriculaire)
{
if (currentStateMainG == EtatMain.ANNULATION && (previousStateMainG == EtatMain.ANNULATION || previousStateMainG == EtatMain.SORTENCOURS))
{
return;
}
previousStateMainG = currentStateMainG;
currentStateMainG = EtatMain.ALLBUTTHUMB;
return;
}
else
{
//par défaut la main est ouverte
previousStateMainG = currentStateMainG;
currentStateMainG = EtatMain.MAINOUVERTE;
return;
}
}
}
}
}
else
{
//s'il y a un sort dans la main gauche
//récupération des distances entre les doigts et le centre de la paume
List <float> listeDistance = new List <float>();
listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, pouceMainG.position));
listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, indexMainG.position));
listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, majeurMainG.position));
listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, annulaireMainG.position));
listeDistance.Add(Vector3.Distance(paumeMainG.transform.position, auriculaireMainG.position));
if (listeDistance[0] < seuilPouce && listeDistance[1] < seuilIndex && listeDistance[2] < seuilMajeur && listeDistance[3] < seuilAnnulaire && listeDistance[4] < seuilAuriculaire)
{
previousStateMainG = EtatMain.ANNULATION;
currentStateMainG = EtatMain.ANNULATION;
return;
}
//si on dépasse une certaine vélocité, on passe en lancement
if (velociteMainG > seuilVitesseLancement)
{
previousStateMainG = currentStateMainG;
currentStateMainG = EtatMain.LANCEMENT;
}
}
}
}
// Update is called once per frame
void Update()
{
previousPositionMainD = currentPositionMainD;
currentPositionMainD = paumeMainD.transform.position;
previousPositionMainG = currentPositionMainG;
currentPositionMainG = paumeMainG.transform.position;
var v = currentPositionMainD - previousPositionMainD;
v /= Time.deltaTime;
velociteMainD = v.magnitude * 10;
var v2 = currentPositionMainG - previousPositionMainG;
v2 /= Time.deltaTime;
velociteMainG = v2.magnitude * 10;
Frame currentFrame = controller.Frame();
nbMainsDetectees = currentFrame.Hands.Count;
if (currentFrame.Hands.Count < 2)
{
if (currentFrame.Hands.Count == 0)
{
currentStateMainG = EtatMain.PERDUE;
previousStateMainG = EtatMain.PERDUE;
if (currentSpellMainG != null)
{
currentSpellMainG.AnnulationSort();
}
currentSpellMainG = null;
currentStateMainD = EtatMain.PERDUE;
previousStateMainD = EtatMain.PERDUE;
if (currentSpellMainD != null)
{
currentSpellMainD.AnnulationSort();
}
currentSpellMainD = null;
}
else
{
if (currentFrame.Hands[0].IsRight)
{
currentStateMainG = EtatMain.PERDUE;
previousStateMainG = EtatMain.PERDUE;
if (currentSpellMainG != null)
{
currentSpellMainG.AnnulationSort();
}
currentSpellMainG = null;
}
else
{
currentStateMainD = EtatMain.PERDUE;
previousStateMainD = EtatMain.PERDUE;
if (currentSpellMainD != null)
{
currentSpellMainD.AnnulationSort();
}
currentSpellMainD = null;
}
}
}
//si on a au moins une main de détectée
if (currentFrame.Hands.Count > 0)
{
foreach (var main in currentFrame.Hands)
{
if (main.IsRight)
{
DetermineEtatMain(true);
}
else
{
DetermineEtatMain(false);
}
}
//gestion des sorts en fonction des états déterminés précédemment
GestionSort();
}
}
/// <summary>
/// Ajout d'un joueur (pas de changment
/// </summary>
/// <param name="joueurAAjouter">Le joueur à ajouter</param>
public void AjouterJoueur(Joueur joueurAAjouter, EtatMain etatDeLaMain)
{
this.AjouterJoueur(joueurAAjouter, etatDeLaMain, this.Children.Count);
}