コード例 #1
0
        private void Contamination(int index_jouer)
        {
            CaseClass.Type_Case type_case_index_jouer = array_case_class [index_jouer]._type_case;
            CaseClass.Type_Case type_case_autre;
            if (type_case_index_jouer == CaseClass.Type_Case.Green)
            {
                type_case_autre = CaseClass.Type_Case.Red;
            }
            else
            {
                type_case_autre = CaseClass.Type_Case.Green;
            }
            List <int> caca = new List <int> ();

            caca.Add(index_jouer - 1);
            caca.Add(index_jouer + 1);
            caca.Add(index_jouer - NOMBRE_PLATEAU_LARGEUR);
            caca.Add(index_jouer - NOMBRE_PLATEAU_LARGEUR - 1);
            caca.Add(index_jouer - NOMBRE_PLATEAU_LARGEUR + 1);
            caca.Add(index_jouer + NOMBRE_PLATEAU_LARGEUR);
            caca.Add(index_jouer + NOMBRE_PLATEAU_LARGEUR + 1);
            caca.Add(index_jouer + NOMBRE_PLATEAU_LARGEUR - 1);

            for (int i = 0; i < caca.Count; i++)
            {
                if (Verification_Case_Possible(caca [i], index_jouer) && array_case_class [caca [i]]._type_case == type_case_autre)
                {
                    array_case_class [caca [i]]._type_case  = type_case_index_jouer;
                    array_case_class [caca [i]]._type_annim = CaseClass.Type_Annimation.Both;
                }
            }
        }
コード例 #2
0
        public bool Verification_possibilite_jouer(CaseClass.Type_Case couleur_verification)
        {
            List <int> caca = new List <int> ();

            for (int k = 0; k < array_case_class.Length; k++)
            {
                if (array_case_class [k]._type_case == couleur_verification)
                {
                    caca.Add(k - 1);
                    caca.Add(k - 2);
                    caca.Add(k + 1);
                    caca.Add(k + 2);
                    caca.Add(k - NOMBRE_PLATEAU_LARGEUR);
                    caca.Add(k - NOMBRE_PLATEAU_LARGEUR - 1);
                    caca.Add(k - NOMBRE_PLATEAU_LARGEUR + 1);
                    caca.Add(k - (NOMBRE_PLATEAU_LARGEUR * 2));
                    caca.Add(k + NOMBRE_PLATEAU_LARGEUR);
                    caca.Add(k + NOMBRE_PLATEAU_LARGEUR + 1);
                    caca.Add(k + NOMBRE_PLATEAU_LARGEUR - 1);
                    caca.Add(k + (NOMBRE_PLATEAU_LARGEUR * 2));

                    for (int i = 0; i < caca.Count; i++)
                    {
                        if (Verification_Case_Vide_Et_Possible(caca [i], k))
                        {
                            return(true);
                        }
                    }
                    caca = new List <int> ();
                }
            }
            return(false);
        }
コード例 #3
0
        public void Reset_Plateau(string plateau)
        {
            for (int i = 0; i < plateau.Length; i++)
            {
                CaseClass.Type_Case type_case = CaseClass.Type_Case.Vide;

                switch (plateau [i])
                {
                case '0':
                    type_case = CaseClass.Type_Case.Vide;
                    break;

                case '1':
                    type_case = CaseClass.Type_Case.Obstacle;
                    break;

                case '3':
                    type_case = CaseClass.Type_Case.Red;
                    break;

                case '4':
                    type_case = CaseClass.Type_Case.Green;
                    break;

                default:
                    type_case = CaseClass.Type_Case.Vide;
                    break;
                }
                array_case_class [i] = new CaseClass(_screen, type_case, Position_Par_Index(i, NOMBRE_PLATEAU_LARGEUR));
                if (array_case_class [i]._type_case == CaseClass.Type_Case.Green || array_case_class [i]._type_case == CaseClass.Type_Case.Red)
                {
                    array_case_class [i]._scale_annimation = 1;
                }
            }
        }
