public void doConvert(Ennemi ennemi)
 {
     for (int i = 0; i < ennemi.nbAfterConvertion; i++)
     {
         GameObject essaimAI = GameObject.Instantiate(prefabEssaim, essaimParent);
         essaimAI.transform.position = new Vector3(ennemi.transform.position.x, essaimMaitre.transform.position.y, ennemi.transform.position.z) + ennemi.radius * new Vector3(Random.Range(-1f, 1f), 0, Random.Range(-1f, 1f));
         EssaimAI essaimAiScript = essaimAI.GetComponent <EssaimAI>();
         essaimAiScript.isMaster = false;
         essaimAiScript.master   = essaimMaitre;
         listEssaim.Add(essaimAiScript);
     }
     listEnnemis.Remove(ennemi);
 }
    public void Kill(EssaimAI essaim)
    {
        try
        {
            if (essaim == essaimMaitre)
            {
                listEssaim[0].Die();
                essaimMaitre.isMaster = false;
                Transform  cameraParent  = listEssaim[0].transform.GetChild(1);
                Vector3    savePosition1 = cameraParent.localPosition;
                Quaternion saveRotation1 = cameraParent.localRotation;
                Vector3    savePosition2 = cameraParent.GetChild(0).localPosition;
                Quaternion saveRotation2 = cameraParent.GetChild(0).localRotation;
                Transform  camera        = cameraParent.GetChild(0).GetChild(0);

                Vector3    savePositionCamera = camera.position;
                Quaternion saveRotationCamera = camera.rotation;

                camera.SetParent(null);
                cameraParent.SetParent(null);
                if (listEssaim.Count > 1)
                {
                    essaimMaitre          = listEssaim[1];
                    essaimMaitre.isMaster = true;
                    cameraParent.SetParent(essaimMaitre.transform);
                    cameraParent.localPosition             = savePosition1;
                    cameraParent.localRotation             = saveRotation1;
                    cameraParent.GetChild(0).localPosition = savePosition2;
                    cameraParent.GetChild(0).localRotation = saveRotation2;
                    camera.SetParent(cameraParent.GetChild(0));
                    camera.position = savePositionCamera;
                    camera.rotation = saveRotationCamera;
                }
                else
                {
                    camera.SetParent(null);
                }
                listEssaim.Remove(essaim);
            }
            else
            {
                essaim.Die();
                listEssaim.Remove(essaim);
            }
        }
        catch (System.Exception e)
        {
        }
    }
    public EssaimAI GetTarget(Ennemi ennemi)
    {
        EssaimAI target           = null;
        float    shortestDistance = ennemi.range * ennemi.range;

        foreach (EssaimAI essaim in listEssaim)
        {
            float distance = Vector3.SqrMagnitude(essaim.transform.position - ennemi.transform.position);
            if (distance < shortestDistance)
            {
                target           = essaim;
                shortestDistance = distance;
            }
        }
        return(target);
    }
    public bool isGettingConversion(Ennemi ennemi)
    {
        int nbClose = 0;

        for (int i = 0; i < listEssaim.Count; i++)
        {
            EssaimAI toCompare        = listEssaim[i];
            Vector3  vectorToVoisin   = (toCompare.transform.position - ennemi.transform.position);
            float    distanceToVoisin = vectorToVoisin.sqrMagnitude;
            if (distanceToVoisin < ennemi.radius + distanceToConversion)
            {
                nbClose++;
                if (nbClose >= ennemi.nbToConvert)
                {
                    return(true);
                }
            }
        }
        return(false);
    }
    // Update is called once per frame
    protected void UpdateLoop()
    {
        if (canShoot)
        {
            countDownShoot += Time.deltaTime;
            if (countDownShoot > timeBetweenShoot)
            {
                if (currentTarget == null || Vector3.SqrMagnitude(this.transform.position - currentTarget.transform.position) > range * range)
                {
                    currentTarget = EssaimManager.instance.GetTarget(this);
                }

                if (currentTarget != null)
                {
                    weaponItem.transform.LookAt(new Vector3(currentTarget.transform.position.x, weaponItem.transform.position.y, currentTarget.transform.position.z));


                    currentTarget.HP -= damage;
                    if (currentTarget.HP <= 0)
                    {
                        EssaimManager.instance.Kill(currentTarget);
                    }
                    countDownShoot = 0;
                }
            }
        }



        bool isGettingConvert = EssaimManager.instance.isGettingConversion(this);

        if (isGettingConvert)
        {
            convertionTaux += speedConversion * Time.deltaTime;
        }
        else
        {
            convertionTaux -= speedConversionGoDown * Time.deltaTime;
        }
        if (convertionTaux < 0)
        {
            convertionTaux = 0;
        }

        foreach (Renderer rend in renderers)
        {
            rend.material.color = Color.Lerp(normalColour, Color.red, convertionTaux);
        }


        if (convertionTaux >= 1f)
        {
            Die();

            EssaimManager.instance.score += scoreIfConverted;

            if (type == Type.Civil)
            {
                EssaimManager.nbCivil--;
            }
            if (type == Type.Voiture)
            {
                EssaimManager.nbVoiture--;
            }
            if (type == Type.Bus)
            {
                EssaimManager.nbBus--;
            }
            if (type == Type.Soldat)
            {
                EssaimManager.nbSoldat--;
            }
            if (type == Type.Tank)
            {
                EssaimManager.nbTank--;
            }
        }
    }
    public Vector3 GetDeplacement(EssaimAI essaim)
    {
        Vector3 deplacement = Vector3.zero;

        Vector3 vectorToMaster   = (essaimMaitre.transform.position - essaim.transform.position);
        float   distanceToMaster = vectorToMaster.sqrMagnitude;

        if (distanceToMaster < distanceMinToAvoidMaster)
        {
            deplacement -= avoidMasterPower * vectorToMaster.normalized * (distanceMinToAvoidMaster - distanceToMaster) / distanceMinToAvoidMaster;
        }
        else
        {
            deplacement += Mathf.Clamp(followMasterPower * (distanceToMaster - distanceMinToAvoidMaster), 0f, followMasterMaxForce) * vectorToMaster.normalized;
        }



        for (int i = 0; i < listEssaim.Count; i++)
        {
            EssaimAI toCompare        = listEssaim[i];
            Vector3  vectorToVoisin   = (toCompare.transform.position - essaim.transform.position);
            float    distanceToVoisin = vectorToVoisin.sqrMagnitude;
            if (distanceToVoisin < distanceMinToAvoid)
            {
                deplacement -= avoidOtherPower * vectorToVoisin.normalized * (distanceMinToAvoid - distanceToVoisin) / distanceMinToAvoid;
            }
        }


        for (int i = 0; i < listEnnemis.Count; i++)
        {
            Ennemi  toCompare        = listEnnemis[i];
            Vector3 vectorToEnnemi   = (toCompare.transform.position - essaim.transform.position);
            float   distanceToEnnemi = vectorToEnnemi.sqrMagnitude;
            if (distanceToEnnemi < toCompare.radius)
            {
                deplacement -= avoidThingsToconvertPower * vectorToEnnemi.normalized * (toCompare.radius - distanceToEnnemi) / toCompare.radius;
            }
            else if (distanceToEnnemi < toCompare.radius + radiusToGoTryConvert)
            {
                deplacement += (Mathf.Clamp(attrackedByThingsToconvertPower * (radiusToGoTryConvert - (distanceToEnnemi - toCompare.radius)) / radiusToGoTryConvert, 0f, attrackedByThingsToconvertrMaxForce)) * vectorToEnnemi.normalized;
            }
        }

        if (activateAvoidanceBatiment)
        {
            foreach (Batiment batiment in Map.instance.listBatiments)
            {
                Vector3 vectorToBatiment   = (batiment.transform.position - essaim.transform.position);
                float   distanceToBatiment = vectorToBatiment.sqrMagnitude;
                if (distanceToBatiment < distanceMinToAvoidBatiment)
                {
                    deplacement -= avoidBatimentPower * vectorToBatiment.normalized * (distanceMinToAvoidBatiment - distanceToBatiment) / distanceMinToAvoid;
                }
            }
        }



        return(deplacement);
    }
    // Update is called once per frame
    void Update()
    {
        if (Map.instance.isInit)
        {
            if (!isInit)
            {
                GeneratePopInitial();
            }

            if (listEssaim.Count > 200)
            {
                panelGagner.SetActive(true);
            }
            else if (listEssaim.Count == 0)
            {
                panelPerdu.SetActive(true);
            }
            else
            {
                time  += Time.deltaTime;
                score += Time.deltaTime * (multiplicateurScoreBase + multiplicateurScoreMorForEachMemberOfEssaim * listEssaim.Count);
                if (essaimMaitre != null)
                {
                    miniMapCamera.transform.position = new Vector3(essaimMaitre.transform.position.x, miniMapCameraStartZoom + this.listEssaim.Count * miniMapCameraZoomEveryNewMember, essaimMaitre.transform.position.z);
                }
            }



            float randomCivil   = Random.Range(0, 1f);
            float randomVoiture = Random.Range(0, 1f);
            float randomBus     = Random.Range(0, 1f);
            float randomSoldat  = Random.Range(0, 1f);
            float randomTank    = Random.Range(0, 1f);
            float randomHelico  = Random.Range(0, 1f);

            if (nbCivil < nbMaxCivil && randomCivil < probaPopCivilBase + listEssaim.Count * probaPopCivilForEveryMemberEssaim)
            {
                PopCivil(true);
            }
            if (nbVoiture < nbMaxVoiture && randomVoiture < probaPopVoitureBase + listEssaim.Count * probaPopVoitureBaseForEveryMemberEssaim)
            {
                PopVoiture(true);
            }
            if (nbBus < nbMaxBus && randomBus < probaPopBusBase + listEssaim.Count * probaPopBusBaseForEveryMemberEssaim)
            {
                PopBus(true);
            }
            if (nbSoldat < nbMaxSoldat && randomSoldat < probaPopSoldatBase + listEssaim.Count * probaPopSoldatForEveryMemberEssaim)
            {
                PopSoldat(true);
            }
            if (nbTank < nbMaxTank && randomTank < probaPopTankBase + listEssaim.Count * probaPopTankForEveryMemberEssaim)
            {
                PopTank(true);
            }
        }



        timeScore.text       = "Temps : " + time.ToString("F2");
        timeScorePerdu.text  = "Temps : " + time.ToString("F2");
        timeScoreGagner.text = "Temps : " + time.ToString("F2");
        essaimSize.text      = "Essaim : " + listEssaim.Count;
        scoreText.text       = "Score : " + score.ToString("F2");
        scoreTextPerdu.text  = "Score : " + score.ToString("F2");
        scoreTextGagner.text = "Score : " + score.ToString("F2");


#if UNITY_EDITOR
        if (Input.GetKeyDown(KeyCode.Space))
        {
            Kill(essaimMaitre);
        }

        if (Input.GetKeyDown(KeyCode.P))
        {
            for (int i = 0; i < 10; i++)
            {
                GameObject essaimAI = GameObject.Instantiate(prefabEssaim, essaimParent);
                essaimAI.transform.position = essaimMaitre.transform.position + new Vector3(Random.Range(-5f, 5f), 0, Random.Range(-5f, 5f));
                EssaimAI essaimAiScript = essaimAI.GetComponent <EssaimAI>();
                essaimAiScript.isMaster = false;
                essaimAiScript.master   = essaimMaitre;
                listEssaim.Add(essaimAiScript);
            }
        }
#endif
        if (essaimMaitre != null)
        {
            foreach (Batiment bat in Map.instance.listBatiments)
            {
                if (bat.transform.position.z < essaimMaitre.transform.position.z)
                {
                    bat.opacityTarget = 0.25f;
                }
                else
                {
                    bat.opacityTarget = 1f;
                }
            }
        }
    }