Split Fuzzy.cpp/h

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"

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
 )

AI/VCAI/FuzzyEngines.cpp

@@ -1,38 +1,22 @@
 /*
- * Fuzzy.cpp, part of VCMI engine
+* FuzzyEngines.cpp, part of VCMI engine
- *
+*
- * Authors: listed in file AUTHORS in main folder
+* Authors: listed in file AUTHORS in main folder
- *
+*
- * License: GNU General Public License v2.0 or later
+* License: GNU General Public License v2.0 or later
- * Full text of license available in license.txt file, in main folder
+* Full text of license available in license.txt file, in main folder
- *
+*
 */
 #include "StdInc.h"
-#include "Fuzzy.h"
+#include "FuzzyEngines.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 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
 
-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()
@@ -106,25 +90,6 @@ float HeroMovementGoalEngineBase::calculateTurnDistanceInputValue(const CGHeroIn
 	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
-
-}
-
 TacticalAdvantageEngine::TacticalAdvantageEngine()
 {
 	try
@@ -193,10 +158,10 @@ TacticalAdvantageEngine::TacticalAdvantageEngine()
 
 		threat = new fl::OutputVariable("Threat");
 		engine.addOutputVariable(threat);
-		threat->addTerm(new fl::Ramp("LOW", 1, MIN_AI_STRENGHT));
+		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_STRENGHT, 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");
@@ -280,40 +245,6 @@ float TacticalAdvantageEngine::getTacticalAdvantage(const CArmedInstance * we, c
 
 //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;
-}
 HeroMovementGoalEngineBase::HeroMovementGoalEngineBase()
 {
 	try
@@ -411,91 +342,6 @@ void HeroMovementGoalEngineBase::setSharedFuzzyVariables(Goals::AbstractGoal & g
 	}
 }
 
-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
@@ -528,7 +374,7 @@ float GetObjEngine::evaluate(Goals::AbstractGoal & goal)
 	if(!g.hero)
 		return 0;
 
-	auto obj = cb->getObj(ObjectInstanceID(g.objid));
+	auto obj = ai->myCb->getObj(ObjectInstanceID(g.objid));
 
 
 	boost::optional<int> objValueKnownByAI = MapObjectsEvaluator::getInstance().getObjectValue(obj->ID, obj->subID);

AI/VCAI/FuzzyEngines.h

@@ -1,20 +1,17 @@
 /*
- * Fuzzy.h, part of VCMI engine
+* FuzzyEngines.h, part of VCMI engine
- *
+*
- * Authors: listed in file AUTHORS in main folder
+* Authors: listed in file AUTHORS in main folder
- *
+*
- * License: GNU General Public License v2.0 or later
+* License: GNU General Public License v2.0 or later
- * Full text of license available in license.txt file, in main folder
+* 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...
 {
@@ -75,34 +72,3 @@ public:
 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<AbstractGoal> chooseSolution (std::vector<std::shared_ptr<AbstractGoal>> & vec);
-};

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<VCAI> 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<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::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
+}

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<AbstractGoal> chooseSolution (std::vector<std::shared_ptr<AbstractGoal>> & vec);
+};

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

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"