vcmi/CCallback.cpp

#include "stdafx.h"
#include "CCallback.h"
#include "CPathfinder.h"
#include "hch/CHeroHandler.h"
#include "hch/CTownHandler.h"
#include "CGameInfo.h"
#include "hch/CAmbarCendamo.h"
#include "mapHandler.h"
#include "CGameState.h"
#include "CPlayerInterface.h"
#include "hch/CGeneralTextHandler.h"
#include "CAdvmapInterface.h"
#include "CPlayerInterface.h"
#include "hch/CBuildingHandler.h"
#include "hch/CObjectHandler.h"
#include "lib/Connection.h"
#include "client/Client.h"
#include <boost/thread.hpp>
#include <boost/foreach.hpp>
#include "lib/NetPacks.h"
//LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
extern CSharedCond<std::set<IPack*> > mess;

HeroMoveDetails::HeroMoveDetails(int3 Src, int3 Dst, CGHeroInstance*Ho)
	:src(Src),dst(Dst),ho(Ho)
{
	owner = ho->getOwner();
};
bool CCallback::moveHero(int ID, CPath * path, int idtype, int pathType)
{
	CGHeroInstance * hero = NULL;

	if (idtype==0)
	{
		if (player==-1)
			hero=gs->players[player+1].heroes[ID];
		else
			hero=gs->players[player].heroes[ID];
	}
	else if (idtype==1 && player>=0) //looking for it in local area
	{
		for (int i=0; i<gs->players[player].heroes.size();i++)
		{
			if (gs->players[player].heroes[i]->type->ID == ID)
				hero = gs->players[player].heroes[i];
		}
	}
	else //idtype==1; player<0
	{

		for(std::map<ui8, PlayerState>::iterator j=CGI->state->players.begin(); j!=CGI->state->players.end(); ++j)
		{
			for (int i=0; i<(*j).second.heroes.size();i++)
			{
				if ((*j).second.heroes[i]->type->ID == ID)
				{
					hero = (*j).second.heroes[i];
				}
			}
		}
	}

	if (!hero)
		return false; //can't find hero
	if(!verifyPath(path,!hero->canWalkOnSea()))//TODO: not check sea, if hero has flying or walking on water
		return false; //invalid path

	//check path format
	if (pathType==0)
		CPathfinder::convertPath(path,pathType);
	if (pathType>1)
		throw std::exception("Unknown path format");

	CPath * ourPath = path; 
	if(!ourPath)
		return false;
	for(int i=ourPath->nodes.size()-1; i>0; i--)
	{
		int3 stpos(ourPath->nodes[i].coord.x, ourPath->nodes[i].coord.y, hero->pos.z), 
			endpos(ourPath->nodes[i-1].coord.x, ourPath->nodes[i-1].coord.y, hero->pos.z);
		HeroMoveDetails curd(stpos,endpos,hero);

		*cl->serv << ui16(501) << hero->id << stpos << endpos;
		{//wait till there is server answer
			boost::unique_lock<boost::mutex> lock(*mess.mx);
			while(std::find_if(mess.res->begin(),mess.res->end(),IPack::isType<501>) == mess.res->end())
				mess.cv->wait(lock);
			std::set<IPack*>::iterator itr = std::find_if(mess.res->begin(),mess.res->end(),IPack::isType<501>);
			TryMoveHero tmh = *static_cast<TryMoveHero*>(*itr);
			mess.res->erase(itr);
			if(!tmh.result)
				return false;
		}
	}
	return true;
}

