En esta entrada del blog voy a mostrar el código de una pequeña aplicación que he creado recreando este juego. Espero que sirva a alguién para aprender algo. A continuación os muestro el código y también un par de imágenes del resultado final.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using System.IO;
using System.Collections;
namespace Hangman01
{
public partial class Form1 : Form
{
enum HangmanParts { None, Head, Trunk, RightArm, LeftArm,
RightLeg, LeftLeg };
//, RightEye, LeftEye, Nose, Mouth
String palabraGenerada;
String palabraIntroducida;
HangmanParts estadoHangman = 0;
int errores;
int letrasAcertadas = 0;
bool juegoFinalizado;
public Form1()
{
InitializeComponent();
palabraGenerada = "";
juegoFinalizado = false;
chkMostrarSolucion.Checked = false;
txtSolucion.Visible = false;
}
//Este método nos permite saber si una determinada letra de la palabra
//generada por el juego todavía no ha sido visualizada al menos en una
//de las casillas.
private bool letraPendienteAdivinar(String letra)
{
int pendientes = 0;
for (int i = 0; i < palabraGenerada.Length; i++)
{
if ((((Label)pnlLetras.Controls["lblLetra" + i]).Text.CompareTo("_") == 0) &&
palabraGenerada[i].ToString().CompareTo(letra) == 0)
{
pendientes++;
}
}
if (pendientes > 0)
return true;
else
return false;
}
//Este método se ejecuta cuando el jugador introduce una palabra para
//comprobar directamente si es la palabra buscada. Cada letra que
//no coincida con la palabra generada se considerará un fallo y se
//actualizará el estado de acuerdo a ello.
private void btnComprobar_Click(object sender, EventArgs e)
{
if (juegoFinalizado == false)
{
btnComprobar.Enabled = false;
//Comparar la palabra generada aleatoriamente con la introducida
//por el jugador. Para cada letra que coincida en la posición
//correcta se asignará en el control label correspondiente en pnlLetras
errores = 0;
letrasAcertadas = 0;
palabraIntroducida = txtPalabra.Text;
if (palabraIntroducida.Length == palabraGenerada.Length)
{
for (int i = 0; i < palabraIntroducida.Length; i++)
{
if (palabraIntroducida[i].ToString().ToUpper().CompareTo(palabraGenerada[i].ToString()) == 0)
{
letrasAcertadas++;
((Label)pnlLetras.Controls["lblLetra" + i]).Text = palabraGenerada[i].ToString();
//---->>>> <<<<----
//Si la letra actual no coincide con ninguna de la palabra generada
//que no se haya introducido correctamente
if (!letraPendienteAdivinar(palabraIntroducida[i].ToString().ToUpper()))
marcarBotonLetra(palabraGenerada[i].ToString(), true);
}
else
{
errores++;
//actualizar gráfico
dibujarHangman(++estadoHangman);
if (!letraPendienteAdivinar(palabraIntroducida[i].ToString().ToUpper()))
marcarBotonLetra(palabraIntroducida[i].ToString(), false);
}
//Si se agotan las oportunidades disponibles se mostrará un mensaje
//indicando que el juego ha finalizado y el jugador ha perdido
if (errores > (int)HangmanParts.LeftLeg)
{
lblMensaje.Text = "El juego ha finalizado. PALABRA INCORRECTA!";
juegoFinalizado = true;
break;
}
}
}
if (palabraIntroducida.Length > palabraGenerada.Length)
{
for (int i = 0; i < palabraIntroducida.Length; i++)
{
if (i < palabraGenerada.Length)
{
if (palabraIntroducida[i].ToString().ToUpper().CompareTo(palabraGenerada[i].ToString()) == 0)
{
letrasAcertadas++;
((Label)pnlLetras.Controls["lblLetra" + i]).Text = palabraGenerada[i].ToString();
if (!letraPendienteAdivinar(palabraIntroducida[i].ToString().ToUpper()))
marcarBotonLetra(palabraIntroducida[i].ToString().ToUpper(), true);
}
else
{
errores++;
//actualizar gráfico
dibujarHangman(++estadoHangman);
if (!letraPendienteAdivinar(palabraIntroducida[i].ToString().ToUpper()))
marcarBotonLetra(palabraIntroducida[i].ToString().ToUpper(), false);
}
}
else
{
errores++;
dibujarHangman(++estadoHangman);
if (!letraPendienteAdivinar(palabraIntroducida[i].ToString().ToUpper()))
marcarBotonLetra(palabraIntroducida[i].ToString(), false);
}
//Si se agotan las oportunidades disponibles se mostrará un
//mensaje indicando que el juego ha finalizado y el jugador ha perdido
if (errores > (int)HangmanParts.LeftLeg)
{
lblMensaje.Text = "El juego ha finalizado. PALABRA INCORRECTA!";
juegoFinalizado = true;
break;
}
}
}
if (palabraGenerada.Length > palabraIntroducida.Length)
{
for (int i = 0; i < palabraGenerada.Length; i++)
{
if (i < palabraIntroducida.Length)
{
if (palabraIntroducida[i].ToString().ToUpper().CompareTo(palabraGenerada[i].ToString()) == 0)
{
letrasAcertadas++;
((Label)pnlLetras.Controls["lblLetra" + i]).Text = palabraGenerada[i].ToString();
if (!letraPendienteAdivinar(palabraIntroducida[i].ToString().ToUpper()))
marcarBotonLetra(palabraGenerada[i].ToString(), true);
}
else
{
errores++;
//actualizar gráfico
dibujarHangman(++estadoHangman);
if (!letraPendienteAdivinar(palabraIntroducida[i].ToString().ToUpper()))
marcarBotonLetra(palabraGenerada[i].ToString(), false);
}
}
else
{
errores++;
dibujarHangman(++estadoHangman);
if (!letraPendienteAdivinar(palabraGenerada[i].ToString().ToUpper()))
marcarBotonLetra(palabraGenerada[i].ToString(), false);
}
//Si se agotan las oportunidades disponibles se mostrará un mensaje
//indicando que el juego ha finalizado y el jugador ha perdido
if (errores > (int)HangmanParts.LeftLeg)
{
lblMensaje.Text = "El juego ha finalizado. PALABRA INCORRECTA!";
juegoFinalizado = true;
break;
}
}
}
if ((juegoFinalizado == false) && (letrasAcertadas == palabraGenerada.Length))
{
lblMensaje.Text = "PALABRA CORRECTA!!!";
juegoFinalizado = true;
}
}
else
{
MessageBox.Show("El juego ha finalizado. Pulse Nuevo para empezar otra vez",
"Juego finalizado", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
//Este método se ocupa de deshabilitar los botones correspondientes a
//las letras que ya han sido pulsadas diferenciando visualmente entre
//las que corresponden a aciertos y las que corresponden a fallos.
private void marcarBotonLetra(String letra, bool acertada)
{
foreach (Control ctrl in pnlBotones.Controls)
{
Button btn = (Button)ctrl;
if (btn.Text.CompareTo(letra.ToUpper()) == 0)
{
if (acertada == true)
btn.Enabled = false;
else
{
btn.Enabled = false;
btn.BackColor = Color.Orchid;
//dibujarFondoBoton(btn);
}
}
}
}
private void dibujarFondoBoton(Button btn)
{
Graphics g = btn.CreateGraphics();
Pen p = new Pen(Color.Red, 2.5f);
g.DrawLine(p, 0, 0, btn.Width, btn.Height);
g.DrawLine(p, 0, btn.Height, btn.Width, 0);
}
//Habilita los botones correspondientes a las letras, para mostrarlos en
//su estado inicial
private void desmarcarBotonesLetras()
{
foreach (Control ctrl in pnlBotones.Controls)
{
Button btn = (Button)ctrl;
btn.ForeColor = Color.FromKnownColor(KnownColor.ControlText);
btn.BackColor = Color.FromKnownColor(KnownColor.Control);
btn.Enabled = true;
}
}
//Inicializa el contenido de las etiquetas correspondientes a cada una
//de las letras de la palabra generada por el juego. El contenido inicial
//de cada etiqueta es el carácter "_"
private void limpiarEtiquetasLetras()
{
foreach (Control ctrl in pnlLetras.Controls)
{
Label lbl = (Label)ctrl;
lbl.Text = "_";
lbl.BackColor = Color.FromKnownColor(KnownColor.Control);
}
}
//Acciones a realizar cuanod se pulsa alguno de los botones correspondientes
//a las letras del alfabeto. Cada uno de estos botones permite que el jugador
//seleccione cual es la letra que quiere seleccionar a continuación para
//adivinar la palabra.
private void btnLetra_Click(object sender, EventArgs e)
{
if (juegoFinalizado == false)
{
int coincidencias = 0;
//Obtenemos la letra correspondiente al botón pulsado
String letra = ((Button)sender).Text;
String lblLetra = "lblLetra";
//Comparar cada una de las letras de la palabra generada
//con la letra pulsada. Para cada una que coincida, mostrar
//la letra en cuestión como el texto del control label que
//corresponde en pnlLetras
for (int i = 0; i < palabraGenerada.Length; i++)
{
if ((palabraGenerada[i].ToString().ToUpper().CompareTo(letra) == 0)
&& (((Label)pnlLetras.Controls[lblLetra + i]).Text.CompareTo("_") == 0))
{
((Label)pnlLetras.Controls[lblLetra + i]).Text = letra;
letrasAcertadas++;
coincidencias++;
marcarBotonLetra(letra, true);
if (letrasAcertadas == palabraGenerada.Length)
{
//Palabra acertada, juego terminado
lblMensaje.Text = "El juego ha finalizado. PALABRA CORRECTA!!!";
juegoFinalizado = true;
return;
}
}
}
if (coincidencias == 0)
{
errores++;
dibujarHangman(++estadoHangman);
marcarBotonLetra(letra, false);
//Si se agotan las posibilidades, mostramos un mensaje
//indicando que el juego ha terminado.
if (errores >= (int)HangmanParts.LeftLeg)
{
lblMensaje.Text = "El juego ha finalizado. PALABRA INCORRECTA!";
juegoFinalizado = true;
}
}
}
else
{
MessageBox.Show("El juego ha finalizado. Pulse Nuevo para empezar otra vez",
"Juego finalizado", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
//Inicialización del juego. Se inicializan la variables necesarias para
//establecer el estado inicial del juego.
private void btnNuevo_Click(object sender, EventArgs e)
{
letrasAcertadas = 0;
errores = 0;
estadoHangman = 0;
juegoFinalizado = false;
btnComprobar.Enabled = true;
//Borramos limpiamos todos los controles label de pnlLetras
limpiarEtiquetasLetras();
//Inicializamos el estado de los botones correspondientes a las letras
desmarcarBotonesLetras();
//Limpiamos el contenido de pnlGrafico y dibujamos la parte inicial (la horca)
dibujarHangman(HangmanParts.None);
//Generamos aleatoriamente una nueva palabra
palabraGenerada = generarPalabra().ToUpper();
txtSolucion.Text = palabraGenerada;
//Creamos y mostramos un control de tipo Label para cada letra
//de la palabra generada
crearEtiquetasPalabra(palabraGenerada.Length);
//Eliminamos el mensaje anterior (si lo hay)
limpiarMensaje();
}
//Este método permite dibujar el muñeco ahorcado que indica el número de
//errores cometidos por el jugador y el número de errores que todavía puede
//cometer antes de perder la partida. El método se ocupa de dibujar en el
//un panel del formulario las partes del muñeco de acuerdo con el estado
//del juego que recibe como parámetro.
private void dibujarHangman(HangmanParts estado)
{
Graphics g = pnlGrafico.CreateGraphics();
Pen pHorca = new Pen(Color.Black, 4.5f);
Pen pCuerda = new Pen(Color.Black, 2.5f);
Pen pMan = new Pen(Color.Brown, 2f);
Pen pManFino = new Pen(Color.Brown, 1.5f);
//Limpiamos el panel para redibujar el ahorcado
g.Clear(Color.FromKnownColor(KnownColor.ScrollBar));
//Dibujamos la horca
g.DrawLine(pHorca, (pnlGrafico.Width / 2)-10, pnlGrafico.Height - 35,
(pnlGrafico.Width / 2) + 80, pnlGrafico.Height - 35);
g.DrawLine(pHorca, (pnlGrafico.Width / 2) + 45, pnlGrafico.Height - 35,
(pnlGrafico.Width / 2) + 45, pnlGrafico.Height - 185);
g.DrawLine(pHorca, (pnlGrafico.Width / 2) + 5, pnlGrafico.Height - 183,
(pnlGrafico.Width / 2) + 45, pnlGrafico.Height - 183);
g.DrawLine(pCuerda, (pnlGrafico.Width / 2) + 6, pnlGrafico.Height - 183,
(pnlGrafico.Width / 2) + 5, pnlGrafico.Height - 160);
if (estado >= HangmanParts.LeftLeg) {
//Dibujamos la pierna izda
g.DrawLine(pMan, (pnlGrafico.Width / 2) + 5, pnlGrafico.Height - 80,
(pnlGrafico.Width / 2) - 8, pnlGrafico.Height - 70);
}
if (estado >= HangmanParts.RightLeg) {
//Dibujamos la pierna derecha
g.DrawLine(pMan, (pnlGrafico.Width / 2) + 5, pnlGrafico.Height - 80,
(pnlGrafico.Width / 2) + 18, pnlGrafico.Height - 70);
}
if (estado >= HangmanParts.LeftArm)
{
//Dibujamos el brazo izquierdo
g.DrawLine(pMan, (pnlGrafico.Width / 2) + 5, pnlGrafico.Height - 120,
(pnlGrafico.Width / 2) - 8, pnlGrafico.Height - 105);
}
if (estado >= HangmanParts.RightArm)
{
//Dibujamos el brazo derecho
g.DrawLine(pMan, (pnlGrafico.Width / 2) + 5, pnlGrafico.Height - 120,
(pnlGrafico.Width / 2) + 18, pnlGrafico.Height - 105);
}
if (estado >= HangmanParts.Trunk)
{
//Dibujamos el tronco
g.DrawLine(pMan, (pnlGrafico.Width / 2) + 5, pnlGrafico.Height - 130,
(pnlGrafico.Width / 2) + 5, pnlGrafico.Height - 80);
}
//if (estado >= HangmanParts.Mouth)
//{
// //Dibujamos la boca
// Point pto1 = new Point((pnlGrafico.Width / 2), pnlGrafico.Height - 137);
// Point pto2 = new Point((pnlGrafico.Width / 2) + 4, pnlGrafico.Height - 135);
// Point pto3 = new Point((pnlGrafico.Width / 2) + 8, pnlGrafico.Height - 137);
// Point[] ptosBoca = new Point[] { pto1, pto2, pto3 };
// g.DrawCurve(pManFino, ptosBoca);
//}
//if (estado >= HangmanParts.Nose)
//{
// //Dibujamos la nariz
// g.DrawEllipse(pMan, (pnlGrafico.Width / 2) + 3, pnlGrafico.Height - 146, 2, 5);
//}
//if (estado >= HangmanParts.LeftEye)
//{
// //Dibujamos el ojo izdo
// g.DrawEllipse(pMan, (pnlGrafico.Width / 2) + 7, pnlGrafico.Height - 152, 8, 4);
//}
//if (estado >= HangmanParts.RightEye)
//{
// //Dibujamos el ojo derecho
// g.DrawEllipse(pMan, (pnlGrafico.Width / 2) - 6, pnlGrafico.Height - 152, 8, 4);
//}
if (estado >= HangmanParts.Head)
{
//Dibujamos la boca
Point pto1 = new Point((pnlGrafico.Width / 2), pnlGrafico.Height - 137);
Point pto2 = new Point((pnlGrafico.Width / 2) + 4, pnlGrafico.Height - 135);
Point pto3 = new Point((pnlGrafico.Width / 2) + 8, pnlGrafico.Height - 137);
Point[] ptosBoca = new Point[] { pto1, pto2, pto3 };
g.DrawCurve(pManFino, ptosBoca);
//Dibujamos la nariz
g.DrawEllipse(pMan, (pnlGrafico.Width / 2) + 3, pnlGrafico.Height - 146, 2, 5);
//Dibujamos el ojo izdo
g.DrawEllipse(pMan, (pnlGrafico.Width / 2) + 7, pnlGrafico.Height - 152, 8, 4);
//Dibujamos el ojo derecho
g.DrawEllipse(pMan, (pnlGrafico.Width / 2) - 6, pnlGrafico.Height - 152, 8, 4);
//Dibujamos la cabeza
g.DrawEllipse(pMan, new Rectangle((pnlGrafico.Width / 2) - 10,
pnlGrafico.Height - 160, 30, 30));
}
}
//Acciones iniciales que se realizan cuando se inicia la aplicación. Poner
//el juego en el estado inicial.
private void Form1_Shown(object sender, EventArgs e)
{
//Generamos aleatoriamente una nueva palabra
palabraGenerada = generarPalabra().ToUpper();
txtSolucion.Text = palabraGenerada;
//Creamos y mostramos un control de tipo Label para cada letra de la
//palabra generada
crearEtiquetasPalabra(palabraGenerada.Length);
//Dibujamos la parte inicial del gráfico (la horca)
dibujarHangman(HangmanParts.None);
}
//Este método se ocupa de generar las etiquetas que albergan cada una de
//las letras que componen la palabra generada. Cuando se generan las
//etiquetas su contenido será el carácter "_" y según avance el juego y según
//vaya acertando letras el jugador, el contenido de dichas etiquetas irá
//cambiando a las letras que se corresponden con las letras de la palabra
//generada en cada momento.
private void crearEtiquetasPalabra(int longitudPalabra)
{
pnlLetras.Controls.Clear();
txtPalabra.Text = "";
for (int i = 0; i < longitudPalabra; i++)
{
Label lbl = new Label();
lbl.Name = "lblLetra" + i.ToString();
lbl.Text = "_";
//lbl.Text = palabra[i].ToString().ToUpper();
lbl.Font = new Font(FontFamily.GenericSansSerif, 14f, FontStyle.Bold);
lbl.Location = new Point(3 + (27 * i), 10);
lbl.Size = new Size(21, 25);
lbl.TextAlign = ContentAlignment.MiddleCenter;
lbl.BackColor = Color.FromKnownColor(KnownColor.ActiveCaption);
pnlLetras.Controls.Add(lbl);
}
}
//Método que se encarga de obtener de forma aleatoria una palabra de una
//conjunto de ellas (un fichero de texto es la opción más razonable). De
//momento, se utiliza un array de cadenas con algunas palabras para realizar
//las pruebas iniciales.
private String generarPalabra()
{
ArrayList listaPalabras = new ArrayList();
String linea;
OpenFileDialog ofd = new OpenFileDialog();
Random rnd = new Random();
//String[] palabras = new String[] {"murciélago", "palabra", "elefante" };
StreamReader sr = new StreamReader(File.OpenRead("listaPalabras.txt"));
while ((linea = sr.ReadLine()) != null)
{
listaPalabras.Add(linea);
}
return listaPalabras[rnd.Next(listaPalabras.Count)].ToString();
//return palabras[rnd.Next(palabras.Length)];
}
private void limpiarMensaje()
{
lblMensaje.Text = "";
}
private void chkMostrarSolucion_CheckedChanged(object sender, EventArgs e)
{
if (chkMostrarSolucion.Checked == true)
{
txtSolucion.Visible = true;
}
else
{
txtSolucion.Visible = false;
}
}
}
}
Hola, gracias por compartir tu proyecto. Estoy realizando el juego el ahorcado, necesito usar un patron de diseño, que patron me recomendarias para este juego. Saludos
ResponderEliminarEste comentario ha sido eliminado por el autor.
ResponderEliminar