//Destroy 2 random enemy minions. Discard 2 random cards.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
if (p.isServer)
{
Minion choosen = p.getRandomMinionFromSide_SERVER(!ownplay, false);
if (choosen != null) p.minionGetDestroyed(choosen);
choosen = p.getRandomMinionFromSide_SERVER(!ownplay, false);
if (choosen != null) p.minionGetDestroyed(choosen);
p.discardRandomCard_SERVER(ownplay);
p.discardRandomCard_SERVER(ownplay);
return;
}
Minion choosen2 = p.searchRandomMinion(p.enemyMinions, Playfield.searchmode.searchLowestAttack);
if (choosen2 != null) p.minionGetDestroyed(choosen2);
choosen2 = p.searchRandomMinion(p.enemyMinions, Playfield.searchmode.searchLowestAttack);
if (choosen2 != null) p.minionGetDestroyed(choosen2);
p.disCardACard(ownplay);
p.disCardACard(ownplay);
}
// 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);
}
}
// 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;
}
}
// 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);
};
}
}
// 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);
}
}
//todo make it better
// todesröcheln:/ übernehmt die kontrolle über einen zufälligen feindlichen diener.
public override void onDeathrattle(Playfield p, Minion m)
{
if (p.isServer)
{
Minion choosen = p.getRandomMinionFromSide_SERVER(!m.own, false);
if (choosen != null) p.minionGetControlled(choosen, m.own, false);
return;
}
List<Minion> tmp = (m.own) ? p.enemyMinions : p.ownMinions;
if (tmp.Count >= 1)
{
Minion target = null;
int value = 10000;
bool found = false;
//search smallest minion:
foreach (Minion mnn in tmp)
{
if (mnn.Hp < value && mnn.Hp >= 1)
{
target = mnn;
value = target.Hp;
found = true;
}
}
if (found) p.minionGetControlled(target, m.own, false);
}
}
// 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);
}
}
// Give your weapon +3 Attack. Combo: Give a random friendly minion +3 Attack.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
if (p.isServer)
{
if (ownplay)
{
if (p.ownWeaponDurability >= 1)
{
p.ownWeaponAttack += 3;
p.minionGetBuffed(p.ownHero, 3, 0);
}
}
else
{
if (p.enemyWeaponDurability >= 1)
{
p.enemyWeaponAttack += 3;
p.minionGetBuffed(p.enemyHero, 3, 0);
}
}
if (p.cardsPlayedThisTurn >= 1 )
{
Minion choosen = p.getRandomMinionFromSide_SERVER(ownplay, false);
if (choosen != null) p.minionGetBuffed(choosen, 3, 0);
}
return;
}
if (ownplay)
{
if (p.ownWeaponDurability >= 1)
{
p.ownWeaponAttack += 3;
p.minionGetBuffed(p.ownHero, 3, 0);
}
if (p.cardsPlayedThisTurn >= 1 && p.ownMinions.Count >= 1)
{
p.minionGetBuffed(p.searchRandomMinion(p.ownMinions, Playfield.searchmode.searchLowestHP), 3, 0);
}
}
else
{
if (p.enemyWeaponDurability >= 1)
{
p.enemyWeaponAttack += 3;
p.minionGetBuffed(p.enemyHero, 3, 0);
}
if (p.cardsPlayedThisTurn >= 1 && p.enemyMinions.Count >= 1)
{
p.minionGetBuffed(p.searchRandomMinion(p.enemyMinions, Playfield.searchmode.searchHighestHP), 3, 0);
}
}
}
// 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;
}
}
// 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;
}
}
// When you play or discard this, deal $4 damage to a random enemy.<
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = (ownplay) ? p.getSpellDamageDamage(4) : p.getEnemySpellDamageDamage(4);
if (p.isServer)
{
Minion choosen = p.getRandomMinionFromSide_SERVER(!ownplay, true);
if (choosen != null) p.minionGetDamageOrHeal(choosen, dmg);
return;
}
p.doDmgToRandomEnemyCLIENT(dmg, true, !ownplay);
}
//todo make it better
// todesröcheln:/ übernehmt die kontrolle über einen zufälligen feindlichen diener.
public override void onDeathrattle(Playfield p, Minion m)
{
if (p.isServer)
{
Minion choosen = p.getRandomMinionFromSide_SERVER(!m.own, false);
if (choosen != null) p.minionGetControlled(choosen, m.own, false);
return;
}
List<Minion> tmp = (m.own) ? p.enemyMinions : p.ownMinions;
if (tmp.Count >= 1)
{
Minion target = null;
int value = 10000;
bool found = false;
//search smallest minion:
if (m.own)
{
foreach (Minion mnn in tmp)
{
if (mnn.Hp < value && mnn.Hp >= 1)
{
target = mnn;
value = target.Hp;
found = true;
}
}
}
else
{
//steal a minion with has not attacked or has taunt
value = -1000;
foreach (Minion mnn in tmp)
{
int special = (m.Ready) ? 10 : 0;
special += (m.taunt) ? 5 : 0;
special += mnn.Hp;
if (special > value)
{
target = mnn;
value = special;
found = true;
}
}
}
if (found) p.minionGetControlled(target, m.own, false);
}
}
// Deathrattle: Deal 1 damage to a random enemy.
public override void onDeathrattle(Playfield p, Minion m)
{
if (p.isServer)
{
int randdmg = 1;
Minion poortarget = p.getRandomMinionFromSide_SERVER(!m.own, true);
if (poortarget != null) p.minionGetDamageOrHeal(poortarget, randdmg);
return;
}
p.doDmgToRandomEnemyCLIENT2(1, true, m.own);
}
// Battlecry: If you have a Mech, deal 4 damage randomly split among all enemies.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
// conservative/realistic
bool ownplay = own.own;
List<Minion> temp1 = (ownplay) ? p.ownMinions : p.enemyMinions;
bool haveAMech = false;
foreach (Minion m in temp1)
{
if ((TAG_RACE)m.handcard.card.race == TAG_RACE.MECHANICAL)
{
haveAMech = true;
break;
}
}
if (!haveAMech) return;
if (p.isServer)
{
int timesS = 4;
for (int iS = 0; iS < timesS; iS++)
{
Minion poortarget = p.getRandomMinionFromSide_SERVER(!ownplay, true);
if (poortarget != null) p.minionGetDamageOrHeal(poortarget, 1);
}
return;
}
List<Minion> targets = (ownplay) ? new List<Minion>(p.enemyMinions) : new List<Minion>(p.ownMinions);
int times = (ownplay) ? p.getSpellDamageDamage(4) : p.getEnemySpellDamageDamage(4);
if (ownplay)
{
targets.Add(p.enemyHero);
targets.Sort((a, b) => -a.Hp.CompareTo(b.Hp)); // most hp -> least
}
else
{
targets.Add(p.ownHero);
targets.Sort((a, b) => a.Hp.CompareTo(b.Hp)); // least hp -> most
}
// Distribute the damage evenly among the targets
int i = 0;
while (i < times)
{
int loc = i % targets.Count;
p.minionGetDamageOrHeal(targets[loc], 1);
i++;
}
}
//Whenever you target this minion with a spell, deal 3 damage to a random enemy.
public override void onCardIsGoingToBePlayed(Playfield p, CardDB.Card c, bool wasOwnCard, Minion triggerEffectMinion, Minion target, int choice)
{
if (triggerEffectMinion.own == wasOwnCard && c.type == CardDB.cardtype.SPELL && target!=null && target.entitiyID == triggerEffectMinion.entitiyID)
{
if (p.isServer)
{
Minion choosen = p.getRandomMinionFromSide_SERVER(!triggerEffectMinion.own, true);
if (choosen != null) p.minionGetDamageOrHeal(choosen, 3);
return;
}
p.doDmgToRandomEnemyCLIENT2(3, true, triggerEffectMinion.own);
}
}
// Whenever you summon a Pirate, deal 2 damage to a random enemy.
public override void onMinionIsSummoned(Playfield p, Minion triggerEffectMinion, Minion summonedMinion)
{
if (triggerEffectMinion.own == summonedMinion.own && summonedMinion.handcard.card.race == TAG_RACE.PIRATE)
{
if (p.isServer)
{
Minion randomguy = p.getRandomMinionFromSide_SERVER(!triggerEffectMinion.own, true);
if (randomguy != null) p.minionGetDamageOrHeal(randomguy, 2, true);
return;
}
p.doDmgToRandomEnemyCLIENT2(2, true, triggerEffectMinion.own);
}
}
public virtual void onCardIsDiscarded(Playfield p, CardDB.Card card, bool own)
{
int dmg = (own) ? p.getSpellDamageDamage(4) : p.getEnemySpellDamageDamage(4);
if (p.isServer)
{
Minion choosen = p.getRandomMinionFromSide_SERVER(!own, true);
if (choosen != null) p.minionGetDamageOrHeal(choosen, dmg);
return;
}
p.doDmgToRandomEnemyCLIENT(dmg, true, !own);
}
//Battlecry: Deal 1 damage to a random enemy.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
//Random minion!
if (p.isServer)
{
Minion choosen = p.getRandomMinionFromSide_SERVER(!own.own, true);
if (choosen != null) p.minionGetDamageOrHeal(choosen, 1);
return;
}
p.doDmgToRandomEnemyCLIENT(1, true, !own.own);
}
// vernichtet einen zufälligen feindlichen diener.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
if (p.isServer)
{
Minion tempS = p.getRandomMinionFromSide_SERVER(!ownplay, false);
if (tempS != null) p.minionGetDestroyed(tempS);
return;
}
List<Minion> temp2 = (ownplay) ? new List<Minion>(p.enemyMinions) : new List<Minion>(p.ownMinions);
temp2.Sort((a, b) => a.Angr.CompareTo(b.Angr));
foreach (Minion enemy in temp2)
{
p.minionGetDestroyed(enemy);
break;
}
}
// Whenever you summon a Pirate, deal 2 damage to a random enemy.
public override void onMinionIsSummoned(Playfield p, Minion triggerEffectMinion, Minion summonedMinion)
{
if (triggerEffectMinion.own == summonedMinion.own && summonedMinion.handcard.card.race == TAG_RACE.PIRATE)
{
if (p.isServer)
{
Minion randomguy = p.getRandomMinionFromSide_SERVER(!triggerEffectMinion.own, true);
if (randomguy != null) p.minionGetDamageOrHeal(randomguy, 2, true);
return;
}
List<Minion> temp = (triggerEffectMinion.own) ? p.enemyMinions : p.ownMinions;
Minion m = p.searchRandomMinion(temp, Playfield.searchmode.searchHighestHP);
if (m == null) return;
p.minionGetDamageOrHeal(m, 2, true);
}
}
//todo secret
// geheimnis:/ wenn einer eurer diener stirbt, erhält ein zufälliger befreundeter diener +3/+2.
public override void onSecretPlay(Playfield p, bool ownplay, int number)
{
if (p.isServer)
{
Minion poortarget = p.getRandomMinionFromSide_SERVER(ownplay, false);
if (poortarget != null) p.minionGetBuffed(poortarget, 3, 2);
return;
}
List<Minion> temp = new List<Minion>();
if (ownplay)
{
List<Minion> temp2 = new List<Minion>(p.ownMinions);
temp2.Sort((a, b) => -a.Angr.CompareTo(b.Angr));
temp.AddRange(temp2);
}
else
{
List<Minion> temp2 = new List<Minion>(p.enemyMinions);
temp2.Sort((a, b) => a.Angr.CompareTo(b.Angr));
temp.AddRange(temp2);
}
if (temp.Count >= 1)
{
if (ownplay)
{
Minion trgt = temp[0];
if (temp.Count >= 2 && trgt.taunt && !temp[1].taunt) trgt = temp[1];
p.minionGetBuffed(trgt, 3, 2);
}
else
{
Minion trgt = temp[0];
if (temp.Count >= 2 && !trgt.taunt && temp[1].taunt) trgt = temp[1];
p.minionGetBuffed(trgt, 3, 2);
}
}
}
// Destroy a random enemy minion. Combo: And your opponent's weapon.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
if(p.isServer)
{
Minion choosen = p.getRandomMinionFromSide_SERVER(!ownplay, false);
if (choosen != null) p.minionGetDestroyed(choosen);
if (p.cardsPlayedThisTurn >= 1) p.lowerWeaponDurability(1000, !ownplay);
return;
}
List<Minion> temp = (ownplay)? p.enemyMinions : p.ownMinions;
if (temp.Count >= 1)
{
p.minionGetDestroyed(p.searchRandomMinion(temp, Playfield.searchmode.searchLowestHP));
}
if (p.cardsPlayedThisTurn >= 1) p.lowerWeaponDurability(1000, !ownplay);
}
//todo list
public override void onDeathrattle(Playfield p, Minion m)
{
if (p.isServer)
{
Minion tempS = p.getRandomMinionFromSide_SERVER(m.own, false);
if(tempS!=null)p.minionGetBuffed(tempS, 0, 3);
return;
}
List<Minion> temp = new List<Minion>();
if (m.own)
{
List<Minion> temp2 = new List<Minion>(p.ownMinions);
temp2.Sort((a, b) => -a.Angr.CompareTo(b.Angr));
temp.AddRange(temp2);
}
else
{
List<Minion> temp2 = new List<Minion>(p.enemyMinions);
temp2.Sort((a, b) => a.Angr.CompareTo(b.Angr));
temp.AddRange(temp2);
}
if (temp.Count >= 1)
{
if (m.own)
{
Minion target = temp[0];
if (temp.Count >= 2 && target.taunt && !temp[1].taunt) target = temp[1];
p.minionGetBuffed(target, 0, 3);
}
else
{
Minion target = temp[0];
if (temp.Count >= 2 && !target.taunt && temp[1].taunt) target = temp[1];
p.minionGetBuffed(target, 0, 3);
}
}
}
//todo list
// kampfschrei:/ falls euer gegner mind. 4 diener hat, übernehmt zufällig die kontrolle über einen davon.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
if (p.isServer)
{
List<Minion> temp = (own.own) ? p.enemyMinions : p.ownMinions;
if (temp.Count >= 4)
{
Minion choosen = p.getRandomMinionFromSide_SERVER(!own.own, false);
if (choosen != null) p.minionGetControlled(choosen, own.own, false);
}
return;
}
if (own.own)
{
if (p.enemyMinions.Count >= 4)
{
List<Minion> temp = new List<Minion>(p.enemyMinions);
temp.Sort((a, b) => a.Angr.CompareTo(b.Angr));//we take the weekest
Minion targett;
targett = temp[0];
if (targett.taunt && temp.Count >= 2 && !temp[1].taunt) targett = temp[1];
p.minionGetControlled(targett, true, false);
}
}
else
{
if (p.ownMinions.Count >= 4)
{
List<Minion> temp = new List<Minion>(p.ownMinions);
temp.Sort((a, b) => a.Angr.CompareTo(b.Angr));//we take the weekest
Minion targett;
targett = temp[0];
if (targett.taunt && temp.Count >= 2 && !temp[1].taunt) targett = temp[1];
p.minionGetControlled(targett, false, false);
}
}
}
// Deathrattle: Deal 1-4 damage to a random enemy.
public override void onDeathrattle(Playfield p, Minion m)
{
if (p.isServer)
{
int randdmg = p.getRandomNumber_SERVER(1, 4);
Minion poortarget = p.getRandomMinionFromSide_SERVER(!m.own, true);
if (poortarget != null) p.minionGetDamageOrHeal(poortarget, randdmg);
return;
}
List<Minion> temp = (m.own) ? p.enemyMinions : p.ownMinions;
if (temp.Count >= 1 && temp.Count >=1 )
{
p.minionGetDamageOrHeal(p.searchRandomMinion(temp, Playfield.searchmode.searchHighestHP), 2);
}
else
{
p.minionGetDamageOrHeal(((m.own)?p.enemyHero : p.ownHero), 2);
}
}
// Whenever a character is healed, deal 1 damage to a random enemy.
public override void onAHeroGotHealedTrigger(Playfield p, Minion triggerEffectMinion, bool ownerOfHeroGotHealed)
{
if (p.isServer)
{
Minion choosen = p.getRandomMinionFromSide_SERVER(!triggerEffectMinion.own, true);
if (choosen != null) p.minionGetDamageOrHeal(choosen, 1);
}
else
{
Minion t = p.searchRandomMinion((triggerEffectMinion.own) ? p.enemyMinions : p.ownMinions, Playfield.searchmode.searchHighestHP);
if (t != null)
{
p.minionGetDamageOrHeal(t, 1);
}
else
{
p.minionGetDamageOrHeal((triggerEffectMinion.own) ? p.enemyHero : p.ownHero, 1);
}
}
}
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
p.equipWeapon(w, ownplay);
List<Minion> temp = (ownplay) ? p.ownMinions : p.enemyMinions;
if (temp.Count <= 0) return;
if (p.isServer)
{
Minion choosen = p.getRandomMinionFromSide_SERVER(ownplay, false);
if (choosen != null)
{
choosen.divineshild = true;
choosen.taunt = true;
}
return;
}
Minion m = p.searchRandomMinion(temp, (ownplay ? Playfield.searchmode.searchLowestAttack : Playfield.searchmode.searchHighestAttack));
m.divineshild = true;
m.taunt = true;
}
// 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> targets = (triggerEffectMinion.own) ? new List<Minion>(p.enemyMinions) : new List<Minion>(p.ownMinions);
if (triggerEffectMinion.own)
{
targets.Add(p.enemyHero);
targets.Sort((a, b) => -a.Hp.CompareTo(b.Hp)); // most hp -> least
}
else
{
targets.Add(p.ownHero);
targets.Sort((a, b) => a.Hp.CompareTo(b.Hp)); // least hp -> most
}
// Distribute the damage evenly among the targets
int i = 0;
while (i < 2)
{
int loc = i % targets.Count;
p.minionGetDamageOrHeal(targets[loc], 1);
i++;
}
triggerEffectMinion.stealth = false;
}
}
//giv a minion +10/10
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
if (p.isServer)
{
int timesS = (ownplay) ? p.getSpellDamageDamage(10) : p.getEnemySpellDamageDamage(10);
for (int iS = 0; iS < timesS; iS++)
{
Minion poortarget = p.getRandomMinionFromSide_SERVER(!ownplay, true);
if (poortarget != null) p.minionGetDamageOrHeal(poortarget, 1);
}
return;
}
List<Minion> targets = (ownplay) ? new List<Minion>(p.enemyMinions) : new List<Minion>(p.ownMinions);
int times = (ownplay) ? p.getSpellDamageDamage(10) : p.getEnemySpellDamageDamage(10);
if (ownplay)
{
targets.Add(p.enemyHero);
targets.Sort((a, b) => -a.Hp.CompareTo(b.Hp)); // most hp -> least
}
else
{
targets.Add(p.ownHero);
targets.Sort((a, b) => a.Hp.CompareTo(b.Hp)); // least hp -> most
}
// Distribute the damage evenly among the targets
int i = 0;
while (i < times)
{
int loc = i % targets.Count;
p.minionGetDamageOrHeal(targets[loc], 1);
i++;
}
}
// Battlecry: If you have a Mech, deal 4 damage randomly split among all enemies.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
// optimistic
bool ownplay = own.own;
List<Minion> temp1 = (ownplay) ? p.ownMinions : p.enemyMinions;
bool haveAMech = false;
foreach (Minion m in temp1)
{
if ((TAG_RACE)m.handcard.card.race == TAG_RACE.MECHANICAL)
{
haveAMech = true;
break;
}
}
if (!haveAMech) return;
if (p.isServer)
{
int timesS = 4;
for (int iS = 0; iS < timesS; iS++)
{
Minion poortarget = p.getRandomMinionFromSide_SERVER(!ownplay, true);
if (poortarget != null) p.minionGetDamageOrHeal(poortarget, 1);
}
return;
}
int i = 0;
List<Minion> temp = (ownplay) ? p.enemyMinions : p.ownMinions;
int times = (ownplay) ? p.getSpellDamageDamage(4) : p.getEnemySpellDamageDamage(4);
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++;
}
}
}