void CCallback::selectionMade(int selection, int asker)
{
	//todo - jak bedzie multiplayer po sieci, to moze wymagac przerobek zaleznych od obranego modelu
	//IChosen * ask = (IChosen *)asker;
	//ask->chosen(selection);
}
void CCallback::recruitCreatures(const CGObjectInstance *obj, int ID, int amount)
{
	if(amount<=0) return;
	if(obj->ID==98) //recruiting from town
	{
		int ser=-1; //used dwelling level
		CGTownInstance *t = const_cast<CGTownInstance*>(static_cast<const CGTownInstance*>(obj));

		//verify
		bool found = false;
		typedef std::pair<const int,int> Parka;
		for(std::map<int,int>::iterator av=t->strInfo.creatures.begin();av!=t->strInfo.creatures.end();av++)
		{
			if(	(   found  = (ID == t->town->basicCreatures[av->first])   ) //creature is available among basic cretures
				|| (found  = (ID == t->town->upgradedCreatures[av->first]))			)//creature is available among upgraded cretures
			{
				amount = min(amount,av->second); //reduce recruited amount up to available amount
				ser = av->first;
				break;
			}
		}
		if(!found)	//no such creature
			return;

		if(amount > CGI->creh->creatures[ID].maxAmount(gs->players[player].resources))
			return; //not enough resources

		//for(int i=0;i<RESOURCE_QUANTITY;i++)
		//	if (gs->players[player].resources[i]  <  (CGI->creh->creatures[ID].cost[i] * amount))
		//		return; //not enough resources

		if(amount<=0) return;

		//recruit
		int slot = -1; //slot ID
		std::pair<int,std::pair<CCreature*,int> > parb;	

		for(int i=0;i<7;i++) //TODO: if there is already stack of same creatures it should be used always
		{
			if((!t->army.slots[i].first) || (t->army.slots[i].first->idNumber == ID)) //slot is free or there is saem creature
			{
				slot = i;
				break;
			}
		}

		if(slot<0) //no free slot
			return;

		for(int i=0;i<RESOURCE_QUANTITY;i++)
			gs->players[player].resources[i]  -=  (CGI->creh->creatures[ID].cost[i] * amount);

		t->strInfo.creatures[ser] -= amount;
		if(t->army.slots[slot].first) //add new creatures to the existing stack
		{
			t->army.slots[slot].second += amount;
		}
		else //create new stack in the garrison
		{
			t->army.slots[slot].first = &CGI->creh->creatures[ID];
			t->army.slots[slot].second = amount;
		}
		cl->playerint[player]->garrisonChanged(obj);

	}
	//TODO: recruit from dwellings on the adventure map
}


bool CCallback::dismissCreature(const CArmedInstance *obj, int stackPos)
{
	if((player>=0)  &&  obj->tempOwner != player)
		return false;
	CArmedInstance *ob = const_cast<CArmedInstance*>(obj);
	ob->army.slots.erase(stackPos);
	cl->playerint[player]->garrisonChanged(obj);
	return true;
}
bool CCallback::upgradeCreature(const CArmedInstance *obj, int stackPos, int newID)
{
	//TODO: write
	return false;
}
void CCallback::endTurn()
{
	std::cout << "Player "<<(unsigned)player<<" end his turn."<<std::endl;
	cl->serv->wmx->lock();
	*cl->serv << ui16(100); //report that we ended turn
	cl->serv->wmx->unlock();
}
UpgradeInfo CCallback::getUpgradeInfo(const CArmedInstance *obj, int stackPos)
{
	UpgradeInfo ret;
	CCreature *base = ((CArmedInstance*)obj)->army.slots[stackPos].first;
	if((obj->ID == 98)  ||  ((obj->ID == 34) && static_cast<const CGHeroInstance*>(obj)->visitedTown))
	{
		CGTownInstance * t;
		if(obj->ID == 98)
			t = static_cast<CGTownInstance *>(const_cast<CArmedInstance *>(obj));
		else
			t = static_cast<const CGHeroInstance*>(obj)->visitedTown;
		for(std::set<int>::iterator i=t->builtBuildings.begin();  i!=t->builtBuildings.end(); i++)
		{
			if( (*i) >= 37   &&   (*i) < 44 ) //upgraded creature dwelling
			{
				int nid = t->town->upgradedCreatures[(*i)-37]; //upgrade offered by that building
				if(base->upgrades.find(nid) != base->upgrades.end()) //possible upgrade
				{
					ret.newID.push_back(nid);
					ret.cost.push_back(std::set<std::pair<int,int> >());
					for(int j=0;j<RESOURCE_QUANTITY;j++)
					{
						int dif = CGI->creh->creatures[nid].cost[j] - base->cost[j];
						if(dif)
							ret.cost[ret.cost.size()-1].insert(std::make_pair(j,dif));
					}
				}
			}
		}//end for
	}
	//TODO: check if hero ability makes some upgrades possible

	if(ret.newID.size())
		ret.oldID = base->idNumber;

	return ret;
}

const StartInfo * CCallback::getStartInfo()
{
	return gs->scenarioOps;
}

int CCallback::howManyTowns()
{
	return gs->players[gs->currentPlayer].towns.size();
}
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];
	else 
	{
		//TODO: add some smart ID to the CTownInstance


		//for (int i=0; i<gs->players[gs->currentPlayer].towns.size();i++)
		//{
		//	if (gs->players[gs->currentPlayer].towns[i]->someID==val)
		//		return gs->players[gs->currentPlayer].towns[i];
		//}
		return NULL;
	}
	return NULL;
}
int CCallback::howManyHeroes()
{
	return gs->players[player].heroes.size();
}
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;
	if (!mode)
		if(val<gs->players[player].heroes.size())
			return gs->players[player].heroes[val];
		else return NULL;
	else 
	{
		for (int i=0; i<gs->players[player].heroes.size();i++)
		{
			if (gs->players[player].heroes[i]->type->ID==val)
				return gs->players[player].heroes[i];
		}
	}
	return NULL;
}

