Esempio n. 1
0
 //reponse
 public void Phase6_Recolte_Clic_Ouvriere(Pion ouvriere)
 {
     Debug.Log("Phase6_Recolte_Clic_Ouvriere");
     Joueurs[0].PN    += ouvriere.tuile.PN;
     ouvriere.position = Pion.Position.nid;
     Phase6_Recolte();
 }
Esempio n. 2
0
File: Naive.cs Progetto: pi-aire/pom
    public Action grabPieces(Pion pion, Board board)
    {
        List <Vector2Int[]> steps = new List <Vector2Int[]>();
        bool       end            = false;
        Vector2Int position       = pion.position;
        Action     ac             = new Action(pion.position);

        // tant qu'on peux prendre un pion on actualise la position du pion
        // on ne peux pas sauter 2 fois sur le meme pions
        while (!end)
        {
            for (int i = -1; i <= 1; i += 2)
            {
                for (int j = -1; j <= 1; j += 2)
                {
                    int xTarget = position.x + i;
                    int yTarget = position.y + j;
                    int xDest   = position.x + 2 * i;
                    int yDest   = position.y + 2 * j;

                    if (xTarget < board.size && xTarget >= 0 && yTarget < board.size && yTarget >= 0 && board.grille[xTarget, yTarget] != null &&
                        xDest < board.size && xDest >= 0 && yDest < board.size && yDest >= 0 && board.grille[xDest, yDest] == null)
                    {
                        if (board.grille[xTarget, yTarget].GetType() == typeof(Pion) && board.grille[xTarget, yTarget].color != pion.color)
                        {
                            // on interdis de resauter sur un pion deja raflé
                            if (!ac.alreadyCaptured(new Vector2Int(xTarget, yTarget)))
                            {
                                Vector2Int[] step = { new Vector2Int(xDest, yDest), new Vector2Int(xTarget, yTarget) };
                                steps.Add(step);
                            }
                        }
                    }
                }
            }

            // si plusieurs prise possibles pour cette rafle on en prend une aléatoire
            // on banis la position
            if (steps.Count != 0)
            {
                int          rand = Random.Range(0, steps.Count);
                Vector2Int[] move = steps.ToArray()[rand];

                //on banis le pions sur lequel on a sauté et on actualise la position
                ac.addCapture(move[1]);

                position.x = move[0].x;
                position.y = move[0].y;

                // on vide les moveùent du premier saut
                steps.Clear();
            }
            else
            {
                end = true;
            }
        }
        ac.newPosition = position;
        return(ac);
    }
Esempio n. 3
0
    internal void Add(Pion PionActif, Pion cible)
    {
        //clic clone
        if (cible.IsClone)
        {
            PionActif.direction  = cible.direction;
            PionActif.joueur.PM -= TuilesVoisine[PionActif.direction].PM;
            ActualiserPions();
            jeu.DesactiverDeplacement();
            jeu.ControlConflit();
        }
        //ou ennemi
        else
        {
            if (PionActif.tuile != cible.tuile)
            {
                PionActif.joueur.PM -= PM;
            }

            cible.position      = Pion.Position.defausse;
            PionActif.direction = 6;
            PionActif.tuile     = this;
            jeu.VoleBonus(PionActif.joueur, cible.joueur);
        }
    }
Esempio n. 4
0
    /* Méthode sur le déplacement des Pions */

    // Déplacement des pions avec objectif d'aller dans le camp adverse
    public Action movePion(Pion p, Board board)
    {
        List <Action> availableMove = new List <Action>();

        // On cherche les déplacements possibles
        for (int i = -1; i <= 1; i += 2)
        {
            for (int j = -1; j <= 1; j += 2)
            {
                int x = p.position.x + i;
                int y = p.position.y + j;
                if (x < board.size && x >= 0 && y < board.size && y >= 0 && board.grille[x, y] == null)
                {
                    availableMove.Add(new Action(p.position, new Vector2Int(x, y)));
                }
            }
        }
        // On cherche les prises qui font avancer
        availableMove.AddRange(grabPieces(p, board));
        //availableMove.Add(grabPieces(p, board));

        // On filtre les mouvements disponiblent
        p.refreshGoal(board);
        List <Action> selectMove = p.goal.filter(board, availableMove);

        // On choisie une avancé aleatoirement
        if (selectMove.Count != 0)
        {
            return(selectMove.ToArray()[Random.Range(0, selectMove.Count)]);
        }

        //Pas de déplacement possible
        return(new Action(p.position));
    }
