//fonction de tir du sort
    public void LancerSort(bool droit)
    {
        //lancer avec la main droite
        if (droit)
        {
            switch (starterMainD)
            {
            case StarterSpell.SORTPAUME:
                var rb = currentSpellMainD.getRigidbody();
                currentSpellMainD.transform.SetParent(null);
                rb.isKinematic = false;
                rb.AddForce(viseeD.right * currentSpellMainD.GetVitesse(), ForceMode.Acceleration);
                currentSpellMainD.LancementSort();
                currentSpellMainD = null;
                break;

            case StarterSpell.SORTINDEX:

                var rbindex = currentSpellMainD.getRigidbody();
                currentSpellMainD.transform.SetParent(null);
                rbindex.isKinematic = false;
                rbindex.AddForce(indexMainD.transform.right * currentSpellMainD.GetVitesse(), ForceMode.Acceleration);
                currentSpellMainD.LancementSort();
                currentSpellMainD = null;
                break;

            case StarterSpell.SORTDOSMAIN:

                var rbdos = currentSpellMainD.getRigidbody();
                currentSpellMainD.transform.SetParent(null);
                rbdos.isKinematic = false;
                rbdos.AddForce(paumeMainD.transform.right * currentSpellMainD.GetVitesse(), ForceMode.Acceleration);
                currentSpellMainD.LancementSort();
                currentSpellMainD = null;
                break;
            }
        }
        else
        {
            //lancer avec la main gauche
            switch (starterMainG)
            {
            case StarterSpell.SORTPAUME:
                var rb = currentSpellMainG.getRigidbody();
                currentSpellMainG.transform.SetParent(null);
                rb.isKinematic = false;
                rb.AddForce(-viseeG.right * currentSpellMainG.GetVitesse(), ForceMode.Acceleration);
                currentSpellMainG.LancementSort();
                currentSpellMainG = null;
                break;

            case StarterSpell.SORTINDEX:

                var rbindex = currentSpellMainG.getRigidbody();
                currentSpellMainG.transform.SetParent(null);
                rbindex.isKinematic = false;
                rbindex.AddForce(-indexMainG.transform.right * currentSpellMainG.GetVitesse(), ForceMode.Acceleration);
                currentSpellMainG.LancementSort();
                currentSpellMainG = null;
                break;

            case StarterSpell.SORTDOSMAIN:

                var rbdos = currentSpellMainG.getRigidbody();
                currentSpellMainG.transform.SetParent(null);
                rbdos.isKinematic = false;
                rbdos.AddForce(-paumeMainG.transform.right * currentSpellMainG.GetVitesse(), ForceMode.Acceleration);
                currentSpellMainG.LancementSort();
                currentSpellMainG = null;
                break;
            }
        }
    }
    //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;
                }
            }
        }
    }
    // 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();
        }
    }