int CCallback::getResourceAmount(int type)
{
	return gs->players[player].resources[type];
}
std::vector<int> CCallback::getResourceAmount()
{
	return gs->players[player].resources;
}
int CCallback::getDate(int mode)
{
	return gs->getDate(mode);
}
std::vector < std::string > CCallback::getObjDescriptions(int3 pos)
{
	std::vector<std::string> ret;
	BOOST_FOREACH(const CGObjectInstance * obj, gs->map->terrain[pos.x][pos.y][pos.z].blockingObjects)
		ret.push_back(obj->hoverName);
	return ret;
}
bool CCallback::verifyPath(CPath * path, bool blockSea)
{
	for (int i=0;i<path->nodes.size();i++)
	{
		if ( CGI->mh->ttiles[path->nodes[i].coord.x][path->nodes[i].coord.y][path->nodes[i].coord.z].tileInfo->blocked 
			&& (! (CGI->mh->ttiles[path->nodes[i].coord.x][path->nodes[i].coord.y][path->nodes[i].coord.z].tileInfo->visitable)))
			return false; //path is wrong - one of the tiles is blocked

		if (blockSea)
		{
			if (i==0)
				continue;

			if (
					((CGI->mh->ttiles[path->nodes[i].coord.x][path->nodes[i].coord.y][path->nodes[i].coord.z].tileInfo->tertype==EterrainType::water)
					&&
					(CGI->mh->ttiles[path->nodes[i-1].coord.x][path->nodes[i-1].coord.y][path->nodes[i-1].coord.z].tileInfo->tertype!=EterrainType::water))
				  ||
					((CGI->mh->ttiles[path->nodes[i].coord.x][path->nodes[i].coord.y][path->nodes[i].coord.z].tileInfo->tertype!=EterrainType::water)
					&&
					(CGI->mh->ttiles[path->nodes[i-1].coord.x][path->nodes[i-1].coord.y][path->nodes[i-1].coord.z].tileInfo->tertype==EterrainType::water))
				  ||
				  (CGI->mh->ttiles[path->nodes[i-1].coord.x][path->nodes[i-1].coord.y][path->nodes[i-1].coord.z].tileInfo->tertype==EterrainType::rock)
					
				)
				return false;
		}


	}
	return true;
}

std::vector< std::vector< std::vector<unsigned char> > > & CCallback::getVisibilityMap()
{
	return gs->players[player].fogOfWarMap;
}


bool CCallback::isVisible(int3 pos, int Player)
{
	return gs->players[Player].fogOfWarMap[pos.x][pos.y][pos.z];
}

std::vector < const CGTownInstance *> CCallback::getTownsInfo(bool onlyOur)
{
	std::vector < const CGTownInstance *> ret = std::vector < const CGTownInstance *>();
	for ( std::map<ui8, PlayerState>::iterator i=gs->players.begin() ; i!=gs->players.end();i++)
	{
		for (int j=0;j<(*i).second.towns.size();j++)
		{
			if ( ( isVisible((*i).second.towns[j]->pos,player) ) || (*i).first==player)
			{
				ret.push_back((*i).second.towns[j]);
			}
		}
	} //	for ( std::map<int, PlayerState>::iterator i=gs->players.begin() ; i!=gs->players.end();i++)
	return ret;
}
std::vector < const CGHeroInstance *> CCallback::getHeroesInfo(bool onlyOur)
{
	std::vector < const CGHeroInstance *> ret = std::vector < const CGHeroInstance *>();
	for ( std::map<ui8, PlayerState>::iterator i=gs->players.begin() ; i!=gs->players.end();i++)
	{
		for (int j=0;j<(*i).second.heroes.size();j++)
		{
			if ( ( isVisible((*i).second.heroes[j]->getPosition(false),player) ) || (*i).first==player)
			{
				ret.push_back((*i).second.heroes[j]);
			}
		}
	} //	for ( std::map<int, PlayerState>::iterator i=gs->players.begin() ; i!=gs->players.end();i++)
	return ret;
}

bool CCallback::isVisible(int3 pos)
{
	return isVisible(pos,player);
}

