public void Tasuj(int ile)
 {
     for (int i = 0; i < ile; i++)
     {
         Queue <Karta> nowyStol = new Queue <Karta>(Karty.OrderBy(a => Guid.NewGuid()));
         Karty = nowyStol;
     }
 }
Esempio n. 2
0
 private void AfterDragLista(bool rezultat)
 {
     if (!rezultat)
     {
         Karty.Add(TymczasowoWybranaKarta, Comparer);
         TymczasowoWybranaKarta = null;
     }
 }
Esempio n. 3
0
 private void DropLista()
 {
     Karty.Add(TymczasowoWybranaKarta, Comparer);
     AktualnieWybranaKarta  = null;
     TymczasowoWybranaKarta = null;
     TypRuchu = null;
     //todo obadać
     //Gra.CofnijRuch();
 }
Esempio n. 4
0
        /// <summary>
        /// Wypelnia dealera oraz inicjuje karty NSWE wywolujac konstruktor klasy Karty.
        /// </summary>
        /// <param name="input">Linia wejscia to "4SA7HJ986DT5CKT972,S92H743DQ743CA843,SJ854HQ2DAKJ92CQ5,SKQT63HAKT5D86CJ6" w kolejności SWNE</param>
        public RozkladKart(string input)
        {
            dealer = (positions)(int.Parse(input[0].ToString()));
            string[] rozklad = input.Substring(1).Split(',');

            N = new Karty(rozklad[2]);
            S = new Karty(rozklad[0]);
            W = new Karty(rozklad[1]);
            E = new Karty(rozklad[3]);
        }
Esempio n. 5
0
        private void DropKarta(TypRuchu typ)
        {
            if (AktualnieWybranaKarta != null)
            {
                Karty.Add(AktualnieWybranaKarta, Comparer);
            }
            Karty.Remove(TymczasowoWybranaKarta);
            AktualnieWybranaKarta  = TymczasowoWybranaKarta;
            TymczasowoWybranaKarta = null;
            TypRuchu = typ;
            Ruch ruch = new Ruch(Gracz, AktualnieWybranaKarta, TypRuchu.Value);

            Gra.WykonajRuch(ruch);
        }
Esempio n. 6
0
        /// <summary>
        /// Wypisuje caly uklad w jednej linii, ale niestety nie da sie go wkleić w jakiś fragment tekstu. Bo tworzy caly paragraf.
        /// </summary>
        /// <param name="karty">Karty wg struktury karty</param>
        /// <param name="p"></param>
        /// <returns>Paragraf z rozkladem w jednej linii</returns>
        public static Paragraph WriteHandInOneLine(Karty karty)
        {
            Paragraph p = new Paragraph();

            p = WriteHandSuit(suits.spade, karty.spades, p);

            p = WriteHandSuit(suits.heart, karty.hearts, p);

            p = WriteHandSuit(suits.diamond, karty.diamonds, p);

            p = WriteHandSuit(suits.club, karty.clubs, p);

            return(p);
        }
Esempio n. 7
0
        /// <summary>
        /// Wypisuje rękę gracza. Każdy kolor w osobnej linii
        /// </summary>
        /// <param name="karty">Karty gracza w strukturze Karty</param>
        /// <returns>Paragraf z ręką</returns>
        public static Paragraph WriteHand(Karty karty, Paragraph p = null)
        {
            if (p == null)
            {
                p = new Paragraph();
            }

            p = WriteHandSuit(suits.spade, karty.spades, p); p.AddLineBreak();

            p = WriteHandSuit(suits.heart, karty.hearts, p); p.AddLineBreak();

            p = WriteHandSuit(suits.diamond, karty.diamonds, p); p.AddLineBreak();

            p = WriteHandSuit(suits.club, karty.clubs, p); p.AddLineBreak();

            return(p);
        }
Esempio n. 8
0
 private void BeforeDragLista(Karta karta)
 {
     TymczasowoWybranaKarta = karta;
     Karty.Remove(karta);
 }
Esempio n. 9
0
        static void Main(string[] args)
        {
            Karty karty = new Karty();

            karty.Gra();
        }
Esempio n. 10
0
 public Karta Rozdaj()
 {
     return(Karty.Dequeue());
 }