Esempio n. 5
0
    private bool checkCondition(int x, int y)
    {
        GameObject[] whitepion = GameObject.FindGameObjectsWithTag("whitepion");
        GameObject[] redpion   = GameObject.FindGameObjectsWithTag("redpion");

        foreach (GameObject pion in whitepion)
        {
            Pion daman = pion.GetComponent("Pion") as Pion;

            if (daman.CurrentX == x && daman.CurrentY == y)
            {
                return(false);
            }
        }

        foreach (GameObject pion in redpion)
        {
            Pion daman = pion.GetComponent("Pion") as Pion;

            if (daman.CurrentX == x && daman.CurrentY == y)
            {
                return(false);
            }
        }

        return(true);
    }
Esempio n. 6
0
/* Méthode de la classe Board*/
    // Remplie le tableau en plaçant les pieces au position d'innitialisation du jeu de Dames
    public void initBoard()
    {
        grille = new Piece[10, 10];
        for (int i = 0; i < 10; i++)
        {
            for (int j = 0; j < 10; j++)
            {
                if (i % 2 == 0 && j % 2 == 0)
                {
                    if (i < 3)
                    {
                        grille[i, j] = new Pion(i, j, Color.White);
                    }
                    else if (i > 6)
                    {
                        grille[i, j] = new Pion(i, j, Color.Black);
                    }
                }
                else if (i % 2 == 1 && j % 2 == 1)
                {
                    if (i < 3)
                    {
                        grille[i, j] = new Pion(i, j, Color.White);
                    }
                    else if (i > 6)
                    {
                        grille[i, j] = new Pion(i, j, Color.Black);
                    }
                }
            }
        }
    }
Esempio n. 7
0
        /// <summary>
        /// Recuperer la liste des zones entourants un pion
        /// </summary>
        /// <param name="p"></param>
        /// <param name="ep"></param>
        /// <returns></returns>
        public List <ZonePion> GetList(Pion p, List <ZonePion> ep)
        {
            List <ZonePion> zoneautour = new List <ZonePion>();

            var co1 = ep.Single(c => c.X == (p.Position.X - 1) && c.Y == (p.Position.Y - 1));
            var co2 = ep.Single(c => c.X == (p.Position.X - 1) && c.Y == (p.Position.Y));
            var co3 = ep.Single(c => c.X == (p.Position.X - 1) && c.Y == (p.Position.Y + 1));
            var co4 = ep.Single(c => c.X == (p.Position.X) && c.Y == (p.Position.Y - 1));
            var co5 = ep.Single(c => c.X == (p.Position.X) && c.Y == (p.Position.Y + 1));
            var co6 = ep.Single(c => c.X == (p.Position.X - 1) && c.Y == (p.Position.Y - 1));
            var co7 = ep.Single(c => c.X == (p.Position.X) && c.Y == (p.Position.Y - 1));

            try
            {
                var co8 = ep.Single(c => c.X == (p.Position.X + 1) && c.Y == (p.Position.Y - 1));
                if (co8 != null)
                {
                    zoneautour.Add(co8);
                }
            }
            catch (Exception e) {
                Console.WriteLine(e.Message);
            }

            zoneautour.Add(co1);
            zoneautour.Add(co2);
            zoneautour.Add(co3);
            zoneautour.Add(co4);
            zoneautour.Add(co5);
            zoneautour.Add(co6);
            zoneautour.Add(co7);

            return(zoneautour);
        }
 public static void genererPions(int x, ConsoleColor color, Joueur joueur)
 {
     joueur.Color = color;
     for (int i = 0; i < joueur.Pions.Length; i++)
     {
         int Row = x;
         while (Row < x + 4)
         {
             int Column;
             if (Row % 2 == 0)
             {
                 Column = 0;
             }
             else
             {
                 Column = 1;
             }
             do
             {
                 joueur[i]   = new Pion();
                 joueur[i].X = Row;
                 joueur[i].Y = Column;
                 Column     += 2;
                 i++;
             } while (Column <= 9);
             Row += 1;
         }
     }
 }
