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 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 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;
}
private int getAttackBuffPenality(Handmanager.Handcard playhc, Minion target, Playfield p, int choice, bool lethal)
{
CardDB.Card card = playhc.card;
CardDB.cardName name = card.name;
if (name == CardDB.cardName.darkwispers && choice != 1) return 0;
if (!lethal && (card.name == CardDB.cardName.bolster))
{
int targets = 0;
foreach (Minion m in p.ownMinions)
{
if (m.taunt) targets++;
}
if (targets < 2)
{
return 10;
}
}
if (!lethal && (card.name == CardDB.cardName.savageroar || card.name == CardDB.cardName.bloodlust))
{
int pen = 0;
int targets = 0;
foreach (Minion m in p.ownMinions)
{
if (m.Ready) targets++;
}
if ((p.ownHero.Ready || p.ownHero.numAttacksThisTurn == 0) && card.name == CardDB.cardName.savageroar) targets++;
if (targets <= 3)
{
pen += 20;
}
return pen + (5 - p.enemyMinions.Count) * 10;
}
if (!this.attackBuffDatabase.ContainsKey(name)) return 0;
if (target == null)
{
//if ((p.ownMaxMana <= 2 && (p.enemyHeroName == HeroEnum.mage || p.enemyHeroName == HeroEnum.hunter)))
// return 10;
if (card.type == CardDB.cardtype.MOB)
{
if (card.name == CardDB.cardName.metaltoothleaper && p.ownMinions.Find(mech => mech.handcard.card.race == TAG_RACE.MECHANICAL) != null) return 0;
return 4 * attackBuffDatabase[name];
}
return 60;
}
if (!target.isHero && !target.own)
{
if (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 && target.Angr <= 6 && p.mana >= (hc.getManaCost(p) + playhc.getManaCost(p))) return 5;
if (hc.card.name == CardDB.cardName.shadowworddeath && target.Angr <= 4 && p.mana >= (hc.getManaCost(p) + playhc.getManaCost(p))) return 5;
}
if (card.name == CardDB.cardName.crueltaskmaster || card.name == CardDB.cardName.innerrage)
{
Minion m = target;
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 && p.mana >= (hc.getManaCost(p) + playhc.getManaCost(p))) return 0;
}
}
return 30;
}
else
{
return 500;
}
}
if (!target.isHero && target.own)
{
Minion m = target;
bool hasownready = false;
//vs mage or hunter we need board presence at early game? so we skip the minion ready-check.
// for everyone else, we penalize buffing minions when they are not ready
if (p.ownMaxMana > 2 || (p.enemyHeroName != HeroEnum.mage && p.enemyHeroName != HeroEnum.hunter))
{
if (card.name == CardDB.cardName.clockworkknight || card.name == CardDB.cardName.screwjankclunker)
{
// hasownready can only apply to mechs
hasownready = p.ownMinions.Find(mnn => mnn.handcard.card.race == TAG_RACE.MECHANICAL && mnn.Ready) != null;
}
else
{
foreach (Minion mnn in p.ownMinions)
{
if (mnn.Ready)
{
hasownready = true;
break;
}
}
}
}
if (!m.Ready && !m.taunt && hasownready)
{
if (this.buffing1TurnDatabase.ContainsKey(name)) return 50;
return 5 * attackBuffDatabase[name];
}
if (m.Hp == 1 && !m.divineshild && !this.buffing1TurnDatabase.ContainsKey(name))
{
if (this.healthBuffDatabase.ContainsKey(name)) return 0; // m.Hp no longer == 1
if (card.type == CardDB.cardtype.MOB) return 2 * attackBuffDatabase[name] + 1; // only 1pt worse than playing vanilla minion with same stats and no atk buff
return 10;
}
if (card.name == CardDB.cardName.blessingofmight) return 6;
}
if (target.own && name == CardDB.cardName.rockbiterweapon)
{
return 10;
}
return 0;
}
private int getSpecialCardComboPenalitys(Handmanager.Handcard playedhcard, Minion target, Playfield p, bool lethal, int choice)
{
CardDB.Card card = playedhcard.card;
CardDB.cardName name = card.name;
if (lethal && card.type == CardDB.cardtype.MOB)
{
if (this.lethalHelpers.ContainsKey(name))
{
return 0;
}
if (this.DamageTargetDatabase.ContainsKey(name) || this.DamageAllDatabase.ContainsKey(name) )
{
return 0;
}
if (this.buffingMinionsDatabase.ContainsKey(name))
{
if (name == CardDB.cardName.timberwolf || name == CardDB.cardName.houndmaster)
{
int beasts = 0;
foreach (Minion mm in p.ownMinions)
{
if (mm.Ready && (TAG_RACE)mm.handcard.card.race == TAG_RACE.PET) beasts++;
}
if (beasts == 0) return 500;
}
if (name == CardDB.cardName.warsongcommander)
{
int beasts = 0;
foreach (Minion mm in p.ownMinions)
{
if (mm.charge>=1) beasts++;
}
if (beasts == 0) return 500;
}
if (name == CardDB.cardName.southseacaptain)
{
int beasts = 0;
foreach (Minion mm in p.ownMinions)
{
if (mm.Ready && (TAG_RACE)mm.handcard.card.race == TAG_RACE.PIRATE) beasts++;
}
if (beasts == 0) return 500;
}
if (name == CardDB.cardName.murlocwarleader || name == CardDB.cardName.grimscaleoracle || name == CardDB.cardName.coldlightseer)
{
int beasts = 0;
foreach (Minion mm in p.ownMinions)
{
if (mm.Ready && (TAG_RACE)mm.handcard.card.race == TAG_RACE.MURLOC) beasts++;
}
if (beasts == 0) return 500;
}
if (name == CardDB.cardName.warhorsetrainer)
{
int beasts = 0;
foreach (Minion mm in p.ownMinions)
{
if (mm.Ready && mm.name == CardDB.cardName.silverhandrecruit) beasts++;
}
if (beasts == 0) return 500;
}
if (name == CardDB.cardName.malganis)
{
int beasts = 0;
foreach (Minion mm in p.ownMinions)
{
if (mm.Ready && mm.handcard.card.race == TAG_RACE.DEMON) beasts++;
}
if (beasts == 0) return 500;
}
}
else
{
if (name == CardDB.cardName.theblackknight)
{
int beasts = 0;
foreach (Minion mm in p.enemyMinions)
{
if (mm.taunt) beasts++;
}
if (beasts == 0) return 500;
}
else
{
if ((this.HealTargetDatabase.ContainsKey(name) || this.HealHeroDatabase.ContainsKey(name) || this.HealAllDatabase.ContainsKey(name)))
{
int beasts = 0;
foreach (Minion mm in p.ownMinions)
{
if (mm.Ready && mm.handcard.card.name == CardDB.cardName.lightwarden) beasts++;
}
if (beasts == 0) return 500;
}
else
{
//ignore that minion if it does not have charge, or we can give him charge ---> warsong was deleted ;_;
if (!(name == CardDB.cardName.nightblade || card.Charge || this.silenceDatabase.ContainsKey(name) || ((TAG_RACE)card.race == TAG_RACE.PET && p.ownMinions.Find(x => x.name == CardDB.cardName.tundrarhino) != null) || p.owncards.Find(x => x.card.name == CardDB.cardName.charge) != null))
{
return 500;
}
}
}
}
}
//lethal end########################################################
//bonus for early thread
if (p.ownMaxMana == 1 )
{
//if (card.name == CardDB.cardName.nerubianegg) return -10;
if (card.name == CardDB.cardName.lepergnome) return -10;
if (card.name == CardDB.cardName.faeriedragon) return -20;
if (card.name == CardDB.cardName.shrinkmeister) return 0;
if (card.Attack >= 3 && card.Health >= 2) return -20;
if (card.name == CardDB.cardName.wildgrowth) return -150;
}
if (p.ownMaxMana == 2)
{
if (card.name == CardDB.cardName.nerubianegg) return -15;
}
/*if (card.name == CardDB.cardName.flamewaker && p.turnCounter == 0)
{
int number =0;
foreach (Action a in p.playactions)
{
if (a.card!=null && a.card.card.type == CardDB.cardtype.SPELL) number++;
}
return number * 10;
}*/
//if (card.name == CardDB.cardName.unstableportal && p.owncards.Count <= 9) return -15;
if (card.name == CardDB.cardName.daggermastery)
{
if (p.ownWeaponAttack >= 2 || p.ownWeaponDurability >= 2) return 5;
}
if (card.name == CardDB.cardName.upgrade)
{
if (p.ownWeaponDurability == 0)
{
return 16;
}
}
if (card.name == CardDB.cardName.baronrivendare)
{
foreach (Minion mnn in p.ownMinions)
{
if (mnn.name == CardDB.cardName.deathlord || mnn.name == CardDB.cardName.zombiechow || mnn.name == CardDB.cardName.dancingswords) return 30;
}
}
//rule for coin on early game
if (p.ownMaxMana < 3 && card.name == CardDB.cardName.thecoin)
{
foreach (Handmanager.Handcard hc in p.owncards)
{
if (hc.card.type == CardDB.cardtype.MOB && hc.canplayCard(p)) return 5;
}
}
// spare parts need a base penalty so the bot does not waste them
// TODO: move this a better location, and break reversing switch into atk buff and hp buff components
if (name == CardDB.cardName.finickycloakfield || name == CardDB.cardName.emergencycoolant || name == CardDB.cardName.reversingswitch)
return 20;
if (name == CardDB.cardName.flare)
{
if (p.enemyHeroName != HeroEnum.hunter && p.enemyHeroName != HeroEnum.mage && p.enemyHeroName != HeroEnum.pala) return 0;
//it is a hunter/mage or pala:
if (p.enemySecretCount == 0) return 50;
if (p.enemySecretCount >= 1 && p.playactions.Count == 0) return -10;
}
//some effects, which are bad :D
int pen = 0;
if (name == CardDB.cardName.houndmaster)
{
if (target == null) return 50;
}
if ((card.name == CardDB.cardName.biggamehunter) && (target == null || target.own))
{
return 40;
}
if (name == CardDB.cardName.aldorpeacekeeper && target == null)
{
return 30;
}
if (name == CardDB.cardName.sylvanaswindrunner && p.enemyMinions.Count == 0)
{
return 50;
}
if (name == CardDB.cardName.cabalshadowpriest && target == null)
{
return 40;
}
if (name == CardDB.cardName.emergencycoolant && target != null && target.own)//dont freeze own minions
{
return 500;
}
if (name == CardDB.cardName.shatteredsuncleric && target == null) { pen = 10; }
if (name == CardDB.cardName.argentprotector)
{
if (target == null) { return 20; }
else
{
if (!target.own) { return 500; }
if (target.divineshild) { return 15; }
if (!target.Ready && !target.handcard.card.isSpecialMinion) { return 10; }
if (!target.Ready && !target.handcard.card.isSpecialMinion && target.Angr <= 2 && target.Hp <= 2) { return 15; }
}
}
if (name == CardDB.cardName.facelessmanipulator)
{
if (target == null)
{
return 50;
}
if (target.Angr >= 5 || target.handcard.card.cost >= 5 || (target.handcard.card.rarity == 5 && target.handcard.card.cost >= 3))
{
return 0;
}
return 49;
}
if (name == CardDB.cardName.ancientofwar)
{
if (p.enemyMinions.Count > 0 && choice == 1) return 200;
if (p.enemyMinions.Count == 0 && choice == 2) return 50;
}
if (name == CardDB.cardName.druidoftheflame)
{
if (p.enemyMinions.Count > 0 && choice == 2) return 40;
if (p.enemyMinions.Count == 0 && choice == 1) return 40;
}
if (name == CardDB.cardName.gangup && target!=null)
{
if(target.handcard.card.isToken) return 20;
if (target.handcard.card.isSpecialMinion) return -20;
}
if (name == CardDB.cardName.theblackknight)
{
if (target == null)
{
return 50;
}
foreach (Minion mnn in p.enemyMinions)
{
if (mnn.taunt && (target.Angr >= 3 || target.Hp >= 3)) return 0;
}
return 20;
}
//------------------------------------------------------------------------------------------------------
Minion m = target;
if (card.name == CardDB.cardName.reincarnate)
{
if (m.own)
{
if (m.handcard.card.deathrattle || m.ancestralspirit >= 1 || m.souloftheforest >= 1 || m.enemyBlessingOfWisdom >= 1 || m.explorersHat >=1) return 0;
if (m.handcard.card.Charge && ((m.numAttacksThisTurn == 1 && !m.windfury) || (m.numAttacksThisTurn == 2 && m.windfury))) return 0;
if (m.wounded || m.Angr < m.handcard.card.Attack || (m.silenced && PenalityManager.instance.specialMinions.ContainsKey(m.name))) return 0;
bool hasOnMinionDiesMinion = false;
foreach (Minion mnn in p.ownMinions)
{
if (mnn.name == CardDB.cardName.scavenginghyena && m.handcard.card.race == TAG_RACE.PET) hasOnMinionDiesMinion = true;
if (mnn.name == CardDB.cardName.flesheatingghoul || mnn.name == CardDB.cardName.cultmaster) hasOnMinionDiesMinion = true;
}
if (hasOnMinionDiesMinion) return 0;
return 500;
}
else
{
if (m.name == CardDB.cardName.nerubianegg && m.Angr <= 4 && !m.taunt) return 500;
if (m.taunt && !m.handcard.card.tank) return 0;
if (m.enemyBlessingOfWisdom >= 1) return 0;
if (m.Angr > m.handcard.card.Attack || m.Hp > m.handcard.card.Health) return 0;
if (m.name == CardDB.cardName.abomination || m.name == CardDB.cardName.zombiechow || m.name == CardDB.cardName.unstableghoul || m.name == CardDB.cardName.dancingswords) return 0;
return 500;
}
}
if (name == CardDB.cardName.madbomber || name == CardDB.cardName.madderbomber)
{
//penalize for any own minions with health equal to potential attack amount
//to lessen risk of losing your own minion
int maxAtk = 3;
if (name == CardDB.cardName.madderbomber) maxAtk = 6;
if (maxAtk >= p.ownHero.Hp && maxAtk < p.enemyHero.Hp) return 500;//we could be killed, but not enemy >_< .. otherwise YOLO
foreach (Minion mnn in p.ownMinions)
{
if (mnn.Hp <= maxAtk)
{
if (mnn.Ready) pen += 20;
}
}
/*
int numTargets = 2 + p.ownMinions.Count + p.enemyMinions.Count;
int numOwnTargets = 1 + p.ownMinions.Count;
int numEnemyTargets = numTargets-numOwnTargets;
double dmgpertarget = ((double)maxAtk)/((double)numTargets);
foreach (Minion mnn in p.ownMinions)
{
if (mnn.Hp <= dmgpertarget)
{
pen += 10;
}
}
*/
}
if (name == CardDB.cardName.mechwarper)
{
List<Handmanager.Handcard> mechCards = p.owncards.FindAll(hc => hc != playedhcard && hc.card.race == TAG_RACE.MECHANICAL);
mechCards.Sort((a, b) => a.getManaCost(p).CompareTo(b.getManaCost(p))); // increasing mana cost
int maxMechsNextTurnWithoutWarper = 0, maxMechsNextTurnWithWarper = 0;
int manaNextTurnWithoutWarper = p.ownMaxMana + 1, manaNextTurnWithWarper = p.ownMaxMana + 1;
for (int i = 0; i < mechCards.Count; i++)
{
int cost = mechCards[i].getManaCost(p);
if (manaNextTurnWithoutWarper > cost)
{
maxMechsNextTurnWithoutWarper++;
manaNextTurnWithoutWarper -= cost;
}
if (manaNextTurnWithWarper > (cost - 1))
{
maxMechsNextTurnWithWarper++;
manaNextTurnWithWarper -= (cost - 1);
}
}
return -3*(maxMechsNextTurnWithWarper - maxMechsNextTurnWithoutWarper); // +1 mana in savings per additional mech
}
if (name == CardDB.cardName.goblinblastmage)
{
bool mechOnField = false;
foreach (Minion mnn in p.ownMinions)
{
if (mnn.handcard.card.race == TAG_RACE.MECHANICAL)
{
mechOnField = true;
break;
}
}
if (!mechOnField) // penalize if we can play a mech this turn
{
int lowestCostMechInHand = 1000;
foreach (Handmanager.Handcard hc in p.owncards)
{
if (hc.card.race == TAG_RACE.MECHANICAL && hc.getManaCost(p) < lowestCostMechInHand) lowestCostMechInHand = hc.getManaCost(p);
}
if (p.mana >= (playedhcard.getManaCost(p) + lowestCostMechInHand)) return 50;
if (p.mana >= lowestCostMechInHand) return 20;
return 0;
}
else // penalize for randomness of battlecry
{
bool hasNerubianEgg = false;
foreach (Minion mnn in p.enemyMinions)
{
if (mnn.handcard.card.name == CardDB.cardName.nerubianegg && !m.silenced && m.Hp <= 2)
{
hasNerubianEgg = true;
break;
}
}
// less minions = less randomness to penalize, but more minions = less chance to kill egg, so egg penalty is constant
return (hasNerubianEgg ? 10 : p.enemyMinions.Count);
}
}
if (card.name == CardDB.cardName.knifejuggler && (p.mobsplayedThisTurn > 1 || ((p.ownHeroName == HeroEnum.shaman || p.ownHeroName == HeroEnum.pala) && p.ownAbilityReady == false)))
{
return 20;
}
if (card.name == CardDB.cardName.flametonguetotem && p.ownMinions.Count == 0)
{
return 100;
}
if (card.name == CardDB.cardName.stampedingkodo)
{
bool found = false;
foreach (Minion mi in p.enemyMinions)
{
if (mi.Angr <= 2) found = true;
}
if (!found) return 20;
}
if (name == CardDB.cardName.windfury)
{
if (!m.own) return 500;
if (m.own && !m.Ready) return 500;
}
if ((name == CardDB.cardName.wildgrowth || name == CardDB.cardName.nourish) && p.ownMaxMana == 9 && !(p.ownHeroName == HeroEnum.thief && p.cardsPlayedThisTurn == 0))
{
return 500;
}
if (name == CardDB.cardName.ancestralspirit)
{
if (!target.own && !target.isHero)
{
if (m.name == CardDB.cardName.deathlord || m.name == CardDB.cardName.zombiechow || m.name == CardDB.cardName.dancingswords) return 0;
return 500;
}
if (target.own && !target.isHero)
{
if (this.specialMinions.ContainsKey(m.name)) return -5;
return 0;
}
}
if (name == CardDB.cardName.sylvanaswindrunner)
{
if (p.enemyMinions.Count == 0)
{
return 10;
}
}
if (name == CardDB.cardName.betrayal && !target.own && !target.isHero)
{
if (m.Angr == 0) return 30;
if (p.enemyMinions.Count == 1) return 30;
}
if (name == CardDB.cardName.bite)
{
if ((p.ownHero.numAttacksThisTurn == 0 || (p.ownHero.windfury && p.ownHero.numAttacksThisTurn == 1)) && !p.ownHero.frozen)
{
return 0;
}
else
{
return 20;
}
}
if (name == CardDB.cardName.deadlypoison)
{
return -p.ownWeaponDurability * 2;
}
if (name == CardDB.cardName.shadydealer)
{
bool haspirate = false;
foreach (Minion mnn in p.ownMinions)
{
if (mnn.handcard.card.race == TAG_RACE.PIRATE)
{
haspirate = true;
break;
}
}
if (haspirate) return 0;
else return 10;
}
if (name == CardDB.cardName.coldblood)
{
if (lethal) return 0;
return 25;
}
if (name == CardDB.cardName.bloodmagethalnos)
{
return 10;
}
if (name == CardDB.cardName.frostbolt)
{
if (!target.own && !target.isHero)
{
if (m.handcard.card.cost <= 2)
return 15;
}
return 8;
}
if (!lethal && choice == 1 && name == CardDB.cardName.druidoftheclaw)
{
return 20;
}
if (name == CardDB.cardName.poweroverwhelming)
{
if (target.own && !target.isHero && !m.Ready)
{
if (target.name == CardDB.cardName.voidcaller) return 50;
if (target.name == CardDB.cardName.sylvanaswindrunner) return 100;
return 500;
}
}
if (name == CardDB.cardName.frothingberserker)
{
if (p.cardsPlayedThisTurn >= 1) return 5;
}
if (name == CardDB.cardName.handofprotection)
{
if (m.Hp == 1) return 15;
}
if (lethal)
{
if (name == CardDB.cardName.corruption)
{
int beasts = 0;
foreach (Minion mm in p.ownMinions)
{
if (mm.Ready && (mm.handcard.card.name == CardDB.cardName.questingadventurer || mm.handcard.card.name == CardDB.cardName.archmageantonidas || mm.handcard.card.name == CardDB.cardName.manaaddict || mm.handcard.card.name == CardDB.cardName.manawyrm || mm.handcard.card.name == CardDB.cardName.wildpyromancer)) beasts++;
}
if (beasts == 0) return 500;
}
}
if (name == CardDB.cardName.divinespirit)
{
if (lethal)
{
if (!target.own && !target.isHero)
{
if (!m.taunt)
{
return 500;
}
else
{
// combo for killing with innerfire and biggamehunter
if (p.owncards.Find(x => x.card.name == CardDB.cardName.biggamehunter) != null && p.owncards.Find(x => x.card.name == CardDB.cardName.innerfire) != null && (m.Hp >= 4 || (p.owncards.Find(x => x.card.name == CardDB.cardName.divinespirit) != null && m.Hp >= 2)))
{
return 0;
}
return 500;
}
}
}
else
{
if (!target.own && !target.isHero)
{
// combo for killing with innerfire and biggamehunter
if (p.owncards.Find(x => x.card.name == CardDB.cardName.biggamehunter) != null && p.owncards.Find(x => x.card.name == CardDB.cardName.innerfire) != null && m.Hp >= 4)
{
return 0;
}
return 500;
}
}
if (target.own && !target.isHero)
{
if (m.Hp >= 4)
{
return 0;
}
return 15;
}
}
if ((name == CardDB.cardName.polymorph || name == CardDB.cardName.hex))
{
if (target.own && !target.isHero)
{
return 500;
}
if (!target.own && !target.isHero)
{
int hexpen = 10; // base penalty so we don't waste the spell on small minions
if (target.allreadyAttacked) hexpen += 30;
Minion frog = target;
if (!frog.silenced && this.priorityTargets.ContainsKey(frog.name) && this.priorityTargets[frog.name] >= 5) return hexpen;
if (frog.Angr >= 4 && frog.Hp >= 4) return 0; // no base penalty because minion is not small
if (frog.Angr >= 4 && !frog.silenced && this.silenceTargets.ContainsKey(frog.name)) return hexpen+5;
return hexpen+30;
}
}
if ((name == CardDB.cardName.defenderofargus || name == CardDB.cardName.sunfuryprotector) && p.ownMinions.Count == 1)
{
return 40;
}
if ((name == CardDB.cardName.defenderofargus || name == CardDB.cardName.sunfuryprotector) && p.ownMinions.Count == 0)
{
return 50;
}
if (name == CardDB.cardName.unleashthehounds)
{
if (p.enemyMinions.Count <= 1)
{
return 20;
}
}
if (name == CardDB.cardName.equality) // aoe penality
{
int hpdestroyed = 0;
foreach (Minion mini in p.enemyMinions)
{
hpdestroyed += (mini.Hp - 1);
}
if (p.enemyMinions.Count <= 2 || hpdestroyed <= 4)
{
return 20;
}
}
if (name == CardDB.cardName.bloodsailraider && p.ownWeaponDurability == 0)
{
//if you have bloodsailraider and no weapon equiped, but own a weapon:
foreach (Handmanager.Handcard hc in p.owncards)
{
if (hc.card.type == CardDB.cardtype.WEAPON) return 10;
}
}
if (name == CardDB.cardName.innerfire)
{
if (m.name == CardDB.cardName.lightspawn) return 500;
}
if (name == CardDB.cardName.huntersmark)
{
if (target.own && !target.isHero) return 500; // dont use on own minions
if (!target.own && !target.isHero && (target.Hp <= 4) && target.Angr <= 4) // only use on strong minions
{
return 20;
}
}
if ((name == CardDB.cardName.aldorpeacekeeper || name == CardDB.cardName.humility))
{
if (target != null)
{
if (target.own) pen = 500; // dont use on own minions
if (!target.own && target.Angr <= 3) // only use on strong minions
{
return 30;
}
if (m.name == CardDB.cardName.lightspawn) pen = 500;
}
else
{
return 50;
}
}
if (name == CardDB.cardName.defiasringleader && p.cardsPlayedThisTurn == 0)
{ pen = 10; }
if (name == CardDB.cardName.bloodknight)
{
int shilds = 0;
foreach (Minion min in p.ownMinions)
{
if (min.divineshild)
{
shilds++;
}
}
foreach (Minion min in p.enemyMinions)
{
if (min.divineshild)
{
shilds++;
}
}
if (shilds == 0)
{
return 10;
}
}
if (name == CardDB.cardName.direwolfalpha)
{
int ready = 0;
foreach (Minion min in p.ownMinions)
{
if (min.Ready)
{ ready++; }
}
if (ready == 0)
{ return 5; }
}
if (name == CardDB.cardName.abusivesergeant)
{
int ready = 0;
foreach (Minion min in p.ownMinions)
{
if (min.Ready)
{ ready++; }
}
if (ready == 0)
{
return 5;
}
}
if (p.turnCounter >= 1 && name == CardDB.cardName.reversingswitch && target.Angr == target.Hp) return 500;
return pen;
}
private int getPlayInspirePenalty(Handmanager.Handcard playhc, Playfield p)
{
// Penalize for playing Inspire minions without Inspire effect
CardDB.Card card = playhc.card;
CardDB.cardName name = card.name;
if (!this.strongInspireEffectMinions.ContainsKey(name)) return 0;
// check already used hero power
if (p.playactions.Find(a => a.actionType == actionEnum.useHeroPower) != null)
return 1 + (5 * strongInspireEffectMinions[name]);
int ownplaycost = playhc.getManaCost(p);
int heropowercost = p.ownHeroAblility.card.getManaCost(p, 2);
// check not enough mana to gain Inspire buff
if (p.mana < ownplaycost + heropowercost) return 2 * strongInspireEffectMinions[name];
return 0;
}
//play a minion trigger stuff:
// 1 whenever you play a card whatever triggers
// 2 Auras
// 5 whenever you summon a minion triggers (like starving buzzard)
// 3 battlecry
// 3.5 place minion
// 3.75 dmg/died/dthrttl triggers
// 4 secret: minion is played
// 4.5 dmg/died/dthrttl triggers
// 5 after you summon a minion triggers
// 5.5 dmg/died/dthrttl triggers
public void playACard(Handmanager.Handcard hc, Minion target, int position, int choice, int penality)
{
CardDB.Card c = hc.card;
this.evaluatePenality += penality;
this.mana = this.mana - hc.getManaCost(this);
removeCard(hc);// remove card from hand
if (c.type == CardDB.cardtype.SPELL) this.playedPreparation = false;
if (c.Secret)
{
this.ownSecretsIDList.Add(c.cardIDenum);
this.playedmagierinderkirintor = 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# " + hc.entity + " mana " + hc.getManaCost(this) + " trgt " + target);
this.triggerACardWillBePlayed(c, true);
if (c.type == CardDB.cardtype.MOB)
{
this.placeAmobSomewhere(hc, target, choice, position);
this.mobsplayedThisTurn++;
}
else
{
c.sim_card.onCardPlay(this, true, target, choice);
this.doDmgTriggers();
//secret trigger? do here
}
//atm only 2 cards trigger this
if (c.type == CardDB.cardtype.SPELL)
{
this.triggerACardWasPlayed(c, true);
this.doDmgTriggers();
}
//this.ueberladung += c.recallValue;
this.cardsPlayedThisTurn++;
}
//play a minion trigger stuff:
// 1 whenever you play a card whatever triggers
// 2 Auras
// 5 whenever you summon a minion triggers (like starving buzzard)
// 3 battlecry
// 3.5 place minion
// 3.75 dmg/died/dthrttl triggers
// 4 secret: minion is played
// 4.5 dmg/died/dthrttl triggers
// 5 after you summon a minion triggers
// 5.5 dmg/died/dthrttl triggers
public void playACard(Handmanager.Handcard hc, Minion target, int position, int choice, int penality)
{
CardDB.Card c = hc.card;
this.evaluatePenality += penality;
this.mana = this.mana - hc.getManaCost(this);
removeCard(hc);// remove card from hand
this.triggerCardsChanged(true);
if (c.type == CardDB.cardtype.SPELL)
{
this.playedPreparation = false;
}
if (c.race == 24) //dragon
{
this.ownDragonConsort = 0;
}
if (c.Secret)
{
this.ownSecretsIDList.Add(c.cardIDenum);
this.playedmagierinderkirintor = 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# " + hc.entity + " mana " + hc.getManaCost(this) + " trgt " + target);
this.triggerACardWillBePlayed(hc, true, target);
int newTarget = secretTrigger_SpellIsPlayed(target, c.type == CardDB.cardtype.SPELL);
if (newTarget >= 1)
{
//search new target!
foreach (Minion m in this.ownMinions)
{
if (m.entitiyID == newTarget)
{
target = m;
break;
}
}
foreach (Minion m in this.enemyMinions)
{
if (m.entitiyID == newTarget)
{
target = m;
break;
}
}
if (this.ownHero.entitiyID == newTarget) target = this.ownHero;
if (this.enemyHero.entitiyID == newTarget) target = this.enemyHero;
}
if (newTarget != -2) // trigger spell-secrets!
{
if (c.type == CardDB.cardtype.MOB)
{
this.placeAmobSomewhere(hc, target, choice, position);
this.mobsplayedThisTurn++;
}
else
{
c.sim_card.onCardPlay(this, true, target, choice);
this.doDmgTriggers();
//secret trigger? do here
}
//atm only 2 cards trigger this
if (c.type == CardDB.cardtype.SPELL)
{
this.triggerACardWasPlayed(c, true);
this.doDmgTriggers();
}
}
//this.ueberladung += c.recallValue;
this.cardsPlayedThisTurn++;
}
