JUEGO DE POKER C# Propósito: Esta aplicación funcionará similar a un juego de póquer. El programa tratará a cabo 2 mano de cinco cartas y determinar qué contiene cada mano. FUNCIONES El programa creará una baraja de 52 cartas. Será entonces barajar "trato" 5 cartas para el Jugador uno y el jugador Dos. El programa evaluará lo que tiene cada mano y mostrar las tarjetas gráficamente por consola, así como la impresión del valor de las manos. Acont ALGORITMO Y PRECEDIMIENTO:

 namespace JUEGOPOKER
{
    class Program
    {
        static void Main(string[] args)
        {
 Console.SetWindowSize(65, 40);
 Console.BufferWidth = 65;
 Console.BufferHeight = 40;            
 Console.Title = "juego de Poker";
 RepartirCarta dc = new RepartirCarta();
 bool quit = false;

  while (!quit)
  {
 dc.Deal();

   char seleccion = ' ';
  while (!seleccion.Equals('S') && !seleccion.Equals('N'))
   {
    Console.WriteLine("                      JUGAR DE NUEVO? SI-NO");
   seleccion = Convert.ToChar(Console.ReadLine().ToUpper());

if (seleccion.Equals('S'))
  quit = false;
  else if (seleccion.Equals('N'))
  quit = true;
   else
    Console.WriteLine("Seleccion invalida. Inténtalo de nuevo");
    }
    }
     Console.ReadKey();
    }
    }
    }

CLASE BARAJA HEREDADA DE LA CLASE CARTA

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace JUEGOPOKER
{
    class Baraja : Carta
    {
        const int NumCarta = 52; 
        private Carta[] deck; 

        public Baraja()
        {
            deck = new Carta[NumCarta];
        }

        public Carta[] getDeck { get { return deck; } } 
        public void setUpDeck()
        {
            int i = 0;
            foreach(SUIT s in Enum.GetValues(typeof(SUIT)))
            {
                foreach(VALUE v in Enum.GetValues(typeof(VALUE)))
                {
                    deck[i] = new Carta { MySuit = s, MyValue = v };
                    i++;
                }
            }

            ShuffleCards();
        }

      
        public void ShuffleCards()
        {
            Random rand = new Random();
            Carta temp;

           
            for (int shuffleTimes = 0; shuffleTimes < 1000; shuffleTimes++)
            {
                for (int i = 0; i < NumCarta; i++)
                {
                    
                    int secondCardIndex = rand.Next(13);
                    temp = deck[i];
                    deck[i] = deck[secondCardIndex];
                    deck[secondCardIndex] = temp;
                }
            }
        }
    }
}

CLASE CARTA

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace JUEGOPOKER
{
    class Carta
    {
        public enum SUIT
        {
            CORAZON,
            PICA,
            DIAMANTE,
            TREBOL
        }

        public enum VALUE
        {
            DOS = 2, TRES, CUATRO, CINCO, SEIS, SIETE,
            OCHO,NUEVE, DIEZ, J, Q, K, A
        }
        
        //properties
        public SUIT MySuit { get; set; }
        public VALUE MyValue { get; set; }
    }
}

