TLlop - Clon del Tetris

Llop Site Home > JAVA > TLlop > Opciones de juego

Opciones de juego:

Clase OpcionesJuego

package ejercicio_5;

import java.io.*;
import java.awt.event.*;

/** Título: TLlop
    Descripción: Prácticas capítulo 11, ejercicio 5
    Copyright: Copyright (c) 2005
    Empresa: Casa_Llop
    @author Albert_Lobo
    @version 1.5  */

/** En esta clase se almacenan todas las variables del juego; además, proporciona métodos para conocer
    su valor, y modificarlo. Implementa la interfaz 'Serializable' porque interesa poder guardar objetos
    de esta clase al disco, a modo de archivo de opciones. */
public class OpcionesJuego implements Serializable
{
  private byte frecuenciaAparicionPiezas [];
  private boolean piezasDisponibles [];
  private byte numeroPiezas;
  private String disenoPieza;
  private byte nivelInicial;
  private byte lineasCambioNivel;
  private byte lineasRellenasInicio;
  private boolean seVeSiguientePieza;
  private boolean gravedadReal;
  private byte cuadradosX;
  private byte cuadradosY;
  private EnteroYCadena top10 [];
  private int controles [];
  private String fondoPanel;
  private String fondoCuadricula;

  /** Constructor. Llama a 'valoresPorDefecto ()' para inicializar las variables. */
  public OpcionesJuego ()
  {
    valoresPorDefecto ();
  }

  /** Inicializa las variables a sus valores por defecto. */
  private void valoresPorDefecto ()
  {
    /** La frecuencia de aparición (en tanto por ciento) de las 7 piezas de siempre.
        Los valores corresponden, en orden, a: Cuadrado, Barra, Ese, Zeta, Ele invertida, Ele, y Te.*/
    frecuenciaAparicionPiezas = new byte [] {16, 11, 16, 14, 14, 13, 16};
    /** Tabla de 35 booleanos que indican si la pieza con la que se corresponden está disponible.
        Los booleanos corresponden a las siguientes piezas, en este orden:
          - Cuadrado, Barra, Ese, Zeta, Ele invertida, Ele, Te,
            Destructora, Cuadradillo, Barra dos, Diagonal dos, Barra tres, Ese tres, Zeta tres,
            Diagonal tres, Ele tres, Uve tres, Olas, Olas invertidas, Paralelas, Ese separada,
            Zeta separada, Diagonal, Coma, Coma invertida, Ángulo recto, Uve, Uve invertida,
            Ese larga, Zeta larga, Sombrero, Flecha, Acento cerrado, Acento abierto, y Media aspa. */
    piezasDisponibles = new boolean [] {true, true, true, true, true, true, true,
                                       false, false, false, false, false, false, false,
                                       false, false, false, false, false, false, false,
                                       false, false, false, false, false, false, false,
                                       false, false, false, false, false, false, false};
    /** Cadena con uno de los 5 diseños de pieza disponibles. */
    disenoPieza = Pieza.CUADRADILLO;
    /** Ruta absoluta de la imagen usada como fondo de la ventana. */
    fondoPanel = PanelJuego.FONDO1;
    /** Ruta absoluta de la imagen usada como fondo del panel de juego. */
    fondoCuadricula = PanelCuadricula.FONDO_CUADRICULA1;
    /** Entero con el 'nivel' (la velocidad de caída de las piezas) con que se empiezan las partidas. */
    nivelInicial = 5;
    /** Variable con el número de líneas a reventar hasta subir el 'nivel'. */
    lineasCambioNivel = 10;
    /** Número de líneas parcialmente rellenas (+-40%) con que se empiezan las partidas. */
    lineasRellenasInicio = 0;
    /** 'true' para mostrar la siguiente pieza en la cuadrícula pequeña, y 'false' para lo contrario. */
    seVeSiguientePieza = true;
    /** Variable booleana: 'true' para utilizar el algoritmo de 'gravedad real' al reventar líneas,
        y false para no utilizarlo. */
    gravedadReal = true;
    /** Número de cuadradillos de ancho de la cuadrícula por defecto. */
    cuadradosX = 10;
    /** Número de cuadradillos de alto de la cuadrícula por defecto. */
    cuadradosY = 21;
    /** Tabla para las 10 mejores puntuaciones registradas, y sus autores. Se inicializan con
        el constructor por defecto de 'EnteroYCadena', es decir, que todas las puntuaciones son de 0. */
    top10 = new EnteroYCadena [10];
    for (byte i = 0; i < top10.length; i++)
      top10 [i] = new EnteroYCadena ();
    /** Tabla de enteros con los 'virtual key codes' de las teclas que ejecutan alguna acción.
        Patrón de los controles: Izquierda, Derecha, Abajo, AbajoDelTodo, RotaIzquierda, RotaDerecha,
                                 Pausa, Opciones, Reset, TerminaJuego, SubeNivel, CambiaMúsica,
                                 VerSiguientePieza, y GravedadReal. */
    controles = new int [] {KeyEvent.VK_LEFT, KeyEvent.VK_RIGHT, KeyEvent.VK_DOWN, KeyEvent.VK_SPACE,
                            KeyEvent.VK_N, KeyEvent.VK_M, KeyEvent.VK_P, KeyEvent.VK_O, KeyEvent.VK_R,
                            KeyEvent.VK_T, KeyEvent.VK_I, KeyEvent.VK_U, KeyEvent.VK_Y, KeyEvent.VK_G};
  }

