Our changes.

Restructured instances classes.
Still very instable.

CAdvmapInterface.cpp

@@ -13,6 +13,7 @@
 #include "CMessage.h"
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/replace.hpp>
+#include "CLua.h"
 extern TTF_Font * TNRB16, *TNR, *GEOR13, *GEORXX; //fonts
 
 using namespace boost::logic;
@@ -176,7 +177,7 @@ void CHeroList::genList()
 	int howMany = LOCPLINT->cb->howManyHeroes();
 	for (int i=0;i<howMany;i++)
 	{
-		items.push_back(std::pair<const CHeroInstance *,CPath *>(LOCPLINT->cb->getHeroInfo(LOCPLINT->playerID,i,0),NULL));
+		items.push_back(std::pair<const CGHeroInstance *,CPath *>(LOCPLINT->cb->getHeroInfo(LOCPLINT->playerID,i,0),NULL));
 	}
 }
 void CHeroList::select(int which)
@@ -633,7 +634,7 @@ void CMinimap::draw()
 	blitAt(map[LOCPLINT->adventureInt->position.z],0,0,temps);
 
 	//draw heroes
-	std::vector <const CHeroInstance *> * hh = LOCPLINT->cb->getHeroesInfo(false);
+	std::vector <const CGHeroInstance *> * hh = LOCPLINT->cb->getHeroesInfo(false);
 	int mw = map[0]->w, mh = map[0]->h,
 		wo = mw/CGI->mh->sizes.x, ho = mh/CGI->mh->sizes.y;
 	for (int i=0; i<hh->size();i++)
@@ -645,7 +646,7 @@ void CMinimap::draw()
 		{
 			for (int jj=0; jj<ho; jj++)
 			{
-				SDL_PutPixel(temps,maplgp.x+ii,maplgp.y+jj,CGI->playerColors[(*hh)[i]->owner].r,CGI->playerColors[(*hh)[i]->owner].g,CGI->playerColors[(*hh)[i]->owner].b);
+				SDL_PutPixel(temps,maplgp.x+ii,maplgp.y+jj,CGI->playerColors[(*hh)[i]->state->owner].r,CGI->playerColors[(*hh)[i]->state->owner].g,CGI->playerColors[(*hh)[i]->state->owner].b);
 			}
 		}
 	}
@@ -816,7 +817,7 @@ void CTerrainRect::clickLeft(tribool down)
 		if ( (currentPath->endPos()) == mp)
 		{ //move
 			CPath sended(*currentPath); //temporary path - engine will operate on it
-			LOCPLINT->cb->moveHero( ((const CHeroInstance*)LOCPLINT->adventureInt->selection.selected)->type->ID,&sended,1,0);
+			LOCPLINT->cb->moveHero( ((const CGHeroInstance*)LOCPLINT->adventureInt->selection.selected)->type->ID,&sended,1,0);
 		}
 		else
 		{
@@ -824,7 +825,7 @@ void CTerrainRect::clickLeft(tribool down)
 			currentPath=NULL;
 		}
 	}
-	const CHeroInstance * currentHero = LOCPLINT->adventureInt->heroList.items[LOCPLINT->adventureInt->heroList.selected].first;
+	const CGHeroInstance * currentHero = LOCPLINT->adventureInt->heroList.items[LOCPLINT->adventureInt->heroList.selected].first;
 	int3 bufpos = currentHero->getPosition(false);
 	//bufpos.x-=1;
 	currentPath = LOCPLINT->adventureInt->heroList.items[LOCPLINT->adventureInt->heroList.selected].second = CGI->pathf->getPath(bufpos,mp,currentHero,1);
@@ -1041,7 +1042,7 @@ void CTerrainRect::show()
 				}
 
 			}
