ArkaLlop - Clon del Arkanoid

Llop Site Home > JAVA > ArkaLlop > Pantalla de menú

Pantalla de menú:

Clase PantallaMenu

package arkallop;

import java.lang.*;
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

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

/** Clase que extiende 'JPanel', y que sirve como pantalla de menú.
    Consta de un panel con pestañas al que se añaden:
      - un panel con un dibujo de presentación,
      - un panel en el que se pueden ajustar algunas opciones,
      - y otro panel con las instrucciones del juego.
    También incorpora un botón para pasar a la pantalla de juego. */
public class PantallaMenu extends JPanel
{
  // La partida actual.
  private Partida partida;

  // Panel con pestañas.
  private JTabbedPane pnlInicio;

  // Panel con la imagen de presentación, panel de las opciones, y panel de la información.
  private PanelConFondo pnlFondo;
  private PanelOpciones pnlOpciones;
  private PanelInformacion pnlInfo;
  // Botón para pasar al juego.
  private ArkaButton boton;

  // Variables que se ajustarán a través del panel de opciones:
  // el escenario inicial, la imagen de fondo, y el modo de juego.
  private byte escenarioInicial;
  private byte fondoEscenario;
  private byte modoJuego;

  // Array de bytes que contendrá un muro -un 'nivel'- para previsualizar en el panel de opciones.
  private byte muestraEscenario [][];

  /** Constructor.
      @param nuevaPartida Partida  Esta partida. */
  public PantallaMenu (Partida nuevaPartida)
  {
    // Llamar al constructor de la superclase, y establecer un gestor de diseño 'BorderLayout'.
    super ();
    setLayout (new BorderLayout ());

    // Inicializar las variables y los componentes.
    partida = nuevaPartida;
    inicializaVariables ();
    inicializaComponentes ();

    // Añadir los componentes al panel.
    add (pnlInicio, BorderLayout.CENTER);
    add (boton, BorderLayout.SOUTH);
  }

  /** Inicializa las variables. */
  public void inicializaVariables ()
  {
    // Obtenemos las variables de la partida.
    escenarioInicial = partida.getEscenarioInicial ();
    fondoEscenario = partida.getFondoEscenario ();
    modoJuego = partida.getModoJuego ();

    muestraEscenario = ColeccionNiveles.getNivel (String.valueOf (escenarioInicial + 1));
  }

  /** Inicializa los componentes. */
  public void inicializaComponentes ()
  {
    // Inicializa los 3 sub-paneles.
    pnlFondo = new PanelConFondo ();
    pnlOpciones = new PanelOpciones ();
    pnlInfo = new PanelInformacion ();

    // Inicializa el panel con pestañas, y añade los 3 sub-paneles.
    pnlInicio = new JTabbedPane ();
    pnlInicio.setForeground (Color.red);
    pnlInicio.setFont (ArkaLlop.getFuenteBeyondWonderland ());
    pnlInicio.addTab ("Juego", pnlFondo);
    pnlInicio.addTab ("Opciones", pnlOpciones);
    pnlInicio.addTab ("Informacion", pnlInfo);

    // Inicializa el botón que lleva a la pantalla de juego para empezar la partida.
    boton = new ArkaButton ();
    boton.setAction (new AbstractAction ("Jugar")
    {
      public void actionPerformed (ActionEvent evento)
      {
        // Se ajustan las opciones, por si ha habido cambios, y se pasa a la pantalla de juego.
        partida.setOpciones (escenarioInicial, fondoEscenario, modoJuego);
        partida.cambioAJuego ();
      }
    });
  }

  /** Clase interna que extiende 'JPanel'. Este panel se limita a mostrar una imagen. */
  class PanelConFondo extends JPanel
  {
    // La imagen de fondo del panel.
    private Image imgFondo;

    /** Constructor. */
    public PanelConFondo ()
    {
      // Llamada al constructor de la superclase, e inicialización de la imagen de fondo.
      super ();
      imgFondo = ArkaLlop.getImagen ("caratula.jpg");
    }

