|
|
@@ -1,643 +0,0 @@
|
|
|
-/*
|
|
|
- * 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 <limits>
|
|
|
-
|
|
|
-#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<CCallback> cb;
|
|
|
-extern boost::thread_specific_ptr<VCAI> 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;
|
|
|
-}
|
|
|
-
|
|
|
-FuzzyHelper::FuzzyHelper()
|
|
|
-{
|
|
|
- initTacticalAdvantage();
|
|
|
- ta.configure();
|
|
|
- initVisitTile();
|
|
|
- vt.configure();
|
|
|
- initWanderTarget();
|
|
|
- wanderTarget.configure();
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void FuzzyHelper::initTacticalAdvantage()
|
|
|
-{
|
|
|
- try
|
|
|
- {
|
|
|
- ta.ourShooters = new fl::InputVariable("OurShooters");
|
|
|
- ta.ourWalkers = new fl::InputVariable("OurWalkers");
|
|
|
- ta.ourFlyers = new fl::InputVariable("OurFlyers");
|
|
|
- ta.enemyShooters = new fl::InputVariable("EnemyShooters");
|
|
|
- ta.enemyWalkers = new fl::InputVariable("EnemyWalkers");
|
|
|
- ta.enemyFlyers = new fl::InputVariable("EnemyFlyers");
|
|
|
-
|
|
|
- //Tactical advantage calculation
|
|
|
- std::vector<fl::InputVariable *> helper =
|
|
|
- {
|
|
|
- ta.ourShooters, ta.ourWalkers, ta.ourFlyers, ta.enemyShooters, ta.enemyWalkers, ta.enemyFlyers
|
|
|
- };
|
|
|
-
|
|
|
- for(auto val : helper)
|
|
|
- {
|
|
|
- ta.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);
|
|
|
- }
|
|
|
-
|
|
|
- ta.ourSpeed = new fl::InputVariable("OurSpeed");
|
|
|
- ta.enemySpeed = new fl::InputVariable("EnemySpeed");
|
|
|
-
|
|
|
- helper = {ta.ourSpeed, ta.enemySpeed};
|
|
|
-
|
|
|
- for(auto val : helper)
|
|
|
- {
|
|
|
- ta.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);
|
|
|
- }
|
|
|
-
|
|
|
- ta.castleWalls = new fl::InputVariable("CastleWalls");
|
|
|
- ta.engine.addInputVariable(ta.castleWalls);
|
|
|
- {
|
|
|
- fl::Rectangle * none = new fl::Rectangle("NONE", CGTownInstance::NONE, CGTownInstance::NONE + (CGTownInstance::FORT - CGTownInstance::NONE) * 0.5f);
|
|
|
- ta.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);
|
|
|
- ta.castleWalls->addTerm(medium);
|
|
|
-
|
|
|
- fl::Ramp * high = new fl::Ramp("HIGH", CGTownInstance::CITADEL - 0.1, CGTownInstance::CASTLE);
|
|
|
- ta.castleWalls->addTerm(high);
|
|
|
-
|
|
|
- ta.castleWalls->setRange(CGTownInstance::NONE, CGTownInstance::CASTLE);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- ta.bankPresent = new fl::InputVariable("Bank");
|
|
|
- ta.engine.addInputVariable(ta.bankPresent);
|
|
|
- {
|
|
|
- fl::Rectangle * termFalse = new fl::Rectangle("FALSE", 0.0, 0.5f);
|
|
|
- ta.bankPresent->addTerm(termFalse);
|
|
|
- fl::Rectangle * termTrue = new fl::Rectangle("TRUE", 0.5f, 1);
|
|
|
- ta.bankPresent->addTerm(termTrue);
|
|
|
- ta.bankPresent->setRange(0, 1);
|
|
|
- }
|
|
|
-
|
|
|
- ta.threat = new fl::OutputVariable("Threat");
|
|
|
- ta.engine.addOutputVariable(ta.threat);
|
|
|
- ta.threat->addTerm(new fl::Ramp("LOW", 1, MIN_AI_STRENGHT));
|
|
|
- ta.threat->addTerm(new fl::Triangle("MEDIUM", 0.8, 1.2));
|
|
|
- ta.threat->addTerm(new fl::Ramp("HIGH", 1, 1.5));
|
|
|
- ta.threat->setRange(MIN_AI_STRENGHT, 1.5);
|
|
|
-
|
|
|
- ta.addRule("if OurShooters is MANY and EnemySpeed is LOW then Threat is LOW");
|
|
|
- ta.addRule("if OurShooters is MANY and EnemyShooters is FEW then Threat is LOW");
|
|
|
- ta.addRule("if OurSpeed is LOW and EnemyShooters is MANY then Threat is HIGH");
|
|
|
- ta.addRule("if OurSpeed is HIGH and EnemyShooters is MANY then Threat is LOW");
|
|
|
-
|
|
|
- ta.addRule("if OurWalkers is FEW and EnemyShooters is MANY then Threat is somewhat LOW");
|
|
|
- ta.addRule("if OurShooters is MANY and EnemySpeed is HIGH then Threat is somewhat HIGH");
|
|
|
- //just to cover all cases
|
|
|
- ta.addRule("if OurShooters is FEW and EnemySpeed is HIGH then Threat is MEDIUM");
|
|
|
- ta.addRule("if EnemySpeed is MEDIUM then Threat is MEDIUM");
|
|
|
- ta.addRule("if EnemySpeed is LOW and OurShooters is FEW then Threat is MEDIUM");
|
|
|
-
|
|
|
- ta.addRule("if Bank is TRUE and OurShooters is MANY then Threat is somewhat HIGH");
|
|
|
- ta.addRule("if Bank is TRUE and EnemyShooters is MANY then Threat is LOW");
|
|
|
-
|
|
|
- ta.addRule("if CastleWalls is HIGH and OurWalkers is MANY then Threat is very HIGH");
|
|
|
- ta.addRule("if CastleWalls is HIGH and OurFlyers is MANY and OurShooters is MANY then Threat is MEDIUM");
|
|
|
- ta.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());
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-float FuzzyHelper::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<CBankInfo *>(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<ui8>(totalChance, 1); //avoid division by zero
|
|
|
-
|
|
|
-}
|
|
|
-
|
|
|
-float FuzzyHelper::getTacticalAdvantage(const CArmedInstance * we, const CArmedInstance * enemy)
|
|
|
-{
|
|
|
- float output = 1;
|
|
|
- try
|
|
|
- {
|
|
|
- armyStructure ourStructure = evaluateArmyStructure(we);
|
|
|
- armyStructure enemyStructure = evaluateArmyStructure(enemy);
|
|
|
-
|
|
|
- ta.ourWalkers->setValue(ourStructure.walkers);
|
|
|
- ta.ourShooters->setValue(ourStructure.shooters);
|
|
|
- ta.ourFlyers->setValue(ourStructure.flyers);
|
|
|
- ta.ourSpeed->setValue(ourStructure.maxSpeed);
|
|
|
-
|
|
|
- ta.enemyWalkers->setValue(enemyStructure.walkers);
|
|
|
- ta.enemyShooters->setValue(enemyStructure.shooters);
|
|
|
- ta.enemyFlyers->setValue(enemyStructure.flyers);
|
|
|
- ta.enemySpeed->setValue(enemyStructure.maxSpeed);
|
|
|
-
|
|
|
- bool bank = dynamic_cast<const CBank *>(enemy);
|
|
|
- if(bank)
|
|
|
- ta.bankPresent->setValue(1);
|
|
|
- else
|
|
|
- ta.bankPresent->setValue(0);
|
|
|
-
|
|
|
- const CGTownInstance * fort = dynamic_cast<const CGTownInstance *>(enemy);
|
|
|
- if(fort)
|
|
|
- ta.castleWalls->setValue(fort->fortLevel());
|
|
|
- else
|
|
|
- ta.castleWalls->setValue(0);
|
|
|
-
|
|
|
- //engine.process(TACTICAL_ADVANTAGE);//TODO: Process only Tactical_Advantage
|
|
|
- ta.engine.process();
|
|
|
- output = ta.threat->getValue();
|
|
|
- }
|
|
|
- catch(fl::Exception & fe)
|
|
|
- {
|
|
|
- logAi->error("getTacticalAdvantage: %s ", fe.getWhat());
|
|
|
- }
|
|
|
-
|
|
|
- if(output < 0 || (output != output))
|
|
|
- {
|
|
|
- fl::InputVariable * tab[] = {ta.bankPresent, ta.castleWalls, ta.ourWalkers, ta.ourShooters, ta.ourFlyers, ta.ourSpeed, ta.enemyWalkers, ta.enemyShooters, ta.enemyFlyers, ta.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;
|
|
|
-}
|
|
|
-
|
|
|
-float FuzzyHelper::getWanderTargetObjectValue(const CGHeroInstance & h, const ObjectIdRef & obj)
|
|
|
-{
|
|
|
- float distFromObject = calculateTurnDistanceInputValue(&h, obj->pos);
|
|
|
- boost::optional<int> 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));
|
|
|
- }
|
|
|
-
|
|
|
- float output = -1.0f;
|
|
|
- try
|
|
|
- {
|
|
|
- wanderTarget.distance->setValue(distFromObject);
|
|
|
- wanderTarget.objectValue->setValue(objValue);
|
|
|
- wanderTarget.engine.process();
|
|
|
- output = wanderTarget.visitGain->getValue();
|
|
|
- }
|
|
|
- catch (fl::Exception & fe)
|
|
|
- {
|
|
|
- logAi->error("evaluate getWanderTargetObjectValue: %s", fe.getWhat());
|
|
|
- }
|
|
|
- assert(output >= 0.0f);
|
|
|
- return output;
|
|
|
-}
|
|
|
-
|
|
|
-FuzzyHelper::TacticalAdvantage::~TacticalAdvantage()
|
|
|
-{
|
|
|
- //TODO: smart pointers?
|
|
|
- delete ourWalkers;
|
|
|
- delete ourShooters;
|
|
|
- delete ourFlyers;
|
|
|
- delete enemyWalkers;
|
|
|
- delete enemyShooters;
|
|
|
- delete enemyFlyers;
|
|
|
- delete ourSpeed;
|
|
|
- delete enemySpeed;
|
|
|
- delete bankPresent;
|
|
|
- delete castleWalls;
|
|
|
- delete threat;
|
|
|
-}
|
|
|
-
|
|
|
-//std::shared_ptr<AbstractGoal> chooseSolution (std::vector<std::shared_ptr<AbstractGoal>> & 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;
|
|
|
-}
|
|
|
-FuzzyHelper::EvalVisitTile::~EvalVisitTile()
|
|
|
-{
|
|
|
- delete strengthRatio;
|
|
|
- delete heroStrength;
|
|
|
- delete turnDistance;
|
|
|
- delete missionImportance;
|
|
|
- delete estimatedReward;
|
|
|
-}
|
|
|
-
|
|
|
-void FuzzyHelper::initVisitTile()
|
|
|
-{
|
|
|
- try
|
|
|
- {
|
|
|
- vt.strengthRatio = new fl::InputVariable("strengthRatio"); //hero must be strong enough to defeat guards
|
|
|
- vt.heroStrength = new fl::InputVariable("heroStrength"); //we want to use weakest possible hero
|
|
|
- vt.turnDistance = new fl::InputVariable("turnDistance"); //we want to use hero who is near
|
|
|
- vt.missionImportance = new fl::InputVariable("lockedMissionImportance"); //we may want to preempt hero with low-priority mission
|
|
|
- vt.estimatedReward = new fl::InputVariable("estimatedReward"); //indicate AI that content of the file is important or it is probably bad
|
|
|
- vt.value = new fl::OutputVariable("Value");
|
|
|
- vt.value->setMinimum(0);
|
|
|
- vt.value->setMaximum(5);
|
|
|
-
|
|
|
- std::vector<fl::InputVariable *> helper = {vt.strengthRatio, vt.heroStrength, vt.turnDistance, vt.missionImportance, vt.estimatedReward};
|
|
|
- for(auto val : helper)
|
|
|
- {
|
|
|
- vt.engine.addInputVariable(val);
|
|
|
- }
|
|
|
- vt.engine.addOutputVariable(vt.value);
|
|
|
-
|
|
|
- vt.strengthRatio->addTerm(new fl::Ramp("LOW", SAFE_ATTACK_CONSTANT, 0));
|
|
|
- vt.strengthRatio->addTerm(new fl::Ramp("HIGH", SAFE_ATTACK_CONSTANT, SAFE_ATTACK_CONSTANT * 3));
|
|
|
- vt.strengthRatio->setRange(0, SAFE_ATTACK_CONSTANT * 3);
|
|
|
-
|
|
|
- //strength compared to our main hero
|
|
|
- vt.heroStrength->addTerm(new fl::Ramp("LOW", 0.2, 0));
|
|
|
- vt.heroStrength->addTerm(new fl::Triangle("MEDIUM", 0.2, 0.8));
|
|
|
- vt.heroStrength->addTerm(new fl::Ramp("HIGH", 0.5, 1));
|
|
|
- vt.heroStrength->setRange(0.0, 1.0);
|
|
|
-
|
|
|
- vt.turnDistance->addTerm(new fl::Ramp("SMALL", 0.5, 0));
|
|
|
- vt.turnDistance->addTerm(new fl::Triangle("MEDIUM", 0.1, 0.8));
|
|
|
- vt.turnDistance->addTerm(new fl::Ramp("LONG", 0.5, 3));
|
|
|
- vt.turnDistance->setRange(0.0, 3.0);
|
|
|
-
|
|
|
- vt.missionImportance->addTerm(new fl::Ramp("LOW", 2.5, 0));
|
|
|
- vt.missionImportance->addTerm(new fl::Triangle("MEDIUM", 2, 3));
|
|
|
- vt.missionImportance->addTerm(new fl::Ramp("HIGH", 2.5, 5));
|
|
|
- vt.missionImportance->setRange(0.0, 5.0);
|
|
|
-
|
|
|
- vt.estimatedReward->addTerm(new fl::Ramp("LOW", 2.5, 0));
|
|
|
- vt.estimatedReward->addTerm(new fl::Ramp("HIGH", 2.5, 5));
|
|
|
- vt.estimatedReward->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
|
|
|
- vt.value->addTerm(new fl::Ramp("LOW", 2.5, 0));
|
|
|
- vt.value->addTerm(new fl::Triangle("MEDIUM", 2, 3)); //can't be center of mass :/
|
|
|
- vt.value->addTerm(new fl::Ramp("HIGH", 2.5, 5));
|
|
|
- vt.value->setRange(0.0, 5.0);
|
|
|
-
|
|
|
- //use unarmed scouts if possible
|
|
|
- vt.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
|
|
|
- vt.addRule("if strengthRatio is HIGH and heroStrength is MEDIUM then Value is somewhat HIGH");
|
|
|
- vt.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)
|
|
|
- vt.addRule("if strengthRatio is LOW and heroStrength is LOW then Value is very LOW");
|
|
|
- //attempt to arm secondary heroes is not stupid
|
|
|
- vt.addRule("if strengthRatio is LOW and heroStrength is MEDIUM then Value is somewhat HIGH");
|
|
|
- vt.addRule("if strengthRatio is LOW and heroStrength is HIGH then Value is LOW");
|
|
|
-
|
|
|
- //do not cancel important goals
|
|
|
- vt.addRule("if lockedMissionImportance is HIGH then Value is very LOW");
|
|
|
- vt.addRule("if lockedMissionImportance is MEDIUM then Value is somewhat LOW");
|
|
|
- vt.addRule("if lockedMissionImportance is LOW then Value is HIGH");
|
|
|
- //pick nearby objects if it's easy, avoid long walks
|
|
|
- vt.addRule("if turnDistance is SMALL then Value is HIGH");
|
|
|
- vt.addRule("if turnDistance is MEDIUM then Value is MEDIUM");
|
|
|
- vt.addRule("if turnDistance is LONG then Value is LOW");
|
|
|
- //some goals are more rewarding by definition f.e. capturing town is more important than collecting resource - experimental
|
|
|
- vt.addRule("if estimatedReward is HIGH then Value is very HIGH");
|
|
|
- vt.addRule("if estimatedReward is LOW then Value is somewhat LOW");
|
|
|
- }
|
|
|
- catch(fl::Exception & fe)
|
|
|
- {
|
|
|
- logAi->error("visitTile: %s", fe.getWhat());
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void FuzzyHelper::initWanderTarget()
|
|
|
-{
|
|
|
- try
|
|
|
- {
|
|
|
- wanderTarget.distance = new fl::InputVariable("distance"); //distance on map from object
|
|
|
- wanderTarget.objectValue = new fl::InputVariable("objectValue"); //value of that object type known by AI
|
|
|
- wanderTarget.visitGain = new fl::OutputVariable("visitGain");
|
|
|
- wanderTarget.visitGain->setMinimum(0);
|
|
|
- wanderTarget.visitGain->setMaximum(10);
|
|
|
-
|
|
|
- wanderTarget.engine.addInputVariable(wanderTarget.distance);
|
|
|
- wanderTarget.engine.addInputVariable(wanderTarget.objectValue);
|
|
|
- wanderTarget.engine.addOutputVariable(wanderTarget.visitGain);
|
|
|
-
|
|
|
- //for now distance variable same as in as VisitTile
|
|
|
- wanderTarget.distance->addTerm(new fl::Ramp("SHORT", 0.5, 0));
|
|
|
- wanderTarget.distance->addTerm(new fl::Triangle("MEDIUM", 0.1, 0.8));
|
|
|
- wanderTarget.distance->addTerm(new fl::Ramp("LONG", 0.5, 3));
|
|
|
- wanderTarget.distance->setRange(0, 3.0);
|
|
|
-
|
|
|
- //objectValue ranges are based on checking RMG priorities of some objects and trying to guess sane value ranges
|
|
|
- wanderTarget.objectValue->addTerm(new fl::Ramp("LOW", 3000, 0)); //I have feeling that concave shape might work well instead of ramp for objectValue FL terms
|
|
|
- wanderTarget.objectValue->addTerm(new fl::Triangle("MEDIUM", 2500, 6000));
|
|
|
- wanderTarget.objectValue->addTerm(new fl::Ramp("HIGH", 5000, 20000));
|
|
|
- wanderTarget.objectValue->setRange(0, 20000); //relic artifact value is border value by design, even better things are scaled down.
|
|
|
-
|
|
|
- wanderTarget.visitGain->addTerm(new fl::Ramp("LOW", 5, 0));
|
|
|
- wanderTarget.visitGain->addTerm(new fl::Triangle("MEDIUM", 4, 6));
|
|
|
- wanderTarget.visitGain->addTerm(new fl::Ramp("HIGH", 5, 10));
|
|
|
- wanderTarget.visitGain->setRange(0, 10);
|
|
|
-
|
|
|
- wanderTarget.addRule("if distance is LONG and objectValue is HIGH then visitGain is MEDIUM");
|
|
|
- wanderTarget.addRule("if distance is MEDIUM and objectValue is HIGH then visitGain is somewhat HIGH");
|
|
|
- wanderTarget.addRule("if distance is SHORT and objectValue is HIGH then visitGain is HIGH");
|
|
|
-
|
|
|
- wanderTarget.addRule("if distance is LONG and objectValue is MEDIUM then visitGain is somewhat LOW");
|
|
|
- wanderTarget.addRule("if distance is MEDIUM and objectValue is MEDIUM then visitGain is MEDIUM");
|
|
|
- wanderTarget.addRule("if distance is SHORT and objectValue is MEDIUM then visitGain is somewhat HIGH");
|
|
|
-
|
|
|
- wanderTarget.addRule("if distance is LONG and objectValue is LOW then visitGain is very LOW");
|
|
|
- wanderTarget.addRule("if distance is MEDIUM and objectValue is LOW then visitGain is LOW");
|
|
|
- wanderTarget.addRule("if distance is SHORT and objectValue is LOW then visitGain is MEDIUM");
|
|
|
- }
|
|
|
- catch(fl::Exception & fe)
|
|
|
- {
|
|
|
- logAi->error("FindWanderTarget: %s", fe.getWhat());
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-float FuzzyHelper::evaluate(Goals::VisitTile & g)
|
|
|
-{
|
|
|
- //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));
|
|
|
- float turns = calculateTurnDistanceInputValue(g.hero.h, g.tile);
|
|
|
- float missionImportance = 0;
|
|
|
- if(vstd::contains(ai->lockedHeroes, g.hero))
|
|
|
- missionImportance = ai->lockedHeroes[g.hero]->priority;
|
|
|
-
|
|
|
- float strengthRatio = 10.0f; //we are much stronger than enemy
|
|
|
- ui64 danger = evaluateDanger(g.tile, g.hero.h);
|
|
|
- if(danger)
|
|
|
- strengthRatio = (fl::scalar)g.hero.h->getTotalStrength() / danger;
|
|
|
-
|
|
|
- float tilePriority = 0;
|
|
|
- if(g.objid == -1)
|
|
|
- {
|
|
|
- vt.estimatedReward->setEnabled(false);
|
|
|
- }
|
|
|
- else if(g.objid == Obj::TOWN) //TODO: move to getObj eventually and add appropiate logic there
|
|
|
- {
|
|
|
- vt.estimatedReward->setEnabled(true);
|
|
|
- tilePriority = 5;
|
|
|
- }
|
|
|
-
|
|
|
- try
|
|
|
- {
|
|
|
- vt.strengthRatio->setValue(strengthRatio);
|
|
|
- vt.heroStrength->setValue((fl::scalar)g.hero->getTotalStrength() / ai->primaryHero()->getTotalStrength());
|
|
|
- vt.turnDistance->setValue(turns);
|
|
|
- vt.missionImportance->setValue(missionImportance);
|
|
|
- vt.estimatedReward->setValue(tilePriority);
|
|
|
-
|
|
|
- vt.engine.process();
|
|
|
- //engine.process(VISIT_TILE); //TODO: Process only Visit_Tile
|
|
|
- g.priority = vt.value->getValue();
|
|
|
- }
|
|
|
- catch(fl::Exception & fe)
|
|
|
- {
|
|
|
- logAi->error("evaluate VisitTile: %s", fe.getWhat());
|
|
|
- }
|
|
|
- assert(g.priority >= 0);
|
|
|
- return g.priority;
|
|
|
-}
|
|
|
-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
|
|
|
-}
|
|
|
-
|
|
|
-FuzzyHelper::EvalWanderTargetObject::~EvalWanderTargetObject()
|
|
|
-{
|
|
|
- delete distance;
|
|
|
- delete objectValue;
|
|
|
- delete visitGain;
|
|
|
-}
|
DjWarmonger