From 72b206347f92bdc55eb6a9f4831083b13f80ad2c Mon Sep 17 00:00:00 2001 From: Dydzio Date: Fri, 10 Aug 2018 18:27:57 +0200 Subject: [PATCH] Split Fuzzy.cpp/h --- AI/VCAI/AIUtility.cpp | 2 +- AI/VCAI/CMakeLists.txt | 6 +- AI/VCAI/{Fuzzy.cpp => FuzzyEngines.cpp} | 1028 ++++++++++------------- AI/VCAI/{Fuzzy.h => FuzzyEngines.h} | 182 ++-- AI/VCAI/FuzzyHelper.cpp | 156 ++++ AI/VCAI/FuzzyHelper.h | 42 + AI/VCAI/Goals.cpp | 2 +- AI/VCAI/VCAI.cpp | 2 +- 8 files changed, 716 insertions(+), 704 deletions(-) rename AI/VCAI/{Fuzzy.cpp => FuzzyEngines.cpp} (74%) rename AI/VCAI/{Fuzzy.h => FuzzyEngines.h} (57%) create mode 100644 AI/VCAI/FuzzyHelper.cpp create mode 100644 AI/VCAI/FuzzyHelper.h diff --git a/AI/VCAI/AIUtility.cpp b/AI/VCAI/AIUtility.cpp index 311597daf..3d614b34c 100644 --- a/AI/VCAI/AIUtility.cpp +++ b/AI/VCAI/AIUtility.cpp @@ -10,7 +10,7 @@ #include "StdInc.h" #include "AIUtility.h" #include "VCAI.h" -#include "Fuzzy.h" +#include "FuzzyHelper.h" #include "../../lib/UnlockGuard.h" #include "../../lib/CConfigHandler.h" diff --git a/AI/VCAI/CMakeLists.txt b/AI/VCAI/CMakeLists.txt index aa26bc10e..9e73e6c56 100644 --- a/AI/VCAI/CMakeLists.txt +++ b/AI/VCAI/CMakeLists.txt @@ -15,7 +15,8 @@ set(VCAI_SRCS SectorMap.cpp BuildingManager.cpp MapObjectsEvaluator.cpp - Fuzzy.cpp + FuzzyEngines.cpp + FuzzyHelper.cpp Goals.cpp main.cpp VCAI.cpp @@ -31,7 +32,8 @@ set(VCAI_HEADERS SectorMap.h BuildingManager.h MapObjectsEvaluator.h - Fuzzy.h + FuzzyEngines.h + FuzzyHelper.h Goals.h VCAI.h ) diff --git a/AI/VCAI/Fuzzy.cpp b/AI/VCAI/FuzzyEngines.cpp similarity index 74% rename from AI/VCAI/Fuzzy.cpp rename to AI/VCAI/FuzzyEngines.cpp index 1feb7b264..2adb5ec82 100644 --- a/AI/VCAI/Fuzzy.cpp +++ b/AI/VCAI/FuzzyEngines.cpp @@ -1,591 +1,437 @@ -/* - * Fuzzy.cpp, part of VCMI engine - * - * Authors: listed in file AUTHORS in main folder - * - * License: GNU General Public License v2.0 or later - * Full text of license available in license.txt file, in main folder - * -*/ -#include "StdInc.h" -#include "Fuzzy.h" -#include - -#include "../../lib/mapObjects/MapObjects.h" -#include "../../lib/mapObjects/CommonConstructors.h" -#include "../../lib/CCreatureHandler.h" -#include "../../lib/CPathfinder.h" -#include "../../lib/CGameStateFwd.h" -#include "../../lib/VCMI_Lib.h" -#include "../../CCallback.h" -#include "VCAI.h" -#include "MapObjectsEvaluator.h" - -#define MIN_AI_STRENGHT (0.5f) //lower when combat AI gets smarter -#define UNGUARDED_OBJECT (100.0f) //we consider unguarded objects 100 times weaker than us - -struct BankConfig; -class CBankInfo; -class Engine; -class InputVariable; -class CGTownInstance; - -FuzzyHelper * fh; - -extern boost::thread_specific_ptr cb; -extern boost::thread_specific_ptr ai; - -engineBase::engineBase() -{ - engine.addRuleBlock(&rules); -} - -void engineBase::configure() -{ - engine.configure("Minimum", "Maximum", "Minimum", "AlgebraicSum", "Centroid", "General"); - logAi->info(engine.toString()); -} - -void engineBase::addRule(const std::string & txt) -{ - rules.addRule(fl::Rule::parse(txt, &engine)); -} - -struct armyStructure -{ - float walkers, shooters, flyers; - ui32 maxSpeed; -}; - -armyStructure evaluateArmyStructure(const CArmedInstance * army) -{ - ui64 totalStrenght = army->getArmyStrength(); - double walkersStrenght = 0; - double flyersStrenght = 0; - double shootersStrenght = 0; - ui32 maxSpeed = 0; - - for(auto s : army->Slots()) - { - bool walker = true; - if(s.second->type->hasBonusOfType(Bonus::SHOOTER)) - { - shootersStrenght += s.second->getPower(); - walker = false; - } - if(s.second->type->hasBonusOfType(Bonus::FLYING)) - { - flyersStrenght += s.second->getPower(); - walker = false; - } - if(walker) - walkersStrenght += s.second->getPower(); - - vstd::amax(maxSpeed, s.second->type->valOfBonuses(Bonus::STACKS_SPEED)); - } - armyStructure as; - as.walkers = walkersStrenght / totalStrenght; - as.shooters = shootersStrenght / totalStrenght; - as.flyers = flyersStrenght / totalStrenght; - as.maxSpeed = maxSpeed; - assert(as.walkers || as.flyers || as.shooters); - return as; -} - -float HeroMovementGoalEngineBase::calculateTurnDistanceInputValue(const CGHeroInstance * h, int3 tile) const -{ - float turns = 0.0f; - float distance = CPathfinderHelper::getMovementCost(h, tile); - if(distance) - { - if(distance < h->movement) //we can move there within one turn - turns = (fl::scalar)distance / h->movement; - else - turns = 1 + (fl::scalar)(distance - h->movement) / h->maxMovePoints(true); //bool on land? - } - return turns; -} - -ui64 FuzzyHelper::estimateBankDanger(const CBank * bank) -{ - //this one is not fuzzy anymore, just calculate weighted average - - auto objectInfo = VLC->objtypeh->getHandlerFor(bank->ID, bank->subID)->getObjectInfo(bank->appearance); - - CBankInfo * bankInfo = dynamic_cast(objectInfo.get()); - - ui64 totalStrength = 0; - ui8 totalChance = 0; - for(auto config : bankInfo->getPossibleGuards()) - { - totalStrength += config.second.totalStrength * config.first; - totalChance += config.first; - } - return totalStrength / std::max(totalChance, 1); //avoid division by zero - -} - -TacticalAdvantageEngine::TacticalAdvantageEngine() -{ - try - { - ourShooters = new fl::InputVariable("OurShooters"); - ourWalkers = new fl::InputVariable("OurWalkers"); - ourFlyers = new fl::InputVariable("OurFlyers"); - enemyShooters = new fl::InputVariable("EnemyShooters"); - enemyWalkers = new fl::InputVariable("EnemyWalkers"); - enemyFlyers = new fl::InputVariable("EnemyFlyers"); - - //Tactical advantage calculation - std::vector helper = - { - ourShooters, ourWalkers, ourFlyers, enemyShooters, enemyWalkers, enemyFlyers - }; - - for(auto val : helper) - { - engine.addInputVariable(val); - val->addTerm(new fl::Ramp("FEW", 0.6, 0.0)); - val->addTerm(new fl::Ramp("MANY", 0.4, 1)); - val->setRange(0.0, 1.0); - } - - ourSpeed = new fl::InputVariable("OurSpeed"); - enemySpeed = new fl::InputVariable("EnemySpeed"); - - helper = { ourSpeed, enemySpeed }; - - for(auto val : helper) - { - engine.addInputVariable(val); - val->addTerm(new fl::Ramp("LOW", 6.5, 3)); - val->addTerm(new fl::Triangle("MEDIUM", 5.5, 10.5)); - val->addTerm(new fl::Ramp("HIGH", 8.5, 16)); - val->setRange(0, 25); - } - - castleWalls = new fl::InputVariable("CastleWalls"); - engine.addInputVariable(castleWalls); - { - fl::Rectangle * none = new fl::Rectangle("NONE", CGTownInstance::NONE, CGTownInstance::NONE + (CGTownInstance::FORT - CGTownInstance::NONE) * 0.5f); - castleWalls->addTerm(none); - - fl::Trapezoid * medium = new fl::Trapezoid("MEDIUM", (CGTownInstance::FORT - CGTownInstance::NONE) * 0.5f, CGTownInstance::FORT, - CGTownInstance::CITADEL, CGTownInstance::CITADEL + (CGTownInstance::CASTLE - CGTownInstance::CITADEL) * 0.5f); - castleWalls->addTerm(medium); - - fl::Ramp * high = new fl::Ramp("HIGH", CGTownInstance::CITADEL - 0.1, CGTownInstance::CASTLE); - castleWalls->addTerm(high); - - castleWalls->setRange(CGTownInstance::NONE, CGTownInstance::CASTLE); - } - - - bankPresent = new fl::InputVariable("Bank"); - engine.addInputVariable(bankPresent); - { - fl::Rectangle * termFalse = new fl::Rectangle("FALSE", 0.0, 0.5f); - bankPresent->addTerm(termFalse); - fl::Rectangle * termTrue = new fl::Rectangle("TRUE", 0.5f, 1); - bankPresent->addTerm(termTrue); - bankPresent->setRange(0, 1); - } - - threat = new fl::OutputVariable("Threat"); - engine.addOutputVariable(threat); - threat->addTerm(new fl::Ramp("LOW", 1, MIN_AI_STRENGHT)); - threat->addTerm(new fl::Triangle("MEDIUM", 0.8, 1.2)); - threat->addTerm(new fl::Ramp("HIGH", 1, 1.5)); - threat->setRange(MIN_AI_STRENGHT, 1.5); - - addRule("if OurShooters is MANY and EnemySpeed is LOW then Threat is LOW"); - addRule("if OurShooters is MANY and EnemyShooters is FEW then Threat is LOW"); - addRule("if OurSpeed is LOW and EnemyShooters is MANY then Threat is HIGH"); - addRule("if OurSpeed is HIGH and EnemyShooters is MANY then Threat is LOW"); - - addRule("if OurWalkers is FEW and EnemyShooters is MANY then Threat is somewhat LOW"); - addRule("if OurShooters is MANY and EnemySpeed is HIGH then Threat is somewhat HIGH"); - //just to cover all cases - addRule("if OurShooters is FEW and EnemySpeed is HIGH then Threat is MEDIUM"); - addRule("if EnemySpeed is MEDIUM then Threat is MEDIUM"); - addRule("if EnemySpeed is LOW and OurShooters is FEW then Threat is MEDIUM"); - - addRule("if Bank is TRUE and OurShooters is MANY then Threat is somewhat HIGH"); - addRule("if Bank is TRUE and EnemyShooters is MANY then Threat is LOW"); - - addRule("if CastleWalls is HIGH and OurWalkers is MANY then Threat is very HIGH"); - addRule("if CastleWalls is HIGH and OurFlyers is MANY and OurShooters is MANY then Threat is MEDIUM"); - addRule("if CastleWalls is MEDIUM and OurShooters is MANY and EnemyWalkers is MANY then Threat is LOW"); - - } - catch(fl::Exception & pe) - { - logAi->error("initTacticalAdvantage: %s", pe.getWhat()); - } - configure(); -} - -float TacticalAdvantageEngine::getTacticalAdvantage(const CArmedInstance * we, const CArmedInstance * enemy) -{ - float output = 1; - try - { - armyStructure ourStructure = evaluateArmyStructure(we); - armyStructure enemyStructure = evaluateArmyStructure(enemy); - - ourWalkers->setValue(ourStructure.walkers); - ourShooters->setValue(ourStructure.shooters); - ourFlyers->setValue(ourStructure.flyers); - ourSpeed->setValue(ourStructure.maxSpeed); - - enemyWalkers->setValue(enemyStructure.walkers); - enemyShooters->setValue(enemyStructure.shooters); - enemyFlyers->setValue(enemyStructure.flyers); - enemySpeed->setValue(enemyStructure.maxSpeed); - - bool bank = dynamic_cast(enemy); - if(bank) - bankPresent->setValue(1); - else - bankPresent->setValue(0); - - const CGTownInstance * fort = dynamic_cast(enemy); - if(fort) - castleWalls->setValue(fort->fortLevel()); - else - castleWalls->setValue(0); - - engine.process(); - output = threat->getValue(); - } - catch(fl::Exception & fe) - { - logAi->error("getTacticalAdvantage: %s ", fe.getWhat()); - } - - if(output < 0 || (output != output)) - { - fl::InputVariable * tab[] = { bankPresent, castleWalls, ourWalkers, ourShooters, ourFlyers, ourSpeed, enemyWalkers, enemyShooters, enemyFlyers, enemySpeed }; - std::string names[] = { "bankPresent", "castleWalls", "ourWalkers", "ourShooters", "ourFlyers", "ourSpeed", "enemyWalkers", "enemyShooters", "enemyFlyers", "enemySpeed" }; - std::stringstream log("Warning! Fuzzy engine doesn't cover this set of parameters: "); - - for(int i = 0; i < boost::size(tab); i++) - log << names[i] << ": " << tab[i]->getValue() << " "; - logAi->error(log.str()); - assert(false); - } - - return output; -} - -//std::shared_ptr chooseSolution (std::vector> & vec) - -Goals::TSubgoal FuzzyHelper::chooseSolution(Goals::TGoalVec vec) -{ - if(vec.empty()) //no possibilities found - return sptr(Goals::Invalid()); - - ai->cachedSectorMaps.clear(); - - //a trick to switch between heroes less often - calculatePaths is costly - auto sortByHeroes = [](const Goals::TSubgoal & lhs, const Goals::TSubgoal & rhs) -> bool - { - return lhs->hero.h < rhs->hero.h; - }; - boost::sort(vec, sortByHeroes); - - for(auto g : vec) - { - setPriority(g); - } - - auto compareGoals = [](const Goals::TSubgoal & lhs, const Goals::TSubgoal & rhs) -> bool - { - return lhs->priority < rhs->priority; - }; - return *boost::max_element(vec, compareGoals); -} - -float FuzzyHelper::evaluate(Goals::Explore & g) -{ - return 1; -} -float FuzzyHelper::evaluate(Goals::RecruitHero & g) -{ - return 1; -} -HeroMovementGoalEngineBase::HeroMovementGoalEngineBase() -{ - try - { - strengthRatio = new fl::InputVariable("strengthRatio"); //hero must be strong enough to defeat guards - heroStrength = new fl::InputVariable("heroStrength"); //we want to use weakest possible hero - turnDistance = new fl::InputVariable("turnDistance"); //we want to use hero who is near - missionImportance = new fl::InputVariable("lockedMissionImportance"); //we may want to preempt hero with low-priority mission - value = new fl::OutputVariable("Value"); - value->setMinimum(0); - value->setMaximum(5); - - std::vector helper = { strengthRatio, heroStrength, turnDistance, missionImportance }; - for(auto val : helper) - { - engine.addInputVariable(val); - } - engine.addOutputVariable(value); - - strengthRatio->addTerm(new fl::Ramp("LOW", SAFE_ATTACK_CONSTANT, 0)); - strengthRatio->addTerm(new fl::Ramp("HIGH", SAFE_ATTACK_CONSTANT, SAFE_ATTACK_CONSTANT * 3)); - strengthRatio->setRange(0, SAFE_ATTACK_CONSTANT * 3); - - //strength compared to our main hero - heroStrength->addTerm(new fl::Ramp("LOW", 0.2, 0)); - heroStrength->addTerm(new fl::Triangle("MEDIUM", 0.2, 0.8)); - heroStrength->addTerm(new fl::Ramp("HIGH", 0.5, 1)); - heroStrength->setRange(0.0, 1.0); - - turnDistance->addTerm(new fl::Ramp("SHORT", 0.5, 0)); - turnDistance->addTerm(new fl::Triangle("MEDIUM", 0.1, 0.8)); - turnDistance->addTerm(new fl::Ramp("LONG", 0.5, 3)); - turnDistance->setRange(0.0, 3.0); - - missionImportance->addTerm(new fl::Ramp("LOW", 2.5, 0)); - missionImportance->addTerm(new fl::Triangle("MEDIUM", 2, 3)); - missionImportance->addTerm(new fl::Ramp("HIGH", 2.5, 5)); - missionImportance->setRange(0.0, 5.0); - - //an issue: in 99% cases this outputs center of mass (2.5) regardless of actual input :/ - //should be same as "mission Importance" to keep consistency - value->addTerm(new fl::Ramp("LOW", 2.5, 0)); - value->addTerm(new fl::Triangle("MEDIUM", 2, 3)); //can't be center of mass :/ - value->addTerm(new fl::Ramp("HIGH", 2.5, 5)); - value->setRange(0.0, 5.0); - - //use unarmed scouts if possible - addRule("if strengthRatio is HIGH and heroStrength is LOW then Value is very HIGH"); - //we may want to use secondary hero(es) rather than main hero - addRule("if strengthRatio is HIGH and heroStrength is MEDIUM then Value is somewhat HIGH"); - addRule("if strengthRatio is HIGH and heroStrength is HIGH then Value is somewhat LOW"); - //don't assign targets to heroes who are too weak, but prefer targets of our main hero (in case we need to gather army) - addRule("if strengthRatio is LOW and heroStrength is LOW then Value is very LOW"); - //attempt to arm secondary heroes is not stupid - addRule("if strengthRatio is LOW and heroStrength is MEDIUM then Value is somewhat HIGH"); - addRule("if strengthRatio is LOW and heroStrength is HIGH then Value is LOW"); - - //do not cancel important goals - addRule("if lockedMissionImportance is HIGH then Value is very LOW"); - addRule("if lockedMissionImportance is MEDIUM then Value is somewhat LOW"); - addRule("if lockedMissionImportance is LOW then Value is HIGH"); - //pick nearby objects if it's easy, avoid long walks - addRule("if turnDistance is SHORT then Value is HIGH"); - addRule("if turnDistance is MEDIUM then Value is MEDIUM"); - addRule("if turnDistance is LONG then Value is LOW"); - } - catch(fl::Exception & fe) - { - logAi->error("HeroMovementGoalEngineBase: %s", fe.getWhat()); - } -} - -void HeroMovementGoalEngineBase::setSharedFuzzyVariables(Goals::AbstractGoal & goal) -{ - float turns = calculateTurnDistanceInputValue(goal.hero.h, goal.tile); - float missionImportanceData = 0; - if(vstd::contains(ai->lockedHeroes, goal.hero)) - missionImportanceData = ai->lockedHeroes[goal.hero]->priority; - - float strengthRatioData = 10.0f; //we are much stronger than enemy - ui64 danger = evaluateDanger(goal.tile, goal.hero.h); - if(danger) - strengthRatioData = (fl::scalar)goal.hero.h->getTotalStrength() / danger; - - try - { - strengthRatio->setValue(strengthRatioData); - heroStrength->setValue((fl::scalar)goal.hero->getTotalStrength() / ai->primaryHero()->getTotalStrength()); - turnDistance->setValue(turns); - missionImportance->setValue(missionImportanceData); - } - catch(fl::Exception & fe) - { - logAi->error("HeroMovementGoalEngineBase::setSharedFuzzyVariables: %s", fe.getWhat()); - } -} - -float FuzzyHelper::evaluate(Goals::VisitTile & g) -{ - return visitTileEngine.evaluate(g); -} -float FuzzyHelper::evaluate(Goals::VisitObj & g) -{ - return getObjEngine.evaluate(g); -} -float FuzzyHelper::evaluate(Goals::VisitHero & g) -{ - auto obj = cb->getObj(ObjectInstanceID(g.objid)); //we assume for now that these goals are similar - if(!obj) - return -100; //hero died in the meantime - //TODO: consider direct copy (constructor?) - g.setpriority(Goals::VisitTile(obj->visitablePos()).sethero(g.hero).setisAbstract(g.isAbstract).accept(this)); - return g.priority; -} -float FuzzyHelper::evaluate(Goals::GatherArmy & g) -{ - //the more army we need, the more important goal - //the more army we lack, the less important goal - float army = g.hero->getArmyStrength(); - float ratio = g.value / std::max(g.value - army, 2000.0f); //2000 is about the value of hero recruited from tavern - return 5 * (ratio / (ratio + 2)); //so 50% army gives 2.5, asymptotic 5 -} - -float FuzzyHelper::evaluate(Goals::ClearWayTo & g) -{ - if(!g.hero.h) - throw cannotFulfillGoalException("ClearWayTo called without hero!"); - - int3 t = ai->getCachedSectorMap(g.hero)->firstTileToGet(g.hero, g.tile); - - if(t.valid()) - { - if(isSafeToVisit(g.hero, t)) - { - g.setpriority(Goals::VisitTile(g.tile).sethero(g.hero).setisAbstract(g.isAbstract).accept(this)); - } - else - { - g.setpriority (Goals::GatherArmy(evaluateDanger(t, g.hero.h)*SAFE_ATTACK_CONSTANT). - sethero(g.hero).setisAbstract(true).accept(this)); - } - return g.priority; - } - else - return -1; - -} - -float FuzzyHelper::evaluate(Goals::BuildThis & g) -{ - return g.priority; //TODO -} -float FuzzyHelper::evaluate(Goals::DigAtTile & g) -{ - return 0; -} -float FuzzyHelper::evaluate(Goals::CollectRes & g) -{ - return g.priority; //handled by ResourceManager -} -float FuzzyHelper::evaluate(Goals::Build & g) -{ - return 0; -} -float FuzzyHelper::evaluate(Goals::BuyArmy & g) -{ - return g.priority; -} -float FuzzyHelper::evaluate(Goals::Invalid & g) -{ - return -1e10; -} -float FuzzyHelper::evaluate(Goals::AbstractGoal & g) -{ - logAi->warn("Cannot evaluate goal %s", g.name()); - return g.priority; -} -void FuzzyHelper::setPriority(Goals::TSubgoal & g) //calls evaluate - Visitor pattern -{ - g->setpriority(g->accept(this)); //this enforces returned value is set -} - -GetObjEngine::GetObjEngine() -{ - try - { - objectValue = new fl::InputVariable("objectValue"); //value of that object type known by AI - - engine.addInputVariable(objectValue); - - //objectValue ranges are based on checking RMG priorities of some objects and trying to guess sane value ranges - objectValue->addTerm(new fl::Ramp("LOW", 3000, 0)); //I have feeling that concave shape might work well instead of ramp for objectValue FL terms - objectValue->addTerm(new fl::Triangle("MEDIUM", 2500, 6000)); - objectValue->addTerm(new fl::Ramp("HIGH", 5000, 20000)); - objectValue->setRange(0, 20000); //relic artifact value is border value by design, even better things are scaled down. - - addRule("if objectValue is HIGH then value is HIGH"); - addRule("if objectValue is MEDIUM then value is MEDIUM"); - addRule("if objectValue is LOW then value is LOW"); - } - catch(fl::Exception & fe) - { - logAi->error("FindWanderTarget: %s", fe.getWhat()); - } - configure(); -} - -float GetObjEngine::evaluate(Goals::AbstractGoal & goal) -{ - auto g = dynamic_cast(goal); - - if(!g.hero) - return 0; - - auto obj = cb->getObj(ObjectInstanceID(g.objid)); - - - boost::optional objValueKnownByAI = MapObjectsEvaluator::getInstance().getObjectValue(obj->ID, obj->subID); - int objValue = 0; - - if(objValueKnownByAI != boost::none) //consider adding value manipulation based on object instances on map - { - objValue = std::min(std::max(objValueKnownByAI.get(), 0), 20000); - } - else - { - MapObjectsEvaluator::getInstance().addObjectData(obj->ID, obj->subID, 0); - logGlobal->warn("AI met object type it doesn't know - ID: " + std::to_string(obj->ID) + ", subID: " + std::to_string(obj->subID) + " - adding to database with value " + std::to_string(objValue)); - } - - setSharedFuzzyVariables(goal); - - float output = -1.0f; - try - { - objectValue->setValue(objValue); - engine.process(); - output = value->getValue(); - } - catch(fl::Exception & fe) - { - logAi->error("evaluate getWanderTargetObjectValue: %s", fe.getWhat()); - } - assert(output >= 0.0f); - return output; -} - -VisitTileEngine::VisitTileEngine() //so far no VisitTile-specific variables that are not shared with HeroMovementGoalEngineBase -{ - configure(); -} - -float VisitTileEngine::evaluate(Goals::AbstractGoal & goal) -{ - auto g = dynamic_cast(goal); - //we assume that hero is already set and we want to choose most suitable one for the mission - if(!g.hero) - return 0; - - //assert(cb->isInTheMap(g.tile)); - - setSharedFuzzyVariables(goal); - - try - { - engine.process(); - g.priority = value->getValue(); - } - catch(fl::Exception & fe) - { - logAi->error("evaluate VisitTile: %s", fe.getWhat()); - } - assert(g.priority >= 0); - return g.priority; -} +/* +* FuzzyEngines.cpp, part of VCMI engine +* +* Authors: listed in file AUTHORS in main folder +* +* License: GNU General Public License v2.0 or later +* Full text of license available in license.txt file, in main folder +* +*/ +#include "StdInc.h" +#include "FuzzyEngines.h" + +#include "../../lib/mapObjects/MapObjects.h" +#include "VCAI.h" +#include "MapObjectsEvaluator.h" + +#define MIN_AI_STRENGTH (0.5f) //lower when combat AI gets smarter +#define UNGUARDED_OBJECT (100.0f) //we consider unguarded objects 100 times weaker than us + +extern boost::thread_specific_ptr ai; + +engineBase::engineBase() +{ + engine.addRuleBlock(&rules); +} + +void engineBase::configure() +{ + engine.configure("Minimum", "Maximum", "Minimum", "AlgebraicSum", "Centroid", "General"); + logAi->info(engine.toString()); +} + +void engineBase::addRule(const std::string & txt) +{ + rules.addRule(fl::Rule::parse(txt, &engine)); +} + +struct armyStructure +{ + float walkers, shooters, flyers; + ui32 maxSpeed; +}; + +armyStructure evaluateArmyStructure(const CArmedInstance * army) +{ + ui64 totalStrenght = army->getArmyStrength(); + double walkersStrenght = 0; + double flyersStrenght = 0; + double shootersStrenght = 0; + ui32 maxSpeed = 0; + + for(auto s : army->Slots()) + { + bool walker = true; + if(s.second->type->hasBonusOfType(Bonus::SHOOTER)) + { + shootersStrenght += s.second->getPower(); + walker = false; + } + if(s.second->type->hasBonusOfType(Bonus::FLYING)) + { + flyersStrenght += s.second->getPower(); + walker = false; + } + if(walker) + walkersStrenght += s.second->getPower(); + + vstd::amax(maxSpeed, s.second->type->valOfBonuses(Bonus::STACKS_SPEED)); + } + armyStructure as; + as.walkers = walkersStrenght / totalStrenght; + as.shooters = shootersStrenght / totalStrenght; + as.flyers = flyersStrenght / totalStrenght; + as.maxSpeed = maxSpeed; + assert(as.walkers || as.flyers || as.shooters); + return as; +} + +float HeroMovementGoalEngineBase::calculateTurnDistanceInputValue(const CGHeroInstance * h, int3 tile) const +{ + float turns = 0.0f; + float distance = CPathfinderHelper::getMovementCost(h, tile); + if(distance) + { + if(distance < h->movement) //we can move there within one turn + turns = (fl::scalar)distance / h->movement; + else + turns = 1 + (fl::scalar)(distance - h->movement) / h->maxMovePoints(true); //bool on land? + } + return turns; +} + +TacticalAdvantageEngine::TacticalAdvantageEngine() +{ + try + { + ourShooters = new fl::InputVariable("OurShooters"); + ourWalkers = new fl::InputVariable("OurWalkers"); + ourFlyers = new fl::InputVariable("OurFlyers"); + enemyShooters = new fl::InputVariable("EnemyShooters"); + enemyWalkers = new fl::InputVariable("EnemyWalkers"); + enemyFlyers = new fl::InputVariable("EnemyFlyers"); + + //Tactical advantage calculation + std::vector helper = + { + ourShooters, ourWalkers, ourFlyers, enemyShooters, enemyWalkers, enemyFlyers + }; + + for(auto val : helper) + { + engine.addInputVariable(val); + val->addTerm(new fl::Ramp("FEW", 0.6, 0.0)); + val->addTerm(new fl::Ramp("MANY", 0.4, 1)); + val->setRange(0.0, 1.0); + } + + ourSpeed = new fl::InputVariable("OurSpeed"); + enemySpeed = new fl::InputVariable("EnemySpeed"); + + helper = { ourSpeed, enemySpeed }; + + for(auto val : helper) + { + engine.addInputVariable(val); + val->addTerm(new fl::Ramp("LOW", 6.5, 3)); + val->addTerm(new fl::Triangle("MEDIUM", 5.5, 10.5)); + val->addTerm(new fl::Ramp("HIGH", 8.5, 16)); + val->setRange(0, 25); + } + + castleWalls = new fl::InputVariable("CastleWalls"); + engine.addInputVariable(castleWalls); + { + fl::Rectangle * none = new fl::Rectangle("NONE", CGTownInstance::NONE, CGTownInstance::NONE + (CGTownInstance::FORT - CGTownInstance::NONE) * 0.5f); + castleWalls->addTerm(none); + + fl::Trapezoid * medium = new fl::Trapezoid("MEDIUM", (CGTownInstance::FORT - CGTownInstance::NONE) * 0.5f, CGTownInstance::FORT, + CGTownInstance::CITADEL, CGTownInstance::CITADEL + (CGTownInstance::CASTLE - CGTownInstance::CITADEL) * 0.5f); + castleWalls->addTerm(medium); + + fl::Ramp * high = new fl::Ramp("HIGH", CGTownInstance::CITADEL - 0.1, CGTownInstance::CASTLE); + castleWalls->addTerm(high); + + castleWalls->setRange(CGTownInstance::NONE, CGTownInstance::CASTLE); + } + + + bankPresent = new fl::InputVariable("Bank"); + engine.addInputVariable(bankPresent); + { + fl::Rectangle * termFalse = new fl::Rectangle("FALSE", 0.0, 0.5f); + bankPresent->addTerm(termFalse); + fl::Rectangle * termTrue = new fl::Rectangle("TRUE", 0.5f, 1); + bankPresent->addTerm(termTrue); + bankPresent->setRange(0, 1); + } + + threat = new fl::OutputVariable("Threat"); + engine.addOutputVariable(threat); + threat->addTerm(new fl::Ramp("LOW", 1, MIN_AI_STRENGTH)); + threat->addTerm(new fl::Triangle("MEDIUM", 0.8, 1.2)); + threat->addTerm(new fl::Ramp("HIGH", 1, 1.5)); + threat->setRange(MIN_AI_STRENGTH, 1.5); + + addRule("if OurShooters is MANY and EnemySpeed is LOW then Threat is LOW"); + addRule("if OurShooters is MANY and EnemyShooters is FEW then Threat is LOW"); + addRule("if OurSpeed is LOW and EnemyShooters is MANY then Threat is HIGH"); + addRule("if OurSpeed is HIGH and EnemyShooters is MANY then Threat is LOW"); + + addRule("if OurWalkers is FEW and EnemyShooters is MANY then Threat is somewhat LOW"); + addRule("if OurShooters is MANY and EnemySpeed is HIGH then Threat is somewhat HIGH"); + //just to cover all cases + addRule("if OurShooters is FEW and EnemySpeed is HIGH then Threat is MEDIUM"); + addRule("if EnemySpeed is MEDIUM then Threat is MEDIUM"); + addRule("if EnemySpeed is LOW and OurShooters is FEW then Threat is MEDIUM"); + + addRule("if Bank is TRUE and OurShooters is MANY then Threat is somewhat HIGH"); + addRule("if Bank is TRUE and EnemyShooters is MANY then Threat is LOW"); + + addRule("if CastleWalls is HIGH and OurWalkers is MANY then Threat is very HIGH"); + addRule("if CastleWalls is HIGH and OurFlyers is MANY and OurShooters is MANY then Threat is MEDIUM"); + addRule("if CastleWalls is MEDIUM and OurShooters is MANY and EnemyWalkers is MANY then Threat is LOW"); + + } + catch(fl::Exception & pe) + { + logAi->error("initTacticalAdvantage: %s", pe.getWhat()); + } + configure(); +} + +float TacticalAdvantageEngine::getTacticalAdvantage(const CArmedInstance * we, const CArmedInstance * enemy) +{ + float output = 1; + try + { + armyStructure ourStructure = evaluateArmyStructure(we); + armyStructure enemyStructure = evaluateArmyStructure(enemy); + + ourWalkers->setValue(ourStructure.walkers); + ourShooters->setValue(ourStructure.shooters); + ourFlyers->setValue(ourStructure.flyers); + ourSpeed->setValue(ourStructure.maxSpeed); + + enemyWalkers->setValue(enemyStructure.walkers); + enemyShooters->setValue(enemyStructure.shooters); + enemyFlyers->setValue(enemyStructure.flyers); + enemySpeed->setValue(enemyStructure.maxSpeed); + + bool bank = dynamic_cast(enemy); + if(bank) + bankPresent->setValue(1); + else + bankPresent->setValue(0); + + const CGTownInstance * fort = dynamic_cast(enemy); + if(fort) + castleWalls->setValue(fort->fortLevel()); + else + castleWalls->setValue(0); + + engine.process(); + output = threat->getValue(); + } + catch(fl::Exception & fe) + { + logAi->error("getTacticalAdvantage: %s ", fe.getWhat()); + } + + if(output < 0 || (output != output)) + { + fl::InputVariable * tab[] = { bankPresent, castleWalls, ourWalkers, ourShooters, ourFlyers, ourSpeed, enemyWalkers, enemyShooters, enemyFlyers, enemySpeed }; + std::string names[] = { "bankPresent", "castleWalls", "ourWalkers", "ourShooters", "ourFlyers", "ourSpeed", "enemyWalkers", "enemyShooters", "enemyFlyers", "enemySpeed" }; + std::stringstream log("Warning! Fuzzy engine doesn't cover this set of parameters: "); + + for(int i = 0; i < boost::size(tab); i++) + log << names[i] << ": " << tab[i]->getValue() << " "; + logAi->error(log.str()); + assert(false); + } + + return output; +} + +//std::shared_ptr chooseSolution (std::vector> & vec) + +HeroMovementGoalEngineBase::HeroMovementGoalEngineBase() +{ + try + { + strengthRatio = new fl::InputVariable("strengthRatio"); //hero must be strong enough to defeat guards + heroStrength = new fl::InputVariable("heroStrength"); //we want to use weakest possible hero + turnDistance = new fl::InputVariable("turnDistance"); //we want to use hero who is near + missionImportance = new fl::InputVariable("lockedMissionImportance"); //we may want to preempt hero with low-priority mission + value = new fl::OutputVariable("Value"); + value->setMinimum(0); + value->setMaximum(5); + + std::vector helper = { strengthRatio, heroStrength, turnDistance, missionImportance }; + for(auto val : helper) + { + engine.addInputVariable(val); + } + engine.addOutputVariable(value); + + strengthRatio->addTerm(new fl::Ramp("LOW", SAFE_ATTACK_CONSTANT, 0)); + strengthRatio->addTerm(new fl::Ramp("HIGH", SAFE_ATTACK_CONSTANT, SAFE_ATTACK_CONSTANT * 3)); + strengthRatio->setRange(0, SAFE_ATTACK_CONSTANT * 3); + + //strength compared to our main hero + heroStrength->addTerm(new fl::Ramp("LOW", 0.2, 0)); + heroStrength->addTerm(new fl::Triangle("MEDIUM", 0.2, 0.8)); + heroStrength->addTerm(new fl::Ramp("HIGH", 0.5, 1)); + heroStrength->setRange(0.0, 1.0); + + turnDistance->addTerm(new fl::Ramp("SHORT", 0.5, 0)); + turnDistance->addTerm(new fl::Triangle("MEDIUM", 0.1, 0.8)); + turnDistance->addTerm(new fl::Ramp("LONG", 0.5, 3)); + turnDistance->setRange(0.0, 3.0); + + missionImportance->addTerm(new fl::Ramp("LOW", 2.5, 0)); + missionImportance->addTerm(new fl::Triangle("MEDIUM", 2, 3)); + missionImportance->addTerm(new fl::Ramp("HIGH", 2.5, 5)); + missionImportance->setRange(0.0, 5.0); + + //an issue: in 99% cases this outputs center of mass (2.5) regardless of actual input :/ + //should be same as "mission Importance" to keep consistency + value->addTerm(new fl::Ramp("LOW", 2.5, 0)); + value->addTerm(new fl::Triangle("MEDIUM", 2, 3)); //can't be center of mass :/ + value->addTerm(new fl::Ramp("HIGH", 2.5, 5)); + value->setRange(0.0, 5.0); + + //use unarmed scouts if possible + addRule("if strengthRatio is HIGH and heroStrength is LOW then Value is very HIGH"); + //we may want to use secondary hero(es) rather than main hero + addRule("if strengthRatio is HIGH and heroStrength is MEDIUM then Value is somewhat HIGH"); + addRule("if strengthRatio is HIGH and heroStrength is HIGH then Value is somewhat LOW"); + //don't assign targets to heroes who are too weak, but prefer targets of our main hero (in case we need to gather army) + addRule("if strengthRatio is LOW and heroStrength is LOW then Value is very LOW"); + //attempt to arm secondary heroes is not stupid + addRule("if strengthRatio is LOW and heroStrength is MEDIUM then Value is somewhat HIGH"); + addRule("if strengthRatio is LOW and heroStrength is HIGH then Value is LOW"); + + //do not cancel important goals + addRule("if lockedMissionImportance is HIGH then Value is very LOW"); + addRule("if lockedMissionImportance is MEDIUM then Value is somewhat LOW"); + addRule("if lockedMissionImportance is LOW then Value is HIGH"); + //pick nearby objects if it's easy, avoid long walks + addRule("if turnDistance is SHORT then Value is HIGH"); + addRule("if turnDistance is MEDIUM then Value is MEDIUM"); + addRule("if turnDistance is LONG then Value is LOW"); + } + catch(fl::Exception & fe) + { + logAi->error("HeroMovementGoalEngineBase: %s", fe.getWhat()); + } +} + +void HeroMovementGoalEngineBase::setSharedFuzzyVariables(Goals::AbstractGoal & goal) +{ + float turns = calculateTurnDistanceInputValue(goal.hero.h, goal.tile); + float missionImportanceData = 0; + if(vstd::contains(ai->lockedHeroes, goal.hero)) + missionImportanceData = ai->lockedHeroes[goal.hero]->priority; + + float strengthRatioData = 10.0f; //we are much stronger than enemy + ui64 danger = evaluateDanger(goal.tile, goal.hero.h); + if(danger) + strengthRatioData = (fl::scalar)goal.hero.h->getTotalStrength() / danger; + + try + { + strengthRatio->setValue(strengthRatioData); + heroStrength->setValue((fl::scalar)goal.hero->getTotalStrength() / ai->primaryHero()->getTotalStrength()); + turnDistance->setValue(turns); + missionImportance->setValue(missionImportanceData); + } + catch(fl::Exception & fe) + { + logAi->error("HeroMovementGoalEngineBase::setSharedFuzzyVariables: %s", fe.getWhat()); + } +} + +GetObjEngine::GetObjEngine() +{ + try + { + objectValue = new fl::InputVariable("objectValue"); //value of that object type known by AI + + engine.addInputVariable(objectValue); + + //objectValue ranges are based on checking RMG priorities of some objects and trying to guess sane value ranges + objectValue->addTerm(new fl::Ramp("LOW", 3000, 0)); //I have feeling that concave shape might work well instead of ramp for objectValue FL terms + objectValue->addTerm(new fl::Triangle("MEDIUM", 2500, 6000)); + objectValue->addTerm(new fl::Ramp("HIGH", 5000, 20000)); + objectValue->setRange(0, 20000); //relic artifact value is border value by design, even better things are scaled down. + + addRule("if objectValue is HIGH then value is HIGH"); + addRule("if objectValue is MEDIUM then value is MEDIUM"); + addRule("if objectValue is LOW then value is LOW"); + } + catch(fl::Exception & fe) + { + logAi->error("FindWanderTarget: %s", fe.getWhat()); + } + configure(); +} + +float GetObjEngine::evaluate(Goals::AbstractGoal & goal) +{ + auto g = dynamic_cast(goal); + + if(!g.hero) + return 0; + + auto obj = ai->myCb->getObj(ObjectInstanceID(g.objid)); + + + boost::optional objValueKnownByAI = MapObjectsEvaluator::getInstance().getObjectValue(obj->ID, obj->subID); + int objValue = 0; + + if(objValueKnownByAI != boost::none) //consider adding value manipulation based on object instances on map + { + objValue = std::min(std::max(objValueKnownByAI.get(), 0), 20000); + } + else + { + MapObjectsEvaluator::getInstance().addObjectData(obj->ID, obj->subID, 0); + logGlobal->warn("AI met object type it doesn't know - ID: " + std::to_string(obj->ID) + ", subID: " + std::to_string(obj->subID) + " - adding to database with value " + std::to_string(objValue)); + } + + setSharedFuzzyVariables(goal); + + float output = -1.0f; + try + { + objectValue->setValue(objValue); + engine.process(); + output = value->getValue(); + } + catch(fl::Exception & fe) + { + logAi->error("evaluate getWanderTargetObjectValue: %s", fe.getWhat()); + } + assert(output >= 0.0f); + return output; +} + +VisitTileEngine::VisitTileEngine() //so far no VisitTile-specific variables that are not shared with HeroMovementGoalEngineBase +{ + configure(); +} + +float VisitTileEngine::evaluate(Goals::AbstractGoal & goal) +{ + auto g = dynamic_cast(goal); + //we assume that hero is already set and we want to choose most suitable one for the mission + if(!g.hero) + return 0; + + //assert(cb->isInTheMap(g.tile)); + + setSharedFuzzyVariables(goal); + + try + { + engine.process(); + g.priority = value->getValue(); + } + catch(fl::Exception & fe) + { + logAi->error("evaluate VisitTile: %s", fe.getWhat()); + } + assert(g.priority >= 0); + return g.priority; +} \ No newline at end of file diff --git a/AI/VCAI/Fuzzy.h b/AI/VCAI/FuzzyEngines.h similarity index 57% rename from AI/VCAI/Fuzzy.h rename to AI/VCAI/FuzzyEngines.h index bfe016af6..f175654f7 100644 --- a/AI/VCAI/Fuzzy.h +++ b/AI/VCAI/FuzzyEngines.h @@ -1,108 +1,74 @@ -/* - * Fuzzy.h, part of VCMI engine - * - * Authors: listed in file AUTHORS in main folder - * - * License: GNU General Public License v2.0 or later - * Full text of license available in license.txt file, in main folder - * -*/ -#pragma once -#include "fl/Headers.h" -#include "Goals.h" - -class VCAI; -class CArmedInstance; -class CBank; -struct SectorMap; - -class engineBase //subclasses create fuzzylite variables with "new" that are not freed - this is desired as fl::Engine wants to destroy these... -{ -protected: - fl::Engine engine; - fl::RuleBlock rules; - virtual void configure(); - void addRule(const std::string & txt); -public: - engineBase(); -}; - -class TacticalAdvantageEngine : public engineBase -{ -public: - TacticalAdvantageEngine(); - float getTacticalAdvantage(const CArmedInstance * we, const CArmedInstance * enemy); //returns factor how many times enemy is stronger than us -private: - fl::InputVariable * ourWalkers, *ourShooters, *ourFlyers, *enemyWalkers, *enemyShooters, *enemyFlyers; - fl::InputVariable * ourSpeed, *enemySpeed; - fl::InputVariable * bankPresent; - fl::InputVariable * castleWalls; - fl::OutputVariable * threat; -}; - -class HeroMovementGoalEngineBase : public engineBase //in future - maybe derive from some (GoalEngineBase : public engineBase) class for handling non-movement goals with common utility for goal engines -{ -public: - HeroMovementGoalEngineBase(); - - virtual float evaluate(Goals::AbstractGoal & goal) = 0; - -protected: - void setSharedFuzzyVariables(Goals::AbstractGoal & goal); - - fl::InputVariable * strengthRatio; - fl::InputVariable * heroStrength; - fl::InputVariable * turnDistance; - fl::InputVariable * missionImportance; - fl::OutputVariable * value; - -private: - float calculateTurnDistanceInputValue(const CGHeroInstance * h, int3 tile) const; -}; - -class VisitTileEngine : public HeroMovementGoalEngineBase -{ -public: - VisitTileEngine(); - float evaluate(Goals::AbstractGoal & goal) override; -}; - -class GetObjEngine : public HeroMovementGoalEngineBase -{ -public: - GetObjEngine(); - float evaluate(Goals::AbstractGoal & goal) override; -protected: - fl::InputVariable * objectValue; -}; - -class FuzzyHelper -{ - friend class VCAI; - -public: - TacticalAdvantageEngine tacticalAdvantageEngine; - VisitTileEngine visitTileEngine; - GetObjEngine getObjEngine; - - float evaluate(Goals::Explore & g); - float evaluate(Goals::RecruitHero & g); - float evaluate(Goals::VisitTile & g); - float evaluate(Goals::VisitObj & g); - float evaluate(Goals::VisitHero & g); - float evaluate(Goals::BuildThis & g); - float evaluate(Goals::DigAtTile & g); - float evaluate(Goals::CollectRes & g); - float evaluate(Goals::Build & g); - float evaluate(Goals::BuyArmy & g); - float evaluate(Goals::GatherArmy & g); - float evaluate(Goals::ClearWayTo & g); - float evaluate(Goals::Invalid & g); - float evaluate(Goals::AbstractGoal & g); - void setPriority(Goals::TSubgoal & g); - - ui64 estimateBankDanger(const CBank * bank); //TODO: move to another class? - - Goals::TSubgoal chooseSolution(Goals::TGoalVec vec); - //std::shared_ptr chooseSolution (std::vector> & vec); -}; +/* +* FuzzyEngines.h, part of VCMI engine +* +* Authors: listed in file AUTHORS in main folder +* +* License: GNU General Public License v2.0 or later +* Full text of license available in license.txt file, in main folder +* +*/ +#pragma once +#include "fl/Headers.h" +#include "Goals.h" + +class CArmedInstance; + +class engineBase //subclasses create fuzzylite variables with "new" that are not freed - this is desired as fl::Engine wants to destroy these... +{ +protected: + fl::Engine engine; + fl::RuleBlock rules; + virtual void configure(); + void addRule(const std::string & txt); +public: + engineBase(); +}; + +class TacticalAdvantageEngine : public engineBase +{ +public: + TacticalAdvantageEngine(); + float getTacticalAdvantage(const CArmedInstance * we, const CArmedInstance * enemy); //returns factor how many times enemy is stronger than us +private: + fl::InputVariable * ourWalkers, *ourShooters, *ourFlyers, *enemyWalkers, *enemyShooters, *enemyFlyers; + fl::InputVariable * ourSpeed, *enemySpeed; + fl::InputVariable * bankPresent; + fl::InputVariable * castleWalls; + fl::OutputVariable * threat; +}; + +class HeroMovementGoalEngineBase : public engineBase //in future - maybe derive from some (GoalEngineBase : public engineBase) class for handling non-movement goals with common utility for goal engines +{ +public: + HeroMovementGoalEngineBase(); + + virtual float evaluate(Goals::AbstractGoal & goal) = 0; + +protected: + void setSharedFuzzyVariables(Goals::AbstractGoal & goal); + + fl::InputVariable * strengthRatio; + fl::InputVariable * heroStrength; + fl::InputVariable * turnDistance; + fl::InputVariable * missionImportance; + fl::OutputVariable * value; + +private: + float calculateTurnDistanceInputValue(const CGHeroInstance * h, int3 tile) const; +}; + +class VisitTileEngine : public HeroMovementGoalEngineBase +{ +public: + VisitTileEngine(); + float evaluate(Goals::AbstractGoal & goal) override; +}; + +class GetObjEngine : public HeroMovementGoalEngineBase +{ +public: + GetObjEngine(); + float evaluate(Goals::AbstractGoal & goal) override; +protected: + fl::InputVariable * objectValue; +}; \ No newline at end of file diff --git a/AI/VCAI/FuzzyHelper.cpp b/AI/VCAI/FuzzyHelper.cpp new file mode 100644 index 000000000..094711fe1 --- /dev/null +++ b/AI/VCAI/FuzzyHelper.cpp @@ -0,0 +1,156 @@ +/* + * FuzzyHelper.cpp, part of VCMI engine + * + * Authors: listed in file AUTHORS in main folder + * + * License: GNU General Public License v2.0 or later + * Full text of license available in license.txt file, in main folder + * +*/ +#include "StdInc.h" +#include "FuzzyHelper.h" + +#include "../../lib/mapObjects/CommonConstructors.h" +#include "VCAI.h" + +FuzzyHelper * fh; + +extern boost::thread_specific_ptr ai; + +Goals::TSubgoal FuzzyHelper::chooseSolution(Goals::TGoalVec vec) +{ + if(vec.empty()) //no possibilities found + return sptr(Goals::Invalid()); + + ai->cachedSectorMaps.clear(); + + //a trick to switch between heroes less often - calculatePaths is costly + auto sortByHeroes = [](const Goals::TSubgoal & lhs, const Goals::TSubgoal & rhs) -> bool + { + return lhs->hero.h < rhs->hero.h; + }; + boost::sort(vec, sortByHeroes); + + for(auto g : vec) + { + setPriority(g); + } + + auto compareGoals = [](const Goals::TSubgoal & lhs, const Goals::TSubgoal & rhs) -> bool + { + return lhs->priority < rhs->priority; + }; + return *boost::max_element(vec, compareGoals); +} + +ui64 FuzzyHelper::estimateBankDanger(const CBank * bank) +{ + //this one is not fuzzy anymore, just calculate weighted average + + auto objectInfo = VLC->objtypeh->getHandlerFor(bank->ID, bank->subID)->getObjectInfo(bank->appearance); + + CBankInfo * bankInfo = dynamic_cast(objectInfo.get()); + + ui64 totalStrength = 0; + ui8 totalChance = 0; + for(auto config : bankInfo->getPossibleGuards()) + { + totalStrength += config.second.totalStrength * config.first; + totalChance += config.first; + } + return totalStrength / std::max(totalChance, 1); //avoid division by zero + +} + +float FuzzyHelper::evaluate(Goals::VisitTile & g) +{ + return visitTileEngine.evaluate(g); +} +float FuzzyHelper::evaluate(Goals::VisitObj & g) +{ + return getObjEngine.evaluate(g); +} +float FuzzyHelper::evaluate(Goals::VisitHero & g) +{ + auto obj = ai->myCb->getObj(ObjectInstanceID(g.objid)); //we assume for now that these goals are similar + if(!obj) + return -100; //hero died in the meantime + //TODO: consider direct copy (constructor?) + g.setpriority(Goals::VisitTile(obj->visitablePos()).sethero(g.hero).setisAbstract(g.isAbstract).accept(this)); + return g.priority; +} +float FuzzyHelper::evaluate(Goals::GatherArmy & g) +{ + //the more army we need, the more important goal + //the more army we lack, the less important goal + float army = g.hero->getArmyStrength(); + float ratio = g.value / std::max(g.value - army, 2000.0f); //2000 is about the value of hero recruited from tavern + return 5 * (ratio / (ratio + 2)); //so 50% army gives 2.5, asymptotic 5 +} + +float FuzzyHelper::evaluate(Goals::ClearWayTo & g) +{ + if(!g.hero.h) + throw cannotFulfillGoalException("ClearWayTo called without hero!"); + + int3 t = ai->getCachedSectorMap(g.hero)->firstTileToGet(g.hero, g.tile); + + if(t.valid()) + { + if(isSafeToVisit(g.hero, t)) + { + g.setpriority(Goals::VisitTile(g.tile).sethero(g.hero).setisAbstract(g.isAbstract).accept(this)); + } + else + { + g.setpriority (Goals::GatherArmy(evaluateDanger(t, g.hero.h)*SAFE_ATTACK_CONSTANT). + sethero(g.hero).setisAbstract(true).accept(this)); + } + return g.priority; + } + else + return -1; + +} + +float FuzzyHelper::evaluate(Goals::BuildThis & g) +{ + return g.priority; //TODO +} +float FuzzyHelper::evaluate(Goals::DigAtTile & g) +{ + return 0; +} +float FuzzyHelper::evaluate(Goals::CollectRes & g) +{ + return g.priority; //handled by ResourceManager +} +float FuzzyHelper::evaluate(Goals::Build & g) +{ + return 0; +} +float FuzzyHelper::evaluate(Goals::BuyArmy & g) +{ + return g.priority; +} +float FuzzyHelper::evaluate(Goals::Explore & g) +{ + return 1; +} +float FuzzyHelper::evaluate(Goals::RecruitHero & g) +{ + return 1; +} +float FuzzyHelper::evaluate(Goals::Invalid & g) +{ + return -1e10; +} +float FuzzyHelper::evaluate(Goals::AbstractGoal & g) +{ + logAi->warn("Cannot evaluate goal %s", g.name()); + return g.priority; +} +void FuzzyHelper::setPriority(Goals::TSubgoal & g) //calls evaluate - Visitor pattern +{ + g->setpriority(g->accept(this)); //this enforces returned value is set +} diff --git a/AI/VCAI/FuzzyHelper.h b/AI/VCAI/FuzzyHelper.h new file mode 100644 index 000000000..619dbd11a --- /dev/null +++ b/AI/VCAI/FuzzyHelper.h @@ -0,0 +1,42 @@ +/* + * FuzzyHelper.h, part of VCMI engine + * + * Authors: listed in file AUTHORS in main folder + * + * License: GNU General Public License v2.0 or later + * Full text of license available in license.txt file, in main folder + * +*/ +#pragma once +#include "FuzzyEngines.h" + +class CBank; + +class FuzzyHelper +{ +public: + TacticalAdvantageEngine tacticalAdvantageEngine; + VisitTileEngine visitTileEngine; + GetObjEngine getObjEngine; + + float evaluate(Goals::Explore & g); + float evaluate(Goals::RecruitHero & g); + float evaluate(Goals::VisitTile & g); + float evaluate(Goals::VisitObj & g); + float evaluate(Goals::VisitHero & g); + float evaluate(Goals::BuildThis & g); + float evaluate(Goals::DigAtTile & g); + float evaluate(Goals::CollectRes & g); + float evaluate(Goals::Build & g); + float evaluate(Goals::BuyArmy & g); + float evaluate(Goals::GatherArmy & g); + float evaluate(Goals::ClearWayTo & g); + float evaluate(Goals::Invalid & g); + float evaluate(Goals::AbstractGoal & g); + void setPriority(Goals::TSubgoal & g); + + ui64 estimateBankDanger(const CBank * bank); //TODO: move to another class? + + Goals::TSubgoal chooseSolution(Goals::TGoalVec vec); + //std::shared_ptr chooseSolution (std::vector> & vec); +}; diff --git a/AI/VCAI/Goals.cpp b/AI/VCAI/Goals.cpp index 1b507ec6f..720c5633a 100644 --- a/AI/VCAI/Goals.cpp +++ b/AI/VCAI/Goals.cpp @@ -10,7 +10,7 @@ #include "StdInc.h" #include "Goals.h" #include "VCAI.h" -#include "Fuzzy.h" +#include "FuzzyHelper.h" #include "ResourceManager.h" #include "BuildingManager.h" #include "../../lib/mapping/CMap.h" //for victory conditions diff --git a/AI/VCAI/VCAI.cpp b/AI/VCAI/VCAI.cpp index c8845232d..fbb1f6733 100644 --- a/AI/VCAI/VCAI.cpp +++ b/AI/VCAI/VCAI.cpp @@ -9,7 +9,7 @@ */ #include "StdInc.h" #include "VCAI.h" -#include "Fuzzy.h" +#include "FuzzyHelper.h" #include "ResourceManager.h" #include "BuildingManager.h"