AI heroes move to random safe objects.

AI recruits heroes.

AI/GeniusAI/BattleLogic.cpp

@@ -215,7 +215,7 @@ void CBattleLogic::MakeStatistics(int currentCreatureId)
 		(float)totalHitPoints / (float)totalEnemyHitPoints < 0.5f)
 	{
 		m_bEnemyDominates = true;
-		MsgBox("** EnemyDominates!");
+		DbgBox("** EnemyDominates!");
 	}
 	else
 	{
@@ -261,11 +261,11 @@ BattleAction CBattleLogic::MakeDecision(int stackID)
 	{
 		creatures = PerformDefaultAction(stackID, additionalInfo);
 	}
-	/*
+	
-	std::string message("Creature will be attacked - ");
+	/*std::string message("Creature will be attacked - ");
 	message += boost::lexical_cast<std::string>(creature_to_attack);
-	MsgBox(message.c_str());
+	DbgBox(message.c_str());*/
-	*/
+	
 
 	if (additionalInfo == -1 || creatures.empty())
 	{
@@ -288,7 +288,9 @@ BattleAction CBattleLogic::MakeDecision(int stackID)
 		}
 		else
 		{
+#if defined PRINT_DEBUG
 			PrintBattleAction(ba);
+#endif
 			return ba;
 		}
 	}
@@ -567,7 +569,9 @@ BattleAction CBattleLogic::MakeAttack(int attackerID, int destinationID)
 			{
 				ba.additionalInfo = dest_tile;
 				ba.actionType = action_walk_and_attack;
+#if defined PRINT_DEBUG
 				PrintBattleAction(ba);
+#endif
 				return ba;
 			}
 		}
@@ -578,7 +582,7 @@ BattleAction CBattleLogic::MakeAttack(int attackerID, int destinationID)
 			{
 				// attack!
 				ba.actionType = action_walk_and_attack;
-#if defined _DEBUG
+#if defined PRINT_DEBUG
 				PrintBattleAction(ba);
 #endif
 				return ba;
@@ -594,12 +598,12 @@ BattleAction CBattleLogic::MakeAttack(int attackerID, int destinationID)
 		message = "Attacker position X=";
 		message += boost::lexical_cast<std::string>(m_battleHelper.DecodeXPosition(nearest_pos)) + ", Y=";
 		message += boost::lexical_cast<std::string>(m_battleHelper.DecodeYPosition(nearest_pos));
-		MsgBox(message.c_str());
+		DbgBox(message.c_str());
 
 		ba.actionType = action_walk;
 		ba.destinationTile = (ui16)nearest_pos;
 		ba.additionalInfo  = -1;
-#if defined _DEBUG
+#if defined PRINT_DEBUG
 		PrintBattleAction(ba);
 #endif
 		return ba;

AI/GeniusAI/CGeniusAI.cpp

@@ -8,9 +8,11 @@ using namespace GeniusAI;
 #include <windows.h>
 #endif
 
-void MsgBox(const char *msg, bool messageBox)
+void DbgBox(const char *msg, bool messageBox)
 {
+#if defined PRINT_DEBUG
 #if defined _DEBUG
+//#if 0
 #	if defined (_MSC_VER) && (_MSC_VER >= 1020)
 	if (messageBox)
 	{
@@ -19,10 +21,11 @@ void MsgBox(const char *msg, bool messageBox)
 #	endif
 	std::cout << msg << std::endl;
 #endif
+#endif
 }
 
 CGeniusAI::CGeniusAI()
-	: m_generalAI(),turn(0)
+	: m_generalAI(),turn(0),firstTurn(true)
 {
 }
 
@@ -40,7 +43,7 @@ void CGeniusAI::init(ICallback *CB)
 	serialID = m_cb->getMySerial();
 	std::string info = std::string("GeniusAI initialized for player ") + boost::lexical_cast<std::string>(playerID);
 	m_battleLogic = NULL;
-	MsgBox(info.c_str());
+	DbgBox(info.c_str());
 }
 
 unsigned long randomFromInt(unsigned long in)
@@ -48,79 +51,10 @@ unsigned long randomFromInt(unsigned long in)
 	return (in*214013+2531011);
 }
 
