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; }