コード例 #4
0
 public void Remplissage_plateau_fin_partie(CaseClass.Type_Case type_case_a_remplir)
 {
     for (int i = 0; i < array_case_class.Length; i++)
     {
         if (array_case_class [i]._type_case == CaseClass.Type_Case.Vide)
         {
             array_case_class [i]._type_case        = type_case_a_remplir;
             array_case_class [i]._scale_annimation = 1f;
         }
     }
 }
コード例 #5
0
        private int Contamination_index(int index, int NOMBRE_PLATEAU_LARGEUR, CaseClass[] plateau, CaseClass.Type_Case couleur_adversaire)
        {
            int jaimelabite = 0;

            List <int> caca = new List <int> ();

            caca.Add(index - 1);
            caca.Add(index + 1);
            caca.Add(index - NOMBRE_PLATEAU_LARGEUR);
            caca.Add(index - NOMBRE_PLATEAU_LARGEUR - 1);
            caca.Add(index - NOMBRE_PLATEAU_LARGEUR + 1);
            caca.Add(index + NOMBRE_PLATEAU_LARGEUR);
            caca.Add(index + NOMBRE_PLATEAU_LARGEUR + 1);
            caca.Add(index + NOMBRE_PLATEAU_LARGEUR - 1);

            for (int i = 0; i < caca.Count; i++)
            {
                if (Verification_Case_Possible(caca[i], index, NOMBRE_PLATEAU_LARGEUR) && plateau [caca [i]]._type_case == couleur_adversaire)
                {
                    jaimelabite++;
                }
            }
            return(jaimelabite);
        }