-void CGeniusAI::doHero(const CGHeroInstance * h)
+
+void CGeniusAI::reportResources()
 {
-
-	
-	if(!h==NULL)
-	{
-		int3 destination, pos;
-		pos=h->convertPosition(h->pos,false);
-		
-		vector<int3> buildingPath;
-
-		int movement = h->movement;
-		int usedMovement = 0;
-		int attempts = 0;
-		CPath path;
-		do{
-			do{
-				destination=pos;
-				attempts++;
-				destination.x+=randomFromInt((attempts*1243)+turn)%9-4;
-				destination.y+=randomFromInt((attempts*1243)+turn+1234)%9-4;
-			}while((!m_cb->getPath(pos,destination,h,path)||(path.nodes[0].dist>=(movement-usedMovement))) && attempts<100);
-			
-			if(attempts<100)
-			{
-				pos = destination;
-				usedMovement += path.nodes[0].dist;
-				path.convert(0);
-				for(int i = path.nodes.size()-2;i>=0;i--)
-					buildingPath.push_back(path.nodes[i].coord);
-			}
-			else break;
-		}while(movement-usedMovement>=50);
-
-		for(int i = 0; i < buildingPath.size();i++)
-		{
-			m_cb->moveHero(h,buildingPath[i]);
-			//std::cout << "(" << buildingPath[i].x << ", " << buildingPath[i].y << ")" << std::endl;
-		}
-
-	}
-
-}
-
-void CGeniusAI::doTown(const CGTownInstance * t)
-{
-	if(m_cb->howManyHeroes(true)<3)		//recrute up to 3 heroes
-	{
-		if(t->visitingHero==NULL)
-		{
-			std::vector<const CGHeroInstance *> toBuy = m_cb->getAvailableHeroes(t);
-			if(toBuy[0]->army.slots.size()>1)//only buy heros with units
-			{
-				m_cb->recruitHero(t,toBuy[0]);
-			}
-		}
-
-	}
-
-//	m_cb->recruitCreatures(t, ui32 ID, ui32 amount)
-
-	
-}
-
-
-void CGeniusAI::yourTurn()
-{
-	//static boost::mutex mutex;
-	//boost::mutex::scoped_lock scoped_lock(mutex);
-	turn++;
-
 	std::cout << "AI Player " <<m_cb->getMySerial()<< " with " <<  m_cb->howManyHeroes(true) << " heroes. " << std::endl;
-
 	
 	std::cout << m_cb->getResourceAmount(0) << " wood. ";
 	std::cout << m_cb->getResourceAmount(1) << " mercury. ";
@@ -130,17 +64,171 @@ void CGeniusAI::yourTurn()
 	std::cout << m_cb->getResourceAmount(5) << " gems. ";
 	std::cout << m_cb->getResourceAmount(6) << " gold.";
 	std::cout << std::endl;
+}
+
+void CGeniusAI::addHeroObjectives(CGeniusAI::HypotheticalGameState::HeroModel &h, CGeniusAI::HypotheticalGameState &hgs)
+{
+	int3 hpos, destination;
+	CPath path;
+	hpos = h.pos;
+	int movement = h.remainingMovement;
+	for(std::set<AIObjectContainer>::const_iterator i = hgs.knownVisitableObjects.begin(); i != hgs.knownVisitableObjects.end();i++)
+	{
+		if(i->o->ID==54||i->o->ID==34)	//creatures, another hero
+			continue;
+
+		if(i->o->getOwner()==m_cb->getMyColor())
+			continue;
+		
+		destination = i->o->getSightCenter();
+		if(hpos.z==destination.z)
+			if(m_cb->getPath(hpos,destination,h.h,path))
+		{
+			path.convert(0);
+			if(path.nodes[0].dist<movement)
+			{
+				AIObjective::Type tp = AIObjective::visit;
+				
+				HeroObjective ho(tp,i->o,&h);
+				std::set<HeroObjective>::iterator found = currentHeroObjectives.find(ho);
+				if(found==currentHeroObjectives.end())
+					currentHeroObjectives.insert(ho);
+				else
+					found->whoCanAchieve.push_back(&h);
+			}
+		}
+	}
+}
+void CGeniusAI::addTownObjectives(HypotheticalGameState::TownModel &t, HypotheticalGameState & hgs)
+{
+	//recruitHero
+	//recruitCreatures
+	//upgradeCreatures
+	//buildBuilding
+
+	if(hgs.heroModels.size()<3) //recruitHero
+	{
+		if(!t.visitingHero)
+		{
+			for(int i =0; i < hgs.AvailableHeroesToBuy.size();i++)
+				if(hgs.AvailableHeroesToBuy[i]->army.slots.size()>1)//only buy heros with units
+				{
+					TownObjective to(AIObjective::recruitHero,&t,0);
+					currentTownObjectives.insert(to);
+				}
+
+		}
+	}
+	
+
+//	for(int i = 0; i < t.t->creatures.size() ;i++)
+//	{
+//		int ID = t.t->creatures[i].second.back();
+//		CCreature
+//		cout << "town has " << t.t->creatures[i].first << " level " << i+1 << " " << creature->namePl << endl;
+//	}
+	
 
 
-	std::vector < const CGHeroInstance *> heroes = m_cb->getHeroesInfo();	
+}
-	for(std::vector < const CGHeroInstance *>::iterator i = heroes.begin(); i < heroes.end(); i++)
-		doHero(*i);
 