CLASE EVALUADOR DE MANO Se creo este métodos para comparar y determinar lo el jugar uno y el jugador dos espera. Utilizamos matrices para realizar comparaciones de las cartas.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace JUEGOPOKER
{
    public enum Mano
    {
        NADA,
        PAR,
        DOSPARES,
        TRIO,
        ESCALERA,
        COLOR,
        FULLHOUSE,
        POQUER
    }

    public struct ValorMano
    {
        public int Total { get; set; }
        public int HighCard { get; set; }
    }

    class EvaluarMano : Carta
    {
        private int corazonSum;
        private int diamanteSum;
        private int trebolSum;
        private int PicaSum;
        private Carta[] cartas;
        private ValorMano valormano;

        public EvaluarMano(Carta[] sortedHand)
        {
            corazonSum = 0;
            diamanteSum = 0;
            trebolSum = 0;
            PicaSum = 0;
            cartas = new Carta[5];
            Cards = sortedHand;
            valormano = new ValorMano();
        }

        public ValorMano HandValues
        {
            get { return valormano; }
            set { valormano = value; }
        }

        public Carta [] Cards
        {
            get { return cartas; }
            set
            {
                cartas[0] = value[0];
                cartas[1] = value[1];
                cartas[2] = value[2];
                cartas[3] = value[3];
                cartas[4] = value[4];
            }
        }

        public Mano EvaluateHand()
        {
            
            getNumberOfSuit();
            if (POQUER())
                return Mano.POQUER;
            else if (FULLHOUSE())
                return Mano.FULLHOUSE;
            else if (COLOR())
                return Mano.COLOR;
            else if (ESCALERA())
                return Mano.ESCALERA;
            else if (TRIO())
                return Mano.TRIO;
            else if (DOSPARES())
                return Mano.DOSPARES;
            else if (PAR())
                return Mano.PAR;
            
            valormano.HighCard = (int)cartas[4].MyValue;
            return Mano.NADA;
        }

        private void getNumberOfSuit()
        {
            foreach (var element in Cards)
            {
                if (element.MySuit == SUIT.CORAZON)
                    corazonSum++;
                else if (element.MySuit == SUIT.DIAMANTE)
                    diamanteSum++;
                else if (element.MySuit == SUIT.TREBOL)
                    trebolSum++;
                else if (element.MySuit == SUIT.PICA)
                    PicaSum++;
            }
        }

        private bool POQUER()
        {
           
            if(cartas[0].MyValue == cartas[1].MyValue && cartas[0].MyValue == cartas[2].MyValue && cartas[0].MyValue == cartas[3].MyValue)
            {
                valormano.Total = (int)cartas[1].MyValue * 4;
                valormano.HighCard = (int)cartas[4].MyValue;
                return true;
            }
            else if (cartas[1].MyValue == cartas[2].MyValue && cartas[1].MyValue == cartas[3].MyValue && cartas[1].MyValue == cartas[4].MyValue)
            {
                valormano.Total = (int)cartas[1].MyValue * 4;
                valormano.HighCard = (int)cartas[0].MyValue;
                return true;
            }

            return false;
        }

        private bool FULLHOUSE()
        {
            
            if ((cartas[0].MyValue == cartas[1].MyValue && cartas[0].MyValue == cartas[2].MyValue && cartas[3].MyValue == cartas[4].MyValue) ||
                (cartas[0].MyValue == cartas[1].MyValue && cartas[2].MyValue == cartas[3].MyValue && cartas[2].MyValue == cartas[4].MyValue))
            {
                valormano.Total = (int)(cartas[0].MyValue) + (int)(cartas[1].MyValue) + (int)(cartas[2].MyValue) +
                    (int)(cartas[3].MyValue) + (int)(cartas[4].MyValue);
                return true;
            }

            return false;
        }

        private bool COLOR()
        {
         
            if (corazonSum == 5 || diamanteSum == 5 || trebolSum == 5 || PicaSum == 5)
            {
                
                valormano.Total = (int)cartas[4].MyValue;
                return true;
            }

            return false;
        }

        private bool ESCALERA()
        {
            
            if (cartas[0].MyValue + 1 == cartas[1].MyValue &&
                cartas[1].MyValue + 1 == cartas[2].MyValue &&
                cartas[2].MyValue + 1 == cartas[3].MyValue &&
                cartas[3].MyValue + 1 == cartas[4].MyValue)
            {
                
                valormano.Total = (int)cartas[4].MyValue;
                return true;
            }

            return false;
        }

        private bool TRIO()
        {
            
            if ((cartas[0].MyValue == cartas[1].MyValue && cartas[0].MyValue == cartas[2].MyValue) ||
            (cartas[1].MyValue == cartas[2].MyValue && cartas[1].MyValue == cartas[3].MyValue))
            {
                valormano.Total = (int)cartas[2].MyValue * 3;
                valormano.HighCard = (int)cartas[4].MyValue;
                return true;
            }
            else if (cartas[2].MyValue == cartas[3].MyValue && cartas[2].MyValue == cartas[4].MyValue)
            {
                valormano.Total = (int)cartas[2].MyValue * 3;
                valormano.HighCard = (int)cartas[1].MyValue;
                return true;
            }
            return false;
        }

        private bool DOSPARES()
        {
            
            if (cartas[0].MyValue == cartas[1].MyValue && cartas[2].MyValue == cartas[3].MyValue)
            {
                valormano.Total = ((int)cartas[1].MyValue * 2) + ((int)cartas[3].MyValue * 2);
                valormano.HighCard = (int)cartas[4].MyValue;
                return true;
            }
            else if (cartas[0].MyValue == cartas[1].MyValue && cartas[3].MyValue == cartas[4].MyValue)
            {
                valormano.Total = ((int)cartas[1].MyValue * 2) + ((int)cartas[3].MyValue * 2);
                valormano.HighCard = (int)cartas[2].MyValue;
                return true;
            }
            else if (cartas[1].MyValue == cartas[2].MyValue && cartas[3].MyValue == cartas[4].MyValue)
            {
                valormano.Total = ((int)cartas[1].MyValue * 2) + ((int)cartas[3].MyValue * 2);
                valormano.HighCard = (int)cartas[0].MyValue;
                return true;
            }
            return false;
        }

        private bool PAR()
        {
            
            if (cartas[0].MyValue == cartas[1].MyValue)
            {
                valormano.Total = (int)cartas[0].MyValue * 2;
                valormano.HighCard = (int)cartas[4].MyValue;
                return true;
            }
            else if (cartas[1].MyValue == cartas[2].MyValue)
            {
                valormano.Total = (int)cartas[1].MyValue * 2;
                valormano.HighCard = (int)cartas[4].MyValue;
                return true;
            }
            else if (cartas[2].MyValue == cartas[3].MyValue)
            {
                valormano.Total = (int)cartas[2].MyValue * 2;
                valormano.HighCard = (int)cartas[4].MyValue;
                return true;
            }
            else if (cartas[3].MyValue == cartas[4].MyValue)
            {
                valormano.Total = (int)cartas[3].MyValue * 2;
                valormano.HighCard = (int)cartas[2].MyValue;
                return true;
            }

            return false;
        }

    }
}