  /** Define el diseño de los cuadradillos que forman las piezas.
      @param diseno String  : Nuevo diseño para los cuadradillos de las piezas. */
  public void setDiseno (String diseno)
  {
    disenoPieza = diseno;
  }

  /** Método para conocer el diseño de los cuadradillos que forman las piezas.
      @return String  : Cadena con la descripción del diseño actual de las piezas. */
  public String getDiseno ()
  {
    return disenoPieza;
  }

  /** Define el fondo de la ventana del programa.
      @param nuevoFondo String  : Cadena con la ruta absoluta del nuevo fondo de ventana. */
  public void setFondoPanel (String nuevoFondo)
  {
    fondoPanel = nuevoFondo;
  }

  /** Devuelve la imagen de fondo de la ventana.
      @return String  : Ruta absoluta de la imagen del fondo de la ventana. */
  public String getFondoPanel ()
  {
    return fondoPanel;
  }

  /** Define el fondo de la cuadrícula de juego, y la de la siguiente pieza.
      @param nuevoFondo String  : Cadena con la ruta absoluta del nuevo fondo de las cuadrículas. */
  public void setFondoCuadricula (String nuevoFondo)
  {
    fondoCuadricula = nuevoFondo;
  }

  /** Devuelve la imagen de fondo de la cuadrícula de juego la de la siguiente pieza.
      @return String  : Ruta absoluta de la imagen del fondo de las cuadrículas. */
  public String getFondoCuadricula ()
  {
    return fondoCuadricula;
  }

  /** Define la disponiblilidad de una pieza durante la partida.
      @param pieza byte          : Número de la pieza cuya disponibilidad se va a definir.
      @param disponible boolean  : 'true' para poder jugar con la pieza, 'false' para lo contrario. */
  public void setPiezaDisponible (byte pieza, boolean disponible)
  {
    piezasDisponibles [pieza] = disponible;
  }

  /** Función para conocer la disponiblidad de una pieza.
      @param pieza byte  : Número de la pieza cuya disponibilidad quiere conocerse.
      @return boolean    : 'true' si la pieza está disponible, y 'false' si no lo está. */
  public boolean getPiezaDisponible (byte pieza)
  {
    return piezasDisponibles [pieza];
  }