-			if (  ((currentPath->nodes[i].dist)-(*(currentPath->nodes.end()-1)).dist) > ((const CHeroInstance*)(LOCPLINT->adventureInt->selection.selected))->movement)
+			if (  ((currentPath->nodes[i].dist)-(*(currentPath->nodes.end()-1)).dist) > ((const CGHeroInstance*)(LOCPLINT->adventureInt->selection.selected))->movement)
 				pn+=25;
 			if (pn>=0)
 			{			
@@ -1239,7 +1240,7 @@ void CAdvMapInt::fmoveHero()
 	if (!terrain.currentPath)
 		return;
 	CPath sended(*(terrain.currentPath)); //temporary path - engine will operate on it
-	LOCPLINT->cb->moveHero( ((const CHeroInstance*)LOCPLINT->adventureInt->selection.selected)->type->ID,&sended,1,0);
+	LOCPLINT->cb->moveHero( ((const CGHeroInstance*)LOCPLINT->adventureInt->selection.selected)->type->ID,&sended,1,0);
 }
 void CAdvMapInt::fshowSpellbok()
 {

CAdvmapInterface.h

@@ -11,7 +11,8 @@ class CDefHandler;
 class CCallback;
 class CTownInstance;
 class CPath; 
-
+class CGHeroInstance;
+class CGTownInstance;
 class AdventureMapButton 
 	: public ClickableL, public ClickableR, public Hoverable, public KeyInterested, public CButtonBase
 {
@@ -26,7 +27,7 @@ public:
 	void hover (bool on);
 	void keyPressed (SDL_KeyboardEvent & key);
 	void activate(); // makes button active
-	void deactivate(); // makes button inactive (but don't deletes)
+	void deactivate(); // makes button inactive (but doesn't delete)
 
 	AdventureMapButton(); //c-tor
 	AdventureMapButton( std::string Name, std::string HelpBox, void(CAdvMapInt::*Function)(), int x, int y, std::string defName, bool activ=false,  std::vector<std::string> * add = NULL );//c-tor
@@ -59,7 +60,7 @@ class CHeroList
 {
 public:
 	CDefHandler *mobile, *mana;
-	std::vector<std::pair<const CHeroInstance*, CPath *> > items;
+	std::vector<std::pair<const CGHeroInstance*, CPath *> > items;
 	int posmobx, posporx, posmanx, posmoby, pospory, posmany;
 
 	CHeroList();
@@ -79,7 +80,7 @@ class CTownList
 	: public CList
 {
 public: 
-	std::vector<const CTownInstance*> items;
+	std::vector<const CGTownInstance*> items;
 	int posporx,pospory;
 
 	CTownList();

CCallback.cpp

@@ -8,7 +8,8 @@
 #include "mapHandler.h"
 #include "CGameState.h"
 #include "CGameInterface.h"
-int CCallback::lowestSpeed(CHeroInstance * chi)
+#include "CLua.h"
+int CCallback::lowestSpeed(CGHeroInstance * chi)
 {
 	int min = 150;
 	for (  std::map<int,std::pair<CCreature*,int> >::iterator i = chi->army.slots.begin(); 
@@ -19,7 +20,7 @@ int CCallback::lowestSpeed(CHeroInstance * chi)
 	}
 	return min;
 }
-int CCallback::valMovePoints(CHeroInstance * chi)
+int CCallback::valMovePoints(CGHeroInstance * chi)
 {
 	int ret = 1270+70*lowestSpeed(chi);
 	if (ret>2000) 
@@ -43,7 +44,7 @@ void CCallback::newTurn()
 }
 bool CCallback::moveHero(int ID, CPath * path, int idtype, int pathType)
 {
-	CHeroInstance * hero = NULL;
+	CGHeroInstance * hero = NULL;
 
 	if (idtype==0)
 	{
@@ -97,8 +98,8 @@ bool CCallback::moveHero(int ID, CPath * path, int idtype, int pathType)
 		HeroMoveDetails curd;
 		curd.src = stpos;
 		curd.dst = endpos;
-		curd.ho = hero->ourObject;
-		curd.owner = hero->owner;
+		//curd.ho = hero->ourObject;
+		curd.owner = hero->state->owner;
 		/*if(player!=-1)
 		{
 			hero->pos = endpos;
@@ -148,10 +149,15 @@ bool CCallback::moveHero(int ID, CPath * path, int idtype, int pathType)
 				}
 				++nn;
 			}
+
+			std::vector< CGObjectInstance * > vis = CGI->mh->getVisitableObjs(hero->getPosition(false));
+			for (int iii=0; iii<vis.size(); iii++)
+				std::cout<< CGI->objh->objects[5].name<<std::endl;
+
 		}
 		else
 			return true; //move ended - no more movement points
-		hero->ourObject->pos = curd.dst;
+		hero->pos = curd.dst;
 	}
 	return true;
 }
@@ -161,7 +167,7 @@ int CCallback::howManyTowns()
 {
 	return gs->players[gs->currentPlayer].towns.size();
 }
-const CTownInstance * CCallback::getTownInfo(int val, bool mode) //mode = 0 -> val = serial; mode = 1 -> val = ID
+const CGTownInstance * CCallback::getTownInfo(int val, bool mode) //mode = 0 -> val = serial; mode = 1 -> val = ID
 {
 	if (!mode)
 		return gs->players[gs->currentPlayer].towns[val];
@@ -183,7 +189,7 @@ int CCallback::howManyHeroes()
 {
 	return gs->players[player].heroes.size();
 }
-const CHeroInstance * CCallback::getHeroInfo(int player, int val, bool mode) //mode = 0 -> val = serial; mode = 1 -> val = ID
+const CGHeroInstance * CCallback::getHeroInfo(int player, int val, bool mode) //mode = 0 -> val = serial; mode = 1 -> val = ID
 {
 	if (gs->currentPlayer!=player) //TODO: checking if we are allowed to give that info
 		return NULL;
@@ -283,9 +289,9 @@ bool CCallback::isVisible(int3 pos, int Player)
 	return gs->players[Player].fogOfWarMap[pos.x][pos.y][pos.z];
 }
 
-std::vector < const CHeroInstance *> * CCallback::getHeroesInfo(bool onlyOur)
+std::vector < const CGHeroInstance *> * CCallback::getHeroesInfo(bool onlyOur)
 {
-	std::vector < const CHeroInstance *> * ret = new std::vector < const CHeroInstance *>();
+	std::vector < const CGHeroInstance *> * ret = new std::vector < const CGHeroInstance *>();
 	for ( std::map<int, PlayerState>::iterator i=gs->players.begin() ; i!=gs->players.end();i++)
 	{
 		for (int j=0;j<(*i).second.heroes.size();j++)

CCallback.h

@@ -7,12 +7,12 @@ class CGameState;
 class CHeroInstance;
 class CTownInstance;
 class CPath;
-class CObjectInstance;
+class CGObjectInstance;
 
 struct HeroMoveDetails
 {
 	int3 src, dst; //source and destination points
-	CObjectInstance * ho; //object instance of this hero
+	CGHeroInstance * ho; //object instance of this hero
 	int owner;
 };
 
@@ -22,8 +22,8 @@ private:
 	void newTurn();
 	CCallback(CGameState * GS, int Player):gs(GS),player(Player){};
 	CGameState * gs;
-	int lowestSpeed(CHeroInstance * chi); //speed of the slowest stack
-	int valMovePoints(CHeroInstance * chi); 
+	int lowestSpeed(CGHeroInstance * chi); //speed of the slowest stack
+	int valMovePoints(CGHeroInstance * chi); 
 	bool isVisible(int3 pos, int Player);
 
 protected:
@@ -38,17 +38,20 @@ public:
 	bool verifyPath(CPath * path, bool blockSea);
 	int getDate(int mode=0); //mode=0 - total days in game, mode=1 - day of week, mode=2 - current week, mode=3 - current month
 	PseudoV< PseudoV< PseudoV<unsigned char> > > & getVisibilityMap(); //returns visibility map (TODO: make it const)
-	const CHeroInstance * getHeroInfo(int player, int val, bool mode); //mode = 0 -> val = serial; mode = 1 -> val = ID
+	const CGHeroInstance * getHeroInfo(int player, int val, bool mode); //mode = 0 -> val = serial; mode = 1 -> val = ID
 	int getResourceAmount(int type);
 	int howManyHeroes();
-	const CTownInstance * getTownInfo(int val, bool mode); //mode = 0 -> val = serial; mode = 1 -> val = ID
+	const CGTownInstance * getTownInfo(int val, bool mode); //mode = 0 -> val = serial; mode = 1 -> val = ID
 	int howManyTowns();
 	std::vector < std::string > getObjDescriptions(int3 pos); //returns descriptions of objects at pos in order from the lowest to the highest
-	std::vector < const CHeroInstance *> * getHeroesInfo(bool onlyOur=true);
+	std::vector < const CGHeroInstance *> * getHeroesInfo(bool onlyOur=true);
 	bool isVisible(int3 pos);
 
 //friends
 	friend int _tmain(int argc, _TCHAR* argv[]);
 };
 
+class CLuaCallback
+{
+};
 #endif //CCALLBACK_H

CConsoleHandler.cpp

@@ -46,7 +46,7 @@ int internalFunc(void * callback)
 		case 'M': //move heroa
 			{
 				readed>>heronum>>dest;
-				const CHeroInstance * hero = cb->getHeroInfo(0,heronum,0);
+				const CGHeroInstance * hero = cb->getHeroInfo(0,heronum,0);
 				CPath * path = CGI->pathf->getPath(hero->getPosition(false),dest,hero);
 				cb->moveHero(heronum, path, 0, 0);
 				delete path;

CGameInterface.cpp

@@ -22,7 +22,7 @@ using namespace CSDL_Ext;
 class OCM_HLP_CGIN
 {
 public:
-	bool operator ()(const std::pair<CObjectInstance*,std::pair<SDL_Rect, std::vector<std::list<int3>>>>  & a, const std::pair<CObjectInstance*,std::pair<SDL_Rect, std::vector<std::list<int3>>>> & b) const
+	bool operator ()(const std::pair<CGObjectInstance*,std::pair<SDL_Rect, std::vector<std::list<int3>>>>  & a, const std::pair<CGObjectInstance*,std::pair<SDL_Rect, std::vector<std::list<int3>>>> & b) const
 	{
 		return (*a.first)<(*b.first);
 	}
@@ -289,7 +289,7 @@ void CPlayerInterface::heroMoved(const HeroMoveDetails & details)
 {
 	adventureInt->minimap.draw();
 	//initializing objects and performing first step of move
-	CObjectInstance * ho = details.ho; //object representing this hero
+	CGHeroInstance * ho = details.ho; //object representing this hero
 	int3 hp = details.src;
 
 	if (adventureInt->terrain.currentPath) //&& hero is moving
@@ -843,10 +843,10 @@ void CPlayerInterface::heroMoved(const HeroMoveDetails & details)
 	//move finished
 	adventureInt->heroList.draw();
 }
-void CPlayerInterface::heroKilled(const CHeroInstance * hero)
+void CPlayerInterface::heroKilled(const CGHeroInstance*)
 {
 }
-void CPlayerInterface::heroCreated(const CHeroInstance * hero)
+void CPlayerInterface::heroCreated(const CGHeroInstance * hero)
 {
 }
 
@@ -862,7 +862,7 @@ SDL_Surface * CPlayerInterface::infoWin(void * specific) //specific=0 => draws i
 			SDL_Surface * ret = copySurface(hInfo);
 			SDL_SetColorKey(ret,SDL_SRCCOLORKEY,SDL_MapRGB(ret->format,0,255,255));
 			blueToPlayersAdv(ret,playerID,1);
-			const CHeroInstance * curh = (const CHeroInstance *)adventureInt->selection.selected;
+			const CGHeroInstance * curh = (const CGHeroInstance *)adventureInt->selection.selected;
 			printAt(curh->name,75,15,GEOR13,zwykly,ret);
 			for (int i=0;i<PRIMARY_SKILLS;i++)
 			{

CGameInterface.h

@@ -15,6 +15,7 @@ class CHeroInstance;
 class CDefHandler;
 struct HeroMoveDetails;
 class CDefEssential;
+class CGHeroInstance;
 class CIntObject //interface object
 {
 public:
@@ -93,8 +94,8 @@ public:
 
 	virtual void init(CCallback * CB)=0{};
 	virtual void yourTurn()=0{};
-	virtual void heroKilled(const CHeroInstance * hero)=0{};
-	virtual void heroCreated(const CHeroInstance * hero)=0{};
+	virtual void heroKilled(const CGHeroInstance*)=0{};
+	virtual void heroCreated(const CGHeroInstance*)=0{};
 
 	virtual void heroMoved(const HeroMoveDetails & details)=0;
 };
@@ -109,8 +110,8 @@ class CGlobalAI : public CGameInterface // AI class (to derivate)
 public:
 	//CGlobalAI();
 	virtual void yourTurn(){};
-	virtual void heroKilled(const CHeroInstance * hero){};
-	virtual void heroCreated(const CHeroInstance * hero){};
+	virtual void heroKilled(const CGHeroInstance*){};
+	virtual void heroCreated(const CGHeroInstance*){};
 };
 class CPlayerInterface : public CGameInterface
 {
@@ -138,8 +139,8 @@ public:
 	//overloaded funcs from Interface
 	void yourTurn();
 	void heroMoved(const HeroMoveDetails & details);
-	void heroKilled(const CHeroInstance * hero);
-	void heroCreated(const CHeroInstance * hero);
+	void heroKilled(const CGHeroInstance*);
+	void heroCreated(const CGHeroInstance*);
 	
 	SDL_Surface * infoWin(void * specific); //specific=0 => draws info about selected town/hero //TODO - gdy sie dorobi sensowna hierarchie klas ins. to wywalic tego brzydkiego void*
 	void handleEvent(SDL_Event * sEvent);

CGameState.h

@@ -14,8 +14,8 @@ public:
 	//std::vector<std::vector<std::vector<char> > > fogOfWarMap; //true - visible, false - hidden
 	PseudoV< PseudoV< PseudoV<unsigned char> > >  fogOfWarMap; //true - visible, false - hidden
 	std::vector<int> resources;
-	std::vector<CHeroInstance *> heroes;
-	std::vector<CTownInstance *> towns;
+	std::vector<CGHeroInstance *> heroes;
+	std::vector<CGTownInstance *> towns;
 	PlayerState():color(-1){};
 };
 

CLuaHandler.cpp

@@ -7,7 +7,8 @@
 #include <luabind/function.hpp>
 #include <luabind/class.hpp>
 #include "CLuaHandler.h"
-
+#include "boost/filesystem.hpp"
+#include <boost/algorithm/string.hpp>
 void piszpowitanie2(std::string i) //simple global function for testing
 {
 	std::cout<<"powitanie2zc++. Liczba dnia to " << i;
@@ -53,4 +54,27 @@ void CLuaHandler::test()
 		}
 	}
 	lua_close (lua);
+}
+
+
+std::vector<std::string> * CLuaHandler::searchForScripts(std::string fol)
+{
+	std::vector<std::string> * ret = new std::vector<std::string> ();
+	boost::filesystem::path folder(fol);
+	if (!boost::filesystem::exists(folder))
+		throw new std::exception("No such folder!");
+	boost::filesystem::directory_iterator end_itr;
+	for 
+	  (
+	  boost::filesystem::directory_iterator it(folder);
+	  it!=end_itr;
+	  it++
+	  )
+	{
+		if(boost::algorithm::ends_with((it->path().leaf()),".lua"))
+		{
+			ret->push_back(fol+"/"+(it->path().leaf()));
+		}
+	}
+	return ret;
 }

CLuaHandler.h

@@ -12,6 +12,9 @@ class CLuaHandler
 {
 public:
 	CLuaHandler();
+
+	static std::vector<std::string> * searchForScripts(std::string fol);
+
 	~CLuaHandler();
 
 	void test();

CMT.cpp

@@ -44,6 +44,7 @@
 #include "CGameState.h"
 #include "CCallback.h"
 #include "CLuaHandler.h"
+#include "CLua.h"
 #if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__)
 #  include <fcntl.h>
 #  include <io.h>
@@ -96,9 +97,9 @@ void initGameState(CGameInfo * cgi)
 	/*************************HEROES************************************************/
 	for (int i=0; i<cgi->heroh->heroInstances.size();i++) //heroes instances
 	{
-		if (!cgi->heroh->heroInstances[i]->type || cgi->heroh->heroInstances[i]->owner<0)
+		if (!cgi->heroh->heroInstances[i]->type || cgi->heroh->heroInstances[i]->state->owner<0)
 			continue;
-		CHeroInstance * vhi = new CHeroInstance();
+		CGHeroInstance * vhi = new CGHeroInstance();
 		*vhi=*(cgi->heroh->heroInstances[i]);
 		if (!vhi->level)
 		{
@@ -138,7 +139,7 @@ void initGameState(CGameInfo * cgi)
 			vhi->army.slots[2].second = (rand()%(vhi->type->high3stack-vhi->type->low3stack))+vhi->type->low3stack;
 		}
 
-		cgi->state->players[vhi->owner].heroes.push_back(vhi);
+		cgi->state->players[vhi->state->owner].heroes.push_back(vhi);
 
 	}
 	/*************************FOG**OF**WAR******************************************/		
@@ -173,12 +174,12 @@ void initGameState(CGameInfo * cgi)
 	/****************************TOWNS************************************************/
 	for (int i=0;i<cgi->townh->townInstances.size();i++)
 	{
-		CTownInstance * vti = new CTownInstance();
+		CGTownInstance * vti = new CGTownInstance();
 		(*vti)=*(cgi->townh->townInstances[i]);
 		if (vti->name.length()==0) // if town hasn't name we draw it
 			vti->name=vti->town->names[rand()%vti->town->names.size()];
 		
-		cgi->state->players[vti->owner].towns.push_back(vti);
+		cgi->state->players[vti->state->owner].towns.push_back(vti);
 	}
 
 	for(std::map<int, PlayerState>::iterator k=cgi->state->players.begin(); k!=cgi->state->players.end(); ++k)
@@ -203,8 +204,13 @@ void initGameState(CGameInfo * cgi)
 
 int _tmain(int argc, _TCHAR* argv[])
 { 
+
 	CLuaHandler luatest;
 	luatest.test();
+	CLuaHandler::searchForScripts("scripts");
+	CLua * lua = new CLua("test.lua");
+
+
 
 		//CBIKHandler cb;
 		//cb.open("CSECRET.BIK");

CPathfinder.cpp

@@ -13,7 +13,7 @@ int3 CPath::endPos()
 	return int3(nodes[0].coord.x,nodes[0].coord.y,nodes[0].coord.z);
 }
 
-CPath * CPathfinder::getPath(int3 src, int3 dest, const CHeroInstance * hero, unsigned char type) //TODO: test it (seems to be finished, but relies on unwritten functions :()
+CPath * CPathfinder::getPath(int3 src, int3 dest, const CGHeroInstance * hero, unsigned char type) //TODO: test it (seems to be finished, but relies on unwritten functions :()
 {
 	//check input
 	if ((src.x < 0)||(src.y < 0)||(src.z < 0)||(dest.x < 0)||(dest.y < 0)||(dest.z < 0))

CPathfinder.h

@@ -4,6 +4,7 @@
 #include <queue>
 #include <vector>
 class CHeroInstance;
+class CGHeroInstance;
 struct CPathNode
 {
 	bool accesible; //true if a hero can be on this node
@@ -29,7 +30,7 @@ class CPathfinder
 private:
 	std::vector< std::vector<CPathNode *> > graph;
 public:
-	CPath * getPath(int3 src, int3 dest, const CHeroInstance * hero, unsigned char type=0); //calculates path between src and dest; returns pointer to CPath or NULL if path does not exists; type - type of calculation: 0 - positions are normal positions of hero; 1 - given places are tiles blocked by hero
+	CPath * getPath(int3 src, int3 dest, const CGHeroInstance * hero, unsigned char type=0); //calculates path between src and dest; returns pointer to CPath or NULL if path does not exists; type - type of calculation: 0 - positions are normal positions of hero; 1 - given places are tiles blocked by hero
 	CPath * getPath(const int3 & src, const int3 & dest, const CHeroInstance * hero, int (*getDist)(int3 & a, int3 & b), unsigned char type=0); //calculates path between src and dest; returns pointer to CPath or NULL if path does not exists; uses getDist to calculate distance; type - type of calculation: 0 - positions are normal positions of hero; 1 - given places are tiles blocked by hero
 
 	static void convertPath(CPath * path, unsigned int mode); //mode=0 -> from 'manifest' to 'object'

hch/CAmbarCendamo.h

@@ -34,7 +34,7 @@ public:
 	std::vector<std::string> resDefNames;
 	////
 	void loadDefs();
-	EDefType getDefType(DefInfo& a); //returns type of object in def
+	EDefType getDefType(CGDefInfo * a); //returns type of object in def
 	CCreatureSet readCreatureSet(int pos, int number = 7); //reads creature set in most recently encountered format; reades number units (default is 7)
 };
 #endif //CAMBARCENDAMO_H

hch/CHeroHandler.h

@@ -13,7 +13,7 @@ class CHeroClass;
 class CObjectInstance;
 class CDefHandler;
 class CGameInfo;
-
+class CGHeroInstance;
 class CHero
 {
 public:
@@ -85,7 +85,7 @@ public:
 class CHeroHandler
 {
 public:
-	std::vector<CHeroInstance *> heroInstances;
+	std::vector<CGHeroInstance *> heroInstances;
 	std::vector<CHero*> heroes; //by³o nodrze
 	std::vector<CHeroClass *> heroClasses;
 	std::vector<CDefHandler *> flags1, flags2, flags3, flags4; //flags blitted on heroes when 

hch/CObjectHandler.cpp

@@ -4,9 +4,9 @@
 #include "CGeneralTextHandler.h"
 #include "CLodHandler.h"
 #include "CAmbarCendamo.h"
-#include "mapHandler.h"
+#include "../mapHandler.h"
 #include "CDefObjInfoHandler.h"
-
+#include "../CLua.h"
 void CObjectHandler::loadObjects()
 {
 	int ID=0;
@@ -24,42 +24,241 @@ void CObjectHandler::loadObjects()
 
 bool CObjectInstance::operator <(const CObjectInstance &cmp) const
 {
-	if(CGI->ac->map.defy[this->defNumber].printPriority==1 && CGI->ac->map.defy[cmp.defNumber].printPriority==0)
+	//if(CGI->ac->map.defy[this->defNumber].printPriority==1 && CGI->ac->map.defy[cmp.defNumber].printPriority==0)
+	//	return true;
+	//if(CGI->ac->map.defy[cmp.defNumber].printPriority==1 && CGI->ac->map.defy[this->defNumber].printPriority==0)
+	//	return false;
+	//if(this->pos.y<cmp.pos.y)
+	//	return true;
+	//if(this->pos.y>cmp.pos.y)
+	//	return false;
+	//if(CGI->ac->map.defy[this->defNumber].isOnDefList && !(CGI->ac->map.defy[cmp.defNumber].isOnDefList))
+	//	return true;
+	//if(CGI->ac->map.defy[cmp.defNumber].isOnDefList && !(CGI->ac->map.defy[this->defNumber].isOnDefList))
+	//	return false;
+	//if(!CGI->ac->map.defy[this->defNumber].isVisitable() && CGI->ac->map.defy[cmp.defNumber].isVisitable())
+	//	return true;
+	//if(!CGI->ac->map.defy[cmp.defNumber].isVisitable() && CGI->ac->map.defy[this->defNumber].isVisitable())
+	//	return false;
+	//if(this->pos.x<cmp.pos.x)
+	//	return true;
+	return false;
+}
+
+int CObjectInstance::getWidth() const
+{
+	return -1;//CGI->mh->reader->map.defy[defNumber].handler->ourImages[0].bitmap->w/32;
+}
+
+int CObjectInstance::getHeight() const
+{
+	return -1;//CGI->mh->reader->map.defy[defNumber].handler->ourImages[0].bitmap->h/32;
+}
+
+bool CObjectInstance::visitableAt(int x, int y) const
+{
+	//if(x<0 || y<0 || x>=getWidth() || y>=getHeight() || defObjInfoNumber<0)
+	//	return false;
+	//if((CGI->dobjinfo->objs[defObjInfoNumber].visitMap[y+6-getHeight()] >> (7-(8-getWidth()+x) )) & 1)
+	//	return true;
+	return false;
+}
+
+
+bool CGObjectInstance::isHero() const
+{
+	return false;
+}
+int CGObjectInstance::getOwner() const
+{
+	return state->getOwner();
+}
+int CGObjectInstance::getWidth() const//returns width of object graphic in tiles
+{
+	return defInfo->handler->ourImages[0].bitmap->w/32;
+}
+int CGObjectInstance::getHeight() const //returns height of object graphic in tiles
+{
+	return defInfo->handler->ourImages[0].bitmap->h/32;
+}
+bool CGObjectInstance::visitableAt(int x, int y) const //returns true if ibject is visitable at location (x, y) form left top tile of image (x, y in tiles)
+{
+	if(x<0 || y<0 || x>=getWidth() || y>=getHeight() || defInfo==NULL)
+		return false;
+	if((defInfo->visitMap[y+6-getHeight()] >> (7-(8-getWidth()+x) )) & 1)
 		return true;
-	if(CGI->ac->map.defy[cmp.defNumber].printPriority==1 && CGI->ac->map.defy[this->defNumber].printPriority==0)
+	return false;
+}
+bool CGObjectInstance::operator<(const CGObjectInstance & cmp) const  //screen printing priority comparing
+{
+	if(defInfo->printPriority==1 && defInfo->printPriority==0)
+		return true;
+	if(defInfo->printPriority==1 && defInfo->printPriority==0)
 		return false;
 	if(this->pos.y<cmp.pos.y)
 		return true;
 	if(this->pos.y>cmp.pos.y)
 		return false;
-	if(CGI->ac->map.defy[this->defNumber].isOnDefList && !(CGI->ac->map.defy[cmp.defNumber].isOnDefList))
+	if(defInfo->isOnDefList && !(defInfo->isOnDefList))
 		return true;
-	if(CGI->ac->map.defy[cmp.defNumber].isOnDefList && !(CGI->ac->map.defy[this->defNumber].isOnDefList))
+	if(defInfo->isOnDefList && !(defInfo->isOnDefList))
 		return false;
-	if(!CGI->ac->map.defy[this->defNumber].isVisitable() && CGI->ac->map.defy[cmp.defNumber].isVisitable())
+	if(!defInfo->isVisitable() && defInfo->isVisitable())
 		return true;
-	if(!CGI->ac->map.defy[cmp.defNumber].isVisitable() && CGI->ac->map.defy[this->defNumber].isVisitable())
+	if(!defInfo->isVisitable() && defInfo->isVisitable())
 		return false;
 	if(this->pos.x<cmp.pos.x)
 		return true;
 	return false;
 }
 
-int CObjectInstance::getWidth() const
+
+bool CGDefInfo::isVisitable()
 {
-	return CGI->mh->reader->map.defy[defNumber].handler->ourImages[0].bitmap->w/32;
+	for (int i=6; i<12; i++)
+	{
+		if (bytes[i])
+			return true;
+	}
+	return false;
 }
 
-int CObjectInstance::getHeight() const
+	
+bool CGHeroInstance::isHero() const
+{
+	return true;
+}
+unsigned int CGHeroInstance::getTileCost(EterrainType & ttype, Eroad & rdtype, Eriver & rvtype)
+{
+	unsigned int ret = type->heroClass->terrCosts[ttype];
+	switch(rdtype)
+	{
+	case Eroad::dirtRoad:
+		ret*=0.75;
+		break;
+	case Eroad::grazvelRoad:
+		ret*=0.667;
+		break;
+	case Eroad::cobblestoneRoad:
+		ret*=0.5;
+		break;
+	}
+	return ret;
+}
+unsigned int CGHeroInstance::getLowestCreatureSpeed()
 {
-	return CGI->mh->reader->map.defy[defNumber].handler->ourImages[0].bitmap->h/32;
+	unsigned int sl = 100;
+	for(int h=0; h<army.slots.size(); ++h)
+	{
+		if(army.slots[h].first->speed<sl)
+			sl = army.slots[h].first->speed;
+	}
+	return sl;
+}
+int3 CGHeroInstance::convertPosition(int3 src, bool toh3m) //toh3m=true: manifest->h3m; toh3m=false: h3m->manifest
+{
+	if (toh3m)
+	{
+		src.x+=1;
+		return src;
+	}
+	else
+	{
+		src.x-=1;
+		return src;
+	}
+}
+int3 CGHeroInstance::getPosition(bool h3m) const //h3m=true - returns position of hero object; h3m=false - returns position of hero 'manifestation'
+{
+	if (h3m)
+		return pos;
+	else return convertPosition(pos,false);
+}
+int CGHeroInstance::getSightDistance() const //returns sight distance of this hero
+{
+	return 6;
+}
+void CGHeroInstance::setPosition(int3 Pos, bool h3m) //as above, but sets position
+{
+	if (h3m)
+		pos = Pos;
+	else
+		pos = convertPosition(Pos,true);
 }
 
-bool CObjectInstance::visitableAt(int x, int y) const
+bool CGHeroInstance::canWalkOnSea() const
 {
-	if(x<0 || y<0 || x>=getWidth() || y>=getHeight())
-		return false;
-	if((CGI->dobjinfo->objs[defObjInfoNumber].visitMap[y] >> (7-x)) & 1)
-		return true;
+	//TODO: write it - it should check if hero is flying, or something similiar
 	return false;
 }
+int CGHeroInstance::getCurrentLuck() const
+{
+	//TODO: write it
+	return 0;
+}
+int CGHeroInstance::getCurrentMorale() const
+{
+	//TODO: write it
+	return 0;
+}
+
+
+int CGTownInstance::getSightDistance() const //returns sight distance
+{
+	return 10;
+}
+CGTownInstance::CGTownInstance()
+{
+	pos = int3(-1,-1,-1);
+	builded=-1;
+	destroyed=-1;
+	garrisonHero=NULL;
+	state->owner=-1;
+	town=NULL;
+}
+
+CGObjectInstance::CGObjectInstance()
+{
+	//std::cout << "Tworze obiekt "<<this<<std::endl;
+	state = new CLuaObjectScript();
+	defObjInfoNumber = -1;
+}
+CGObjectInstance::~CGObjectInstance()
+{
+	//std::cout << "Usuwam obiekt "<<this<<std::endl;
+	if (state)
+		delete state;
+	state=NULL;
+}
+
+CGHeroInstance::~CGHeroInstance()
+{
+}
+
+CGTownInstance::~CGTownInstance()
+{}
+CGObjectInstance::CGObjectInstance(const CGObjectInstance & right)
+{
+	pos = right.pos;
+	ID = right.ID;
+	subID = right.subID;
+	id	= right.id;
+	defInfo = right.defInfo;
+	info = right.info;
+	defObjInfoNumber = right.defObjInfoNumber;
+	state = new CLuaObjectScript();
+	*state = *right.state;
+}
+CGObjectInstance& CGObjectInstance::operator=(const CGObjectInstance & right)
+{
+	pos = right.pos;
+	ID = right.ID;
+	subID = right.subID;
+	id	= right.id;
+	defInfo = right.defInfo;
+	info = right.info;
+	defObjInfoNumber = right.defObjInfoNumber;
+	state = new CLuaObjectScript();
+	*state = *right.state;
+	return *this;
+}

hch/CObjectHandler.h

@@ -8,7 +8,13 @@
 #include "CAbilityHandler.h"
 #include "CSpellHandler.h"
 #include "CHeroHandler.h"
-
+class CScript;
+class CObjectScript;
+class CGHeroInstance;
+class CTown;
+class CHero;
+class CBuilding;
+class CSpell;
 class CSpecObjInfo //class with object - specific info (eg. different information for creatures and heroes); use inheritance to make object - specific classes
 {
 };
@@ -60,7 +66,7 @@ public:
 	std::vector<CAbility *> abilities; //hero's abilities
 	std::vector<int> abilityLevels; //hero ability levels
 	bool defaultMainStats; //if true attack, defence, power and knowledge are typical
-	CHeroInstance * myInstance; //pointer to appropriate hero instance
+	CGHeroInstance * myInstance; //pointer to appropriate hero instance
 };
 
 class CCreatureObjInfo : public CSpecObjInfo
@@ -307,11 +313,108 @@ public:
 	bool operator<(const CObjectInstance & cmp) const;  //screen printing priority comparing
 };
 
+class CGDefInfo
+{
+public:
+	std::string name; 
+	int bytes [42];
+
+	unsigned char visitMap[6];
+	unsigned char blockMap[6];
+	//CSemiDefHandler * handler;
+	CDefHandler * handler;
+	int printPriority;
+	bool isOnDefList;
+	bool isVisitable();
+};
+
+class CGObjectInstance
+{
+public:
+	int3 pos; //h3m pos
+	int ID, subID; //normal ID (this one from OH3 maps ;])
+	int id;//number of object in CObjectHandler's vector		
+	CGDefInfo * defInfo;
+	CObjectScript * state;
+	CSpecObjInfo * info;
+	int defObjInfoNumber;
+	
+	virtual bool isHero() const;
+	int getOwner() const; 
+	int getWidth() const; //returns width of object graphic in tiles
+	int getHeight() const; //returns height of object graphic in tiles
+	bool visitableAt(int x, int y) const; //returns true if ibject is visitable at location (x, y) form left top tile of image (x, y in tiles)
+	bool operator<(const CGObjectInstance & cmp) const;  //screen printing priority comparing
+	CGObjectInstance();
+	virtual ~CGObjectInstance();
+	CGObjectInstance(const CGObjectInstance & right);
+	CGObjectInstance& operator=(const CGObjectInstance & right);
+};
+
+class CGHeroInstance : public CGObjectInstance
+{
+public:
+	int moveDir;
+
+	bool isStanding;
+	bool flagPrinted;
+	CHero * type;
+	int exp; //experience point
+	int level; //current level of hero
+	std::string name; //may be custom
+	std::string biography; //may be custom
+	int portrait; //may be custom
+	CCreatureSet army; //army
+	int mana; // remaining spell points
+	std::vector<int> primSkills; //0-attack, 1-defence, 2-spell power, 3-knowledge
+	std::vector<std::pair<int,int> > secSkills; //first - ID of skill, second - level of skill (0 - basic, 1 - adv., 2 - expert)
+	int movement; //remaining movement points
+	bool inTownGarrison; // if hero is in town garrison 
+
+	virtual bool isHero() const;
+	unsigned int getTileCost(EterrainType & ttype, Eroad & rdtype, Eriver & rvtype);
+	unsigned int getLowestCreatureSpeed();
+	unsigned int getAdditiveMoveBonus();
+	unsigned float getMultiplicativeMoveBonus();
+	static int3 convertPosition(int3 src, bool toh3m); //toh3m=true: manifest->h3m; toh3m=false: h3m->manifest
+	int3 getPosition(bool h3m) const; //h3m=true - returns position of hero object; h3m=false - returns position of hero 'manifestation'
+	int getSightDistance() const; //returns sight distance of this hero
+	void setPosition(int3 Pos, bool h3m); //as above, but sets position
+
+	bool canWalkOnSea() const;
+	int getCurrentLuck() const;
+	int getCurrentMorale() const;
+	virtual ~CGHeroInstance();
+};
+
+class CGTownInstance : public CGObjectInstance
+{
+public:
+	CTown * town;
+	std::string name; // name of town
+	CCreatureSet garrison;
+	int builded; //how many buildings has been built this turn
+	int destroyed; //how many buildings has been destroyed this turn
+	
+	//TODO:
+	std::vector<CBuilding *> allBuildings, possibleBuildings, builtBuildings;
+	std::vector<int> creatureIncome; //vector by level
+	std::vector<int> creaturesLeft; //that can be recruited
+
+	CHero * garrisonHero;
+
+	std::vector<CSpell *> possibleSpells, obligatorySpells, availableSpells;
+
+	int getSightDistance() const; //returns sight distance
+	CGTownInstance();
+	virtual ~CGTownInstance();
+};
+
 class CObjectHandler
 {
 public:
 	std::vector<CObject> objects; //vector of objects; i-th object in vector has subnumber i
-	std::vector<CObjectInstance*> objInstances; //vector with objects on map
+	std::vector<CGObjectInstance*> objInstances; //vector with objects on map
 	void loadObjects();
 };
 

hch/CTownHandler.h

@@ -12,7 +12,7 @@ class CBuilding;
 class CSpell;
 class CHero;
 class CTownInstance;
-
+class CGTownInstance;
 class CTown
 {
 public:
@@ -33,7 +33,7 @@ public:
 	SDL_Surface * getPic(int ID, bool fort=true, bool builded=false); //ID=-1 - blank; -2 - border; -3 - random
 	static int getTypeByDefName(std::string name);
 
-	std::vector<CTownInstance *> townInstances;
+	std::vector<CGTownInstance *> townInstances;
 
 };
 

map.h

@@ -6,7 +6,7 @@
 #include "global.h"
 #include "hch\CSemiDefHandler.h"
 #include "hch\CDefHandler.h"
-
+class CGDefInfo;
 enum ESortBy{name,playerAm,size,format, viccon,loscon};
 struct Sresource
 {
@@ -184,7 +184,7 @@ struct Mapa
 	TerrainTile** terrain; 
 	TerrainTile** undergroungTerrain; // used only if there is underground level
 	std::vector<Rumor> rumors;
-	std::vector<DefInfo> defy; // list of .def files
+	std::vector<CGDefInfo *> defy; // list of .def files
 	PlayerInfo players[8]; // info about players
 	std::vector<int> teams;  // teams[i] = team of player no i 
 	LossCondition lossCondition;

mapHandler.cpp

@@ -14,7 +14,7 @@ extern SDL_Surface * ekran;
 class OCM_HLP
 {
 public:
-	bool operator ()(const std::pair<CObjectInstance*,std::pair<SDL_Rect, std::vector<std::list<int3>>>> & a, const std::pair<CObjectInstance*,std::pair<SDL_Rect, std::vector<std::list<int3>>>> & b)
+	bool operator ()(const std::pair<CGObjectInstance*,std::pair<SDL_Rect, std::vector<std::list<int3>>>> & a, const std::pair<CGObjectInstance*,std::pair<SDL_Rect, std::vector<std::list<int3>>>> & b)
 	{
 		return (*a.first)<(*b.first);
 	}
@@ -404,7 +404,7 @@ void CMapHandler::init()
 	{	
 		/*CGI->objh->objInstances[f]->pos.x+=1;
 		CGI->objh->objInstances[f]->pos.y+=1;*/
-		CDefHandler * curd = CGI->ac->map.defy[CGI->objh->objInstances[f]->defNumber].handler;
+		CDefHandler * curd = CGI->objh->objInstances[f]->defInfo->handler;
 		for(int fx=0; fx<curd->ourImages[0].bitmap->w/32; ++fx)
 		{
 			for(int fy=0; fy<curd->ourImages[0].bitmap->h/32; ++fy)
@@ -414,19 +414,19 @@ void CMapHandler::init()
 				cr.h = 32;
 				cr.x = fx*32;
 				cr.y = fy*32;
-				std::pair<CObjectInstance*,std::pair<SDL_Rect, std::vector<std::list<int3>>>> toAdd = std::make_pair(CGI->objh->objInstances[f], std::make_pair(cr, std::vector<std::list<int3>>()));
+				std::pair<CGObjectInstance*,std::pair<SDL_Rect, std::vector<std::list<int3>>>> toAdd = std::make_pair(CGI->objh->objInstances[f], std::make_pair(cr, std::vector<std::list<int3>>()));
 				///initializing places that will be coloured by blitting (flag colour / player colour positions)
 				if(toAdd.first->defObjInfoNumber>=0 && CGI->dobjinfo->objs[toAdd.first->defObjInfoNumber].isVisitable())
 				{
-					toAdd.second.second.resize(CGI->mh->reader->map.defy[toAdd.first->defNumber].handler->ourImages.size());
-					for(int no = 0; no<CGI->mh->reader->map.defy[toAdd.first->defNumber].handler->ourImages.size(); ++no)
+					toAdd.second.second.resize(toAdd.first->defInfo->handler->ourImages.size());
+					for(int no = 0; no<toAdd.first->defInfo->handler->ourImages.size(); ++no)
 					{
 						bool breakNow = true;
 						for(int dx=0; dx<32; ++dx)
 						{
 							for(int dy=0; dy<32; ++dy)
 							{
-								SDL_Surface * curs = CGI->mh->reader->map.defy[toAdd.first->defNumber].handler->ourImages[no].bitmap;
+								SDL_Surface * curs = toAdd.first->defInfo->handler->ourImages[no].bitmap;
 								Uint32* point = (Uint32*)( (Uint8*)curs->pixels + curs->pitch * (fy*32+dy) + curs->format->BytesPerPixel*(fx*32+dx));
 								Uint8 r, g, b, a;
 								SDL_GetRGBA(*point, curs->format, &r, &g, &b, &a);
@@ -460,7 +460,7 @@ void CMapHandler::init()
 	{	
 		if(CGI->objh->objInstances[f]->defObjInfoNumber == -1)
 			continue;
-		CDefHandler * curd = CGI->ac->map.defy[CGI->objh->objInstances[f]->defNumber].handler;
+		CDefHandler * curd = CGI->objh->objInstances[f]->defInfo->handler;
 		for(int fx=0; fx<8; ++fx)
 		{
 			for(int fy=0; fy<6; ++fy)
@@ -566,17 +566,18 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 				sr.y = (by)*32;
 
 				SDL_Rect pp = ttiles[x+bx][y+by][level].objects[h].second.first;
-				if(ttiles[x+bx][y+by][level].objects[h].first->isHero && ttiles[x+bx][y+by][level].objects[h].first->moveDir && !ttiles[x+bx][y+by][level].objects[h].first->isStanding)
+				CGHeroInstance * themp = (dynamic_cast<CGHeroInstance*>(ttiles[x+bx][y+by][level].objects[h].first));
+				if(themp && themp->moveDir && !themp->isStanding)
 				{
 					int imgVal = 8;
 					SDL_Surface * tb;
-					switch(ttiles[x+bx][y+by][level].objects[h].first->moveDir)
+					switch(themp->moveDir)
 					{
 					case 1:
 						{
-							if(((CHeroObjInfo*)ttiles[x+bx][y+by][level].objects[h].first->info)->myInstance->type==NULL)
+							if(((CHeroObjInfo*)themp->info)->myInstance->type==NULL)
 								continue;
-							std::vector<Cimage> & iv = ((CHeroObjInfo*)ttiles[x+bx][y+by][level].objects[h].first->info)->myInstance->type->heroClass->moveAnim->ourImages;
+							std::vector<Cimage> & iv = ((CHeroObjInfo*)themp->info)->myInstance->type->heroClass->moveAnim->ourImages;
 							int gg;
 							for(gg=0; gg<iv.size(); ++gg)
 							{
@@ -589,7 +590,7 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 							SDL_BlitSurface(tb,&pp,su,&sr);
 							pp.y+=imgVal*2-32;
 							sr.y-=16;
-							SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->owner]->ourImages[gg+anim%imgVal+35].bitmap, &pp, su, &sr);
+							SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->getOwner()]->ourImages[gg+anim%imgVal+35].bitmap, &pp, su, &sr);
 							break;
 						}
 					case 2:
@@ -609,7 +610,7 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 							SDL_BlitSurface(tb,&pp,su,&sr);
 							pp.y+=imgVal*2-32;
 							sr.y-=16;
-							SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->owner]->ourImages[gg+anim%imgVal+35].bitmap, &pp, su, &sr);	
+							SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->getOwner()]->ourImages[gg+anim%imgVal+35].bitmap, &pp, su, &sr);	
 							break;
 						}
 					case 3:
@@ -629,7 +630,7 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 							SDL_BlitSurface(tb,&pp,su,&sr);
 							pp.y+=imgVal*2-32;
 							sr.y-=16;
-							SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->owner]->ourImages[gg+anim%imgVal+35].bitmap, &pp, su, &sr);
+							SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->getOwner()]->ourImages[gg+anim%imgVal+35].bitmap, &pp, su, &sr);
 							break;
 						}
 					case 4:
@@ -649,7 +650,7 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 							SDL_BlitSurface(tb,&pp,su,&sr);
 							pp.y+=imgVal*2-32;
 							sr.y-=16;
-							SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->owner]->ourImages[gg+anim%imgVal+35].bitmap, &pp, su, &sr);
+							SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->getOwner()]->ourImages[gg+anim%imgVal+35].bitmap, &pp, su, &sr);
 							break;
 						}
 					case 5:
@@ -669,7 +670,7 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 							SDL_BlitSurface(tb,&pp,su,&sr);
 							pp.y+=imgVal*2-32;
 							sr.y-=16;
-							SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->owner]->ourImages[gg+anim%imgVal+35].bitmap, &pp, su, &sr);
+							SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->getOwner()]->ourImages[gg+anim%imgVal+35].bitmap, &pp, su, &sr);
 							break;
 						}
 					case 6: //ok
