Enunciado
Se quiere crear una aplicación que permita a los usuarios jugar ahorcado. El juego consiste en adivinar una palabra en una cantidad dada de intentos, conociendo desde el comienzo la cantidad de letras que esta tiene. Cada vez que el jugador elige una letra incorrecta, se dibuja una parte del cuerpo del ahorcado. El juego termina cuando el jugador adivina la palabra o cuando se completa el dibujo.
Cuando se inicia una partida, se muestra una fila de guiones, en la que cada uno de ellos representa una letra de la palabra a adivinar. El jugador empieza con 6 intentos.
Cada vez que un usuario elija una letra, se deben hacer las siguientes validaciones:
- Si la letra elegida por el usuario está en la palabra, esta debe ser mostrada sobre el guion correspondiente.
- Si la letra elegida por el usuario no está en la palabra, se pierde un intento y se muestra gráficamente.
- Si la letra elegida ya fue utilizada, se informa al jugador.
Al terminar cada jugada, se deben hacer las siguientes validaciones:
- Si el jugador se quedó sin intentos, pierde el juego, se avisa al jugador que fue ahorcado y se muestra gráficamente y no se permite hacer otra jugada.
- Si el jugador adivinó la palabra, se informa al jugador y no se permite hacer otra jugada.
El programa debe permitir al usuario:
1. Iniciar una nueva partida del Ahorcado.
2. Escoger una letra del alfabeto que puede o no estar en la palabra.
3. Visualizar el resultado de haber escogido una letra.
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* 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: n3_ahorcado
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.ahorcado.interfaz;
import java.awt.BorderLayout;
import java.util.ArrayList;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.UIManager;
import uniandes.cupi2.ahorcado.mundo.JuegoAhorcado;
import uniandes.cupi2.ahorcado.mundo.JuegoAhorcado.Estado;
import uniandes.cupi2.ahorcado.mundo.Letra;
/**
* Clase principal de la aplicación.
*/
@SuppressWarnings("serial")
public class InterfazAhorcado extends JFrame
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Panel que contiene el banner de la aplicación.
*/
private PanelImagen panelImagen;
/**
* Panel que contiene las letras del alfabeto.
*/
private PanelLetras panelLetras;
/**
* Panel que contiene las representaciones gráficas del juego.
*/
private PanelAhorcado panelAhorcado;
/**
* Representa el juego en curso.
*/
private JuegoAhorcado juego;
/**
* Panel que contiene los botones para las extensiones.
*/
private PanelExtension panelOpciones;
// -----------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------
/**
* Esta es la ventana principal de la aplicación.
*/
public InterfazAhorcado( )
{
setTitle( "Cupi2 - Ahorcado" );
setSize( 620, 600 );
setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
juego = new JuegoAhorcado( );
juego.iniciarJuego( );
panelImagen = new PanelImagen( );
panelLetras = new PanelLetras( this );
panelAhorcado = new PanelAhorcado( this );
panelOpciones = new PanelExtension( this );
setLayout( new BorderLayout( ) );
add( panelImagen, BorderLayout.NORTH );
add( panelOpciones, BorderLayout.SOUTH );
add( panelAhorcado, BorderLayout.CENTER );
add( panelLetras, BorderLayout.WEST );
setLocationRelativeTo( null );
setResizable( false );
panelAhorcado.actualizar( );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Realiza una jugada en el mundo con la letra que se recibe. <br>
* <b>post: </b> Se realiza la jugada y se actualizan los valores en la interfaz.
* @param pLetra La letra que se pretende jugar. pLetra != null.
*/
public void jugarLetra( char pLetra )
{
Estado estado = juego.darEstado( );
if( estado == Estado.JUGANDO )
{
Letra jugada = new Letra( pLetra );
boolean usada = juego.letraUtilizada( jugada );
if( usada )
panelAhorcado.actualizarEtiquetaMensaje( "La letra ya había sido jugada" );
else if( !juego.jugarLetra( jugada ) && !usada )
{
// Error en la letra
panelAhorcado.actualizarEtiquetaMensaje( "INCORRECTO" );
}
else
panelAhorcado.actualizarEtiquetaMensaje( " " );
panelAhorcado.actualizar( );
}
}
/**
* Inicia el juego. <br>
* <b>post: </b> Inicia un nuevo juego en el mundo y actualiza la interfaz.
*/
public void iniciarJuego( )
{
juego.iniciarJuego( );
panelAhorcado.actualizarEtiquetaMensaje( " " );
panelAhorcado.actualizar( );
}
/**
* Retorna la cantidad de intentos que quedan para jugar.
* @return Un entero con la cantidad de intentos que quedan para el jugador.
*/
public int darIntentosDisponibles( )
{
return juego.darIntentosDisponibles( );
}
/**
* Retorna un arreglo de las letras que han sido jugadas.
* @return Un objeto ArrayList con las letras que ya han sido jugadas.
*/
public ArrayList darLetras( )
{
return juego.darOcurrencias( );
}
/**
* Retorna el estado del juego para saber si se está jugando, si el juego se acabó, o si hubo un ganador.
* @return Entero con el estado del juego.
*/
public Estado darEstado( )
{
return juego.darEstado( );
}
// -----------------------------------------------------------------
// Puntos de Extensión
// -----------------------------------------------------------------
/**
* Método para la extensión 1.
*/
public void reqFuncOpcion1( )
{
String respuesta = juego.metodo1( );
JOptionPane.showMessageDialog( this, respuesta, "Respuesta", JOptionPane.INFORMATION_MESSAGE );
}
/**
* Método para la extensión 2.
*/
public void reqFuncOpcion2( )
{
String respuesta = juego.metodo2( );
JOptionPane.showMessageDialog( this, respuesta, "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( ) );
InterfazAhorcado i = new InterfazAhorcado( );
i.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: n3_ahorcado
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.ahorcado.interfaz;
import java.awt.Color;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.border.LineBorder;
import uniandes.cupi2.ahorcado.mundo.JuegoAhorcado.Estado;
import uniandes.cupi2.ahorcado.mundo.Letra;
/**
* Clase para crear un nuevo panel con los elementos gráficos del ahorcado.
*/
@SuppressWarnings("serial")
public class PanelAhorcado extends JPanel
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Representa la ventana principal del programa.
*/
private InterfazAhorcado principal;
// -----------------------------------------------------------------
// Atributos de interfaz
// -----------------------------------------------------------------
/**
* Etiqueta que contiene el dibujo del estado del ahorcado.
*/
private JLabel dibujo;
/**
* Etiqueta que contiene el mensaje del estado del juego.
*/
private JLabel labMensaje;
/**
* Etiqueta que contiene los campos de la palabra a adivinar.
*/
private JLabel labPalabra;
/**
* Etiqueta que contiene la cantidad de jugadas que quedan.
*/
private JLabel labDisponibles;
// -----------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------
/**
* Crea un nuevo panel con los elementos gráficos del ahorcado.
* @param pPrincipal La ventana principal. pPrincipal != null.
*/
public PanelAhorcado( InterfazAhorcado pPrincipal )
{
principal = pPrincipal;
labDisponibles = new JLabel( );
dibujo = new JLabel( );
labPalabra = new JLabel( );
labMensaje = new JLabel( );
inicializarElementos( );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Inicializa y dispone los elementos de la interfaz en el panel.
*/
private void inicializarElementos( )
{
// GridbagConstraints para el label disponibles
GridBagConstraints gridBagConstraints0 = new GridBagConstraints( );
gridBagConstraints0.gridx = 0;
gridBagConstraints0.gridy = 0;
gridBagConstraints0.weighty = 0.2D;
// GridBagConstraints para el label de dibujo
GridBagConstraints gridBagConstraints1 = new GridBagConstraints( );
gridBagConstraints1.gridx = 0;
gridBagConstraints1.gridy = 1;
gridBagConstraints1.fill = java.awt.GridBagConstraints.VERTICAL;
// GridbagConstraints para el label del mensaje
GridBagConstraints gridBagConstraints2 = new GridBagConstraints( );
gridBagConstraints2.gridx = 0;
gridBagConstraints2.gridy = 2;
gridBagConstraints2.fill = java.awt.GridBagConstraints.HORIZONTAL;
// GridBagConstraints para el label de palabra
GridBagConstraints gridBagConstraints3 = new GridBagConstraints( );
gridBagConstraints3.gridx = 0;
gridBagConstraints3.gridy = 3;
gridBagConstraints3.fill = java.awt.GridBagConstraints.VERTICAL;
gridBagConstraints3.weightx = 1.0D;
gridBagConstraints3.weighty = 0.3D;
setLayout( new GridBagLayout( ) );
labDisponibles.setText( "" );
dibujo.setText( "" );
dibujo.setVerticalAlignment( javax.swing.SwingConstants.BOTTOM );
dibujo.setHorizontalAlignment( javax.swing.SwingConstants.CENTER );
labMensaje.setText( "" );
labMensaje.setAlignmentX( 0.0F );
labMensaje.setForeground( java.awt.Color.red );
labMensaje.setFont( new java.awt.Font( "Dialog", java.awt.Font.BOLD, 18 ) );
labMensaje.setHorizontalAlignment( javax.swing.SwingConstants.CENTER );
labPalabra.setFont( new java.awt.Font( "Dialog", java.awt.Font.BOLD, 18 ) );
labPalabra.setForeground( java.awt.Color.blue );
// Agregar los labels al panel
add( labDisponibles, gridBagConstraints0 );
add( dibujo, gridBagConstraints1 );
add( labMensaje, gridBagConstraints2 );
add( labPalabra, gridBagConstraints3 );
actualizar( );
}
/**
* Este método se usa para actualizar la pantalla, cambiando el dibujo y la palabra que se quiere descubrir. <br>
* <b>post: </b> La interfaz de la aplicación queda actualizada con los datos del mundo.
*/
public void actualizar( )
{
int numDisponibles = principal.darIntentosDisponibles( );
labDisponibles.setText( "Quedan " + numDisponibles );
// Cambiar la imagen según los intentos disponibles
try
{
dibujo.setIcon( new ImageIcon( cargarImagen( "./data/quedan" + numDisponibles + ".png" ) ) );
}
catch( IOException e )
{
JOptionPane.showMessageDialog( this, "La imagen no se pudo cargar: " + e.getMessage( ) );
e.printStackTrace( );
}
dibujo.setBorder( new LineBorder( Color.DARK_GRAY ) );
// Actualizar la palabra
ArrayList palabra = principal.darLetras( );
StringBuffer sb = new StringBuffer( "" );
int i = 0;
int tam = palabra.size( );
while( i < tam )
{
Letra letra = ( Letra )palabra.get( i );
sb.append( " " + letra.darLetra( ) + " " );
i++;
}
labPalabra.setText( sb.toString( ).trim( ) );
// Cambiar el mensaje de estado
Estado estado = principal.darEstado( );
if( estado == Estado.GANADOR )
{
labMensaje.setText( "Palabra adivinada!" );
}
else if( estado == Estado.AHORCADO )
{
labMensaje.setText( "AHORCADO!!!!" );
}
validate( );
}
/**
* Este método se usa para cargar la información de la imagen. <br>
* <b>pre: </b> La imagen existe. <br>
* <b>post: </b> Se retorna un arreglo de bytes con la representación de la imagen cargada.
* @param pNombreImagen El nombre de la imagen del estado del ahorcado.
* @return Retorna un arreglo de bytes con la información de la imagen.
* @throws IOException Se lanza esta excepción si no se puede leer la imagen.
*/
private byte[] cargarImagen( String pNombreImagen ) throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream( );
FileInputStream fin = new FileInputStream( pNombreImagen );
int data = 0;
while( data != -1 )
{
data = fin.read( );
baos.write( data );
}
return baos.toByteArray( );
}
/**
* Cambia el valor del mensaje del estado del juego. <br>
* <b>post: </b> El texto del campo del mensaje queda actualizado con los valores actuales del mundo.
* @param pMensaje El mensaje a introducir.
*/
public void actualizarEtiquetaMensaje( String pMensaje )
{
labMensaje.setText( pMensaje );
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* 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: n3_ahorcado
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.ahorcado.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.border.EmptyBorder;
/**
* Panel de manejo de extensiones.
*/
@SuppressWarnings("serial")
public class PanelExtension extends JPanel implements ActionListener
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* Constante de identificación de action command de INICIAR.
*/
private final static String NUEVA_PALABRA = "Nueva Palabra";
/**
* Constante OPCION_1, Usada para realizar la opción de la extensión 1.
*/
private final static String OPCION_1 = "Opción 1";
/**
* Constante OPCION_2, Usada para realizar la opción de la extensión 2.
*/
private final static String OPCION_2 = "Opción 2";
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Representa la ventana principal de la aplicación.
*/
private InterfazAhorcado principal;
// -----------------------------------------------------------------
// Atributos de Interfaz
// -----------------------------------------------------------------
/**
* Botón para iniciar un nuevo juego.
*/
private JButton nuevaPalabra;
/**
* Botón Para hacer la extensión 1.
*/
private JButton opcion1;
/**
* Botón Para hacer la extensión 2.
*/
private JButton opcion2;
// -----------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------
/**
* Crea un nuevo panel con los botones para realizar las extensiones.
* @param pPrincipal La ventana principal.
*/
public PanelExtension( InterfazAhorcado pPrincipal )
{
principal = pPrincipal;
setLayout( new GridLayout( 1, 5, 5, 5 ) );
setBorder( new EmptyBorder( 0, 0, 10, 0 ) );
add( new JLabel( ) );
nuevaPalabra = new JButton( NUEVA_PALABRA );
nuevaPalabra.setActionCommand( NUEVA_PALABRA );
nuevaPalabra.addActionListener( this );
add( nuevaPalabra );
opcion1 = new JButton( OPCION_1 );
opcion1.setActionCommand( OPCION_1 );
opcion1.addActionListener( this );
add( opcion1 );
opcion2 = new JButton( OPCION_2 );
opcion2.setActionCommand( OPCION_2 );
opcion2.addActionListener( this );
add( opcion2 );
add( new JLabel( ) );
}
// -----------------------------------------------------------------
// 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( OPCION_1.equals( comando ) )
{
principal.reqFuncOpcion1( );
}
else if( OPCION_2.equals( comando ) )
{
principal.reqFuncOpcion2( );
}
else if( NUEVA_PALABRA.equals( comando ) )
{
principal.iniciarJuego( );
}
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* 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: n3_ahorcado
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.ahorcado.interfaz;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JPanel;
/**
* Panel que contiene el banner con la imagen.
*/
@SuppressWarnings("serial")
public class PanelImagen extends JPanel
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* Ruta de la imagen del banner.
*/
public final static String RUTA_IMAGEN = "./data/banner.jpg";
// -----------------------------------------------------------------
// Atributos de la interfaz
// -----------------------------------------------------------------
/**
* Etiqueta de la imagen.
*/
private JLabel labImagen;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye el panel con el banner.
*/
public PanelImagen( )
{
labImagen = new JLabel( );
labImagen.setIcon( new ImageIcon( RUTA_IMAGEN ) );
add( labImagen );
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* 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: n3_ahorcado
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.ahorcado.interfaz;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.border.CompoundBorder;
import javax.swing.border.EmptyBorder;
import javax.swing.border.TitledBorder;
/**
* Clase que permite crear un panel con las letras del alfabeto.
*/
@SuppressWarnings("serial")
public class PanelLetras extends JPanel implements ActionListener
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Representa la ventana principal de la aplicación.
*/
private InterfazAhorcado principal;
// -----------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------
/**
* Crea un nuevo panel con las letras del alfabeto.
* @param pPrincipal La ventana principal. pPrincipal != null.
*/
public PanelLetras( InterfazAhorcado pPrincipal )
{
principal = pPrincipal;
setLayout( new GridLayout( 4, 7 ) );
ArrayList botones = inicializarBotones( );
int contador = 0;
while( contador < botones.size( ) )
{
JButton boton = ( JButton )botones.get( contador );
add( boton );
contador++;
}
setBorder( new CompoundBorder( new EmptyBorder( 15, 15, 60, 15 ), new TitledBorder( "" ) ) );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Inicializa los botones de las letras.
* @return Retorna un arreglo con los botones inicializados.
*/
private ArrayList inicializarBotones( )
{
ArrayList botones = new ArrayList( );
for( int i = 'A'; i <= 'Z'; i++ )
{
String letra = String.valueOf( ( char )i );
JButton boton = new JButton( letra );
boton.setActionCommand( letra );
boton.setPreferredSize( new java.awt.Dimension( 30, 50 ) );
boton.setMargin( new java.awt.Insets( 3, 3, 3, 3 ) );
boton.setForeground( java.awt.Color.blue );
boton.setMaximumSize( new java.awt.Dimension( 30, 50 ) );
boton.setMinimumSize( new java.awt.Dimension( 30, 50 ) );
boton.addActionListener( this );
botones.add( boton );
}
return botones;
}
/**
* Realiza la acción de jugar con la letra especificada. <br>
* <b>post: </b> Se ha realizado la jugada con la letra especificada y luego se actualiza la interfaz.
* @param pEvento El evento realizado por el usuario.
*/
public void actionPerformed( ActionEvent pEvento )
{
String comando = pEvento.getActionCommand( );
principal.jugarLetra( comando.charAt( 0 ) );
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* 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: n3_ahorcado
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.ahorcado.mundo;
import java.util.ArrayList;
/**
* Clase que implementa un juego de ahorcado.
*/
public class JuegoAhorcado
{
// -----------------------------------------------------------------
// Enumeraciones
// -----------------------------------------------------------------
/**
* Enumeradores para los posibles estado de juego.
*/
public enum Estado {
/**
* El juego no ha sido iniciado y todavía no se puede jugar.
*/
NO_INICIADO,
/**
* El juego está listo para iniciar o ya empezó pero la palabra no está completa y quedan intentos disponibles.
*/
JUGANDO,
/**
* La palabra está completa.
*/
GANADOR,
/**
* La palabra no está completa y se acabaron los intentos disponibles.
*/
AHORCADO
}
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* Número total de palabras del diccionario.
*/
public static final int TOTAL_PALABRAS = 12;
/**
* Número máximo de intentos por palabra.
*/
public static final int MAX_INTENTOS = 6;
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* El diccionario de palabras por adivinar del juego del ahorcado.
*/
private Palabra[] diccionario;
/**
* Es la palabra actual del juego.
*/
private Palabra actual;
/**
* Arreglo de letras jugadas por el usuario.
*/
private ArrayList<Letra> jugadas;
/**
* Es el número de intentos disponibles que le quedan al jugador.
*/
private int intentosDisponibles;
/**
* Indica el estado del juego.
*/
private Estado estadoJuego;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Crea un nuevo juego inicializando el diccionario con las palabras por adivinar, el número de intentos disponibles y el estado del juego. <br>
* <b>post: </b> El juego tiene las 12 palabras por adivinar del diccionario Cupi2, tiene un máximo de 6 intentos y se encuentra en estado no iniciado.
*/
public JuegoAhorcado( )
{
// Crea el diccionario y agrega las palabras por adivinar
diccionario = new Palabra[TOTAL_PALABRAS];
diccionario[ 0 ] = new Palabra( "algoritmo" );
diccionario[ 1 ] = new Palabra( "contenedora" );
diccionario[ 2 ] = new Palabra( "avance" );
diccionario[ 3 ] = new Palabra( "ciclo" );
diccionario[ 4 ] = new Palabra( "indice" );
diccionario[ 5 ] = new Palabra( "instrucciones" );
diccionario[ 6 ] = new Palabra( "arreglo" );
diccionario[ 7 ] = new Palabra( "vector" );
diccionario[ 8 ] = new Palabra( "inicio" );
diccionario[ 9 ] = new Palabra( "cuerpo" );
diccionario[ 10 ] = new Palabra( "recorrido" );
diccionario[ 11 ] = new Palabra( "patron" );
// Inicializa el número de intentos disponibles y el estado del juego
intentosDisponibles = MAX_INTENTOS;
estadoJuego = Estado.NO_INICIADO;
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Inicia un nuevo juego. Esto incluye: <br>
* 1. Buscar una palabra al azar en el diccionario y marcarla como actual <br>
* 2. Establecer el número máximo de intentos <br>
* 3. Inicializar el arreglo de letras jugadas. <br>
* 4. Actualizar el estado del juego. <br>
* <b>post: </b> Se crea un nuevo juego con todos los atributos inicializados en valores válidos.
*/
public void iniciarJuego( )
{
// Sacar una palabra al azar del diccionario
double pos = generarValor( ) * TOTAL_PALABRAS;
actual = ( Palabra )diccionario[ ( int )pos ];
// Establecer el número máximo de intentos
intentosDisponibles = MAX_INTENTOS;
// Inicializar el vector de letras jugadas
jugadas = new ArrayList<Letra>( );
// Actualizar el estado del juego
estadoJuego = Estado.JUGANDO;
}
/**
* Juega una letra e indica si pertenece a la palabra o no. El estado del juego se actualiza después de jugarla. <br>
* <b>pre: </b> El arreglo de jugadas ya está inicializado. <br>
* <b>post: </b> La letra escogida queda agregada al vector de jugadas.
* @param pLetra Es la letra que se está jugando. pLetra != null.
* @return Retorna true si la letra pertenece a la palabra. Retorna false en caso contrario.
*/
public boolean jugarLetra( Letra pLetra )
{
boolean resultado = true;
if( estadoJuego != Estado.JUGANDO )
{
resultado = false;
}
else
{
// Agregar la letra a las jugadas
jugadas.add( pLetra );
resultado = actual.estaLetra( pLetra );
if( !resultado )
{
intentosDisponibles--;
// Se acabaron los intentos
if( intentosDisponibles == 0 )
{
estadoJuego = Estado.AHORCADO;
}
}
else
{
// Se completó la palabra
if( actual.estaCompleta( jugadas ) )
{
estadoJuego = Estado.GANADOR;
}
}
}
return resultado;
}
/**
* Devuelve la palabra actual que se está adivinando.
* @return Palabra por adivinar.
*/
public Palabra darPalabraActual( )
{
return actual;
}
/**
* Devuelve la palabra del diccionario que se encuentra en la posición especificada.
* @param posicion Posición de la palabra. 0 <= posicion < TOTAL_PALABRAS.
* @return Palabra que se encuentra en la posición dada.
*/
public Palabra darPalabra( int posicion )
{
return diccionario[ posicion ];
}
/**
* Devuelve el número de intentos disponibles.
* @return El número de intentos disponibles.
*/
public int darIntentosDisponibles( )
{
return intentosDisponibles;
}
/**
* Devuelve las letras jugadas hasta el momento.
* @return Arreglo con las letras jugadas.
*/
public ArrayList<Letra> darJugadas( )
{
return jugadas;
}
/**
* Devuelve un arreglo con las ocurrencias de las letras jugadas que están en la palabra y con las letras que aún no se han adivinado. <br>
* Por ejemplo, si la palabra es "recorrido" y hasta el momento se han jugado las letras <br>
* "r" y "d", entonces el método retorna "r_ _ _ r r _ d _".
* @return Retorna las letras organizadas, reemplazando las que no se conocen por "_".
*/
public ArrayList<Letra> darOcurrencias( )
{
ArrayList<Letra> ocurrencias = actual.darOcurrencias( jugadas );
return ocurrencias;
}
/**
* Devuelve el estado del juego. <br>
* El juego puede estar en estado: "NO_INICIADO" si no ha empezado el juego, "JUGANDO" si está recién iniciado o si todavía hay intentos disponibles <br>
* y la palabra no está completa, "GANADOR" si la palabra está completa, "AHORCADO" si la palabra no está completa y se acabaron los intentos.
* @return El estado del juego.
*/
public Estado darEstado( )
{
return estadoJuego;
}
/**
* Indica si una letra ya fue utilizada. <br>
* @param pLetra La letra que se quiere verificar.
* @return Retorna true si la letra ya fue utilizada; retorna false en caso contrario.
*/
public boolean letraUtilizada( Letra pLetra )
{
boolean utilizada = false;
int contador = 0;
while( contador < jugadas.size( ) && !utilizada )
{
Letra l = jugadas.get( contador );
if( l.esIgual( pLetra ) )
{
utilizada = true;
}
contador++;
}
return utilizada;
}
/**
* Genera aleatoriamente un valor real positivo mayor a 0.0 y menor que 1.0.
* @return Un valor real aleatorio en el intervalo [0.0, 1.0).
*/
private double generarValor( )
{
return Math.random( );
}
// -----------------------------------------------------------------
// Puntos de Extensión
// -----------------------------------------------------------------
/**
* Método para la extensión 1.
* @return Respuesta de la extensión 1.
*/
public String metodo1( )
{
return "Respuesta 1";
}
/**
* Método para la extensión 2.
* @return Respuesta de la extensión 2.
*/
public String metodo2( )
{
return "Respuesta 2";
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* 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: n3_ahorcado
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.ahorcado.mundo;
/**
* Clase que representa una letra de una palabra.
*/
public class Letra
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Caracter que contiene la letra.
*/
private char letra;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Crea una nueva letra a partir de un caracter dado.
* @param pLetra Variable de tipo char que representa un caracter para inicializar la letra.
*/
public Letra( char pLetra )
{
letra = pLetra;
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Devuelve el caracter que representa la letra.
* @return Retorna un caracter con la letra.
*/
public char darLetra( )
{
return letra;
}
/**
* Indica si dos letras son iguales, sin importar si una está en mayúscula y otra en minúscula.
* @param pLetra La letra para comparar. pLetra != null.
* @return Retorna true si la letra dada por parámetro es igual al caracter que la representa, false de lo contrario.
*/
public boolean esIgual( Letra pLetra )
{
boolean igual = false;
// Compara si la letra es igual a la letra dada
if( pLetra.darLetra( ) == letra ) //
{
igual = true;
}
// Si la letra es minúscula compara si la mayúscula correspondiente es igual a la letra dada
else if( letra >= 97 && letra - 32 == pLetra.darLetra( ) )
{
igual = true;
}
// La letra es mayúscula y verifica si la minúscula correspondiente es igual a la letra dada
else if( letra + 32 == pLetra.darLetra( ) )
{
igual = true;
}
return igual;
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* 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: n3_ahorcado
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.ahorcado.mundo;
import java.util.ArrayList;
/**
* Clase para representar una palabra del juego.
*/
public class Palabra
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Arreglo de letras de una palabra.
*/
private ArrayList<Letra> letras;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye una nueva palabra a partir de su representación en String. <br>
* <b>post: </b> Se crea una nueva palabra que consiste en un arreglo de caracteres que son las letras que forman la palabra.
* @param pPalabra La palabra que se quiere construir.
*/
public Palabra( String pPalabra )
{
// Inicializar el vector de letras
letras = new ArrayList<Letra>( );
// Adicionar las letras al arreglo recorriendo todos los caracteres del String
int i = 0;
int cuantos = pPalabra.length( );
while( i < cuantos )
{
// Cada uno de los caracteres del String se convierte en una Letra
char c = pPalabra.charAt( i );
Letra l = new Letra( c );
letras.add( l );
i++;
}
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Indica si con las letras jugadas hasta el momento ya es posible conocer la palabra completa.
* @param pJugadas Es un arreglo con las letras jugadas.
* @return Retorna true si con las letras jugadas se conoce toda la palabra, false en caso contrario.
*/
public boolean estaCompleta( ArrayList<Letra> pJugadas )
{
boolean completa = true;
int contador = 0;
// Se recorren todas las letras de la palabra y se revisa que cada una esté en el arreglo de jugadas
while( contador < letras.size( ) && completa )
{
Letra l = letras.get( contador );
// Si la letra no está en el arreglo de jugadas, entonces la palabra no está completa
if( !buscarLetraEnVector( l, pJugadas ) )
{
completa = false;
}
contador++;
}
return completa;
}
/**
* Indica si dentro de un arreglo de letras se encuentra una letra en especial.
* @param pLetra La letra que se está buscando. pLetra != null.
* @param pArregloLetras El vector de letras en la que se busca. pArregloLetras != null.
* @return Retorna true si en el arreglo estaba la letra, retorna false en caso contrario.
*/
private boolean buscarLetraEnVector( Letra pLetra, ArrayList<Letra> pArregloLetras )
{
boolean estaLetra = false;
int contador = 0;
// Se recorre todo el vector
while( contador < pArregloLetras.size( ) && !estaLetra )
{
Letra l = pArregloLetras.get( contador );
// Se verifica que las letras sean iguales
if( l.esIgual( pLetra ) )
{
estaLetra = true;
}
contador++;
}
return estaLetra;
}
/**
* Informa si una letra hace parte de la palabra.
* @param pLetra La letra que queremos saber si pertenece a la palabra. pLetra != null.
* @return Retorna true si la letra pertenece a la palabra, false en caso contrario.
*/
public boolean estaLetra( Letra pLetra )
{
boolean resultado = buscarLetraEnVector( pLetra, letras );
return resultado;
}
/**
* Devuelve un arreglo con las ocurrencias de las letras jugadas que están en la palabra y con las letras que aún no se han adivinado <br>
* reemplazándolas por el caracter "_". Por ejemplo, si la palabra es "recorrido" y hasta el momento se han jugado las letras <br>
* "r" y "d", entonces el método retorna "r_ _ _ r r _ d _".
* @param pJugadas Arreglo con las letras que han sido jugadas hasta el momento.
* @return Retorna las letras organizadas, reemplazando las que no se conocen por "_".
*/
public ArrayList<Letra> darOcurrencias( ArrayList<Letra> pJugadas )
{
ArrayList<Letra> visibles = new ArrayList<Letra>( );
int contador = 0;
// Se recorren todas las letras de la palabra
while( contador < letras.size( ) )
{
Letra l = letras.get( contador );
// La letra no está dentro de las jugadas (no se muestra)
if( !buscarLetraEnVector( l, pJugadas ) )
{
visibles.add( new Letra( '_' ) );
}
else
// La letra ya se jugó, entonces se muestra
{
visibles.add( l );
}
contador++;
}
return visibles;
}
/**
* Devuelve el arreglo con las letras de la palabra.
* @return Las letras que componen la palabra.
*/
public ArrayList<Letra> darLetras( )
{
return letras;
}
}
|
Interfaz
InterfazAhorcado