  /** Función para conocer las piezas disponibles para la partida, y su frecuencia de aparición.
      @return float[][]  : Tabla con las piezas disponibles en la primera fila, y sus respectivas
                           frecuencias de aparición, en tanto por ciento, en la segunda. */
  public float [][] getPiezasDisponibles ()
  {
    float retorno [][] = new float [2][35];
    byte indice = 0;
    byte i;
    float frecuenciaAparicion;
    float offset = 0;

    /** Se meten las piezas especiales disponibles. */
    for (i = 8; i < 35; i++)
      if (piezasDisponibles [i])
        retorno [0][indice++] = i;

    /** Se meten las frecuencias de aparición de las piezas especiales. */
    if (indice != 0)
    {
      frecuenciaAparicion = (float) 17.5 / indice;
      offset = (float) 2.5;
      for (i = 0; i < indice; i++)
        retorno [1][i] = frecuenciaAparicion;
    }

    /** A continuación se meten las 7 piezas clásicas, y su frecuencia de aparición. */
    for (i = 0; i < 7; i++)
    {
      retorno [0][indice] = i;
      retorno [1][indice++] = frecuenciaAparicionPiezas [i] - offset;
    }

    /** La pieza número 7 es la destructora, y ésta debe tener una frecuencia de aparición muy baja
        -del 3%, concretamente-, por lo que, si está disponible, además de añadirla al retorno, hay
        que hacer hueco en la frecuencia de aparición del resto de las piezas. */
    if (piezasDisponibles [7])
    {
      retorno [0][indice] = 7;
      retorno [1][indice] = 3;
      offset = (float) 3 / indice;
      for (i = 0; i < indice; i++)
        retorno [1][i] -= offset;
    }

    /** Se ajusta la variable con el total de piezas disponibles. */
    numeroPiezas = (byte) (indice + 1);

    return retorno;
  }

  /** Función para conocer cuántas piezas están disponibles.
      @return byte  : Número de piezas disponibles en la partida. */
  public byte getNumeroPiezas ()
  {
    return numeroPiezas;
  }

  /** Define el nivel inicial del juego.
      @param valor byte  : Nuevo nivel con el que se empezarán las partidas. */
  public void setNivelInicial (byte valor)
  {
    nivelInicial = valor;
  }

  /** Devuelve el nivel inicial del juego.
      @return byte  : Valor del nivel inicial del juego. */
  public byte getNivelInicial ()
  {
    return nivelInicial;
  }

  /** Define las líneas a reventar hasta subir el nivel de juego.
      @param valor byte  : Nuevo número de líneas hasta subir nivel. */
  public void setLineasCambioNivel (byte valor)
  {
    lineasCambioNivel = valor;
  }

  /** Función que devuelve las líneas a completas para subir el nivel de juego.
      @return byte  : Número de líneas a reventar hasta subir el nivel de juego. */
  public byte getLineasCambioNivel ()
  {
    return lineasCambioNivel;
  }

  /** Método para definir el número de líneas parcialmente rellenas que hay al empezar el juego.
      @param valor byte  : Líneas parcialmente rellenas. */
  public void setLineasRellenasInicio (byte valor)
  {
    lineasRellenasInicio = valor;
  }

  /** Devuelve cuántas líneas hay medio rellenas al comenzar una partida.
      @return byte  : Número de líneas parcialmente rellenas al empezar el juego. */
  public byte getLineasRellenasInicio ()
  {
    return lineasRellenasInicio;
  }

  /** Define si la siguiente pieza está visible en la cuadrícula pequeña.
      @param bool boolean  : 'true' si se ve la siguiente pieza, y 'false' si no. */
  public void setSeVeSiguientePieza (boolean bool)
  {
    seVeSiguientePieza = bool;
  }

  /** Método para conocer la visiblidad de la siguiente pieza, en la cuadrícula pequeña.
      @return boolean  : 'true' o 'false' según la siguiente pieza se ve o no. */
  public boolean getSeVeSiguientePieza ()
  {
    return seVeSiguientePieza;
  }