CLASE MARCO DE LAS CARTAS Utilizamos métodos y propiedades para crear un motor de dibujo para mostrar nuestras cartas en la ventana de la consola. Creamos el contorno de la tarjeta e imprimimos la carta y el valor dentro de la carta utilizando la página de códigos 437

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace JUEGOPOKER
{
    class MarcoCarta
    {
      
        public static void DrawCardOutline (int xcoor, int ycoor)
        {
            


            Console.ForegroundColor = ConsoleColor.White;


            int x = xcoor * 12;
            int y = ycoor;

            Console.SetCursorPosition(x, y);
            Console.Write(" **********\n"); 

            for (int i = 0; i < 10; i++)
            {
                Console.SetCursorPosition(x, y + 1 + i);

                if (i != 9)
                    Console.WriteLine("*          *");
                else
                    Console.WriteLine("************");
            }
        }

        
        public static void DrawCardSuitValue(Carta card, int xcoor, int ycoor)
        {
            char cardSuit = ' ';
            int x = xcoor * 12;
            int y = ycoor;

          
            switch(card.MySuit)
            {
                case Carta.SUIT.CORAZON:
                    cardSuit = Encoding.GetEncoding(437).GetChars(new byte[] { 3 })[0];
                    Console.ForegroundColor = ConsoleColor.White;
                    break;
                case Carta.SUIT.DIAMANTE:
                    cardSuit = Encoding.GetEncoding(437).GetChars(new byte[] { 4 })[0];
                    Console.ForegroundColor = ConsoleColor.White;
                    break;
                case Carta.SUIT.TREBOL:

                    cardSuit = Encoding.GetEncoding(437).GetChars(new byte[] { 5 })[0];
                    Console.ForegroundColor = ConsoleColor.White;
                    break;
                case Carta.SUIT.PICA:
                    cardSuit = Encoding.GetEncoding(437).GetChars(new byte[] { 6 })[0];
                    Console.ForegroundColor = ConsoleColor.White;
                    break;
            }

          
            Console.SetCursorPosition(x +5 , y + 5);
            Console.Write(cardSuit);
            Console.SetCursorPosition(x + 4, y + 7);
            Console.Write(card.MyValue);

        }
    }
}

