//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.playerFirst.ownHero.Hp <= anz)
{
p.minionGetDamageOrHeal(p.playerFirst.ownHero, 1);
continue;
}
List<Minion> temp = new List<Minion>(p.playerSecond.ownMinions);
if (temp.Count == 0)
{
temp.AddRange(p.playerFirst.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.playerSecond.ownHero, 1);
}
}
// 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 = p.getMinionHeal(6, triggerEffectMinion.own);
int heal = 0;
foreach (Minion m in p.playerFirst.ownMinions)
{
if (m.maxHp - m.Hp > heal)
{
tm = m;
heal = m.maxHp - m.Hp;
}
}
foreach (Minion m in p.playerSecond.ownMinions)
{
if (m.maxHp - m.Hp > heal)
{
tm = m;
heal = m.maxHp - m.Hp;
}
}
if (heal >= 1)
{
p.minionGetDamageOrHeal(tm, -hl);
}
else
{
p.minionGetDamageOrHeal(p.playerFirst.ownHero.Hp < 30 ? p.playerFirst.ownHero : p.playerSecond.ownHero, -hl);
}
}
}
// 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 = p.getSpellDamageDamage(1, ownplay);
int dmg1 = p.getSpellDamageDamage(4, ownplay);
List<Minion> temp = (ownplay) ? p.playerSecond.ownMinions : p.playerFirst.ownMinions;
p.minionGetDamageOrHeal(target, dmg1);
foreach (Minion m in temp)
{
if (m.entitiyID != target.entitiyID)
{
p.minionGetDamageOrHeal(m, dmg);
}
}
if (ownplay)
{
if (p.playerSecond.ownHero.entitiyID != target.entitiyID)
{
p.minionGetDamageOrHeal(p.playerSecond.ownHero, dmg);
}
}
else
{
if (p.playerFirst.ownHero.entitiyID != target.entitiyID)
{
p.minionGetDamageOrHeal(p.playerFirst.ownHero, dmg);
}
}
}
// <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 = p.getMinionHeal(3, turnStartOfOwner);
List<Minion> temp = (turnStartOfOwner) ? p.playerFirst.ownMinions : p.playerSecond.ownMinions;
if (temp.Count >= 1)
{
bool healed = false;
foreach (Minion mins in temp)
{
if (mins.wounded)
{
p.minionGetDamageOrHeal(mins, -heal);
healed = true;
break;
}
}
if (!healed)
{
p.minionGetDamageOrHeal(turnStartOfOwner ? p.playerFirst.ownHero : p.playerSecond.ownHero, -heal);
}
}
else
{
p.minionGetDamageOrHeal(turnStartOfOwner ? p.playerFirst.ownHero : p.playerSecond.ownHero, -heal);
}
}
}
// verursacht $5 schaden. stellt bei eurem helden #5 leben wieder her.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = p.getSpellDamageDamage(5, ownplay);
p.minionGetDamageOrHeal(target, dmg);
int heal = p.getSpellHeal(5, ownplay);
p.minionGetDamageOrHeal(ownplay ? p.playerFirst.ownHero : p.playerSecond.ownHero, -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 = p.getSpellDamageDamage(3, ownplay);
p.minionGetDamageOrHeal(target, dmg);
if (ownplay) p.minionGetDamageOrHeal(p.playerSecond.ownHero, dmg);
else p.minionGetDamageOrHeal(p.playerFirst.ownHero, dmg);
}
// 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 = p.getSpellDamageDamage(5, ownplay);
int dmg2 = p.getSpellDamageDamage(2, ownplay);
List<Minion> temp = (target.own) ? p.playerFirst.ownMinions : p.playerSecond.ownMinions;
p.minionGetDamageOrHeal(target, dmg1);
foreach (Minion m in temp)
{
if (m.zonepos + 1 == target.zonepos || m.zonepos - 1 == target.zonepos) p.minionGetDamageOrHeal(m, dmg2);
}
}
// 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.playerSecond.ownMinions : p.playerFirst.ownMinions;
int times = p.getSpellDamageDamage(8, ownplay);
if ((ownplay && p.playerSecond.ownHero.Hp <= times) || (!ownplay && p.playerFirst.ownHero.Hp <= times))
{
if (ownplay) p.minionGetDamageOrHeal(p.playerSecond.ownHero, p.playerSecond.ownHero.Hp - 1);
else p.minionGetDamageOrHeal(p.playerFirst.ownHero, p.playerFirst.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.playerSecond.ownHero : p.playerFirst.ownHero, 1);
}
}
else
{
p.minionGetDamageOrHeal(ownplay ? p.playerSecond.ownHero : p.playerFirst.ownHero, 1);
}
i++;
}
}
}
// 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.playerFirst.ownMinions)
{
p.minionGetDamageOrHeal(m, m.Angr, true);
}
foreach (Minion m in p.playerSecond.ownMinions)
{
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.playerFirst.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.playerSecond.ownMinions)
{
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;
}
}
}
// 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.playerFirst.ownMinions)
{
if (m.handcard.card.deathrattle) p.minionGetDamageOrHeal(m, 2);
}
foreach (Minion m in p.playerSecond.ownMinions)
{
if (m.handcard.card.deathrattle) p.minionGetDamageOrHeal(m, 2);
}
}
// Battlecry: Restore 8 Health to your hero.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
if (own.own)
{
int heal = p.getMinionHeal(8, own.own);
p.minionGetDamageOrHeal(p.playerFirst.ownHero, -heal, true);
}
else
{
int heal = p.getMinionHeal(8, own.own);
p.minionGetDamageOrHeal(p.playerSecond.ownHero, -heal, true);
}
}
// After you cast a spell, deal 2 damage randomly split among all enemies.
public override void onCardIsGoingToBePlayed(Playfield p, CardDB.Card c, bool ownplay, Minion m)
{
if (m.own == ownplay && c.type == CardDB.cardtype.SPELL)
{
Minion target = (ownplay) ? p.playerSecond.ownHero : p.playerFirst.ownHero;
p.minionGetDamageOrHeal(target, 1);
List<Minion> temp = (ownplay) ? p.playerSecond.ownMinions : p.playerFirst.ownMinions;
if (temp.Count > 0) target = p.searchRandomMinion(temp, Playfield.searchmode.searchLowestHP);
if (target == null) target = (ownplay) ? p.playerSecond.ownHero : p.playerFirst.ownHero;
p.minionGetDamageOrHeal(target, 1);
}
}
// Deal 2 damage to all non-Demon minions.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = p.getSpellDamageDamage(2, ownplay);
foreach (Minion m in p.playerFirst.ownMinions)
{
if ((TAG_RACE)m.handcard.card.race != TAG_RACE.DEMON) p.minionGetDamageOrHeal(m, dmg);
}
foreach (Minion m in p.playerSecond.ownMinions)
{
if ((TAG_RACE)m.handcard.card.race != TAG_RACE.DEMON) p.minionGetDamageOrHeal(m, dmg);
}
}
//todo make it better :D
//Fügt allen Feinden $2 Schaden zu. Stellt bei allen befreundeten Charakteren #2 Leben wieder her.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = p.getSpellDamageDamage(2, ownplay);
int heal = p.getSpellHeal(2, ownplay);
if (ownplay)
{
p.minionGetDamageOrHeal(p.playerFirst.ownHero, -heal);
p.minionGetDamageOrHeal(p.playerSecond.ownHero, dmg);
foreach (Minion m in p.playerFirst.ownMinions)
{
p.minionGetDamageOrHeal(m, -heal);
}
foreach (Minion m in p.playerSecond.ownMinions)
{
p.minionGetDamageOrHeal(m, dmg);
}
}
else
{
p.minionGetDamageOrHeal(p.playerSecond.ownHero, -heal);
p.minionGetDamageOrHeal(p.playerFirst.ownHero, dmg);
foreach (Minion m in p.playerSecond.ownMinions)
{
p.minionGetDamageOrHeal(m, -heal);
}
foreach (Minion m in p.playerFirst.ownMinions)
{
p.minionGetDamageOrHeal(m, dmg);
}
}
}
// fügt allen charakteren mit ausnahme von ysera $5 schaden zu.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = p.getSpellDamageDamage(5, ownplay);
foreach (Minion m in p.playerFirst.ownMinions)
{
if (m.name != CardDB.cardName.ysera) p.minionGetDamageOrHeal(m, dmg);
}
foreach (Minion m in p.playerSecond.ownMinions)
{
if (m.name != CardDB.cardName.ysera) p.minionGetDamageOrHeal(m, dmg);
}
p.minionGetDamageOrHeal(p.playerFirst.ownHero, dmg);
p.minionGetDamageOrHeal(p.playerSecond.ownHero, dmg);
}
// Restore all characters to full Health.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int heal = 1000;
foreach (Minion m in p.playerFirst.ownMinions)
{
p.minionGetDamageOrHeal(m, -heal);
}
foreach (Minion m in p.playerSecond.ownMinions)
{
p.minionGetDamageOrHeal(m, -heal);
}
p.minionGetDamageOrHeal(p.playerSecond.ownHero, -heal);
p.minionGetDamageOrHeal(p.playerFirst.ownHero, -heal);
}
// 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);
}
// heldenfähigkeit/\nzieht eine karte und erleidet 2 schaden.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
p.drawACard(p.getArandomCardFromDeck(ownplay), ownplay);
int dmg = 2;
if (ownplay)
{
if (p.playerFirst.doublepriest >= 1) dmg *= (2 * p.playerFirst.doublepriest);
p.minionGetDamageOrHeal(p.playerFirst.ownHero, dmg);
}
else
{
if (p.playerSecond.doublepriest >= 1) dmg *= (2 * p.playerSecond.doublepriest);
p.minionGetDamageOrHeal(p.playerSecond.ownHero, dmg);
}
}
// Combo:: Deal 2 damage.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
if (p.playerFirst.cardsPlayedThisTurn >= 1 && target != null)
{
p.minionGetDamageOrHeal(target, 2);
}
}
// friert/ einen diener sowie seine benachbarten diener ein und fügt ihnen $1 schaden zu.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = p.getSpellDamageDamage(1, ownplay);
p.minionGetDamageOrHeal(target, dmg);
target.frozen = true;
List<Minion> temp = (target.own) ? p.playerFirst.ownMinions : p.playerSecond.ownMinions;
foreach (Minion m in temp)
{
if (target.zonepos == m.zonepos + 1 || target.zonepos + 1 == m.zonepos)
{
p.minionGetDamageOrHeal(m, dmg);
m.frozen = true;
}
}
}
// Hero PowerDeal 8 damage to a random enemy.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = 8;
if (ownplay)
{
if (p.playerFirst.doublepriest >= 1) dmg *= (2 * p.playerFirst.doublepriest);
if (p.playerSecond.ownMinions.Count > 0)
{
target = p.searchRandomMinion(p.playerSecond.ownMinions, Playfield.searchmode.searchLowestHP); //damage the lowest (pessimistic variant)
}
else
{
target = p.playerSecond.ownHero;
}
}
else
{
if (p.playerSecond.doublepriest >= 1) dmg *= (2 * p.playerSecond.doublepriest);
if (p.playerFirst.ownMinions.Count > 0)
{
target = p.searchRandomMinion(p.playerFirst.ownMinions, Playfield.searchmode.searchHighestAttack); //damage the Highest (pessimistic variant)
}
else
{
target = p.playerFirst.ownHero;
}
}
p.minionGetDamageOrHeal(target, dmg);
}
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = p.getSpellDamageDamage(1, ownplay);
if (p.playerFirst.cardsPlayedThisTurn >= 1) dmg = p.getSpellDamageDamage(2, ownplay);
p.minionGetDamageOrHeal(target, dmg);
p.equipWeapon(w, ownplay);
}
// fügt am ende eures zuges allen anderen charakteren 2 schaden zu.
public override void onTurnEndsTrigger(Playfield p, Minion triggerEffectMinion, bool turnEndOfOwner)
{
if (turnEndOfOwner == triggerEffectMinion.own)
{
foreach (Minion m in p.playerSecond.ownMinions)
{
if (triggerEffectMinion.entitiyID != m.entitiyID) p.minionGetDamageOrHeal(m, 2);
}
foreach (Minion m in p.playerFirst.ownMinions)
{
if (triggerEffectMinion.entitiyID != m.entitiyID) p.minionGetDamageOrHeal(m, 2);
}
p.minionGetDamageOrHeal(p.playerFirst.ownHero, 2);
p.minionGetDamageOrHeal(p.playerSecond.ownHero, 2);
}
}
// Restore #4 Health to your hero and gain +2 Attack this turn.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
if (ownplay)
{
int heal = p.getSpellHeal(4, ownplay);
p.minionGetDamageOrHeal(p.playerFirst.ownHero, -heal);
p.minionGetTempBuff(p.playerFirst.ownHero, 2, 0);
}
else
{
int heal = p.getSpellHeal(4, ownplay);
p.minionGetDamageOrHeal(p.playerSecond.ownHero, -heal);
p.minionGetTempBuff(p.playerSecond.ownHero, 2, 0);
}
}
// At the start of your turn, deal 1 damage to your hero.
public override void onTurnStartTrigger(Playfield p, Minion triggerEffectMinion, bool turnStartOfOwner)
{
if (triggerEffectMinion.own == turnStartOfOwner)
{
p.minionGetDamageOrHeal(turnStartOfOwner ? p.playerFirst.ownHero : p.playerSecond.ownHero, 1);
}
}
// fügt einem feindlichen charakter $1 schaden zu und friert/ ihn ein.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = p.getSpellDamageDamage(1, ownplay);
target.frozen = true;
p.minionGetDamageOrHeal(target, dmg);
}
// stellt zu beginn eures zuges das volle leben dieses dieners wieder her.
public override void onTurnStartTrigger(Playfield p, Minion triggerEffectMinion, bool turnStartOfOwner)
{
if (triggerEffectMinion.own == turnStartOfOwner)
{
int heal = p.getMinionHeal(triggerEffectMinion.maxHp - triggerEffectMinion.Hp, triggerEffectMinion.own);
p.minionGetDamageOrHeal(triggerEffectMinion, -heal);
}
}
// 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);
}
