public PlayAEntityCommand(CartaPartida cl, JugadorPartida p, int tablePos, Ente ente)
{
this.p = p;
this.cl = cl;
this.tablePos = tablePos;
this.ente = ente;
}
public DrawACardCommand(CartaPartida cl, JugadorPartida p, bool fast, bool fromDeck)
{
this.cl = cl;
this.p = p;
this.fast = fast;
this.fromDeck = fromDeck;
}
/// <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);
}
/// <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>
/// 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>
/// 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);
}
}
/// <summary>
/// Devuelve una carta a partir de la posición indexada en la mano del jugador.
/// </summary>
/// <returns>The carta por posicion.</returns>
/// <param name="c">C.</param>
/// <param name="position">Position.</param>
/// <param name="eulerAngles">Euler angles.</param>
GameObject CrearCartaPorPosicion(CartaPartida c, Vector3 position, Vector3 eulerAngles)
{
// Instantiate a card depending on its type
GameObject card;
// this card is a creature card
card = GameObject.Instantiate(ObjetosGenerales.Instance.CardPrefab, position, Quaternion.Euler(eulerAngles)) as GameObject;
// apply the look of the card based on the info from CardAsset
OneCardManager manager = card.GetComponent <OneCardManager>();
manager.CartaAsset = c.AssetCarta;
manager.LeerDatos();
return(card);
}
public void EliminarCartaMano(CartaPartida carta)
{
mano.CartasEnMano.Remove(carta);
}
public void AñadirCartaMano(int posicionMano, CartaPartida carta)
{
mano.CartasEnMano.Insert(posicionMano, carta);
}
/// <summary>
/// Resta mana al jugador según la carta lanzada al tablero
/// </summary>
/// <param name="jugador"></param>
/// <param name="carta"></param>
public void RestarManaCarta(JugadorPartida jugador, CartaPartida carta)
{
jugador.ManaRestante -= carta.CosteManaActual;
}
/// <summary>
/// Instancia la carta visual del jugador y la reparte.
/// </summary>
/// <param name="c">C.</param>
/// <param name="UniqueID">Unique I.</param>
/// <param name="fast">If set to <c>true</c> fast.</param>
/// <param name="fromDeck">If set to <c>true</c> from deck.</param>
/// <param name="rotarDeCara">If set to <c>true</c> rotar de cara.</param>
public void DarCartaJugador(CartaPartida c, int UniqueID, bool fast = false, bool fromDeck = true, bool rotarDeCara = false)
{
if (!rotarDeCara)
{
fast = true;
}
GameObject card;
if (fromDeck)
{
card = CrearCartaPorPosicion(c, DeckTransform.position, new Vector3(0f, -179f, 0f));
}
else
{
card = CrearCartaPorPosicion(c, OtherCardDrawSourceTransform.position, new Vector3(0f, -179f, 0f));
}
// save this as visual representation in CardLogic
// Player ownerPlayer = GlobalSettings.Instance.Players[owner];
//Debug.Log(ownerPlayer);
//Debug.Log(ownerPlayer.hand);
//Debug.Log("CArdsInHand.Count: "+ ownerPlayer.hand.CardsInHand.Count);
//Debug.Log("Attempted placeInHand: " +placeInHand);
// ownerPlayer.hand.CardsInHand[0].VisualRepresentation = card;
//Debug.Log(ownerPlayer.hand);
// Set a tag to reflect where this card is
foreach (Transform t in card.GetComponentsInChildren <Transform>())
{
t.tag = owner.ToString() + "Card";
}
// pass this card to HandVisual class
AñadirCarta(card);
// let the card know about its place in hand.
WhereIsTheCardOrEntity w = card.GetComponent <WhereIsTheCardOrEntity>();
w.TraerAlFrente();
w.Slot = 0;
w.EstadoVisual = VisualStates.Transicion;
// pass a unique ID to this card.
IDHolder id = card.AddComponent <IDHolder>();
id.UniqueID = UniqueID;
// save this card to change its state to "Hand" when it arrives to the hand.
LastDealtCard = card;
if (card.GetComponent <AudioSource>() != null && ConfiguracionUsuario.Instance.Musica)
{
card.GetComponent <AudioSource>().Play();
}
// move card to the hand;
Sequence s = DOTween.Sequence();
if (!fast)
{
Debug.Log("Not fast!!!");
s.Append(card.transform.DOMove(DrawPreviewSpot.position, ConfiguracionUsuario.Instance.CardTransitionTime));
s.Insert(0f, card.transform.DORotate(Vector3.zero, ConfiguracionUsuario.Instance.CardTransitionTime));
s.AppendInterval(ConfiguracionUsuario.Instance.CardPreviewTime);
// displace the card so that we can select it in the scene easier.
s.Append(card.transform.DOLocalMove(slots.Children[0].transform.localPosition, ConfiguracionUsuario.Instance.CardTransitionTime));
}
else
{
// displace the card so that we can select it in the scene easier.
if (rotarDeCara)
{
s.Insert(0f, card.transform.DORotate(Vector3.zero, ConfiguracionUsuario.Instance.CardTransitionTime));
}
s.Append(card.transform.DOLocalMove(slots.Children[0].transform.localPosition, ConfiguracionUsuario.Instance.CardTransitionTime));
//if (TakeCardsOpenly)
//s.Insert(0f, card.transform.DORotate(Vector3.zero, DatosGenerales.Instance.CardTransitionTimeFast));
}
s.OnComplete(() => CambiarEstadoCartaAMano(card, w));
}
/***************************************** CARTA ****************************************************/
public bool CartaPuedeUsarse(JugadorPartida jugador, CartaPartida carta)
{
return(carta.CosteManaActual <= jugador.ManaRestante);
}
private void RestarManaCarta(JugadorPartida jugador, CartaPartida carta)
{
controladorJugador.RestarManaCarta(jugador, carta);
}