Esempio n. 9
0
        /// <summary>
        /// Liste des pions environnants not used
        /// </summary>
        /// <param name="pion"></param>
        /// <param name="listeDesZoneAuxAlentours"></param>
        /// <returns></returns>

        public List <ZonePion> ListePionsEnvironnants(Pion pion, List <ZonePion> listeDesZoneAuxAlentours)
        {
            List <ZonePion> listePionZoneEnvironnants = new List <ZonePion>();

            if (pion.GetType().Equals(typeof(PionBlanc)))
            {
                foreach (var item in listeDesZoneAuxAlentours)
                {
                    if (item.Occupe.Equals(true) && item.PionPosseder.Equals("PionNoir"))
                    {
                        listePionZoneEnvironnants.Add(item);
                    }
                }
                return(listePionZoneEnvironnants);
            }
            else
            {
                foreach (var item in listeDesZoneAuxAlentours)
                {
                    if (item.Occupe.Equals(true) && item.PionPosseder.Equals("PionBlanc"))
                    {
                        listePionZoneEnvironnants.Add(item);
                    }
                }

                return(listePionZoneEnvironnants);
            }
        }
Esempio n. 10
0
File: Naive.cs Progetto: pi-aire/pom
    /* Méthode utilisé pour le résolveur*/
    // Déplacement des pions avec objectif d'aller dans le camp adverse
    public Action movePiece(Pion p, Board board)
    {
        List <Vector2Int> availableMove = new List <Vector2Int>();

        // On cherche les déplacements possibles
        for (int i = -1; i <= 1; i += 2)
        {
            for (int j = -1; j <= 1; j += 2)
            {
                int x = p.position.x + i;
                int y = p.position.y + j;
                if (x < board.size && x >= 0 && y < board.size && y >= 0 && board.grille[x, y] == null)
                {
                    availableMove.Add(new Vector2Int(i, j));
                }
            }
        }
        Action ac = new Action(p.position);

        // On prend un déplacement aleatoire si la piece ne peut pas se rapprocher du camps adverse
        if (availableMove.Count != 0)
        {
            // Le pion ne peux pas se déplacer dans la direction du camp adverse
            Vector2Int move = availableMove.ToArray()[Random.Range(0, availableMove.Count)];
            ac.newPosition = new Vector2Int(move.x + p.position.x, move.y + p.position.y);
            return(ac);
        }

        //Pas de déplacement possible
        return(ac);
    }
 public PionViewModel(Pion model)
 {
     pion       = model;
     id         = model.ID;
     Karakter   = model.Karakter;
     Team       = model.Team;
     isMoveable = model.isMoveable;
 }
Esempio n. 12
0
        /// <summary>
        /// Plaatst een pion op het veld
        /// </summary>
        /// <param name="pion">Pion</param>
        /// <returns>boolean als het gelukt is of niet</returns>
        public override bool Plaats(Pion pion)
        {
            //staat al iets op
            if (Pionnen.Any()) return false;

            Pionnen.Add(pion);
            return true;
        }
Esempio n. 13
0
        private void MutaPionInCasuta(Pion pion, Casuta.UserControl.Casuta casuta, int pozitieCasuta)
        {
            ElibereazaCasuta(pion.CasutaCurenta);

            pion.CasutaCurenta                 = casuta;
            pion.CasutaCurenta.EsteOcupata     = true;
            pion.PozitiaCurenta                = pozitieCasuta;
            casuta.ImaginePion.BackgroundImage = pion.Imagine;
        }
