// erhaltet jedes mal einen „feuerball“-zauber auf eure hand, wenn ihr einen zauber wirkt.
public override void onCardIsGoingToBePlayed(Playfield p, CardDB.Card c, bool wasOwnCard, Minion triggerEffectMinion, Minion target, int choice)
{
if (wasOwnCard == triggerEffectMinion.own && c.type == CardDB.cardtype.SPELL)
{
p.drawACard(CardDB.cardIDEnum.CS2_029, wasOwnCard, true);
}
}
// wenn ein spieler einen zauber wirkt, erhält der andere spieler eine kopie desselben auf seine hand.
public override void onCardIsGoingToBePlayed(Playfield p, CardDB.Card c, bool wasOwnCard, Minion triggerEffectMinion)
{
if (c.type == CardDB.cardtype.SPELL)
{
p.drawACard(c.cardIDenum, !wasOwnCard, true);
}
}
// verleiht euren dienern bis zu eurem nächsten zug verstohlenheit/.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
if (ownplay)
{
foreach (Minion m in p.ownMinions)
{
if (!m.stealth)
{
m.stealth = true;
m.concedal = true;
}
}
}
else
{
foreach (Minion m in p.enemyMinions)
{
if (!m.stealth)
{
m.stealth = true;
m.concedal = true;
}
}
}
}
public override void onAuraEnds(Playfield p, Minion own)
{
if (own.own)
{
p.anzOwnHorsemen--;
if (p.anzOwnHorsemen < 1)
{
p.ownHero.immune = false;
if (p.ownWeaponCard.name == CardDB.cardName.runeblade)
{
int bonus = (p.ownWeaponCard.cardIDenum == CardDB.cardIDEnum.NAX9_05H) ? 6 : 3;
p.minionGetBuffed(p.ownHero, bonus, 0);
p.ownWeaponAttack += bonus;
}
}
}
else
{
p.anzEnemyHorsemen--;
if (p.anzEnemyHorsemen < 1)
{
p.enemyHero.immune = false;
if (p.enemyWeaponCard.name == CardDB.cardName.runeblade)
{
int bonus = (p.enemyWeaponCard.cardIDenum == CardDB.cardIDEnum.NAX9_05H) ? 6 : 3;
p.minionGetBuffed(p.enemyHero, bonus, 0);
p.enemyWeaponAttack += bonus;
}
}
}
}
//Battlecry: Give all minions in your hand and deck +1/+1.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
if (p.isServer)
{
if (own.own)
{
foreach (Handmanager.Handcard hc in p.owncards)
{
if (hc.card.type == CardDB.cardtype.MOB)
{
hc.addattack++;
hc.addHp++;
}
}
foreach (Handmanager.Handcard hc in p.myDeck)
{
if (hc.card.type == CardDB.cardtype.MOB)
{
hc.addattack++;
hc.addHp++;
}
}
}
else
{
foreach (Handmanager.Handcard hc in p.EnemyCards)
{
if (hc.card.type == CardDB.cardtype.MOB)
{
hc.addattack++;
hc.addHp++;
}
}
foreach (Handmanager.Handcard hc in p.enemyDeck)
{
if (hc.card.type == CardDB.cardtype.MOB)
{
hc.addattack++;
hc.addHp++;
}
}
}
return;
}
if (own.own)
{
foreach (Handmanager.Handcard hc in p.owncards)
{
if (hc.card.type == CardDB.cardtype.MOB)
{
hc.addattack++;
hc.addHp++;
}
}
}
}
public override void onSecretPlay(Playfield p, bool ownplay, Minion attacker, Minion target, out int number)
{
number = 0;
if (ownplay)
{
int posi = p.ownMinions.Count;
p.callKid(kid, posi, true);
if (p.ownMinions.Count >= 1)
{
if (p.ownMinions[p.ownMinions.Count - 1].name == CardDB.cardName.spellbender)
{
number = p.ownMinions[p.ownMinions.Count - 1].entityID;
}
}
}
else
{
int posi = p.enemyMinions.Count;
p.callKid(kid, posi, false);
if (p.enemyMinions.Count >= 1)
{
if (p.enemyMinions[p.enemyMinions.Count - 1].name == CardDB.cardName.spellbender)
{
number = p.enemyMinions[p.enemyMinions.Count - 1].entityID;
}
}
}
}
//todo: what happens if the target is damaged?
//Battlecry: Swap Health with another minion.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
if (target == null) return;
int volMHp = own.maxHp;
int tarMHp = target.maxHp;
target.maxHp = volMHp;
if (tarMHp < volMHp)//minion has lower maxHp as his card -> heal his hp
{
target.Hp += volMHp - tarMHp; //heal minion
}
if (target.Hp > target.maxHp)
{
target.Hp = target.maxHp;
}
own.maxHp = tarMHp;
if (volMHp < tarMHp)//minion has lower maxHp as his card -> heal his hp
{
own.Hp += tarMHp - volMHp; //heal minion
}
if (own.Hp > own.maxHp)
{
own.Hp = own.maxHp;
}
}
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
p.equipWeapon(w, ownplay);
List<Minion> temp = (ownplay) ? p.ownMinions : p.enemyMinions;
bool hasmech = false;
foreach (Minion m in temp)
{
//if we have allready a mechanical, we are buffed
if ((TAG_RACE)m.handcard.card.race == TAG_RACE.MECHANICAL) hasmech=true;
}
if (hasmech)
{
if (ownplay)
{
p.ownWeaponAttack += 2;
p.minionGetBuffed(p.ownHero, 2, 0);
}
else
{
p.enemyWeaponAttack += 2;
p.minionGetBuffed(p.enemyHero, 2, 0);
}
}
}
public override void onMinionIsSummoned(Playfield p, Minion triggerEffectMinion, Minion summonedMinion)
{
if ((TAG_RACE)summonedMinion.handcard.card.race == TAG_RACE.MECHANICAL)
{
List<Minion> temp = (triggerEffectMinion.own) ? p.ownMinions : p.enemyMinions;
foreach (Minion m in temp)
{
//if we have allready a mechanical, we are buffed
if ((TAG_RACE)m.handcard.card.race == TAG_RACE.MECHANICAL) return;
}
//we had no mechanical, but now!
if (triggerEffectMinion.own)
{
p.ownWeaponAttack += 2;
p.minionGetBuffed(p.ownHero, 2, 0);
}
else
{
p.enemyWeaponAttack += 2;
p.minionGetBuffed(p.enemyHero, 2, 0);
}
}
}
CardDB.Card kid = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.CS2_101t);//silverhandrecruit
// Summon two 1/1 Recruits.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int posi = (ownplay) ? p.ownMinions.Count : p.enemyMinions.Count;
p.callKid(kid, posi, ownplay);
p.callKid(kid, posi, ownplay);
}
// kampfschrei:/ fügt einem diener 1 schaden zu und verleiht ihm +2 angriff.
public override int getPlayPenalty(Playfield p, Minion m, Minion target, int choice, bool isLethal)
{
if (target.own)
{
if (m.Hp == 1) return 50;
if (!m.Ready)
{
return 50;
}
}
else
{
if (m.handcard.card.type == CardDB.cardtype.MOB && p.ownMinions.Count == 0) return 0;
//allow it if you have biggamehunter
foreach (Handmanager.Handcard hc in p.owncards)
{
if (hc.card.name == CardDB.cardName.biggamehunter || hc.card.name == CardDB.cardName.shadowworddeath) return 0;
}
if (m.Hp == 1)
{
return 0;
}
if (!m.wounded && (m.Angr >= 4 || m.Hp >= 5))
{
foreach (Handmanager.Handcard hc in p.owncards)
{
if (hc.card.name == CardDB.cardName.execute) return 0;
}
}
return base.getValueOfMinion(4,5);
}
return 0;
}
// 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.doublepriest >= 1) dmg *= (2 * p.doublepriest);
if (p.enemyMinions.Count > 0)
{
target = p.searchRandomMinion(p.enemyMinions, Playfield.searchmode.searchLowestHP); //damage the lowest (pessimistic variant)
}
else
{
target = p.enemyHero;
}
}
else
{
if (p.enemydoublepriest >= 1) dmg *= (2 * p.enemydoublepriest);
if (p.ownMinions.Count > 0)
{
target = p.searchRandomMinion(p.ownMinions, Playfield.searchmode.searchHighestAttack); //damage the Highest (pessimistic variant)
}
else
{
target = p.ownHero;
}
}
p.minionGetDamageOrHeal(target, dmg);
}
// erhält jedes Mal +1/+1, wenn Ihr eine Karte mit uberladung< ausspielt.
public override void onCardIsGoingToBePlayed(Playfield p, CardDB.Card c, bool wasOwnCard, Minion triggerEffectMinion, Minion target, int choice)
{
if (wasOwnCard == triggerEffectMinion.own && c.Recall)
{
p.minionGetBuffed(triggerEffectMinion, 1, 1);
}
}
// 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);
}
}
//Battlecry: Give a friendly Beast Immune this turn.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
if (target != null && target.handcard.card.race == TAG_RACE.PET)
{
target.immune = true;
}
}
public override void onMinionDiedTrigger(Playfield p, Minion m, Minion diedMinion)
{
int diedMinions = (m.own)? p.tempTrigger.ownMechanicDied : p.tempTrigger.enemyMechanicDied;
if (diedMinions >= 1)
{
List<Minion> temp = (m.own) ? p.ownMinions : p.enemyMinions;
bool hasmechanics = false;
foreach (Minion mTmp in temp) //check if we have more mechanics, or debuff him
{
if (mTmp.Hp >=1 && (TAG_RACE)mTmp.handcard.card.race == TAG_RACE.MECHANICAL) hasmechanics = true;
}
if (!hasmechanics)
{
if(m.own)
{
p.ownWeaponAttack -= 2;
p.minionGetBuffed(p.ownHero, -2, 0);
}
else
{
p.enemyWeaponAttack -= 2;
p.minionGetBuffed(p.enemyHero, -2, 0);
}
}
}
}
public override float getPlayPenalty(Playfield p, Handmanager.Handcard hc, Minion target, int choice, bool isLethal)
{
int pen = 0;
foreach(Handmanager.Handcard hcc in p.owncards)
{
if (hcc.getManaCost(p) == 2 && hcc.card.type == CardDB.cardtype.MOB && hcc.card.type != CardDB.cardtype.HEROPWR && hcc.card.name != CardDB.cardName.ironbeakowl) pen += 2;
//if (p.manaTurnEnd >= hcc.getManaCost(p)) pen -= 2;
}
bool ablilityready = false;
foreach(Minion mnn in p.ownMinions)
{
if (mnn.name == CardDB.cardName.knifejuggler && p.ownHeroAblility.card.getManaCost(p, 2) <= p.manaTurnEnd) ablilityready = true;
}
bool targetready = false;
foreach (Minion mnn in p.ownMinions)
{
if (mnn.name != CardDB.cardName.grimpatron && mnn.Hp == 1) targetready = true;
}
if (ablilityready && targetready) pen = 0;
foreach (Minion mnn in p.enemyMinions)
{
if (mnn.Angr >= 2 && mnn.Hp == 1 && p.ownMaxMana <= 2 && p.enemyHeroName != HeroEnum.druid && p.enemyHeroName != HeroEnum.thief && p.enemyHeroName != HeroEnum.mage) return -5;
}
return pen;
}
// 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 = (ownplay) ? p.getSpellDamageDamage(1) : p.getEnemySpellDamageDamage(1);
target.frozen = true;
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(CardDB.cardName.unknown, turnEndOfOwner);
}
}
// verursacht $5 schaden. zieht eine karte.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = (ownplay) ? p.getSpellDamageDamage(5) : p.getEnemySpellDamageDamage(5);
p.minionGetDamageOrHeal(target, dmg);
//this.owncarddraw++;
p.drawACard(CardDB.cardName.unknown, ownplay);
}
// Your hero is Immune.
public override void onAuraStarts(Playfield p, Minion own)
{
if (own.own)
{
p.ownHero.immune = true;
if (p.ownWeaponCard.name == CardDB.cardName.runeblade && p.anzOwnHorsemen < 1)
{
int bonus = (p.ownWeaponCard.cardIDenum == CardDB.cardIDEnum.NAX9_05H) ? 6 : 3;
p.minionGetBuffed(p.ownHero, -1 * Math.Min(bonus, p.ownWeaponAttack - 1), 0);
p.ownWeaponAttack = Math.Min(1, p.ownWeaponAttack - bonus);
}
p.anzOwnHorsemen++;
}
else
{
p.enemyHero.immune = true;
if (p.enemyWeaponCard.name == CardDB.cardName.runeblade && p.anzEnemyHorsemen < 1)
{
int bonus = (p.enemyWeaponCard.cardIDenum == CardDB.cardIDEnum.NAX9_05H) ? 6 : 3;
p.minionGetBuffed(p.enemyHero, -1 * Math.Min(bonus, p.enemyWeaponAttack - 1), 0);
p.enemyWeaponAttack = Math.Min(1, p.enemyWeaponAttack - bonus);
}
p.anzEnemyHorsemen++;
}
}
//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);
}
}
//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);
}
// <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);
}
}
}
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
if (ownplay)
{
if (p.ownHeroAblility.card.cardIDenum == CardDB.cardIDEnum.CS1h_001) // lesser heal becomes mind spike
{
p.ownHeroAblility.card = mindspike;
p.ownAbilityReady = true;
}
else
{
p.ownHeroAblility.card = shatter; // mindspike becomes mind shatter
p.ownAbilityReady = true;
}
}
else
{
if (p.enemyHeroAblility.card.cardIDenum == CardDB.cardIDEnum.CS1h_001) // lesser heal becomes mind spike
{
p.enemyHeroAblility.card = mindspike;
}
else
{
p.enemyHeroAblility.card = shatter; // mindspike becomes mind shatter
}
}
}
//Battlecry: The next time you use your Hero Power, it costs (2) less.
public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
{
if (own.own) p.anzOwnFencingCoach++;
else p.anzEnemyFencingCoach++;
}
// fügt einem diener $3 schaden zu.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int damage = 0;
damage = (ownplay) ? p.getSpellDamageDamage(3) : p.getEnemySpellDamageDamage(3);
p.minionGetDamageOrHeal(target, damage);
}
// wählt einen feindlichen diener aus. vernichtet ihn zu beginn eures zuges.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
//if ownplay == true -> destroyOnOwnturnstart =true else destroyonenemyturnstart
target.destroyOnOwnTurnStart = target.destroyOnOwnTurnStart || ownplay;
target.destroyOnEnemyTurnStart = target.destroyOnEnemyTurnStart || !ownplay;
}
// verursacht $4 schaden. werft eine zufällige karte ab.
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = (ownplay) ? p.getSpellDamageDamage(4) : p.getEnemySpellDamageDamage(4);
p.minionGetDamageOrHeal(target, dmg);
if (p.isServer)
{
p.discardRandomCard_SERVER(ownplay);
return;
}
if (ownplay)
{
p.owncarddraw -= Math.Min(1, p.owncards.Count);
p.owncards.RemoveRange(0, Math.Min(1, p.owncards.Count));
p.triggerCardsChanged(true);
}
else
{
if (p.enemyAnzCards >= 1)
{
p.enemycarddraw--;
p.enemyAnzCards--;
p.triggerCardsChanged(false);
}
}
}
// verursacht $5 schaden. überladung:/ (2)
public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
{
int dmg = (ownplay) ? p.getSpellDamageDamage(5) : p.getEnemySpellDamageDamage(5);
p.minionGetDamageOrHeal(target, dmg);
p.changeRecall(ownplay, 2);
}
