/// <summary>
/// Genera el conjunto de ocurrencias de un conjunto de letras. Las letras no despejadas se son representadas por el carácter _.
/// </summary>
/// <param name="jugadas">Conjunto de letras jugadas.</param>
/// <returns>Conjunto de ocurrencias de las letras jugadas.</returns>
public ArrayList GenerarOcurrencias(ArrayList jugadas)
{
ArrayList visibles = new ArrayList();
int contador = 0;
// Se recorren todas las letras de la palabra:
while (contador < m_letras.Count)
{
Letra l = (Letra)m_letras[contador];
if (!BuscarLetraEnVector(l, jugadas))
{
visibles.Add(new Letra('_'));
}
else
{
visibles.Add(l);
}
++contador;
}
return(visibles);
}
/// <summary>
/// Juega una letra específica.
/// </summary>
/// <param name="letra">Letra a jugar.</param>
/// <returns><em>true</em> si la letra pertenece a la palbra; <em>false</em> en caso contrario.</returns>
public bool JugarLetra(Letra letra)
{
if (m_estado != EstadoJuego.Jugando)
{
return(false);
}
m_jugadas.Add(letra);
bool pertenece = m_actual.EstaLetra(letra);
if (!pertenece)
{
--m_intentosDisponibles;
if (m_intentosDisponibles == 0)
{
m_estado = EstadoJuego.Ahorcado;
}
}
else
{
if (m_actual.EstaCompleta(m_jugadas))
{
m_estado = EstadoJuego.Ganador;
}
}
return(pertenece);
}
/// <summary>
/// Determina si la palabra ya fue completada respecto a las letras jugadas.
/// </summary>
/// <param name="jugadas">Conjunto de letras jugadas.</param>
/// <returns><i>true</i> si palabra ya fue completada; <em>false</em> en caso contrario.</returns>
public bool EstaCompleta(ArrayList jugadas)
{
Boolean completa = true;
int contador = 0;
while (contador < m_letras.Count && completa)
{
Letra l = (Letra)m_letras[contador];
if (!BuscarLetraEnVector(l, jugadas))
{
completa = false;
}
++contador;
}
return(completa);
}
/// <summary>
/// Determina si la letra fue utilizada en una partida del ahorcado.
/// </summary>
/// <param name="letra">Letra a determinar si ha sido jugada.</param>
/// <returns><i>true</i> si la letra fue jugada; <i>false</i> en caso contrario.</returns>
public bool LetraUtilizada(Letra letra)
{
bool utilizada = false;
int contador = 0;
while (contador < m_jugadas.Count && !utilizada)
{
Letra l = (Letra)m_jugadas[contador];
if (l.EsIgual(letra))
{
utilizada = true;
}
++contador;
}
return(utilizada);
}
/// <summary>
/// Determina si una letra es igual a otra.
/// </summary>
/// <param name="letra">Letra a comparar.</param>
/// <returns><em>true</em> si las letras son iguales; <em>false</em> en caso contrario.</returns>
public bool EsIgual(Letra letra)
{
bool igual = false;
if (letra.Caracter == Caracter)
{
igual = true;
}
else if (Caracter >= 97 && ((Caracter - 32) == letra.Caracter))
{
igual = true;
}
else if (Caracter + 32 == letra.Caracter)
{
igual = true;
}
return igual;
}
/// <summary>
/// Determina si una letra es igual a otra.
/// </summary>
/// <param name="letra">Letra a comparar.</param>
/// <returns><em>true</em> si las letras son iguales; <em>false</em> en caso contrario.</returns>
public bool EsIgual(Letra letra)
{
bool igual = false;
if (letra.Caracter == Caracter)
{
igual = true;
}
else if (Caracter >= 97 && ((Caracter - 32) == letra.Caracter))
{
igual = true;
}
else if (Caracter + 32 == letra.Caracter)
{
igual = true;
}
return(igual);
}
/// <summary>
/// Bucar una letra en un vector de letras.
/// </summary>
/// <param name="letra">Letra a buscar.</param>
/// <param name="vectorLetras">Vector con las letras.</param>
/// <returns><i>true</i> si la letra fue encontrada; <i>false</i> en caso contrario.</returns>
private bool BuscarLetraEnVector(Letra letra, ArrayList vectorLetras)
{
bool estaLetra = false;
int contador = 0;
// Se recorre el vector:
while (contador < vectorLetras.Count && !estaLetra)
{
Letra l = (Letra)vectorLetras[contador];
if (l.EsIgual(letra))
{
estaLetra = true;
}
++contador;
}
return(estaLetra);
}
/// <summary>
/// Bucar una letra en un vector de letras.
/// </summary>
/// <param name="letra">Letra a buscar.</param>
/// <param name="vectorLetras">Vector con las letras.</param>
/// <returns><i>true</i> si la letra fue encontrada; <i>false</i> en caso contrario.</returns>
private bool BuscarLetraEnVector(Letra letra, ArrayList vectorLetras)
{
bool estaLetra = false;
int contador = 0;
// Se recorre el vector:
while (contador < vectorLetras.Count && !estaLetra)
{
Letra l = (Letra)vectorLetras[contador];
if (l.EsIgual(letra))
{
estaLetra = true;
}
++contador;
}
return estaLetra;
}
public void JugarLetraTest()
{
ConfiguracionEscenario1();
m_juego.IniciarJuego();
Palabra actual = m_juego.PalabraActual;
ArrayList jugadas = new ArrayList();
Letra letraIntento = new Letra('a');
jugadas.AddRange(actual.Letras);
Assert.IsTrue(actual.EstaCompleta(jugadas), "La palabra ya fue adivinada.");
ArrayList ocurrencias = actual.GenerarOcurrencias(jugadas);
Assert.IsFalse(ocurrencias.Contains('_'), "todas las letras deben ser visibles.");
if (m_juego.JugarLetra(letraIntento) == true)
{
Assert.IsTrue(m_juego.Jugadas.Contains(letraIntento), "El vector de letras debe contener las letras jugadas.");
}
else
{
int intentos = (int)JuegoAhorcadoConstantes.MaximoIntentos - 1;
Assert.AreEqual((int) JuegoAhorcadoConstantes.MaximoIntentos - 1, m_juego.IntentosDisponibles, String.Format("El número de intentos debe ser {0}.", intentos.ToString()));
if ((int)JuegoAhorcadoConstantes.MaximoIntentos == 0)
{
Assert.AreEqual(EstadoJuego.Ahorcado, m_juego.Estado, "El estado del juego debe ser AHORCADO.");
}
Assert.IsFalse(m_juego.JugarLetra(letraIntento), "La letra no est[a en la palabra.");
}
}
/// <summary>
/// Determina si una letra está en el conjunto de letras de la palabra.
/// </summary>
/// <param name="letra">Letra a buscar.</param>
/// <returns><em>true</em> si la letra está en el conjunto de letras; <em>false</em> en caso contrario.</returns>
public bool EstaLetra(Letra letra)
{
return(BuscarLetraEnVector(letra, m_letras));
}
/// <summary>
/// Juega una letra.
/// </summary>
/// <param name="letra">Letra a jugar.</param>
public void JugarLetra(char letra)
{
EstadoJuego estado = m_juego.Estado;
if (estado == EstadoJuego.Jugando)
{
Letra letraJugada = new Letra(letra);
bool letraUsada = m_juego.LetraUtilizada(letraJugada);
if (letraUsada)
{
m_ctlAhorcado.EtiquetarMensaje("Letra Ya Jugada");
}
else if (!(m_juego.JugarLetra(letraJugada)) && !letraUsada)
{
m_ctlAhorcado.EtiquetarMensaje("Incorrecto");
}
else
{
m_ctlAhorcado.EtiquetarMensaje(String.Empty);
}
m_ctlAhorcado.Actualizar();
}
}
/// <summary>
/// Determina si una letra está en el conjunto de letras de la palabra.
/// </summary>
/// <param name="letra">Letra a buscar.</param>
/// <returns><em>true</em> si la letra está en el conjunto de letras; <em>false</em> en caso contrario.</returns>
public bool EstaLetra(Letra letra)
{
return BuscarLetraEnVector(letra, m_letras);
}
/// <summary>
/// /// Configuración de escenario de pruebas no. 4.
/// </summary>
public void ConfiguracionEscenario4()
{
m_letra = new Letra('Z');
}
/// <summary>
/// Determina si la letra fue utilizada en una partida del ahorcado.
/// </summary>
/// <param name="letra">Letra a determinar si ha sido jugada.</param>
/// <returns><i>true</i> si la letra fue jugada; <i>false</i> en caso contrario.</returns>
public bool LetraUtilizada(Letra letra)
{
bool utilizada = false;
int contador = 0;
while(contador < m_jugadas.Count && !utilizada)
{
Letra l = (Letra)m_jugadas[contador];
if (l.EsIgual(letra))
{
utilizada = true;
}
++contador;
}
return utilizada;
}
/// <summary>
/// Juega una letra específica.
/// </summary>
/// <param name="letra">Letra a jugar.</param>
/// <returns><em>true</em> si la letra pertenece a la palbra; <em>false</em> en caso contrario.</returns>
public bool JugarLetra(Letra letra)
{
if (m_estado != EstadoJuego.Jugando)
{
return false;
}
m_jugadas.Add(letra);
bool pertenece = m_actual.EstaLetra(letra);
if (!pertenece)
{
--m_intentosDisponibles;
if(m_intentosDisponibles == 0)
{
m_estado = EstadoJuego.Ahorcado;
}
}
else
{
if (m_actual.EstaCompleta(m_jugadas))
{
m_estado = EstadoJuego.Ganador;
}
}
return pertenece;
}