/***************************************** PLAYER ****************************************************/
/// <summary>
/// Quita numCartas del mazo y las inserta en la mano
/// </summary>
/// <param name="player"></param>
/// <param name="numCartas"></param>
/// <param name="fast"></param>
public void DibujarCartasMazo(JugadorPartida player, int numCartas, bool fast = false)
{
for (int i = 0; i < numCartas; i++)
{
DibujarCartaMazo(player, fast);
}
}
/// <summary>
/// Muestra cartas jugables de la mano del jugador
/// </summary>
/// <param name="jugador">Jugador.</param>
public void ActualizarEstadoCartasJugadorActual(JugadorPartida jugador)
{
if (jugador == JugadorActual)
{
ActualizarEstadoCartasJugador(jugador, false);
}
}
/// <summary>
/// Permite jugar un ente para el bot.
/// </summary>
/// <returns><c>true</c>, if ente was jugared, <c>false</c> otherwise.</returns>
bool JugarEnte()
{
bool movimientoHecho = false;
for (int i = 0; i < NumEntesEnLaMesa() && !movimientoHecho; i++)
{
Ente cl = EntesEnLaMesa() [i];
if (Controlador.Instance.EntePuedeUsarse(cl))
{
// attack a random target with a creature
if (cl.GetType() == typeof(Magica))
{
if (!((Magica)cl).EfectoActivado)
{
if (!Controlador.Instance.EsMagicaTrampa(cl))
{
Controlador.Instance.ActivarEfectoMagica(cl.ID);
movimientoHecho = true;
}
}
}
else
{
Criatura criatura = (Criatura)cl;
if (criatura.PosicionCriatura.Equals(PosicionCriatura.ATAQUE))
{
if (!Controlador.Instance.CriaturaHaAtacado(criatura))
{
JugadorPartida enemigo = Controlador.Instance.OtroJugador(this);
if (enemigo.NumEntesEnLaMesa() > 0)
{
int index = Random.Range(0, enemigo.NumEntesEnLaMesa());
Ente enteObjetivo = enemigo.EntesEnLaMesa() [index];
if (enteObjetivo.GetType() == typeof(Criatura) || (enteObjetivo.GetType() == typeof(Magica) && !((Magica)enteObjetivo).EfectoActivado))
{
Controlador.Instance.AtacarEnte(cl.ID, enteObjetivo.ID);
movimientoHecho = true;
}
}
else
{
Controlador.Instance.AtacarJugador(cl.ID, enemigo.ID);
movimientoHecho = true;
}
}
}
else
{
Controlador.Instance.CambiarPosicionCriatura(criatura.ID);
movimientoHecho = true;
}
}
}
}
if (movimientoHecho)
{
InsertDelay(1f);
}
return(movimientoHecho);
}
/// <summary>
/// Función que se llama cuando se ataca a un ente mágico.
/// </summary>
/// <param name="criaturaAtacante">Criatura atacante.</param>
/// <param name="magicaObjetivo">Magica objetivo.</param>
public void AtacarMagica(Criatura criaturaAtacante, Magica magicaObjetivo)
{
JugadorPartida objetivo = ObtenerDueñoEnte(magicaObjetivo);
controladorEnte.AtacarMagica(criaturaAtacante, magicaObjetivo);
controladorJugador.QuitarVidaJugador(objetivo, criaturaAtacante.Ataque);
}
/// <summary>
/// Jugar una carta de la mano en el tablero mágica
/// </summary>
/// <param name="magicaJugada"></param>
/// <param name="tablePos"></param>
public void JugarMagicaMano(JugadorPartida jugador, CartaPartida magicaJugada, int tablePos)
{
RestarManaCarta(jugador, magicaJugada);
Magica nuevaMagica = new Magica(jugador.Area, magicaJugada.AssetCarta);
JugarCarta(jugador, magicaJugada, nuevaMagica, tablePos);
}
public PlayAEntityCommand(CartaPartida cl, JugadorPartida p, int tablePos, Ente ente)
{
this.p = p;
this.cl = cl;
this.tablePos = tablePos;
this.ente = ente;
}
/// <summary>
/// Funcion que para el movimiento de los jugadores, el temporizador de turno y lanza el mensaje de fin de batalla
/// </summary>
public void MuerteJugador(JugadorPartida jugador)
{
PararControlJugadores();
Button salirPartida = GameObject.FindGameObjectWithTag("SalirPartida").GetComponent <Button> ();
salirPartida.interactable = false;
GameObject.FindGameObjectWithTag("BotonFinTurno").GetComponent <Button> ().interactable = false;
Controlador.Instance.StopTheTimer();
new MuerteJugadorCommand(jugador).AñadirAlaCola();
IDFactory.RecoverCountMenu();
int exp = AñadirExperienciaJugador(jugador);
if (jugador.GetType() == typeof(JugadorHumano))
{
new GameOverCommand(jugador, exp).AñadirAlaCola();
BaseDatos.Instance.ActualizarNivelYExperienciaBaseDatos();
}
else
{
JugadorPartida ganador = OtroJugador(jugador);
Carta carta = ObtenerCartaPremio();
List <Item> items = ObtenerItemsPremio();
AñadirPremioJugador(ganador, carta, items);
IDFactory.SaveCountMenu();
new PremioPartidaCommand(jugador, carta, items, exp).AñadirAlaCola();
BaseDatos.Instance.ActualizarJugadorBaseDatos(carta != null);
}
}
/// <summary>
/// Añade la experiencia obtenida al jugador, según el tipo de configuración da mas o menos.
/// </summary>
/// <returns>The experiencia jugador.</returns>
/// <param name="jugador">Jugador.</param>
private int AñadirExperienciaJugador(JugadorPartida jugador)
{
ConfiguracionUsuario settings = ConfiguracionUsuario.Instance;
int min = 0;
int max = 0;
if (settings.ConfiguracionBatalla.Equals(ConfiguracionUsuario.TIPO_CONFIGURACION.PORCENTAJE))
{
min = 50;
max = 90;
}
else
{
min = 10;
max = 50;
}
int exp = Random.Range(min, max);
jugador.Jugador.Experiencia += exp;
if (jugador.Jugador.Experiencia >= 100)
{
jugador.Jugador.Experiencia -= 100;
jugador.Jugador.Nivel += 1;
}
return(exp);
}
public PremioPartidaCommand(JugadorPartida ganador, Carta carta, List <Item> items, int exp)
{
this.ganador = ganador;
this.carta = carta;
this.items = items;
this.exp = exp;
}
public DrawACardCommand(CartaPartida cl, JugadorPartida p, bool fast, bool fromDeck)
{
this.cl = cl;
this.p = p;
this.fast = fast;
this.fromDeck = fromDeck;
}
/// <summary>
/// Inicia el turno del jugador, muestra el mensaje de turno y actualiza el mana y las cartas.
/// </summary>
/// <param name="jugador">Jugador.</param>
private void OnTurnStart(JugadorPartida jugador)
{
jugador.OnTurnStart();
if (jugador.Jugador.TipoJugador.Equals(Jugador.TIPO_JUGADOR.AUTOMÁTICO))
{
new ShowMessageCommand("¡Turno enemigo!", 2.0f).AñadirAlaCola();
}
else
{
new ShowMessageCommand("¡Tu Turno!", 2.0f).AñadirAlaCola();
}
Controlador.Instance.DibujarCartaMazo(jugador);
if (jugador.GetType() == typeof(JugadorBot))
{
((JugadorBot)jugador).EmpezarTurnoBot();
}
else
{
ActualizarManaJugador(jugador);
ActualizarEstadoCartasJugadorActual(jugador);
}
if (OtroJugador(jugador).GetType() == typeof(JugadorHumano))
{
ActualizarEstadoCartasJugadorEnemigo(jugador);
}
}
/// <summary>
/// Oculta las cartas del jugador que no tiene el turno.
/// </summary>
/// <param name="jugador">Jugador.</param>
private void ActualizarEstadoCartasJugadorEnemigo(JugadorPartida jugador)
{
if (jugador == JugadorActual)
{
ActualizarEstadoCartasJugador(OtroJugador(jugador), true);
}
}
/// <summary>
/// Función que permite que la criatura ataque al jugador.
/// </summary>
/// <param name="idCriaturaAtacante">Identifier criatura atacante.</param>
/// <param name="idJugadorObjetivo">Identifier jugador objetivo.</param>
public void AtacarJugador(int idCriaturaAtacante, int idJugadorObjetivo)
{
Criatura atacante = (Criatura)Recursos.EntesCreadosEnElJuego[idCriaturaAtacante];
JugadorPartida jugador = Controlador.Instance.Local.ID == idJugadorObjetivo ? Controlador.Instance.Local : Controlador.Instance.Enemigo;
atacante.HaAtacado = true;
controladorJugador.AtacarJugador(atacante, jugador);
}
/// <summary>
/// Jugar una carta de la mano en el tablero no mágica
/// </summary>
/// <param name="cartaJugada"></param>
/// <param name="tablePos"></param>
/// <param name="posicionAtaque"></param>
public void JugarCartaMano(JugadorPartida jugador, CartaPartida cartaJugada, int tablePos, bool posicionAtaque)
{
//ELIMINATE
RestarManaCarta(jugador, cartaJugada);
Criatura newCreature = new Criatura(jugador.Area, cartaJugada.AssetCarta, posicionAtaque == true ? PosicionCriatura.ATAQUE : PosicionCriatura.DEFENSA);
JugarCarta(jugador, cartaJugada, newCreature, tablePos);
}
/// <summary>
/// Actualiza los valores del jugador al iniciarse un turno.
/// </summary>
/// <param name="jugador">Jugador.</param>
public void ActualizarValoresJugador(JugadorPartida jugador)
{
timer.StartTimer();
ActivarBotonFinDeTurno(jugador);
controladorJugador.ActualizarValoresJugador(jugador);
}
/// <summary>
/// Mira si el jugador tiene el turno, si no hay cartas pendientes por mostrar y si tiene el control activado.
/// </summary>
/// <returns><c>true</c>, if permite controlar el jugador was sed, <c>false</c> otherwise.</returns>
/// <param name="jugador">Jugador.</param>
public bool SePermiteControlarElJugador(JugadorPartida jugador)
{
PlayerArea areaJugador = AreaJugador(jugador);
bool TurnoDelJugador = (_jugadorActual == jugador);
bool NoCartasPendientesPorMostrar = !Comandas.Instance.ComandasDeDibujoCartaPendientes();
return(areaJugador.PermitirControlJugador && areaJugador.ControlActivado && TurnoDelJugador && NoCartasPendientesPorMostrar);
}
/// <summary>
/// Permite añadir vida adicinal al jugador.
/// </summary>
/// <param name="jugador">Jugador.</param>
/// <param name="vida">Vida.</param>
public void GiveHealth(JugadorPartida jugador, int vida)
{
jugador.Defensa += vida;
if (jugador.GetType() == typeof(JugadorHumano))
{
new ShowMessageCommand("¡Obtienes " + vida + " de vida!", 1.0f).AñadirAlaCola();
}
ActualizarVidaJugador(jugador, jugador.Defensa - vida);
}
/// <summary>
/// Función que mata un ente.
/// </summary>
/// <param name="idEnte">Identifier ente.</param>
public void MuerteEnte(int idEnte)
{
Ente ente = Recursos.EntesCreadosEnElJuego[idEnte];
JugadorPartida jugadorObjetivo = Controlador.Instance.ObtenerDueñoEnte(ente);
jugadorObjetivo.EliminarEnteMesa(ente);
ente.Morir();
new EnteDieCommand(idEnte, jugadorObjetivo).AñadirAlaCola();
}
/// <summary>
/// Quita vida al jugador sin un ataque visual.
/// </summary>
/// <param name="jugadorObjetivo">Jugador objetivo.</param>
/// <param name="valorAtaque">Valor ataque.</param>
public void QuitarVidaJugador(JugadorPartida jugadorObjetivo, int valorAtaque)
{
new DealDamageCommand(jugadorObjetivo.ID, valorAtaque, jugadorObjetivo.Defensa).AñadirAlaCola();
jugadorObjetivo.Defensa -= valorAtaque;
if (JugadorMuerto(jugadorObjetivo))
{
MuerteJugador(jugadorObjetivo);
}
}
/// <summary>
/// Permite añadir mana adicinal al jugador.
/// </summary>
/// <param name="jugador">Jugador.</param>
/// <param name="mana">Mana.</param>
public void GiveManaBonus(JugadorPartida jugador, int mana)
{
jugador.ConseguirManaExtra(mana);
if (jugador.GetType() == typeof(JugadorHumano))
{
new ShowMessageCommand("¡Obtienes " + mana + " de maná!", 1.0f).AñadirAlaCola();
ActualizarManaJugador(jugador);
MostrarCartasJugablesJugador(jugador);
}
}
/// <summary>
/// Permite atacar de cara al jugador.
/// </summary>
/// <param name="atacante">Atacante.</param>
/// <param name="jugadorObjetivo">Jugador objetivo.</param>
public void AtacarJugador(Criatura atacante, JugadorPartida jugadorObjetivo)
{
atacante.AtaquesRestantesEnTurno--;
new CreatureAttackCommand(jugadorObjetivo.ID, atacante.ID, atacante.Ataque, jugadorObjetivo.Defensa).AñadirAlaCola();
jugadorObjetivo.Defensa -= atacante.Ataque;
if (JugadorMuerto(jugadorObjetivo))
{
MuerteJugador(jugadorObjetivo);
}
}
/// <summary>
/// Añade al jugador los premios obtenidos.
/// </summary>
/// <param name="jugador">Jugador.</param>
/// <param name="carta">Carta.</param>
/// <param name="items">Items.</param>
private void AñadirPremioJugador(JugadorPartida jugador, Carta carta, List <Item> items)
{
if (carta != null)
{
jugador.Jugador.AñadirCarta(carta);
}
foreach (Item item in items)
{
jugador.Jugador.AñadirItem(item);
}
}
/// <summary>
/// Inicializars los valores del jugador.
/// </summary>
/// <param name="jugador">Jugador.</param>
public void InicializarValoresJugador(JugadorPartida jugador)
{
PlayerArea areaJugador = AreaJugador(jugador);
jugador.ManaEnEsteTurno = 0;
jugador.ManaRestante = 0;
TransmitirInformacionVisualJugador(jugador);
areaJugador.mazoVisual.CartasEnMazo = jugador.Jugador.NumCartasMazo();
// move both portraits to the center
areaJugador.Personaje.transform.position = areaJugador.PosicionInicialPersonaje.position;
}
/// <summary>
/// Habilita o deshabilita el botón de fin de turno en función del jugador.
/// </summary>
/// <param name="P">P.</param>
public void ActivarBotonFinDeTurno(JugadorPartida P)
{
if (SePermiteControlarElJugador(P))
{
GameObject.FindGameObjectWithTag("BotonFinTurno").GetComponent <Button> ().interactable = true;
}
else
{
GameObject.FindGameObjectWithTag("BotonFinTurno").GetComponent <Button> ().interactable = false;
}
}
/// <summary>
/// Ataca a todas las criaturas del territorio enemigo, solo criaturas.
/// </summary>
/// <param name="jugador">Jugador.</param>
/// <param name="daño">Daño.</param>
public void DamageAllCreatures(JugadorPartida jugador, int daño)
{
ArrayList array = new ArrayList(jugador.EntesEnLaMesa());
ArrayList CreaturesToDamage = (ArrayList)array.Clone();
foreach (Ente cl in CreaturesToDamage)
{
if (cl.GetType() == typeof(Criatura))
{
Controlador.Instance.DañarCriatura((Criatura)cl, daño);
}
}
}
/// <summary>
/// Permite dañar una criatura sin mostrar un ataque visual, en caso de que se encuentre en defensa y
/// muera se quita vida al jugador, en ataque siempre se quita vida al jugador.
/// </summary>
/// <param name="criaturaObjetivo">Criatura objetivo.</param>
/// <param name="daño">Daño.</param>
public void DañarCriatura(Criatura criaturaObjetivo, int daño)
{
JugadorPartida objetivo = ObtenerDueñoEnte(criaturaObjetivo);
controladorEnte.QuitarVidaCriatura(criaturaObjetivo, daño);
if (criaturaObjetivo.PosicionCriatura.Equals(PosicionCriatura.ATAQUE))
{
controladorJugador.QuitarVidaJugador(objetivo, daño);
}
else if (criaturaObjetivo.PosicionCriatura.Equals(PosicionCriatura.DEFENSA) && controladorEnte.CriaturaMuerta(criaturaObjetivo))
{
controladorJugador.QuitarVidaJugador(objetivo, criaturaObjetivo.Defensa);
}
}
/// <summary>
/// Quita una carta del mazo y la muestra en la mano
/// </summary>
/// <param name="jugador"></param>
/// <param name="fast"></param>
public void DibujarCartaMazo(JugadorPartida jugador, bool fast = false)
{
if (jugador.Jugador.NumCartasMazo() > 0)
{
if (jugador.NumCartasMano() < 4)
{
//Esto nos devuelve la carta actual del mazo que se recorre infinitamente
Carta newCard = (Carta)jugador.CartaActual();
CartaPartida carta = new CartaPartida(newCard.AssetCarta);
jugador.AñadirCartaMano(0, carta);
// Debug.Log(hand.CardsInHand.Count);
new DrawACardCommand(jugador.CartasEnLaMano()[0], jugador, fast, fromDeck: true).AñadirAlaCola();
}
}
}
/// <summary>
/// Determina si el control tiene control.
/// </summary>
/// <param name="jugador">Jugador.</param>
public void TransmitirInformacionVisualJugador(JugadorPartida jugador)
{
PlayerArea areaJugador = AreaJugador(jugador);
areaJugador.Personaje.gameObject.AddComponent <IDHolder>().UniqueID = jugador.ID;
areaJugador.PermitirControlJugador = true;
if (jugador.GetType() == typeof(JugadorBot))
{
areaJugador.PermitirControlJugador = false;
}
else
{
areaJugador.PermitirControlJugador = true;
}
}
/// <summary>
/// Permite atacar a una criatura, mostrándose la animación de ataque.
/// </summary>
/// <param name="criaturaAtacante">Criatura atacante.</param>
/// <param name="criaturaObjetivo">Criatura objetivo.</param>
public void AtacarCriatura(Criatura criaturaAtacante, Criatura criaturaObjetivo)
{
JugadorPartida objetivo = ObtenerDueñoEnte(criaturaObjetivo);
controladorEnte.AtacarCriatura(criaturaAtacante, criaturaObjetivo);
if (criaturaObjetivo.PosicionCriatura.Equals(PosicionCriatura.ATAQUE))
{
controladorJugador.QuitarVidaJugador(objetivo, criaturaAtacante.Ataque);
controladorEnte.QuitarVidaCriatura(criaturaAtacante, criaturaObjetivo.Ataque);
}
else if (criaturaObjetivo.PosicionCriatura.Equals(PosicionCriatura.DEFENSA) && controladorEnte.CriaturaMuerta(criaturaObjetivo))
{
controladorJugador.QuitarVidaJugador(objetivo, System.Math.Abs(criaturaObjetivo.Defensa));
}
}
/// <summary>
/// Jugar carta
/// </summary>
/// <param name="cartaJugada"></param>
/// <param name="ente"></param>
/// <param name="tablePos"></param>
private void JugarCarta(JugadorPartida jugador, CartaPartida cartaJugada, Ente ente, int tablePos)
{
jugador.AñadirEnteMesa(tablePos, ente);
// no matter what happens, move this card to PlayACardSpot
new PlayAEntityCommand(cartaJugada, jugador, tablePos, ente).AñadirAlaCola();
if (jugador.GetType() == typeof(JugadorHumano))
{
ActualizarManaJugador(jugador);
MostrarCartasJugablesJugador(jugador);
}
jugador.EliminarCartaMano(cartaJugada);
if (jugador.GetType() == typeof(JugadorHumano))
{
MostrarCartasJugablesJugador(jugador);
}
}
