// Deal $4 damage to a random enemy minion.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
if (p.isServer)
{
int dmg = (ownplay) ? p.getSpellDamageDamage(4) : p.getEnemySpellDamageDamage(4);
Minion poortarget = p.getRandomMinionFromSide_SERVER(!ownplay, false);
if (poortarget != null) p.minionGetDamageOrHeal(poortarget, dmg);
return;
}
// optimistic
List<Minion> temp = (ownplay) ? p.enemyMinions : p.ownMinions;
int times = (ownplay) ? p.getSpellDamageDamage(4) : p.getEnemySpellDamageDamage(4);
if (temp.Count >= 1)
{
//search Minion with lowest hp
Minion enemy = temp[0];
int minhp = 10000;
foreach (Minion m in temp)
{
if (m.Hp >= times + 1 && minhp > m.Hp)
{
enemy = m;
minhp = m.Hp;
}
}
p.minionGetDamageOrHeal(enemy, times);
}
}
// Deal $4-$5 damage to all minions. Overload: (5)
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
if (ownplay) { p.owedRecall += 5; } else { p.enemyRecall += 5; };
if (p.isServer)
{
foreach (Minion m in p.ownMinions)
{
int dmgr = p.getRandomNumber_SERVER(4, 5);
dmgr = (ownplay) ? p.getSpellDamageDamage(dmgr) : p.getEnemySpellDamageDamage(dmgr);
p.minionGetDamageOrHeal(m, dmgr);
}
foreach (Minion m in p.enemyMinions)
{
int dmgr = p.getRandomNumber_SERVER(4, 5);
dmgr = (ownplay) ? p.getSpellDamageDamage(dmgr) : p.getEnemySpellDamageDamage(dmgr);
p.minionGetDamageOrHeal(m, dmgr);
}
return;
}
int dmg = (ownplay) ? p.getSpellDamageDamage(5) : p.getEnemySpellDamageDamage(5);
p.allMinionsGetDamage(dmg);
}
//Battlecry: Restore 4 Health to each hero
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
int heal2 = (own.own) ? p.getMinionHeal(4) : p.getEnemyMinionHeal(4);
p.minionGetDamageOrHeal(own.own ? p.ownHero : p.enemyHero, -heal2);
p.minionGetDamageOrHeal(own.own ? p.enemyHero : p.ownHero, -heal2);
}
// Hero Power: Deal 8 damage to a random enemy. TWICE.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = 8;
if (ownplay)
{
dmg += p.anzOwnFallenHeros;
if (p.doublepriest >= 1) dmg *= (2 * p.doublepriest);
}
else
{
dmg += p.anzEnemyFallenHeros;
if (p.enemydoublepriest >= 1) dmg *= (2 * p.enemydoublepriest);
}
if (p.isServer)
{
Minion poortarget = p.getRandomMinionFromSide_SERVER(!ownplay, true);
if (poortarget != null) p.minionGetDamageOrHeal(poortarget, dmg);
return;
}
int count = (ownplay) ? p.enemyMinions.Count : p.ownMinions.Count;
if (count >= 1)
{
List<Minion> temp2 = (ownplay) ? new List<Minion>(p.enemyMinions) : new List<Minion>(p.ownMinions);
temp2.Sort((a, b) => a.Hp.CompareTo(b.Hp));//damage the lowest
foreach (Minion mins in temp2)
{
p.minionGetDamageOrHeal(mins, dmg);
break;
}
}
else
{
p.minionGetDamageOrHeal(ownplay ? p.enemyHero : p.ownHero, dmg);
}
p.doDmgTriggers();
count = (ownplay) ? p.enemyMinions.Count : p.ownMinions.Count;
if (count >= 1)
{
List<Minion> temp2 = (ownplay) ? new List<Minion>(p.enemyMinions) : new List<Minion>(p.ownMinions);
temp2.Sort((a, b) => a.Hp.CompareTo(b.Hp));//damage the lowest
foreach (Minion mins in temp2)
{
p.minionGetDamageOrHeal(mins, dmg);
break;
}
}
else
{
p.minionGetDamageOrHeal(ownplay ? p.enemyHero : p.ownHero, dmg);
}
}
// Battlecry: Deal 4 damage to a random enemy minion.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
if (p.isServer)
{
Minion choosen = p.getRandomMinionFromSide_SERVER(!own.own, false);
if (choosen != null) p.minionGetDamageOrHeal(choosen, 4);
return;
}
List<Minion> temp = (own.own) ? p.enemyMinions : p.ownMinions;
int times = 4;
if (temp.Count >= 1)
{
//search Minion with lowest hp
Minion enemy = temp[0];
int minhp = 10000;
foreach (Minion m in temp)
{
if (m.Hp >= times + 1 && minhp > m.Hp)
{
enemy = m;
minhp = m.Hp;
}
}
p.minionGetDamageOrHeal(enemy, times);
}
}
// <deDE>Stellt zu Beginn Eures Zuges bei einem verletzten befreundeten Charakter 3 Leben wieder her.</deDE>
public override void onTurnStartTrigger(Playfield p, Minion triggerEffectMinion, bool turnStartOfOwner)
{
if (turnStartOfOwner == triggerEffectMinion.own)
{
int heal = (turnStartOfOwner) ? p.getMinionHeal(3) : p.getEnemyMinionHeal(3);
List<Minion> temp = (turnStartOfOwner) ? p.ownMinions : p.enemyMinions;
if (temp.Count >= 1)
{
bool healed = false;
foreach (Minion mins in temp)
{
if (mins.wounded)
{
p.minionGetDamageOrHeal(mins, -heal);
healed = true;
break;
}
}
if (!healed)
{
if (turnStartOfOwner) p.minionGetDamageOrHeal(p.ownHero, -heal);
else p.minionGetDamageOrHeal(p.enemyHero, -heal);
}
}
else
{
if (turnStartOfOwner) p.minionGetDamageOrHeal(p.ownHero, -heal);
else p.minionGetDamageOrHeal(p.enemyHero, -heal);
}
}
}
// heldenfähigkeit/\nzieht eine karte und erleidet 2 schaden.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
bool reduceToZero = false;
if(ownplay && p.anzOwnFizzlebang >=1)
{
reduceToZero=true;
}
if(!ownplay && p.anzEnemyFizzlebang>=1)
{
reduceToZero=true;
}
p.drawACard(CardDB.cardIDEnum.None, ownplay, false, reduceToZero);
int dmg = 2;
if (ownplay)
{
dmg += p.anzOwnFallenHeros;
if (p.doublepriest >= 1) dmg *= (2 * p.doublepriest);
p.minionGetDamageOrHeal(p.ownHero, dmg);
}
else
{
dmg += p.anzEnemyFallenHeros;
if (p.enemydoublepriest >= 1) dmg *= (2 * p.enemydoublepriest);
p.minionGetDamageOrHeal(p.enemyHero, dmg);
}
}
// kann nicht angreifen. fügt am ende eures zuges einem zufälligen feind 8 schaden zu.
public override void onTurnEndsTrigger(Playfield p, Minion triggerEffectMinion, bool turnEndOfOwner)
{
if (p.isServer)
{
Minion choosen = p.getRandomMinionFromSide_SERVER(!triggerEffectMinion.own, true);
if (choosen != null) p.minionGetDamageOrHeal(choosen, 8);
return;
}
if (triggerEffectMinion.own == turnEndOfOwner)
{
int count = (turnEndOfOwner) ? p.enemyMinions.Count : p.ownMinions.Count;
if (count >= 1)
{
List<Minion> temp2 = (turnEndOfOwner) ? new List<Minion>(p.enemyMinions) : new List<Minion>(p.ownMinions);
temp2.Sort((a, b) => a.Hp.CompareTo(b.Hp));//damage the lowest
foreach (Minion mins in temp2)
{
p.minionGetDamageOrHeal(mins, 8);
break;
}
}
else
{
p.minionGetDamageOrHeal(turnEndOfOwner ? p.enemyHero : p.ownHero, 8);
}
triggerEffectMinion.stealth = false;
}
}
//todo make it better
// kampfschrei:/ verursacht 3 schaden, der zufällig auf alle anderen charaktere aufgeteilt wird.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
int anz = 3;
for (int i = 0; i < anz; i++)
{
if (p.ownHero.Hp <= anz)
{
p.minionGetDamageOrHeal(p.ownHero, 1);
continue;
}
List<Minion> temp = new List<Minion>(p.enemyMinions);
if (temp.Count == 0)
{
temp.AddRange(p.ownMinions);
}
temp.Sort((a, b) => a.Hp.CompareTo(b.Hp));//destroys the weakest
foreach (Minion m in temp)
{
p.minionGetDamageOrHeal(m, 1);
break;
}
p.minionGetDamageOrHeal(p.enemyHero, 1);
}
}
// kann nicht angreifen. fügt am ende eures zuges einem zufälligen feind 8 schaden zu.
public override void onTurnEndsTrigger(Playfield p, Minion triggerEffectMinion, bool turnEndOfOwner)
{
if (triggerEffectMinion.own == turnEndOfOwner)
{
int count = (turnEndOfOwner) ? p.enemyMinions.Count : p.ownMinions.Count;
if (count >= 1)
{
List<Minion> temp2 = (turnEndOfOwner) ? new List<Minion>(p.enemyMinions) : new List<Minion>(p.ownMinions);
temp2.Sort((a, b) => -a.Hp.CompareTo(b.Hp));//damage the stronges
foreach (Minion mins in temp2)
{
p.minionGetDamageOrHeal(mins, 8);
break;
}
}
else
{
if (turnEndOfOwner)
{
p.minionGetDamageOrHeal(p.enemyHero, 8);
}
else
{
p.minionGetDamageOrHeal(p.ownHero, 8);
}
}
triggerEffectMinion.stealth = false;
}
}
// fügt zwei zufälligen feindlichen dienern $2 schaden zu.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
if (p.isServer)
{
int damageS = (ownplay) ? p.getSpellDamageDamage(2) : p.getEnemySpellDamageDamage(2);
List<Minion> temp22 = (ownplay) ? new List<Minion>(p.enemyMinions) : new List<Minion>(p.ownMinions);
if (temp22.Count < 2) return;
int random1 = p.getRandomNumber_SERVER(0, temp22.Count - 1);
int random2 = p.getRandomNumber_SERVER(0, temp22.Count - 2);
if (random2 >= random1) random2++;
p.minionGetDamageOrHeal(temp22[random1], damageS);
p.minionGetDamageOrHeal(temp22[random2], damageS);
return;
}
//TODO delete new list
int damage = (ownplay) ? p.getSpellDamageDamage(2) : p.getEnemySpellDamageDamage(2);
List<Minion> temp2 = (ownplay) ? new List<Minion>(p.enemyMinions) : new List<Minion>(p.ownMinions) ;
temp2.Sort((a, b) => a.Hp.CompareTo(b.Hp));
int i = 0;
foreach (Minion enemy in temp2)
{
p.minionGetDamageOrHeal(enemy, damage);
i++;
if (i == 2) break;
}
}
// fügt einem feind $4 schaden und allen anderen feinden $1 schaden zu.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = (ownplay)? p.getSpellDamageDamage(1) : p.getEnemySpellDamageDamage(1);
int dmg1 = (ownplay) ? p.getSpellDamageDamage(4) : p.getEnemySpellDamageDamage(4);
List<Minion> temp = (ownplay) ? p.enemyMinions : p.ownMinions;
p.minionGetDamageOrHeal(target, dmg1);
foreach (Minion m in temp)
{
if (m.entitiyID != target.entitiyID)
{
p.minionGetDamageOrHeal(m, dmg);
}
}
if (ownplay)
{
if (p.enemyHero.entitiyID != target.entitiyID)
{
p.minionGetDamageOrHeal(p.enemyHero, dmg);
}
}
else
{
if (p.ownHero.entitiyID != target.entitiyID)
{
p.minionGetDamageOrHeal(p.ownHero, dmg);
}
}
}
// fügt zu beginn eures zuges einem zufälligen feind 2 schaden zu.
public override void onTurnStartTrigger(Playfield p, Minion triggerEffectMinion, bool turnStartOfOwner)
{
if (triggerEffectMinion.own == turnStartOfOwner)
{
if (p.isServer)
{
Minion choosen = p.getRandomMinionFromSide_SERVER(!triggerEffectMinion.own, true);
if (choosen != null) p.minionGetDamageOrHeal( choosen, 2);
return;
}
List<Minion> temp2 = (turnStartOfOwner) ? p.enemyMinions : p.ownMinions;
bool dmgdone = false;
foreach (Minion mins in temp2)
{
p.minionGetDamageOrHeal(mins, 2);
dmgdone = true;
break;
}
if (!dmgdone)
{
p.minionGetDamageOrHeal(turnStartOfOwner ? p.enemyHero : p.ownHero, 2);
};
}
}
// stellt am ende eures zuges bei einem verletzten charakter 6 leben wieder her.
public override void onTurnEndsTrigger(Playfield p, Minion triggerEffectMinion, bool turnEndOfOwner)
{
if (turnEndOfOwner == triggerEffectMinion.own)
{
Minion tm = null;
int hl = (triggerEffectMinion.own) ? p.getMinionHeal(6) : p.getEnemyMinionHeal(6);
int heal = 0;
foreach (Minion m in p.ownMinions)
{
if (m.maxHp - m.Hp > heal)
{
tm = m;
heal = m.maxHp - m.Hp;
}
}
foreach (Minion m in p.enemyMinions)
{
if (m.maxHp - m.Hp > heal)
{
tm = m;
heal = m.maxHp - m.Hp;
}
}
if (heal >= 1)
{
p.minionGetDamageOrHeal(tm, -hl);
}
else
{
p.minionGetDamageOrHeal(p.ownHero.Hp < 30 ? p.ownHero : p.enemyHero, -hl);
}
}
}
// Battlecry:</b> Shuffle a Mine into your opponent's deck. When drawn, it explodes for 10 damage.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
if (own.own)
{
p.enemyDeckSize++;
if (p.enemyDeckSize <= 6)
{
p.minionGetDamageOrHeal(p.enemyHero, Math.Min(10, p.enemyHero.Hp-1), true);
p.evaluatePenality -= 6;
}
else
{
if (p.enemyDeckSize <= 16)
{
p.minionGetDamageOrHeal(p.enemyHero, Math.Min(5, p.enemyHero.Hp - 1), true);
p.evaluatePenality -= 8;
}
else
{
if (p.enemyDeckSize <= 26)
{
p.minionGetDamageOrHeal(p.enemyHero, Math.Min(2, p.enemyHero.Hp - 1), true);
p.evaluatePenality -= 10;
}
}
}
}
else
{
p.ownDeckSize++;
}
}
// verursacht $2 schaden. stellt bei eurem helden #2 leben wieder her.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = (ownplay) ? p.getSpellDamageDamage(2) : p.getEnemySpellDamageDamage(2);
int heal = (ownplay) ? p.getSpellHeal(2) : p.getEnemySpellHeal(2);
p.minionGetDamageOrHeal(target, dmg);
p.minionGetDamageOrHeal(ownplay ? p.ownHero : p.enemyHero, -heal);
}
// Deal $3 damage to a minion and the enemy hero.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = (ownplay) ? p.getSpellDamageDamage(3) : p.getEnemySpellDamageDamage(3);
p.minionGetDamageOrHeal(target, dmg);
if (ownplay) p.minionGetDamageOrHeal(p.enemyHero, dmg);
else p.minionGetDamageOrHeal(p.ownHero, dmg);
}
// After you cast a spell, deal 2 damage randomly split among all enemies.
public override void onCardWasPlayed(Playfield p, CardDB.Card c, bool wasOwnCard, Minion triggerEffectMinion)
{
if (triggerEffectMinion.own == wasOwnCard)
{
if (p.isServer)
{
int timesS = 2;
for (int iS = 0; iS < timesS; iS++)
{
Minion poortarget = p.getRandomMinionFromSide_SERVER(!wasOwnCard, true);
if (poortarget != null) p.minionGetDamageOrHeal(poortarget, 1);
}
return;
}
List<Minion> temp = (triggerEffectMinion.own) ? p.enemyMinions : p.ownMinions;
for (int i = 0; i < 2; i++)
{
if (temp.Count >= 1)
{
//search Minion with lowest hp
Minion enemy = temp[0];
int minhp = 10000;
bool found = false;
foreach (Minion m in temp)
{
if (m.name == CardDB.cardName.nerubianegg && m.Hp >= 2) continue; //dont attack nerubianegg!
if (m.handcard.card.isToken && m.Hp == 1) continue;
if (m.name == CardDB.cardName.defender) continue;
if (m.name == CardDB.cardName.spellbender) continue;
if (m.Hp >= 2 && minhp > m.Hp)
{
enemy = m;
minhp = m.Hp;
found = true;
}
}
if (found)
{
p.minionGetDamageOrHeal(enemy, 1);
}
else
{
p.minionGetDamageOrHeal(triggerEffectMinion.own ? p.enemyHero : p.ownHero, 1);
}
}
else
{
p.minionGetDamageOrHeal(triggerEffectMinion.own ? p.enemyHero : p.ownHero, 1);
}
}
triggerEffectMinion.stealth = false;
}
}
//Spend all your Mana. Heal for double the mana you spent.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
if (ownplay)
{
p.minionGetDamageOrHeal(target, -p.getSpellHeal(2 * p.mana));
p.mana = 0;
}
else p.minionGetDamageOrHeal(target, -p.getSpellHeal(2 * p.enemyMaxMana));
}
// fügt einem zufälligen feind 1 schaden zu, nachdem ihr einen diener herbeigerufen habt.
public override void onMinionWasSummoned(Playfield p, Minion triggerEffectMinion, Minion summonedMinion)
{
if (triggerEffectMinion.entityID != summonedMinion.entityID && triggerEffectMinion.own == summonedMinion.own)
{
if (p.isServer)
{
Minion choosen = p.getRandomMinionFromSide_SERVER(!triggerEffectMinion.own, true);
if (choosen != null)
{
p.minionGetDamageOrHeal(choosen, 1);
triggerEffectMinion.stealth = false;
}
return;
}
List<Minion> temp = (triggerEffectMinion.own) ? p.enemyMinions : p.ownMinions;
if (temp.Count >= 1)
{
//search Minion with lowest hp
Minion enemy = temp[0];
int minhp = 10000;
bool found = false;
foreach (Minion m in temp)
{
if (m.name == CardDB.cardName.nerubianegg && m.Hp >= 2) continue; //dont attack nerubianegg!
if (m.handcard.card.isToken && m.Hp == 1) continue;
if (m.name == CardDB.cardName.defender) continue;
if (m.name == CardDB.cardName.spellbender) continue;
if (m.Hp >= 2 && minhp > m.Hp)
{
enemy = m;
minhp = m.Hp;
found = true;
}
}
if (found)
{
p.minionGetDamageOrHeal(enemy, 1);
}
else
{
p.minionGetDamageOrHeal(triggerEffectMinion.own ? p.enemyHero : p.ownHero, 1);
}
}
else
{
p.minionGetDamageOrHeal(triggerEffectMinion.own ? p.enemyHero : p.ownHero, 1);
}
triggerEffectMinion.stealth = false;
}
}
// verursacht $8 schaden, der zufällig auf feindliche charaktere verteilt wird.
//todo for enemy
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
// optimistic
int i = 0;
List<Minion> temp = (ownplay) ? p.enemyMinions : p.ownMinions;
int times = (ownplay) ? p.getSpellDamageDamage(8) : p.getEnemySpellDamageDamage(8);
if ((ownplay && p.enemyHero.Hp <= times) || (!ownplay && p.ownHero.Hp <= times))
{
if (ownplay) p.minionGetDamageOrHeal(p.enemyHero, p.enemyHero.Hp - 1);
else p.minionGetDamageOrHeal(p.ownHero, p.ownHero.Hp - 1);
}
else
{
while (i < times)
{
if (temp.Count >= 1)
{
//search Minion with lowest hp
Minion enemy = temp[0];
int minhp = 10000;
bool found = false;
foreach (Minion m in temp)
{
if (m.name == CardDB.cardName.nerubianegg && enemy.Hp >= 2) continue; //dont attack nerubianegg!
if (m.Hp >= 2 && minhp > m.Hp)
{
enemy = m;
minhp = m.Hp;
found = true;
}
}
if (found)
{
p.minionGetDamageOrHeal(enemy, 1);
}
else
{
p.minionGetDamageOrHeal(ownplay ? p.enemyHero : p.ownHero, 1);
}
}
else
{
p.minionGetDamageOrHeal(ownplay ? p.enemyHero : p.ownHero, 1);
}
i++;
}
}
}
// todesröcheln:/ fügt dem feindlichen helden 2 schaden zu.
public override void onDeathrattle(Playfield p, Minion m)
{
if (m.own)
{
p.minionGetDamageOrHeal(p.enemyHero, 2);
}
else
{
p.minionGetDamageOrHeal(p.ownHero, 2);
}
}
// fügt einem diener $5 schaden und benachbarten dienern $2 schaden zu.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg1 = (ownplay) ? p.getSpellDamageDamage(5) : p.getEnemySpellDamageDamage(5);
int dmg2 = (ownplay) ? p.getSpellDamageDamage(2) : p.getEnemySpellDamageDamage(2);
List<Minion> temp = (target.own) ? p.ownMinions : p.enemyMinions;
p.minionGetDamageOrHeal(target, dmg1);
foreach (Minion m in temp)
{
if (m.zonepos + 1 == target.zonepos || m.zonepos - 1 == target.zonepos) p.minionGetDamageOrHeal(m, dmg2);
}
}
//insprire: If your hand is empty, deal 2 damage to the enemy hero.
public override void onInspire(Playfield p, Minion m)
{
if (m.own && p.owncards.Count == 0)
{
p.minionGetDamageOrHeal(p.enemyHero, 2);
}
if (!m.own && p.enemyAnzCards == 0)
{
p.minionGetDamageOrHeal(p.ownHero, 2);
}
}
// kampfschrei:/ fügt eurem helden 3 schaden zu.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
if (own.own)
{
p.minionGetDamageOrHeal(p.ownHero, 3);
}
else
{
p.minionGetDamageOrHeal(p.enemyHero, 3);
}
}
// Deal damage to each minion equal to its Attack.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
foreach (Minion m in p.ownMinions)
{
p.minionGetDamageOrHeal(m, m.Angr, true);
}
foreach (Minion m in p.enemyMinions)
{
p.minionGetDamageOrHeal(m, m.Angr, true);
}
}
// At the end of your turn, deal 2 damage to a non-Mech minion.
public override void onTurnEndsTrigger(Playfield p, Minion triggerEffectMinion, bool turnEndOfOwner)
{
if (triggerEffectMinion.own == turnEndOfOwner)
{
//count non-mechs
int ownNonMechs = 0;
Minion ownTemp = null;
foreach (Minion m in p.ownMinions)
{
if ((TAG_RACE)m.handcard.card.race != TAG_RACE.MECHANICAL)
{
if (ownTemp == null) ownTemp = m;
ownNonMechs++;
}
}
int enemyNonMechs = 0;
Minion enemyTemp = null;
foreach (Minion m in p.enemyMinions)
{
if ((TAG_RACE)m.handcard.card.race != TAG_RACE.MECHANICAL)
{
if (enemyTemp == null) enemyTemp = m;
enemyNonMechs++;
}
}
// dmg own minion if we have more than the enemy, in the other case dmg him!
if (ownNonMechs >= 1 && enemyNonMechs >= 1)
{
if (ownNonMechs >= enemyNonMechs)
{
p.minionGetDamageOrHeal(ownTemp, 2, true);
return;
}
p.minionGetDamageOrHeal(enemyTemp, 2, true);
return;
}
if (ownNonMechs >= 1)
{
p.minionGetDamageOrHeal(ownTemp, 2, true);
return;
}
if (enemyNonMechs >= 1)
{
p.minionGetDamageOrHeal(enemyTemp, 2, true);
return;
}
}
}
// Deal 2 damage to all non-Demon minions.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = (ownplay) ? p.getSpellDamageDamage(2) : p.getEnemySpellDamageDamage(2);
foreach (Minion m in p.ownMinions)
{
if ((TAG_RACE)m.handcard.card.race != TAG_RACE.DEMON) p.minionGetDamageOrHeal(m, dmg);
}
foreach (Minion m in p.enemyMinions)
{
if ((TAG_RACE)m.handcard.card.race != TAG_RACE.DEMON) p.minionGetDamageOrHeal(m, dmg);
}
}
// fügt dem feindlichen helden $2 schaden zu. combo:/ lasst die karte in eurem nächsten zug wieder auf eure hand zurückkehren.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = (ownplay) ? p.getSpellDamageDamage(2) : p.getEnemySpellDamageDamage(2);
if (ownplay)
{
p.minionGetDamageOrHeal(p.enemyHero, dmg);
}
else
{
p.minionGetDamageOrHeal(p.ownHero, dmg);
}
if (p.cardsPlayedThisTurn >= 1) p.evaluatePenality -= 5;
}
// Battlecry: Deal 2 damage to all minions with Deathrattle.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
foreach (Minion m in p.ownMinions)
{
if (m.handcard.card.deathrattle) p.minionGetDamageOrHeal(m, 2);
}
foreach (Minion m in p.enemyMinions)
{
if (m.handcard.card.deathrattle) p.minionGetDamageOrHeal(m, 2);
}
}