    /** Se sobrecarga esta la función para que pinte la imagen de fondo.
        @param graficos Graphics  Contexto 'Graphics' sobre el que pintamos. */
    public void paint (Graphics graficos)
    {
      super.paint (graficos);
      graficos.drawImage (imgFondo, 0, 0, null);
    }
  }

  /** Clase interna que extiende 'JPanel'.
      Permite ajustar el escenario inicial de la partida, la imagen de fondo, y el modo de juego. */
  class PanelOpciones extends JPanel
  {
    // La fuente del panel, una tabla de colores (para los ladrillos de la vista previa del muro),
    // y una tabla de imágenes para la vista previa de los fondos del juego.
    private Font fuente;
    private Color colores [];
    private Image imagenes [];

    // Lista desplegable para los niveles.
    private JComboBox listaNiveles;
    // Etiqueta para la vista previa de las imagenes de fondo.
    private JLabel etqImagenFondo;
    // Botones para ajustar las opciones 'fondo del juego', y 'modo del juego'.
    private ArkaButton btnFonodoMenos;
    private ArkaButton btnFonodoMas;
    private ArkaButton btnModoJuegoMenos;
    private ArkaButton btnModoJuegoMas;

    /** Constructor. */
    public PanelOpciones ()
    {
      // Llama al constructor de la superclase, y pone un gestor de diseño nulo.
      super ();
      setLayout (null);

      // Se inicializan las variables y los componentes.
      inicializaVariables ();
      inicializaComponentes ();
    }

    /** Inicializa las variables. */
    private void inicializaVariables ()
    {
      // Inicializa la fuente, los fondos, y los colores.
      fuente = ArkaLlop.getFuenteBeyondWonderland ().deriveFont (28);
      imagenes = new Image [FondosPantalla.TOTAL_FONDOS];
      for (byte i = 0; i < FondosPantalla.TOTAL_FONDOS; i++)
        imagenes [i] = FondosPantalla.getImagenFondo (i).getScaledInstance (205, 160, Image.SCALE_DEFAULT);
      // Inicializa los colores con su valor RGB en HEX.
      colores = new Color [] {new Color (Integer.decode ("#FFFFFF").intValue ()),
                              new Color (Integer.decode ("#FFFF00").intValue ()),
                              new Color (Integer.decode ("#0033FF").intValue ()),
                              new Color (Integer.decode ("#CC0099").intValue ()),
                              new Color (Integer.decode ("#993300").intValue ()),
                              new Color (Integer.decode ("#FF6600").intValue ()),
                              new Color (Integer.decode ("#33FFFF").intValue ()),
                              new Color (Integer.decode ("#FF0000").intValue ()),
                              new Color (Integer.decode ("#00CC00").intValue ()),
                              new Color (Integer.decode ("#66CC66").intValue ()),
                              new Color (Integer.decode ("#666666").intValue ())};
    }

