Пример #1
0
        public static List <TrainCard> Shuffle(this List <TrainCard> cards)
        {
            Random r = new Random();

            //Step 1: For each unshuffled item in the collection
            for (int n = cards.Count - 1; n > 0; --n)
            {
                //Step 2: Randomly pick an item which has not been shuffled
                int k = r.Next(n + 1);

                //Step 3: Swap the selected item with the last "unstruck" letter in the collection
                TrainCard temp = cards[n];
                cards[n] = cards[k];
                cards[k] = temp;
            }

            return(cards);
        }
Пример #2
0
        public static void addTrainCards(List <TrainCard> cardlist)
        {
            ExtensionMethods.niceLayout("adding traincards");
            TrainCard card;

            for (int i = 0; i < 8; i++)
            {
                for (int j = 0; j < 12; j++)
                {
                    card = new TrainCard((Color)i);
                    cardlist.Add(card);
                }
            }
            for (int i = 0; i < 14; i++)
            {
                card = new TrainCard((Color)8);
                cardlist.Add(card);
            }
            Program.logboek.WriteLine(cardlist.ToArray().Length + "\tTrainCards added");
        }
Пример #3
0
        private static void initializeTrainCardPics(List <foto> pics, Dictionary <TrainCard, foto> traincardpics)
        {
            for (int i = 0; i < 9; i++)
            {
                TrainCard card = new TrainCard((Color)i);
                traincardpics.Add(card, default(foto));
            }


            foreach (foto pic in pics)
            {
                foreach (KeyValuePair <TrainCard, foto> p in traincardpics)
                {
                    if (pic.getName().ToUpper() == p.Key.ToString().ToUpper())
                    {
                        traincardpics[p.Key] = pic;
                        break;
                    }
                }
            }
        }
Пример #4
0
    public bool Claim(TrainCard pick, Player player, int claimsLeft)
    {
        if (pick == null)
        {
            if (!TicketDeck.CanDraw())
            {
                throw new ArgumentException("There is nothing left to draw");
            }

            player.Tickets.Add(TicketDeck.Draw());
            return(claimsLeft > 0);
        }

        player.Tickets.Add(pick);

        TicketDisplay[TicketDisplay.FindIndex(pick)] = null;

        EnsureTicketDisplayValid();

        return(pick.Color != Color.Any && TicketDisplay.Any(c => c?.Color != Color.Any) && claimsLeft > 0);
    }
Пример #5
0
 protected void Render(TrainCard subject)
 {
     Console.WriteLine($"{subject.Color}");
 }