int CCallback::getMyColor()
{
	return player;
}
int CCallback::getHeroSerial(const CGHeroInstance * hero)
{
	for (int i=0; i<gs->players[player].heroes.size();i++)
	{
		if (gs->players[player].heroes[i]==hero)
			return i;
	}
	return -1;
}
const CCreatureSet* CCallback::getGarrison(const CGObjectInstance *obj)
{
	if(!obj)
		return NULL;
	if(obj->ID == 34)
		return &(dynamic_cast<const CGHeroInstance*>(obj))->army;
	else if(obj->ID == 98)
		return &(dynamic_cast<const CGTownInstance*>(obj)->army);
	else return NULL;
}

int CCallback::swapCreatures(const CGObjectInstance *s1, const CGObjectInstance *s2, int p1, int p2)
{
	CCreatureSet *S1 = const_cast<CCreatureSet*>(getGarrison(s1)), *S2 = const_cast<CCreatureSet*>(getGarrison(s2));
	if (false)
	{
		//TODO: check if we are allowed to swap these creatures
		return -1;
	}

	CCreature * pom = S2->slots[p2].first;
	S2->slots[p2].first = S1->slots[p1].first;
	S1->slots[p1].first = pom;
	int pom2 = S2->slots[p2].second;
	S2->slots[p2].second = S1->slots[p1].second;
	S1->slots[p1].second = pom2;

	if(!S1->slots[p1].first)
		S1->slots.erase(p1);
	if(!S2->slots[p2].first)
		S2->slots.erase(p2);

	if(s1->tempOwner<PLAYER_LIMIT)
		cl->playerint[s1->tempOwner]->garrisonChanged(s1);
	if((s2->tempOwner<PLAYER_LIMIT) && (s2 != s1))
		cl->playerint[s2->tempOwner]->garrisonChanged(s2);
	return 0;
}

int CCallback::mergeStacks(const CGObjectInstance *s1, const CGObjectInstance *s2, int p1, int p2)
{	
	CCreatureSet *S1 = const_cast<CCreatureSet*>(getGarrison(s1)), *S2 = const_cast<CCreatureSet*>(getGarrison(s2));
	if ((S1->slots[p1].first != S2->slots[p2].first) && (true /*we are allowed to*/))
	{
		return -1;
	}


	S2->slots[p2].second += S1->slots[p1].second;
	S1->slots[p1].first = NULL;
	S1->slots[p1].second = 0;

	S1->slots.erase(p1);

	if(s1->tempOwner<PLAYER_LIMIT)
		cl->playerint[s1->tempOwner]->garrisonChanged(s1);

	if((s2->tempOwner<PLAYER_LIMIT) && (s2 != s1))
		cl->playerint[s2->tempOwner]->garrisonChanged(s2);
	return 0;
}
int CCallback::splitStack(const CGObjectInstance *s1, const CGObjectInstance *s2, int p1, int p2, int val)
{
	if(!val)
		return -1;
	CCreatureSet *S1 = const_cast<CCreatureSet*>(getGarrison(s1)), *S2 = const_cast<CCreatureSet*>(getGarrison(s2));
	if ((S1->slots[p1].second<val) && (true /*we are allowed to*/))
	{
		return -1;
	}

	S2->slots[p2].first = S1->slots[p1].first;
	S2->slots[p2].second = val;
	S1->slots[p1].second -= val;
	if(!S1->slots[p1].second) //if we've moved all creatures
		S1->slots.erase(p1); 


	if(s1->tempOwner<PLAYER_LIMIT)
	{
		cl->playerint[s1->tempOwner]->garrisonChanged(s1);
	}
	if((s2->tempOwner<PLAYER_LIMIT) && (s2 != s1))
	{
		cl->playerint[s2->tempOwner]->garrisonChanged(s2);
	}
	return 0;
}

bool CCallback::dismissHero(const CGHeroInstance *hero)
{
	CGHeroInstance * Vhero = const_cast<CGHeroInstance *>(hero);
	CGI->mh->removeObject(Vhero);
	std::vector<CGHeroInstance*>::iterator nitr = find(CGI->state->players[player].heroes.begin(), CGI->state->players[player].heroes.end(), Vhero);
	CGI->state->players[player].heroes.erase(nitr);
	LOCPLINT->adventureInt->heroList.updateHList();
	return false;
}

int CCallback::getMySerial()
{	
	return gs->players[player].serial;
}

