public void cuttingposibilities(int maxwide)
{
// take the x best values
List <Playfield> temp = new List <Playfield>();
Dictionary <Int64, Playfield> tempDict = new Dictionary <Int64, Playfield>();
posmoves.Sort((a, b) => - (botBase.getPlayfieldValue(a)).CompareTo(botBase.getPlayfieldValue(b)));//want to keep the best
if (this.useComparison)
{
int i = 0;
int max = Math.Min(posmoves.Count, maxwide);
Playfield p = null;
//foreach (Playfield p in posmoves)
for (i = 0; i < max; i++)
{
p = posmoves[i];
Int64 hash = p.GetPHash();
p.hashcode = hash;
if (!tempDict.ContainsKey(hash))
{
tempDict.Add(hash, p);
}
}
foreach (KeyValuePair <Int64, Playfield> d in tempDict)
{
temp.Add(d.Value);
}
}
else
{
temp.AddRange(posmoves);
}
posmoves.Clear();
posmoves.AddRange(temp.GetRange(0, Math.Min(maxwide, temp.Count)));
}
public void simmulateWholeTurn(Playfield board)
{
help.ErrorLog("########################################################################################################");
help.ErrorLog("simulate board " + this.mainTurnSimulator.boardindexToSimulate);
help.ErrorLog("########################################################################################################");
//this.bestboard.printActions();
Playfield tempbestboard = new Playfield();
tempbestboard.value = botBase.getPlayfieldValue(tempbestboard);
tempbestboard.printBoard();
foreach (Action bestmovee in board.playactions)
{
help.logg("stepp");
if (bestmovee != null && bestmovee.actionType != actionEnum.endturn) // save the guessed move, so we doesnt need to recalc!
{
bestmovee.print();
tempbestboard.doAction(bestmovee);
}
else
{
tempbestboard.mana = -100;
}
help.logg("-------------");
tempbestboard.value = botBase.getPlayfieldValue(tempbestboard);
tempbestboard.printBoard();
}
//help.logg("AFTER ENEMY TURN:" );
tempbestboard.sEnemTurn = true;
tempbestboard.endTurn(false, this.playaround, false, Settings.Instance.playaroundprob, Settings.Instance.playaroundprob2);
help.logg("ENEMY TURN:-----------------------------");
tempbestboard.value = botBase.getPlayfieldValue(tempbestboard);
tempbestboard.prepareNextTurn(tempbestboard.isOwnTurn);
Ai.Instance.enemyTurnSim[0].simulateEnemysTurn(tempbestboard, true, playaround, true, Settings.Instance.playaroundprob, Settings.Instance.playaroundprob2);
}
private void startEnemyTurnSimThread(List <Playfield> source, int startIndex, int endIndex)
{
int threadnumber = 0;
lock (threadnumberLocker)
{
threadnumber = threadnumberGlobal++;
System.Threading.Monitor.Pulse(threadnumberLocker);
}
if (threadnumber > Ai.Instance.maxNumberOfThreads - 2)
{
threadnumber = Ai.Instance.maxNumberOfThreads - 2;
Helpfunctions.Instance.ErrorLog("You need more threads!");
return;
}
int berserk = Settings.Instance.berserkIfCanFinishNextTour;
int printRules = Settings.Instance.printRules;
for (int i = startIndex; i < endIndex; i++)
{
Playfield p = source[i];
if (p.complete || p.ownHero.Hp <= 0)
{
}
else if (!enoughCalculations)
{
//gernerate actions and play them!
List <Action> actions = movegen.getMoveList(p, usePenaltyManager, useCutingTargets, true);
if (printRules > 0)
{
p.endTurnState = new Playfield(p);
}
foreach (Action a in actions)
{
Playfield pf = new Playfield(p);
pf.doAction(a);
pf.evaluatePenalty += -pf.ruleWeight + RulesEngine.Instance.getRuleWeight(pf);
if (pf.ownHero.Hp > 0 && pf.evaluatePenalty < 500)
{
p.nextPlayfields.Add(pf);
}
}
}
if (this.isLethalCheck)
{
if (berserk > 0)
{
p.endTurn();
if (p.enemyHero.Hp > 0)
{
bool needETS = true;
if (p.anzEnemyTaunt < 1)
{
foreach (Minion m in p.ownMinions)
{
if (m.Ready)
{
needETS = false; break;
}
}
}
else
{
if (p.anzOwnTaunt < 1)
{
foreach (Minion m in p.ownMinions)
{
if (m.Ready)
{
needETS = false; break;
}
}
}
}
if (needETS)
{
Ai.Instance.enemyTurnSim[threadnumber].simulateEnemysTurn(p, this.simulateSecondTurn, playaround, false, playaroundprob, playaroundprob2);
}
}
}
p.complete = true;
}
else
{
p.endTurn();
if (p.enemyHero.Hp > 0)
{
Ai.Instance.enemyTurnSim[threadnumber].simulateEnemysTurn(p, this.simulateSecondTurn, playaround, false, playaroundprob, playaroundprob2);
if (p.value <= -10000)
{
bool secondChance = false;
foreach (Action a in p.playactions)
{
if (a.actionType == actionEnum.playcard)
{
if (pen.cardDrawBattleCryDatabase.ContainsKey(a.card.card.name))
{
secondChance = true;
}
}
}
if (secondChance)
{
p.value += 1500;
}
}
}
p.complete = true;
}
botBase.getPlayfieldValue(p);
}
}
public float doallmoves(Playfield playf)
{
print = playf.print;
this.isLethalCheck = playf.isLethalCheck;
enoughCalculations = false;
botBase = Ai.Instance.botBase;
this.posmoves.Clear();
this.twoturnfields.Clear();
this.addToPosmoves(playf);
bool havedonesomething = true;
List <Playfield> temp = new List <Playfield>();
int deep = 0;
this.calculated = 0;
Playfield bestold = null;
bestoldval = -20000000;
while (havedonesomething)
{
if (this.printNormalstuff)
{
Helpfunctions.Instance.logg("ailoop");
}
GC.Collect();
temp.Clear();
temp.AddRange(this.posmoves);
this.posmoves.Clear();
havedonesomething = false;
threadnumberGlobal = 0;
if (print)
{
startEnemyTurnSimThread(temp, 0, temp.Count);
}
else
{
Parallel.ForEach(Partitioner.Create(0, temp.Count),
range =>
{
startEnemyTurnSimThread(temp, range.Item1, range.Item2);
});
}
foreach (Playfield p in temp)
{
if (this.totalboards > 0)
{
this.calculated += p.nextPlayfields.Count;
}
if (this.calculated <= this.totalboards)
{
this.posmoves.AddRange(p.nextPlayfields);
p.nextPlayfields.Clear();
}
//get the best Playfield
float pVal = botBase.getPlayfieldValue(p);
if (pVal > bestoldval)
{
bestoldval = pVal;
bestold = p;
bestoldDuplicates.Clear();
}
else if (pVal == bestoldval)
{
bestoldDuplicates.Add(p);
}
}
if (isLethalCheck && bestoldval >= 10000)
{
this.posmoves.Clear();
}
if (this.posmoves.Count > 0)
{
havedonesomething = true;
}
if (this.printNormalstuff)
{
int donec = 0;
foreach (Playfield p in posmoves)
{
if (p.complete)
{
donec++;
}
}
Helpfunctions.Instance.logg("deep " + deep + " len " + this.posmoves.Count + " dones " + donec);
}
cuttingposibilities(isLethalCheck);
if (this.printNormalstuff)
{
Helpfunctions.Instance.logg("cut to len " + this.posmoves.Count);
}
deep++;
temp.Clear();
if (this.calculated > this.totalboards)
{
enoughCalculations = true;
}
if (deep >= this.maxdeep)
{
enoughCalculations = true;
}
}
if (this.dirtyTwoTurnSim > 0 && !twoturnfields.Contains(bestold))
{
twoturnfields.Add(bestold);
}
this.posmoves.Clear();
this.posmoves.Add(bestold);
this.posmoves.AddRange(bestoldDuplicates);
// search the best play...........................................................
//do dirtytwoturnsim first :D
if (!isLethalCheck && bestoldval < 10000)
{
doDirtyTwoTurnsim();
}
if (posmoves.Count >= 1)
{
posmoves.Sort((a, b) => botBase.getPlayfieldValue(b).CompareTo(botBase.getPlayfieldValue(a)));
Playfield bestplay = posmoves[0];
float bestval = botBase.getPlayfieldValue(bestplay);
int pcount = posmoves.Count;
for (int i = 1; i < pcount; i++)
{
float val = botBase.getPlayfieldValue(posmoves[i]);
if (bestval > val)
{
break;
}
if (posmoves[i].cardsPlayedThisTurn > bestplay.cardsPlayedThisTurn)
{
continue;
}
else if (posmoves[i].cardsPlayedThisTurn == bestplay.cardsPlayedThisTurn)
{
if (bestplay.optionsPlayedThisTurn > posmoves[i].optionsPlayedThisTurn)
{
continue;
}
else if (bestplay.optionsPlayedThisTurn == posmoves[i].optionsPlayedThisTurn && bestplay.enemyHero.Hp <= posmoves[i].enemyHero.Hp)
{
continue;
}
}
bestplay = posmoves[i];
bestval = val;
}
this.bestmove = bestplay.getNextAction();
this.bestmoveValue = bestval;
this.bestboard = new Playfield(bestplay);
this.bestboard.guessingHeroHP = bestplay.guessingHeroHP;
this.bestboard.value = bestplay.value;
this.bestboard.hashcode = bestplay.hashcode;
bestoldDuplicates.Clear();
return(bestval);
}
this.bestmove = null;
this.bestmoveValue = -100000;
this.bestboard = playf;
return(-10000);
}
public float doallmoves(Playfield playf, bool isLethalCheck)
{
//Helpfunctions.Instance.logg("NXTTRN" + playf.mana);
if (botBase == null)
{
botBase = Ai.Instance.botBase;
}
bool test = false;
this.posmoves.Clear();
this.twoturnfields.Clear();
this.addToPosmoves(playf);
bool havedonesomething = true;
List <Playfield> temp = new List <Playfield>();
int deep = 0;
//Helpfunctions.Instance.logg("NXTTRN" + playf.mana + " " + posmoves.Count);
this.calculated = 0;
while (havedonesomething)
{
if (this.printNormalstuff)
{
Helpfunctions.Instance.logg("ailoop");
}
GC.Collect();
temp.Clear();
temp.AddRange(this.posmoves);
havedonesomething = false;
Playfield bestold = null;
float bestoldval = -20000000;
foreach (Playfield p in temp)
{
if (p.complete || p.ownHero.Hp <= 0)
{
continue;
}
//gernerate actions and play them!
List <Action> actions = movegen.getMoveList(p, isLethalCheck, usePenalityManager, useCutingTargets);
foreach (Action a in actions)
{
//if (deep == 0 && a.actionType == actionEnum.attackWithMinion) Helpfunctions.Instance.ErrorLog("play " + a.own.entitiyID + " -> " + a.target.entitiyID);
havedonesomething = true;
Playfield pf = new Playfield(p);
pf.doAction(a);
addToPosmoves(pf);
}
// end the turn of the current board (only if its not a lethalcheck)
if (isLethalCheck)
{
p.complete = true;
}
else
{
//end turn of enemy
p.endTurn(this.simulateSecondTurn, this.playaround, false, this.playaroundprob, this.playaroundprob2);
//simulate the enemys response
this.startEnemyTurnSim(p, this.simulateSecondTurn, false);
}
//sort stupid stuff ouf
if (botBase.getPlayfieldValue(p) > bestoldval)
{
bestoldval = botBase.getPlayfieldValue(p);
bestold = p;
}
if (!test)
{
posmoves.Remove(p);
}
if (this.calculated > this.totalboards)
{
break;
}
}
if (!test && bestoldval >= -10000 && bestold != null)
{
this.posmoves.Add(bestold);
}
//Helpfunctions.Instance.loggonoff(true);
if (this.printNormalstuff)
{
int donec = 0;
foreach (Playfield p in posmoves)
{
if (p.complete)
{
donec++;
}
}
Helpfunctions.Instance.logg("deep " + deep + " len " + this.posmoves.Count + " dones " + donec);
}
if (!test)
{
cuttingposibilities();
}
if (this.printNormalstuff)
{
Helpfunctions.Instance.logg("cut to len " + this.posmoves.Count);
}
//Helpfunctions.Instance.loggonoff(false);
deep++;
if (this.calculated > this.totalboards)
{
break;
}
if (deep >= this.maxdeep)
{
break; //remove this?
}
}
foreach (Playfield p in posmoves)//temp
{
if (!p.complete)
{
if (isLethalCheck)
{
p.complete = true;
}
else
{
p.endTurn(this.simulateSecondTurn, this.playaround, false, this.playaroundprob, this.playaroundprob2);
this.startEnemyTurnSim(p, this.simulateSecondTurn, false);
}
}
}
// search the best play...........................................................
//do dirtytwoturnsim first :D
if (!isLethalCheck)
{
doDirtyTwoTurnsim();
}
if (!isLethalCheck)
{
this.dirtyTwoTurnSim /= 2;
}
// Helpfunctions.Instance.logg("find best ");
if (posmoves.Count >= 1)
{
float bestval = int.MinValue;
int bestanzactions = 1000;
Playfield bestplay = posmoves[0]; //temp[0]
foreach (Playfield p in posmoves) //temp
{
float val = botBase.getPlayfieldValue(p);
if (bestval <= val)
{
if (bestval == val && bestanzactions < p.playactions.Count)
{
continue;
}
bestplay = p;
bestval = val;
bestanzactions = p.playactions.Count;
}
}
this.bestmove = bestplay.getNextAction();
this.bestmoveValue = bestval;
this.bestboard = new Playfield(bestplay);
//Helpfunctions.Instance.logg("return");
return(bestval);
}
//Helpfunctions.Instance.logg("return");
this.bestmove = null;
this.bestmoveValue = -100000;
this.bestboard = playf;
return(-10000);
}
public void simulateEnemysTurn(Playfield rootfield, bool simulateTwoTurns, bool playaround, bool print, int pprob, int pprob2)
{
if (botBase == null)
{
botBase = Ai.Instance.botBase;
}
bool havedonesomething = true;
posmoves.Clear();
if (print)
{
Helpfunctions.Instance.ErrorLog("board at enemyturn start-----------------------------");
rootfield.value = botBase.getPlayfieldValue(rootfield);
rootfield.printBoard();
}
posmoves.Add(new Playfield(rootfield));
//posmoves[0].prepareNextTurn(false);
List <Playfield> temp = new List <Playfield>();
int deep = 0;
int enemMana = rootfield.enemyMaxMana;
//get rid of cursed! ?
if (posmoves[0].anzEnemyCursed >= 1)
{
int curseds = posmoves[0].anzEnemyCursed;
for (int ii = curseds; ii > 0; ii--)
{
if (enemMana >= 2)
{
enemMana -= 2;
posmoves[0].anzEnemyCursed--;
}
}
}
if (print)
{
Console.WriteLine("enemMana " + enemMana);
}
//playing aoe-effects if activated (and we didnt play loatheb)
if (playaround && rootfield.anzOwnLoatheb == 0)
{
float oldval = botBase.getPlayfieldValueEnemy(posmoves[0]);
posmoves[0].value = int.MinValue;
enemMana = posmoves[0].EnemyCardPlaying(rootfield.enemyHeroName, enemMana, rootfield.enemyAnzCards, pprob, pprob2);
float newval = botBase.getPlayfieldValueEnemy(posmoves[0]);
posmoves[0].value = int.MinValue;
posmoves[0].enemyAnzCards--;
posmoves[0].triggerCardsChanged(false);
posmoves[0].mana = enemMana;
if (oldval < newval)
{
posmoves.Clear();
posmoves.Add(new Playfield(rootfield));
}
}
//play ability!
if (posmoves[0].enemyAbilityReady && enemMana >= 2 && posmoves[0].enemyHeroAblility.card.canplayCard(posmoves[0], 0) && rootfield.anzOwnSaboteur == 0)
{
int abilityPenality = 0;
havedonesomething = true;
// if we have mage or priest or hunter, we have to target something####################################################
if (penmanager.TargetAbilitysDatabase.ContainsKey(posmoves[0].enemyHeroAblility.card.cardIDenum))
{
List <Minion> trgts = posmoves[0].enemyHeroAblility.card.getTargetsForCard(posmoves[0], false, false);
foreach (Minion trgt in trgts)
{
if (trgt.isHero)
{
continue; //do play his ability in basics
}
Action a = new Action(actionEnum.useHeroPower, posmoves[0].enemyHeroAblility, null, 0, trgt, abilityPenality, 0);
Playfield pf = new Playfield(posmoves[0]);
pf.doAction(a);
posmoves.Add(pf);
}
}
else
{
bool hasinspire = false;
foreach (Minion minie in rootfield.enemyMinions)
{
if (minie.handcard.card.Inspire)
{
hasinspire = true;
}
}
// the other classes dont have to target####################################################
if ((rootfield.enemyHeroName == HeroEnum.thief && rootfield.enemyWeaponDurability == 0) || rootfield.enemyHeroName != HeroEnum.thief || hasinspire)
{
Action a = new Action(actionEnum.useHeroPower, posmoves[0].enemyHeroAblility, null, 0, null, abilityPenality, 0);
Playfield pf = new Playfield(posmoves[0]);
pf.doAction(a);
posmoves.Add(pf);
}
}
}
foreach (Minion m in posmoves[0].enemyMinions)
{
if (m.Angr == 0)
{
continue;
}
m.numAttacksThisTurn = 0;
m.playedThisTurn = false;
m.updateReadyness();
}
int boardcount = 0;
//movegen...
int i = 0;
int count = 0;
Playfield p = null;
Playfield bestold = null;
while (havedonesomething)
{
temp.Clear();
temp.AddRange(posmoves);
havedonesomething = false;
float bestoldval = int.MaxValue;
//foreach (Playfield p in temp)
count = temp.Count;
for (i = 0; i < count; i++)
{
p = temp[i];
if (p.complete)
{
continue;
}
List <Action> actions = movegen.getEnemyMoveList(p, false, true, true, 1);// 1 for not using ability moves
foreach (Action a in actions)
{
havedonesomething = true;
Playfield pf = new Playfield(p);
pf.doAction(a);
posmoves.Add(pf);
/*if (print)
* {
* a.print();
* }*/
boardcount++;
}
p.endEnemyTurn();
//p.guessingHeroHP = rootfield.guessingHeroHP;
if (botBase.getPlayfieldValueEnemy(p) < bestoldval) // want the best enemy-play-> worst for us
{
bestoldval = botBase.getPlayfieldValueEnemy(p);
bestold = p;
}
posmoves.Remove(p);
if (boardcount >= maxwide)
{
break;
}
}
if (bestoldval <= 10000 && bestold != null)
{
posmoves.Add(bestold);
}
cuttingPosibilitiesET();
deep++;
if (boardcount >= maxwide)
{
break;
}
}
//foreach (Playfield p in posmoves)
count = posmoves.Count;
for (i = 0; i < count; i++)
{
if (!posmoves[i].complete)
{
posmoves[i].endEnemyTurn();
}
}
float bestval = int.MaxValue;
Playfield bestplay = rootfield;// posmoves[0];
//foreach (Playfield p in posmoves)
count = posmoves.Count;
for (i = 0; i < count; i++)
{
p = posmoves[i];
//p.guessingHeroHP = rootfield.guessingHeroHP;
float val = botBase.getPlayfieldValueEnemy(p);
if (bestval > val)// we search the worst value
{
bestplay = p;
bestval = val;
}
/*if (print)
* {
* Helpfunctions.Instance.ErrorLog(""+val);
* p.printBoard();
* }*/
}
if (print)
{
Helpfunctions.Instance.ErrorLog("best enemy board----------------------------------");
bestplay.printBoard();
}
rootfield.value = bestplay.value;
if (simulateTwoTurns && bestplay.ownHero.Hp > 0 && bestplay.value > -1000)
{
bestplay.prepareNextTurn(true);
rootfield.value = Settings.Instance.firstweight * bestval + Settings.Instance.secondweight * Ai.Instance.nextTurnSimulator[this.thread].doallmoves(bestplay, false, print);
}
}
public float doallmoves(Playfield playf, bool isLethalCheck, bool print = false)
{
//todo only one time!
this.doEnemySecondTurn = Settings.Instance.simEnemySecondTurn;
int totalboards = Settings.Instance.nextTurnTotalBoards;
int maxwide = Settings.Instance.nextTurnMaxWide;
int maxdeep = Settings.Instance.nextTurnDeep;
bool playaround = Settings.Instance.playarround;
int playaroundprob = Settings.Instance.playaroundprob;
int playaroundprob2 = Settings.Instance.playaroundprob2;
//Helpfunctions.Instance.logg("NXTTRN" + playf.mana);
if (botBase == null)
{
botBase = Ai.Instance.botBase;
}
bool test = false;
this.posmoves.Clear();
this.addToPosmoves(playf, totalboards);
bool havedonesomething = true;
List <Playfield> temp = new List <Playfield>();
int deep = 0;
//Helpfunctions.Instance.logg("NXTTRN" + playf.mana + " " + posmoves.Count);
this.calculated = 0;
Playfield bestold = null;
while (havedonesomething)
{
//if (this.printNormalstuff) Helpfunctions.Instance.logg("ailoop");
//GC.Collect();
temp.Clear();
temp.AddRange(this.posmoves);
havedonesomething = false;
float bestoldval = -20000000;
foreach (Playfield p in temp)
{
if (p.complete || p.ownHero.Hp <= 0)
{
continue;
}
List <Action> actions = movegen.getMoveList(p, isLethalCheck, usePenalityManager, useCutingTargets);
foreach (Action a in actions)
{
havedonesomething = true;
Playfield pf = new Playfield(p);
pf.doAction(a);
addToPosmoves(pf, totalboards);
}
if (isLethalCheck)
{
p.complete = true;
}
else
{
p.sEnemTurn = this.doEnemySecondTurn;
p.endTurn(this.simulateSecondTurn, playaround, false, playaroundprob, playaroundprob2);
this.startEnemyTurnSim(p, this.simulateSecondTurn, false, playaround, playaroundprob, playaroundprob2);
}
//sort stupid stuff ouf
if (botBase.getPlayfieldValue(p) > bestoldval)
{
bestoldval = botBase.getPlayfieldValue(p);
bestold = p;
}
if (!test)
{
posmoves.Remove(p);
}
if (this.calculated > totalboards)
{
break;
}
}
if (!test && bestoldval >= -10000 && bestold != null)
{
this.posmoves.Add(bestold);
}
//Helpfunctions.Instance.loggonoff(true);
/*if (this.printNormalstuff)
* {
* int donec = 0;
* foreach (Playfield p in posmoves)
* {
* if (p.complete) donec++;
* }
* Helpfunctions.Instance.logg("deep " + deep + " len " + this.posmoves.Count + " dones " + donec);
* }*/
if (!test)
{
cuttingposibilities(maxwide);
}
//if (this.printNormalstuff) Helpfunctions.Instance.logg("cut to len " + this.posmoves.Count);
//Helpfunctions.Instance.loggonoff(false);
deep++;
if (this.calculated > totalboards)
{
break;
}
if (deep >= maxdeep)
{
break; //remove this?
}
}
foreach (Playfield p in posmoves)//temp
{
if (!p.complete)
{
if (isLethalCheck)
{
p.complete = true;
}
else
{
p.sEnemTurn = this.doEnemySecondTurn;
p.endTurn(this.simulateSecondTurn, playaround, false, playaroundprob, playaroundprob2);
this.startEnemyTurnSim(p, this.simulateSecondTurn, false, playaround, playaroundprob, playaroundprob2);
}
}
}
// Helpfunctions.Instance.logg("find best ");
if (posmoves.Count >= 1)
{
float bestval = int.MinValue;
int bestanzactions = 1000;
Playfield bestplay = posmoves[0]; //temp[0]
foreach (Playfield p in posmoves) //temp
{
float val = botBase.getPlayfieldValue(p);
if (bestval <= val)
{
if (bestval == val && bestanzactions < p.playactions.Count)
{
continue;
}
bestplay = p;
bestval = val;
bestanzactions = p.playactions.Count;
}
}
this.bestboard = new Playfield(bestplay);
if (print)
{
Helpfunctions.Instance.ErrorLog("best board after your second turn (value included enemy second turn)----------");
bestplay.printBoard();
bestplay.value = int.MinValue;
bestplay.sEnemTurn = this.doEnemySecondTurn;
Ai.Instance.enemySecondTurnSim[this.thread].simulateEnemysTurn(bestplay, false, playaround, false, playaroundprob, playaroundprob2);
//Ai.Instance.enemySecondTurnSim.simulateEnemysTurn(bestplay, false, false, true, 100, 100); //dont play arround in enemys second turn
}
this.bestmove = bestplay.getNextAction();
this.bestmoveValue = bestval;
this.bestboard = new Playfield(bestplay);
//Helpfunctions.Instance.logg("return");
return(bestval);
}
//Helpfunctions.Instance.logg("return");
this.bestmove = null;
this.bestmoveValue = -100000;
this.bestboard = playf;
return(-10000);
}
public float doallmoves(Playfield playf, bool print = false)
{
//todo only one time!
bool isLethalCheck = playf.isLethalCheck;
int totalboards = Settings.Instance.nextTurnTotalBoards;
int maxwide = Settings.Instance.nextTurnMaxWide;
int maxdeep = Settings.Instance.nextTurnDeep;
bool playaround = Settings.Instance.playaround;
int playaroundprob = Settings.Instance.playaroundprob;
int playaroundprob2 = Settings.Instance.playaroundprob2;
botBase = Ai.Instance.botBase;
this.posmoves.Clear();
this.posmoves.Add(new Playfield(playf));
bool havedonesomething = true;
List <Playfield> temp = new List <Playfield>();
int deep = 0;
this.calculated = 0;
Playfield bestold = null;
float bestoldval = -20000000;
while (havedonesomething)
{
//GC.Collect();
temp.Clear();
temp.AddRange(this.posmoves);
havedonesomething = false;
foreach (Playfield p in temp)
{
if (p.complete || p.ownHero.Hp <= 0)
{
continue;
}
List <Action> actions = movegen.getMoveList(p, usePenaltyManager, useCutingTargets, true);
foreach (Action a in actions)
{
havedonesomething = true;
Playfield pf = new Playfield(p);
pf.doAction(a);
if (pf.ownHero.Hp > 0)
{
this.posmoves.Add(pf);
}
if (totalboards > 0)
{
this.calculated++;
}
}
p.endTurn();
if (!isLethalCheck)
{
this.startEnemyTurnSim(p, this.simulateSecondTurn, false, playaround, playaroundprob, playaroundprob2);
}
//sort stupid stuff ouf
if (botBase.getPlayfieldValue(p) > bestoldval)
{
bestoldval = botBase.getPlayfieldValue(p);
bestold = p;
}
posmoves.Remove(p);
if (this.calculated > totalboards)
{
break;
}
}
cuttingposibilities(maxwide);
deep++;
if (this.calculated > totalboards)
{
break;
}
if (deep >= maxdeep)
{
break;
}
}
posmoves.Add(bestold);
foreach (Playfield p in posmoves)
{
if (!p.complete)
{
p.endTurn();
if (!isLethalCheck)
{
this.startEnemyTurnSim(p, this.simulateSecondTurn, false, playaround, playaroundprob, playaroundprob2);
}
}
}
// find best
if (posmoves.Count >= 1)
{
posmoves.Sort((a, b) => botBase.getPlayfieldValue(b).CompareTo(botBase.getPlayfieldValue(a)));
Playfield bestplay = posmoves[0];
float bestval = botBase.getPlayfieldValue(bestplay);
int pcount = posmoves.Count;
for (int i = 1; i < pcount; i++)
{
float val = botBase.getPlayfieldValue(posmoves[i]);
if (bestval > val)
{
break;
}
if (bestplay.playactions.Count <= posmoves[i].playactions.Count)
{
continue; //priority to the minimum acts
}
bestplay = posmoves[i];
bestval = val;
}
this.bestmove = bestplay.getNextAction();
this.bestmoveValue = bestval;
this.bestboard = new Playfield(bestplay);
return(bestval);
}
this.bestmove = null;
this.bestmoveValue = -100000;
this.bestboard = playf;
return(-10000);
}
public int doallmoves(Playfield playf, bool isLethalCheck)
{
//Helpfunctions.Instance.logg("NXTTRN" + playf.mana);
if (botBase == null)
{
botBase = Ai.Instance.botBase;
}
bool test = false;
this.posmoves.Clear();
this.addToPosmoves(playf);
bool havedonesomething = true;
List <Playfield> temp = new List <Playfield>();
int deep = 0;
//Helpfunctions.Instance.logg("NXTTRN" + playf.mana + " " + posmoves.Count);
this.calculated = 0;
while (havedonesomething)
{
if (this.printNormalstuff)
{
Helpfunctions.Instance.logg("ailoop");
}
GC.Collect();
temp.Clear();
temp.AddRange(this.posmoves);
havedonesomething = false;
Playfield bestold = null;
int bestoldval = -20000000;
foreach (Playfield p in temp)
{
if (p.complete || p.ownHeroHp <= 0)
{
continue;
}
//take a card and play it
List <CardDB.cardName> playedcards = new List <CardDB.cardName>();
foreach (Handmanager.Handcard hc in p.owncards)
{
if (this.calculated > this.totalboards)
{
continue;
}
CardDB.Card c = hc.card;
//help.logg("try play crd" + c.name + " " + c.getManaCost(p) + " " + c.canplayCard(p));
if (playedcards.Contains(c.name))
{
continue; // dont play the same card in one loop
}
playedcards.Add(c.name);
if (c.choice)
{
if (doAllChoices(p, hc, isLethalCheck))
{
havedonesomething = true;
}
}
else
{
int bestplace = p.getBestPlace(c, isLethalCheck);
if (hc.canplayCard(p))
{
havedonesomething = true;
List <targett> trgts = c.getTargetsForCard(p);
if (isLethalCheck && (pen.DamageTargetDatabase.ContainsKey(c.name) || pen.DamageTargetSpecialDatabase.ContainsKey(c.name)))// only target enemy hero during Lethal check!
{
targett trg = trgts.Find(x => x.target == 200);
if (trg != null)
{
trgts.Clear();
trgts.Add(trg);
}
else
{
// no enemy hero -> enemy have taunts ->kill the taunts from left to right
if (trgts.Count >= 1)
{
trg = trgts[0];
trgts.Clear();
trgts.Add(trg);
}
}
}
int cardplayPenality = 0;
if (trgts.Count == 0)
{
if (usePenalityManager)
{
cardplayPenality = pen.getPlayCardPenality(c, -1, p, 0, isLethalCheck);
if (cardplayPenality <= 499)
{
Playfield pf = new Playfield(p);
havedonesomething = true;
pf.playCard(hc, hc.position - 1, hc.entity, -1, -1, 0, bestplace, cardplayPenality);
addToPosmoves(pf);
}
}
else
{
Playfield pf = new Playfield(p);
havedonesomething = true;
pf.playCard(hc, hc.position - 1, hc.entity, -1, -1, 0, bestplace, cardplayPenality);
addToPosmoves(pf);
}
}
else
{
if (isLethalCheck)// only target enemy hero during Lethal check!
{
targett trg = trgts.Find(x => x.target == 200);
if (trg != null)
{
trgts.Clear();
trgts.Add(trg);
}
}
foreach (targett trgt in trgts)
{
if (usePenalityManager)
{
cardplayPenality = pen.getPlayCardPenality(c, trgt.target, p, 0, isLethalCheck);
if (cardplayPenality <= 499)
{
Playfield pf = new Playfield(p);
havedonesomething = true;
pf.playCard(hc, hc.position - 1, hc.entity, trgt.target, trgt.targetEntity, 0, bestplace, cardplayPenality);
addToPosmoves(pf);
}
}
else
{
Playfield pf = new Playfield(p);
havedonesomething = true;
pf.playCard(hc, hc.position - 1, hc.entity, trgt.target, trgt.targetEntity, 0, bestplace, cardplayPenality);
addToPosmoves(pf);
}
}
}
}
}
}
//attack with a minion
List <Minion> playedMinions = new List <Minion>(8);
foreach (Minion m in p.ownMinions)
{
if (this.calculated > this.totalboards)
{
continue;
}
if (m.Ready && m.Angr >= 1 && !m.frozen)
{
//BEGIN:cut (double/similar) attacking minions out#####################################
// DONT LET SIMMILAR MINIONS ATTACK IN ONE TURN (example 3 unlesh the hounds-hounds doesnt need to simulated hole)
List <Minion> tempoo = new List <Minion>(playedMinions);
bool dontattacked = true;
bool isSpecial = pen.specialMinions.ContainsKey(m.name);
foreach (Minion mnn in tempoo)
{
// special minions are allowed to attack in silended and unsilenced state!
//help.logg(mnn.silenced + " " + m.silenced + " " + mnn.name + " " + m.name + " " + penman.specialMinions.ContainsKey(m.name));
bool otherisSpecial = pen.specialMinions.ContainsKey(mnn.name);
if ((!isSpecial || (isSpecial && m.silenced)) && (!otherisSpecial || (otherisSpecial && mnn.silenced))) // both are not special, if they are the same, dont add
{
if (mnn.Angr == m.Angr && mnn.Hp == m.Hp && mnn.divineshild == m.divineshild && mnn.taunt == m.taunt && mnn.poisonous == m.poisonous)
{
dontattacked = false;
}
continue;
}
if (isSpecial == otherisSpecial && !m.silenced && !mnn.silenced) // same are special
{
if (m.name != mnn.name) // different name -> take it
{
continue;
}
// same name -> test whether they are equal
if (mnn.Angr == m.Angr && mnn.Hp == m.Hp && mnn.divineshild == m.divineshild && mnn.taunt == m.taunt && mnn.poisonous == m.poisonous)
{
dontattacked = false;
}
continue;
}
}
if (dontattacked)
{
playedMinions.Add(m);
}
else
{
//help.logg(m.name + " doesnt need to attack!");
continue;
}
//END: cut (double/similar) attacking minions out#####################################
//help.logg(m.name + " is going to attack!");
List <targett> trgts = p.getAttackTargets(true);
if (isLethalCheck)// only target enemy hero during Lethal check!
{
targett trg = trgts.Find(x => x.target == 200);
if (trg != null)
{
trgts.Clear();
trgts.Add(trg);
}
else
{
// no enemy hero -> enemy have taunts ->kill the taunts from left to right
if (trgts.Count >= 1)
{
trg = trgts[0];
trgts.Clear();
trgts.Add(trg);
}
}
}
else
{
if (this.useCutingTargets)
{
trgts = this.cutAttackTargets(trgts, p, true);
}
}
foreach (targett trgt in trgts)
{
int attackPenality = 0;
if (usePenalityManager)
{
attackPenality = pen.getAttackWithMininonPenality(m, p, trgt.target, isLethalCheck);
if (attackPenality <= 499)
{
Playfield pf = new Playfield(p);
havedonesomething = true;
pf.attackWithMinion(m, trgt.target, trgt.targetEntity, attackPenality);
addToPosmoves(pf);
}
}
else
{
Playfield pf = new Playfield(p);
havedonesomething = true;
pf.attackWithMinion(m, trgt.target, trgt.targetEntity, attackPenality);
addToPosmoves(pf);
}
}
if ((!m.stealth || isLethalCheck) && p.enemySecretCount == 0 && trgts.Count == 1 && trgts[0].target == 200) //only enemy hero is available als attack
{
break;
}
}
}
// attack with hero
if (p.ownHeroReady)
{
if (this.calculated > this.totalboards)
{
continue;
}
List <targett> trgts = p.getAttackTargets(true);
havedonesomething = true;
if (isLethalCheck)// only target enemy hero during Lethal check!
{
targett trg = trgts.Find(x => x.target == 200);
if (trg != null)
{
trgts.Clear();
trgts.Add(trg);
}
else
{
// no enemy hero -> enemy have taunts ->kill the taunts from left to right
if (trgts.Count >= 1)
{
trg = trgts[0];
trgts.Clear();
trgts.Add(trg);
}
}
}
else
{
if (this.useCutingTargets)
{
trgts = this.cutAttackTargets(trgts, p, true);
}
}
foreach (targett trgt in trgts)
{
Playfield pf = new Playfield(p);
int heroAttackPen = 0;
if (usePenalityManager)
{
heroAttackPen = pen.getAttackWithHeroPenality(trgt.target, p, isLethalCheck);
}
pf.attackWithWeapon(trgt.target, trgt.targetEntity, heroAttackPen);
addToPosmoves(pf);
}
}
// use ability
/// TODO check if ready after manaup
if (p.ownAbilityReady && p.mana >= 2 && p.ownHeroAblility.canplayCard(p, 2))
{
if (this.calculated > this.totalboards)
{
continue;
}
int abilityPenality = 0;
havedonesomething = true;
// if we have mage or priest, we have to target something####################################################
if (p.ownHeroName == HeroEnum.mage || p.ownHeroName == HeroEnum.priest)
{
List <targett> trgts = p.ownHeroAblility.getTargetsForCard(p);
if (isLethalCheck && (p.ownHeroName == HeroEnum.mage || (p.ownHeroName == HeroEnum.priest && (p.ownHeroAblility.name != CardDB.cardName.lesserheal || (p.ownHeroAblility.name == CardDB.cardName.lesserheal && p.auchenaiseelenpriesterin))))) // only target enemy hero during Lethal check!
{
targett trg = trgts.Find(x => x.target == 200);
if (trg != null)
{
trgts.Clear();
trgts.Add(trg);
}
else
{
// no enemy hero -> enemy have taunts ->kill the taunts from left to right
if (trgts.Count >= 1)
{
trg = trgts[0];
trgts.Clear();
trgts.Add(trg);
}
}
}
foreach (targett trgt in trgts)
{
if (usePenalityManager)
{
abilityPenality = pen.getPlayCardPenality(p.ownHeroAblility, trgt.target, p, 0, isLethalCheck);
if (abilityPenality <= 499)
{
Playfield pf = new Playfield(p);
havedonesomething = true;
pf.activateAbility(p.ownHeroAblility, trgt.target, trgt.targetEntity, abilityPenality);
addToPosmoves(pf);
}
}
else
{
Playfield pf = new Playfield(p);
havedonesomething = true;
pf.activateAbility(p.ownHeroAblility, trgt.target, trgt.targetEntity, abilityPenality);
addToPosmoves(pf);
}
}
}
else
{
// the other classes dont have to target####################################################
Playfield pf = new Playfield(p);
if (usePenalityManager)
{
abilityPenality = pen.getPlayCardPenality(p.ownHeroAblility, -1, pf, 0, isLethalCheck);
if (abilityPenality <= 499)
{
havedonesomething = true;
pf.activateAbility(p.ownHeroAblility, -1, -1, abilityPenality);
addToPosmoves(pf);
}
}
else
{
havedonesomething = true;
pf.activateAbility(p.ownHeroAblility, -1, -1, abilityPenality);
addToPosmoves(pf);
}
}
}
if (isLethalCheck)
{
p.complete = true;
}
else
{
p.endTurn(this.simulateSecondTurn, this.playaround, false, this.playaroundprob, this.playaroundprob2);
}
//sort stupid stuff ouf
if (botBase.getPlayfieldValue(p) > bestoldval)
{
bestoldval = botBase.getPlayfieldValue(p);
bestold = p;
}
if (!test)
{
posmoves.Remove(p);
}
if (this.calculated > this.totalboards)
{
break;
}
}
if (!test && bestoldval >= -10000 && bestold != null)
{
this.posmoves.Add(bestold);
}
//Helpfunctions.Instance.loggonoff(true);
if (this.printNormalstuff)
{
int donec = 0;
foreach (Playfield p in posmoves)
{
if (p.complete)
{
donec++;
}
}
Helpfunctions.Instance.logg("deep " + deep + " len " + this.posmoves.Count + " dones " + donec);
}
if (!test)
{
cuttingposibilities();
}
if (this.printNormalstuff)
{
Helpfunctions.Instance.logg("cut to len " + this.posmoves.Count);
}
//Helpfunctions.Instance.loggonoff(false);
deep++;
if (this.calculated > this.totalboards)
{
break;
}
if (deep >= this.maxdeep)
{
break; //remove this?
}
}
foreach (Playfield p in posmoves)//temp
{
if (!p.complete)
{
if (isLethalCheck)
{
p.complete = true;
}
else
{
p.endTurn(this.simulateSecondTurn, this.playaround, false, this.playaroundprob, this.playaroundprob2);
}
}
}
// Helpfunctions.Instance.logg("find best ");
if (posmoves.Count >= 1)
{
int bestval = int.MinValue;
int bestanzactions = 1000;
Playfield bestplay = posmoves[0]; //temp[0]
foreach (Playfield p in posmoves) //temp
{
int val = botBase.getPlayfieldValue(p);
if (bestval <= val)
{
if (bestval == val && bestanzactions < p.playactions.Count)
{
continue;
}
bestplay = p;
bestval = val;
bestanzactions = p.playactions.Count;
}
}
this.bestmove = bestplay.getNextAction();
this.bestmoveValue = bestval;
this.bestboard = new Playfield(bestplay);
//Helpfunctions.Instance.logg("return");
return(bestval);
}
//Helpfunctions.Instance.logg("return");
this.bestmove = null;
this.bestmoveValue = -100000;
this.bestboard = playf;
return(-10000);
}
public void autoTester(bool printstuff, string data = "", bool logg = true)
{
help.logg("simulating board ");
BoardTester bt = new BoardTester(data);
if (!bt.datareaded)
{
return;
}
//calculate the stuff
posmoves.Clear();
posmoves.Add(new Playfield());
posmoves[0].sEnemTurn = Settings.Instance.simulateEnemysTurn;
if (logg)
{
help.logg("readed:");
help.logg(posmoves[0].getCompleteBoardForSimulating("", "", ""));
}
if (logg)
{
foreach (Playfield p in this.posmoves)
{
p.value = botBase.getPlayfieldValue(p);
p.printBoard();
}
}
help.logg("ownminionscount " + posmoves[0].ownMinions.Count);
help.logg("owncardscount " + posmoves[0].owncards.Count);
foreach (var item in this.posmoves[0].owncards)
{
if (item.canplayCard(posmoves[0]))
{
help.logg("card " + item.card.name + " is playable :" + item.canplayCard(posmoves[0]) + " cost/mana: " + item.manacost + "/" + posmoves[0].mana);
}
}
if (Playfield.Instance.ownAbilityReady)
{
if (posmoves[0].ownHeroAblility.card.canplayCard(posmoves[0], 2))
{
help.logg("ability " + posmoves[0].ownHeroAblility.card.name + " is playable :" + posmoves[0].ownHeroAblility.card.canplayCard(posmoves[0], 2) + " cost/mana: " + posmoves[0].ownHeroAblility.card.getManaCost(posmoves[0], 2) + "/" + posmoves[0].mana);
}
}
else
{
help.logg("ability is NOT READY");
}
// lethalcheck + normal
DateTime strt = DateTime.Now;
doallmoves(false, true);
help.logg("calculated " + (DateTime.Now - strt).TotalSeconds);
double timeneeded = 0;
if (bestmoveValue < 8500)
{
posmoves.Clear();
posmoves.Add(new Playfield());
posmoves[0].sEnemTurn = Settings.Instance.simulateEnemysTurn;
strt = DateTime.Now;
doallmoves(false, false);
timeneeded = (DateTime.Now - strt).TotalSeconds;
help.logg("calculated 2 " + (DateTime.Now - strt).TotalSeconds);
}
if (printstuff)
{
this.mainTurnSimulator.printPosmoves();
simmulateWholeTurn(this.mainTurnSimulator.bestboard);
help.logg("Best Board Actions:");
this.mainTurnSimulator.bestboard.printActions();
help.logg("");
help.logg("calculated " + timeneeded);
}
if (bt.boardToSimulate >= 0)
{
int input = 0;
while (input >= 0)
{
Console.WriteLine("write Index of board you want to simulate:");
String cnslrdl = Console.ReadLine();
try
{
input = Convert.ToInt32(cnslrdl);
simmulateWholeTurn(this.mainTurnSimulator.getBoard(input));
}
catch
{
Console.WriteLine("testmode ended...");
input = -1;
}
}
}
else
{
//Console.WriteLine("notestmode");
}
}
