Ledger Nano X - The secure hardware wallet
SHARE
TWEET

Untitled

a guest Apr 7th, 2020 151 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2. * Representa la mesa de juego, donde estarán todas las cartas.
  3. * Tendrá dos partes diferenciadas:
  4. * - la parte interior, donde inicialmente estarán colocadas las cartas correctamente para jugar al solitario
  5. * - los montones exteriores, donde estarán colocadas las cartas por palo ordenadas de menor a mayor
  6. * Estructura: Se utilizarán TADs adecuados para su respresentación. En concreto:
  7. * - Una matriz de Pilas para representar la parte o montón interior
  8. * - Un array de Pilas para representar los montones exteriores.
  9. * Funcionalidad: colocar las cartas para iniciar el juego, quitar una carta de la parte interior, colocar una carta en el interior,
  10. * colocar una carta en el montón exterior correspondiente, visualizar cartas en la mesa, etc
  11.  
  12. La Pila es una estructura de datos que existe en Java y que se corresponde con la clase Stack. Por lo tanto debereis
  13. La Pila es una estructura de datos que existe en Java y que se correspohacer uso de dicha
  14. clase para representar la mesa de juego, y en particular de los métodos que se indican a continuación (de ser necesarios):
  15.  
  16.         public boolean empty();
  17.         // Produce: Si la pila está vacía devuelve true, sino false.
  18.         public Carta peek();
  19.         // Produce: Devuelve la Carta del tope de la pila, sin eliminarla de ella.
  20.         public Carta pop();
  21.         // Produce: Elimina la Carta del tope de la pila y la devuelve.
  22.         public void push(Carta item);
  23.         // Produce: Introduce la Carta en el tope de la pila.
  24.  */
  25.  
  26. package solitario.Core;
  27.  
  28. import java.util.Stack;
  29.  
  30.  
  31. /**
  32.  *
  33.  * @author Eva Castiñeiras Puente
  34.  */
  35. public class Mesa {
  36.     private final int NUM_STACKS = 4;
  37.    
  38.     private final Stack<Carta> [] montonExterior;     // 4 palos // Palos
  39.     private final Stack<Carta> [][] montonInterior;   // 10 cartas // Juego
  40.  
  41.     public Mesa() {
  42.         // Inicializamos el tamaño
  43.         this.montonExterior = new Stack[4];
  44.         this.montonInterior = new Stack[NUM_STACKS][NUM_STACKS];
  45.         // Creamos los montones vacío
  46.         for(int i = 0; i < this.montonExterior.length; i++)
  47.             this.montonExterior[i] = new Stack<>();
  48.         for(int i = 0; i < this.montonInterior.length; i++)
  49.             for(int j = 0; j < this.montonInterior[i].length; j++)
  50.                 this.montonInterior[i][j] = new Stack<>();        
  51.     }
  52.    
  53.     public void iniciarElJuego(){
  54.         // Obtenemos la baraja
  55.         Baraja baraja = new Baraja();
  56.         // Barajar
  57.         baraja.desordenar();
  58.        
  59.         /* Poner las cartas en la mesa */
  60.        
  61.         // 1.- Colocar 16 cartas boca abajo
  62.         for(int fila = 0; fila < NUM_STACKS; fila++)
  63.             for(int columna = 0; columna < NUM_STACKS; columna++)
  64.                 this.repartirCarta(baraja, fila, columna);
  65.        
  66.         // 2.- Colocar cartas en la diagonal
  67.         for(int posicion = 0; posicion < NUM_STACKS; posicion++)
  68.         {
  69.             // Principal
  70.             this.repartirCarta(baraja, posicion, posicion);
  71.             // Secundaria
  72.             this.repartirCarta(baraja, posicion, NUM_STACKS-posicion-1);
  73.         }
  74.        
  75.         // 3.- Colocar 16 cartas boca arriba
  76.         for(int fila = 0; fila < NUM_STACKS; fila++)
  77.             for(int columna = 0; columna < NUM_STACKS; columna++)
  78.                 this.repartirCarta(baraja, fila, columna);
  79.     }
  80.    
  81.     private void repartirCarta(Baraja baraja, int fila, int columna) {
  82.         Carta carta = baraja.cartaSuperior();
  83.         this.montonInterior[fila][columna].push(carta);
  84.     }
  85.    
  86.     public void mostrar() {
  87.         // Creamos una foto del estado actual de la mesa
  88.         StringBuilder estadoActual = new StringBuilder();
  89.         // Recorremos la mesa por filas y columnas
  90.         for(int fila = 0; fila < NUM_STACKS; fila++)
  91.         {
  92.             for(int columna = 0; columna < NUM_STACKS; columna++)
  93.             {
  94.                 // Mostramos el icono de la carta, si existe
  95.                 Stack<Carta> posicion = this.montonInterior[fila][columna];
  96.                 String icono = posicion.empty() ? "--" : posicion.peek().toIcon();
  97.                 estadoActual.append(icono);
  98.                 estadoActual.append("  ");
  99.             }
  100.             estadoActual.append("\n");
  101.         }
  102.        
  103.         estadoActual.append("\n");
  104.         for(int palo = 0; palo < 4; palo++) {
  105.             // Mostramos el icono de la carta, si existe
  106.             Stack<Carta> posicion = this.montonExterior[palo];
  107.             String icono = posicion.empty() ? "--" : posicion.peek().toIcon();
  108.             estadoActual.append(icono);
  109.             estadoActual.append("  ");
  110.         }
  111.         // Mostramos la foto del estado actual de la mesa
  112.         System.out.println(estadoActual.toString());
  113.     }
  114.    
  115.     public void moverAlExterior(int fila, int columna) throws Exception {
  116.         // Comprobamos si está vacío
  117.         if(this.montonInterior[fila][columna].empty())
  118.             throw new Exception("No puedes mover cartas donde nos las hay");
  119.         // Miramos qué carta es
  120.         Carta carta = this.montonInterior[fila][columna].peek();
  121.         // Buscamos el palo donde debería ir
  122.         Stack<Carta> palo = this.montonExterior[carta.getPalo().ordinal()];
  123.         // Comprobamos si se puede colocar
  124.         if (carta.getNumero() == 1                                                                 // Si es 1
  125.                 || (carta.getNumero() != 10 && carta.getNumero() - 1 == palo.peek().getNumero())   // Si es 2-7 ó 11-12
  126.                 || palo.peek().getNumero() == 7)                                                   // Si es 10
  127.         {
  128.             palo.push(this.montonInterior[fila][columna].pop());
  129.         // Evitamos que el juego permita colocar cartas no permitidas en el exterior
  130.         } else { throw new Exception("No se puede mover la carta " + carta.toIcon() + " al exterior"); }
  131.     }
  132.    
  133.     /**
  134.      * Método para poder mover una carta de posición dentro del montón interior.
  135.      * La carta movida ha de ser del mismo palo y un número menor que la carta
  136.      * sobre la que se quiere colocar.
  137.      *
  138.      * @param ifila Fila de la carta que se quiere mover
  139.      * @param icolumna Columna de la carta que se quiere mover
  140.      * @param ffila Fila de la posición a la que se quiere mover
  141.      * @param fcolumna Columna de la posición a la que se quiere mover
  142.      * @throws Exception Impide movimientos no autorizados
  143.      */
  144.     public void moverAlInterior(int ifila, int icolumna, int ffila, int fcolumna) throws Exception {
  145.         // Comprobamos si está vacío
  146.         if(this.montonInterior[ifila][icolumna].empty() || this.montonInterior[ffila][fcolumna].empty())
  147.             throw new Exception("No puedes mover cartas donde nos las hay");
  148.         // Miramos qué cartas son
  149.         Carta origen    = this.montonInterior[ifila][icolumna].peek();
  150.         Carta destino   = this.montonInterior[ffila][fcolumna].peek();
  151.         // Comprobamos que sean del mismo palo y que cumpla las condiciones de número
  152.         if(origen.getPalo() == destino.getPalo()                                                    // Son del mismo palo
  153.                 && origen.getNumero() != 12 &&                                                      // No es 12
  154.                 (origen.getNumero() != 7 && origen.getNumero() + 1 == destino.getNumero()           // Si es 1-6 ó 10-11
  155.                 || destino.getNumero() == 10))                                                      // Si es 7
  156.         {
  157.             this.montonInterior[ffila][fcolumna].push(this.montonInterior[ifila][icolumna].pop());
  158.         // Evitamos que el juego permita colocar cartas no permitidas encima de otras cartas
  159.         } else { throw new Exception("No se puede mover la carta " + origen.toIcon() + " encima de " + destino.toIcon()); }
  160.     }
  161. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top