コード例 #6
0
        public List <int> index_coup_jouer(CaseClass[] plateau, int NOMBRE_PLATEAU_LARGEUR, CaseClass.Type_Case couleur_joueur)
        {
            int index_coup_jouer        = -1;
            int _type_coup_jouer        = -1;
            int _origin_coup_jouer_saut = -1;

            CaseClass.Type_Case type_case_adversaire;
            List <int>          list_index_possible_en_evolution   = new List <int> ();
            List <int>          list_index_possible_en_saut        = new List <int> ();
            List <int>          list_index_possible_en_saut_origin = new List <int> ();

            //set case adversaire
            if (couleur_joueur == CaseClass.Type_Case.Green)
            {
                type_case_adversaire = CaseClass.Type_Case.Red;
            }
            else
            {
                type_case_adversaire = CaseClass.Type_Case.Green;
            }

            //fais la liste des cases possibles
            for (int k = 0; k < plateau.Length; k++)
            {
                if (plateau [k]._type_case == type_case_adversaire)
                {
                    int        i = 0;
                    List <int> list_index_selected = new List <int> ();
                    list_index_selected.Add(k - 1);
                    list_index_selected.Add(k - 2);
                    list_index_selected.Add(k + 1);
                    list_index_selected.Add(k + 2);
                    list_index_selected.Add(k - NOMBRE_PLATEAU_LARGEUR);
                    list_index_selected.Add(k - NOMBRE_PLATEAU_LARGEUR - 1);
                    list_index_selected.Add(k - NOMBRE_PLATEAU_LARGEUR + 1);
                    list_index_selected.Add(k - (NOMBRE_PLATEAU_LARGEUR * 2));
                    list_index_selected.Add(k + NOMBRE_PLATEAU_LARGEUR);
                    list_index_selected.Add(k + NOMBRE_PLATEAU_LARGEUR + 1);
                    list_index_selected.Add(k + NOMBRE_PLATEAU_LARGEUR - 1);
                    list_index_selected.Add(k + (NOMBRE_PLATEAU_LARGEUR * 2));

                    foreach (int caca in list_index_selected)
                    {
                        if (Verification_Case_Vide_Et_Possible(list_index_selected [i], k, NOMBRE_PLATEAU_LARGEUR, plateau))
                        {
                            if (list_index_selected [i] == k - 2 ||
                                list_index_selected [i] == k + 2 ||
                                list_index_selected [i] == k + (NOMBRE_PLATEAU_LARGEUR * 2) ||
                                list_index_selected [i] == k - (NOMBRE_PLATEAU_LARGEUR * 2))
                            {
                                if (!list_index_possible_en_saut.Contains(list_index_selected [i]))
                                {
                                    list_index_possible_en_saut.Add(list_index_selected [i]);
                                    list_index_possible_en_saut_origin.Add(k);
                                }
                            }
                            else
                            {
                                if (!list_index_possible_en_evolution.Contains(list_index_selected [i]))
                                {
                                    list_index_possible_en_evolution.Add(list_index_selected [i]);
                                }
                            }
                        }
                        i++;
                    }
                }
            }

            List <int> foutre = new List <int> ();

            //TODO : AMELIORER CETTE IA DEG
            //CALCUL DISTANCE POUR PLUS OPTIMISE ET NON RANDOM COMME UN PD
            if (difficulté == 1)
            {
                if (list_index_possible_en_evolution.Count > 0)
                {
                    int blbl = rand.Next(0, list_index_possible_en_evolution.Count);
                    index_coup_jouer = list_index_possible_en_evolution [blbl];
                    _type_coup_jouer = 1;
                }
                else
                {
                    int blbl = rand.Next(0, list_index_possible_en_saut.Count);
                    index_coup_jouer        = list_index_possible_en_saut [blbl];
                    _type_coup_jouer        = 2;
                    _origin_coup_jouer_saut = list_index_possible_en_saut_origin [blbl];
                }

                foutre.Add(_type_coup_jouer);
                foutre.Add(index_coup_jouer);
                foutre.Add(_origin_coup_jouer_saut);
            }
            else
            {
                int[,] list_de_possibilite      = new int[list_index_possible_en_evolution.Count, 2];
                int[,] list_de_possibilite_saut = new int[list_index_possible_en_saut.Count, 2];
                for (int i = 0; i < list_index_possible_en_evolution.Count; i++)
                {
                    int blbl = Contamination_index(list_index_possible_en_evolution [i], NOMBRE_PLATEAU_LARGEUR, plateau, couleur_joueur);
                    list_de_possibilite [i, 0] = list_index_possible_en_evolution [i];
                    list_de_possibilite [i, 1] = blbl;
                }
                for (int i = 0; i < list_index_possible_en_saut.Count; i++)
                {
                    int blbl = Contamination_index(list_index_possible_en_saut [i], NOMBRE_PLATEAU_LARGEUR, plateau, couleur_joueur);
                    list_de_possibilite_saut [i, 0] = list_index_possible_en_saut [i];
                    list_de_possibilite_saut [i, 1] = blbl;
                }

                int max_conta_evol = 0, max_conta_saut = 0, index_evol = 0, index_saut = 0, origin_index_saut = 0;

                for (int i = 0; i < list_de_possibilite.Length / 2; i++)
                {
                    if (list_de_possibilite [i, 1] > max_conta_evol)
                    {
                        max_conta_evol = list_de_possibilite [i, 1];
                        index_evol     = list_de_possibilite [i, 0];
                    }
                }

                for (int i = 0; i < list_de_possibilite_saut.Length / 2; i++)
                {
                    if (list_de_possibilite_saut [i, 1] > max_conta_saut)
                    {
                        max_conta_saut    = list_de_possibilite_saut [i, 1];
                        index_saut        = list_de_possibilite_saut [i, 0];
                        origin_index_saut = list_index_possible_en_saut_origin [i];
                    }
                }

                if (max_conta_evol == 0 && max_conta_saut == 0)
                {
                    if (list_index_possible_en_evolution.Count > 0)
                    {
                        int blbl = rand.Next(0, list_index_possible_en_evolution.Count);
                        index_coup_jouer = list_index_possible_en_evolution [blbl];
                        _type_coup_jouer = 1;
                    }
                    else
                    {
                        int blbl = rand.Next(0, list_index_possible_en_saut.Count);
                        index_coup_jouer        = list_index_possible_en_saut [blbl];
                        _type_coup_jouer        = 2;
                        _origin_coup_jouer_saut = list_index_possible_en_saut_origin [blbl];
                    }

                    foutre.Add(_type_coup_jouer);
                    foutre.Add(index_coup_jouer);
                    foutre.Add(_origin_coup_jouer_saut);
                }
                else
                {
                    if (max_conta_saut > max_conta_evol)
                    {
                        foutre.Add(2);
                        foutre.Add(index_saut);
                        foutre.Add(origin_index_saut);
                    }
                    else
                    {
                        foutre.Add(1);
                        foutre.Add(index_evol);
                        foutre.Add(0);
                    }
                }
            }

            return(foutre);
        }