@@ -689,7 +690,7 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 							SDL_BlitSurface(tb,&pp,su,&sr);
 							pp.y+=imgVal*2-32;
 							sr.y-=16;
-							SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->owner]->ourImages[gg+anim%imgVal+35].bitmap, &pp, su, &sr);
+							SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->getOwner()]->ourImages[gg+anim%imgVal+35].bitmap, &pp, su, &sr);
 							break;
 						}
 					case 7:
@@ -709,7 +710,7 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 							SDL_BlitSurface(tb,&pp,su,&sr);
 							pp.y+=imgVal*2-32;
 							sr.y-=16;
-							SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->owner]->ourImages[gg+anim%imgVal+35].bitmap, &pp, su, &sr);
+							SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->getOwner()]->ourImages[gg+anim%imgVal+35].bitmap, &pp, su, &sr);
 							break;
 						}
 					case 8:
@@ -729,16 +730,16 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 							SDL_BlitSurface(tb,&pp,su,&sr);
 							pp.y+=imgVal*2-32;
 							sr.y-=16;
-							SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->owner]->ourImages[gg+anim%imgVal+35].bitmap, &pp, su, &sr);
+							SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->getOwner()]->ourImages[gg+anim%imgVal+35].bitmap, &pp, su, &sr);
 							break;
 						}
 					}
 				}