Esempio n. 11
0
        static void Main()
        {
            Karty poker = new Karty();

            Console.Write("Ile rąk rozdać? (2-5): ");
            int ilosc = int.Parse(Console.ReadLine());

            int[,] wynikTab = new int[ilosc, 4]; //[ID Reki, ID z tablicy ukladTab] np[2,0] wyświetli ID układu trzeciej ręki
            int[] uklady = new int[ilosc];
            for (int i = 0; i < ilosc; i++)
            {
                Console.WriteLine("\nRęka {0}: ", i + 1);
                int[] wynik = poker.Sprawdz(poker.Rozdaj());
                for (int j = 0; j < wynik.Length; j++)
                {
                    wynikTab[i, j] = wynik[j];
                }
                uklady[i] = wynik[0]; // Indeksy numerów układów; indeks danego numeru to indeks ręki
            }
            /// I STOPIEN - Uklad się nie powtarza ///
            int licznik = 0;

            for (int i = 0; i < ilosc; i++)
            {
                if (uklady.Max() == uklady[i])
                {
                    licznik++;
                }
            }
            ;
            if (licznik == 1) // Najprostsza opcja, największy układ występuje raz i łatwo go wyłonić
            {
                Console.WriteLine("\nWygrywa ręka: {0}!", Array.IndexOf(uklady, uklady.Max()) + 1);
            }
            else
            {
                int j = 0;
                while (j != 3)
                {
                    int[] indeksyNajwiekszych = new int[licznik];
                    for (int i = 0; i < licznik; i++)
                    {
                        if (i == 0)
                        {
                            indeksyNajwiekszych[i] = Array.IndexOf(uklady, uklady.Max());
                        }
                        else if (i > 0)
                        {
                            indeksyNajwiekszych[i] = Array.IndexOf(uklady, uklady.Max(), indeksyNajwiekszych[i - 1] + 1);
                        }
                    }
                    int[] kickery = new int[licznik];
                    for (int i = 0; i < licznik; i++)
                    {
                        kickery[i] = wynikTab[indeksyNajwiekszych[i], 1 + j]; // Tablica przechowująca indeksy kickerów najwyzszych ukladów
                    }
                    int licznikKickerow = 0;
                    for (int i = 0; i < licznik; i++)
                    {
                        if (kickery[i] == kickery.Max())
                        {
                            licznikKickerow++;
                        }
                    }
                    if (licznikKickerow == 1)
                    {
                        Console.WriteLine("\nWygrywa ręka: {0}!", indeksyNajwiekszych[Array.IndexOf(kickery, kickery.Max())] + 1);
                        j = 3;
                        ////////////// TESTY////////////////
                        Console.WriteLine("\n" + poker.hierarchiaUkladow[uklady.Max()] + ", powtarza się " + licznik + " razy");
                        Console.WriteLine("I są na rękach: ");
                        for (int i = 0; i < licznik; i++)
                        {
                            Console.WriteLine(indeksyNajwiekszych[i] + 1 + " " + poker.figura[kickery[i]]);
                        }
                        //////////////////////////////////////
                    }
                    else
                    {
                        j++;
                    }
                }
                ;
            }

            /*                                                                                                             Tu komentarz
             * /// II STOPIEN - Uklad się powtarza i I znacząca sie nie powtarza ///
             * else if(licznik > 1)
             * {
             *  int[] indeksyNajwiekszych = new int[licznik];
             *  for(int i = 0; i < licznik; i++)
             *  {
             *      if (i == 0)
             *      {
             *          indeksyNajwiekszych[i] = Array.IndexOf(uklady, uklady.Max());
             *      }
             *      else if(i > 0)
             *      {
             *          indeksyNajwiekszych[i] = Array.IndexOf(uklady, uklady.Max(),indeksyNajwiekszych[i-1]+1);
             *      }
             *  }
             *  int[] kickery = new int[licznik];
             *  for(int i = 0; i < licznik; i++)
             *  {
             *      kickery[i] = wynikTab[indeksyNajwiekszych[i], 1]; // Tablica przechowująca indeksy kickerów najwyzszych ukladów
             *  }
             *  int licznikKickerow = 0;
             *  for(int i = 0; i< licznik; i++)
             *  {
             *      if(kickery[i] == kickery.Max())
             *      {
             *          licznikKickerow++;
             *      }
             *  }
             *  if(licznikKickerow == 1)
             *  {
             *      Console.WriteLine("\nWygrywa ręka: {0}!",indeksyNajwiekszych[Array.IndexOf(kickery, kickery.Max())] + 1);
             *  }
             *  /// III STOPIEN - Uklad się powtarza i I znacząca się powtarza, ale II znacząca się nie powtarza ///
             *  else if(licznikKickerow > 1)
             *  {
             *      Console.WriteLine("XDXDXD");
             *  }
             *  ////////////// TESTY////////////////
             *
             *  Console.WriteLine("\n" + poker.hierarchiaUkladow[uklady.Max()] + ", powtarza się " + licznik + " razy");
             *  Console.WriteLine("I są na rękach: ");
             *  for (int i = 0; i < licznik; i++)
             *  {
             *      Console.WriteLine(indeksyNajwiekszych[i] + 1 + " " + poker.figura[kickery[i]]);
             *  }
             *
             *  //////////////////////////////////////
             * }                                                                                                             Aż do tąd */
            Console.WriteLine("\nNaciśnij dowolny przycisk aby zakończyć");
            Console.Read();
        }