コード例 #7
0
        private void LoadContent()
        {
            //PLATEAU DIMENSION
            array_case_class = new CaseClass[NOMBRE_PLATEAU_LARGEUR * NOMBRE_PLATEAU_LARGEUR];
            LARGEUR_PLATEAU  = (int)(_screen.ScreenManager.GraphicsDevice.Viewport.Width * 0.9);

            _taille_bordure = Taille_Bordure();
            int Largueur_Case = Taille_Case();


            //INITIALISATION TEXTURE
            plateau_fond = RoundedRectangle_Class.Texture_Rounded_Rectangle(_screen.ScreenManager.GraphicsDevice, LARGEUR_PLATEAU, LARGEUR_PLATEAU, color_fond, (int)(LARGEUR_PLATEAU * 0.005), (int)(LARGEUR_PLATEAU * 0.03));
            case_vide    = RoundedRectangle_Class.Texture_Rounded_Rectangle(_screen.ScreenManager.GraphicsDevice, Largueur_Case, Largueur_Case, color_case_vide, (int)(LARGEUR_PLATEAU * 0.005), (int)(LARGEUR_PLATEAU * 0.03));
            case_verte   = RoundedRectangle_Class.Texture_Rounded_Rectangle(_screen.ScreenManager.GraphicsDevice, Largueur_Case, Largueur_Case, color_green, (int)(LARGEUR_PLATEAU * 0.005), (int)(LARGEUR_PLATEAU * 0.03));
            case_rouge   = RoundedRectangle_Class.Texture_Rounded_Rectangle(_screen.ScreenManager.GraphicsDevice, Largueur_Case, Largueur_Case, color_red, (int)(LARGEUR_PLATEAU * 0.005), (int)(LARGEUR_PLATEAU * 0.03));

            //INITIALISATION TEXTURE SURBRILLANCE SAUT

            case_surbrillance_vert  = RoundedRectangle_Class.Texture_Rounded_Rectangle_Saut_Cercle(_screen.ScreenManager.GraphicsDevice, Largueur_Case, Largueur_Case, color_green, color_case_vide, (int)(LARGEUR_PLATEAU * 0.005), (int)(LARGEUR_PLATEAU * 0.03));
            case_surbrillance_rouge = RoundedRectangle_Class.Texture_Rounded_Rectangle_Saut_Cercle(_screen.ScreenManager.GraphicsDevice, Largueur_Case, Largueur_Case, color_red, color_case_vide, (int)(LARGEUR_PLATEAU * 0.005), (int)(LARGEUR_PLATEAU * 0.03));

            position_plateau = new Vector2((float)(_screen.ScreenManager.GraphicsDevice.Viewport.Width * 0.05), _height_debut);

            if (!_multi)
            {
                _plateau_debut = Return_Type_Plateau();
            }

            // SET COLOR JOUEUR
            if (_couleur_joueur == PlayClass.Couleurs.Green)
            {
                _case_joueur        = CaseClass.Type_Case.Green;
                _case_adversaire    = CaseClass.Type_Case.Red;
                _couleur_adversaire = PlayClass.Couleurs.Red;
            }
            else
            {
                _case_joueur        = CaseClass.Type_Case.Red;
                _case_adversaire    = CaseClass.Type_Case.Green;
                _couleur_adversaire = PlayClass.Couleurs.Green;
            }

            //INITIALISATION ARRAY
            if (!_multi)
            {
                _type_plateau = new char[NOMBRE_PLATEAU_LARGEUR * NOMBRE_PLATEAU_LARGEUR];
                for (int i = 0; i < array_case_class.Length; i++)
                {
                    _type_plateau [i] = _plateau_debut [i];
                    CaseClass.Type_Case type_case = CaseClass.Type_Case.Vide;

                    switch (_type_plateau [i])
                    {
                    case '0':
                        type_case = CaseClass.Type_Case.Vide;
                        break;

                    case '1':
                        type_case = CaseClass.Type_Case.Obstacle;
                        break;

                    case '3':
                        type_case = CaseClass.Type_Case.Red;
                        break;

                    case '4':
                        type_case = CaseClass.Type_Case.Green;
                        break;

                    default:
                        type_case = CaseClass.Type_Case.Vide;
                        break;
                    }
                    array_case_class [i] = new CaseClass(_screen, type_case, Position_Par_Index(i, NOMBRE_PLATEAU_LARGEUR));
                    if (array_case_class [i]._type_case == CaseClass.Type_Case.Green || array_case_class [i]._type_case == CaseClass.Type_Case.Red)
                    {
                        array_case_class [i]._scale_annimation = 1;
                    }
                }
            }
            else
            {
                _type_plateau = new char[NOMBRE_PLATEAU_LARGEUR * NOMBRE_PLATEAU_LARGEUR];
                for (int i = 0; i < array_case_class.Length; i++)
                {
                    _type_plateau [i] = _plateau_debut [i];
                    CaseClass.Type_Case type_case = CaseClass.Type_Case.Vide;

                    switch (_type_plateau [i])
                    {
                    case '0':
                        type_case = CaseClass.Type_Case.Vide;
                        break;

                    case '1':
                        type_case = CaseClass.Type_Case.Obstacle;
                        break;

                    case '3':
                        if (_is_joueur_1)
                        {
                            type_case = _case_joueur;
                        }
                        else
                        {
                            type_case = _case_adversaire;
                        }
                        break;

                    case '4':
                        if (_is_joueur_1)
                        {
                            type_case = _case_adversaire;
                        }
                        else
                        {
                            type_case = _case_joueur;
                        }
                        break;

                    default:
                        type_case = CaseClass.Type_Case.Vide;
                        break;
                    }
                    array_case_class [i] = new CaseClass(_screen, type_case, Position_Par_Index(i, NOMBRE_PLATEAU_LARGEUR));
                    if (array_case_class [i]._type_case == CaseClass.Type_Case.Green || array_case_class [i]._type_case == CaseClass.Type_Case.Red)
                    {
                        array_case_class [i]._scale_annimation = 1;
                    }
                }
            }
        }
コード例 #8
0
 private bool Changement_Statut_Selected_To_Validation(int index_selected, int index_origin, CaseClass.Type_Case type_case_joueur)
 {
     if (array_case_class [index_selected]._type_surbrillance == CaseClass.Surbrillance_Type.Evolution)
     {
         _coup_jouer_index = index_selected;
         _type_coup_jouer  = CaseClass.Surbrillance_Type.Evolution;
         Reset_Surbrillance();
         _index_selected = -1;
         Gestion_Coup_Jouer(_couleur_joueur);
         return(true);
     }
     else if (array_case_class [index_selected]._type_surbrillance == CaseClass.Surbrillance_Type.Saut)
     {
         _coup_jouer_index       = index_selected;
         _type_coup_jouer        = CaseClass.Surbrillance_Type.Saut;
         _origin_saut_coup_jouer = index_origin;
         Reset_Surbrillance();
         _index_selected = -1;
         Gestion_Coup_Jouer(_couleur_joueur);
         return(true);
     }
     return(false);
 }