private bool[,] CalcularPiezasAGirar(Point tirada, ColorDeFicha colorDeJugadorTirando)
{
bool[,] piezas = new bool[TAMAÑO_DE_TABLERO, TAMAÑO_DE_TABLERO];
Point incremento = new Point(1, 0);
incremento = AsignarDireccion(incremento, Direccion.Abajo);
piezas = SumarTableros(piezas, SeDebeGirar(tirada, incremento, colorDeJugadorTirando));
incremento = AsignarDireccion(incremento, Direccion.AbajoDerecha);
piezas = SumarTableros(piezas, SeDebeGirar(tirada, incremento, colorDeJugadorTirando));
incremento = AsignarDireccion(incremento, Direccion.AbajoIzquierda);
piezas = SumarTableros(piezas, SeDebeGirar(tirada, incremento, colorDeJugadorTirando));
incremento = AsignarDireccion(incremento, Direccion.Arriba);
piezas = SumarTableros(piezas, SeDebeGirar(tirada, incremento, colorDeJugadorTirando));
incremento = AsignarDireccion(incremento, Direccion.ArribaDerecha);
piezas = SumarTableros(piezas, SeDebeGirar(tirada, incremento, colorDeJugadorTirando));
incremento = AsignarDireccion(incremento, Direccion.ArribaIzquierda);
piezas = SumarTableros(piezas, SeDebeGirar(tirada, incremento, colorDeJugadorTirando));
incremento = AsignarDireccion(incremento, Direccion.Derecha);
piezas = SumarTableros(piezas, SeDebeGirar(tirada, incremento, colorDeJugadorTirando));
incremento = AsignarDireccion(incremento, Direccion.Izquierda);
piezas = SumarTableros(piezas, SeDebeGirar(tirada, incremento, colorDeJugadorTirando));
return(piezas);
}
public void PonerFicha(Point punto, ColorDeFicha colorDeJugador)
{
Ficha fichaTirada = new Ficha()
{
ColorActual = colorDeJugador,
Posicion = punto
};
Fichas[(int)punto.X, (int)punto.Y] = fichaTirada;
}
/// <summary>
/// Valida la <paramref name="sesion"/> y la <paramref name="sala"/> para registrar la sesión en esta
/// </summary>
/// <param name="sala"></param>
/// <param name="sesion"></param>
public void IngresarASala(Sesion sesion, Sala sala)
{
if (ValidarAutenticidadDeSesion(sesion) &&
ValidarExistenciaDeSala(sala) &&
!ValidarExistenciaDeSesionEnSalasCreadas(sesion))
{
Sala salaLocal = SalasCreadas.FirstOrDefault(s => s.ID == sala.ID);
Sesion sesionLocal = SesionesConectadas.FirstOrDefault(s => s.ID == sesion.ID);
if (salaLocal.Jugadores.Count < NUMERO_MAXIMO_DE_JUGADORES_EN_SALA)
{
if (sesionLocal.Usuario.Puntuacion.Nivel >= salaLocal.NivelMinimo &&
sesionLocal.Usuario.Puntuacion.Nivel <= salaLocal.NivelMaximo)
{
ColorDeFicha colorDeCreador = ColorDeFicha.Ninguno;
foreach (Jugador jugadorEnSala in salaLocal.Jugadores)
{
if (jugadorEnSala.Sesion.Usuario.NombreDeUsuario == salaLocal.NombreDeUsuarioCreador)
{
colorDeCreador = jugadorEnSala.Color;
}
}
Jugador jugador = new Jugador
{
Color = ColorContrario(colorDeCreador),
Sesion = sesionLocal,
ListoParaJugar = false
};
int indiceSalaLocal = SalasCreadas.IndexOf(salaLocal);
SalasCreadas[indiceSalaLocal].Jugadores.Add(jugador);
NotificarCambioEnSalaAJugadores(SalasCreadas[indiceSalaLocal]);
if (ControladorServiciosDeFlipllo != null)
{
ControladorServiciosDeFlipllo.ListaDeSalasActualizado(SalasCreadas);
}
}
else
{
int indiceSala = SalasCreadas.IndexOf(salaLocal);
SalasCreadas[indiceSala].Estado = EstadoSala.CupoLleno;
if (ControladorServiciosDeFlipllo != null)
{
ControladorServiciosDeFlipllo.ListaDeSalasActualizado(SalasCreadas);
}
}
}
}
}
public void Girar()
{
if (ColorActual == ColorDeFicha.Blanco)
{
ColorActual = ColorDeFicha.Negro;
ColorAnterior = ColorDeFicha.Blanco;
}
else
{
ColorActual = ColorDeFicha.Blanco;
ColorAnterior = ColorDeFicha.Negro;
}
}
public static ColorDeFicha ColorContrario(ColorDeFicha colorDeJugador)
{
ColorDeFicha resultado = ColorDeFicha.Ninguno;
if (colorDeJugador == ColorDeFicha.Blanco)
{
resultado = ColorDeFicha.Negro;
}
else if (colorDeJugador == ColorDeFicha.Negro)
{
resultado = ColorDeFicha.Blanco;
}
return(resultado);
}
public int ObtenerPuntosPorColor(ColorDeFicha colorDeFicha)
{
int cuenta = 0;
if (colorDeFicha == ColorDeFicha.Blanco)
{
cuenta = PuntosBlancos;
}
if (colorDeFicha == ColorDeFicha.Negro)
{
cuenta = PuntosNegros;
}
return(cuenta);
}
public int ObtenerCuentaDeFichas(ColorDeFicha colorDeFicha)
{
int cuenta = 0;
if (colorDeFicha == ColorDeFicha.Blanco)
{
cuenta = FichasBlancas;
}
if (colorDeFicha == ColorDeFicha.Negro)
{
cuenta = FichasNegras;
}
return(cuenta);
}
public bool EsMovimientoLegal(Point posicion, ColorDeFicha colorDeJugadorTirando)
{
Point incremento = new Point(1, 0);
bool resultadoDeValidacion = EsMovimientoLegalConOrientacion(posicion, colorDeJugadorTirando, incremento);
if (!resultadoDeValidacion)
{
incremento = AsignarDireccion(incremento, Direccion.Abajo);
resultadoDeValidacion = EsMovimientoLegalConOrientacion(posicion, colorDeJugadorTirando, incremento);
}
if (!resultadoDeValidacion)
{
incremento = AsignarDireccion(incremento, Direccion.AbajoDerecha);
resultadoDeValidacion = EsMovimientoLegalConOrientacion(posicion, colorDeJugadorTirando, incremento);
}
if (!resultadoDeValidacion)
{
incremento = AsignarDireccion(incremento, Direccion.AbajoIzquierda);
resultadoDeValidacion = EsMovimientoLegalConOrientacion(posicion, colorDeJugadorTirando, incremento);
}
if (!resultadoDeValidacion)
{
incremento = AsignarDireccion(incremento, Direccion.Arriba);
resultadoDeValidacion = EsMovimientoLegalConOrientacion(posicion, colorDeJugadorTirando, incremento);
}
if (!resultadoDeValidacion)
{
incremento = AsignarDireccion(incremento, Direccion.ArribaDerecha);
resultadoDeValidacion = EsMovimientoLegalConOrientacion(posicion, colorDeJugadorTirando, incremento);
}
if (!resultadoDeValidacion)
{
incremento = AsignarDireccion(incremento, Direccion.ArribaIzquierda);
resultadoDeValidacion = EsMovimientoLegalConOrientacion(posicion, colorDeJugadorTirando, incremento);
}
if (!resultadoDeValidacion)
{
incremento = AsignarDireccion(incremento, Direccion.Derecha);
resultadoDeValidacion = EsMovimientoLegalConOrientacion(posicion, colorDeJugadorTirando, incremento);
}
if (!resultadoDeValidacion)
{
incremento = AsignarDireccion(incremento, Direccion.Izquierda);
resultadoDeValidacion = EsMovimientoLegalConOrientacion(posicion, colorDeJugadorTirando, incremento);
}
return(resultadoDeValidacion);
}
public int ContarFichas(ColorDeFicha colorDeFicha)
{
int cuenta = 0;
for (int i = 0; i < TAMAÑO_DE_TABLERO; i++)
{
for (int j = 0; j < TAMAÑO_DE_TABLERO; j++)
{
if (Fichas[i, j].ColorActual == colorDeFicha)
{
cuenta++;
}
}
}
return(cuenta);
}
private bool[,] SeDebeGirar(Point tirada, Point incremento, ColorDeFicha colorDeJugadorTirando)
{
bool finalEncontrado = false;
bool hayPiezasIntermedias = false;
bool haySaltos = false;
bool[,] piezasAGirar = new bool[TAMAÑO_DE_TABLERO, TAMAÑO_DE_TABLERO];
bool[,] piezasMarcadas = new bool[TAMAÑO_DE_TABLERO, TAMAÑO_DE_TABLERO];
Point posicionActual = new Point(tirada.X, tirada.Y);
int i = 0;
while (i <= TAMAÑO_DE_TABLERO && !finalEncontrado)
{
i++;
posicionActual.X += incremento.X;
posicionActual.Y += incremento.Y;
bool casillaDentroDeTablero = Tablero.EsCasillaDentroDeTablero(posicionActual);
if (casillaDentroDeTablero)
{
ColorDeFicha colorDeCasillaActual = Tablero.GetFicha(posicionActual).ColorActual;
if (colorDeCasillaActual == ColorDeFicha.Ninguno)
{
haySaltos = true;
}
else if (colorDeCasillaActual == ColorContrario(colorDeJugadorTirando))
{
piezasMarcadas[(int)posicionActual.X, (int)posicionActual.Y] = true;
hayPiezasIntermedias = true;
}
else if (colorDeCasillaActual == colorDeJugadorTirando)
{
finalEncontrado = true;
}
}
}
if (finalEncontrado && hayPiezasIntermedias && !haySaltos)
{
piezasAGirar = piezasMarcadas;
}
return(piezasAGirar);
}
public bool EsMovimientoLegalConOrientacion(Point posicion, ColorDeFicha colorDeJugadorTirando, Point incremento)
{
Point posicionActual = new Point(posicion.X, posicion.Y);
bool movimientoPosible = false;
if (EsMovimientoValido(posicionActual))
{
movimientoPosible = true;
}
bool hayPiezasIntermedias = false;
bool movimientoEncontrado = false;
int i = 0;
while (i <= TAMAÑO_DE_TABLERO && !movimientoEncontrado && movimientoPosible)
{
i++;
posicionActual.X += incremento.X;
posicionActual.Y += incremento.Y;
if (EsCasillaDentroDeTablero(posicionActual))
{
ColorDeFicha colorCasillaActual = Fichas[(int)posicionActual.X, (int)posicionActual.Y].ColorActual;
if (colorCasillaActual == ColorContrario(colorDeJugadorTirando))
{
hayPiezasIntermedias = true;
}
else
{
if (hayPiezasIntermedias && colorCasillaActual == colorDeJugadorTirando)
{
movimientoEncontrado = true;
}
else
{
movimientoPosible = false;
}
}
}
else
{
movimientoPosible = false;
}
}
return(movimientoEncontrado);
}
/// <summary>
/// Cambia el color del jugador creador de una sala y cambia el de los demás al color contrario
/// </summary>
/// <param name="sesion">Sesion creadora de la sala</param>
/// <param name="color">Color de la sesion a cambiar</param>
public void CambiarColorDeJugadorEnSala(Sesion sesion, ColorDeFicha color)
{
Sala sala = BuscarSalaDeSesion(sesion);
if (sala != null)
{
if (sesion.Usuario.NombreDeUsuario == sala.NombreDeUsuarioCreador)
{
int indiceSala = SalasCreadas.IndexOf(sala);
sala.Jugadores.FirstOrDefault(j => j.Sesion.ID == sesion.ID).Color = color;
if (color != ColorDeFicha.Ninguno)
{
foreach (Jugador jugador in sala.Jugadores)
{
jugador.Color = ColorContrario(color);
}
}
NotificarCambioEnSalaAJugadores(SalasCreadas[indiceSala]);
}
}
}
public Sala CrearSala(Sala sala, Sesion sesion, ColorDeFicha colorDeFicha)
{
Sala salaAEnviar = new Sala();
if (ValidarAutenticidadDeSesion(sesion) &&
!ValidarExistenciaDeSesionEnSalasCreadas(sesion) &&
ValidarDatosDeSala(sala) &&
!ValidarExistenciaDeSala(sala))
{
Sesion sesionCargada = SesionesConectadas.FirstOrDefault(s => s.ID == sesion.ID);
Sala salaAGuardar = new Sala
{
ID = Guid.NewGuid().ToString(),
Nombre = sala.Nombre,
NivelMaximo = sala.NivelMaximo,
NivelMinimo = sala.NivelMinimo,
NombreDeUsuarioCreador = sesionCargada.Usuario.NombreDeUsuario,
Estado = EstadoSala.Registrada,
};
Jugador jugador = new Jugador
{
Color = colorDeFicha,
Sesion = sesionCargada,
ListoParaJugar = false
};
salaAGuardar.Jugadores = new List <Jugador>();
salaAGuardar.Jugadores.Add(jugador);
SalasCreadas.Add(salaAGuardar);
salaAEnviar = salaAGuardar;
if (ControladorServiciosDeFlipllo != null)
{
ControladorServiciosDeFlipllo.ListaDeSalasActualizado(SalasCreadas);
}
}
return(salaAEnviar);
}
public bool[,] CalcularMovimientosLegales(ColorDeFicha colorDeFicha)
{
bool[,] movimientos = new bool[TAMAÑO_DE_TABLERO, TAMAÑO_DE_TABLERO];
Point posicion = new Point();
for (posicion.X = 0; posicion.X < TAMAÑO_DE_TABLERO; posicion.X++)
{
for (posicion.Y = 0; posicion.Y < TAMAÑO_DE_TABLERO; posicion.Y++)
{
if (EsMovimientoLegal(posicion, colorDeFicha))
{
movimientos[(int)posicion.X, (int)posicion.Y] = true;
}
else
{
movimientos[(int)posicion.X, (int)posicion.Y] = false;
}
}
}
return(movimientos);
}