-				else if(ttiles[x+bx][y+by][level].objects[h].first->isHero && ttiles[x+bx][y+by][level].objects[h].first->moveDir && ttiles[x+bx][y+by][level].objects[h].first->isStanding)
+				else if(themp && themp->moveDir && themp->isStanding)
 				{
 					int imgVal = 8;
 					SDL_Surface * tb;
-					switch(ttiles[x+bx][y+by][level].objects[h].first->moveDir)
+					switch(themp->moveDir)
 					{
 					case 1:
 						{
@@ -760,8 +761,8 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 								SDL_Rect bufr = sr;
 								bufr.x-=2*32;
 								bufr.y-=1*32;
-								SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->owner]->ourImages[13*8+anim%imgVal].bitmap, NULL, su, &bufr);
-								ttiles[x+bx][y+by][level].objects[h].first->flagPrinted = true;
+								SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->getOwner()]->ourImages[13*8+anim%imgVal].bitmap, NULL, su, &bufr);
+								themp->flagPrinted = true;
 							}
 							break;
 						}
@@ -785,8 +786,8 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 								SDL_Rect bufr = sr;
 								bufr.x-=2*32;
 								bufr.y-=1*32;
-								SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->owner]->ourImages[anim%imgVal].bitmap, NULL, su, &bufr);	
-								ttiles[x+bx][y+by][level].objects[h].first->flagPrinted = true;
+								SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->getOwner()]->ourImages[anim%imgVal].bitmap, NULL, su, &bufr);	
+								themp->flagPrinted = true;
 							}
 							break;
 						}