  /** Determina si la gravedad real se utilizará durante el juego.
      @param bool boolean  : 'true' o 'false' según se desee activar o desactivar la gravedad real. */
  public void setGravedadReal (boolean bool)
  {
    gravedadReal = bool;
  }

  /** Devuelve si la gravedad real se utliza.
      @return boolean  : 'true' o 'false' según haya gravedad real o no. */
  public boolean getGravedadReal ()
  {
    return gravedadReal;
  }

  /** Define el número de cuadradillos a lo ancho que tendrá la cuadrícula de juego.
      @param valor byte  : Nuevo número de cuadradillos a lo ancho de la cuadrícula. */
  public void setCuadradosX (byte valor)
  {
    cuadradosX = valor;
  }

  /** Devuelve cuántos cuadradillos a lo ancho tiene la cuadrícula de juego.
      @return byte  : Número de cuadradillos a lo ancho de la cuadrícula. */
  public byte getCuadradosX ()
  {
    return cuadradosX;
  }

  /** Define el número de cuadradillos a lo alto que tendrá la cuadrícula de juego.
      @param valor byte  : Nuevo número de cuadradillos a lo alto de la cuadrícula. */
  public void setCuadradosY (byte valor)
  {
    cuadradosY = valor;
  }

  /** Devuelve cuántos cuadradillos a lo alto tiene la cuadrícula de juego.
      @return byte  : Número de cuadradillos a lo alto de la cuadrícula. */
  public byte getCuadradosY ()
  {
    return cuadradosY;
  }

  /** Introduce un nuevo récord en el 'top10' actual.
      @param nuevoRecord EnteroYCadena  : Nuevo récord a meter en el 'top10'.  */
  public void setRecord (EnteroYCadena nuevoRecord)
  {
    byte i;
    byte j = 0;
    /** Bucle que busca la pocición que 'nuevoRecord' debe ocupar en 'top10'. */
    for (i = (byte) (top10.length - 1); i >= 0; i--)
      if (nuevoRecord.getEntero () > top10 [i].getEntero ())
        j = i;
    /** Corre los récords inferiores un lugar abajo. */
    for (i = (byte) (top10.length - 1); i > j; i--)
      top10 [i] = top10 [i - 1];
    /** Establece el nuevo récord. */
    top10 [j] = nuevoRecord;
  }

  /** Método para conocer la menor de las puntuaciones máximas.
      @return long  : Entero con la puntuación del último registro de 'top10'. */
  public long getUltimoRecord ()
  {
    return top10 [9].getEntero ();
  }

  /** Método que toma el array 'top10', y añade sus elementos a una cadena.
      @return String  : Cadena con los récords establecidos. */
  public String getTop10 ()
  {
    /** Con la etiqueta  al inicio de la cadena, se pueden poner saltos de línea en el texto. */
    String retorno = "";
    for (byte i = 0; i < top10.length; i++)
    {
      /** El bucle termina cuando uno de los récords es 0. */
      if (top10 [i].getEntero () == 0)
        break;
      /** El nombre del jugador es 'Anónimo' si no entró su nombre. */
      retorno += (top10 [i].getCadena ().equals ("") ? "Anónimo" : top10 [i].getCadena ())
                 + " - " + top10 [i].getEntero () + "";
    }
    return retorno;
  }

  /** Método para saber cuántas de teclas de control hay.
      @return byte  : Número de teclas de control. */
  public byte getNumeroControles ()
  {
    return (byte) controles.length;
  }

  /** Método para conocer los controles actuales del juego.
      @return int[]  : Array con los controles del juego. */
  public int [] getControles ()
  {
    return controles;
  }

  /** Define los controles del juego.
      @param nuevosControles int[]  : Array de enteros con los nuevos controles. */
  public void setControles (int nuevosControles [])
  {
    for (byte i = 0; i < controles.length; i++)
      controles [i] = nuevosControles [i];
  }
}

¿Comentarios, sugerencias?: llopsite.at.yahoo.es | © 2005-07 Albert Lobo

Última actualización: 18-Feb-2007