mirror of
https://github.com/vcmi/vcmi.git
synced 2025-01-24 03:47:18 +02:00
Experiment: goal values calculated by Fuzzy Helper will be stored in "priority" field and used in consecutive calculations.
This commit is contained in:
DjWarmonger
parent
7af9b0ea74
commit
603cbd8850
@ -306,21 +306,18 @@ Goals::TSubgoal FuzzyHelper::chooseSolution (Goals::TGoalVec vec)
|
||||
if (vec.empty()) //no possibilities found
|
||||
return sptr(Goals::Invalid());
|
||||
|
||||
typedef std::pair<Goals::TSubgoal, float> goalValue;
|
||||
std::vector <goalValue> values;
|
||||
|
||||
for (auto g : vec)
|
||||
{
|
||||
values.push_back (std::make_pair(g, g->accept(this)));
|
||||
g->setpriority (g->accept(this));
|
||||
}
|
||||
|
||||
auto compareGoals = [&](const goalValue & lhs, const goalValue & rhs) -> bool
|
||||
auto compareGoals = [&](Goals::TSubgoal & lhs, const Goals::TSubgoal & rhs) -> bool
|
||||
{
|
||||
return lhs.second < rhs.second;
|
||||
return lhs->priority < rhs->priority;
|
||||
};
|
||||
|
||||
boost::sort (values, compareGoals);
|
||||
return values.back().first;
|
||||
boost::sort (vec, compareGoals);
|
||||
return vec.back();
|
||||
}
|
||||
|
||||
float FuzzyHelper::evaluate (Goals::Explore & g)
|
||||
@ -404,14 +401,12 @@ float FuzzyHelper::evaluate (Goals::VisitTile & g)
|
||||
if (!g.hero)
|
||||
return 0;
|
||||
|
||||
float output = 0;
|
||||
|
||||
cb->setSelection (g.hero.h);
|
||||
int distance = cb->getDistance(g.tile); //at this point we already assume tile is reachable
|
||||
|
||||
float missionImportance = 0;
|
||||
if (vstd::contains(ai->lockedHeroes, g.hero))
|
||||
missionImportance = ai->lockedHeroes[g.hero]->importanceWhenLocked();
|
||||
missionImportance = ai->lockedHeroes[g.hero]->priority;
|
||||
|
||||
float strengthRatio = 100; //we are much stronger than enemy
|
||||
ui64 danger = evaluateDanger (g.tile, g.hero.h);
|
||||
@ -427,13 +422,13 @@ float FuzzyHelper::evaluate (Goals::VisitTile & g)
|
||||
vt.movement->setInput(g.hero->movement);
|
||||
|
||||
engine.process (VISIT_TILE);
|
||||
output = vt.value->output().defuzzify();
|
||||
g.priority = vt.value->output().defuzzify();
|
||||
}
|
||||
catch (fl::FuzzyException & fe)
|
||||
{
|
||||
logAi->errorStream() << "evaluate VisitTile " << fe.name() << ": " << fe.message();
|
||||
}
|
||||
return output;
|
||||
return g.priority;
|
||||
|
||||
}
|
||||
float FuzzyHelper::evaluate (Goals::VisitHero & g)
|
||||
|
||||
@ -242,10 +242,6 @@ TSubgoal FindObj::whatToDoToAchieve()
|
||||
else
|
||||
return sptr (Goals::Explore());
|
||||
}
|
||||
float FindObj::importanceWhenLocked() const
|
||||
{
|
||||
return 1; //we will probably fins it anyway, someday
|
||||
}
|
||||
|
||||
std::string GetObj::completeMessage() const
|
||||
{
|
||||
@ -271,11 +267,6 @@ TSubgoal GetObj::whatToDoToAchieve()
|
||||
return sptr (Goals::ClearWayTo(pos).sethero(hero));
|
||||
}
|
||||
|
||||
float GetObj::importanceWhenLocked() const
|
||||
{
|
||||
return 3;
|
||||
}
|
||||
|
||||
bool GetObj::fulfillsMe (TSubgoal goal)
|
||||
{
|
||||
if (goal->goalType == Goals::VISIT_TILE)
|
||||
@ -313,11 +304,6 @@ TSubgoal VisitHero::whatToDoToAchieve()
|
||||
return sptr (Goals::Invalid());
|
||||
}
|
||||
|
||||
float VisitHero::importanceWhenLocked() const
|
||||
{
|
||||
return 4;
|
||||
}
|
||||
|
||||
bool VisitHero::fulfillsMe (TSubgoal goal)
|
||||
{
|
||||
if (goal->goalType == Goals::VISIT_TILE && cb->getObj(ObjectInstanceID(objid))->visitablePos() == goal->tile)
|
||||
@ -334,11 +320,6 @@ TSubgoal GetArtOfType::whatToDoToAchieve()
|
||||
return sptr (Goals::Invalid());
|
||||
}
|
||||
|
||||
float GetArtOfType::importanceWhenLocked() const
|
||||
{
|
||||
return 2;
|
||||
}
|
||||
|
||||
TSubgoal ClearWayTo::whatToDoToAchieve()
|
||||
{
|
||||
assert(cb->isInTheMap(tile)); //set tile
|
||||
@ -402,11 +383,6 @@ TGoalVec ClearWayTo::getAllPossibleSubgoals()
|
||||
return ret;
|
||||
}
|
||||
|
||||
float ClearWayTo::importanceWhenLocked() const
|
||||
{
|
||||
return 5;
|
||||
}
|
||||
|
||||
std::string Explore::completeMessage() const
|
||||
{
|
||||
return "Hero " + hero.get()->name + " completed exploration";
|
||||
@ -494,11 +470,6 @@ TGoalVec Explore::getAllPossibleSubgoals()
|
||||
return ret;
|
||||
};
|
||||
|
||||
float Explore::importanceWhenLocked() const
|
||||
{
|
||||
return 1; //exploration is natural and lowpriority process
|
||||
}
|
||||
|
||||
TSubgoal RecruitHero::whatToDoToAchieve()
|
||||
{
|
||||
const CGTownInstance *t = ai->findTownWithTavern();
|
||||
@ -536,11 +507,6 @@ TSubgoal VisitTile::whatToDoToAchieve()
|
||||
return ret;
|
||||
}
|
||||
|
||||
float VisitTile::importanceWhenLocked() const
|
||||
{
|
||||
return 5; //depends on a distance, but we should really reach the tile once it was selected
|
||||
}
|
||||
|
||||
TGoalVec VisitTile::getAllPossibleSubgoals()
|
||||
{
|
||||
TGoalVec ret;
|
||||
@ -582,11 +548,6 @@ TSubgoal DigAtTile::whatToDoToAchieve()
|
||||
return sptr (Goals::VisitTile(tile));
|
||||
}
|
||||
|
||||
float DigAtTile::importanceWhenLocked() const
|
||||
{
|
||||
return 20; //do not! interrupt tile digging
|
||||
}
|
||||
|
||||
TSubgoal BuildThis::whatToDoToAchieve()
|
||||
{
|
||||
//TODO check res
|
||||
@ -595,11 +556,6 @@ TSubgoal BuildThis::whatToDoToAchieve()
|
||||
return iAmElementar();
|
||||
}
|
||||
|
||||
float BuildThis::importanceWhenLocked() const
|
||||
{
|
||||
return 5;
|
||||
}
|
||||
|
||||
TSubgoal CollectRes::whatToDoToAchieve()
|
||||
{
|
||||
std::vector<const IMarket*> markets;
|
||||
@ -667,11 +623,6 @@ TSubgoal CollectRes::whatToDoToAchieve()
|
||||
return sptr (setisElementar(true)); //all the conditions for trade are met
|
||||
}
|
||||
|
||||
float CollectRes::importanceWhenLocked() const
|
||||
{
|
||||
return 2;
|
||||
}
|
||||
|
||||
TSubgoal GatherTroops::whatToDoToAchieve()
|
||||
{
|
||||
std::vector<const CGDwelling *> dwellings;
|
||||
@ -727,11 +678,6 @@ TSubgoal GatherTroops::whatToDoToAchieve()
|
||||
//TODO: exchange troops between heroes
|
||||
}
|
||||
|
||||
float GatherTroops::importanceWhenLocked() const
|
||||
{
|
||||
return 2;
|
||||
}
|
||||
|
||||
TSubgoal Conquer::whatToDoToAchieve()
|
||||
{
|
||||
return fh->chooseSolution (getAllPossibleSubgoals());
|
||||
@ -776,21 +722,11 @@ TGoalVec Conquer::getAllPossibleSubgoals()
|
||||
return ret;
|
||||
}
|
||||
|
||||
float Conquer::importanceWhenLocked() const
|
||||
{
|
||||
return 10; //defeating opponent is hig priority, always
|
||||
}
|
||||
|
||||
TSubgoal Build::whatToDoToAchieve()
|
||||
{
|
||||
return iAmElementar();
|
||||
}
|
||||
|
||||
float Build::importanceWhenLocked() const
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
TSubgoal Invalid::whatToDoToAchieve()
|
||||
{
|
||||
return iAmElementar();
|
||||
@ -887,11 +823,6 @@ TGoalVec GatherArmy::getAllPossibleSubgoals()
|
||||
return ret;
|
||||
}
|
||||
|
||||
float GatherArmy::importanceWhenLocked() const
|
||||
{
|
||||
return 2.5;
|
||||
}
|
||||
|
||||
//TSubgoal AbstractGoal::whatToDoToAchieve()
|
||||
//{
|
||||
// logAi->debugStream() << boost::format("Decomposing goal of type %s") % name();
|
||||
|
||||
@ -67,7 +67,7 @@ class AbstractGoal
|
||||
public:
|
||||
bool isElementar; VSETTER(bool, isElementar)
|
||||
bool isAbstract; VSETTER(bool, isAbstract)
|
||||
int priority; VSETTER(bool, priority)
|
||||
float priority; VSETTER(float, priority)
|
||||
int value; VSETTER(int, value)
|
||||
int resID; VSETTER(int, resID)
|
||||
int objid; VSETTER(int, objid)
|
||||
@ -104,8 +104,6 @@ public:
|
||||
|
||||
virtual TGoalVec getAllPossibleSubgoals() = 0;
|
||||
virtual TSubgoal whatToDoToAchieve() = 0;
|
||||
virtual float importanceWhenLocked() const {return -1e10;}; //how much would it cost to interrupt the goal
|
||||
//probably could use some sophisticated fuzzy evalluation for it as well
|
||||
|
||||
///Visitor pattern
|
||||
//TODO: make accept work for shared_ptr... somehow
|
||||
@ -146,7 +144,7 @@ public:
|
||||
|
||||
OSETTER(bool, isElementar)
|
||||
OSETTER(bool, isAbstract)
|
||||
OSETTER(bool, priority)
|
||||
OSETTER(float, priority)
|
||||
OSETTER(int, value)
|
||||
OSETTER(int, resID)
|
||||
OSETTER(int, objid)
|
||||
@ -158,6 +156,7 @@ public:
|
||||
|
||||
void accept (VCAI * ai) override;
|
||||
float accept (FuzzyHelper * f) override;
|
||||
//float importanceWhenLocked() const override;
|
||||
|
||||
CGoal<T> * clone() const override
|
||||
{
|
||||
@ -182,157 +181,141 @@ TSubgoal sptr(const AbstractGoal & tmp);
|
||||
class Invalid : public CGoal<Invalid>
|
||||
{
|
||||
public:
|
||||
Invalid() : CGoal (Goals::INVALID){};
|
||||
Invalid() : CGoal (Goals::INVALID) {priority = -1e10;};
|
||||
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
//float importanceWhenLocked() const override;
|
||||
};
|
||||
class Win : public CGoal<Win>
|
||||
{
|
||||
public:
|
||||
Win() : CGoal (Goals::WIN){};
|
||||
Win() : CGoal (Goals::WIN) {priority = 100;};
|
||||
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
//float importanceWhenLocked() const override; //can't be locked, doesn't make much sense anyway
|
||||
};
|
||||
class NotLose : public CGoal<NotLose>
|
||||
{
|
||||
public:
|
||||
NotLose() : CGoal (Goals::DO_NOT_LOSE){};
|
||||
NotLose() : CGoal (Goals::DO_NOT_LOSE) {priority = 100;};
|
||||
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
float importanceWhenLocked() const override;
|
||||
};
|
||||
class Conquer : public CGoal<Conquer>
|
||||
{
|
||||
public:
|
||||
Conquer() : CGoal (Goals::CONQUER){};
|
||||
Conquer() : CGoal (Goals::CONQUER) {priority = 10;};
|
||||
TGoalVec getAllPossibleSubgoals() override;
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
float importanceWhenLocked() const override;
|
||||
};
|
||||
class Build : public CGoal<Build>
|
||||
{
|
||||
public:
|
||||
Build() : CGoal (Goals::BUILD){};
|
||||
Build() : CGoal (Goals::BUILD) {priority = 1;};
|
||||
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
float importanceWhenLocked() const override;
|
||||
};
|
||||
class Explore : public CGoal<Explore>
|
||||
{
|
||||
public:
|
||||
Explore() : CGoal (Goals::EXPLORE){};
|
||||
Explore() : CGoal (Goals::EXPLORE){priority = 1;};
|
||||
Explore(HeroPtr h) : CGoal (Goals::EXPLORE){hero = h;};
|
||||
TGoalVec getAllPossibleSubgoals() override;
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
std::string completeMessage() const override;
|
||||
float importanceWhenLocked() const override;
|
||||
};
|
||||
class GatherArmy : public CGoal<GatherArmy>
|
||||
{
|
||||
private:
|
||||
GatherArmy() : CGoal (Goals::GATHER_ARMY){};
|
||||
public:
|
||||
GatherArmy(int val) : CGoal (Goals::GATHER_ARMY){value = val;};
|
||||
GatherArmy(int val) : CGoal (Goals::GATHER_ARMY){value = val; priority = 2.5;};
|
||||
TGoalVec getAllPossibleSubgoals() override;
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
std::string completeMessage() const override;
|
||||
float importanceWhenLocked() const override;
|
||||
};
|
||||
class BoostHero : public CGoal<BoostHero>
|
||||
{
|
||||
public:
|
||||
BoostHero() : CGoal (Goals::INVALID){}; //TODO
|
||||
BoostHero() : CGoal (Goals::INVALID){priority = -1e10;}; //TODO
|
||||
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
float importanceWhenLocked() const override;
|
||||
};
|
||||
class RecruitHero : public CGoal<RecruitHero>
|
||||
{
|
||||
public:
|
||||
RecruitHero() : CGoal (Goals::RECRUIT_HERO){};
|
||||
RecruitHero() : CGoal (Goals::RECRUIT_HERO){priority = 1;};
|
||||
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
//float importanceWhenLocked() const override;
|
||||
};
|
||||
class BuildThis : public CGoal<BuildThis>
|
||||
{
|
||||
private:
|
||||
BuildThis() : CGoal (Goals::BUILD_STRUCTURE){};
|
||||
public:
|
||||
BuildThis(BuildingID Bid, const CGTownInstance *tid) : CGoal (Goals::BUILD_STRUCTURE) {bid = Bid; town = tid;};
|
||||
BuildThis(BuildingID Bid) : CGoal (Goals::BUILD_STRUCTURE) {bid = Bid;};
|
||||
BuildThis(BuildingID Bid, const CGTownInstance *tid) : CGoal (Goals::BUILD_STRUCTURE) {bid = Bid; town = tid; priority = 5;};
|
||||
BuildThis(BuildingID Bid) : CGoal (Goals::BUILD_STRUCTURE) {bid = Bid; priority = 5;};
|
||||
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
float importanceWhenLocked() const override;
|
||||
};
|
||||
class CollectRes : public CGoal<CollectRes>
|
||||
{
|
||||
private:
|
||||
CollectRes() : CGoal (Goals::COLLECT_RES){};
|
||||
public:
|
||||
CollectRes(int rid, int val) : CGoal (Goals::COLLECT_RES) {resID = rid; value = val;};
|
||||
CollectRes(int rid, int val) : CGoal (Goals::COLLECT_RES) {resID = rid; value = val; priority = 2;};
|
||||
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
float importanceWhenLocked() const override;
|
||||
};
|
||||
class GatherTroops : public CGoal<GatherTroops>
|
||||
{
|
||||
private:
|
||||
GatherTroops() : CGoal (Goals::GATHER_TROOPS){};
|
||||
GatherTroops() : CGoal (Goals::GATHER_TROOPS){priority = 2;};
|
||||
public:
|
||||
GatherTroops(int type, int val) : CGoal (Goals::GATHER_TROOPS){objid = type; value = val;};
|
||||
GatherTroops(int type, int val) : CGoal (Goals::GATHER_TROOPS){objid = type; value = val; priority = 2;};
|
||||
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
float importanceWhenLocked() const override;
|
||||
};
|
||||
class GetObj : public CGoal<GetObj>
|
||||
{
|
||||
private:
|
||||
GetObj() {}; // empty constructor not allowed
|
||||
public:
|
||||
GetObj(int Objid) : CGoal(Goals::GET_OBJ) {objid = Objid;};
|
||||
GetObj(int Objid) : CGoal(Goals::GET_OBJ) {objid = Objid; priority = 3;};
|
||||
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
bool operator== (GetObj &g) {return g.objid == objid;}
|
||||
bool fulfillsMe (TSubgoal goal) override;
|
||||
std::string completeMessage() const override;
|
||||
float importanceWhenLocked() const override;
|
||||
};
|
||||
class FindObj : public CGoal<FindObj>
|
||||
{
|
||||
private:
|
||||
FindObj() {}; // empty constructor not allowed
|
||||
public:
|
||||
FindObj(int ID) : CGoal(Goals::FIND_OBJ) {objid = ID;};
|
||||
FindObj(int ID, int subID) : CGoal(Goals::FIND_OBJ) {objid = ID; resID = subID;};
|
||||
FindObj(int ID) : CGoal(Goals::FIND_OBJ) {objid = ID; priority = 1;};
|
||||
FindObj(int ID, int subID) : CGoal(Goals::FIND_OBJ) {objid = ID; resID = subID; priority = 1;};
|
||||
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
float importanceWhenLocked() const override;
|
||||
};
|
||||
class VisitHero : public CGoal<VisitHero>
|
||||
{
|
||||
private:
|
||||
VisitHero() : CGoal (Goals::VISIT_HERO){};
|
||||
public:
|
||||
VisitHero(int hid) : CGoal (Goals::VISIT_HERO){objid = hid;};
|
||||
VisitHero(int hid) : CGoal (Goals::VISIT_HERO){objid = hid; priority = 4;};
|
||||
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
bool operator== (VisitHero &g) {return g.objid == objid;}
|
||||
bool fulfillsMe (TSubgoal goal) override;
|
||||
std::string completeMessage() const override;
|
||||
float importanceWhenLocked() const override;
|
||||
};
|
||||
class GetArtOfType : public CGoal<GetArtOfType>
|
||||
{
|
||||
private:
|
||||
GetArtOfType() : CGoal (Goals::GET_ART_TYPE){};
|
||||
public:
|
||||
GetArtOfType(int type) : CGoal (Goals::GET_ART_TYPE){aid = type;};
|
||||
GetArtOfType(int type) : CGoal (Goals::GET_ART_TYPE){aid = type; priority = 2;};
|
||||
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
float importanceWhenLocked() const override;
|
||||
};
|
||||
class VisitTile : public CGoal<VisitTile>
|
||||
//tile, in conjunction with hero elementar; assumes tile is reachable
|
||||
@ -340,21 +323,19 @@ class VisitTile : public CGoal<VisitTile>
|
||||
private:
|
||||
VisitTile() {}; // empty constructor not allowed
|
||||
public:
|
||||
VisitTile(int3 Tile) : CGoal (Goals::VISIT_TILE) {tile = Tile;};
|
||||
VisitTile(int3 Tile) : CGoal (Goals::VISIT_TILE) {tile = Tile; priority = 5;};
|
||||
TGoalVec getAllPossibleSubgoals() override;
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
bool operator== (VisitTile &g) {return g.tile == tile;}
|
||||
std::string completeMessage() const override;
|
||||
float importanceWhenLocked() const override;
|
||||
};
|
||||
class ClearWayTo : public CGoal<ClearWayTo>
|
||||
{
|
||||
public:
|
||||
ClearWayTo(int3 Tile) : CGoal (Goals::CLEAR_WAY_TO) {tile = Tile;};
|
||||
ClearWayTo(int3 Tile) : CGoal (Goals::CLEAR_WAY_TO) {tile = Tile; priority = 5;};
|
||||
TGoalVec getAllPossibleSubgoals() override;
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
bool operator== (ClearWayTo &g) {return g.tile == tile;}
|
||||
float importanceWhenLocked() const override;
|
||||
};
|
||||
class DigAtTile : public CGoal<DigAtTile>
|
||||
//elementar with hero on tile
|
||||
@ -362,11 +343,10 @@ class DigAtTile : public CGoal<DigAtTile>
|
||||
private:
|
||||
DigAtTile() : CGoal (Goals::DIG_AT_TILE){};
|
||||
public:
|
||||
DigAtTile(int3 Tile) : CGoal (Goals::DIG_AT_TILE) {tile = Tile;};
|
||||
DigAtTile(int3 Tile) : CGoal (Goals::DIG_AT_TILE) {tile = Tile; priority = 20;};
|
||||
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
bool operator== (DigAtTile &g) {return g.tile == tile;}
|
||||
float importanceWhenLocked() const override;
|
||||
};
|
||||
|
||||
class CIssueCommand : public CGoal<CIssueCommand>
|
||||
@ -374,10 +354,9 @@ class CIssueCommand : public CGoal<CIssueCommand>
|
||||
std::function<bool()> command;
|
||||
|
||||
public:
|
||||
CIssueCommand(std::function<bool()> _command): CGoal(ISSUE_COMMAND), command(_command) {}
|
||||
CIssueCommand(std::function<bool()> _command): CGoal(ISSUE_COMMAND), command(_command) {priority = 1e10;};
|
||||
TGoalVec getAllPossibleSubgoals() override {return TGoalVec();};
|
||||
TSubgoal whatToDoToAchieve() override;
|
||||
//float importanceWhenLocked() const override; //unsupported yet, but shoudl be highest
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user