Пример #6
0
        public static bool Pickcards(Player player, Railroad road)
        {
            Dictionary <TrainCard, int> traincards = player.GetTraincards();
            {
                int               amountOfLocomotives = road.getAmountOfLocomotives();
                int               railLength          = road.getRailLength() - amountOfLocomotives;
                Color             kleur     = road.getColor();
                bool              hasCard   = false;
                int /*temp = 0,*/ maxamount = 0;
                Console.WriteLine("this track needs {0} locomotives", amountOfLocomotives);
                if (amountOfLocomotives > 0)
                {
                    foreach (KeyValuePair <TrainCard, int> playercard in traincards)        // met index werken?
                    {
                        if (playercard.Key.getColor() == Color.Locomotief)
                        {
                            hasCard = true;
                            if (playercard.Value >= amountOfLocomotives)
                            {
                                Console.WriteLine("you have enough locomotives");
                                player.GetTraincards()[playercard.Key] -= amountOfLocomotives;
                                TrainCard card = playercard.Key;
                                for (int i = 0; i < amountOfLocomotives; i++)
                                {
                                    usedCardsDeck.Add(card);
                                }
                                break;
                            }
                            else
                            {
                                Console.WriteLine("you don't have enough locomotives to make the track");
                                if (!(player is IntelligentPlayer))
                                {
                                    MessageBox.Show("you don't have enough locomotives to make the track");
                                }
                                return(false);
                            }
                        }
                    }
                    if (!hasCard)
                    {
                        Console.WriteLine("you dont have any locomotives");
                        if (!(player is IntelligentPlayer))
                        {
                            MessageBox.Show("you don't have enough locomotives to make the track");
                        }
                        return(false);
                    }
                }


                // de maximumwaarde wordt gezocht
                int amountLoco = 0;
                foreach (KeyValuePair <TrainCard, int> card in traincards)
                {
                    if (card.Value > maxamount && card.Key.getColor() != Color.Locomotief)
                    {
                        maxamount = card.Value;
                    }
                    else if (card.Key.getColor() == Color.Locomotief)
                    {
                        amountLoco = card.Value;
                    }
                }
                maxamount += amountLoco;

                if (railLength > 0)
                {
                    if (railLength <= maxamount)
                    {
                        bool colorfound = false;
                        if (kleur == Color.Grijs)
                        {
                            TrainCard traincard = null;
                            Console.WriteLine("Please chose a color");
                            //bool firsttime = true;
                            string a = null;
                            Dictionary <TrainCard, int> possibleCard = goodCards(player, railLength);
                            /*misschien beter een dictionary van object int maken*/
                            Dictionary <string, int> possiblities = new Dictionary <string, int>();
                            foreach (KeyValuePair <TrainCard, int> de in possibleCard)
                            {
                                a += "\t" + de.Key.ToString();
                                possiblities.Add(de.Key.ToString(), (int)de.Key.getColor());
                            }
                            Console.WriteLine(a);
                            if (!(player is IntelligentPlayer))
                            {
                                int val = GetInput(possiblities, player);
                                traincard = new TrainCard((Color)val);
                            }
                            else
                            {
                                traincard = new TrainCard((Color)possiblities.Values.ToList()[0]);
                                // sorry, heb hiervoor geen intelligentie meer geïmplementeerd
                            }
                            foreach (KeyValuePair <TrainCard, int> card in traincards)
                            {
                                if (card.Key.getColor() == traincard.getColor())
                                {
                                    if (railLength > card.Value)
                                    {
                                        int temp = card.Value;
                                        railLength -= temp;
                                        TrainCard tCard = card.Key;
                                        for (int i = 0; i < temp; i++)
                                        {
                                            usedCardsDeck.Add(tCard);
                                        }
                                        traincards[card.Key] = 0;
                                        foreach (KeyValuePair <TrainCard, int> trCard in traincards)
                                        {
                                            if (trCard.Key.getColor() == Color.Locomotief)
                                            {
                                                traincards[trCard.Key] -= railLength;
                                                tCard = trCard.Key;
                                                for (int i = 0; i < railLength; i++)
                                                {
                                                    usedCardsDeck.Add(tCard);
                                                }
                                                return(true);
                                            }
                                        }
                                    }
                                    else
                                    {
                                        traincards[card.Key] -= railLength;
                                        traincard             = card.Key;
                                        for (int i = 0; i < railLength; i++)
                                        {
                                            usedCardsDeck.Add(traincard);
                                        }
                                        return(true);
                                    }
                                }
                            }
                        }

                        else
                        {
                            // indien de kleur van het spoort vasligt
                            foreach (KeyValuePair <TrainCard, int> card in traincards)
                            {
                                if (card.Key.getColor() == kleur)
                                {
                                    colorfound = true;
                                    // indien je voldoende kaarten hebt van die kleur (zonder locomotieven bij te leggen)
                                    if (card.Value >= railLength)
                                    {
                                        traincards[card.Key] -= railLength;
                                        player.addRailroad(road);
                                        TrainCard trCard = card.Key;
                                        for (int i = 0; i < railLength; i++)
                                        {
                                            usedCardsDeck.Add(trCard);
                                        }
                                        return(true);
                                    }
                                    else
                                    {
                                        foreach (KeyValuePair <TrainCard, int> pair in traincards)
                                        {
                                            if (pair.Key.getColor() == Color.Locomotief)
                                            {
                                                int val = traincards[card.Key];
                                                traincards[card.Key]  = 0;
                                                traincards[pair.Key] -= (railLength - val);
                                                TrainCard trCard = card.Key;
                                                for (int i = 0; i < railLength - val; i++)
                                                {
                                                    usedCardsDeck.Add(trCard);
                                                }
                                                return(true);
                                            }
                                        }
                                    }
                                }
                                else if (amountLoco >= railLength)
                                {
                                    foreach (KeyValuePair <TrainCard, int> pair in traincards)
                                    {
                                        if (pair.Key.getColor() == Color.Locomotief)
                                        {
                                            traincards[pair.Key] -= (railLength);
                                            TrainCard trCard = pair.Key;
                                            for (int i = 0; i < railLength; i++)
                                            {
                                                usedCardsDeck.Add(trCard);
                                            }
                                            return(true);
                                        }
                                    }
                                }
                            }
                            return(false);

                            if (!colorfound)
                            {
                                if (amountLoco >= railLength)
                                {
                                    foreach (KeyValuePair <TrainCard, int> card in traincards)
                                    {
                                        traincards[card.Key] -= amountLoco;
                                        TrainCard trCard = card.Key;
                                        for (int i = 0; i < railLength; i++)
                                        {
                                            usedCardsDeck.Add(trCard);
                                        }
                                        return(true);
                                    }
                                }
                                Console.WriteLine("U heeft geen kaarten van dit type kleur");
                                if (!(player is IntelligentPlayer))
                                {
                                    MessageBox.Show("you dont have any cards of this type color");
                                }
                            }
                        }
                    }
                    else
                    {
                        Console.WriteLine("you dont have enough cards of the same type to build the track");
                        if (!(player is IntelligentPlayer))
                        {
                            MessageBox.Show("you dont have enough cards of the same type to build the track");
                        }
                    }
                }
                else
                {
                    player.addRailroad(road);
                    Console.WriteLine("The railroad {0} was successfully added", road.ToString());
                    ExtensionMethods.WaitForUser();
                    return(true);
                }
                //ExtensionMethods.WaitForUser();
                returnLocomotives(traincards, amountOfLocomotives);
                return(false);
            }
        }