ESTA ES LA CLASE REPARTIR CARTA Creamos una clase Repartir Cartas que sirve como motor para repartir 5 cartas al Jugador uno y al Jugador dos. A continuación, ordenamos la mano para poder comparar los valores nominales más fáciles.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace JUEGOPOKER
{
    class RepartirCarta : Baraja
    {
        private Carta[] playeruno;
        private Carta[] playerdos;
        private Carta[] sortedPlayeruno;
        private Carta[] sortedplayerdos;

        public RepartirCarta()
        {
            playeruno = new Carta[5];
            sortedPlayeruno = new Carta[5];
            playerdos = new Carta[5];
            sortedplayerdos = new Carta[5];
        }

        public void Deal()
        {
            setUpDeck(); 
            getHand();//obtener mano
            ordenarcarta();
            presentacioncarta();
            evaluadormano();
        }

        public void getHand()
        {
            
            for (int i = 0; i < 5; i++)
                playeruno[i] = getDeck[i];

            
            for (int i = 5; i < 10; i++)
                playerdos[i -5] = getDeck[i];
        }

        public void ordenarcarta()
        {
            var queryPlayer = from hand in playeruno
                              orderby hand.MyValue
                              select hand;

            var queryComputer = from hand in playerdos
                                orderby hand.MyValue
                                select hand;

            var index = 0;
            foreach(var element in queryPlayer.ToList())
            {
                sortedPlayeruno[index] = element;
                index++;
            }

            index = 0;
            foreach (var element in queryComputer.ToList())
            {
                sortedplayerdos[index] = element;
                index++;
            }
        }

        public void presentacioncarta()
        {
            Console.Clear();
            int x = 0; 
            int y = 1;

           
            Console.WriteLine("                           JUGADOR UNO");
            for (int i = 0; i < 5; i++)
            {
                MarcoCarta.DrawCardOutline(x, y);
                MarcoCarta.DrawCardSuitValue(sortedPlayeruno[i], x, y);
                x++;
            }
            y = 15; 
            x = 0; 
            Console.SetCursorPosition(x, 14);
            Console.ForegroundColor = ConsoleColor.DarkRed;
            Console.WriteLine("                            JUGADOR DOS");
            for (int i = 5; i < 10; i++)
            {
                MarcoCarta.DrawCardOutline(x, y);
                MarcoCarta.DrawCardSuitValue(sortedplayerdos[i - 5], x, y);
                x++;
            }

        }

        public void evaluadormano()
        {
          
            EvaluarMano playerHandEvaluator = new EvaluarMano(sortedPlayeruno);
            EvaluarMano computerHandEvaluator = new EvaluarMano(sortedplayerdos);

            
            Mano playeruno = playerHandEvaluator.EvaluateHand();
            Mano playerdos = computerHandEvaluator.EvaluateHand();

            
            Console.WriteLine("\n\n\n\n\n                      JUGADOR UNO: " + playeruno);
            Console.WriteLine("\n                      JUGADOR DOS: " + playerdos);

            //evaluar las manos
            if (playeruno > playerdos)
            {
                Console.WriteLine("\n                      JUGADOR UNO GANADOR!");
            }
            else if (playeruno < playerdos)
            {
                Console.WriteLine("\n                      JUGADOR DOS GANADOR!");
            }
            else //Si las manos son los mismos, evaluar los valores
            {
                //Primero en evalua quién tiene mayor en valor de la mano de póker
                if (playerHandEvaluator.HandValues.Total > computerHandEvaluator.HandValues.Total)
                    Console.WriteLine("\n                      JUGADOR UNO GANADOR!");
                else if (playerHandEvaluator.HandValues.Total < computerHandEvaluator.HandValues.Total)
                    Console.WriteLine("\n                      JUGADOR DOS GANADOR!");
               
                else if (playerHandEvaluator.HandValues.HighCard > computerHandEvaluator.HandValues.HighCard)
                    Console.WriteLine("\n                      JUGADOR UNO GANADOR!");
                else if (playerHandEvaluator.HandValues.HighCard < computerHandEvaluator.HandValues.HighCard)
                    Console.WriteLine("\n                      JUGADOR DOS GANADOR!");
                else
                    Console.WriteLine("\n                      NO HAY GANADOR!");
            }
        }
    }
}

En esta parte final del código en el cual se comparan las manos de POKER de los jugadores y determinar el ganador. A continuación, mostramos los resultados en la pantalla. LINK DE DESCARGA https://drive.google.com/open?id=0BwJNBThSd1cfWDZTbUtnWFd1ajg