Esempio n. 14
0
 void ClearPionSelected()
 {
     foreach (GameObject arrow in activeArrow)
     {
         Destroy(arrow);
     }
     activeArrow.Clear();
     pionSelectedBool = false;
     selectedPion     = null;
 }
Esempio n. 15
0
    internal void Add(Pion PionActif)
    {
        if (GetProprietaire() != PionActif.joueur && terrain != Terrain.Nid)
        {
            PionActif.joueur.PM -= PM;
        }

        PionActif.direction = 6;
        PionActif.tuile     = this;
    }
Esempio n. 16
0
    void TourSuivant()
    {
        bool joueurFini = pionCourant != Pion.Bobail;

        if (joueurFini)
        {
            NouveauTour();
        }
        pionCourant = (Pion)mouvements.Dequeue();
    }
Esempio n. 17
0
    public override Piece clone()
    {
        Pion clone = new Pion(position.x, position.y, color);

        clone.life        = this.life;
        clone.id          = this.id;
        clone.goal        = this.goal;
        clone.predictions = this.predictions;
        clone.standBy     = this.standBy;
        return(clone);
    }
Esempio n. 18
0
    private void Ambuscade(Pion P)
    {
        Debug.Log("Ambuscade");
        var cible = PionActif;

        PionActif           = P;
        cible.position      = Pion.Position.defausse;
        PionActif.direction = 6;
        PionActif.tuile     = TConflit;

        VoleBonus(PionActif.joueur, cible.joueur);
    }
Esempio n. 19
0
        private void tekenPionnen()
        {
            foreach (Speler speler in spelerslijst)
            {
                Pion  pion  = speler.Pion;
                Color color = Colors.White;
                if (pion.Kleur.ToLower() == "rood")
                {
                    color = Colors.Red;
                }

                else if (pion.Kleur.ToLower() == "blauw")
                {
                    color = Colors.Blue;
                }

                else if (pion.Kleur.ToLower() == "groen")
                {
                    color = Colors.Green;
                }

                else if (pion.Kleur.ToLower() == "paars")
                {
                    color = Colors.Purple;
                }

                else if (pion.Kleur.ToLower() == "zwart")
                {
                    color = Colors.Black;
                }

                else if (pion.Kleur.ToLower() == "geel")
                {
                    color = Colors.Yellow;
                }


                Ellipse ellipse = new Ellipse();
                ellipse.Width               = pion.Grootte;
                ellipse.Height              = pion.Grootte;
                ellipse.Fill                = new SolidColorBrush(color);
                ellipse.Margin              = new Thickness(45, 850, 0, 0);
                ellipse.VerticalAlignment   = VerticalAlignment.Top;
                ellipse.HorizontalAlignment = HorizontalAlignment.Left;
                ellipse.Stroke              = new SolidColorBrush(Colors.Black);
                ellipse.StrokeThickness     = 2;
                testgrid.Children.Add(ellipse);
                ellipses.Add(ellipse);
            }
        }
Esempio n. 20
0
        static void Main(string[] args)
        {
            var Flower1 = new Iris("Pink", 20);
            var Flower2 = new Pion("Red", 22);
            var Flower3 = new Rose("Pink", 78);
            var Flower4 = new Iris("Blue", 23);
            var Flower5 = new Scaevola("Blue", 67);

            var Bouquet = new Bouquet(Flower1, Flower2, Flower3, Flower4, Flower5);

            System.Console.WriteLine("Bouquet information");

            Bouquet.BouqetInfo();
        }
Esempio n. 21
0
    void Start()
    {
        plateau     = new Plateau();
        pionCourant = Pion.A;
        joueurs     = new Queue();
        joueurs.Enqueue("A");
        joueurs.Enqueue("B");
        mouvements = new Queue();
        mouvements.Enqueue(Pion.A);
        mouvements.Enqueue(Pion.Bobail);
        mouvements.Enqueue(Pion.B);
        destinationsPossibles = new List <Coordonnees>();

        PremierTour();
    }