-//	std::vector < const CGTownInstance *> towns = m_cb->getTownsInfo();	
+void CGeniusAI::TownObjective::fulfill(CGeniusAI & cg, HypotheticalGameState & hgs)
-//	for(std::vector < const CGTownInstance *>::iterator i = towns.begin(); i < towns.end(); i++)
+{
-//		doTown(*i);
+	switch(type)
+	{
+	case recruitHero:
+		cg.m_cb->recruitHero(whichTown->t,hgs.AvailableHeroesToBuy[which]);
+		hgs.heroModels.push_back(hgs.AvailableHeroesToBuy[which]);
+		whichTown->visitingHero = true;
+		//TODO: sub 2500 gold from hgs here
+	}
+}
+void CGeniusAI::getObjectives(CGeniusAI::HypotheticalGameState & hgs)
+{
+	currentHeroObjectives.clear();
+	currentTownObjectives.clear();
+	
+	for(std::vector <CGeniusAI::HypotheticalGameState::HeroModel>::iterator i = hgs.heroModels.begin(); i != hgs.heroModels.end(); i++)
+		addHeroObjectives(*i,hgs);
+
+	for(std::vector <CGeniusAI::HypotheticalGameState::TownModel>::iterator i = hgs.townModels.begin(); i != hgs.townModels.end(); i++)
+		addTownObjectives(*i,hgs);
+}
+
+void CGeniusAI::HeroObjective::fulfill(CGeniusAI & cg, HypotheticalGameState & hgs)
+{
+	switch(type)
+	{
+	case visit:
+		HypotheticalGameState::HeroModel * h = whoCanAchieve[rand()%whoCanAchieve.size()];
+		int3 hpos, destination;
+		CPath path;
+		hpos = h->pos;
+		//std::cout << "trying to visit " << object->hoverName << std::endl;
+		
+		destination = object->getSightCenter();
+		if(cg.m_cb->getPath(hpos,destination,h->h,path))
+		{
+			path.convert(0);
+			for(int i = path.nodes.size()-2;i>=0;i--)
+				cg.m_cb->moveHero(h->h,path.nodes[i].coord);
+			h->remainingMovement-=path.nodes[0].dist;
+			if(object->blockVisit)
+				h->pos = path.nodes[1].coord;
+			else
+				h->pos=destination;
+			std::set<AIObjectContainer>::iterator i = hgs.knownVisitableObjects.find(AIObjectContainer(object));
+			if(i!=hgs.knownVisitableObjects.end())
+				hgs.knownVisitableObjects.erase(i);
+		}
 
 
+	}
+}
+
+
+void CGeniusAI::yourTurn()
+{
+	static int seed = rand();
+	srand(seed);
+	if(firstTurn)
+	{
+		//m_cb->sendMessage("vcmieagles");
+		firstTurn = false;
+
+			
+	}
+	knownVisitableObjects.clear();
+	int3 pos = m_cb->getMapSize();
+	for(int x = 0;x<pos.x;x++)
+		for(int y = 0;y<pos.y;y++)
+			for(int z = 0;z<pos.z;z++)
+				tileRevealed(int3(x,y,z));
+
+	reportResources();
+	turn++;
+	HypotheticalGameState hgs(*this);
+	getObjectives(hgs);
+	vector<AIObjectivePtrCont> AIObjectiveQueue;
+	do{
+			
+		//std::cout << "I have " << currentHeroObjectives.size() << " things I could do with my heroes!" << std::endl;
+		//std::cout << "I have " << currentTownObjectives.size() << " things I could do with my towns!" << std::endl;
+		
+		AIObjectiveQueue.clear();
+		for(std::set<CGeniusAI::HeroObjective>::iterator i = currentHeroObjectives.begin(); i != currentHeroObjectives.end(); i++)
+			AIObjectiveQueue.push_back(AIObjectivePtrCont(&(*i)));
+		for(std::set<CGeniusAI::TownObjective>::iterator i = currentTownObjectives.begin(); i != currentTownObjectives.end(); i++)
+			AIObjectiveQueue.push_back(AIObjectivePtrCont(&(*i)));
+		if(!AIObjectiveQueue.empty())
+			max_element(AIObjectiveQueue.begin(),AIObjectiveQueue.end())->obj->fulfill(*this, hgs);
+
+		getObjectives(hgs);
+
+	}while(!currentHeroObjectives.empty());
+
+
+	seed = rand();
 	m_cb->endTurn();
 }
 
