// erhaltet einen leeren manakristall.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
if (ownplay)
{
if (p.playerFirst.ownMaxMana < 10)
{
p.playerFirst.ownMaxMana++;
}
else
{
p.drawACard(CardDB.cardName.excessmana, true, true);
}
}
else
{
if (p.playerSecond.ownMaxMana < 10)
{
p.playerSecond.ownMaxMana++;
}
else
{
p.drawACard(CardDB.cardName.excessmana, false, true);
}
}
}
// Give each player a Mana Crystal.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
p.drawACard(p.getArandomCardFromDeck(true), true);
p.drawACard(p.getArandomCardFromDeck(false), false);
}
// zieht 4 karten.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
p.drawACard(p.getArandomCardFromDeck(ownplay), ownplay);
p.drawACard(p.getArandomCardFromDeck(ownplay), ownplay);
p.drawACard(p.getArandomCardFromDeck(ownplay), ownplay);
p.drawACard(p.getArandomCardFromDeck(ownplay), ownplay);
}
// Whenever your opponent casts a spell, gain a copy of it and give them a Coin.
public override void onCardIsGoingToBePlayed(Playfield p, CardDB.Card c, bool wasOwnCard, Minion triggerEffectMinion)
{
if (c.type == CardDB.cardtype.SPELL && c.name != CardDB.cardName.gallywixscoin && wasOwnCard != triggerEffectMinion.own)
{
p.drawACard(c.cardIDenum, triggerEffectMinion.own, true);
p.drawACard(CardDB.cardName.gallywixscoin, wasOwnCard, true);
}
}
// Both players draw 2 cards and gain a Mana Crystal.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
p.drawACard(p.getArandomCardFromDeck(true), true);
p.drawACard(p.getArandomCardFromDeck(false), false);
p.playerFirst.mana = Math.Min(10, p.playerFirst.mana+1);
p.playerFirst.ownMaxMana = Math.Min(10, p.playerFirst.ownMaxMana+1);
p.playerSecond.ownMaxMana = Math.Min(10, p.playerSecond.ownMaxMana+1);
}
// vernichtet zu beginn eures zuges diesen diener und zieht 3 karten.
public override void onTurnStartTrigger(Playfield p, Minion triggerEffectMinion, bool turnStartOfOwner)
{
if (turnStartOfOwner == triggerEffectMinion.own)
{
p.minionGetDestroyed(triggerEffectMinion);
p.drawACard(p.getArandomCardFromDeck(turnStartOfOwner), turnStartOfOwner);
p.drawACard(p.getArandomCardFromDeck(turnStartOfOwner), turnStartOfOwner);
p.drawACard(p.getArandomCardFromDeck(turnStartOfOwner), turnStartOfOwner);
}
}
// kampfschrei:/ gebt eurem gegner 2 bananen.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
p.drawACard(CardDB.cardName.bananas, !own.own, true);
if (own.own)
{
p.playerSecond.owncarddraw -= 1;
}
p.drawACard(CardDB.cardName.bananas, !own.own, true);
if (own.own)
{
p.playerSecond.owncarddraw -= 1;
}
}
//Zieht 2 Karten; oder stellt 5 Leben wieder her
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
if (choice == 2)
{
int heal = p.getMinionHeal(5, own.own);
p.minionGetDamageOrHeal(target, -heal);
}
else
{
p.drawACard(p.getArandomCardFromDeck(own.own), own.own);
p.drawACard(p.getArandomCardFromDeck(own.own), own.own);
}
}
//todo secret
// geheimnis:/ wenn ein befreundeter diener stirbt, erhaltet ihr 2 kopien dieses dieners auf eure hand.
public override void onSecretPlay(Playfield p, bool ownplay, int number)
{
if (ownplay)
{
p.drawACard(p.playerFirst.revivingOwnMinion, ownplay, true);
p.drawACard(p.playerFirst.revivingOwnMinion, ownplay, true);
}
else
{
p.drawACard(p.playerSecond.revivingOwnMinion, ownplay, true);
p.drawACard(p.playerSecond.revivingOwnMinion, ownplay, true);
}
}
// Choose One - Give each player a Mana Crystal; or Each player draws a card.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
if (choice == 1)
{
p.playerFirst.mana = Math.Min(10, p.playerFirst.mana+1);
p.playerFirst.ownMaxMana = Math.Min(10, p.playerFirst.ownMaxMana+1);
p.playerSecond.ownMaxMana = Math.Min(10, p.playerSecond.ownMaxMana+1);
}
if (choice == 2)//TODO: need order here?
{
p.drawACard(p.getArandomCardFromDeck(own.own), own.own);
p.drawACard(p.getArandomCardFromDeck(!own.own), !own.own);
}
}
// zieht am ende eures zuges eine traumkarte.
public override void onTurnEndsTrigger(Playfield p, Minion triggerEffectMinion, bool turnEndOfOwner)
{
if (triggerEffectMinion.own == turnEndOfOwner)
{
p.drawACard(CardDB.cardName.yseraawakens, turnEndOfOwner, true);
}
}
// tauscht zu beginn eures zuges diesen diener gegen einen zufälligen diener auf eurer hand aus.
public override void onTurnStartTrigger(Playfield p, Minion triggerEffectMinion, bool turnStartOfOwner)
{
if (turnStartOfOwner && triggerEffectMinion.own == turnStartOfOwner)
{
List<Handmanager.Handcard> temp2 = new List<Handmanager.Handcard>();
foreach (Handmanager.Handcard hc in p.playerFirst.owncards)
{
if (hc.card.type == CardDB.cardtype.MOB) temp2.Add(hc);
}
temp2.Sort((a, b) => -a.card.Attack.CompareTo(b.card.Attack));//damage the stronges
foreach (Handmanager.Handcard mins in temp2)
{
CardDB.Card c = CardDB.Instance.getCardDataFromID(mins.card.cardIDenum);
p.minionTransform(triggerEffectMinion, c);
p.removeCard(mins, true);
p.drawACard(CardDB.cardName.alarmobot, true, true);
break;
}
return;
}
if (!turnStartOfOwner && triggerEffectMinion.own == turnStartOfOwner)
{
p.minionGetBuffed(triggerEffectMinion, 4, 4);
triggerEffectMinion.Hp = triggerEffectMinion.maxHp;
}
}
// todo ask the posibility manager!
// zieht eine karte und verursacht schaden, der ihren kosten entspricht.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
p.drawACard(p.getArandomCardFromDeck(ownplay), ownplay);
int dmg = p.getSpellDamageDamage(3, ownplay);
p.minionGetDamageOrHeal(target, dmg);
}
// zieht am ende eures zuges eine karte.
public override void onTurnEndsTrigger(Playfield p, Minion triggerEffectMinion, bool turnEndOfOwner)
{
if (turnEndOfOwner == triggerEffectMinion.own)
{
p.drawACard(p.getArandomCardFromDeck(turnEndOfOwner), turnEndOfOwner);
}
}
// At the end of each player's turn, that player draws until they have 3 cards.
public override void onTurnEndsTrigger(Playfield p, Minion triggerEffectMinion, bool turnEndOfOwner)
{
if (triggerEffectMinion.own == turnEndOfOwner)
{
Player mPlayer;
if (turnEndOfOwner)
{
mPlayer = p.playerFirst;
}
else
{
mPlayer = p.playerSecond;
}
int cardstodraw = 0;
if (mPlayer.owncards.Count <= 2)
{
cardstodraw = 3 - mPlayer.owncards.Count;
}
for (int i = 0; i < cardstodraw; i++)
{
p.drawACard(p.getArandomCardFromDeck(turnEndOfOwner), turnEndOfOwner);
}
}
}
// Deal 3 damage. If your hand is empty, draw a card.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = p.getSpellDamageDamage(3, ownplay);
p.minionGetDamageOrHeal(target, dmg);
int cardsCount = (ownplay) ? p.playerFirst.owncards.Count : p.playerSecond.owncards.Count;
if (cardsCount <= 0) p.drawACard(p.getArandomCardFromDeck(ownplay), ownplay);
}
// fügt einem diener $1 schaden zu. zieht eine karte.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int damage = p.getSpellDamageDamage(1, ownplay);
//this.owncarddraw++;
p.minionGetDamageOrHeal(target, damage);
p.drawACard(p.getArandomCardFromDeck(ownplay), ownplay);
}
// zu beginn eures zuges besteht eine chance von 50%, dass ihr eine zusätzliche karte zieht.
public override void onTurnStartTrigger(Playfield p, Minion triggerEffectMinion, bool turnStartOfOwner)
{
if (triggerEffectMinion.own == turnStartOfOwner)
{
if (GameManager.getRNG().NextDouble() < 0.5)
p.drawACard(p.getArandomCardFromDeck(turnStartOfOwner), turnStartOfOwner);
}
}
// Battlecry: Add 4 random Murlocs to your hand. Overload: (3)
public override void getBattlecryEffect(Playfield p, Minion m, Minion target, int choice)
{
for (int i = 0; i < 4; i++)
{
p.drawACard(CardDB.cardName.murlocraider, m.own, true);
}
if (m.own) p.ueberladung += 3;
}
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int anz = (ownplay) ? p.playerSecond.owncards.Count : p.playerFirst.owncards.Count;
if (anz >= 1)
{
p.drawACard(p.getArandomCardFromDeck(ownplay), ownplay, true);
}
}
// zieht jedes mal eine karte, wenn ihr einen zauber wirkt.
public override void onCardIsGoingToBePlayed(Playfield p, CardDB.Card c, bool wasOwnCard, Minion triggerEffectMinion)
{
if (c.type == CardDB.cardtype.SPELL && wasOwnCard == triggerEffectMinion.own)
{
p.drawACard(p.getArandomCardFromDeck(wasOwnCard), wasOwnCard);
}
}
// Battlecry: Draw a card. If it's a minion, transform it into a Chicken.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
CardDB.Card randomCard = CardDB.Instance.getCardData(p.getArandomCardFromDeck(own.own));
if (randomCard.type == CardDB.cardtype.MOB) {
randomCard = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.Mekka4t);
}
p.drawACard(randomCard.name, own.own);
}
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
List<Minion> temp = (ownplay) ? p.playerFirst.ownMinions : p.playerSecond.ownMinions;
foreach (Minion t in temp)
{
t.cantLowerHPbelowONE = true;
}
p.drawACard(p.getArandomCardFromDeck(ownplay), ownplay);
}
public override void onMinionDiedTrigger(Playfield p, Minion m, Minion diedMinion)
{
int diedMinions = (m.own)? p.tempTrigger.ownMurlocDied : p.tempTrigger.enemyMurlocDied;
if(p.tempTrigger.ownMurlocDied > 0 && m.own)
{
for (int i = 0; i < diedMinions; i++)
{
p.drawACard(p.getArandomCardFromDeck(m.own), m.own);
}
}
else if(p.tempTrigger.enemyMurlocDied > 0 && !m.own)
{
for (int i = 0; i < diedMinions; i++)
{
p.drawACard(p.getArandomCardFromDeck(m.own), m.own);
}
}
}
// Whenever this minion takes damage, add a Spare Part card to your hand.
public override void onMinionGotDmgTrigger(Playfield p, Minion m, bool ownDmgdmin)
{
if (m.anzGotDmg>=1)
{
for (int i = 0; i < m.anzGotDmg; i++)
{
p.drawACard(CardDB.cardName.armorplating, m.own, true);
}
m.anzGotDmg = 0;
}
}
// kampfschrei:/ zerstört die waffe eures gegners. zieht ihrer haltbarkeit entsprechend karten.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
if (own.own)
{
//this.owncarddraw += enemyWeaponDurability;
for (int i = 0; i < p.playerSecond.ownWeaponDurability; i++)
{
p.drawACard(p.getArandomCardFromDeck(true), true);
}
p.lowerWeaponDurability(1000, false);
}
else
{
for (int i = 0; i < p.playerSecond.ownWeaponDurability; i++)
{
p.drawACard(p.getArandomCardFromDeck(false), false);
}
p.lowerWeaponDurability(1000, true);
}
}
// fügt einem diener $1 schaden zu. zieht eine karte, wenn er dadurch vernichtet wird.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = p.getSpellDamageDamage(1, ownplay);
if (dmg >= target.Hp && !target.divineshild && !target.immune)
{
//this.owncarddraw++;
p.drawACard(p.getArandomCardFromDeck(ownplay), ownplay);
}
p.minionGetDamageOrHeal(target, dmg);
}
// erhaltet 5 rüstung. zieht eine karte.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
if (ownplay)
{
p.minionGetArmor(p.playerFirst.ownHero, 5);
}
else
{
p.minionGetArmor(p.playerSecond.ownHero, 5);
}
p.drawACard(p.getArandomCardFromDeck(ownplay), ownplay);
}
// zieht so viele karten, bis ihr genauso viele karten auf eurer hand habt wie euer gegner.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int diff = (ownplay) ? p.playerSecond.owncards.Count - p.playerFirst.owncards.Count : p.playerFirst.owncards.Count - p.playerSecond.owncards.Count;
if (diff >= 1)
{
for (int i = 0; i < diff; i++)
{
//this.owncarddraw++;
p.drawACard(p.getArandomCardFromDeck(ownplay), ownplay);
}
}
}
// Battlecry: If you have a Mech, gain +1/+1 and add a Spare Part to your hand.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
List<Minion> temp = (own.own) ? p.playerFirst.ownMinions : p.playerSecond.ownMinions;
foreach (Minion m in temp)
{
if ((TAG_RACE)m.handcard.card.race == TAG_RACE.MECHANICAL)
{
p.minionGetBuffed(own, 1, 1);
p.drawACard(CardDB.cardName.armorplating, own.own, true);
return;
}
}
}