Esempio n. 22
0
 private bool CEstMonNid(Pion P, Tuile T)
 {
     Debug.Log("CestMonNid");
     if (T.terrain == Tuile.Terrain.Nid)
     {
         foreach (Tuile t in Joueurs[0].Nids)
         {
             if (t == T)
             {
                 return(true);
             }
         }
     }
     return(false);
 }
Esempio n. 23
0
        public MainPage()
        {
            InitializeComponent();
            ServiceReference1.Service1Client cl = new Service1Client();
            cl.AddPionToGameSteCompleted += cl_AddPionToGameSteCompleted;
            Pion p = new Pion();

            p.Ijsschots = 33;
            p.LobbyID   = 5;
            p.Row       = 88;
            p.SpelerID  = 1;
            p.Column    = 4;

            cl.AddPionToGameSteAsync(p);
        }
Esempio n. 24
0
        public Plateau()
        {
            echiquier = new Piece[8, 8];
            pN1       = new Pion(false);
            pN2       = new Pion(false);
            pN3       = new Pion(false);
            pN4       = new Pion(false);
            pN5       = new Pion(false);
            pN6       = new Pion(false);
            pN7       = new Pion(false);
            pN8       = new Pion(false);

            pB1 = new Pion(true);
            pB2 = new Pion(true);
            pB3 = new Pion(true);
            pB4 = new Pion(true);
            pB5 = new Pion(true);
            pB6 = new Pion(true);
            pB7 = new Pion(true);
            pB8 = new Pion(true);

            cavN1 = new Cavalier(false);
            cavN2 = new Cavalier(false);

            cavB1 = new Cavalier(true);
            cavB2 = new Cavalier(true);

            fouN1 = new Fou(false);
            fouN2 = new Fou(false);

            fouB1 = new Fou(true);
            fouB2 = new Fou(true);

            tourN1 = new Tour(false);
            tourN2 = new Tour(false);

            tourB1 = new Tour(true);
            tourB2 = new Tour(true);

            reineN = new Reine(false);
            reineB = new Reine(true);

            roiN         = new Roi(false);
            roiB         = new Roi(true);
            roiB.Couleur = true;

            initierPlateau(echiquier);
        }
        /// <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);
            }
        }
        //Vierkanten maken van fotos in de bestanden
        public void CreateVierkanten()
        {
            GeheugenVierkanten = new ObservableCollection <PionViewModel>();

            for (int i = 0; i < 100; i++)
            {
                if (i == 42 || i == 43 || i == 46 || i == 47 || i == 52 || i == 53 || i == 56 || i == 57) //obstacles
                {
                    var model = new Pion();
                    model.ID         = i + 1;
                    model.FotoBron   = Path.Combine(Environment.CurrentDirectory + "/images/13_Obstacle.png");
                    model.Karakter   = "obstacle";
                    model.isMoveable = false;
                    var vierkant = new PionViewModel(model);
                    GeheugenVierkanten.Add(vierkant);
                }
                else
                {
                    var model = new Pion();
                    model.ID         = i + 1;
                    model.FotoBron   = Path.Combine(Environment.CurrentDirectory + "/images/00_Null_Grey.png");
                    model.Karakter   = "grey";
                    model.isMoveable = false;
                    var vierkant = new PionViewModel(model);
                    GeheugenVierkanten.Add(vierkant);
                }
            }

            //Cooördinaten definiëren
            int x = 0;

            for (int i = 0; i < 10; i++)
            {
                for (int j = 0; j < 10; j++)
                {
                    GeheugenVierkanten[x].X = i;
                    GeheugenVierkanten[x].Y = j;

                    x++;
                }
            }

            NotifyPropertyChanged();
        }
Esempio n. 27
0
        private int GetPozitieCurentaPion(Pion pion)
        {
            switch (_randJucator)
            {
            case 0:
                return(pion.CasutaCurenta.PozitieRosu);

            case 1:
                return(pion.CasutaCurenta.PozitieVerde);

            case 2:
                return(pion.CasutaCurenta.PozitieGalben);

            case 3:
                return(pion.CasutaCurenta.PozitieAlbastru);
            }
            //throw new InvalidRandJucator;
            return(0);
        }