@@ -154,12 +242,24 @@ void CGeniusAI::heroCreated(const CGHeroInstance *hero)
 
 }
 
+void CGeniusAI::tileRevealed(int3 pos)
+{
+	std::vector < const CGObjectInstance * > objects = 	m_cb->getVisitableObjs(pos);
+	for(std::vector < const CGObjectInstance * >::iterator o = objects.begin();o!=objects.end();o++)
+		knownVisitableObjects.insert(*o);
+	objects = m_cb->getFlaggableObjects(pos);
+	for(std::vector < const CGObjectInstance * >::iterator o = objects.begin();o!=objects.end();o++)
+		knownVisitableObjects.insert(*o);
+}
+
+void CGeniusAI::tileHidden(int3 pos)
+{
+
+}
+
 void CGeniusAI::heroMoved(const TryMoveHero &TMH)
 {
-	MsgBox("** CGeniusAI::heroMoved **");
+	DbgBox("** CGeniusAI::heroMoved **");
-
-	
-
 }
 
 void CGeniusAI::heroGotLevel(const CGHeroInstance *hero, int pskill, std::vector<ui16> &skills, boost::function<void(ui32)> &callback)
@@ -187,7 +287,7 @@ void CGeniusAI::actionFinished(const BattleAction *action)
 	message += "), side(";
 	message += boost::lexical_cast<std::string>((unsigned)action->side);
 	message += ")";