    /** Inicializa los componentes. */
    private void inicializaComponentes ()
    {
      // Rellenamos la lista desplegable con un array de 'String's que lleva los números
      // del "1" al "45".
      String contenidoLista [] = new String [ColeccionNiveles.TOTAL_NIVELES];
      for (byte i = 0; i < ColeccionNiveles.TOTAL_NIVELES; i++)
        contenidoLista [i] = String.valueOf (i + 1);
      listaNiveles = new JComboBox (contenidoLista);
      // Le ponemos fuente, color, tamaño, y ubicación.
      listaNiveles.setFont (fuente);
      listaNiveles.setForeground (Color.red);
      listaNiveles.setLocation (20, 135);
      listaNiveles.setSize (110, 40);
      // Si se detecta algún cambio, habrá que ajustar la variable del escenario inicial, la
      // vista previa del muro de ladrillos, y repintar para que se note el cambio.
      listaNiveles.setAction (new AbstractAction ()
      {
        public void actionPerformed (ActionEvent evento)
        {
          escenarioInicial = (byte) listaNiveles.getSelectedIndex ();
          muestraEscenario = ColeccionNiveles.getNivel (String.valueOf (escenarioInicial + 1));
          repaint ();
        }
      });

      // Inicializamos la etiqueta para la vista previa del fondo, y le ponemos
      // la imagen del fondo de pantalla actual.
      etqImagenFondo = new JLabel ();
      etqImagenFondo.setIcon (new ImageIcon (imagenes [fondoEscenario]));
      // Establecemos tamaño y ubicación.
      etqImagenFondo.setSize (205, 180);
      etqImagenFondo.setLocation (30, 305);
      // Inicializamos los botones para gestionar la opción 'fondo del juego'.
      // Este botón pone a 'etqImagenFondo' la anterior imagen del array de fondos, y repinta.
      btnFonodoMenos = new ArkaButton ();
      btnFonodoMenos.setAction (new AbstractAction ()
      {
        public void actionPerformed (ActionEvent evento)
        {
          // Si estamos al principio del array, volvemos al final.
          if (fondoEscenario == 0)
            fondoEscenario = 3;
          else
            fondoEscenario--;
          etqImagenFondo.setIcon (new ImageIcon (imagenes [fondoEscenario]));
          repaint ();
        }
      });
      btnFonodoMenos.setLocation (145, 295);
      // Este botón pone a 'etqImagenFondo' la siguiente imagen del array de fondos, y repinta.
      btnFonodoMas = new ArkaButton ();
      btnFonodoMas.setAction (new AbstractAction ()
      {
        public void actionPerformed (ActionEvent evento)
        {
          // Si estamos al final del array, volvemos al principio.
          if (fondoEscenario == 3)
            fondoEscenario = 0;
          else
            fondoEscenario++;
          etqImagenFondo.setIcon (new ImageIcon (imagenes [fondoEscenario]));
          repaint ();
        }
      });
      btnFonodoMas.setLocation (205, 295);
      // Inicializamos los botones para gestionar la opción 'modo de juego'.
      // Tanto el uno como el otro disparan la misma acción:
      // cambiar el modo de juego (que será o 'COMPETICION' o 'ENTRENAMIENTO').
      btnModoJuegoMenos = new ArkaButton ();
      btnModoJuegoMenos.setAction (new AbstractAction ()
      {
        public void actionPerformed (ActionEvent evento)
        {
          if (modoJuego == Partida.COMPETICION)
            modoJuego = Partida.ENTRENAMIENTO;
          else
            modoJuego = Partida.COMPETICION;
          repaint ();
        }
      });
      btnModoJuegoMenos.setLocation (360, 330);
      btnModoJuegoMas = new ArkaButton ();
      btnModoJuegoMas.setAction (btnModoJuegoMenos.getAction ());
      btnModoJuegoMas.setLocation (425, 330);

      // Ponemos el texto a los botones del panel (unas flechas) -genuino arte ASCII.
      btnFonodoMenos.setText ("<-");
      btnFonodoMas.setText ("->");
      btnModoJuegoMenos.setText ("<-");
      btnModoJuegoMas.setText ("->");

      // Añadir todos estos componentes al panel.
      add (listaNiveles);
      add (btnFonodoMenos);
      add (btnFonodoMas);
      add (btnModoJuegoMenos);
      add (btnModoJuegoMas);
      add (etqImagenFondo);
    }

    /** Función sobrecargada para pintar los bordes del panel.
        @param graficos Graphics  Contexto 'Graphics' sobre el que pintar. */
    public void paintBorder (Graphics graficos)
    {
      super.paintBorder (graficos);

      graficos.setColor (Color.blue);
      // Pinta un rectángulo redondeado azul alrededor de cada una de las 3 'zonas de opción'.
      graficos.drawRoundRect (10, 30, 470, 220, 10, 10);
      graficos.drawRoundRect (25, 240, 250, 240, 10, 10);
      graficos.drawRoundRect (240, 270, 250, 220, 10, 10);

      // Pinta un rectángulo redondeado azul alrededor de cada una de las 3 opciones seleccionadas.
      graficos.drawRoundRect (60, 199, 199, 30, 10, 10);
      graficos.drawRoundRect (5, 460, 150, 30, 10, 10);
      graficos.drawRoundRect (255, 355, 230, 30, 10, 10);
    }

