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;
}
//private static Ai instance;
//public static Ai Instance
//{
// get
// {
// return instance ?? (instance = new Ai());
// }
//}
public Ai(Silverfish sf)
{
this.sf = sf;
this.nextMoveGuess = new Playfield(sf);
PenalityManager penman = sf.PenalityManager;
hp = sf.Hrtprozis;
hm = sf.Handmanager;
help = sf.Helpfunctions;
this.nextMoveGuess = new Playfield (sf) { mana = -100 };
this.mainTurnSimulator = new MiniSimulator(sf, maxdeep, maxwide, 0); // 0 for unlimited
this.mainTurnSimulator.setPrintingstuff(true);
/*this.nextTurnSimulator = new MiniSimulatorNextTurn();
this.enemyTurnSim = new EnemyTurnSimulator();
this.enemySecondTurnSim = new EnemyTurnSimulator();*/
for (int i = 0; i < sf.Settings.numberOfThreads; i++)
{
this.nextTurnSimulator.Add(new MiniSimulatorNextTurn(sf));
this.enemyTurnSim.Add(new EnemyTurnSimulator(sf));
this.enemySecondTurnSim.Add(new EnemyTurnSimulator(sf));
this.nextTurnSimulator[i].thread = i;
this.enemyTurnSim[i].thread = i;
this.enemySecondTurnSim[i].thread = i;
}
}
public override float getPlayPenalty(Playfield p, Handmanager.Handcard hc, Minion target, int choice, bool isLethal)
{
if (p.enemyMinions.Count == 0)
return 20;
return 0;
}
public override float getPlayPenalty(Playfield p, Handmanager.Handcard hc, Minion target, int choice, bool isLethal)
{
if (p.enemyHeroName == HeroEnum.hunter || p.enemyHeroName == HeroEnum.mage || p.enemyHeroName == HeroEnum.pala)
{
return 50;
}
return 0;
}
public override float getPlayPenalty(Playfield p, Handmanager.Handcard hc, Minion target, int choice, bool isLethal)
{
int pen = 25;
if ((target.Hp <= 1 + p.spellpower || target.divineshild) && !target.isHero)
{
if (target.own) pen -= 20;
if (!target.own) pen -= 25;
}
return pen;
}
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) <= p.mana && hcc.card.name != CardDB.cardName.biggamehunter && !target.taunt) pen += 1;
if (!p.ownHero.allreadyAttacked) pen += 1;
}
return pen;
}
public Action(actionEnum type, Handmanager.Handcard hc, Minion ownCardEntity, int place, Minion target, int pen, int choice)
{
this.actionType = type;
this.card = hc;
this.own = ownCardEntity;
this.place = place;
this.target = target;
this.penalty = pen;
this.druidchoice = choice;
}
public override float getPlayPenalty(Playfield p, Handmanager.Handcard hc, Minion target, int choice, bool isLethal)
{
bool juggleron = false;
foreach (Minion mnn in p.ownMinions)
{
if (mnn.name == CardDB.cardName.knifejuggler) juggleron = true;
}
if (juggleron) return -10;
return 0;
}
public override float getPlayPenalty(Playfield p, Handmanager.Handcard hc, Minion target, int choice, bool isLethal)
{
int pen = 0;
bool hasdivineshild = false;
foreach(Minion mnn in p.ownMinions)
{
if (mnn.divineshild && p.enemyMinions.Count >= 1) hasdivineshild = true;
}
if (hasdivineshild) pen += 4;
return pen;
}
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)
{
//find another 2mana minion
if (hcc.card.cost == 2 && hcc.card.type == CardDB.cardtype.MOB && hcc.card.name != CardDB.cardName.ironbeakowl) pen += 2;
}
if (p.ownMinions.Count - p.enemyMinions.Count >= 2) pen -= 10;
return pen;
}
//Choose One - Summon a 2/2 Slime; or Gain an empty Mana Crystal.
public override float getPlayPenalty(Playfield p, Handmanager.Handcard hc, Minion target, int choice, bool isLethal)
{
if (choice == 1)
{
if (p.ownMinions.Count > 5) return 18;
}
if (choice == 2)
{
if (p.ownMaxMana == 10) return 500;
else if (p.ownMaxMana > 5) return p.ownMaxMana;
}
return 0;
}
public override float getPlayPenalty(Playfield p, Handmanager.Handcard hc, Minion target, int choice, bool isLethal)
{
if (choice == 1) //deal 2 dmg
{
if (p.enemyMinions.Count == 0) return 25;
}
if (choice == 2) // summon 2 1/1 sampling
{
if (p.manaTurnEnd <= hc.getManaCost(p))
{
if (hc.getManaCost(p) == 1) return -2;
}
}
return 0;
}
public override float getPlayPenalty(Playfield p, Handmanager.Handcard hc, Minion target, int choice, bool isLethal)
{
// penalty for playing Loatheb as a vanilla 5/5, i.e. on an empty board (should hold for offensive finishing or preventing AoE/removal)
int penalty = 0;
if (p.ownHero.Hp + p.ownHero.armor > 15)
{
if (p.ownMinions.Count >= 3) return 0;
else penalty += 5;
if (p.enemyMinions.Count == 0) penalty += 5;
}
return penalty;
}
public override float getPlayPenalty(Playfield p, Handmanager.Handcard hc, Minion target, int choice, bool isLethal)
{
int PENALTY = 0;
if (Ai.Instance.botBase is BehaviorHandlock)
{
foreach (Handmanager.Handcard hcc in p.owncards)//check moltengiant
{
if (hcc.card.name == CardDB.cardName.moltengiant && p.ownHeroName == HeroEnum.warlock)//use giant first
{
if (hcc.card.getManaCost(p, hcc.manacost) == 0)
{
return 500;
}
else
{
return 2 * (hcc.card.getManaCost(p, hcc.manacost));
}
}
}
if (p.ownHero.Hp >= 15)
{
int ENEMYMINIONATTACK = 0; //if we candie, use heal
foreach (Minion mnn in p.enemyMinions)
{
ENEMYMINIONATTACK += mnn.Angr;
}
if (p.ownHero.Hp - ENEMYMINIONATTACK <= 8)
{
PENALTY = 0;
}
else PENALTY = 2 * (p.ownHero.Hp - 14); //15hp: 2 16hp : 4...
if (p.ownHero.Hp - ENEMYMINIONATTACK >= 20) PENALTY -= 20;
}
if (p.ownHero.Hp <= 14) // 0~14 pen = 0;
{
PENALTY = 0;
}
}
return PENALTY;
}
public override float getPlayPenalty(Playfield p, Handmanager.Handcard hc, Minion target, int choice, bool isLethal)
{
if (p.enemyHeroName == HeroEnum.warrior || p.enemyHeroName == HeroEnum.thief || p.enemyHeroName == HeroEnum.pala)
{
bool canPlayAnotherMob = false;
foreach (Handmanager.Handcard hcc in p.owncards)
{
if (hcc.card.type == CardDB.cardtype.MOB && hcc.canplayCard(p))
{
canPlayAnotherMob = true;
break;
}
}
bool hasGoodWeapon = (p.enemyWeaponDurability > 0 && p.enemyWeaponAttack > 1);
if (!hasGoodWeapon)
{
return (canPlayAnotherMob ? 20 : 5);
}
}
return 0;
}
public override float getPlayPenalty(Playfield p, Handmanager.Handcard hc, Minion target, int choice, bool isLethal)
{
return 0;
}
private Minion createNewMinion(Handmanager.Handcard hc, int id)
{
Minion m = new Minion();
m.handcard = new Handmanager.Handcard(hc);
m.zonepos = id + 1;
m.entitiyID = hc.entity;
m.Angr = hc.card.Attack;
m.Hp = hc.card.Health;
m.maxHp = hc.card.Health;
m.name = hc.card.name;
m.playedThisTurn = true;
m.numAttacksThisTurn = 0;
if (hc.card.windfury) m.windfury = true;
if (hc.card.tank) m.taunt = true;
if (hc.card.Charge)
{
m.Ready = true;
m.charge = 1;
}
if (hc.card.Shield) m.divineshild = true;
if (hc.card.poisionous) m.poisonous = true;
if (hc.card.Stealth) m.stealth = true;
if (m.name == CardDB.cardName.lightspawn && !m.silenced)
{
m.Angr = m.Hp;
}
return m;
}
private void triggerPlayedAMinion(Handmanager.Handcard hc, bool own)
{
if (own) // effects only for OWN minons
{
List<Minion> tempo = new List<Minion>(this.ownMinions);
foreach (Minion m in tempo)
{
if (m.silenced) continue;
if (m.handcard.card.specialMin == CardDB.specialMinions.knifejuggler && m.entitiyID != hc.entity)
{
if (this.enemyMinions.Count >= 1)
{
List<Minion> temp = new List<Minion>();
int damage = 1;
List<Minion> temp2 = new List<Minion>(this.enemyMinions);
temp2.Sort((a, b) => -a.Hp.CompareTo(b.Hp));
bool dmgdone = false;
foreach (Minion enemy in temp2)
{
if (enemy.Hp > 1)
{
minionGetDamagedOrHealed(enemy, damage, 0, false);
dmgdone = true;
break;
}
if (!dmgdone) this.attackOrHealHero(1, false);
}
}
else
{
this.attackOrHealHero(1, false);
}
}
if (own && m.handcard.card.specialMin == CardDB.specialMinions.starvingbuzzard && (TAG_RACE)hc.card.race == TAG_RACE.PET && m.entitiyID != hc.entity)
{
//this.owncarddraw++;
this.drawACard("", true);
}
if (own && m.handcard.card.specialMin == CardDB.specialMinions.undertaker && hc.card.deathrattle)
{
minionGetBuffed(m, 1, 1, own);
}
}
}
//effects for ALL minons
List<Minion> tempoo = new List<Minion>(this.ownMinions);
foreach (Minion m in tempoo)
{
if (m.silenced) continue;
if (m.handcard.card.specialMin== CardDB.specialMinions.murloctidecaller && hc.card.race == 14 && m.entitiyID != hc.entity)
{
minionGetBuffed(m, 1, 0, true);
}
if (m.handcard.card.specialMin == CardDB.specialMinions.oldmurkeye && hc.card.race == 14 && m.entitiyID != hc.entity)
{
minionGetBuffed(m, 1, 0, true);
}
}
tempoo.Clear();
tempoo.AddRange(this.enemyMinions);
foreach (Minion m in tempoo)
{
if (m.silenced) continue;
//truebaugederalte
if (m.handcard.card.specialMin == CardDB.specialMinions.murloctidecaller && hc.card.race == 14 && m.entitiyID != hc.entity)
{
minionGetBuffed(m, 1, 0, false);
}
if (m.handcard.card.specialMin == CardDB.specialMinions.oldmurkeye && hc.card.race == 14 && m.entitiyID != hc.entity)
{
minionGetBuffed(m, 1, 0, false);
}
}
}
private void playCardWithTarget(Handmanager.Handcard hc, int target, int choice)
{
CardDB.Card c = hc.card;
//play card with target
int attackbuff = 0;
int hpbuff = 0;
int heal = 0;
int damage = 0;
bool spott = false;
bool divineshild = false;
bool windfury = false;
bool silence = false;
bool destroy = false;
bool frozen = false;
bool stealth = false;
bool backtohand = false;
int backtoHandManaChange = 0;
bool charge = false;
bool setHPtoONE = false;
bool immune = false;
int adjacentDamage = 0;
bool sheep = false;
bool frogg = false;
//special
bool geistderahnen = false;
bool ueberwaeltigendemacht = false;
bool own = true;
if (target >= 10 && target < 20)
{
own = false;
}
Minion m = new Minion();
if (target < 10)
{
m = this.ownMinions[target];
}
if (target >= 10 && target < 20)
{
m = this.enemyMinions[target - 10];
}
//warrior###########################################################################
if (c.name == "execute")
{
destroy = true;
}
if (c.name == "innerrage")
{
damage = 1;
attackbuff = 2;
}
if (c.name == "slam")
{
damage = 2;
if (m.Hp >= 3)
{
//this.owncarddraw++;
drawACard("", true);
}
}
if (c.name == "mortalstrike")
{
damage = 4;
if (ownHeroHp <= 12) damage = 6;
}
if (c.name == "shieldslam")
{
damage = this.ownHeroDefence;
}
if (c.name == "charge")
{
charge = true;
attackbuff = 2;
}
if (c.name == "rampage")
{
attackbuff = 3;
hpbuff = 3;
}
//hunter#################################################################################
if (c.name == "huntersmark")
{
setHPtoONE = true;
}
if (c.name == "arcaneshot")
{
damage = 2;
}
if (c.name == "killcommand")
{
damage = 3;
foreach (Minion mnn in this.ownMinions)
{
if ((TAG_RACE)mnn.handcard.card.race == TAG_RACE.PET)
{
damage = 5;
}
}
}
if (c.name == "bestialwrath")
{
Enchantment e = CardDB.getEnchantmentFromCardID("EX1_549o");
e.creator = hc.entity;
e.controllerOfCreator = this.ownController;
addEffectToMinionNoDoubles(m, e, own);
}
if (c.name == "explosiveshot")
{
damage = 5;
adjacentDamage = 2;
}
//mage###############################################################################
if (c.name == "icelance")
{
if (target >= 0 && target <= 19)
{
if (m.frozen)
{
damage = 4;
}
else { frozen = true; }
}
else
{
if (target ==100)
{
if (this.ownHeroFrozen)
{
damage = 4;
}
else
{
frozen = true;
}
}
if (target == 200)
{
if (this.enemyHeroFrozen)
{
damage = 4;
}
else
{
frozen = true;
}
}
}
}
if (c.name == "coneofcold")
{
damage = 1;
adjacentDamage = 1;
frozen = true;
}
if (c.name == "fireball")
{
damage = 6;
}
if (c.name == "polymorph")
{
sheep = true;
}
if (c.name == "pyroblast")
{
damage = 10;
}
if (c.name == "frostbolt")
{
damage = 3;
frozen = true;
}
//pala######################################################################
if (c.name == "humility")
{
m.Angr = 1;
}
if (c.name == "handofprotection")
{
divineshild = true;
}
if (c.name == "blessingofmight")
{
attackbuff = 3;
}
if (c.name == "holylight")
{
heal = 6;
}
if (c.name == "hammerofwrath")
{
damage = 3;
//this.owncarddraw++;
drawACard("", true);
}
if (c.name == "blessingofkings")
{
attackbuff = 4;
hpbuff = 4;
}
if (c.name == "blessingofwisdom")
{
Enchantment e = CardDB.getEnchantmentFromCardID("EX1_363e2");
e.creator = hc.entity;
e.controllerOfCreator = this.ownController;
m.enchantments.Add(e);
}
if (c.name == "blessedchampion")
{
m.Angr *= 2;
}
if (c.name == "holywrath")
{
damage = 3;
//this.owncarddraw++;
drawACard("", true);
}
if (c.name == "layonhands")
{
for (int i = 0; i < 3; i++)
{
//this.owncarddraw++;
drawACard("", true);
}
heal = 8;
}
//priest ##########################################
if (c.name == "shadowmadness")
{
Enchantment e = CardDB.getEnchantmentFromCardID("EX1_334e");
e.creator = hc.entity;
e.controllerOfCreator = this.ownController;
addEffectToMinionNoDoubles(m, e, own);
this.minionGetControlled(m, true, true);
}
if (c.name == "mindcontrol")
{
this.minionGetControlled(m, true, false);
}
if (c.name == "holysmite")
{
damage = 2;
}
if (c.name == "powerwordshield")
{
hpbuff = 2;
//this.owncarddraw++;
drawACard("", true);
}
if (c.name == "silence")
{
silence = true;
}
if (c.name == "divinespirit")
{
hpbuff = m.Hp;
}
if (c.name == "innerfire")
{
m.Angr = m.Hp;
}
if (c.name == "holyfire")
{
damage = 5;
int ownheal = getSpellHeal(5);
attackOrHealHero(-ownheal, true);
}
if (c.name == "shadowwordpain")
{
destroy = true;
}
if (c.name == "shadowworddeath")
{
destroy = true;
}
//rogue ##########################################
if (c.name == "shadowstep")
{
backtohand = true;
backtoHandManaChange = -2;
//m.handcard.card.cost = Math.Max(0, m.handcard.card.cost -= 2);
}
if (c.name == "sap")
{
backtohand = true;
backtoHandManaChange = 0;
}
if (c.name == "shiv")
{
damage = 1;
//this.owncarddraw++;
drawACard("", true);
}
if (c.name == "coldblood")
{
attackbuff = 2;
if (this.cardsPlayedThisTurn >= 1) attackbuff = 4;
}
if (c.name == "conceal")
{
stealth = true;
}
if (c.name == "eviscerate")
{
damage = 2;
if (this.cardsPlayedThisTurn >= 1) damage = 4;
}
if (c.name == "betrayal")
{
//attack right neightbor
if (target >= 10 && target < 20 && target < this.enemyMinions.Count + 10 - 1)
{
attack(target, target + 1, true);
}
if (target < 10 && target < this.ownMinions.Count - 1)
{
attack(target, target + 1, true);
}
//attack left neightbor
if (target >= 11 || (target < 10 && target >= 1))
{
attack(target, target - 1, true);
}
}
if (c.name == "perditionsblade")
{
damage = 1;
if (this.cardsPlayedThisTurn >= 1) damage = 2;
}
if (c.name == "backstab")
{
damage = 2;
}
if (c.name == "assassinate")
{
destroy = true;
}
//shaman ##########################################
if (c.name == "lightningbolt")
{
damage = 3;
}
if (c.name == "frostshock")
{
frozen = true;
damage = 1;
}
if (c.name == "rockbiterweapon")
{
if (target <= 20)
{
Enchantment e = CardDB.getEnchantmentFromCardID("CS2_045e");
e.creator = hc.entity;
e.controllerOfCreator = this.ownController;
addEffectToMinionNoDoubles(m, e, own);
}
else
{
if (target == 100)
{
this.ownheroAngr += 3;
if ((this.ownHeroNumAttackThisTurn == 0 || (this.ownHeroWindfury && this.ownHeroNumAttackThisTurn == 1)) && !this.ownHeroFrozen)
{
this.ownHeroReady = true;
}
}
}
}
if (c.name == "windfury")
{
windfury = true;
}
if (c.name == "hex")
{
frogg = true;
}
if (c.name == "earthshock")
{
silence = true;
damage = 1;
}
if (c.name == "ancestralspirit")
{
geistderahnen = true;
}
if (c.name == "lavaburst")
{
damage = 5;
}
if (c.name == "ancestralhealing")
{
heal = 1000;
spott = true;
}
//hexenmeister ##########################################
if (c.name == "sacrificialpact")
{
destroy = true;
this.attackOrHealHero(getSpellHeal(5), true); // heal own hero
}
if (c.name == "soulfire")
{
damage = 4;
this.owncarddraw--;
this.owncards.RemoveRange(0, Math.Min(1, this.owncards.Count));
}
if (c.name == "poweroverwhelming")
{
//only to own mininos
Enchantment e = CardDB.getEnchantmentFromCardID("EX1_316e");
e.creator = hc.entity;
e.controllerOfCreator = this.ownController;
addEffectToMinionNoDoubles(m, e, true);
}
if (c.name == "corruption")
{
//only to enemy mininos
Enchantment e = CardDB.getEnchantmentFromCardID("CS2_063e");
e.creator = hc.entity;
e.controllerOfCreator = this.ownController;
addEffectToMinionNoDoubles(m, e, false);
}
if (c.name == "mortalcoil")
{
damage = 1;
if (getSpellDamageDamage(1) >= m.Hp && !m.divineshild && !m.immune)
{
//this.owncarddraw++;
drawACard("", true);
}
}
if (c.name == "drainlife")
{
damage = 2;
attackOrHealHero(2, true);
}
if (c.name == "shadowbolt")
{
damage = 4;
}
if (c.name == "shadowflame")
{
int damage1 = getSpellDamageDamage(m.Angr);
List<Minion> temp = new List<Minion>(this.enemyMinions);
foreach (Minion mnn in temp)
{
minionGetDamagedOrHealed(mnn, damage1, 0, false);
}
//destroy own mininon
destroy = true;
}
if (c.name == "demonfire")
{
if (m.handcard.card.race == 15 && own)
{
attackbuff = 2;
hpbuff = 2;
}
else
{
damage = 2;
}
}
if (c.name == "baneofdoom")
{
damage = 2;
if (getSpellDamageDamage(2) >= m.Hp && !m.divineshild && !m.immune)
{
int posi = this.ownMinions.Count - 1;
CardDB.Card kid = CardDB.Instance.getCardData("bloodimp");
callKid(kid, posi, true);
}
}
if (c.name == "siphonsoul")
{
destroy = true;
attackOrHealHero(3, true);
}
//druid #######################################################################
if (c.name == "moonfire" && c.CardID == "CS2_008")// nicht zu verwechseln mit cenarius choice nummer 1
{
damage = 1;
}
if (c.name == "markofthewild")
{
spott = true;
attackbuff = 2;
hpbuff = 2;
}
if (c.name == "healingtouch")
{
heal = 8;
}
if (c.name == "starfire")
{
damage = 5;
//this.owncarddraw++;
drawACard("", true);
}
if (c.name == "naturalize")
{
destroy = true;
this.enemycarddraw += 2;
}
if (c.name == "savagery")
{
damage = this.ownheroAngr;
}
if (c.name == "swipe")
{
damage = 4;
// all others get 1 spelldamage
int damage1 = getSpellDamageDamage(1);
if (target != 200)
{
attackOrHealHero(damage1, false);
}
List<Minion> temp = new List<Minion>(this.enemyMinions);
foreach (Minion mnn in temp)
{
if (mnn.id + 10 != target)
{
minionGetDamagedOrHealed(mnn, damage1, 0, false);
}
}
}
//druid choices##################################################################################
if (c.name == "wrath")
{
if (choice == 1)
{
damage = 3;
}
if (choice == 2)
{
damage = 1;
//this.owncarddraw++;
drawACard("", true);
}
}
if (c.name == "markofnature")
{
if (choice == 1)
{
attackbuff = 4;
}
if (choice == 2)
{
spott = true;
hpbuff = 4;
}
}
if (c.name == "starfall")
{
if (choice == 1)
{
damage = 5;
}
}
//special cards#########################################################################################
if (c.name == "nightmare")
{
//only to own mininos
Enchantment e = CardDB.getEnchantmentFromCardID("EX1_316e");
e.creator = hc.entity;
e.controllerOfCreator = this.ownController;
addEffectToMinionNoDoubles(m, e, true);
}
if (c.name == "dream")
{
backtohand = true;
backtoHandManaChange = 0;
}
if (c.name == "bananas")
{
attackbuff = 1;
hpbuff = 1;
}
if (c.name == "barreltoss")
{
damage = 2;
}
if (c.CardID == "PRO_001b")// i am murloc
{
damage = 4;
//this.owncarddraw++;
drawACard("", true);
} if (c.name == "willofmukla")
{
heal = 6 ;
}
//NaxxCards###################################################################################
if (c.name == "reincarnation")
{
int place = m.id;
if(place >=10) place -=10;
CardDB.Card d = m.handcard.card;
minionGetDestroyed(m, own);
callKid(d, place, own);
}
//make effect on target
//ownminion
if (damage >= 1) damage = getSpellDamageDamage(damage);
if (adjacentDamage >= 1) adjacentDamage = getSpellDamageDamage(adjacentDamage);
if (heal >= 1 && heal < 1000) heal = getSpellHeal(heal);
if (target < 10)
{
if (silence) minionGetSilenced(m, true);
minionGetBuffed(m, attackbuff, hpbuff, true);
minionGetDamagedOrHealed(m, damage, heal, true);
if (spott) m.taunt = true;
if (charge) minionGetCharge(m);
if (windfury) minionGetWindfurry(m);
if (divineshild) m.divineshild = true;
if (destroy) minionGetDestroyed(m, true);
if (frozen) m.frozen = true;
if (stealth) m.stealth = true;
if (backtohand) minionReturnToHand(m, true,backtoHandManaChange );
if (immune) m.immune = true;
if (adjacentDamage >= 1)
{
List<Minion> tempolist = new List<Minion>(this.ownMinions);
foreach (Minion mnn in tempolist)
{
if (mnn.id == target + 1 || mnn.id == target - 1)
{
minionGetDamagedOrHealed(m, adjacentDamage, 0, own);
if (frozen) mnn.frozen = true;
}
}
}
if (sheep) minionTransform(m, CardDB.Instance.getCardDataFromID("CS2_tk1"), own);
if (frogg) minionTransform(m, CardDB.Instance.getCardDataFromID("hexfrog"), own);
if (setHPtoONE)
{
m.Hp = 1; m.maxHp = 1;
}
if (geistderahnen)
{
Enchantment e = CardDB.getEnchantmentFromCardID("CS2_038e");
e.creator = hc.entity;
e.controllerOfCreator = this.ownController;
addEffectToMinionNoDoubles(m, e, true);
}
}
//enemyminion
if (target >= 10 && target < 20)
{
if (silence) minionGetSilenced(m, false);
minionGetBuffed(m, attackbuff, hpbuff, false);
minionGetDamagedOrHealed(m, damage, heal, false);
if (spott) m.taunt = true;
if (charge) minionGetCharge(m);
if (windfury) minionGetWindfurry(m);
if (divineshild) m.divineshild = true;
if (destroy) minionGetDestroyed(m, false);
if (frozen) m.frozen = true;
if (stealth) m.stealth = true;
if (backtohand) minionReturnToHand(m, false,backtoHandManaChange);
if (immune) m.immune = true;
if (adjacentDamage >= 1)
{
List<Minion> tempolist = new List<Minion>(this.enemyMinions);
foreach (Minion mnn in tempolist)
{
if (mnn.id + 10 == target + 1 || mnn.id + 10 == target - 1)
{
minionGetDamagedOrHealed(m, adjacentDamage, 0, own);
if (frozen) mnn.frozen = true;
}
}
}
if (sheep) minionTransform(m, CardDB.Instance.getCardDataFromID("CS2_tk1"), own);
if (frogg) minionTransform(m, CardDB.Instance.getCardDataFromID("hexfrog"), own);
if (setHPtoONE)
{
m.Hp = 1; m.maxHp = 1;
}
if (geistderahnen)
{
Enchantment e = CardDB.getEnchantmentFromCardID("CS2_038e");
e.creator = hc.entity;
e.controllerOfCreator = this.ownController;
addEffectToMinionNoDoubles(m, e, false);
}
}
if (target == 100)
{
if (frozen) this.ownHeroFrozen = true;
if (damage >= 1) attackOrHealHero(damage, true);
if (heal >= 1) attackOrHealHero(-heal, true);
}
if (target == 200)
{
if (frozen) this.enemyHeroFrozen = true;
if (damage >= 1) attackOrHealHero(damage, false);
if (heal >= 1) attackOrHealHero(-heal, false);
}
}
private void playCardWithoutTarget(Handmanager.Handcard hc, int choice)
{
CardDB.Card c = hc.card;
//todo faehrtenlesen!
//play card without target
if (c.name == "thecoin")
{
this.mana++;
}
//hunter#########################################################################
if (c.name == "multi-shot" && this.enemyMinions.Count >= 2)
{
List<Minion> temp = new List<Minion>();
int damage = getSpellDamageDamage(3);
List<Minion> temp2 = new List<Minion>(this.enemyMinions);
temp2.Sort((a, b) => -a.Hp.CompareTo(b.Hp));//damage the strongest
temp.AddRange(Helpfunctions.TakeList(temp2, 2));
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, damage, 0, false);
}
}
if (c.name == "animalcompanion")
{
CardDB.Card c2 = CardDB.Instance.getCardData("misha");
int placeoffather = this.ownMinions.Count - 1;
callKid(c2, placeoffather, true);
}
if (c.name == "flare")
{
foreach (Minion m in this.ownMinions)
{
m.stealth = false;
}
foreach (Minion m in this.enemyMinions)
{
m.stealth = false;
}
//this.owncarddraw++;
drawACard("", true);
this.enemySecretCount = 0;
}
if (c.name == "unleashthehounds")
{
int anz = this.enemyMinions.Count;
int posi = this.ownMinions.Count - 1;
CardDB.Card kid = CardDB.Instance.getCardData("hound");
for (int i = 0; i < anz; i++)
{
callKid(kid, posi, true);
}
}
if (c.name == "deadlyshot" && this.enemyMinions.Count >= 1)
{
List<Minion> temp = new List<Minion>();
List<Minion> temp2 = new List<Minion>(this.enemyMinions);
temp2.Sort((a, b) => a.Angr.CompareTo(b.Angr));
temp.AddRange(Helpfunctions.TakeList(temp2, 1));
foreach (Minion enemy in temp)
{
minionGetDestroyed(enemy, false);
}
}
//warrior#########################################################################
if (c.name == "commandingshout")
{
List<Minion> temp = new List<Minion>(this.ownMinions);
Enchantment e1 = CardDB.getEnchantmentFromCardID("NEW1_036e");
e1.creator = hc.entity;
e1.controllerOfCreator = this.ownController;
Enchantment e2 = CardDB.getEnchantmentFromCardID("NEW1_036e2");
e2.creator = hc.entity;
e2.controllerOfCreator = this.ownController;
foreach (Minion mnn in temp)
{//cantLowerHPbelowONE
addEffectToMinionNoDoubles(mnn, e1, true);
addEffectToMinionNoDoubles(mnn, e2, true);
mnn.cantLowerHPbelowONE = true;
}
}
if (c.name == "battlerage")
{
foreach (Minion mnn in this.ownMinions)
{
if (mnn.wounded)
{
//this.owncarddraw++;
drawACard("", true);
}
}
}
if (c.name == "brawl")
{
List<Minion> temp = new List<Minion>(this.ownMinions);
foreach (Minion mnn in temp)
{
minionGetDestroyed(mnn, true);
}
temp.Clear();
temp.AddRange(this.enemyMinions);
foreach (Minion mnn in temp)
{
minionGetDestroyed(mnn,false);
}
}
if (c.name == "cleave" && this.enemyMinions.Count >= 2)
{
List<Minion> temp = new List<Minion>();
int damage = getSpellDamageDamage(2);
List<Minion> temp2 = new List<Minion>(this.enemyMinions);
temp2.Sort((a, b) => -a.Hp.CompareTo(b.Hp));
temp.AddRange(Helpfunctions.TakeList(temp2, 2));
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, damage, 0, false);
}
}
if (c.name == "upgrade")
{
if (this.ownWeaponName != "")
{
this.ownWeaponAttack++;
this.ownheroAngr++;
this.ownWeaponDurability++;
}
else
{
CardDB.Card wcard = CardDB.Instance.getCardData("heavyaxe");
this.equipWeapon(wcard);
}
}
if (c.name == "whirlwind")
{
List<Minion> temp = new List<Minion>(this.enemyMinions);
int damage = getSpellDamageDamage(1);
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, damage, 0, false);
}
temp.Clear();
temp = new List<Minion>(this.ownMinions);
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, damage, 0, true);
}
}
if (c.name == "heroicstrike")
{
this.ownheroAngr = this.ownheroAngr + 4;
if ((this.ownHeroNumAttackThisTurn == 0 || (this.ownHeroWindfury && this.ownHeroNumAttackThisTurn == 1)) && !this.ownHeroFrozen)
{
this.ownHeroReady = true;
}
}
if (c.name == "shieldblock")
{
this.ownHeroDefence = this.ownHeroDefence + 5;
//this.owncarddraw++;
drawACard("", true);
}
//mage#########################################################################################
if (c.name == "blizzard")
{
int damage = getSpellDamageDamage(2);
List<Minion> temp = new List<Minion>(this.enemyMinions);
int maxHp = 0;
foreach (Minion enemy in temp)
{
enemy.frozen = true;
if (maxHp < enemy.Hp) maxHp = enemy.Hp;
minionGetDamagedOrHealed(enemy, damage, 0, false, true);
}
this.lostDamage += Math.Max(0, damage - maxHp);
}
if (c.name == "arcanemissiles")
{
/*List<Minion> temp = new List<Minion>(this.enemyMinions);
temp.Sort((a, b) => -a.Hp.CompareTo(b.Hp));
int damage = 1;
int ammount = getSpellDamageDamage(3);
int i = 0;
int hp = 0;
foreach (Minion enemy in temp)
{
if (enemy.Hp >= 2)
{
minionGetDamagedOrHealed(enemy, damage, 0, false);
i++;
hp += enemy.Hp;
if (i == ammount) break;
}
}
if (i < ammount) attackOrHealHero(ammount - i, false);*/
int damage = 1;
int i = 0;
List<Minion> temp = new List<Minion>(this.enemyMinions);
int times = this.getSpellDamageDamage(3);
while (i < times)
{
if (temp.Count >= 1)
{
temp.Sort((a, b) => -a.Hp.CompareTo(b.Hp));
if (temp[0].Hp == 1 && this.enemyHeroHp >= 2)
{
attackOrHealHero(damage, false);
}
else
{
minionGetDamagedOrHealed(temp[0], damage, 0, false);
}
}
else
{
attackOrHealHero(damage, false);
}
i++;
}
}
if (c.name == "arcaneintellect")
{
//this.owncarddraw++;
drawACard("", true);
drawACard("", true);
}
if (c.name == "mirrorimage")
{
int posi = this.ownMinions.Count - 1;
CardDB.Card kid = CardDB.Instance.getCardDataFromID("CS2_mirror");
callKid(kid, posi, true);
callKid(kid, posi, true);
}
if (c.name == "arcaneexplosion")
{
List<Minion> temp = new List<Minion>(this.enemyMinions);
int damage = getSpellDamageDamage(1);
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, damage, 0, false);
}
}
if (c.name == "frostnova")
{
List<Minion> temp = new List<Minion>(this.enemyMinions);
foreach (Minion enemy in temp)
{
enemy.frozen = true;
}
}
if (c.name == "flamestrike")
{
List<Minion> temp = new List<Minion>(this.enemyMinions);
int damage = getSpellDamageDamage(4);
int maxHp = 0;
foreach (Minion enemy in temp)
{
if (maxHp < enemy.Hp) maxHp = enemy.Hp;
minionGetDamagedOrHealed(enemy, damage, 0, false, true);
}
this.lostDamage += Math.Max(0, damage - maxHp);
}
//pala#################################################################
if (c.name == "consecration")
{
List<Minion> temp = new List<Minion>(this.enemyMinions);
int damage = getSpellDamageDamage(2);
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, damage, 0, false);
}
attackOrHealHero(damage, false);
}
if (c.name == "equality")
{
foreach (Minion m in this.ownMinions)
{
m.Hp = 1;
m.maxHp = 1;
}
foreach (Minion m in this.enemyMinions)
{
m.Hp = 1;
m.maxHp = 1;
}
}
if (c.name == "divinefavor")
{
int enemcardsanz = this.enemyAnzCards + this.enemycarddraw;
int diff = enemcardsanz - this.owncards.Count;
if (diff >= 1)
{
for (int i = 0; i < diff; i++)
{
//this.owncarddraw++;
drawACard("", true);
}
}
}
if (c.name == "avengingwrath")
{
int damage = 1;
int i = 0;
List<Minion> temp = new List<Minion>(this.enemyMinions);
int times = this.getSpellDamageDamage(8);
while (i < times)
{
if (temp.Count >= 1)
{
temp.Sort((a, b) => -a.Hp.CompareTo(b.Hp));
if (temp[0].Hp == 1 && this.enemyHeroHp >= 2)
{
attackOrHealHero(damage, false);
}
else
{
minionGetDamagedOrHealed(temp[0], damage, 0, false);
}
}
else
{
attackOrHealHero(damage, false);
}
i++;
}
}
//priest ####################################################
if (c.name == "circleofhealing")
{
List<Minion> temp = new List<Minion>(this.enemyMinions);
int heal = getSpellHeal(4);
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, 0, heal, false);
}
temp.Clear();
temp.AddRange(this.ownMinions);
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, 0, heal, true);
}
}
if (c.name == "thoughtsteal")
{
//this.owncarddraw++;
this.drawACard("enemycard",true);
//this.owncarddraw++;
this.drawACard("enemycard",true);
}
if (c.name == "mindvision")
{
if (this.enemyAnzCards+this.enemycarddraw >= 1)
{
//this.owncarddraw++;
this.drawACard("enemycard",true);
}
}
if (c.name == "shadowform")
{
if (this.ownHeroAblility.CardID == "CS1h_001") // lesser heal becomes mind spike
{
this.ownHeroAblility = CardDB.Instance.getCardDataFromID("EX1_625t");
this.ownAbilityReady = true;
}
else
{
this.ownHeroAblility = CardDB.Instance.getCardDataFromID("EX1_625t2"); // mindspike becomes mind shatter
this.ownAbilityReady = true;
}
}
if (c.name == "mindgames")
{
CardDB.Card copymin = CardDB.Instance.getCardDataFromID("CS2_152"); //we draw a knappe :D (worst case)
callKid(copymin, this.ownMinions.Count - 1, true);
}
if (c.name == "massdispel")
{
foreach (Minion m in this.enemyMinions)
{
minionGetSilenced(m, false);
}
}
if (c.name == "mindblast")
{
int damage = getSpellDamageDamage(5);
attackOrHealHero(damage, false);
}
if (c.name == "holynova")
{
List<Minion> temp = new List<Minion>(this.ownMinions);
int heal = getSpellHeal(2);
int damage = getSpellDamageDamage(2);
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, 0, heal,true,true);
}
attackOrHealHero(-heal, true);
temp.Clear();
temp.AddRange(this.enemyMinions);
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, damage, 0, false,true);
}
attackOrHealHero(damage, false);
}
//rogue #################################################
if (c.name == "preparation")
{
this.playedPreparation = true;
}
if (c.name == "bladeflurry")
{
List<Minion> temp = new List<Minion>(this.enemyMinions);
int damage = this.getSpellDamageDamage(this.ownWeaponAttack);
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, damage, 0, false);
}
attackOrHealHero(damage, false);
//destroy own weapon
this.lowerWeaponDurability(1000, true);
}
if (c.name == "headcrack")
{
int damage = getSpellDamageDamage(2);
attackOrHealHero(damage, false);
if (this.cardsPlayedThisTurn >= 1) this.owncarddraw++; // DONT DRAW A CARD WITH (drawAcard()) because we get this NEXT turn
}
if (c.name == "sinisterstrike")
{
int damage = getSpellDamageDamage(3);
attackOrHealHero(damage, false);
}
if (c.name == "deadlypoison")
{
if (this.ownWeaponName != "")
{
this.ownWeaponAttack += 2;
this.ownheroAngr += 2;
}
}
if (c.name == "fanofknives")
{
List<Minion> temp = new List<Minion>(this.enemyMinions);
int damage = getSpellDamageDamage(1);
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, damage, 0, false);
}
drawACard("", true);
}
if (c.name == "sprint")
{
for (int i = 0; i < 4; i++)
{
//this.owncarddraw++;
drawACard("", true);
}
}
if (c.name == "vanish")
{
List<Minion> temp = new List<Minion>(this.enemyMinions);
int heal = getSpellHeal(4);
foreach (Minion enemy in temp)
{
minionReturnToHand(enemy, false, 0);
}
temp.Clear();
temp.AddRange(this.ownMinions);
foreach (Minion enemy in temp)
{
minionReturnToHand(enemy, true, 0);
}
}
//shaman #################################################
if (c.name == "forkedlightning" && this.enemyMinions.Count >= 2)
{
List<Minion> temp = new List<Minion>();
int damage = getSpellDamageDamage(2);
List<Minion> temp2 = new List<Minion>(this.enemyMinions);
temp2.Sort((a, b) => -a.Hp.CompareTo(b.Hp));
temp.AddRange(Helpfunctions.TakeList(temp2, 2));
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, damage, 0, false);
}
}
if (c.name == "farsight")
{
//this.owncarddraw++;
drawACard("", true);
}
if (c.name == "lightningstorm")
{
List<Minion> temp = new List<Minion>(this.enemyMinions);
int damage = getSpellDamageDamage(2);
int maxHp = 0;
foreach (Minion enemy in temp)
{
if (maxHp < enemy.Hp) maxHp = enemy.Hp;
minionGetDamagedOrHealed(enemy, damage, 0, false,true);
}
this.lostDamage += Math.Max(0, damage - maxHp);
}
if (c.name == "feralspirit")
{
int posi = this.ownMinions.Count - 1;
CardDB.Card kid = CardDB.Instance.getCardData("spiritwolf");
callKid(kid, posi, true);
callKid(kid, posi, true);
}
if (c.name == "totemicmight")
{
List<Minion> temp = new List<Minion>(this.ownMinions);
foreach (Minion m in temp)
{
if (m.handcard.card.race == 21) // if minion is a totem, buff it
{
minionGetBuffed(m, 0, 2, true);
}
}
}
if (c.name == "bloodlust")
{
List<Minion> temp = new List<Minion>(this.ownMinions);
foreach (Minion m in temp)
{
Enchantment e = CardDB.getEnchantmentFromCardID("CS2_046e");
e.creator = this.ownController;
e.controllerOfCreator = this.ownController;
addEffectToMinionNoDoubles(m, e, true);
}
}
//hexenmeister #################################################
if (c.name == "sensedemons")
{
//this.owncarddraw += 2;
this.drawACard("", true);
this.drawACard("", true);
}
if (c.name == "twistingnether")
{
List<Minion> temp = new List<Minion>(this.enemyMinions);
foreach (Minion enemy in temp)
{
minionGetDestroyed(enemy, false);
}
temp.Clear();
temp.AddRange(this.ownMinions);
foreach (Minion enemy in temp)
{
minionGetDestroyed(enemy, true);
}
}
if (c.name == "hellfire")
{
List<Minion> temp = new List<Minion>(this.enemyMinions);
int damage = getSpellDamageDamage(3);
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, damage, 0, false);
}
temp.Clear();
temp.AddRange(this.ownMinions);
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, damage, 0, true);
}
attackOrHealHero(damage, true);
attackOrHealHero(damage, false);
}
//druid #################################################
if (c.name == "souloftheforest")
{
List<Minion> temp = new List<Minion>(this.ownMinions);
Enchantment e = CardDB.getEnchantmentFromCardID("EX1_158e");
e.creator = hc.entity;
e.controllerOfCreator = this.ownController;
foreach (Minion enemy in temp)
{
addEffectToMinionNoDoubles(enemy, e, true);
}
}
if (c.name == "innervate")
{
this.mana = Math.Min(this.mana + 2 ,10);
}
if (c.name == "bite")
{
this.ownheroAngr += 4;
this.ownHeroDefence += 4;
if ((this.ownHeroNumAttackThisTurn == 0 || (this.ownHeroWindfury && this.ownHeroNumAttackThisTurn == 1)) && !this.ownHeroFrozen)
{
this.ownHeroReady = true;
}
}
if (c.name == "claw")
{
this.ownheroAngr += 2;
this.ownHeroDefence += 2;
if ((this.ownHeroNumAttackThisTurn == 0 || (this.ownHeroWindfury && this.ownHeroNumAttackThisTurn == 1)) && !this.ownHeroFrozen)
{
this.ownHeroReady = true;
}
}
if (c.name == "forceofnature")
{
int posi = this.ownMinions.Count - 1;
CardDB.Card kid = CardDB.Instance.getCardDataFromID("EX1_tk9");//Treant
callKid(kid, posi, true);
callKid(kid, posi, true);
callKid(kid, posi, true);
}
if (c.name == "powerofthewild")// macht der wildnis with summoning
{
if (choice == 1)
{
foreach (Minion m in this.ownMinions)
{
minionGetBuffed(m, 1, 1, true);
}
}
if (choice == 2)
{
int posi = this.ownMinions.Count - 1;
CardDB.Card kid = CardDB.Instance.getCardDataFromID("EX1_160t");//panther
callKid(kid, posi, true);
}
}
if (c.name == "starfall")
{
if (choice == 2)
{
List<Minion> temp = new List<Minion>(this.enemyMinions);
int damage = getSpellDamageDamage(2);
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, damage, 0, false);
}
}
}
if (c.name == "nourish")
{
if (choice == 1)
{
if (this.ownMaxMana == 10)
{
//this.owncarddraw++;
this.drawACard("excessmana",true);
}
else
{
this.ownMaxMana++;
this.mana++;
}
if (this.ownMaxMana == 10)
{
//this.owncarddraw++;
this.drawACard("excessmana",true);
}
else
{
this.ownMaxMana++;
this.mana++;
}
}
if (choice == 2)
{
//this.owncarddraw+=3;
this.drawACard("", true);
this.drawACard("", true);
this.drawACard("", true);
}
}
if (c.name == "savageroar")
{
List<Minion> temp = new List<Minion>(this.ownMinions);
Enchantment e = CardDB.getEnchantmentFromCardID("CS2_011o");
e.creator = hc.entity;
e.controllerOfCreator = this.ownController;
foreach (Minion m in temp)
{
addEffectToMinionNoDoubles(m, e, true);
}
this.ownheroAngr += 2;
}
//special cards#######################
if (c.CardID == "PRO_001a")// i am murloc
{
int posi = this.ownMinions.Count - 1;
CardDB.Card kid = CardDB.Instance.getCardDataFromID("PRO_001at");//panther
callKid(kid, posi, true);
callKid(kid, posi, true);
callKid(kid, posi, true);
}
if (c.CardID == "PRO_001c")// i am murloc
{
int posi = this.ownMinions.Count - 1;
CardDB.Card kid = CardDB.Instance.getCardDataFromID("EX1_021");//scharfseher
callKid(kid, posi, true);
}
if (c.name == "wildgrowth")
{
if (this.ownMaxMana == 10)
{
//this.owncarddraw++;
this.drawACard("excessmana",true);
}
else
{
this.ownMaxMana++;
}
}
if (c.name == "excessmana")
{
//this.owncarddraw++;
this.drawACard("", true);
}
if (c.name == "yseraawakens")
{
List<Minion> temp = new List<Minion>(this.enemyMinions);
int damage = getSpellDamageDamage(5);
foreach (Minion enemy in temp)
{
if (enemy.name != "ysera")// dont attack ysera
{
minionGetDamagedOrHealed(enemy, damage, 0, false);
}
}
temp.Clear();
temp.AddRange(this.ownMinions);
foreach (Minion enemy in temp)
{
if (enemy.name != "ysera")//dont attack ysera
{
minionGetDamagedOrHealed(enemy, damage, 0, false);
}
}
attackOrHealHero(damage, true);
attackOrHealHero(damage, false);
}
if (c.name == "stomp")
{
List<Minion> temp = new List<Minion>(this.enemyMinions);
int damage = getSpellDamageDamage(2);
foreach (Minion enemy in temp)
{
minionGetDamagedOrHealed(enemy, damage, 0, false);
}
}
//NaxxCards###################################################################################
if (c.name == "poisonseeds")
{
int ownanz= this.ownMinions.Count;
int enemanz = this.enemyMinions.Count;
foreach (Minion mnn in this.ownMinions)
{
minionGetDestroyed(mnn, true);
}
foreach (Minion mnn in this.enemyMinions)
{
minionGetDestroyed(mnn, false);
}
for (int i = 0; i < ownanz; i++)
{
CardDB.Card d = CardDB.Instance.getCardDataFromID("EX1_158t");
callKid(d, 0, true);
}
for (int i = 0; i < enemanz; i++)
{
CardDB.Card d = CardDB.Instance.getCardDataFromID("EX1_158t");
callKid(d, 0, false);
}
}
}
private Action placeAmobSomewhere(Handmanager.Handcard hc, int cardpos, int target, int choice, int placepos)
{
Action a = new Action();
a.cardplay = true;
//a.card = new CardDB.Card(c);
a.numEnemysBeforePlayed = this.enemyMinions.Count;
a.comboBeforePlayed = (this.cardsPlayedThisTurn >= 1) ? true : false;
//we place him on the right!
int mobplace = placepos;
//create the minion out of the card + effects from other minions, which higher his hp/angr
// but before additional minions span next to it! (because we buff the minion in createNewMinion and swordofjustice gives summeond minons his buff first!
int spawnkids = spawnKids(hc.card, mobplace-1, true, choice); // if a mob targets something, it doesnt spawn minions!?
//create the new minion
Minion m = createNewMinion(hc, mobplace, true);
//do the battlecry (where you dont need a target)
doBattleCryWithoutTargeting(m, mobplace, true, choice);
if (target >= 0)
{
doBattleCryWithTargeting(m, target, choice);
}
addMiniontoList(m, this.ownMinions, mobplace, true);
if (logging) Helpfunctions.Instance.logg("added " + m.handcard.card.name);
//only for fun :D
if (target >= 0)
{
// the OWNtargets right of the placed mobs are going up :D
if (target < 10 && target > mobplace + spawnkids) target++;
}
a.enemytarget = target;
a.owntarget = mobplace + 1; //1==before the 1.minion on board , 2 ==before the 2. minion o board (from left)
return a;
}
private Minion createNewMinion(Handmanager.Handcard hc, int placeOfNewMob, bool own)
{
Minion m = new Minion();
m.handcard = new Handmanager.Handcard(hc);
m.entitiyID = hc.entity;
m.Posix = 0;
m.Posiy = 0;
m.Angr = hc.card.Attack;
m.Hp = hc.card.Health;
m.maxHp = hc.card.Health;
m.name = hc.card.name;
m.playedThisTurn = true;
m.numAttacksThisTurn = 0;
m.id = placeOfNewMob;
m.zonepos = placeOfNewMob + 1;
if (hc.card.windfury) m.windfury = true;
if (hc.card.tank) m.taunt = true;
if (hc.card.Charge)
{
m.Ready = true;
m.charge = true;
}
if (hc.card.Shield) m.divineshild = true;
if (hc.card.poisionous) m.poisonous = true;
if (hc.card.Stealth) m.stealth = true;
if (m.name == "lightspawn" && !m.silenced)
{
m.Angr = m.Hp;
}
this.getNewEffects(m, own, placeOfNewMob,true);
return m;
}
public void removeCard(Handmanager.Handcard hcc)
{
this.owncards.RemoveAll(x => x.entity == hcc.entity);
int i = 1;
foreach (Handmanager.Handcard hc in this.owncards)
{
hc.position = i;
i++;
}
}
public void playCard(Handmanager.Handcard hc, int cardpos, int cardEntity, int target, int targetEntity, int choice, int placepos, int penality)
{
CardDB.Card c = hc.card;
this.evaluatePenality += penality;
// lock at frostnova (click) / frostblitz (no click)
this.mana = this.mana - hc.getManaCost(this);
removeCard(hc);// remove card
if (c.Secret)
{
this.ownSecretsIDList.Add(c.CardID);
this.playedmagierinderkirintor = false;
}
if (c.type == CardDB.cardtype.SPELL) this.playedPreparation = false;
//Helpfunctions.Instance.logg("play crd " + c.name + " entitiy# " + cardEntity + " mana " + hc.getManaCost(this) + " trgt " + target);
if (logging) Helpfunctions.Instance.logg("play crd " + c.name + " entitiy# " + cardEntity + " mana " + hc.getManaCost(this) + " trgt " + target);
if (c.type == CardDB.cardtype.MOB)
{
Action b = this.placeAmobSomewhere(hc, cardpos, target, choice,placepos);
b.handcard = new Handmanager.Handcard(hc);
b.druidchoice = choice;
b.owntarget = placepos;
b.enemyEntitiy = targetEntity;
b.cardEntitiy = cardEntity;
this.playactions.Add(b);
this.mobsplayedThisTurn++;
if (c.name == "kirintormage") this.playedmagierinderkirintor = true;
}
else
{
Action a = new Action();
a.cardplay = true;
a.handcard = new Handmanager.Handcard(hc);
a.cardEntitiy = cardEntity;
a.numEnemysBeforePlayed = this.enemyMinions.Count;
a.comboBeforePlayed = (this.cardsPlayedThisTurn >= 1) ? true : false;
a.owntarget = 0;
if (target >= 0)
{
a.owntarget = -1;
}
a.enemytarget = target;
a.enemyEntitiy = targetEntity;
a.druidchoice = choice;
if (target == -1)
{
//card with no target
if (c.type == CardDB.cardtype.WEAPON)
{
equipWeapon(c);
}
playCardWithoutTarget(hc, choice);
}
else //before : if(target >=0 && target < 20)
{
if (c.type == CardDB.cardtype.WEAPON)
{
equipWeapon(c);
}
playCardWithTarget(hc, target, choice);
}
this.playactions.Add(a);
if (c.type == CardDB.cardtype.SPELL)
{
this.triggerPlayedASpell(c);
}
}
triggerACardGetPlayed(c);
this.ueberladung += c.recallValue;
this.cardsPlayedThisTurn++;
}
public Minion createNewMinion(Handmanager.Handcard hc, int zonepos, bool own)
{
Minion m = new Minion
{
handcard = new Handmanager.Handcard(hc),
zonepos = zonepos,
entityID = hc.entity,
Angr = hc.card.Attack,
Hp = hc.card.Health,
maxHp = hc.card.Health,
name = hc.card.name,
playedThisTurn = true,
numAttacksThisTurn = 0
};
m.own = own;
m.isHero = false;
m.entityID = hc.entity;
m.playedThisTurn = true;
m.numAttacksThisTurn = 0;
m.windfury = hc.card.windfury;
m.taunt = hc.card.tank;
m.charge = (hc.card.Charge) ? 1 : 0;
m.divineshild = hc.card.Shield;
m.poisonous = hc.card.poisionous;
m.stealth = hc.card.Stealth;
m.updateReadyness();
if (m.name == CardDB.cardName.lightspawn)
{
m.Angr = m.Hp;
}
return m;
}
//Spend all your Mana. Heal for double the mana you spent.
public override float getPlayPenalty(Playfield p, Handmanager.Handcard hc, Minion target, int choice, bool isLethal)
{
if (p.mana == 0) return 500;
else return 150 / p.mana;
}
public override float getPlayPenalty(Playfield p, Handmanager.Handcard hc, Minion target, int choice, bool isLethal)
{
if (p.ownMaxMana <= 8) return -20;
return 0;
}
public override float getPlayPenalty(Playfield p, Handmanager.Handcard hc, Minion target, int choice, bool isLethal)
{
int pen = 0;
if (p.ownMaxMana <= 6 && hc.card.name == CardDB.cardName.mysteriouschallenger && hc.getManaCost(p) <= 6) pen -= 10;
return pen;
}
private int getTauntBuffPenality(Handmanager.Handcard hcard, Minion target, Playfield p, int choice)
{
int pen = 0;
//buff enemy?
if (!this.tauntBuffDatabase.ContainsKey(hcard.card.name)) return 0;
if (hcard.card.name == CardDB.cardName.markofnature && choice != 2) return 0;
if (hcard.card.name == CardDB.cardName.darkwispers && choice != 1) return 0;
if (target == null) return 20;
if (!target.isHero && !target.own)
{
//allow it if you have black knight
foreach (Handmanager.Handcard hc in p.owncards)
{
if (hc.card.name == CardDB.cardName.theblackknight && (p.mana >= hcard.getManaCost(p) + hc.getManaCost(p))) return 0;
}
// allow taunting if target is priority and others have taunt
bool enemyhasTaunts = false;
foreach (Minion mnn in p.enemyMinions)
{
if (mnn.taunt)
{
enemyhasTaunts = true;
break;
}
}
if (enemyhasTaunts && this.priorityDatabase.ContainsKey(target.name) && !target.silenced && !target.taunt)
{
return 0;
}
pen = 500;
}
return pen;
}
public List<Action> doAllChoices(Playfield p, Handmanager.Handcard hc, bool lethalcheck, bool usePenalityManager)
{
List<Action> returnlist = new List<Action>();
if (hc.card.type == CardDB.cardtype.MOB && p.ownMinions.Count >= 7) return returnlist;
int max = 3;
if (hc.card.cardIDenum == CardDB.cardIDEnum.AT_132_SHAMAN) max = 5;
for (int i = 1; i < max; i++)
{
CardDB.Card c = hc.card;
if (c.cardIDenum == CardDB.cardIDEnum.AT_132_SHAMAN)
{
if (i == 1)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.AT_132_SHAMANa);
}
if (i == 2)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.AT_132_SHAMANb);
}
if (i == 3)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.AT_132_SHAMANc);
}
if (i == 4)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.AT_132_SHAMANd);
}
}
if (c.name == CardDB.cardName.darkwispers)
{
if (i == 1)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.GVG_041a);
}
if (i == 2)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.GVG_041b);
}
}
if (c.name == CardDB.cardName.keeperofthegrove)
{
if (i == 1)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_166a);
}
if (i == 2)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_166b);
}
}
if (c.name == CardDB.cardName.starfall)
{
if (i == 1)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.NEW1_007b);
}
if (i == 2)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.NEW1_007a);
}
}
if (c.name == CardDB.cardName.ancientoflore)
{
if (i == 1)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.NEW1_008a);
}
if (i == 2)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.NEW1_008b);
}
}
if (c.name == CardDB.cardName.powerofthewild)
{
if (i == 1)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_160b);
}
if (i == 2)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_160a);
}
}
if (c.name == CardDB.cardName.ancientofwar)
{
if (i == 1)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_178b);
}
if (i == 2)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_178a);
}
}
if (c.name == CardDB.cardName.druidoftheclaw)
{
if (i == 1)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_165t1);
}
if (i == 2)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_165t2);
}
}
if (c.name == CardDB.cardName.druidoftheflame)
{
if (i == 1)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.BRM_010t);
}
if (i == 2)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.BRM_010t2);
}
}
//cenarius dont need
if (c.name == CardDB.cardName.keeperofthegrove)//keeper of the grove
{
if (i == 1)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_166a);
}
if (i == 2)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_166b);
}
}
if (c.name == CardDB.cardName.markofnature)
{
if (i == 1)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_155a);
}
if (i == 2)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_155b);
}
}
if (c.name == CardDB.cardName.nourish)
{
if (i == 1)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_164a);
}
if (i == 2)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_164b);
}
}
if (c.name == CardDB.cardName.wrath)
{
if (i == 1)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_154a);
}
if (i == 2)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_154b);
}
}
if (c.name == CardDB.cardName.livingroots)
{
if (i == 1)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.AT_037a);
}
if (i == 2)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.AT_037b);
}
}
if (c.name == CardDB.cardName.druidofthesaber)
{
if (i == 1)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.AT_042a);
}
if (i == 2)
{
c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.AT_042b);
}
}
if (c.canplayCard(p, hc.manacost))
{
int bestplace = p.getBestPlace(c, lethalcheck);
List<Minion> trgts = c.getTargetsForCard(p);
int cardplayPenality = 0;
if (trgts.Count == 0)
{
if (usePenalityManager)
{
cardplayPenality = pen.getPlayCardPenality(hc, null, p, i, lethalcheck);
if (cardplayPenality <= 499)
{
//help.logg(hc.card.name + " is played");
//pf.playCard(hc, hc.position - 1, hc.entity, -1, -1, i, bestplace, cardplayPenality);
// i is the choice
Action a = new Action(actionEnum.playcard, hc, null, bestplace, null, cardplayPenality, i);
//pf.playCard(hc, hc.position - 1, hc.entity, -1, -1, 0, bestplace, cardplayPenality);
returnlist.Add(a);
}
}
else
{
//pf.playCard(hc, hc.position - 1, hc.entity, -1, -1, i, bestplace, cardplayPenality);
Action a = new Action(actionEnum.playcard, hc, null, bestplace, null, cardplayPenality, i);
returnlist.Add(a);
}
}
else
{
foreach (Minion trgt in trgts)
{
if (usePenalityManager)
{
cardplayPenality = pen.getPlayCardPenality(hc, trgt, p, i, lethalcheck);
if (cardplayPenality <= 499)
{
//help.logg(hc.card.name + " is played");
//pf.playCard(hc, hc.position - 1, hc.entity, trgt.target, trgt.targetEntity, i, bestplace, cardplayPenality);
Action a = new Action(actionEnum.playcard, hc, null, bestplace, trgt, cardplayPenality, i); //i is the choice
returnlist.Add(a);
}
}
else
{
//pf.playCard(hc, hc.position - 1, hc.entity, trgt.target, trgt.targetEntity, i, bestplace, cardplayPenality);
Action a = new Action(actionEnum.playcard, hc, null, bestplace, trgt, cardplayPenality, i); //i is the choice
returnlist.Add(a);
}
}
}
}
}
return returnlist;
}