-	MsgBox(message.c_str());
+	DbgBox(message.c_str());
 }
 /**
  * occurs BEFORE every action taken by any stack or by the hero
@@ -199,21 +299,21 @@ void CGeniusAI::actionStarted(const BattleAction *action)
 	message += "), side(";
 	message += boost::lexical_cast<std::string>((unsigned)action->side);
 	message += ")";
-	MsgBox(message.c_str());
+	DbgBox(message.c_str());
 }
 /**
  * called when stack is performing attack
  */
 void CGeniusAI::battleAttack(BattleAttack *ba)
 {
-	MsgBox("\t\t\tCGeniusAI::battleAttack");
+	DbgBox("\t\t\tCGeniusAI::battleAttack");
 }
 /**
  * called when stack receives damage (after battleAttack())
  */
 void CGeniusAI::battleStacksAttacked(std::set<BattleStackAttacked> & bsa)
 {
-	MsgBox("\t\t\tCGeniusAI::battleStacksAttacked");
+	DbgBox("\t\t\tCGeniusAI::battleStacksAttacked");
 }
 /**
  * called by engine when battle starts; side=0 - left, side=1 - right
@@ -224,7 +324,7 @@ void CGeniusAI::battleStart(CCreatureSet *army1, CCreatureSet *army2, int3 tile,
 	assert(!m_battleLogic); //************** assert fails when AI starts two battles at same time? ***************
 	m_battleLogic = new BattleAI::CBattleLogic(m_cb, army1, army2, tile, hero1, hero2, side);
 
-	MsgBox("** CGeniusAI::battleStart **");
+	DbgBox("** CGeniusAI::battleStart **");
 }
 /**
  *
@@ -241,7 +341,7 @@ void CGeniusAI::battleEnd(BattleResult *br)
 	delete m_battleLogic;
 	m_battleLogic = NULL;
 
-	MsgBox("** CGeniusAI::battleEnd **");
+	DbgBox("** CGeniusAI::battleEnd **");
 }
 /**
  * called at the beggining of each turn, round=-1 is the tactic phase, round=0 is the first "normal" turn
@@ -250,7 +350,7 @@ void CGeniusAI::battleNewRound(int round)
 {
 	std::string message("\tCGeniusAI::battleNewRound - ");
 	message += boost::lexical_cast<std::string>(round);
-	MsgBox(message.c_str());
+	DbgBox(message.c_str());
 
 	m_battleLogic->SetCurrentTurn(round);
 }
@@ -264,42 +364,42 @@ void CGeniusAI::battleStackMoved(int ID, int dest, int distance, bool end)
 	message += "), dest(";
 	message += boost::lexical_cast<std::string>(dest);
 	message += ")";
-	MsgBox(message.c_str());
+	DbgBox(message.c_str());
 }
 /**
  *
  */
 void CGeniusAI::battleSpellCast(SpellCast *sc)
 {
-	MsgBox("\t\t\tCGeniusAI::battleSpellCast");
+	DbgBox("\t\t\tCGeniusAI::battleSpellCast");
 }
 /**
  * called when battlefield is prepared, prior the battle beginning
  */
 void CGeniusAI::battlefieldPrepared(int battlefieldType, std::vector<CObstacle*> obstacles)
 {
-	MsgBox("CGeniusAI::battlefieldPrepared");
+	DbgBox("CGeniusAI::battlefieldPrepared");
 }
 /**
  *
  */
 void CGeniusAI::battleStackMoved(int ID, int dest, bool startMoving, bool endMoving)
 {
-	MsgBox("\t\t\tCGeniusAI::battleStackMoved");
+	DbgBox("\t\t\tCGeniusAI::battleStackMoved");
 }
 /**
  *
  */
 void CGeniusAI::battleStackAttacking(int ID, int dest)
 {
-	MsgBox("\t\t\tCGeniusAI::battleStackAttacking");
+	DbgBox("\t\t\tCGeniusAI::battleStackAttacking");
 }
 /**
  *
  */
 void CGeniusAI::battleStackIsAttacked(int ID, int dmg, int killed, int IDby, bool byShooting)
 {
-	MsgBox("\t\t\tCGeniusAI::battleStackIsAttacked");
+	DbgBox("\t\t\tCGeniusAI::battleStackIsAttacked");
 }
 
 /**
@@ -311,7 +411,7 @@ BattleAction CGeniusAI::activeStack(int stackID)
 
 	message += boost::lexical_cast<std::string>(stackID);
 	message += ")";
-	MsgBox(message.c_str());
+	DbgBox(message.c_str());
 
 	return m_battleLogic->MakeDecision(stackID);
 };

AI/GeniusAI/CGeniusAI.h

@@ -1,55 +1,217 @@
-#ifndef __CGENIUSAI_H__
+#ifndef __CGENIUSAI_H__
-#define __CGENIUSAI_H__
+#define __CGENIUSAI_H__
-
+
-#include "Common.h"
+#include "Common.h"
-#include "BattleLogic.h"
+#include "BattleLogic.h"
-#include "GeneralAI.h"
+#include "GeneralAI.h"
-namespace GeniusAI {
+#include "../../lib/VCMI_Lib.h"
-
+#include <set>
-class CGeniusAI : public CGlobalAI
+#include <list>
-{
+#include <queue>
-private:
+namespace GeniusAI {
-	ICallback*							m_cb;
+
-	GeniusAI::BattleAI::CBattleLogic*	m_battleLogic;
+class CGeniusAI : public CGlobalAI
-	GeniusAI::GeneralAI::CGeneralAI		m_generalAI;
+{
-
+private:
-	void doHero(const CGHeroInstance * h);
+	ICallback*							m_cb;
-	void doTown(const CGTownInstance * t);
+	GeniusAI::BattleAI::CBattleLogic*	m_battleLogic;
-	int turn;
+	GeniusAI::GeneralAI::CGeneralAI		m_generalAI;
-
+	class AIObjectContainer
-public:
+	{
-	CGeniusAI();
+	public:
-	virtual ~CGeniusAI();
+		AIObjectContainer(const CGObjectInstance * o):o(o){}
-
+		const CGObjectInstance * o;
-	virtual void init(ICallback * CB);
+		bool operator<(const AIObjectContainer& b)const
-	virtual void yourTurn();
+		{
-	virtual void heroKilled(const CGHeroInstance *);
+			if (o->pos!=b.o->pos)
-	virtual void heroCreated(const CGHeroInstance *);
+				return o->pos<b.o->pos;
-	virtual void heroMoved(const TryMoveHero &);
+			return o->id<b.o->id;
-	virtual void heroPrimarySkillChanged(const CGHeroInstance * hero, int which, int val) {};
+		}
-	virtual void showSelDialog(std::string text, std::vector<CSelectableComponent*> & components, int askID){};
+	};
-	virtual void showBlockingDialog(const std::string &text, const std::vector<Component> &components, ui32 askID, const int soundID, bool selection, bool cancel); //Show a dialog, player must take decision. If selection then he has to choose between one of given components, if cancel he is allowed to not choose. After making choice, CCallback::selectionMade should be called with number of selected component (1 - n) or 0 for cancel (if allowed) and askID.
+	std::set< AIObjectContainer > knownVisitableObjects;
-	virtual void tileRevealed(int3 pos){};
+
-	virtual void tileHidden(int3 pos){};
+	class HypotheticalGameState
-	virtual void heroGotLevel(const CGHeroInstance *hero, int pskill, std::vector<ui16> &skills, boost::function<void(ui32)> &callback);
+	{
-	virtual void showGarrisonDialog(const CArmedInstance *up, const CGHeroInstance *down, boost::function<void()> &onEnd);
+	public:
-	// battle
+		HypotheticalGameState(CGeniusAI & AI)
-	virtual void actionFinished(const BattleAction *action);//occurs AFTER every action taken by any stack or by the hero
+			:knownVisitableObjects(AI.knownVisitableObjects)
-	virtual void actionStarted(const BattleAction *action);//occurs BEFORE every action taken by any stack or by the hero
+		{
-	virtual void battleAttack(BattleAttack *ba); //called when stack is performing attack
+			std::vector < const CGHeroInstance *> heroes = AI.m_cb->getHeroesInfo();	
-	virtual void battleStacksAttacked(std::set<BattleStackAttacked> & bsa); //called when stack receives damage (after battleAttack())
+			for(std::vector < const CGHeroInstance *>::iterator i = heroes.begin(); i != heroes.end(); i++)
-	virtual void battleEnd(BattleResult *br);
+				heroModels.push_back(HeroModel(*i));
-	virtual void battleNewRound(int round); //called at the beggining of each turn, round=-1 is the tactic phase, round=0 is the first "normal" turn
+			
-	virtual void battleStackMoved(int ID, int dest, int distance, bool end);
+			std::vector < const CGTownInstance *> towns = AI.m_cb->getTownsInfo();	
-	virtual void battleSpellCast(SpellCast *sc);
+			for(std::vector < const CGTownInstance *>::iterator i = towns.begin(); i != towns.end(); i++)
-	virtual void battleStart(CCreatureSet *army1, CCreatureSet *army2, int3 tile, CGHeroInstance *hero1, CGHeroInstance *hero2, bool side); //called by engine when battle starts; side=0 - left, side=1 - right
+				townModels.push_back(TownModel(*i));
-	virtual void battlefieldPrepared(int battlefieldType, std::vector<CObstacle*> obstacles); //called when battlefield is prepared, prior the battle beginning
+
-	//
+			if(AI.m_cb->howManyTowns()!=0)
-	virtual void battleStackMoved(int ID, int dest, bool startMoving, bool endMoving);
+				AvailableHeroesToBuy = AI.m_cb->getAvailableHeroes(AI.m_cb->getTownInfo(0,0));
-	virtual void battleStackAttacking(int ID, int dest);
+		}
-	virtual void battleStackIsAttacked(int ID, int dmg, int killed, int IDby, bool byShooting);
+
-	virtual BattleAction activeStack(int stackID);
+		class TownModel
-};
+		{
-}
+		public:
-
+			TownModel(const CGTownInstance *t):t(t){visitingHero=(t->visitingHero!=NULL);}
-#endif // __CGENIUSAI_H__
+			const CGTownInstance *t;
+			bool visitingHero;
+		};
+		class HeroModel
+		{
+		public:
+			HeroModel(const CGHeroInstance * h):h(h){
+				pos = h->getPosition(false);remainingMovement = h->movement;
+			}
+			int3 pos;
+			int remainingMovement;
+			const CGHeroInstance * h;
+		};
+		std::vector<const CGHeroInstance *> AvailableHeroesToBuy;
+		std::vector<HeroModel> heroModels;
+		std::vector<TownModel> townModels;
+		std::set< AIObjectContainer > knownVisitableObjects;
+	};
+	void addHeroObjectives(HypotheticalGameState::HeroModel &h, HypotheticalGameState & hgs);
+	void addTownObjectives(HypotheticalGameState::TownModel &h, HypotheticalGameState & hgs);
+	void getObjectives(HypotheticalGameState & hgs);
+	void reportResources();
+	int turn;
+	bool firstTurn;
+
+
+	class AIObjective
+	{
+	public: 
+		enum Type
+		{
+			//hero objectives
+			visit,
+			attack,
+			flee,
+			dismissUnits,
+			dismissYourself,
+			finishTurn,			//uses up remaining motion to get somewhere nice.
+
+			//town objectives
+			recruitHero,
+			recruitCreatures,
+			upgradeCreatures,
+			buildBuilding
+		};
+		
+		Type type;
+		//virtual bool operator < (const AIObjective &)const=0;
+		//virtual bool stillPossible(const HypotheticalGameState &)const = 0;
+		virtual void fulfill(CGeniusAI &,HypotheticalGameState & hgs)=0;
+		virtual float getValue() const=0;	//how much is it worth to the AI to achieve
+	};
+
+	class HeroObjective: public AIObjective
+	{
+	public:
+		int3 pos;
+		const CGObjectInstance * object;
+		std::vector<HypotheticalGameState::HeroModel *> whoCanAchieve;
+		
+		HeroObjective(){}
+		HeroObjective(Type t):object(NULL){type = t;}
+		HeroObjective(Type t,const CGObjectInstance * object,HypotheticalGameState::HeroModel *h):object(object)
+		{
+			pos = object->pos;
+			type = t;
+			whoCanAchieve.push_back(h);
+			_value = rand();
+		}
+		bool operator < (const HeroObjective &other)const
+		{
+			if(type != other.type)
+				return type<other.type;
+			if(pos!=other.pos)
+				return pos < other.pos;
+			if(object->id!=other.object->id)
+				return object->id < other.object->id;
+			return false;
+		}
+		//bool stillPossible(const HypotheticalGameState &) const;
+		void fulfill(CGeniusAI &,HypotheticalGameState & hgs);
+		float getValue() const{return _value;}
+	private:
+		float _value;
+	};
+
+				//town objectives
+			//recruitHero,
+			//recruitCreatures,
+			//upgradeCreatures,
+			//buildBuilding
+
+	class TownObjective: public AIObjective
+	{
+	public:
+		HypotheticalGameState::TownModel * whichTown;
+		int which;				//which hero, which building, which creature, 
+
+		TownObjective(Type t,HypotheticalGameState::TownModel * tn,int which):whichTown(tn),which(which){type = t;_value = rand();}
+		
+		bool operator < (const TownObjective &other)const
+		{
+			if(type != other.type)
+				return type<other.type;
+			if(whichTown->t->id!=other.whichTown->t->id)
+				return whichTown->t->id < other.whichTown->t->id;
+			return false;
+		}
+		void fulfill(CGeniusAI &,HypotheticalGameState & hgs);
+		float getValue() const {return _value;}
+	private:
+		float _value;
+	};
+
+	class AIObjectivePtrCont
+	{
+	public:
+		AIObjectivePtrCont():obj(NULL){}
+		AIObjectivePtrCont(AIObjective * obj):obj(obj){};
+		AIObjective * obj;
+		bool operator < (const AIObjectivePtrCont & other) const
+		{return obj->getValue()<other.obj->getValue();}
+
+	};
+	std::set<HeroObjective> currentHeroObjectives;	//can be fulfilled right now
+	std::set<TownObjective> currentTownObjectives;
+
+public:
+	CGeniusAI();
+	virtual ~CGeniusAI();
+
+	virtual void init(ICallback * CB);
+	virtual void yourTurn();
+	virtual void heroKilled(const CGHeroInstance *);
+	virtual void heroCreated(const CGHeroInstance *);
+	virtual void heroMoved(const TryMoveHero &);
+	virtual void heroPrimarySkillChanged(const CGHeroInstance * hero, int which, int val) {};
+	virtual void showSelDialog(std::string text, std::vector<CSelectableComponent*> & components, int askID){};
+	virtual void showBlockingDialog(const std::string &text, const std::vector<Component> &components, ui32 askID, const int soundID, bool selection, bool cancel); //Show a dialog, player must take decision. If selection then he has to choose between one of given components, if cancel he is allowed to not choose. After making choice, CCallback::selectionMade should be called with number of selected component (1 - n) or 0 for cancel (if allowed) and askID.
+	virtual void tileRevealed(int3 pos);
+	virtual void tileHidden(int3 pos);
+	virtual void heroGotLevel(const CGHeroInstance *hero, int pskill, std::vector<ui16> &skills, boost::function<void(ui32)> &callback);
+	virtual void showGarrisonDialog(const CArmedInstance *up, const CGHeroInstance *down, boost::function<void()> &onEnd);
+	// battle
+	virtual void actionFinished(const BattleAction *action);//occurs AFTER every action taken by any stack or by the hero
+	virtual void actionStarted(const BattleAction *action);//occurs BEFORE every action taken by any stack or by the hero
+	virtual void battleAttack(BattleAttack *ba); //called when stack is performing attack
+	virtual void battleStacksAttacked(std::set<BattleStackAttacked> & bsa); //called when stack receives damage (after battleAttack())
+	virtual void battleEnd(BattleResult *br);
+	virtual void battleNewRound(int round); //called at the beggining of each turn, round=-1 is the tactic phase, round=0 is the first "normal" turn
+	virtual void battleStackMoved(int ID, int dest, int distance, bool end);
+	virtual void battleSpellCast(SpellCast *sc);
+	virtual void battleStart(CCreatureSet *army1, CCreatureSet *army2, int3 tile, CGHeroInstance *hero1, CGHeroInstance *hero2, bool side); //called by engine when battle starts; side=0 - left, side=1 - right
+	virtual void battlefieldPrepared(int battlefieldType, std::vector<CObstacle*> obstacles); //called when battlefield is prepared, prior the battle beginning
+	//
+	virtual void battleStackMoved(int ID, int dest, bool startMoving, bool endMoving);
+	virtual void battleStackAttacking(int ID, int dest);
+	virtual void battleStackIsAttacked(int ID, int dmg, int killed, int IDby, bool byShooting);
+	virtual BattleAction activeStack(int stackID);
+};
+}
+
+#endif // __CGENIUSAI_H__

AI/GeniusAI/Common.h

@@ -11,6 +11,6 @@
 #include "../../AI_Base.h"
 #pragma warning (default: 4100 4244)
 
-void MsgBox(const char *msg, bool messageBox = false);
+void DbgBox(const char *msg, bool messageBox = false);
 
 #endif/*__GENIUS_COMMON__*/