Пример #7
0
        }   // ez done

        public static bool BuildStation(Player player, List <City> cityList)
        {
            if (player.GetAmountOfUnplacedStations() > 0)                                // indien er nog ongeplaatste stationnen zijn
            {
                /******************************
                 * checking if the player has enough cards of the same type
                 *******************************/
                citylist = cityList;
                Dictionary <string, int> possibilities = new Dictionary <string, int>();
                TrainCard tCard = null;
                int       amountOfsameCardsNeeded = 4 - player.GetAmountOfUnplacedStations(); // # kaarten van het zelfde type dat nodig is
                Program.logboek.WriteLine(string.Format("you need {0} card{1} of the same type", amountOfsameCardsNeeded,
                                                        ((4 - player.GetAmountOfUnplacedStations()) > 1) ? "s" : ""));
                Dictionary <TrainCard, int> viableCards = goodCards(player, amountOfsameCardsNeeded);

                if (viableCards.Count > 0)                                  // indien de speler genoeg kaarten heeft
                {
                    Program.logboek.WriteLine("These are The Posibilities");
                    string a = null;
                    foreach (KeyValuePair <TrainCard, int> de in viableCards)
                    {
                        a += "\t" + de.Key.ToString();
                        possibilities.Add(de.Key.ToString(), (int)(de.Key.getColor()));
                    }
                    Program.logboek.WriteLine(a);                               // de mogelijke kaarten worden uitgeprint

                    /******************************
                     * player input
                     *******************************/
                    ExtensionMethods.niceLayout("asking input");
                    if (player is IntelligentPlayer)
                    {
                        tCard = new TrainCard((Color)((IntelligentPlayer)player).ChoseOption(Possibilities.leastImportantTraincard));
                    }
                    else
                    {
                        int cardval = GetInput(possibilities, player);
                        tCard = new TrainCard((Color)cardval);
                    }

                    /******************************
                     * removing the cards from the players
                     *******************************/
                    foreach (KeyValuePair <TrainCard, int> card in player.GetTraincards())
                    {
                        if (card.Key.getColor() == tCard.getColor())
                        {
                            // gaan we ervan uitgaan dat hij alle kaarten gebruikt indien hij er genoeg heeft
                            if (card.Value >= amountOfsameCardsNeeded)
                            {
                                TrainCard trCard = card.Key;
                                for (int i = 0; i < card.Value; i++)
                                {
                                    usedCardsDeck.Add(trCard);
                                }
                                player.GetTraincards()[card.Key] -= amountOfsameCardsNeeded;
                                break;
                            }

                            else if (card.Value < amountOfsameCardsNeeded)
                            {
                                foreach (KeyValuePair <TrainCard, int> trcard in player.GetTraincards())
                                {
                                    if (trcard.Key.getColor() == Color.Locomotief)
                                    {
                                        amountOfsameCardsNeeded         -= player.GetTraincards()[card.Key];
                                        player.GetTraincards()[card.Key] = 0;
                                        TrainCard kaart = trcard.Key;
                                        player.GetTraincards()[trcard.Key] -= amountOfsameCardsNeeded;
                                        for (int i = 0; i < amountOfsameCardsNeeded; i++)
                                        {
                                            usedCardsDeck.Add((kaart));
                                        }
                                        break;
                                    }
                                }
                                break;
                            }
                        }
                    }


                    /******************************
                     * Player input for city name
                     *******************************/
                    int val = 0;
                    val = player.ChoseOption(Possibilities.stationCities);
                    City stad = getCity(val);
                    if (stad != null)
                    {
                        player.setStation(stad);
                        stad.DrawCircle(player, Program.form.pictureBox1);
                        return(true);
                    }
                    else
                    {
                        throw new NullReferenceException();
                    }
                }
                else
                {
                    Program.logboek.WriteLine("You don't have enough cards of the same cards");
                    if (!(player is IntelligentPlayer))
                    {
                        MessageBox.Show(string.Format("You don't have enough cards of the same type," +
                                                      "\n\t you need atleast {0} cards of the same type", amountOfsameCardsNeeded));
                    }
                }
            }
            else
            {
                Program.logboek.WriteLine("this is impossible to do, you don't have any stations left!");
                if (!(player is IntelligentPlayer))
                {
                    MessageBox.Show("this is impossible to do, since you don't have any stations left!");
                }
            }
            return(false);
        }