bool CCallback::swapArifacts(const CGHeroInstance * hero1, bool worn1, int pos1, const CGHeroInstance * hero2, bool worn2, int pos2)
{
	if(!hero1 || !hero2) //incorrect data
		return false;
	CGHeroInstance * Uhero1 = const_cast<CGHeroInstance *>(hero1);
	CGHeroInstance * Uhero2 = const_cast<CGHeroInstance *>(hero2);

	if(worn1 && worn2)
	{
		std::swap(Uhero1->artifWorn[pos1], Uhero2->artifWorn[pos2]);
	}
	else if(worn1 && !worn2)
	{
		std::swap(Uhero1->artifWorn[pos1], Uhero2->artifacts[pos2]);
	}
	else if(!worn1 && worn2)
	{
		std::swap(Uhero1->artifacts[pos1], Uhero2->artifWorn[pos2]);
	}
	else
	{
		std::swap(Uhero1->artifacts[pos1], Uhero2->artifacts[pos2]);
	}
	
	return true;
}

bool CCallback::buildBuilding(const CGTownInstance *town, int buildingID)
{
	CGTownInstance * t = const_cast<CGTownInstance *>(town);
	CBuilding *b = CGI->buildh->buildings[t->subID][buildingID];

	if(0/*not allowed*/)//TODO: check if we are allowed to build
		return false;

	if(buildingID>36) //upg dwelling
	{
		if(t->getHordeLevel(0) == (buildingID-37))
			t->builtBuildings.insert(19);
		else if(t->getHordeLevel(1) == (buildingID-37))
			t->builtBuildings.insert(25);
	}
	else if(buildingID >= 30) //bas. dwelling
	{
		t->strInfo.creatures[buildingID-30] = CGI->creh->creatures[t->town->basicCreatures[buildingID-30]].growth;
	}

	t->builtBuildings.insert(buildingID);
	for(int i=0;i<7;i++)
		gs->players[player].resources[i]-=b->resources[i];
	t->builded++;
	cl->playerint[player]->buildChanged(town,buildingID,1);
	return true;
}

int CCallback::battleGetBattlefieldType()
{
	return CGI->mh->ttiles[CGI->state->curB->tile.x][CGI->state->curB->tile.y][CGI->state->curB->tile.z].tileInfo->tertype;
}

int CCallback::battleGetObstaclesAtTile(int tile) //returns bitfield 
{
	//TODO - write
	return -1;
}
int CCallback::battleGetStack(int pos)
{
	for(int g=0; g<CGI->state->curB->stacks.size(); ++g)
	{
		if(CGI->state->curB->stacks[g]->position == pos ||
				( CGI->state->curB->stacks[g]->creature->isDoubleWide() && 
					( (CGI->state->curB->stacks[g]->attackerOwned && CGI->state->curB->stacks[g]->position-1 == pos) || 
						(!CGI->state->curB->stacks[g]->attackerOwned && CGI->state->curB->stacks[g]->position+1 == pos)
					) 
				)
			)
			return CGI->state->curB->stacks[g]->ID;
	}
	return -1;
}

CStack* CCallback::battleGetStackByID(int ID)
{
	for(int g=0; g<CGI->state->curB->stacks.size(); ++g)
	{
		if(CGI->state->curB->stacks[g]->ID == ID)
			return CGI->state->curB->stacks[g];
	}
	return NULL;
}

CStack* CCallback::battleGetStackByPos(int pos)
{
	return battleGetStackByID(battleGetStack(pos));
}

int CCallback::battleGetPos(int stack)
{
	for(int g=0; g<CGI->state->curB->stacks.size(); ++g)
	{
		if(CGI->state->curB->stacks[g]->ID == stack)
			return CGI->state->curB->stacks[g]->position;
	}
	return -1;
}

std::map<int, CStack> CCallback::battleGetStacks()
{
	std::map<int, CStack> ret;
	for(int g=0; g<CGI->state->curB->stacks.size(); ++g)
	{
		ret[CGI->state->curB->stacks[g]->ID] = *(CGI->state->curB->stacks[g]);
	}
	return ret;
}

CCreature CCallback::battleGetCreature(int number)
{
	for(int h=0; h<CGI->state->curB->stacks.size(); ++h)
	{
		if(CGI->state->curB->stacks[h]->ID == number) //creature found
			return *(CGI->state->curB->stacks[h]->creature);
	}
	throw new std::exception("Cannot find the creature");
}

std::vector<int> CCallback::battleGetAvailableHexes(int ID)
{
	return CGI->state->battleGetRange(ID);
}

bool CCallback::battleIsStackMine(int ID)
{
	for(int h=0; h<CGI->state->curB->stacks.size(); ++h)
	{
		if(CGI->state->curB->stacks[h]->ID == ID) //creature found
			return CGI->state->curB->stacks[h]->owner == player;
	}
	return false;
}