@@ -810,8 +811,8 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 								SDL_Rect bufr = sr;
 								bufr.x-=2*32;
 								bufr.y-=1*32;
-								SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->owner]->ourImages[8+anim%imgVal].bitmap, NULL, su, &bufr);
-								ttiles[x+bx][y+by][level].objects[h].first->flagPrinted = true;
+								SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->getOwner()]->ourImages[8+anim%imgVal].bitmap, NULL, su, &bufr);
+								themp->flagPrinted = true;
 							}
 							break;
 						}
@@ -835,8 +836,8 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 								SDL_Rect bufr = sr;
 								bufr.x-=2*32;
 								bufr.y-=1*32;
-								SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->owner]->ourImages[2*8+anim%imgVal].bitmap, NULL, su, &bufr);
-								ttiles[x+bx][y+by][level].objects[h].first->flagPrinted = true;
+								SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->getOwner()]->ourImages[2*8+anim%imgVal].bitmap, NULL, su, &bufr);
+								themp->flagPrinted = true;
 							}
 							break;
 						}
@@ -860,8 +861,8 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 								SDL_Rect bufr = sr;
 								bufr.x-=2*32;
 								bufr.y-=1*32;
-								SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->owner]->ourImages[3*8+anim%imgVal].bitmap, NULL, su, &bufr);
-								ttiles[x+bx][y+by][level].objects[h].first->flagPrinted = true;
+								SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->getOwner()]->ourImages[3*8+anim%imgVal].bitmap, NULL, su, &bufr);
+								themp->flagPrinted = true;
 							}
 							break;
 						}