    /** Método sobrecargado. Pinta la vista previa del muro, y los textos de ayuda.
        @param graficos Graphics  Contexto 'Graphics' sobre el que se pinta. */
    public void paint (Graphics graficos)
    {
      super.paint (graficos);

      // Los ladrillos del muro.
      for (byte i = 0; i < 11; i++)
        for (byte j = 0; j < 13; j++)
        {
          if (muestraEscenario [j][i] != -1)
          {
            graficos.setColor (getColor (muestraEscenario [j][i]));
            graficos.fillRoundRect (140 + (i * 30), 20 + (j * 15), 28, 13, 2, 2);
            graficos.setColor (Color.black);
            graficos.drawRoundRect (140 + (i * 30), 20 + (j * 15), 28, 13, 2, 2);
          }
        }

      graficos.setFont (fuente);
      graficos.setColor (Color.red);
      // Los textos que orientan sobre cada opción.
      graficos.drawString ("Escoja el", 18, 50);
      graficos.drawString ("escenario", 18, 75);
      graficos.drawString ("inicial.", 18, 100);
      graficos.drawString ("Escenario " + String.valueOf (escenarioInicial + 1), 80, 220);
      graficos.drawString ("Escoja el fondo del", 20, 285);
      graficos.drawString ("escenario.", 20, 310);
      graficos.drawString ("Fondo " + String.valueOf (fondoEscenario + 1), 10, 485);
      graficos.drawString ("Modo de Juego", 275, 320);

      // La descripción del modo de juego es distinta según la opción seleccionada.
      if (modoJuego == Partida.COMPETICION)
      {
        graficos.drawString ("Competicion", 285, 385);
        graficos.drawString ("Atraviese los 45", 270, 430);
        graficos.drawString ("niveles para", 270, 455);
        graficos.drawString ("completar el juego.", 250, 480);
      }
      else
      {
        graficos.drawString ("Entenamiento", 285, 385);
        graficos.drawString ("Practique en el", 270, 430);
        graficos.drawString ("escenario inicial.", 270, 455);
      }
    }

    /** Devuelve un color.
        @param color byte  Color que se busca -su utiliza una de las constantes de color de la clase 'Nivel'.
        @return Color      El color buscado. */
    private Color getColor (byte color)
    {
      return colores [color];
    }
  }

  /** Clase interna que extiende 'JScrollPane'.
      Lleva un 'JEditorPane' en el que incrustamos una página HTML con información acerca del juego. */
  class PanelInformacion extends JScrollPane
  {
    // Panel en el que pegaremos el archivo HTML.
    private JEditorPane pnlEdtr;

    /** Constructor. */
    public PanelInformacion ()
    {
      // Llamada al constructor de la superclase. La barra deslizante debe ser vertical.
      super ();
      setVerticalScrollBarPolicy (JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
      // Se inicializa el 'panel editor', y se añade al panel.
      inicalizaComponentes ();
      setViewportView (pnlEdtr);
    }

    /** Inicializa el 'JEditorPane'. */
    private void inicalizaComponentes ()
    {
      // Inicializa 'pnlEdtr', se hace no editable, y se incrusta la página web.
      pnlEdtr = new JEditorPane ();
      pnlEdtr.setEditable (false);
      try
      {
        pnlEdtr.setPage (ArkaLlop.class.getResource ("rscArkaLlop/info.htm"));
      } catch (IOException e) { ArkaLlop.error ("Fichero 'info.htm' no encontrado."); }
    }
  }
}

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

Última actualización: 18-Feb-2007