public void simmulateWholeTurn()
{
help.ErrorLog("########################################################################################################");
help.ErrorLog("simulate best board");
help.ErrorLog("########################################################################################################");
//this.bestboard.printActions();
Playfield tempbestboard = new Playfield();
tempbestboard.printBoard();
if (bestmove != null && bestmove.actionType != actionEnum.endturn) // save the guessed move, so we doesnt need to recalc!
{
bestmove.print();
tempbestboard.doAction(bestmove);
}
else
{
tempbestboard.mana = -100;
}
help.logg("-------------");
tempbestboard.printBoard();
foreach (Action bestmovee in this.bestActions)
{
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.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 = int.MinValue;
tempbestboard.prepareNextTurn(tempbestboard.isOwnTurn);
Ai.Instance.enemyTurnSim[0].simulateEnemysTurn(tempbestboard, true, playaround, true, Settings.Instance.playaroundprob, Settings.Instance.playaroundprob2);
}
public void simmulateWholeTurn()
{
help.ErrorLog("####################################################");
help.logg("simulate best board");
help.ErrorLog("####################################################");
//this.bestboard.printActions();
Playfield tempbestboard = new Playfield();
if (bestmove != null) // save the guessed move, so we doesnt need to recalc!
{
bestmove.print();
tempbestboard.doAction(bestmove);
}
else
{
tempbestboard.mana = -100;
}
help.logg("-------------");
tempbestboard.printBoard();
foreach (Action bestmovee in bestboard.playactions)
{
help.logg("stepp");
if (bestmovee != null) // save the guessed move, so we doesnt need to recalc!
{
bestmovee.print();
tempbestboard.doAction(bestmovee);
}
else
{
tempbestboard.mana = -100;
}
help.logg("-------------");
tempbestboard.printBoard();
}
help.logg("AFTER ENEMY TURN:");
tempbestboard.sEnemTurn = this.simulateEnemyTurn;
tempbestboard.endTurn(this.secondturnsim, this.playaround, true);
}
public void simulateEnemysTurn(Playfield rootfield, bool simulateTwoTurns, bool playaround, bool print, int pprob, int pprob2)
{
bool havedonesomething = true;
posmoves.Clear();
if (print)
{
Helpfunctions.Instance.ErrorLog("board at enemyturn start-----------------------------");
rootfield.printBoard();
}
posmoves.Add(new Playfield(rootfield));
//posmoves[0].prepareNextTurn(false);
List<Playfield> temp = new List<Playfield>();
int deep = 0;
int enemMana = rootfield.enemyMaxMana;
if (print)
{ Console.WriteLine("enemMana "+ enemMana); }
//playing aoe-effects if activated (and we didnt play loatheb)
if (playaround && rootfield.ownloatheb == 0)
{
float oldval = Ai.Instance.botBase.getPlayfieldValue(posmoves[0]);
posmoves[0].value = int.MinValue;
enemMana = posmoves[0].EnemyCardPlaying(rootfield.enemyHeroName, enemMana, rootfield.enemyAnzCards, pprob, pprob2);
float newval = Ai.Instance.botBase.getPlayfieldValue(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.ownSaboteur == 0)//loatheb doesnt do anything to heropower
{
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.getTargetsForCardEnemy(posmoves[0]);
foreach (Minion trgt in trgts)
{
if (trgt.isHero) continue;
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.hasInspire) 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);
}
}
}
//kill to strong minions with low hp
/*if (enemMana >= 4)
{
foreach (Playfield pf in posmoves)
{
Minion lowest = null;
foreach (Minion m in pf.ownMinions)
{
if (m.Angr >= 4 && m.Hp <= 2 && m.Hp>=1)
{
pf.minionGetDamageOrHeal(m, 100);
if (lowest == null || lowest.Angr <= m.Angr)
{
// lowest = m;
}
}
}
pf.doDmgTriggers();
if (lowest != null)
{
pf.minionGetDamageOrHeal(lowest, lowest.Hp);
pf.doDmgTriggers();
}
}
}*/
foreach (Minion m in posmoves[0].enemyMinions)
{
if (m.Angr == 0) continue;
m.numAttacksThisTurn = 0;
m.playedThisTurn = false;
m.updateReadyness();
}
//might be more than just one
foreach (Playfield pipi in posmoves)
{
doSomeBasicEnemyAi(pipi);
}
int boardcount = 0;
//movegen...
int i = 0;
int count = 0;
Playfield p = null;
while (havedonesomething)
{
temp.Clear();
temp.AddRange(posmoves);
havedonesomething = false;
Playfield bestold = null;
float bestoldval = 20000000;
//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);
boardcount++;
}
p.endEnemyTurn();
//p.guessingHeroHP = rootfield.guessingHeroHP;
if (Ai.Instance.botBase.getPlayfieldValue(p) < bestoldval) // want the best enemy-play-> worst for us
{
bestoldval = Ai.Instance.botBase.getPlayfieldValue(p);
bestold = p;
}
posmoves.Remove(p);
if (boardcount >= maxwide) break;
}
if (bestoldval <= 10000 && bestold != null)
{
posmoves.Add(bestold);
}
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 = Ai.Instance.botBase.getPlayfieldValue(p);
if (bestval > val)// we search the worst value
{
bestplay = p;
bestval = val;
}
}
if (print)
{
Helpfunctions.Instance.ErrorLog("best enemy board----------------------------------");
bestplay.printBoard();
}
rootfield.value = bestplay.value;
if (simulateTwoTurns && 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 void simmulateWholeTurn()
{
help.logg("simulate best board");
//this.bestboard.printActions();
Playfield tempbestboard = new Playfield();
if (bestmove != null) // save the guessed move, so we doesnt need to recalc!
{
bestmove.print();
if (bestmove.cardplay)
{
help.logg("card");
//pf.playCard(c, hc.position - 1, hc.entity, trgt.target, trgt.targetEntity, 0, bestplace, cardplayPenality);
Handmanager.Handcard hc = tempbestboard.owncards.Find(x => x.entity == bestmove.cardEntitiy);
if (bestmove.owntarget >= 0 && bestmove.enemytarget >= 0 && bestmove.enemytarget <= 9 && bestmove.owntarget < bestmove.enemytarget)
{
tempbestboard.playCard(bestmove.handcard, hc.position - 1, hc.entity, bestmove.enemytarget - 1, bestmove.enemyEntitiy, bestmove.druidchoice, bestmove.owntarget, 0);
}
else
{
tempbestboard.playCard(bestmove.handcard, hc.position - 1, hc.entity, bestmove.enemytarget, bestmove.enemyEntitiy, bestmove.druidchoice, bestmove.owntarget, 0);
}
}
if (bestmove.minionplay)
{
help.logg("min");
//.attackWithMinion(m, trgt.target, trgt.targetEntity, attackPenality);
Minion mm = tempbestboard.ownMinions.Find(x => x.entitiyID == bestmove.ownEntitiy);
tempbestboard.attackWithMinion(mm, bestmove.enemytarget, bestmove.enemyEntitiy, 0);
}
if (bestmove.heroattack)
{
help.logg("hero");
tempbestboard.attackWithWeapon(bestmove.enemytarget, bestmove.enemyEntitiy, 0);
}
if (bestmove.useability)
{
help.logg("abi");
//.activateAbility(p.ownHeroAblility, trgt.target, trgt.targetEntity, abilityPenality);
tempbestboard.activateAbility(this.nextMoveGuess.ownHeroAblility, bestmove.enemytarget, bestmove.enemyEntitiy, 0);
}
}
else
{
tempbestboard.mana = -1;
}
help.logg("-------------");
tempbestboard.printBoard();
foreach (Action bestmovee in bestboard.playactions)
{
help.logg("stepp");
if (bestmovee != null) // save the guessed move, so we doesnt need to recalc!
{
bestmovee.print();
if (bestmovee.cardplay)
{
help.logg("card");
//pf.playCard(c, hc.position - 1, hc.entity, trgt.target, trgt.targetEntity, 0, bestplace, cardplayPenality);
Handmanager.Handcard hc = tempbestboard.owncards.Find(x => x.entity == bestmovee.cardEntitiy);
if (bestmovee.owntarget >= 0 && bestmovee.enemytarget >= 0 && bestmovee.enemytarget <= 9 && bestmovee.owntarget < bestmovee.enemytarget)
{
tempbestboard.playCard(bestmovee.handcard, hc.position - 1, hc.entity, bestmovee.enemytarget - 1, bestmovee.enemyEntitiy, bestmovee.druidchoice, bestmovee.owntarget, 0);
}
else
{
tempbestboard.playCard(bestmovee.handcard, hc.position - 1, hc.entity, bestmovee.enemytarget, bestmovee.enemyEntitiy, bestmovee.druidchoice, bestmovee.owntarget, 0);
}
}
if (bestmovee.minionplay)
{
help.logg("min");
//.attackWithMinion(m, trgt.target, trgt.targetEntity, attackPenality);
Minion mm = tempbestboard.ownMinions.Find(x => x.entitiyID == bestmovee.ownEntitiy);
tempbestboard.attackWithMinion(mm, bestmovee.enemytarget, bestmovee.enemyEntitiy, 0);
}
if (bestmovee.heroattack)
{
help.logg("hero");
tempbestboard.attackWithWeapon(bestmovee.enemytarget, bestmovee.enemyEntitiy, 0);
}
if (bestmovee.useability)
{
help.logg("abi");
//.activateAbility(p.ownHeroAblility, trgt.target, trgt.targetEntity, abilityPenality);
tempbestboard.activateAbility(this.nextMoveGuess.ownHeroAblility, bestmovee.enemytarget, bestmovee.enemyEntitiy, 0);
}
}
else
{
tempbestboard.mana = -1;
}
help.logg("-------------");
tempbestboard.printBoard();
}
help.logg("AFTER ENEMY TURN:");
tempbestboard.sEnemTurn = this.simulateEnemyTurn;
tempbestboard.endTurn(this.secondturnsim, this.playaround, true);
}
public void simulateEnemysTurn(Playfield rootfield, bool simulateTwoTurns, bool playaround, bool print, int pprob, int pprob2)
{
bool havedonesomething = true;
posmoves.Clear();
if (print)
{
sf.Helpfunctions.ErrorLog("board at enemyturn start-----------------------------");
rootfield.printBoard();
}
posmoves.Add(new Playfield(rootfield));
//posmoves[0].prepareNextTurn(false);
List<Playfield> temp = new List<Playfield>();
int deep = 0;
int enemMana = Math.Min(rootfield.enemyMaxMana + 1, 10);
if (playaround && !rootfield.loatheb)
{
float oldval = sf.Ai.botBase.getPlayfieldValue(posmoves[0]);
posmoves[0].value = int.MinValue;
enemMana = posmoves[0].EnemyCardPlaying(rootfield.enemyHeroStartClass, enemMana, rootfield.enemyAnzCards, pprob, pprob2);
float newval = sf.Ai.botBase.getPlayfieldValue(posmoves[0]);
posmoves[0].value = int.MinValue;
posmoves[0].enemyAnzCards--;
posmoves[0].triggerCardsChanged(false);
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.loatheb)
{
int abilityPenality = 0;
havedonesomething = true;
// if we have mage/priest/hunter, we have to target something####################################################
if (posmoves[0].enemyHeroName == HeroEnum.mage || posmoves[0].enemyHeroName == HeroEnum.priest || posmoves[0].enemyHeroName == HeroEnum.hunter)
{
List<Minion> trgts = posmoves[0].enemyHeroAblility.card.getTargetsForCardEnemy(posmoves[0]);
foreach (Minion trgt in trgts)
{
if (trgt.isHero) continue;
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
{
// the other classes dont have to target####################################################
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();
}
doSomeBasicEnemyAi(posmoves[0]);
int boardcount = 0;
//sf.Movegenerator...
int i = 0;
int count = 0;
Playfield p = null;
while (havedonesomething)
{
temp.Clear();
temp.AddRange(posmoves);
havedonesomething = false;
Playfield bestold = null;
float bestoldval = 20000000;
//foreach (Playfield p in temp)
count = temp.Count;
for (i = 0; i < count; i++)
{
p = temp[i];
if (p.complete)
{
continue;
}
List<Action> actions = sf.Movegenerator.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);
boardcount++;
}
p.endEnemyTurn();
p.guessingHeroHP = rootfield.guessingHeroHP;
if (sf.Ai.botBase.getPlayfieldValue(p) < bestoldval) // want the best enemy-play-> worst for us
{
bestoldval = sf.Ai.botBase.getPlayfieldValue(p);
bestold = p;
}
posmoves.Remove(p);
if (boardcount >= maxwide) break;
}
if (bestoldval <= 10000 && bestold != null)
{
posmoves.Add(bestold);
}
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 = 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 = sf.Ai.botBase.getPlayfieldValue(p);
if (bestval > val)// we search the worst value
{
bestplay = p;
bestval = val;
}
}
if (print)
{
sf.Helpfunctions.ErrorLog("best enemy board----------------------------------");
bestplay.printBoard();
}
rootfield.value = bestplay.value;
if (simulateTwoTurns && bestplay.value > -1000)
{
bestplay.prepareNextTurn(true);
rootfield.value = sf.Settings.firstweight * bestval + sf.Settings.secondweight * sf.Ai.nextTurnSimulator[this.thread].doallmoves(bestplay, false, print);
}
}
public bool updateEverything(Behavior botbase, bool runExtern=false)
{
this.updateBehaveString(botbase);
HRPlayer ownPlayer = HRPlayer.GetLocalPlayer();
HRPlayer enemyPlayer = HRPlayer.GetEnemyPlayer();
ownPlayerController = ownPlayer.GetHero().GetControllerId();//ownPlayer.GetHero().GetControllerId()
// create hero + minion data
getHerostuff();
getMinions();
getHandcards();
getDecks();
// send ai the data:
Hrtprozis.Instance.clearAll();
Handmanager.Instance.clearAll();
Hrtprozis.Instance.setOwnPlayer(ownPlayerController);
Handmanager.Instance.setOwnPlayer(ownPlayerController);
this.numOptionPlayedThisTurn = 0;
this.numOptionPlayedThisTurn += this.cardsPlayedThisTurn + this.ownHero.numAttacksThisTurn;
foreach (Minion m in this.ownMinions)
{
if (m.Hp >= 1) this.numOptionPlayedThisTurn += m.numAttacksThisTurn;
}
Hrtprozis.Instance.updatePlayer(this.ownMaxMana, this.currentMana, this.cardsPlayedThisTurn, this.numMinionsPlayedThisTurn,this.numOptionPlayedThisTurn, this.ueberladung, ownPlayer.GetHero().GetEntityId(), enemyPlayer.GetHero().GetEntityId());
Hrtprozis.Instance.updateSecretStuff(this.ownSecretList, this.enemySecretCount);
Hrtprozis.Instance.updateOwnHero(this.ownHeroWeapon, this.heroWeaponAttack, this.heroWeaponDurability, this.heroname, this.heroAbility, this.ownAbilityisReady, this.ownHero);
Hrtprozis.Instance.updateEnemyHero(this.enemyHeroWeapon, this.enemyWeaponAttack, this.enemyWeaponDurability, this.enemyHeroname, this.enemyMaxMana, this.enemyAbility, this.enemyHero);
Hrtprozis.Instance.updateMinions(this.ownMinions, this.enemyMinions);
Handmanager.Instance.setHandcards(this.handCards, this.anzcards, this.enemyAnzCards);
Hrtprozis.Instance.updateFatigueStats(this.ownDecksize, this.ownHeroFatigue, this.enemyDecksize, this.enemyHeroFatigue);
//learnmode :D
Playfield p = new Playfield();
if (lastpf != null)
{
if (lastpf.isEqualf(p))
{
return false;
}
lastpf = p;
}
else
{
lastpf = p;
}
// calculate stuff
Helpfunctions.Instance.ErrorLog("calculating stuff... " + DateTime.Now.ToString("HH:mm:ss.ffff"));
if (runExtern)
{
Helpfunctions.Instance.logg("recalc-check###########");
p.printBoard();
Ai.Instance.nextMoveGuess.printBoard();
if (p.isEqual(Ai.Instance.nextMoveGuess, true))
{
printstuff(false);
Ai.Instance.doNextCalcedMove();
}
else
{
printstuff(true);
readActionFile();
}
}
else
{
printstuff(false);
Ai.Instance.dosomethingclever(botbase);
}
Helpfunctions.Instance.ErrorLog("calculating ended! " + DateTime.Now.ToString("HH:mm:ss.ffff"));
return true;
}