@@ -885,8 +886,8 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 								SDL_Rect bufr = sr;
 								bufr.x-=2*32;
 								bufr.y-=1*32;
-								SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->owner]->ourImages[4*8+anim%imgVal].bitmap, NULL, su, &bufr);
-								ttiles[x+bx][y+by][level].objects[h].first->flagPrinted = true;
+								SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->getOwner()]->ourImages[4*8+anim%imgVal].bitmap, NULL, su, &bufr);
+								themp->flagPrinted = true;
 							}
 							break;
 						}
@@ -910,8 +911,8 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 								SDL_Rect bufr = sr;
 								bufr.x-=2*32;
 								bufr.y-=1*32;
-								SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->owner]->ourImages[15*8+anim%imgVal].bitmap, NULL, su, &bufr);
-								ttiles[x+bx][y+by][level].objects[h].first->flagPrinted = true;
+								SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->getOwner()]->ourImages[15*8+anim%imgVal].bitmap, NULL, su, &bufr);
+								themp->flagPrinted = true;
 							}
 							break;
 						}
@@ -935,8 +936,8 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 								SDL_Rect bufr = sr;
 								bufr.x-=2*32;
 								bufr.y-=1*32;
-								SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->owner]->ourImages[14*8+anim%imgVal].bitmap, NULL, su, &bufr);
-								ttiles[x+bx][y+by][level].objects[h].first->flagPrinted = true;
+								SDL_BlitSurface(CGI->heroh->flags4[ttiles[x+bx][y+by][level].objects[h].first->getOwner()]->ourImages[14*8+anim%imgVal].bitmap, NULL, su, &bufr);
+								themp->flagPrinted = true;
 							}
 							break;
 						}