Esempio n. 28
0
    /* Méthode pour la génération des plateau possible */
    //Liste les rafles de pion possible
    public List <Action> grapPossible(Pion pion, Action current, Board board)
    {
        List <Action> available = new List <Action>();

        for (int i = -1; i <= 1; i += 2)
        {
            for (int j = -1; j <= 1; j += 2)
            {
                if (j == i || j == -i)
                {
                    int xTarget = current.newPosition.x + i;
                    int yTarget = current.newPosition.y + j;
                    int xDest   = current.newPosition.x + 2 * i;
                    int yDest   = current.newPosition.y + 2 * j;

                    if (board.isCorrect(new Vector2Int(xTarget, yTarget)) &&
                        board.isCorrect(new Vector2Int(xDest, yDest)) &&
                        board.grille[xTarget, yTarget] != null &&
                        board.grille[xDest, yDest] == null)
                    {
                        if (board.grille[xTarget, yTarget].GetType() == typeof(Pion) &&
                            board.grille[xTarget, yTarget].color != pion.color)
                        {
                            // on interdis de resauter sur un pion deja raflé
                            if (!current.alreadyCaptured(new Vector2Int(xTarget, yTarget)))
                            {
                                Action tmp = new Action(current);
                                tmp.newPosition = new Vector2Int(xDest, yDest);
                                tmp.addCapture(new Vector2Int(xTarget, yTarget));
                                available.Add(tmp); // On ajoute l'action contenant la capture dans la liste de actions possibles
                            }
                        }
                    }
                }
            }
        }
        // On regarde si on peut faire une nouvelle capture
        foreach (Action ac in available.ToArray())
        {
            available.AddRange(grapPossible(pion, new Action(ac), board));
        }
        return(available);
    }
Esempio n. 29
0
    public void AddClone(Pion P, int direction)
    {
        Transform transform = this.transform.Find("Gue0" + direction.ToString());

        GameObject clone     = Instantiate(Resources.Load <GameObject>("PrefabGueriere"), transform.position, transform.rotation);
        Pion       pionClone = clone.GetComponent <Pion>();

        jeu.Clones.Add(pionClone);

        pionClone.direction    = direction;
        pionClone.joueur       = P.joueur;
        pionClone.race         = Pion.Race.Gueriere;
        pionClone.effet        = Pion.Effet.Transparant;
        pionClone.name         = "clone";
        pionClone.IsClone      = true;
        pionClone.IsSelectable = true;
        pionClone.tuile        = this;
        pionClone.jeu          = jeu;
    }
Esempio n. 30
0
        /// <summary>
        /// plaats een pion op dit veld
        /// </summary>
        /// <param name="pion">Pion</param>
        /// <returns>altijd ja</returns>
        public override bool Plaats(Pion pion)
        {
            CheckBarricade();

            //staat al iets op, sla deze pion
            if (Pionnen.Any())
            {
                foreach (var vorig in Pionnen.ToArray())
                {
                    var nieuwVeld = IsDorp ? (IVeld) pion.Speler.Spel.Bos : vorig.Speler.Startveld;
                    vorig.Verplaats(nieuwVeld);
                }

                Pionnen.Clear();
            }

            Pionnen.Add(pion);

            return true;
        }
Esempio n. 31
0
    //Retourne tous les déplacements que peut le pion fournie en paramètre
    public List <Action> getAvalaibleMove(Pion p, Board board)
    {
        List <Action> availableMove = new List <Action>();

        // On cherche les déplacements possibles
        for (int i = -1; i <= 1; i += 2)
        {
            for (int j = -1; j <= 1; j += 2)
            {
                int x = p.position.x + i;
                int y = p.position.y + j;
                if (x < board.size && x >= 0 && y < board.size && y >= 0 && board.grille[x, y] == null)
                {
                    availableMove.Add(new Action(p.position, new Vector2Int(x, y)));
                }
            }
        }
        availableMove.Add(new Action(p.position));
        // On cherche les prises qui font avancer
        availableMove.AddRange(grapPossible(p, new Action(p.position), board));
        return(availableMove);
    }
