/* Is it a legal move to add the card to this row? */
protected virtual Boolean CanAddCard(InGameCard card)
{
return(card != null &&
card.combatTypes.Contains(this.combatType) &&
((!card.IsSpy() && player == Player.Us) ||
(card.IsSpy() && player == Player.Them)));
}
/* Attempt to add card to row. If the card can't be added, throws
* an exception. Use skipCheck = true to always add the card */
virtual public IPromise <IList <TurnEvent> > AddCard(InGameCard card, Boolean skipCheck = false)
{
if (skipCheck || this.CanAddCard(card))
{
TurnEvent turnEvent = card.SetCardRow(this);
this.cards.Add(card);
this.UpdateCardOrder();
this.UpdateScore();
if (card.IsMedic())
{
medicList.Add(turnEvent);
discardPile.ShowCardsForRevival().Then(teList => {
medicList.AddRange(teList);
medicPromise.Resolve(medicList);
}).Catch(e =>
Debug.LogError(e)
);
return(medicPromise);
}
else
{
return(Promise <IList <TurnEvent> > .Resolved(new List <TurnEvent> {
turnEvent
}));
}
}
throw new AddCardException(String.Format("Attempt to add card {0} to invalid row.", card.id));
}
public static InGameCard CreateCard(
CardRow cardRow,
String id,
IList <CombatType> combatTypes,
IList <CardAttribute> attributes,
int?basePower,
int?currentPower,
String faction,
CombatType?reviveRow)
{
GameObject cardObject = Instantiate((GameObject)Resources.Load("InGameCard"), cardRow.transform);
InGameCard card = cardObject.GetComponent <InGameCard>();
card.cardObject = cardObject;
card.id = id;
card.combatTypes = new List <CombatType>(combatTypes);
card.attributes = new List <CardAttribute>(attributes);
card.basePower = basePower;
card.currentPower = currentPower;
card.faction = faction;
card.reviveRow = reviveRow;
card.cardRow = cardRow;
card.image = Resources.Load <Sprite>("CardImages/" + id);
return(card);
}
virtual public void OnDrop(PointerEventData eventData)
{
InGameCard card = eventData.pointerDrag.GetComponent <InGameCard>();
try {
medicPromise = new Promise <IList <TurnEvent> >();
medicList = new List <TurnEvent>();
gwn.SendTurn(this.AddCard(card));
} catch (AddCardException) {}
}
static public InGameCard createNewInGameCard(GameObject cardObject, Card cardData)
{
var newCard = new InGameCard();
newCard.NameText.text = cardData.Name;
newCard.DescriptionText.text = cardData.Description;
newCard.EnergyLimitText.text = (string)cardData.energyLimit;
return(GameObject.Instantiate(cardObject));
}
public IPromise <IList <TurnEvent> > PlayCardFromDiscardPile(DisplayCard displayCard)
{
InGameCard card = ourDiscardPile.PopCardById(displayCard.id);
List <CombatType> eligibleCts = new List <CombatType> {
CombatType.Melee, CombatType.Ranged, CombatType.Siege
};
if (card.reviveRow == null)
{
throw new AddCardException(
String.Format("{0} card is missing a revive row.", card.id)
);
}
else if (!eligibleCts.Contains(card.reviveRow.Value))
{
throw new AddCardException(
String.Format("{0} card has an ineligble revive row.", card.id)
);
}
CombatType reviveRow = card.reviveRow.Value;
IPromise <IList <TurnEvent> > result;
if (card.IsSpy())
{
if (reviveRow == CombatType.Siege)
{
result = theirSiegeRow.AddCard(card);
}
else if (reviveRow == CombatType.Ranged)
{
result = theirRangedRow.AddCard(card);
}
else
{
result = theirMeleeRow.AddCard(card);
}
}
else
{
if (reviveRow == CombatType.Melee)
{
result = ourMeleeRow.AddCard(card);
}
else if (reviveRow == CombatType.Ranged)
{
result = ourRangedRow.AddCard(card);
}
else
{
result = ourSiegeRow.AddCard(card);
}
}
return(result);
}
//Pick a random card in deck, remove it from deck, add it to the hand + (optional : AddPower)
public void DrawCard(bool cost)
{
InGameCard _card = GetARandomCardInDeck();
RemoveCardFromDeck(_card);
AddCardToHand(_card);
if (cost)
{
AddPower(_card.cost[0], true);
}
}
public InGameCard ToInGameCard(CardRow row)
{
return(InGameCard.CreateCard(
row,
id,
ParseCombatTypes(this.combatTypes),
ParseCardAttributes(this.attributes),
basePower,
currentPower,
faction,
ParseCombatType(reviveRow)));
}
static public InGameCard createNewInGameCard(GameObject cardObject, Card cardData)
{
var newCard = new InGameCard();
newCard.NameText.text = cardData.Name;
newCard.DescriptionText.text = cardData.Description;
newCard.EnergyLimitText.text = cardData.energyLimit.ToString();
GameObject instance = Object.Instantiate(cardObject);
return(null);
}
public InGameCard PopCardById(String id)
{
InGameCard result = cards.Find(c => c.id == id);
if (result == null)
{
throw new AddCardException(
String.Format("Card {0} not found in Discard pile.")
);
}
RemoveCard(result);
return(result);
}
public InGameCard Copy()
{
return(InGameCard.CreateCard(
cardRow,
id,
new List <CombatType>(combatTypes),
new List <CardAttribute>(attributes),
basePower,
currentPower,
faction,
reviveRow
));
}
public static DisplayCard CreateCard(
InGameCard inGameCard,
CardDisplay display,
Boolean cardSelectBehaviour)
{
GameObject cardObject = Instantiate((GameObject)Resources.Load("DisplayCard"), display.transform);
DisplayCard card = cardObject.GetComponent <DisplayCard>();
card.cardObject = cardObject;
card.id = inGameCard.id;
card.combatTypes = new List <CombatType>(inGameCard.combatTypes);
card.attributes = new List <CardAttribute>(inGameCard.attributes);
card.basePower = inGameCard.basePower;
card.currentPower = inGameCard.currentPower;
card.faction = inGameCard.faction;
card.image = Resources.Load <Sprite>("CardImages/" + inGameCard.id);
card.cardDisplay = display;
card.cardSelectBehaviour = cardSelectBehaviour;
return(card);
}
public void OnDrop(PointerEventData eventData)
{
InGameCard decoy = eventData.pointerDrag.GetComponent <InGameCard>();
if (decoy && decoy.HasDecoy() && cardRow is CombatCardRow)
{
TurnEvent ev1 = new TurnEvent(decoy.id, cardRow.rowName);
TurnEvent ev2 = new TurnEvent(id, hand.rowName);
hand.RemoveCard(decoy);
cardRow.AddCard(decoy, true);
cardRow.RemoveCard(this);
hand.AddCard(this, true);
GwentNetworkManager gwn = (GwentNetworkManager)FindObjectOfType(typeof(GwentNetworkManager));
gwn.SendTurn(new List <TurnEvent> {
ev1, ev2
});
}
else
{
this.transform.parent.SendMessage("OnDrop", eventData);
}
}
//Play a full card
public void UseCard(Belligerent owner, InGameCard _cardPlayed)
{
//Read All the effect in order.
for (int i = 0; i < _cardPlayed.effects.Length; i++)
{
if (ReadEffect(_cardPlayed.effects[i], owner))
{
}
else
{
break;
}
}
//Remove Card from Hand
_cardPlayed.nbrOfUtilisation--;
if (_cardPlayed.nbrOfUtilisation <= 0)
{
_cardPlayed.nbrOfUtilisation = _cardPlayed.soToReferTo.nbrOfUtilisation;
owner.ResetCardPosition(_cardPlayed.gameObject);
owner.hand.Remove(_cardPlayed);
}
owner.UseCard();
}
override public void RemoveCard(InGameCard card)
{
base.RemoveCard(card);
UpdateImage();
}
public int Compare(InGameCard c1, InGameCard c2)
{
return(Compare((Card)c1, (Card)c2));
}
void AddCardToHand(InGameCard card)
{
hand.Add(card);
UpdateDrawStatut();
ReOrderHand();
}
public void RemoveCardFromDeck(InGameCard _card)
{
actualDeck.Remove(_card);
UpdateDrawStatut();
}
virtual public void RemoveCard(InGameCard card)
{
this.cards.Remove(card);
this.UpdateCardOrder();
this.UpdateScore();
}
public void BanishCardFromCombat(InGameCard _card)
{
}
public void Scorch(InGameCard card)
{
gwn.SendTurn(AddCard(card, true));
}
override protected Boolean CanAddCard(InGameCard card)
{
return(card != null &&
card.combatTypes.Contains(this.combatType) &&
!this.cards.Select(c => c.id).Contains(card.id));
}
override protected Boolean CanAddCard(InGameCard card)
{
return(this.cards.Count == 0 && base.CanAddCard(card));
}