@@ -944,8 +945,8 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 				}
 				else
 				{
-					int imgVal = CGI->ac->map.defy[ttiles[x+bx][y+by][level].objects[h].first->defNumber].handler->ourImages.size();
-					SDL_BlitSurface(CGI->ac->map.defy[ttiles[x+bx][y+by][level].objects[h].first->defNumber].handler->ourImages[anim%imgVal].bitmap,&pp,su,&sr);
+					int imgVal = ttiles[x+bx][y+by][level].objects[h].first->defInfo->handler->ourImages.size();
+					SDL_BlitSurface(ttiles[x+bx][y+by][level].objects[h].first->defInfo->handler->ourImages[anim%imgVal].bitmap,&pp,su,&sr);
 				}
 				//printing appropriate flag colour
 				if(ttiles[x+bx][y+by][level].objects[h].second.second.size())
@@ -954,10 +955,10 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 					for(std::list<int3>::iterator g=curl.begin(); g!=curl.end(); ++g)
 					{
 						SDL_Color ourC;
-						int own = ttiles[x+bx][y+by][level].objects[h].first->owner;
-						if(ttiles[x+bx][y+by][level].objects[h].first->owner!=255 && ttiles[x+bx][y+by][level].objects[h].first->owner!=254)
-							ourC = CGI->playerColors[ttiles[x+bx][y+by][level].objects[h].first->owner];
-						else if(ttiles[x+bx][y+by][level].objects[h].first->owner==255)
+						int own = ttiles[x+bx][y+by][level].objects[h].first->getOwner();
+						if(ttiles[x+bx][y+by][level].objects[h].first->getOwner()!=255 && ttiles[x+bx][y+by][level].objects[h].first->getOwner()!=254)
+							ourC = CGI->playerColors[ttiles[x+bx][y+by][level].objects[h].first->getOwner()];
+						else if(ttiles[x+bx][y+by][level].objects[h].first->getOwner()==255)
 							ourC = CGI->neutralColor;
 						else continue;
 						CSDL_Ext::SDL_PutPixelWithoutRefresh(su, bx*32 + g->x%32 , by*32 + g->y%32, ourC.r , ourC.g, ourC.b, 0);
@@ -971,7 +972,7 @@ SDL_Surface * CMapHandler::terrainRect(int x, int y, int dx, int dy, int level,
 
 	for(int qq=0; qq<CGI->heroh->heroInstances.size(); ++qq)
 	{
-		CGI->heroh->heroInstances[qq]->ourObject->flagPrinted = false;
+		//CGI->heroh->heroInstances[qq]->ourObject->flagPrinted = false;
 	}
 
 	///flags enabled
@@ -1341,7 +1342,7 @@ SDL_Surface * CMapHandler::getVisBitmap(int x, int y, PseudoV< PseudoV< PseudoV<
 //	return undVisibility[x+Woff][y+Hoff];
 //}
 
-int CMapHandler::getCost(int3 &a, int3 &b, const CHeroInstance *hero)
+int CMapHandler::getCost(int3 &a, int3 &b, const CGHeroInstance *hero)
 {
 	int ret = hero->type->heroClass->terrCosts[CGI->mh->ttiles[a.x][a.y][a.z].malle];
 	if(!(a.x==b.x || a.y==b.y))
@@ -1353,7 +1354,7 @@ int CMapHandler::getCost(int3 &a, int3 &b, const CHeroInstance *hero)
 
 std::vector < std::string > CMapHandler::getObjDescriptions(int3 pos)
 {
-	std::vector < std::pair<CObjectInstance*,std::pair<SDL_Rect, std::vector<std::list<int3>>>> > objs = ttiles[pos.x][pos.y][pos.z].objects;
+	std::vector < std::pair<CGObjectInstance*,std::pair<SDL_Rect, std::vector<std::list<int3>>>> > objs = ttiles[pos.x][pos.y][pos.z].objects;
 	std::vector<std::string> ret;
 	for(int g=0; g<objs.size(); ++g)
 	{
@@ -1362,19 +1363,21 @@ std::vector < std::string > CMapHandler::getObjDescriptions(int3 pos)
 			) //checking position blocking
 		{
 			unsigned char * blm = CGI->dobjinfo->objs[objs[g].first->defObjInfoNumber].blockMap;
-			ret.push_back(CGI->objh->objects[CGI->ac->map.defy[objs[g].first->defNumber].bytes[16]].name);
+			ret.push_back(
+			  CGI->objh->objects[objs[g].first->defInfo->bytes[16]].name
+			  );
 		}
 	}
 	return ret;
 }
 
-std::vector < CObjectInstance * > CMapHandler::getVisitableObjs(int3 pos)
+std::vector < CGObjectInstance * > CMapHandler::getVisitableObjs(int3 pos)
 {
-	std::vector < CObjectInstance * > ret;
+	std::vector < CGObjectInstance * > ret;
 	for(int h=0; h<ttiles[pos.x][pos.y][pos.z].objects.size(); ++h)
 	{
-		CObjectInstance * curi = ttiles[pos.x][pos.y][pos.z].objects[h].first;
-		if(curi->visitableAt(curi->pos.x - pos.x, curi->pos.y - pos.y))
+		CGObjectInstance * curi = ttiles[pos.x][pos.y][pos.z].objects[h].first;
+		if(curi->visitableAt(- curi->pos.x + pos.x + curi->getWidth() - 1, -curi->pos.y + pos.y + curi->getHeight() - 1))
 			ret.push_back(curi);
 	}
 	return ret;

mapHandler.h

@@ -29,8 +29,8 @@ struct TerrainTile2
 	bool visitable; //false = not visitable; true = visitable
 	bool blocked; //false = free; true = blocked;
 
-	std::vector < std::pair<CObjectInstance*,std::pair<SDL_Rect, std::vector<std::list<int3>>>> > objects; //poiters to objects being on this tile with rects to be easier to blit this tile on screen
-	std::vector <CObjectInstance*> visitableObjects; //pointers to objects hero is visiting being on this tile
+	std::vector < std::pair<CGObjectInstance*,std::pair<SDL_Rect, std::vector<std::list<int3>>>> > objects; //poiters to objects being on this tile with rects to be easier to blit this tile on screen
+	std::vector <CGObjectInstance*> visitableObjects; //pointers to objects hero is visiting being on this tile
 
 };
 
@@ -77,9 +77,9 @@ public:
 	SDL_Surface mirrorImage(SDL_Surface *src); //what is this??
 	SDL_Surface * getVisBitmap(int x, int y, PseudoV< PseudoV< PseudoV<unsigned char> > > & visibilityMap, int lvl);
 
-	int getCost(int3 & a, int3 & b, const CHeroInstance * hero);
+	int getCost(int3 & a, int3 & b, const CGHeroInstance * hero);
 	std::vector< std::string > getObjDescriptions(int3 pos); //returns desriptions of objects blocking given position
-	std::vector< CObjectInstance * > getVisitableObjs(int3 pos); //returns vector of visitable objects at certain position
+	std::vector< CGObjectInstance * > getVisitableObjs(int3 pos); //returns vector of visitable objects at certain position
 	void init();
 	SDL_Surface * terrainRect(int x, int y, int dx, int dy, int level=0, unsigned char anim=0, PseudoV< PseudoV< PseudoV<unsigned char> > > & visibilityMap = CGI->mh->visibility);
 	SDL_Surface * terrBitmap(int x, int y);