Пример #8
0
        public static bool PickTrainCards(Player player, List <TrainCard> deck, List <TrainCard> visibleDeck,
                                          int roundNumber, List <foto> gamePics, List <TrainCard> favourableCards = null)
        {
            // visibleTraincards = visibleDeck;

            /******************************
             * playerInput
             *******************************/
            int       i = 0, val = 0;
            TrainCard card       = null;
            bool      Locomotive = false;

            while (Locomotive == false && i < 2)
            // de spelers mogen 2 kaarten nemen (tenzij ze een locomotief nemen in de eerste ronde
            {
                Program.logboek.WriteLine("");
                Program.logboek.WriteLine("1.\tPick an invisible card");
                Program.logboek.WriteLine("2.\tPick a visible card");
                val = player.ChoseOption(Possibilities.Traincard);    // geïmplementeerd bij intelligente speler

                switch (val)
                {
                case (int)Cardoptions.Invisible:
                    /******************************
                     * Onzichtbare kaart
                     *******************************/
                    card = CardMethods <TrainCard> .pickAndRemoveCardsFromDeck(deck);

                    player.addCard(card);
                    Program.logboek.WriteLine(string.Format(
                                                  "{0} picked an invisible card, that was a {1} traincard", player.GetName(), card.ToString()));
                    if (!(player is IntelligentPlayer))
                    {
                        MessageBox.Show(string.Format("{0} picked an invisible card, that was a {1} traincard",
                                                      player.GetName(), card.ToString()));
                    }
                    break;

                case (int)Cardoptions.Visible:
                    /******************************
                     * Zichtbare kaart
                     *******************************/
                    Program.logboek.WriteLine("Please type the name of the card you want to pick");
                    bool cardFound = false;
                    while (cardFound == false)
                    {
                        val       = player.ChoseOption(Possibilities.visibleTraincards); // override bij intelligente spelers
                        cardFound = true;

                        if (i == 1 && cardFound)
                        // indien geen geneste if krijg ik een fout omdat het object card --> null (nulreferenceException)
                        {
                            if ((Color)val == Color.Locomotief)
                            // indien het de 2de (sub) beurt is en de gevonden kaart geen locomotief is
                            {
                                Program.logboek.WriteLine("you can't pick an locomotive as a visible card");
                                if (!(player is IntelligentPlayer))
                                {
                                    MessageBox.Show("you can't pick an locomotive as a visible card, in you second turn");
                                    cardFound = false;
                                }
                            }
                        }

                        if (cardFound)
                        {
                            cardFound = false;
                            foreach (TrainCard tCard in visibleDeck)
                            {
                                /******************************
                                 * swapping card form dack
                                 *******************************/
                                if (tCard.getColor() == (Color)val)
                                {
                                    card = CardMethods <TrainCard> .pickAndRemoveCardsFromDeck(visibleDeck, visibleDeck.IndexOf(tCard));

                                    CardMethods <TrainCard> .swapCardFromDeck(deck, visibleDeck);

                                    player.addCard(card);
                                    Program.logboek.WriteLine("valid");
                                    cardFound = true;
                                    Program.form.refreshVisibleTrainCards(visibleDeck);
                                    //Round.Header(visibleDeck, roundNumber, player);
                                    if (tCard.ToString() == Convert.ToString(Color.Locomotief))
                                    {
                                        Locomotive = true;
                                    }
                                    break;     /*sorrynotsorry*/
                                }
                            }
                            if (!cardFound)
                            {
                                Program.logboek.WriteLine("the card you selected isn't available on the visible deck");
                                if (!(player is IntelligentPlayer))
                                {
                                    MessageBox.Show("the card you selected isn't available on the visible deck");
                                }
                            }
                        }
                    }
                    break;
                }
                i++;
            }
            return(true);
        }       // done