Enunciado
Se quiere crear una aplicación que ayude a aprender los nombres de los animales de la granja en inglés. Cada vez que se inicia una nueva jugada, aparece el nombre de un animal en inglés, y el usuario debe seleccionar la imagen del animal. Posteriormente, la aplicación muestra cuál era la respuesta correcta. Por cada respuesta correcta, el usuario obtiene 20 puntos.
Se espera que el programa permita:
1. Iniciar una jugada.
2. Seleccionar un animal.
3. Visualizar la traducción correcta.
4. Visualizar el puntaje del jugador.
Interfaz
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n5_traductorGranja
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.granjaTraducciones.interfaz;
import java.awt.BorderLayout;
import javax.swing.*;
import uniandes.cupi2.granjaTraducciones.mundo.GranjaTraducciones;
import uniandes.cupi2.granjaTraducciones.mundo.GranjaTraducciones.Estado;
/**
* Clase principal de la interfaz.
*/
@SuppressWarnings("serial")
public class InterfazGranjaTraducciones extends JFrame
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Panel con los botones de juego.
*/
private PanelBotones panelBotones;
/**
* Panel con la información del juego actual.
*/
private PanelJuego panelJuego;
/**
* Panel con el estado del juego
*/
private PanelEstado panelEstado;
/**
* Panel con las opciones.
*/
private PanelExtension panelExtension;
/**
* Clase principal del mundo.
*/
private GranjaTraducciones traductor;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye la interfaz de la aplicación e inicializa el traductor. <br>
* <b>post: </b> Se inicializó la ventana principal de la aplicación con sus paneles.
*/
public InterfazGranjaTraducciones( )
{
try
{
traductor = new GranjaTraducciones( );
setTitle( "Granja de traducciones" );
setSize( 565, 700 );
setDefaultCloseOperation( EXIT_ON_CLOSE );
setLayout( new BorderLayout( ) );
JLabel imagen = new JLabel( new ImageIcon( "./data/imagenes/banner.jpg" ) );
add( imagen, BorderLayout.NORTH );
JPanel panelCentro = new JPanel( );
panelCentro.setLayout( new BorderLayout( ) );
add( panelCentro, BorderLayout.CENTER );
panelBotones = new PanelBotones( this, traductor.darPalabras( ) );
panelCentro.add( panelBotones, BorderLayout.CENTER );
panelJuego = new PanelJuego( );
panelCentro.add( panelJuego, BorderLayout.SOUTH );
JPanel panelSur = new JPanel( );
panelSur.setLayout( new BorderLayout( ) );
add( panelSur, BorderLayout.SOUTH );
panelEstado = new PanelEstado( this );
panelSur.add( panelEstado, BorderLayout.CENTER );
panelExtension = new PanelExtension( this );
panelSur.add( panelExtension, BorderLayout.SOUTH );
setLocationRelativeTo( null );
setResizable( false );
}
catch( Exception e )
{
e.printStackTrace( );
JOptionPane.showMessageDialog( this, e.getMessage( ), "Granja de traducciones", JOptionPane.ERROR_MESSAGE );
}
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Realiza una jugada. <br>
* <b>post: </b> Se realizó la jugada.
* @param pAnimal El nombre del animal seleccionado. pAnimal != null && pAnimal != "".
*/
public void jugada( String pAnimal )
{
if( traductor.darEstadoJuego( ) == Estado.EN_ESPERA )
{
boolean resultado = traductor.verificarJugada( pAnimal );
panelJuego.actualizarResultado( pAnimal, traductor.darAnimalActual( ).darNombre( ), resultado );
panelEstado.actualizar( traductor.darPuntaje( ) );
}
}
/**
* Se muestra un nuevo animal. <br>
* <b>post: </b> Se muestra un nuevo animal.
*/
public void darNuevoAnimal( )
{
Estado estado = traductor.darEstadoJuego( );
String nuevoAnimal = traductor.darNuevoAnimal( );
panelJuego.limpiar( nuevoAnimal );
if( estado == Estado.SIN_EMPEZAR )
{
panelBotones.habilitar( true );
}
}
// ----------------------------------------------------------------
// Puntos de Extensión
// ----------------------------------------------------------------
/**
* Punto de extensión 1.
*/
public void reqFuncOpcion1( )
{
String resultado = traductor.metodo1( );
JOptionPane.showMessageDialog( this, resultado, "Respuesta", JOptionPane.INFORMATION_MESSAGE );
}
/**
* Punto de extensión 2.
*/
public void reqFuncOpcion2( )
{
String resultado = traductor.metodo2( );
JOptionPane.showMessageDialog( this, resultado, "Respuesta", JOptionPane.INFORMATION_MESSAGE );
}
// -----------------------------------------------------------------
// Main
// -----------------------------------------------------------------
/**
* Ejecuta la aplicación.
* @param pArgs Parámetros de la ejecución. No son necesarios.
*/
public static void main( String[] pArgs )
{
try
{
// Unifica la interfaz para Mac y para Windows.
UIManager.setLookAndFeel( UIManager.getCrossPlatformLookAndFeelClassName( ) );
InterfazGranjaTraducciones interfaz = new InterfazGranjaTraducciones( );
interfaz.setVisible( true );
}
catch( Exception e )
{
e.printStackTrace( );
}
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n5_traductorGranja
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.granjaTraducciones.interfaz;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.event.*;
import javax.swing.*;
import uniandes.cupi2.granjaTraducciones.mundo.Animal;
/**
* Panel con los botones.
*/
@SuppressWarnings("serial")
public class PanelBotones extends JPanel implements ActionListener
{ // -----------------------------------------------------------
// Constantes
// -----------------------------------------------------------
/**
* Ruta donde se encuentran todas las imágenes.
*/
private final static String RUTA = "./data/imagenes/";
// -----------------------------------------------------------
// Atributos
// -----------------------------------------------------------
/**
* Ventana principal de la aplicación.
*/
private InterfazGranjaTraducciones principal;
// -----------------------------------------------------------
// Atributos de interfaz
// -----------------------------------------------------------
/**
* Botón para la vaca.
*/
private JButton[] botones;
// -----------------------------------------------------------
// Constructores
// -----------------------------------------------------------
/**
* Constructor del panel. <br>
* <b>post: </b> Se inicializó el panel.
* @param pPrincipal Ventana principal. pPrincipal != null.
* @param pAnimales Lista de palabras a mostrar.
*/
public PanelBotones( InterfazGranjaTraducciones pPrincipal, Animal[] pAnimales )
{
principal = pPrincipal;
int tamanio = pAnimales.length;
setLayout( new GridLayout( 3, tamanio / 3 ) );
botones = new JButton[tamanio];
for( int i = 0; i < tamanio; i++ )
{
botones[ i ] = new JButton( );
botones[ i ].setActionCommand( pAnimales[ i ].darNombre( ) );
botones[ i ].addActionListener( this );
botones[ i ].setForeground( null );
botones[ i ].setIcon( new ImageIcon( new ImageIcon( RUTA + pAnimales[ i ].darRutaImagen( ).trim( ) ).getImage( ).getScaledInstance( 133, 133, Image.SCALE_DEFAULT ) ) );
botones[ i ].setEnabled( false );
add( botones[ i ] );
}
}
/**
* Habilita todos los botones.
* @param pHabilitar True si se desea habilitar los botones, false de lo contrario.
*/
public void habilitar( boolean pHabilitar )
{
for( int i = 0; i < botones.length; i++ )
{
botones[ i ].setEnabled( pHabilitar );
}
}
/**
* Manejo de los eventos de los botones.
* @param pEvento Evento de click sobre un botón. pEvento != null.
*/
public void actionPerformed( ActionEvent pEvento )
{
String animal = pEvento.getActionCommand( );
principal.jugada( animal );
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n5_traductorGranja
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.granjaTraducciones.interfaz;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.border.TitledBorder;
/**
* Panel con el estado actual del juego.
*/
@SuppressWarnings("serial")
public class PanelEstado extends JPanel implements ActionListener
{
// -----------------------------------------------------------
// Constantes
// -----------------------------------------------------------
/**
* Constante para el botón de nuevo animal.
*/
public final static String NUEVO_ANIMAL = "Nuevo Animal";
// -----------------------------------------------------------
// Atributos
// -----------------------------------------------------------
/**
* Ventana principal de la granja.
*/
private InterfazGranjaTraducciones principal;
// -----------------------------------------------------------
// Atributos de interfaz
// -----------------------------------------------------------
/**
* Caja de texto del estado.
*/
private JTextField txtEstado;
/**
* Caja de texto del puntaje global.
*/
private JTextField txtPuntajeGlobal;
/**
* Botón nueva palabra.
*/
private JButton btnNuevaPalabra;
// -----------------------------------------------------------
// Constructores
// -----------------------------------------------------------
/**
* Construye el panel de juego. <br>
* <b>post: </b> Panel quedó inicializado.
* @param pPrincipal Venta principal de la aplicación. pPrincipal != null.
*/
public PanelEstado( InterfazGranjaTraducciones pPrincipal )
{
principal = pPrincipal;
setLayout( new GridLayout( 2, 3, 5, 3 ) );
setBorder( new TitledBorder( "Estado de juego" ) );
JLabel labEstado = new JLabel( "Estado:" );
add( labEstado );
txtEstado = new JTextField( );
txtEstado.setEditable( false );
txtEstado.setText( "Juego sin empezar" );
add( txtEstado );
add( new JLabel( ) );
JLabel labPuntajeGlobal = new JLabel( "Puntaje Jugador:" );
add( labPuntajeGlobal );
txtPuntajeGlobal = new JTextField( );
txtPuntajeGlobal.setEditable( false );
add( txtPuntajeGlobal );
btnNuevaPalabra = new JButton( NUEVO_ANIMAL );
btnNuevaPalabra.addActionListener( this );
btnNuevaPalabra.setActionCommand( NUEVO_ANIMAL );
add( btnNuevaPalabra );
}
// -----------------------------------------------------------
// Métodos
// -----------------------------------------------------------
/**
* @param pPuntaje El puntaje global.
*
*/
public void actualizar( double pPuntaje )
{
txtEstado.setText( "Jugada terminada" );
txtPuntajeGlobal.setText( pPuntaje + "" );
}
/**
*
*/
public void limpiar( )
{
txtEstado.setText( "Esperando jugada" );
}
/**
* Manejo de los eventos de los botones.
* @param pEvento Evento de click sobre un botón. pEvento != null.
*/
public void actionPerformed( ActionEvent pEvento )
{
String comando = pEvento.getActionCommand( );
if( comando.equals( NUEVO_ANIMAL ) )
{
principal.darNuevoAnimal( );
}
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n5_traductorGranja
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.granjaTraducciones.interfaz;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
import javax.swing.border.TitledBorder;
/**
* Panel que contiene los botones para ejecutar los puntos de extensión.
*/
@SuppressWarnings("serial")
public class PanelExtension extends JPanel implements ActionListener
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* Constante para el método de extensión 1.
*/
public final static String COMANDO_1 = "UNO";
/**
* Constante para el método de extensión 2.
*/
public final static String COMANDO_2 = "DOS";
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Ventana principal de la granja.
*/
private InterfazGranjaTraducciones principal;
// -----------------------------------------------------------------
// Atributos de Interfaz
// -----------------------------------------------------------------
/**
* Botón opción 1.
*/
private JButton btnOpc1;
/**
* Botón opción 2.
*/
private JButton btnOpc2;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Constructor del panel para los métodos de extensión.
* @param pPrincipal Ventana principal de la aplicación.
*/
public PanelExtension( InterfazGranjaTraducciones pPrincipal )
{
principal = pPrincipal;
setLayout( new GridLayout( 1, 2 ) );
setBorder( new TitledBorder( "Panel Extensión" ) );
btnOpc1 = new JButton( "Opción 1" );
btnOpc1.setActionCommand( COMANDO_1 );
btnOpc1.addActionListener( this );
add( btnOpc1 );
btnOpc2 = new JButton( "Opción 2" );
btnOpc2.setActionCommand( COMANDO_2 );
btnOpc2.addActionListener( this );
add( btnOpc2 );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Manejo de los eventos de los botones.
* @param pEvento Acción que generó el evento.
*/
public void actionPerformed( ActionEvent pEvento )
{
String comando = pEvento.getActionCommand( );
if( comando.equals( COMANDO_1 ) )
{
principal.reqFuncOpcion1( );
}
else
{
principal.reqFuncOpcion2( );
}
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n5_traductorGranja
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.granjaTraducciones.interfaz;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GridLayout;
import javax.swing.*;
import javax.swing.border.TitledBorder;
/**
* Panel de juego.
*/
@SuppressWarnings("serial")
public class PanelJuego extends JPanel
{
// -----------------------------------------------------------
// Constantes
// -----------------------------------------------------------
/**
* Constante para el botón de nuevo animal.
*/
public final static String NUEVO_ANIMAL = "Nuevo Animal";
// -----------------------------------------------------------
// Atributos de interfaz
// -----------------------------------------------------------
/**
* Caja de texto con el nombre palabra.
*/
private JTextField txtPalabra;
/**
* Caja de texto de la traducción del jugador.
*/
private JTextField txtTraduccionJugador;
/**
* Caja de texto de la traducción correcta.
*/
private JTextField txtTraduccionCorrecta;
/**
* Caja de texto del resultado.
*/
private JTextField txtResultado;
/**
* Caja de texto del puntaje obtenido.
*/
private JTextField txtPuntajeObtenido;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye el panel de juego. <br>
* <b>post: </b> Panel quedó inicializado.
*/
public PanelJuego( )
{
setLayout( new BorderLayout( ) );
JPanel centro = new JPanel( );
centro.setLayout( new GridLayout( 4, 4, 5, 2 ) );
centro.setBorder( new TitledBorder( "Juego actual" ) );
add( centro, BorderLayout.CENTER );
JLabel labPalabra = new JLabel( "Animal" );
txtPalabra = new JTextField( );
txtPalabra.setEditable( false );
centro.add( labPalabra );
centro.add( txtPalabra );
JLabel labTraduccionJugador = new JLabel( "Traducción Jugador:" );
txtTraduccionJugador = new JTextField( );
txtTraduccionJugador.setEditable( false );
centro.add( labTraduccionJugador );
centro.add( txtTraduccionJugador );
centro.add( new JLabel( ) );
centro.add( new JLabel( ) );
JLabel labTraduccionCorrecta = new JLabel( "Traducción Correcta:" );
txtTraduccionCorrecta = new JTextField( );
txtTraduccionCorrecta.setEditable( false );
centro.add( labTraduccionCorrecta );
centro.add( txtTraduccionCorrecta );
centro.add( new JLabel( ) );
centro.add( new JLabel( ) );
centro.add( new JLabel( ) );
centro.add( new JLabel( ) );
JLabel labResultado = new JLabel( "Resultado:" );
txtResultado = new JTextField( );
txtResultado.setEditable( false );
centro.add( labResultado );
centro.add( txtResultado );
JLabel labPuntajeObtenido = new JLabel( "Puntos Obtenidos:" );
txtPuntajeObtenido = new JTextField( );
txtPuntajeObtenido.setEditable( false );
centro.add( labPuntajeObtenido );
centro.add( txtPuntajeObtenido );
}
/**
* Actualiza el resultado de la jugada. <br>
* <b>post: </b> Se actualizó el resultado de la jugada.
* @param pTraduccionJugador Traducción seleccionada por el jugador. pTraduccionJugador != null && pTraduccionJugador!= "".
* @param pPalabraCorrecta La palabra correcta. pPalabraCorrecta != null && pPalabraCorrecta != "".
* @param pCorrecto True si el jugador acertó, false de lo contrario.
*/
public void actualizarResultado( String pTraduccionJugador, String pPalabraCorrecta, boolean pCorrecto )
{
txtTraduccionCorrecta.setText( pPalabraCorrecta );
txtTraduccionJugador.setText( pTraduccionJugador );
if( pCorrecto )
{
txtResultado.setText( "Correcto!" );
txtResultado.setBackground( Color.GREEN );
txtPuntajeObtenido.setText( "20" );
}
else
{
txtResultado.setText( "Incorrecto" );
txtResultado.setBackground( Color.RED );
txtPuntajeObtenido.setText( "0" );
}
}
/**
* Limpia el panel de juego. <br>
* <b>post: </b> Se limpió el panel de juego y se actualizó con la nueva palabra.
* @param pNuevaPalabra La nueva palabra. pNuevaPalabra != null && pNuevaPalabra != "".
*/
public void limpiar( String pNuevaPalabra )
{
txtResultado.setText( "" );
txtResultado.setBackground( null );
txtTraduccionCorrecta.setText( "" );
txtTraduccionJugador.setText( "" );
txtPalabra.setText( pNuevaPalabra );
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n5_traductorGranja
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.granjaTraducciones.mundo;
/**
* Representa el animal y su traducción.
*/
public class Animal
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* El nombre del animal.
*/
private String nombre;
/**
* La traducción del nombre.
*/
private String traduccion;
/**
* Ruta de la imagen donde se encuentra el animal.
*/
private String rutaImagen;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Crea un nuevo animal con los datos recibidos por parámetro.
* @param pNombre Nombre del animal. pNombre != null && pNombre != "".
* @param pTraduccion Traducción del nombre. pTraduccion != null && pTraduccion != "".
* @param pRutaImagen Ruta de la imagen. pRutaImagen != null && pRutaImagen != "".
*/
public Animal( String pNombre, String pTraduccion, String pRutaImagen )
{
nombre = pNombre;
traduccion = pTraduccion;
rutaImagen = pRutaImagen;
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Devuelve el nombre del animal.
* @return el nombre de animal.
*/
public String darNombre( )
{
return nombre;
}
/**
* Devuelve la traducción del nombre.
* @return La traducción del nombre.
*/
public String darTraduccion( )
{
return traduccion;
}
/**
* Devuelve la ruta donde se encuentra la imagen.
* @return Ruta de la imagen.
*/
public String darRutaImagen( )
{
return rutaImagen;
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n5_traductorGranja
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.granjaTraducciones.mundo;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Properties;
/**
* Granja de traducciones.
*/
public class GranjaTraducciones
{
// -----------------------------------------------------------------
// Enumeraciones
// -----------------------------------------------------------------
/**
* Enumeraciones para el estado de juego.
*/
public enum Estado
{
/**
* El juego no ha iniciado, no hay palabra actual.
*/
SIN_EMPEZAR,
/**
* En espera de la entrada del usuario.
*/
EN_ESPERA,
/**
* El jugador hizo un intento, se espera solicitud de nueva palabra.
*/
JUGADA
}
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* Ruta del archivo desde donde se cargarán los animales.
*/
private final static String ARCHIVO = "./data/traducciones.properties";
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Lista que contiene todos los animales.
*/
private Animal[] animales;
/**
* La palabra actual.
*/
private Animal animalActual;
/**
* El puntaje obtenido.
*/
private double puntaje;
/**
* El estado del juego.
*/
private Estado estadoJuego;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Inicializa la lista de animales del traductor. <br>
* <b>post: </b> Se inicializó la lista de animales con la información del archivo de propiedades.<br>
* Se inicializó el estado del juego en SIN_EMPEZAR.<br>
* Se inicializó el puntaje en cero (0).<br>
* La palabra actual se inicializó en null.
* @throws Exception Lanza excepción si hubo algún problema cargando el archivo.
*/
public GranjaTraducciones( ) throws Exception
{
cargar( ARCHIVO );
estadoJuego = Estado.SIN_EMPEZAR;
puntaje = 0;
animalActual = null;
}
/**
* Carga la información del archivo.
* @param pArchivo Ruta del archivo desde donde se cargará la información.
* @throws Exception Lanza excepción si hubo algún problema cargando el archivo.
*/
private void cargar( String pArchivo ) throws Exception
{
Properties info = new Properties( );
try
{
info.load( new FileInputStream( pArchivo ) );
int cantidad = Integer.parseInt( info.getProperty( "traducciones.cantidad" ) );
animales = new Animal[cantidad];
for( int i = 1; i <= cantidad; i++ )
{
String cadenaLetras = info.getProperty( "traducciones" + i );
String[] informacion = cadenaLetras.split( "," );
Animal animal = new Animal( informacion[ 0 ], informacion[ 1 ], informacion[ 2 ] );
animales[ i - 1 ] = animal;
}
}
catch( FileNotFoundException fnfe )
{
throw new Exception( "Error al cargar el archivo." );
}
catch( NumberFormatException nfe )
{
throw new Exception( "Error en el formato del archivo." );
}
catch( ArrayIndexOutOfBoundsException ae )
{
throw new Exception( "Error en el formato del archivo." );
}
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Retorna la lista de animales del traductor.
* @return Lista de animales.
*/
public Animal[] darPalabras( )
{
return animales;
}
/**
* Retorna el puntaje del juego.
* @return El puntaje del juego.
*/
public double darPuntaje( )
{
return puntaje;
}
/**
* Retorna el estado del juego.
* @return El estado del juego.
*/
public Estado darEstadoJuego( )
{
return estadoJuego;
}
/**
* Retorna el animal actual.
* @return El animal actual.
*/
public Animal darAnimalActual( )
{
return animalActual;
}
/**
* Verifica si el animal seleccionado corresponde al animal actual.
* @param pAnimal El animal seleccionado por el jugador.
* @return Retorna true si es el animal seleccionado corresponde al animal actual, false en caso contrario.
*/
public boolean verificarJugada( String pAnimal )
{
estadoJuego = Estado.JUGADA;
boolean resultado = false;
if( pAnimal.equals( animalActual.darNombre( ) ) )
{
puntaje += 20;
resultado = true;
}
return resultado;
}
/**
* Retorna el nuevo animal.
* @return El nuevo animal.
*/
public String darNuevoAnimal( )
{
estadoJuego = Estado.EN_ESPERA;
int indice = ( int )Math.floor( Math.random( ) * 12 );
animalActual = animales[ indice ];
return animalActual.darTraduccion( );
}
// -----------------------------------------------------------------
// Puntos de Extensión
// -----------------------------------------------------------------
/**
* Método para la extensión 1.
* @return Respuesta 1.
*/
public String metodo1( )
{
return "Respuesta 1";
}
/**
* Método para la extensión 2.
* @return Respuesta 2.
*/
public String metodo2( )
{
return "Respuesta 2";
}
}
|
Interfaz
InterfazGranjaTraducciones