private void ApplyEffects(GameObject room, GameObject slot, CardDesc cardDesc)
{
var effects = new List <EffectData>();
roomEffects[room] = effects;
foreach (var effectResource in cardDesc.Effects)
{
var ts = effectResource.TargetSelector;
if (ts == null)
{
continue;
}
var targets = ts.GetTargets(slot);
foreach (var targetSlot in targets)
{
var instance = effectResource.CreateInstance();
instance.Attach(targetSlot);
effects.Add(new EffectData {
EffectInstance = instance, Slot = targetSlot
});
RecalculateSlot(targetSlot);
}
}
}
private bool CanCast(CardDesc cardDesc)
{
if (Helpers.LocalPlayer == GameState.Instance.PlayerOverlord)
{
if (!Helpers.IsOverlordTurn())
{
return(false);
}
if (GameState.Instance.ManaOverlord < cardDesc.GetManaToCast())
{
return(false);
}
}
if (Helpers.LocalPlayer == GameState.Instance.PlayerRunner)
{
if (!Helpers.IsRunnerTurn())
{
return(false);
}
if (GameState.Instance.ManaRunner < cardDesc.GetManaToCast())
{
return(false);
}
}
return(true);
}
// -----
// TODO: Crap
public void OnTargetSelected(GameObject target)
{
if (Helpers.IsLocalPlayerRunner() &&
Helpers.IsRunnerTurn() &&
GameState.Instance.RunState != null &&
GameState.Instance.RunState.GetComponent <RunState>().Stage == RunStage.Combat)
{
PlayerCommands.Instance.CmdAttackWithHero(target);
return;
}
if (!IsActive)
{
return;
}
if (card != null)
{
PlayerCommands.Instance.CmdPlayCard(card.Id, target);
}
if (isRunStarting)
{
PlayerCommands.Instance.CmdStartRun(target);
}
card = null;
isRunStarting = false;
UnhighlightAll();
}
public static Color GetCardColor(CardDesc cardDesc)
{
if (cardDesc.Type == CardType.Hero)
{
return(ColorHero);
}
if (cardDesc.Type == CardType.Room)
{
return(ColorRoomRevealed);
}
if (cardDesc.Type == CardType.Heart)
{
return(ColorHeart);
}
if (cardDesc.Type == CardType.Enchantment)
{
return(ColorEnchantmentRevealed);
}
if (cardDesc.Type == CardType.Spell)
{
return(ColorSpell);
}
return(Color.gray);
}
public Card(CardDesc desc)
{
this.setName(desc.name);
this.setID(desc.id);
this.setDescription(desc.description);
this.type = desc.type;
this.rarity = desc.rarity;
this.collectible = desc.collectible;
this.cardSet = desc.set;
}
public void Add(CardDesc cardToAdd)
{
if (cards == null)
{
cards = new List <CardDesc>();
}
cards.Add(cardToAdd);
UpdateCount();
}
static public Card CreateCard(CardDesc card)
{
Card cardObject = Instantiate(instance.emptyCardPrefab);
cardObject.hidden = false;
cardObject.name = "Card[" + card.name + "]";
cardObject.Set(card);
return(cardObject);
}
// -----
private void Update()
{
if (Input.GetKey(KeyCode.Escape))
{
UnhighlightAll();
card = null;
isRunStarting = false;
}
}
public CardDB()
{
CardDesc c = new CardDesc()
{
Effects = { new EffectBonusStats()
{
TargetSelector = new TargetSelectorSelf(), Damage = 1
} }
};
XmlSerializeHelper.SaveToXml(c, "card.xml");
}
public bool TryCastEnchantmentInSlot(CardDesc cardDesc, GameObject targetSlot)
{
var ri = targetSlot.GetComponent <RoomSlotInfo>();
if (!ri.IsEnchantment)
{
return(false);
}
InstantiateRoomOrEnchantment(cardDesc, targetSlot);
return(true);
}
private void PlayRunnerCardInternal(CardDesc card)
{
if (card.Type == CardType.Hero)
{
if (!heroManager.TrySummonHero(card))
{
return;
}
}
gameState.HandRunner.Remove(card.Id);
gameState.ManaRunner -= card.GetManaToCast();
}
/*
public void CreateCards(int count = 8)
{
UpdatesDisabled = true;
for (int q = 1; q <= count; q++)
{
var card = (Instantiate(Game.Instance.cardPrefab) as GameObject).GetComponent<Card>();
card.transform.localScale = Game.Instance.cardPrefab.transform.localScale;
card.desc = Game.Instance.cards[q % Game.Instance.cards.Length];
card.Deck = this;
//cards.Add(card);
}
UpdatesDisabled = false;
UpdateCards();
}
*/
public void CreateCards(CardDesc[] descs, int repeat = 1)
{
UpdatesDisabled = true;
foreach (var desc in descs)
{
for (int q = 0; q < repeat; ++q)
{
for (int w = 0; w < (int)Mathf.Max(1, 4 - desc.rarity); ++w)
{
var card = (Instantiate(Game.Instance.cardPrefab) as GameObject).GetComponent<Card>();
card.transform.localScale = Game.Instance.cardPrefab.transform.localScale;
card.desc = desc;
card.Deck = this;
}
}
}
UpdatesDisabled = false;
UpdateCards();
}
private void PlayOverlordCardInternal(CardDesc card, GameObject targetSlot)
{
if (card.Type == CardType.Room)
{
if (!roomManager.TryCastRoomInSlot(card, targetSlot))
{
return;
}
}
if (card.Type == CardType.Enchantment)
{
if (!roomManager.TryCastEnchantmentInSlot(card, targetSlot))
{
return;
}
}
gameState.HandOverlord.Remove(card.Id);
gameState.ManaOverlord -= card.GetManaToCast();
}
public bool TrySummonHero(CardDesc card)
{
if (heroes.Count >= Constants.MaxHeroCount)
{
return(false);
}
var hero = GameObject.Instantiate(GameRoot.Instance.HeroPrefab);
var heroInfo = hero.GetComponent <HeroInfo>();
heroInfo.CardId = card.Id;
heroInfo.Damage = card.Damage;
heroInfo.Health = card.Health;
heroInfo.SummoningSickness = true;
NetworkServer.Spawn(hero);
AddHero(hero);
return(true);
}
public bool TryCastRoomInSlot(CardDesc cardDesc, GameObject targetSlot)
{
var ri = targetSlot.GetComponent <RoomSlotInfo>();
if (ri.IsHeart || ri.IsEnchantment)
{
return(false);
}
// If slot before is empty - can't cast
if (ri.Order > 1)
{
var slotBeforeThis = roomSlotsByWing[ri.Wing][ri.Order];
if (!slotsToRooms.ContainsKey(slotBeforeThis))
{
return(false);
}
}
InstantiateRoomOrEnchantment(cardDesc, targetSlot);
return(true);
}
public void SelectTargetAndCastSpell(CardDesc cardDesc)
{
if (GameState.Instance.IsMulliganState)
{
PlayerCommands.Instance.CmdMulliganReplaceCard(cardDesc.Id);
return;
}
if (IsActive)
{
return;
}
if (!CanCast(cardDesc))
{
return;
}
if (cardDesc.Type == CardType.Room)
{
card = cardDesc;
var roomSlotsRenderer = GetComponent <RoomSlotsRenderer>();
roomSlotsRenderer.HighlightForNewRoom();
}
if (cardDesc.Type == CardType.Enchantment)
{
card = cardDesc;
var roomSlotsRenderer = GetComponent <RoomSlotsRenderer>();
roomSlotsRenderer.HighlightForNewEnchantment();
}
if (cardDesc.Type == CardType.Hero)
{
PlayerCommands.Instance.CmdPlayCard(cardDesc.Id, null);
}
}
// -----
private GameObject InstantiateRoomOrEnchantment(CardDesc cardDesc, GameObject targetSlot)
{
GameObject previousRoom;
if (slotsToRooms.TryGetValue(targetSlot, out previousRoom) && previousRoom != null)
{
DestroyRoom(previousRoom);
}
var newRoom = GameObject.Instantiate(GameRoot.Instance.RoomPrefab);
var ri = newRoom.GetComponent <RoomInfo>();
ri.Slot = targetSlot;
ri.CardId = cardDesc.Id;
ri.Damage = cardDesc.Damage;
ri.DamageDealt = 0;
ri.TotalHealth = cardDesc.Health;
if (cardDesc.Type == CardType.Heart)
{
ri.IsRevealed = true;
ri.IsActive = true;
}
slotsToRooms[targetSlot] = newRoom;
if (RoomCreated != null)
{
RoomCreated(newRoom);
}
NetworkServer.Spawn(newRoom);
return(newRoom);
}
public CardContext(CardDesc desc)
{
this.desc = desc;
ResetPriority();
}
public void Set(CardDesc card)
{
desc = card;
defense = desc.defensePower;
UpdateCard();
}
public void SendToGraveyard(CardDesc card)
{
graveyard.Add(card);
}
public void DrawCard(CardPile pile)
{
// Can't draw cards if we're not the active player
if (!activePlayer)
{
return;
}
// Can't draw a card if we have one floating
if (currentCard != null)
{
return;
}
// Check if pile has cards
if (pile.GetCardCount() <= 0)
{
// Check if we can dump the graveyard back in the deck
if (GameMng.GetRules().infiniteDeck)
{
var cards = graveyard.GetCards();
graveyard.Clear();
if (GameMng.GetRules().reshuffleInfinite)
{
ShuffleDeck(cards);
}
pile.Add(cards);
if (pile.GetCardCount() <= 0)
{
return;
}
}
else
{
return;
}
}
// Check if we can draw cards (cards in hand is less than maximum allowed)
if (hand.GetCardCount() >= GameMng.GetRules().maxCardsInHand)
{
return;
}
// Check if we've already drawn enough cards this turn
if (drawCount >= GameMng.GetRules().drawPerTurn)
{
return;
}
drawCount++;
// Get the first card
CardDesc card = pile.GetFirstCard();
// Create the card itself and pop it on the hand
var cardObject = GameMng.CreateCard(card);
hand.Add(cardObject);
}
