public override AbstractPlateauDeJeu CreerPlateauDeJeu(AbstractFabriqueDeJeu fabrique)
        {
            PlateauDeJeuDame damier  = new PlateauDeJeuDame();
            FactoryDame      factory = new FactoryDame();

            List <ZonePion> caseDamier = new List <ZonePion>();

            caseDamier = factory.CreateCarre(10, 10);
            damier.setZoneFree(caseDamier);

            plateau = damier;
            return(plateau);
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="pion"></param>
        /// <param name="plateau"></param>
        /// <returns></returns>
        public Boolean PionADeplacer(Pion pion, PlateauDeJeuDame plateau)
        {
            var zoneEnvironnantDuPion = pion.Position.GetList(pion, plateau.getZoneForFree());

            var zoneFree = zoneEnvironnantDuPion.Where(c => c.Occupe == false).ToList <ZonePion>();

            int nbreZoneFree = zoneFree.Count;

            //var zoneOfPlateau = plateau.getZoneForFree();
            if (zoneFree != null && zoneFree.Count >= 2)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Example #3
0
        /// <summary>
        /// Placer les pions sur un damier constitué de zone
        /// </summary>
        /// <param name="perso"></param>
        /// <param name="damier"></param>
        public void PlacerLesPionsSurDamier(List <Personnage> perso, PlateauDeJeuDame damier)
        {
            var listezone = damier.getZoneForFree();// damier.getZonesAcces();

            foreach (var z in listezone)
            {
                foreach (var p in perso)
                {
                    if (p.GetType().Equals(typeof(PionBlanc)))
                    {
                        if (z.Y < 4 && (z.Y % 2 != 0) && (z.X % 2 == 0))
                        {
                            p.Position     = z;
                            z.Occupe       = true;
                            z.PionPosseder = "PionBlanc";
                        }
                        else if (z.Y < 4 && (z.Y % 2 == 0) && (z.X % 2 != 0))
                        {
                            p.Position     = z;
                            z.Occupe       = true;
                            z.PionPosseder = "PionBlanc";
                        }
                    }
                    else if (p.GetType().Equals(typeof(PionNoir)))
                    {
                        if (z.Y > 5 && (z.Y % 2 == 0) && (z.X % 2 != 0))
                        {
                            p.Position     = z;
                            z.Occupe       = true;
                            z.PionPosseder = "PionNoir";
                        }
                        else if (z.Y > 5 && (z.Y % 2 != 0) && (z.X % 2 == 0))
                        {
                            p.Position     = z;
                            z.Occupe       = true;
                            z.PionPosseder = "PionNoir";
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Deplacement d'une zone vers une zone
        /// </summary>
        /// <param name="perso"></param>
        /// <param name="damier"></param>
        public void Execution(List <Pion> perso, PlateauDeJeuDame damier)
        {
            Random      hasard        = new Random();
            List <Pion> listPionNoir  = new List <Pion>();
            List <Pion> listPionBlanc = new List <Pion>();

            foreach (var pionPerso in perso)
            {
                if (pionPerso.Color == Color.White)
                {
                    listPionBlanc.Add(pionPerso);
                }
                else
                {
                    listPionNoir.Add(pionPerso);
                }
            }


            int tour = 100;

            Pion pionBlanc; //= new PionBlanc();
            Pion pionNoir;  //= new PionNoir();

            for (int i = 0; i <= tour; i++)
            {
                if (i % 2 == 0)
                {
                    bool testB;

                    do
                    {
                        testB     = PionADeplacer(listPionBlanc.ElementAt(hasard.Next(listPionBlanc.Count)), damier);
                        pionBlanc = listPionBlanc.ElementAt(hasard.Next(listPionBlanc.Count));
                    } while (testB == true);
                }
                else
                {
                    bool testN;

                    do
                    {
                        testN    = PionADeplacer(listPionNoir.ElementAt(hasard.Next(0, listPionNoir.Count)), damier);
                        pionNoir = listPionNoir.ElementAt(hasard.Next(0, listPionNoir.Count));
                    } while (testN == true);
                }
            }


            /*
             * foreach (Pion i in perso)
             * {
             *  var ip = i.Position.GetList(i, damier.getZoneForFree());
             *  int taille = ip.Count;
             *
             *
             *
             *  foreach (var item in ip)
             *  {
             *      int numhasard = hasard.Next(0, 20);
             *      if (item.Occupe == false)
             *      {
             *          i.ZoneVersZone(item);
             *          return;
             *      }
             *  }
             * }
             */
        }
Example #5
0
        /// <summary>
        /// Deplacement d'une zone vers une zone
        /// </summary>
        /// <param name="perso"></param>
        /// <param name="damier"></param>
        public void Execution(List <Personnage> perso, PlateauDeJeuDame damier)
        {
            Random      hasard        = new Random();
            List <Pion> listPionNoir  = new List <Pion>();
            List <Pion> listPionBlanc = new List <Pion>();

            foreach (Pion pionPerso in perso)
            {
                if (pionPerso.GetType().Equals(typeof(PionBlanc)))
                {
                    listPionBlanc.Add(pionPerso);
                }
                else
                {
                    listPionNoir.Add(pionPerso);
                }
            }
            int  tour             = 100;
            Pion pionBlanc        = null;
            Pion pionBlancAdverse = null;
            Pion pionNoir         = null;
            Pion pionNoirAdverse  = null;

            for (int i = 0; i <= tour; i++)
            {
                if (i % 2 == 0)
                {
                    bool testB = false;
                    int  varialeB;
                    while (testB == false)
                    {
                        varialeB  = hasard.Next(1, listPionBlanc.Count);
                        testB     = PionADeplacer(listPionBlanc.ElementAt(varialeB), damier);
                        pionBlanc = listPionBlanc.ElementAt(varialeB);
                    }
                    //public List<ZonePion> ListePionsEnvironnants(Pion pion, List<ZonePion> listeDesZoneAuxAlentours)
                    var listeDesPionsContrairesAlentours = this.ListePionsEnvironnants(pionBlanc, pionBlanc.Position.GetList(pionBlanc, plateau.getZoneForFree().ToList()));
                    if (listeDesPionsContrairesAlentours == null)
                    {
                        pionBlanc.Avancer(1);
                    }
                    else
                    {
                        if (listeDesPionsContrairesAlentours.Count != 0)
                        {
                            int itemPionAdverse = hasard.Next(1, listeDesPionsContrairesAlentours.Count);
                            //Choisir un pion adverse au hasard à manger
                            foreach (Pion item in perso)
                            {
                                if (item.Position.X == listeDesPionsContrairesAlentours.ElementAt(itemPionAdverse).X&& item.Position.Y == listeDesPionsContrairesAlentours.ElementAt(itemPionAdverse).Y
                                    )
                                {
                                    pionBlancAdverse = item;
                                    continue;
                                }
                            }
                            pionBlanc.ComportementManger.MangerPion(pionBlanc, pionBlancAdverse, this);
                        }
                    }
                }
                else
                {
                    bool testN = false;
                    int  variableN;
                    while (testN == false)
                    {
                        variableN = hasard.Next(1, listPionNoir.Count);
                        testN     = PionADeplacer(listPionNoir.ElementAt(variableN), damier);
                        pionNoir  = listPionNoir.ElementAt(variableN);
                    }

                    var listeDesPionsContrairesAlentours = this.ListePionsEnvironnants(pionNoir, pionNoir.Position.GetList(pionNoir, plateau.getZoneForFree().ToList()));
                    if (listeDesPionsContrairesAlentours == null)
                    {
                        pionNoir.Avancer(1);
                    }
                    else
                    {
                        if (listeDesPionsContrairesAlentours.Count != 0)
                        {
                            int itemPionAdverse = hasard.Next(1, listeDesPionsContrairesAlentours.Count);
                            //Choisir un pion adverse au hasard à manger
                            foreach (Pion item in perso)
                            {
                                if (item.Position.X == listeDesPionsContrairesAlentours.ElementAt(itemPionAdverse).X&& item.Position.Y == listeDesPionsContrairesAlentours.ElementAt(itemPionAdverse).Y
                                    )
                                {
                                    pionNoirAdverse = item;
                                    continue;
                                }
                            }
                            pionNoir.ComportementManger.MangerPion(pionBlanc, pionBlancAdverse, this);
                        }
                    }
                }
            }
        }