/// <summary>
/// 根据状态更新排面显示效果
/// </summary>
/// <param name="value">Value.</param>
private void EffectUpdateCardsStatus(BaseCard value, bool terminate = false)
{
Color color = new Color();
color.a = color.r = color.g = color.b = 1f;
if (!terminate)
{
switch (value.Status)
{
case CardStatus.CanUse:
color.r = color.g = color.b = 1f;
break;
case CardStatus.Fixed:
color = _cardConfig.GetComboMask(4); // DataModel.Instance.ComboLevel );
break;
case CardStatus.UnUseable:
break;
case CardStatus.Used:
break;
case CardStatus.Wait:
break;
default:
break;
}
}
value.sprite.DOColor(color, _cardConfig.colorTransTime);
}
/// <summary>
/// Used for adding a given card to a given hand
/// </summary>
/// <param name="Card">
/// The card we want to add to a hand
/// </param>
/// <param name="Hand">
/// The hand we want to add the card to
/// </param>
public void addCardToHand(Dictionary <string, object> prms, int ID, object caller)
{
object obj;
if (!prms.TryGetValue("Card", out obj))
{
throw new ApplicationException("Raised 'add card to hand' without a card field");
}
if (!(obj is BaseCard))
{
throw new ApplicationException("Card field in 'add card to hand' event was not a BaseCard");
}
BaseCard c = obj as BaseCard;
if (!prms.TryGetValue("Hand", out obj))
{
throw new ApplicationException("Raised 'add card to hand' without a hand field");
}
if (!(obj is Hand))
{
throw new ApplicationException("Hand field in 'add card to hand' event was not a hand");
}
Hand h = obj as Hand;
h.addCardToHand(c);
}
public void InvokeCardPlayedEvent(BaseCard card, List <BaseCard> targets = null)
{
if (this.OnCardPlayedEvent != null)
{
this.OnCardPlayedEvent(card, targets);
}
}
internal void TakeCard(BaseCard card)
{
switch (card.CardType)
{
case CardType.Mutiny:
MutinyHand.Add((MutinyCard)card);
break;
case CardType.Quorum:
QuorumHand.Add((QuorumCard)card);
break;
case CardType.Skill:
Cards.Add((SkillCard)card);
break;
case CardType.SuperCrisis:
SuperCrisisCards.Add((SuperCrisisCard)card);
break;
case CardType.Loyalty:
LoyaltyCards.Add((LoyaltyCard)card);
break;
}
}
public void TakeDamage(BaseCard sourceCard, int amount)
{
if (amount <= 0)
{
return;
}
var cards = new List <BaseCard>();
for (int i = 0; i < amount; i++)
{
if (this.TypeImmunity.Contains(sourceCard.Type))
{
continue;
}
var card = this.Deck.TakeTopCard();
if (card == null)
{
break;
}
cards.Add(card);
}
this.Discard.AddAll(cards);
if (this.OnDamageTakenEvent != null && sourceCard != null)
{
this.OnDamageTakenEvent(sourceCard, cards.Count);
}
}
/// <summary>
/// Removes a card from the baord
/// </summary>
/// <param name="card">The card to remove</param>
public void RemoveCard(BaseCard card)
{
// First figure out which play zone it's in
List<BaseCard> playZone;
if (this.PlayerPlayZone.Contains(card))
{
playZone = this.PlayerPlayZone;
}
else if (this.OpponentPlayZone.Contains(card))
{
playZone = this.OpponentPlayZone;
}
else
{
Logger.Instance.DebugFormat("{0} was not found on the board. Perhaps it was removed already?", card);
return;
}
// Next, remove the card and shift any cards necessary
var index = playZone.IndexOf(card);
playZone[index] = null;
for (int i = index; i < Constants.MAX_CARDS_ON_BOARD - 1; i++)
{
playZone[i] = playZone[i + 1];
}
playZone[Constants.MAX_CARDS_ON_BOARD - 1] = null;
}
private void UpdateCardSelection(BaseCard baseCard)
{
labelCost.Text = baseCard.Cost.ToString();
groupBoxCardDetail.Text = baseCard.Name.ToString();
labelDescription.Text = baseCard.Description.ToString();
labelExhaust.Text = (baseCard.CardUseType == CardUseType.Exhaust ? "Exhaust" : "");
}
public bool Use(List <IEnemyInstance> targets, List <ICardInstance> cardTargets, bool?skipLog = false)
{
if (skipLog.HasValue && !skipLog.Value)
{
Logger.Log($"! Card activation: {this.Name} ({this.UniqueId})");
}
if (GameWorldManager.HeroManager.CurrentEnergyCount >= ActualCost)
{
if (BaseCard.Use(GameWorldManager, targets, cardTargets))
{
GameWorldManager.HeroManager.SpendEnergy(ActualCost);
GameWorldManager.CardManager.MoveCardBetweenPiles(this, CardMovePoint.Hand, DetermineCardMovePoint());
if (this.CardUseType == CardUseType.Exhaust)
{
GameWorldManager.CardManager.LastCardExhausted = this;
}
else if (this.CardUseType == CardUseType.Default)
{
GameWorldManager.CardManager.LastCardExhausted = this;
}
GameWorldManager.EventManager.CardUsed(this);
return(true);
}
}
return(false);
}
public bool Update(BaseCard model, DbOperator dbOperator)
{
model.LastUpdateTime = DateTime.Now;
model.HaveUpdate = SystemDefaultConfig.DataUpdateFlag;
StringBuilder strSql = new StringBuilder();
strSql.Append(@"update BaseCard set Balance=@Balance,CardNo=@CardNo,
CardNumb=@CardNumb,CardSystem=@CardSystem,CardType=@CardType,
Deposit=@Deposit,EmployeeID=@EmployeeID,HaveUpdate=@HaveUpdate,LastUpdateTime=@LastUpdateTime,
OperatorID=@OperatorID,RegisterTime=@RegisterTime,State=@State,VID=@VID");
strSql.Append(" where CardID=@CardID");
dbOperator.ClearParameters();
dbOperator.AddParameter("CardID", model.CardID);
dbOperator.AddParameter("Balance", model.Balance);
dbOperator.AddParameter("CardNo", model.CardNo);
dbOperator.AddParameter("CardNumb", model.CardNumb);
dbOperator.AddParameter("CardSystem", (int)model.CardSystem);
dbOperator.AddParameter("CardType", (int)model.CardType);
dbOperator.AddParameter("Deposit", model.Deposit);
dbOperator.AddParameter("EmployeeID", model.EmployeeID);
dbOperator.AddParameter("HaveUpdate", model.HaveUpdate);
dbOperator.AddParameter("LastUpdateTime", model.LastUpdateTime);
dbOperator.AddParameter("OperatorID", model.OperatorID);
dbOperator.AddParameter("RegisterTime", model.RegisterTime);
dbOperator.AddParameter("State", (int)model.State);
dbOperator.AddParameter("VID", model.VID);
return(dbOperator.ExecuteNonQuery(strSql.ToString()) > 0);
}
public void Mulligan()
{
GameEngine.DealPreMulligan();
// Mulligan the player's hand completely
var handCount = player.Hand.Count;
BaseCard[] originalHand = new BaseCard[handCount];
player.Hand.CopyTo(originalHand, 0);
GameEngine.Mulligan(player, originalHand);
// Verify that the player's hand don't contain the same cards
Assert.IsFalse(player.Hand.SequenceEqual(originalHand.ToList()), "Verify the hand is new.");
Assert.AreEqual(Constants.MAX_CARDS_IN_DECK - handCount, player.Deck.Cards.Count, "Verify deck size after mulligan");
Assert.IsFalse(originalHand.Except(player.Deck.Cards).Any(), "Verify the original cards are back in the deck");
Assert.IsTrue(GameEngine.PlayerMulliganed, "Verify that the player mulliganed flag is set");
// For the opponent, choose not to mulligan any cards
var opponentHandCount = opponent.Hand.Count;
BaseCard[] opponentOriginalHand = new BaseCard[opponentHandCount];
opponent.Hand.CopyTo(opponentOriginalHand, 0);
GameEngine.Mulligan(opponent, null);
// Verify that the opponent's hand contains the same cards
Assert.IsFalse(opponentOriginalHand.Except(opponent.Hand).Any(), "Verify the hand has the same cards");
Assert.IsTrue(GameEngine.OpponentMulliganed, "Verify that the opponent mulliganed flag is set");
}
public bool Add(BaseCard model, DbOperator dbOperator)
{
model.DataStatus = DataStatus.Normal;
model.LastUpdateTime = DateTime.Now;
model.HaveUpdate = SystemDefaultConfig.DataUpdateFlag;
StringBuilder strSql = new StringBuilder();
strSql.Append("insert into BaseCard(CardID,EmployeeID,CardNo,CardNumb,CardType,Balance,State,Deposit,RegisterTime ,OperatorID,CardSystem,VID,LastUpdateTime,HaveUpdate,DataStatus)");
strSql.Append(" values(@CardID,@EmployeeID,@CardNo,@CardNumb,@CardType,@Balance,@State,@Deposit,@RegisterTime ,@OperatorID,@CardSystem,@VID,@LastUpdateTime,@HaveUpdate,@DataStatus)");
dbOperator.ClearParameters();
dbOperator.AddParameter("CardID", model.CardID);
dbOperator.AddParameter("EmployeeID", model.EmployeeID);
dbOperator.AddParameter("CardNo", model.CardNo);
dbOperator.AddParameter("CardNumb", model.CardNumb);
dbOperator.AddParameter("CardType", (int)model.CardType);
dbOperator.AddParameter("Balance", model.Balance);
dbOperator.AddParameter("State", (int)model.State);
dbOperator.AddParameter("Deposit", model.Deposit);
dbOperator.AddParameter("RegisterTime", model.RegisterTime);
dbOperator.AddParameter("OperatorID", model.OperatorID);
dbOperator.AddParameter("CardSystem", (int)model.CardSystem);
dbOperator.AddParameter("VID", model.VID);
dbOperator.AddParameter("LastUpdateTime", model.LastUpdateTime);
dbOperator.AddParameter("HaveUpdate", model.HaveUpdate);
dbOperator.AddParameter("DataStatus", (int)model.DataStatus);
return(dbOperator.ExecuteNonQuery(strSql.ToString()) > 0);
}
public bool Add(BaseCard model)
{
using (DbOperator dbOperator = ConnectionManager.CreateConnection())
{
return(Add(model, dbOperator));
}
}
private BaseCard UpgradeCard(BaseCard baseCard, Type targetType)
{
var newCard = (Activator.CreateInstance(targetType) as BaseCard);
Logger.Log($"Upgrading card {baseCard.Name} into {newCard.Name}");
return(newCard);
}
private void CountCreatureDamage(BaseCard source, int amount)
{
if (source.Type == Type.Creature)
{
_enemyCreatures.Add(source);
}
}
public override void OnPointerDownUnitCard(BaseCard unitCard, PointerEventData eventData)
{
base.OnPointerDownUnitCard(unitCard, eventData);
//进入召唤状态
FSM.PushState(new InputFSMSummonState(FSM));
}
// todo may want to add logging to these
/// <summary>
/// Inserts the card into the player's appropriate hand
/// </summary>
/// <param name="toPlayer">The player to give the cards to.</param>
/// <param name="card">The card to give them.</param>
/// <param name="fromPlayer">The player who is giving the card (if applicable)</param>
public void GiveCardToPlayer(Player toPlayer, BaseCard card, Player fromPlayer = null)
{
switch (card.CardType)
{
case CardType.Skill:
toPlayer.Cards.Add((SkillCard)card);
break;
case CardType.Quorum:
toPlayer.QuorumHand.Add((QuorumCard)card);
break;
case CardType.Loyalty:
toPlayer.LoyaltyCards.Add((LoyaltyCard)card);
break;
case CardType.SuperCrisis:
toPlayer.SuperCrisisCards.Add((SuperCrisisCard)card);
break;
case CardType.Mutiny:
toPlayer.MutinyHand.Add((MutinyCard)card);
break;
}
if (fromPlayer != null)
{
fromPlayer.Discard(card);
}
}
public void TakeDamage(BaseCard sourceCard, int amount)
{
if (amount <= 0)
{
return;
}
var cards = new List <BaseCard>();
for (int i = 0; i < amount; i++)
{
if (TypeImmunity.Contains(sourceCard.Type))
{
continue;
}
var card = Deck.TakeTopCard();
if (card == null)
{
Log.Write("Game Over");
break;
}
cards.Add(card);
}
Discard.AddAll(cards);
if (OnDamageTaken != null && sourceCard != null)
{
OnDamageTaken(sourceCard, cards.Count);
}
}
public static bool Add(BaseCard model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
using (DbOperator dbOperator = ConnectionManager.CreateConnection())
{
try
{
dbOperator.BeginTransaction();
IBaseCard factory = BaseCardFactory.GetFactory();
model.CardID = GuidGenerator.GetGuidString();
bool result = factory.Add(model, dbOperator);
if (!result)
{
throw new MyException("添加卡信息失败");
}
dbOperator.CommitTransaction();
return(result);
}
catch {
dbOperator.RollbackTransaction();
throw;
}
}
}
public void InvokeCardPlayedEvent(BaseCard card, List <BaseCard> targets = null)
{
if (OnCardPlayed != null)
{
OnCardPlayed(card, targets);
}
}
/// <summary>
/// 生存返还卡片押金订单
/// </summary>
/// <param name="card"></param>
/// <param name="operatorId"></param>
/// <returns></returns>
public static ParkOrder MarkUserCardDepositRefundOrder(BaseCard card, string operatorId, DbOperator dbOperator)
{
ParkOrder order = GetUserCardDepositRefundOrder(card, operatorId);
IParkOrder factory = ParkOrderFactory.GetFactory();
return(factory.Add(order, dbOperator));
}
public override DataTemplate SelectTemplate(object item, DependencyObject container)
{
BaseCard card = item as BaseCard;
if (card is Banner)
{
return(BannerDataTemplate);
}
else if (card is CaptionedImage)
{
return(CaptionedImageDataTemplate);
}
else if (card is CrossPromotionSmall)
{
return(CrossPromotionSmallDataTemplate);
}
else if (card is ShortNews)
{
return(ShortNewsDataTemplate);
}
else if (card is TextAnnouncement)
{
return(TextAnnouncementDataTemplate);
}
else
{
Debug.WriteLine("Could not find the appropriate template for card {0}.", card);
}
return(base.SelectTemplate(item, container));
}
public bool DamageAsBlockTarget(BaseCard card, List <IEnemyInstance> targets)
{
return(DamageTarget(card, new DamageMultipleTimesEffect()
{
DamageAmount = _gameWorldManager.HeroManager.StatusValues[StatusEffect.Block], HitTimes = 1
}, targets));
}
public void Initialize(IEnumerable <BaseCard> cardList, BaseCard startingCharacter)
{
Cards = new List <BaseCard>(cardList);
StartingCharacter = startingCharacter;
var cardPos = new Vector3(_deckPositionOffset.x, _deckPositionOffset.y);
for (int i = 0; i < Cards.Count; i++)
{
Cards[i] = Instantiate(Cards[i]);
Cards[i].transform.parent = transform;
Cards[i].transform.localPosition = cardPos + Vector3.back * -16f;
Cards[i].transform.rotation = Quaternion.Euler(new Vector3(0f, 180f, _player.transform.rotation.eulerAngles.z));
Cards[i].transform.position += i * Vector3.back * 0.2f;
Cards[i].Player = _player;
Cards[i].NetworkId = GameManager.NetworkIdCounter++;
GameManager.AllCards.Add(Cards[i]);
Cards[i].CurrentCollection = this;
}
}
public static bool Update(BaseCard model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
IBaseCard factory = BaseCardFactory.GetFactory();
using (DbOperator dbOperator = ConnectionManager.CreateConnection())
{
try
{
dbOperator.BeginTransaction();
bool result = factory.Update(model, dbOperator);
if (!result)
{
throw new MyException("修改卡信息失败");
}
dbOperator.CommitTransaction();
return(result);
}
catch
{
dbOperator.RollbackTransaction();
throw;
}
}
}
public BaseCard Draw()
{
if (Deck.Count > 0)
{
if (Hand.Count < MaxCardsInHand)
{
// Drawing the first card in the deck
BaseCard drawnBaseCard = DrawFromDeck(Deck[0]);
return(drawnBaseCard);
}
else
{
// TODO : Discard the card
// Updating the Player glows
UpdateSprites();
}
}
else
{
// Suming 1 to the player fatigue
Fatigue++;
// Dealing fatigue damage to the Hero
Hero.Damage(null, Fatigue);
// Updating the Player glows
UpdateSprites();
}
return(null);
}
/// <summary>
/// Removes the card from the players hand. This can be used to move cards between players.
/// </summary>
/// <param name="player"></param>
/// <param name="card"></param>
public void PlayerRemoveCard(Player player, BaseCard card)
{
switch (card.CardType)
{
case CardType.Skill:
player.Cards.Remove((SkillCard)card);
break;
case CardType.Quorum:
player.QuorumHand.Remove((QuorumCard)card);
break;
case CardType.Loyalty:
player.LoyaltyCards.Remove((LoyaltyCard)card);
break;
case CardType.SuperCrisis:
player.SuperCrisisCards.Remove((SuperCrisisCard)card);
break;
case CardType.Mutiny:
player.MutinyHand.Remove((MutinyCard)card);
break;
}
}
void OnPlacementDone(BaseCard obj)
{
DragManager.OnPlacementDone -= OnPlacementDone;
player.RemoveFromHand(obj);
selectedUnit = null;
UpdateView();
}
/// <summary>
/// 移动牌到指定索引及层
/// </summary>
private void EffectMoveTo(BaseCard baseCards, bool showEffect = true)
{
//计算将要前往的目标位置
Vector3 pos = new Vector3(
CARDS_HALFWIDTH * baseCards.ColIndex - baseCards.Layer * CARDS_XOFFSET,
CARDS_HALFHEIGHT * baseCards.RowIndex * -1f + baseCards.Layer * CARDS_YOFFSET,
-0.05f * baseCards.Index - 1 * baseCards.Layer);
baseCards.sprite.material.DOFade(1, 0.1f);
if (showEffect)
{
var cardMiddleSequence = DOTween.Sequence();
cardMiddleSequence.PrependCallback(() => { baseCards.sprite.sortingOrder = 10000; });
cardMiddleSequence.Append(baseCards.cardObj.transform.DOLocalMove(pos, _cardConfig.CardMoveNormalTime));
cardMiddleSequence.Join(baseCards.cardObj.transform.DOScale(Vector3.one, _cardConfig.CardMoveNormalTime));
cardMiddleSequence.AppendCallback(() => { baseCards.sprite.sortingOrder = AssignSortingOrder(baseCards); });
cardMiddleSequence.OnComplete(() => { CheckCameraPos(); cardMiddleSequence.Kill(); });
}
else
{
baseCards.cardObj.transform.localPosition = pos;
baseCards.cardObj.transform.localScale = Vector3.one;
baseCards.sprite.sortingOrder = AssignSortingOrder(baseCards);
}
}
public ConcreteCard(BaseCard baseCard, int level, List <Ability> abilities, Texture cardSprite)
{
if (baseCard == null)
{
throw new System.ArgumentNullException("baseCard");
}
_baseCard = baseCard;
_maxLevel = BaseCard._maxLevelTable [(int)rarity];
if (level > _maxLevel || level < 1)
{
Debug.Log("The level of card should not be less than 1 nor be larger than card's max level.");
throw new System.ArgumentException("level");
}
this.level = level;
if (abilities == null)
{
throw new System.ArgumentNullException("abilities");
}
_abilities = abilities;
_price = baseCard.price;
_cardSprite = cardSprite;
}
private static bool MeetsRarityRequirements(this BaseCard card)
{
float chanceToAdd;
float rng = Random.Range(0f, 1f);
switch (card.Rarity)
{
case Rarity.Common:
chanceToAdd = 1f;
break;
case Rarity.Uncommon:
chanceToAdd = 0.7f;
break;
case Rarity.Rare:
chanceToAdd = 0.5f;
break;
case Rarity.UltraRare:
chanceToAdd = 0.3f;
break;
default:
chanceToAdd = 1f;
break;
}
return(rng <= chanceToAdd);
}
private void AnimateCardToHand(BaseCard card, FlipState flipState, bool preview = true)
{
var cardPosition = GetTargetPositionForCard(card);
if (preview)
{
var previewTween = new MoveTween
{
Target = card.gameObject,
Position = _handPreviewPosition,
Time = 0.5f,
Flip = flipState,
Rotate = TweenRotationType.NoRotate,
OnCompleteCallback = () => card.State = State.InHand
};
GameManager.TweenQueue.AddTweenToQueue(previewTween);
}
var finalTween = new MoveTween
{
Target = card.gameObject,
Position = cardPosition,
Time = 0.3f,
Delay = 0.1f,
Flip = flipState,
Rotate = TweenRotationType.NoRotate,
OnCompleteCallback = () => card.State = State.InHand
};
GameManager.TweenQueue.AddTweenToQueue(finalTween);
}
/// <summary>
/// Constructs an instance of DeathrattleHealTarget
/// </summary>
/// <param name="owner">The owner of the deathrattle</param>
/// <param name="healTarget">The target to heal</param>
/// <param name="healAmount">The amount to heal</param>
public DeathrattleHealTarget(BaseCard owner, IDamageableEntity healTarget, int healAmount)
{
if (owner == null) throw new ArgumentNullException("owner");
if (healTarget == null) throw new ArgumentNullException("healTarget");
this.owner = owner;
this.healTarget = healTarget;
this.healAmount = healAmount;
}
/// <summary>
/// Tries to add an equipment card.
/// Returns true if it is successful. Otherwise, it returns false.
/// </summary>
public bool AddEquipmentCard(BaseCard equipmentCard)
{
if (m_EquipmentCards.Count < GameConstants.MAXIMUM_NUMBER_OF_CARDS && m_EnergyCount >= equipmentCard.EnergyCost)
{
m_EnergyCount -= equipmentCard.EnergyCost;
m_EquipmentCards.Add(equipmentCard);
equipmentCard.AddCard();
return true;
}
else
{
return false;
}
}
/// <summary>
/// Removes the card from the players hand. This can be used to move cards between players.
/// </summary>
/// <param name="player"></param>
/// <param name="card"></param>
public void PlayerRemoveCard(Player player, BaseCard card)
{
switch (card.CardType)
{
case CardType.Skill:
player.Cards.Remove((SkillCard)card);
break;
case CardType.Quorum:
player.QuorumHand.Remove((QuorumCard)card);
break;
case CardType.Loyalty:
player.LoyaltyCards.Remove((LoyaltyCard)card);
break;
case CardType.SuperCrisis:
player.SuperCrisisCards.Remove((SuperCrisisCard)card);
break;
case CardType.Mutiny:
player.MutinyHand.Remove((MutinyCard)card);
break;
}
}
// todo may want to add logging to these
/// <summary>
/// Inserts the card into the player's appropriate hand
/// </summary>
/// <param name="toPlayer">The player to give the cards to.</param>
/// <param name="card">The card to give them.</param>
/// <param name="fromPlayer">The player who is giving the card (if applicable)</param>
public void GiveCardToPlayer(Player toPlayer, BaseCard card, Player fromPlayer = null)
{
switch (card.CardType)
{
case CardType.Skill:
toPlayer.Cards.Add((SkillCard)card);
break;
case CardType.Quorum:
toPlayer.QuorumHand.Add((QuorumCard)card);
break;
case CardType.Loyalty:
toPlayer.LoyaltyCards.Add((LoyaltyCard)card);
break;
case CardType.SuperCrisis:
toPlayer.SuperCrisisCards.Add((SuperCrisisCard)card);
break;
case CardType.Mutiny:
toPlayer.MutinyHand.Add((MutinyCard)card);
break;
}
if (fromPlayer != null)
fromPlayer.Discard(card);
}
internal bool Discard(BaseCard card)
{
switch (card.CardType)
{
case CardType.Mutiny:
return MutinyHand.Remove((MutinyCard)card);
case CardType.Quorum:
return QuorumHand.Remove((QuorumCard)card);
case CardType.Skill:
return Cards.Remove((SkillCard)card);
case CardType.SuperCrisis:
return SuperCrisisCards.Remove((SuperCrisisCard) card);
case CardType.Loyalty:
LoyaltyCards.Remove((LoyaltyCard)card);
break;
}
return false;
}
/// <summary>
/// Unregister from all events
/// </summary>
/// <param name="self">The instance to be unregistered</param>
public static void UnregisterForEvents(BaseCard self)
{
_minionAttackingListeners.RemoveAll(kvp => kvp.Item1.Id == self.Id);
_damageDealtListeners.RemoveAll(kvp => kvp.Item1.Id == self.Id);
_healingListeners.RemoveAll(kvp => kvp.Item1.Id == self.Id);
_healingDealtListeners.RemoveAll(kvp => kvp.Item1.Id == self.Id);
_minionPlacedListeners.RemoveAll(kvp => kvp.Item1.Id == self.Id);
_minionPlayedListeners.RemoveAll(kvp => kvp.Item1.Id == self.Id);
_spellCastingListeners.RemoveAll(kvp => kvp.Item1.Id == self.Id);
_turnEndListeners.RemoveAll(kvp => kvp.Item1.Id == self.Id);
_turnStartListeners.RemoveAll(kvp => kvp.Item1.Id == self.Id);
}
public static void RegisterForEvent(BaseCard self, TurnStartEventHandler callback)
{
_turnStartListeners.Add(new Tuple<BaseCard, TurnStartEventHandler>(self, callback));
}
public static void RegisterForEvent(BaseCard self, SpellCastingEventHandler callback)
{
_spellCastingListeners.Add(new Tuple<BaseCard, SpellCastingEventHandler>(self, callback));
}
public static void RegisterForEvent(BaseCard self, MinionPlayedEventHandler callback)
{
_minionPlayedListeners.Add(new Tuple<BaseCard, MinionPlayedEventHandler>(self, callback));
}
public static void RegisterForEvent(BaseCard self, HealingDealtEventHandler callback)
{
_healingDealtListeners.Add(new Tuple<BaseCard, HealingDealtEventHandler>(self, callback));
}
public BaseCard DrawCard(BaseCard card, Player player = null)
{
// todo each discard creates new gamestate? that would let us implement undos
// discards the passed card into its appropriate deck
BaseCard ret = new SkillCard();
switch (card.CardType)
{
case CardType.Crisis:
ret = CurrentGameState.CrisisDeck.Draw();
break;
case CardType.Quorum:
ret = CurrentGameState.QuorumDeck.Draw();
break;
case CardType.Skill:
var skillCard = (SkillCard)card;
switch (skillCard.CardColor)
{
case SkillCardColor.Politics:
ret = CurrentGameState.PoliticsDeck.Draw();
break;
case SkillCardColor.Leadership:
ret = CurrentGameState.LeadershipDeck.Draw();
break;
case SkillCardColor.Tactics:
ret = CurrentGameState.TacticsDeck.Draw();
break;
case SkillCardColor.Engineering:
ret = CurrentGameState.EngineeringDeck.Draw();
break;
case SkillCardColor.Piloting:
ret = CurrentGameState.PilotingDeck.Draw();
break;
case SkillCardColor.Treachery:
ret = CurrentGameState.TreacheryDeck.Draw();
break;
}
break;
case CardType.SuperCrisis:
ret = CurrentGameState.SuperCrisisDeck.Draw();
break;
case CardType.Loyalty:
ret = CurrentGameState.LoyaltyDeck.Draw();
break;
}
if (player != null)
player.TakeCard(ret);
return ret;
}
/// <summary>
/// Register with GameEventManager to get called when an attack happens
/// </summary>
/// <param name="self">The instance requesting to be called</param>
/// <param name="callback">The callback to call</param>
public static void RegisterForEvent(BaseCard self, AttackingEventHandler callback)
{
_minionAttackingListeners.Add(new Tuple<BaseCard, AttackingEventHandler>(self, callback));
}
public void DiscardCard(BaseCard card, Player player = null)
{
// discards the passed card into its appropriate deck
switch (card.CardType)
{
case CardType.Quorum:
CurrentGameState.QuorumDeck.Discard((QuorumCard)card);
break;
case CardType.Skill:
var skillCard = (SkillCard) card;
switch (skillCard.CardColor)
{
case SkillCardColor.Politics:
CurrentGameState.PoliticsDeck.Discard(skillCard);
break;
case SkillCardColor.Leadership:
CurrentGameState.LeadershipDeck.Discard(skillCard);
break;
case SkillCardColor.Tactics:
CurrentGameState.TacticsDeck.Discard(skillCard);
break;
case SkillCardColor.Engineering:
CurrentGameState.EngineeringDeck.Discard(skillCard);
break;
case SkillCardColor.Piloting:
CurrentGameState.PilotingDeck.Discard(skillCard);
break;
case SkillCardColor.Treachery:
CurrentGameState.TreacheryDeck.Discard(skillCard);
break;
}
break;
case CardType.SuperCrisis:
CurrentGameState.SuperCrisisDeck.Discard((SuperCrisisCard) card);
break;
case CardType.Loyalty:
CurrentGameState.LoyaltyDeck.Discard((LoyaltyCard) card);
break;
}
if (player != null)
player.Discard(card);
}
/// <summary>
/// Place the card on the bottom of its Deck
/// </summary>
/// <param name="card"></param>
public void BuryCard(BaseCard card)
{
switch (card.CardType)
{
case CardType.Crisis:
CurrentGameState.CrisisDeck.Bury((CrisisCard)card);
break;
case CardType.Destination:
CurrentGameState.DestinationDeck.Bury((DestinationCard)card);
break;
case CardType.Loyalty:
CurrentGameState.LoyaltyDeck.Bury((LoyaltyCard)card);
break;
case CardType.Quorum:
CurrentGameState.QuorumDeck.Bury((QuorumCard)card);
break;
case CardType.Skill:
var skill = (SkillCard)card;
switch (skill.CardColor)
{
case SkillCardColor.Politics:
CurrentGameState.PoliticsDeck.Bury(skill);
break;
case SkillCardColor.Leadership:
CurrentGameState.LeadershipDeck.Bury(skill);
break;
case SkillCardColor.Tactics:
CurrentGameState.TacticsDeck.Bury(skill);
break;
case SkillCardColor.Engineering:
CurrentGameState.EngineeringDeck.Bury(skill);
break;
case SkillCardColor.Piloting:
CurrentGameState.PilotingDeck.Bury(skill);
break;
case SkillCardColor.Treachery:
CurrentGameState.TreacheryDeck.Bury(skill);
break;
}
break;
case CardType.SuperCrisis:
CurrentGameState.SuperCrisisDeck.Bury((SuperCrisisCard)card);
break;
}
}
/// <summary>
/// Register a baseDeathrattle with the game engine. If the source card dies, it will trigger.
/// </summary>
/// <param name="source">The triggering card</param>
/// <param name="baseDeathrattle">The baseDeathrattle to perform</param>
public static void RegisterDeathrattle(BaseCard source, BaseDeathrattle baseDeathrattle)
{
if (!GameEngine.Deathrattles.ContainsKey(source))
{
GameEngine.Deathrattles[source] = new List<BaseDeathrattle>(){baseDeathrattle};
}
else
{
GameEngine.Deathrattles[source].Add(baseDeathrattle);
}
}
internal void TakeCard(BaseCard card)
{
switch (card.CardType)
{
case CardType.Mutiny:
MutinyHand.Add((MutinyCard)card);
break;
case CardType.Quorum:
QuorumHand.Add((QuorumCard)card);
break;
case CardType.Skill:
Cards.Add((SkillCard)card);
break;
case CardType.SuperCrisis:
SuperCrisisCards.Add((SuperCrisisCard)card);
break;
case CardType.Loyalty:
LoyaltyCards.Add((LoyaltyCard) card);
break;
}
}
public void Mulligan()
{
GameEngine.DealPreMulligan();
// Mulligan the player's hand completely
var handCount = player.Hand.Count;
BaseCard[] originalHand = new BaseCard[handCount];
player.Hand.CopyTo(originalHand, 0);
GameEngine.Mulligan(player, originalHand);
// Verify that the player's hand don't contain the same cards
Assert.IsFalse(player.Hand.SequenceEqual(originalHand.ToList()), "Verify the hand is new.");
Assert.AreEqual(Constants.MAX_CARDS_IN_DECK - handCount, player.Deck.Cards.Count, "Verify deck size after mulligan");
Assert.IsFalse(originalHand.Except(player.Deck.Cards).Any(), "Verify the original cards are back in the deck");
Assert.IsTrue(GameEngine.PlayerMulliganed, "Verify that the player mulliganed flag is set");
// For the opponent, choose not to mulligan any cards
var opponentHandCount = opponent.Hand.Count;
BaseCard[] opponentOriginalHand = new BaseCard[opponentHandCount];
opponent.Hand.CopyTo(opponentOriginalHand, 0);
GameEngine.Mulligan(opponent, null);
// Verify that the opponent's hand contains the same cards
Assert.IsFalse(opponentOriginalHand.Except(opponent.Hand).Any(), "Verify the hand has the same cards");
Assert.IsTrue(GameEngine.OpponentMulliganed, "Verify that the opponent mulliganed flag is set");
}
public void Shuffle()
{
for (int i = 0; i < 30; i++)
{
player.Deck.AddCard(new ChillwindYeti(i));
}
var originalDeck = new BaseCard[30];
player.Deck.Cards.CopyTo(originalDeck);
player.Deck.Shuffle();
var shuffledDeck = new BaseCard[30];
player.Deck.Cards.CopyTo(shuffledDeck);
Assert.IsFalse(originalDeck.SequenceEqual(shuffledDeck));
}
/// <summary>
/// Adds a card to the current deck
/// </summary>
/// <param name="card">The card to add</param>
/// <remarks>Adds to the end of the deck by default</remarks>
public void AddCard(BaseCard card)
{
this.Cards.Add(card);
}
private void GiveCardToCurrentCharacterButtonClick(object sender, EventArgs e)
{
// if no cards selected, give all
object[] cards = new BaseCard[drawnCardListBox.Items.Count];
if (drawnCardListBox.SelectedIndex == -1)
drawnCardListBox.Items.CopyTo(cards, 0);
else
drawnCardListBox.SelectedItems.CopyTo(cards, 0);
drawnCardListBox.BeginUpdate();
foreach (BaseCard c in cards)
drawnCardListBox.Items.Remove(c);
drawnCardListBox.EndUpdate();
Program.GManager.GiveCardToPlayer(_currentPlayer, (IEnumerable<BaseCard>)cards);
UpdatePlayerHandControls();
}