Esempio n. 32
0
        /// <summary>
        /// Recuperer la liste des zones entourants un pion
        /// </summary>
        /// <param name="p"></param>
        /// <param name="ep"></param>
        /// <returns></returns>
        public List <ZonePion> GetList(Pion p, List <ZonePion> ep)
        {
            List <ZonePion> zoneautour = new List <ZonePion>();


            var co1 = ep.Where(c => c.X == (p.Position.X - 1) && c.Y == (p.Position.Y - 1)).Single();
            var co2 = ep.Where(c => c.X == (p.Position.X - 1) && c.Y == (p.Position.Y)).Single();
            var co3 = ep.Where(c => c.X == (p.Position.X - 1) && c.Y == (p.Position.Y + 1)).Single();
            var co4 = ep.Where(c => c.X == (p.Position.X) && c.Y == (p.Position.Y - 1)).Single();
            var co5 = ep.Where(c => c.X == (p.Position.X) && c.Y == (p.Position.Y + 1)).Single();
            var co6 = ep.Where(c => c.X == (p.Position.X - 1) && c.Y == (p.Position.Y - 1)).Single();
            var co7 = ep.Where(c => c.X == (p.Position.X) && c.Y == (p.Position.Y - 1)).Single();
            var co8 = ep.Where(c => c.X == (p.Position.X + 1) && c.Y == (p.Position.Y - 1)).Single();

            zoneautour.Add(co1);
            zoneautour.Add(co2);
            zoneautour.Add(co3);
            zoneautour.Add(co4);
            zoneautour.Add(co5);
            zoneautour.Add(co6);
            zoneautour.Add(co7);
            zoneautour.Add(co8);
            return(zoneautour);
        }
Esempio n. 33
0
 /// <summary>
 /// Plaats pion op veld
 /// </summary>
 /// <param name="pion">Pion om er op te zetten</param>
 /// <returns>ja of nee</returns>
 public override bool Plaats(Pion pion)
 {
     Pionnen.Add(pion);
     return true;
 }
Esempio n. 34
0
 /// <summary>
 /// Plaats een pion in het bos
 /// </summary>
 /// <param name="pion">de pion</param>
 /// <returns>altijd true</returns>
 public bool Plaats(Pion pion)
 {
     //meerdere pionnen op dit veld toegestaan
     Pionnen.Add(pion);
     return true;
 }
Esempio n. 35
0
 public bool MagPion(Pion pion)
 {
     return true;
 }
Esempio n. 36
0
 public override bool MagPion(Pion pion)
 {
     return false;
 }
Esempio n. 37
0
 /// <summary>
 /// Geeft aan of die leeg is of niet.
 /// </summary>
 /// <param name="pion">Pion</param>
 /// <returns>ja of nee</returns>
 public override bool MagPion(Pion pion)
 {
     return Pionnen.Count == 0;
 }
Esempio n. 38
0
 public abstract bool Plaats(Pion pion);
Esempio n. 39
0
 /// <summary>
 /// Kijkt of er een pion op staat of er een pion geslagen kan worden
 /// </summary>
 /// <param name="pion">Pion</param>
 /// <returns>ja of nee</returns>
 public virtual bool MagPion(Pion pion)
 {
     return Pionnen.Count == 0 || !Pionnen.Select(other => other.Speler).Contains(pion.Speler);
 }
Esempio n. 40
0
 /// <summary>
 /// Plaats een pion op dit veld
 /// </summary>
 /// <param name="pion">de pion</param>
 /// <returns>een gewonnenexception</returns>
 public override bool Plaats(Pion pion)
 {
     Pionnen.Add(pion);
     throw new GewonnenException(pion.Speler);
 }