games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2025-03-03 14:52:11 +02:00
Code Issues Releases Activity

* PlayerColor and TeamID refactoring

Browse Source
This commit is contained in:
mateuszb 2013-03-03 17:06:03 +00:00
parent ef6be76480
commit dbec99ffc7
70 changed files with 889 additions and 843 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
AI/VCAI/VCAI.cpp
View File

@ -393,7 +393,7 @@ ui64 evaluateDanger(crint3 tile, const CGHeroInstance *visitor)
ui64 evaluateDanger(const CGObjectInstance *obj)
{
if(obj->tempOwner < GameConstants::PLAYER_LIMIT && cb->getPlayerRelations(obj->tempOwner, ai->playerID) != PlayerRelations::ENEMIES) //owned or allied objects don't pose any threat
if(obj->tempOwner < PlayerColor::PLAYER_LIMIT && cb->getPlayerRelations(obj->tempOwner, ai->playerID) != PlayerRelations::ENEMIES) //owned or allied objects don't pose any threat
return 0;
switch(obj->ID)
@ -553,11 +553,11 @@ void VCAI::showShipyardDialog(const IShipyard *obj)
LOG_ENTRY;
}
void VCAI::gameOver(ui8 player, bool victory)
void VCAI::gameOver(PlayerColor player, bool victory)
{
NET_EVENT_HANDLER;
LOG_ENTRY;
BNLOG("Player %d: I heard that player %d %s.", playerID % (int)player % (victory ? "won" : "lost"));
BNLOG("Player %d: I heard that player %d %s.", playerID % player.getNum() % (victory ? "won" : "lost"));
if(player == playerID)
{
if(victory)
@ -567,7 +567,7 @@ void VCAI::gameOver(ui8 player, bool victory)
}
else
{
tlog0 << "VCAI: Player " << (int)player << " lost. It's me. What a disappointment! :(\n";
tlog0 << "VCAI: Player " << player << " lost. It's me. What a disappointment! :(\n";
}
// //let's make Impossible difficulty finally standing to its name :>
@ -838,7 +838,7 @@ void VCAI::objectPropertyChanged(const SetObjectProperty * sop)
LOG_ENTRY;
if(sop->what == ObjProperty::OWNER)
{
if(sop->val == playerID)
if(sop->val == playerID.getNum())
remove_if_present(visitableObjs, myCb->getObj(sop->id));
//TODO restore lost obj
}
@ -1593,7 +1593,7 @@ void VCAI::completeGoal (const CGoal goal)
void VCAI::battleStart(const CCreatureSet *army1, const CCreatureSet *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool side)
{
NET_EVENT_HANDLER;
assert(playerID > GameConstants::PLAYER_LIMIT || status.getBattle() == UPCOMING_BATTLE);
assert(playerID > PlayerColor::PLAYER_LIMIT || status.getBattle() == UPCOMING_BATTLE);
status.setBattle(ONGOING_BATTLE);
const CGObjectInstance *presumedEnemy = backOrNull(cb->getVisitableObjs(tile)); //may be NULL in some very are cases -> eg. visited monolith and fighting with an enemy at the FoW covered exit
battlename = boost::str(boost::format("Starting battle of %s attacking %s at %s") % (hero1 ? hero1->name : "a army") % (presumedEnemy ? presumedEnemy->hoverName : "unknown enemy") % tile);
@ -2344,7 +2344,7 @@ void VCAI::striveToQuest (const QuestInfo &q)
}
case CQuest::MISSION_PLAYER:
{
if (playerID != q.quest->m13489val)
if (playerID.getNum() != q.quest->m13489val)
BNLOG ("Can't be player of color %d\n", q.quest->m13489val);
break;
}

2
AI/VCAI/VCAI.h
View File

@ -305,7 +305,7 @@ public:
virtual void playerBlocked(int reason) OVERRIDE;
virtual void showPuzzleMap() OVERRIDE;
virtual void showShipyardDialog(const IShipyard *obj) OVERRIDE;
virtual void gameOver(ui8 player, bool victory) OVERRIDE;
virtual void gameOver(PlayerColor player, bool victory) OVERRIDE;
virtual void artifactPut(const ArtifactLocation &al) OVERRIDE;
virtual void artifactRemoved(const ArtifactLocation &al) OVERRIDE;
virtual void stacksErased(const StackLocation &location) OVERRIDE;

6
CCallback.cpp
View File

@ -98,7 +98,7 @@ bool CCallback::upgradeCreature(const CArmedInstance *obj, SlotID stackPos, Crea
void CCallback::endTurn()
{
tlog5 << "Player " << (unsigned)*player << " ended his turn." << std::endl;
tlog5 << "Player " << *player << " ended his turn." << std::endl;
EndTurn pack;
sendRequest(&pack); //report that we ended turn
}
@ -289,7 +289,7 @@ void CCallback::buildBoat( const IShipyard *obj )
sendRequest(&bb);
}
CCallback::CCallback( CGameState * GS, boost::optional<TPlayerColor> Player, CClient *C )
CCallback::CCallback( CGameState * GS, boost::optional<PlayerColor> Player, CClient *C )
:CBattleCallback(GS, Player, C)
{
waitTillRealize = false;
@ -376,7 +376,7 @@ int CCallback::mergeOrSwapStacks(const CArmedInstance *s1, const CArmedInstance
return swapCreatures(s1, s2, p1, p2);
}
CBattleCallback::CBattleCallback(CGameState *GS, boost::optional<TPlayerColor> Player, CClient *C )
CBattleCallback::CBattleCallback(CGameState *GS, boost::optional<PlayerColor> Player, CClient *C )
{
gs = GS;
player = Player;

4
CCallback.h
View File

@ -86,7 +86,7 @@ protected:
//virtual bool hasAccess(int playerId) const;
public:
CBattleCallback(CGameState *GS, boost::optional<TPlayerColor> Player, CClient *C);
CBattleCallback(CGameState *GS, boost::optional<PlayerColor> Player, CClient *C);
int battleMakeAction(BattleAction* action) OVERRIDE;//for casting spells by hero - DO NOT use it for moving active stack
bool battleMakeTacticAction(BattleAction * action) OVERRIDE; // performs tactic phase actions
@ -101,7 +101,7 @@ private:
void validatePaths(); //recalcualte paths if necessary
public:
CCallback(CGameState * GS, boost::optional<TPlayerColor> Player, CClient *C);
CCallback(CGameState * GS, boost::optional<PlayerColor> Player, CClient *C);
virtual ~CCallback();
//client-specific functionalities (pathfinding)

2
Editor/Editor.cpp
View File

@ -10,7 +10,7 @@
Editor::Editor(QWidget *parent)
: QMainWindow(parent)
{
logfile = new std::ofstream((GVCMIDirs.UserPath + "/VCMI_Editor_log.txt").c_str());
logfile = new std::ofstream((VCMIDirs::get().localPath() + "/VCMI_Editor_log.txt").c_str());
console = new CConsoleHandler;
preinitDLL(console,logfile);

7
Scripting/ERM/ERMInterpreter.cpp
View File

@ -5,6 +5,7 @@
#include "../../lib/CObjectHandler.h"
#include "../../lib/CHeroHandler.h"
#include "../../lib/CCreatureHandler.h"
#include "../../lib/VCMIDirs.h"
/*
* ERMInterpreter.cpp, part of VCMI engine
@ -366,13 +367,13 @@ void ERMInterpreter::scanForScripts()
{
using namespace boost::filesystem;
//parser checking
if(!exists(GameConstants::DATA_DIR + "/Data/s/"))
if(!exists(VCMIDirs::get().dataPath() + "/Data/s/"))
{
tlog3 << "Warning: Folder " << GameConstants::DATA_DIR << "/Data/s/ doesn't exist!\n";
tlog3 << "Warning: Folder " << VCMIDirs::get().dataPath() << "/Data/s/ doesn't exist!\n";
return;
}
directory_iterator enddir;
for (directory_iterator dir(GameConstants::DATA_DIR + "/Data/s"); dir!=enddir; dir++)
for (directory_iterator dir(VCMIDirs::get().dataPath() + "/Data/s"); dir!=enddir; dir++)
{
if(is_regular(dir->status()))
{

36
client/AdventureMapClasses.cpp
View File

@ -361,12 +361,12 @@ const SDL_Color & CMinimapInstance::getTileColor(const int3 & pos)
if (obj->ID == Obj::HERO)
continue;
int player = obj->getOwner();
if(player == GameConstants::NEUTRAL_PLAYER)
PlayerColor player = obj->getOwner();
if(player == PlayerColor::NEUTRAL)
return *graphics->neutralColor;
else
if (player < GameConstants::PLAYER_LIMIT)
return graphics->playerColors[player];
if (player < PlayerColor::PLAYER_LIMIT)
return graphics->playerColors[player.getNum()];
}
// else - use terrain color (blocked version or normal)
@ -468,7 +468,7 @@ void CMinimapInstance::showAll(SDL_Surface *to)
int3 position = hero->getPosition(false);
if (position.z == level)
{
const SDL_Color & color = graphics->playerColors[hero->getOwner()];
const SDL_Color & color = graphics->playerColors[hero->getOwner().getNum()];
blitTileWithColor(color, position, to, pos.x, pos.y);
}
}
@ -723,13 +723,13 @@ void CInfoBar::CVisibleInfo::loadDay()
forceRefresh.push_back(new CLabel(95, 31, FONT_MEDIUM, CENTER, Colors::WHITE, labelText));
}
void CInfoBar::CVisibleInfo::loadEnemyTurn(int player)
void CInfoBar::CVisibleInfo::loadEnemyTurn(PlayerColor player)
{
assert(children.empty()); // visible info should be re-created to change type
OBJ_CONSTRUCTION_CAPTURING_ALL;
new CPicture("ADSTATNX");
new CAnimImage("CREST58", player, 0, 20, 51);
new CAnimImage("CREST58", player.getNum(), 0, 20, 51);
new CShowableAnim(99, 51, "HOURSAND");
// FIXME: currently there is no way to get progress from VCAI
@ -753,17 +753,17 @@ void CInfoBar::CVisibleInfo::loadGameStatus()
BOOST_FOREACH(auto town, LOCPLINT->towns)
halls[town->hallLevel()]++;
std::vector<int> allies, enemies;
std::vector<PlayerColor> allies, enemies;
//generate list of allies and enemies
for(int i = 0; i < GameConstants::PLAYER_LIMIT; i++)
for(int i = 0; i < PlayerColor::PLAYER_LIMIT_I; i++)
{
if(LOCPLINT->cb->getPlayerStatus(i) == EPlayerStatus::INGAME)
if(LOCPLINT->cb->getPlayerStatus(PlayerColor(i)) == EPlayerStatus::INGAME)
{
if (LOCPLINT->cb->getPlayerRelations(LOCPLINT->playerID, i) != PlayerRelations::ENEMIES)
allies.push_back(i);
if (LOCPLINT->cb->getPlayerRelations(LOCPLINT->playerID, PlayerColor(i)) != PlayerRelations::ENEMIES)
allies.push_back(PlayerColor(i));
else
enemies.push_back(i);
enemies.push_back(PlayerColor(i));
}
}
@ -774,16 +774,16 @@ void CInfoBar::CVisibleInfo::loadGameStatus()
auto enemyLabel = new CLabel(10, 136, FONT_SMALL, TOPLEFT, Colors::WHITE, CGI->generaltexth->allTexts[391] + ":");
int posx = allyLabel->pos.w + allyLabel->pos.x - pos.x + 4;
BOOST_FOREACH(int & player, allies)
BOOST_FOREACH(PlayerColor & player, allies)
{
auto image = new CAnimImage("ITGFLAGS", player, 0, posx, 102);
auto image = new CAnimImage("ITGFLAGS", player.getNum(), 0, posx, 102);
posx += image->pos.w;
}
posx = enemyLabel->pos.w + enemyLabel->pos.x - pos.x + 4;
BOOST_FOREACH(int & player, enemies)
BOOST_FOREACH(PlayerColor & player, enemies)
{
auto image = new CAnimImage("ITGFLAGS", player, 0, posx, 132);
auto image = new CAnimImage("ITGFLAGS", player.getNum(), 0, posx, 132);
posx += image->pos.w;
}
@ -904,7 +904,7 @@ void CInfoBar::showComponent(const Component & comp, std::string message)
redraw();
}
void CInfoBar::startEnemyTurn(ui8 color)
void CInfoBar::startEnemyTurn(PlayerColor color)
{
reset(AITURN);
visibleInfo->loadEnemyTurn(color);

4
client/AdventureMapClasses.h
View File

@ -261,7 +261,7 @@ class CInfoBar : public CIntObject
void loadHero(const CGHeroInstance * hero);
void loadTown(const CGTownInstance * town);
void loadDay();
void loadEnemyTurn(int player);
void loadEnemyTurn(PlayerColor player);
void loadGameStatus();
void loadComponent(const Component &comp, std::string message);
@ -298,7 +298,7 @@ public:
void showComponent(const Component & comp, std::string message);
/// print enemy turn progress
void startEnemyTurn(ui8 color);
void startEnemyTurn(PlayerColor color);
/// updates enemy turn.
/// NOTE: currently DISABLED. Check comments in CInfoBar::CVisibleInfo::loadEnemyTurn()
void updateEnemyTurn(double progress);

2
client/BattleInterface/CBattleInterfaceClasses.cpp
View File

@ -198,7 +198,7 @@ void CBattleHero::switchToNextPhase()
currentFrame = firstFrame;
}
CBattleHero::CBattleHero(const std::string & defName, bool flipG, ui8 player, const CGHeroInstance * hero, const CBattleInterface * owner):
CBattleHero::CBattleHero(const std::string & defName, bool flipG, PlayerColor player, const CGHeroInstance * hero, const CBattleInterface * owner):
flip(flipG),
myHero(hero),
myOwner(owner),

2
client/BattleInterface/CBattleInterfaceClasses.h
View File

@ -61,7 +61,7 @@ public:
void show(SDL_Surface * to); //prints next frame of animation to to
void setPhase(int newPhase); //sets phase of hero animation
void clickLeft(tribool down, bool previousState); //call-in
CBattleHero(const std::string &defName, bool filpG, ui8 player, const CGHeroInstance *hero, const CBattleInterface *owner); //c-tor
CBattleHero(const std::string &defName, bool filpG, PlayerColor player, const CGHeroInstance *hero, const CBattleInterface *owner); //c-tor
~CBattleHero(); //d-tor
};

6
client/CAdvmapInterface.cpp
View File

@ -748,7 +748,7 @@ void CAdvMapInt::show(SDL_Surface * to)
{
terrain.show(to);
for(int i=0;i<4;i++)
blitAt(gems[i]->ourImages[LOCPLINT->playerID].bitmap,ADVOPT.gemX[i],ADVOPT.gemY[i],to);
blitAt(gems[i]->ourImages[LOCPLINT->playerID.getNum()].bitmap,ADVOPT.gemX[i],ADVOPT.gemY[i],to);
updateScreen=false;
LOCPLINT->cingconsole->showAll(to);
}
@ -1066,12 +1066,12 @@ bool CAdvMapInt::isActive()
return active & ~CIntObject::KEYBOARD;
}
void CAdvMapInt::startHotSeatWait(int Player)
void CAdvMapInt::startHotSeatWait(PlayerColor Player)
{
state = WAITING;
}
void CAdvMapInt::setPlayer(int Player)
void CAdvMapInt::setPlayer(PlayerColor Player)
{
player = Player;
graphics->blueToPlayersAdv(bg,player);

6
client/CAdvmapInterface.h
View File

@ -93,7 +93,7 @@ public:
~CAdvMapInt();
int3 position; //top left corner of visible map part
int player;
PlayerColor player;
bool duringAITurn;
@ -164,8 +164,8 @@ public:
void setHeroSleeping(const CGHeroInstance *hero, bool sleep);
int getNextHeroIndex(int startIndex); //for Next Hero button - cycles awake heroes with movement only
void setPlayer(int Player);
void startHotSeatWait(int Player);
void setPlayer(PlayerColor Player);
void startHotSeatWait(PlayerColor Player);
void startTurn();
void endingTurn();
void aiTurnStarted();

12
client/CAnimation.cpp
View File

@ -651,7 +651,7 @@ void SDLImage::draw(SDL_Surface *where, int posX, int posY, Rect *src, ui8 rotat
CSDL_Ext::blitSurface(surf, &sourceRect, where, &destRect);
}
void SDLImage::playerColored(int player)
void SDLImage::playerColored(PlayerColor player)
{
graphics->blueToPlayersAdv(surf, player);
}
@ -852,14 +852,14 @@ void CompImage::BlitBlock(ui8 type, ui8 size, ui8 *&data, ui8 *&dest, ui8 alpha)
}
}
void CompImage::playerColored(int player)
void CompImage::playerColored(PlayerColor player)
{
SDL_Color *pal = NULL;
if(player < GameConstants::PLAYER_LIMIT && player >= 0)
if(player < PlayerColor::PLAYER_LIMIT)
{
pal = graphics->playerColorPalette + 32*player;
pal = graphics->playerColorPalette + 32*player.getNum();
}
else if(player == 255 || player == -1)
else if(player == PlayerColor::NEUTRAL)
{
pal = graphics->neutralColorPalette;
}
@ -1253,7 +1253,7 @@ void CAnimImage::setFrame(size_t Frame, size_t Group)
tlog1 << "Error: accessing unavailable frame " << Group << ":" << Frame << " in CAnimation!\n";
}
void CAnimImage::playerColored(int currPlayer)
void CAnimImage::playerColored(PlayerColor currPlayer)
{
player = currPlayer;
flags |= CShowableAnim::PLAYER_COLORED;

10
client/CAnimation.h
View File

@ -68,7 +68,7 @@ public:
void increaseRef();
//Change palette to specific player
virtual void playerColored(int player)=0;
virtual void playerColored(PlayerColor player)=0;
virtual int width() const=0;
virtual int height() const=0;
IImage();
@ -98,7 +98,7 @@ public:
~SDLImage();
void draw(SDL_Surface *where, int posX=0, int posY=0, Rect *src=NULL, ui8 alpha=255) const;
void playerColored(int player);
void playerColored(PlayerColor player);
int width() const;
int height() const;
@ -144,7 +144,7 @@ public:
~CompImage();
void draw(SDL_Surface *where, int posX=0, int posY=0, Rect *src=NULL, ui8 alpha=255) const;
void playerColored(int player);
void playerColored(PlayerColor player);
int width() const;
int height() const;
@ -228,7 +228,7 @@ private:
//displayed frame/group
size_t frame;
size_t group;
int player;
PlayerColor player;
ui8 flags;
void init();
@ -245,7 +245,7 @@ public:
void setFrame(size_t Frame, size_t Group=0);
//makes image player-colored
void playerColored(int player);
void playerColored(PlayerColor player);
void showAll(SDL_Surface * to);
};

2
client/CCastleInterface.cpp
View File

@ -424,7 +424,7 @@ void CHeroGSlot::set(const CGHeroInstance *newHero)
if (newHero)
image = new CAnimImage("PortraitsLarge", newHero->portrait, 0, 0, 0);
else if(!upg && owner->showEmpty) //up garrison
image = new CAnimImage("CREST58", LOCPLINT->castleInt->town->getOwner(), 0, 0, 0);
image = new CAnimImage("CREST58", LOCPLINT->castleInt->town->getOwner().getNum(), 0, 0, 0);
else
image = NULL;
}

2
client/CHeroWindow.cpp
View File

@ -98,7 +98,7 @@ CHeroWindow::CHeroWindow(const CGHeroInstance *hero):
curHero = hero;
listSelection = nullptr;
new CAnimImage("CREST58", LOCPLINT->playerID, 0, 606, 8);
new CAnimImage("CREST58", LOCPLINT->playerID.getNum(), 0, 606, 8);
//artifs = new CArtifactsOfHero(pos.topLeft(), true);
ourBar = new CGStatusBar(7, 559, "ADROLLVR.bmp", 660); // new CStatusBar(pos.x+72, pos.y+567, "ADROLLVR.bmp", 660);

4
client/CMT.cpp
View File

@ -348,8 +348,8 @@ int main(int argc, char** argv)
StartInfo *si = new StartInfo();
si->mode = StartInfo::DUEL;
si->mapname = vm["battle"].as<std::string>();
si->playerInfos[0].color = 0;
si->playerInfos[1].color = 1;
si->playerInfos[PlayerColor(0)].color = PlayerColor(0);
si->playerInfos[PlayerColor(1)].color = PlayerColor(1);
startGame(si);
}
mainGUIThread = new boost::thread(&CGuiHandler::run, boost::ref(GH));

16
client/CMessage.cpp
View File

@ -73,8 +73,8 @@ namespace
void CMessage::init()
{
{
piecesOfBox.resize(GameConstants::PLAYER_LIMIT);
for (int i=0;i<GameConstants::PLAYER_LIMIT;i++)
piecesOfBox.resize(PlayerColor::PLAYER_LIMIT_I);
for (int i=0; i<PlayerColor::PLAYER_LIMIT_I; i++)
{
CDefHandler * bluePieces = CDefHandler::giveDef("DIALGBOX.DEF");
if (i==1)
@ -87,7 +87,7 @@ void CMessage::init()
}
for (size_t j=0;j<bluePieces->ourImages.size();++j)
{
graphics->blueToPlayersAdv(bluePieces->ourImages[j].bitmap,i);
graphics->blueToPlayersAdv(bluePieces->ourImages[j].bitmap, PlayerColor(i));
piecesOfBox[i].push_back(bluePieces->ourImages[j].bitmap);
bluePieces->ourImages[j].bitmap->refcount++;
}
@ -102,7 +102,7 @@ void CMessage::init()
void CMessage::dispose()
{
for (int i=0;i<GameConstants::PLAYER_LIMIT;i++)
for (int i=0; i<PlayerColor::PLAYER_LIMIT_I; i++)
{
for (size_t j=0; j<piecesOfBox[i].size(); ++j)
{
@ -114,7 +114,7 @@ void CMessage::dispose()
delete cancel;
}
SDL_Surface * CMessage::drawDialogBox(int w, int h, TPlayerColor playerColor)
SDL_Surface * CMessage::drawDialogBox(int w, int h, PlayerColor playerColor)
{
//prepare surface
SDL_Surface * ret = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, screen->format->BitsPerPixel, screen->format->Rmask, screen->format->Gmask, screen->format->Bmask, screen->format->Amask);
@ -219,7 +219,7 @@ std::vector<std::string> CMessage::breakText( std::string text, size_t maxLineSi
return ret;
}
void CMessage::drawIWindow(CInfoWindow * ret, std::string text, TPlayerColor player)
void CMessage::drawIWindow(CInfoWindow * ret, std::string text, PlayerColor player)
{
bool blitOr = false;
if(dynamic_cast<CSelWindow*>(ret)) //it's selection window, so we'll blit "or" between components
@ -304,9 +304,9 @@ void CMessage::drawIWindow(CInfoWindow * ret, std::string text, TPlayerColor pla
ret->components[i]->moveBy(Point(ret->pos.x, ret->pos.y));
}
void CMessage::drawBorder(TPlayerColor playerColor, SDL_Surface * ret, int w, int h, int x, int y)
void CMessage::drawBorder(PlayerColor playerColor, SDL_Surface * ret, int w, int h, int x, int y)
{
std::vector<SDL_Surface *> &box = piecesOfBox[playerColor];
std::vector<SDL_Surface *> &box = piecesOfBox[playerColor.getNum()];
// Note: this code assumes that the corner dimensions are all the same.

6
client/CMessage.h
View File

@ -31,12 +31,12 @@ public:
static SDL_Surface * blitTextOnSur(std::vector<std::vector<SDL_Surface*> > * txtg, int fontHeight, int & curh, SDL_Surface * ret, int xCenterPos=-1); //xPos==-1 works as if ret->w/2
/// Draw border on exiting surface
static void drawBorder(TPlayerColor playerColor, SDL_Surface * ret, int w, int h, int x=0, int y=0);
static void drawBorder(PlayerColor playerColor, SDL_Surface * ret, int w, int h, int x=0, int y=0);
/// Draw simple dialog box (borders and background only)
static SDL_Surface * drawDialogBox(int w, int h, TPlayerColor playerColor=1);
static SDL_Surface * drawDialogBox(int w, int h, PlayerColor playerColor = PlayerColor(1));
static void drawIWindow(CInfoWindow * ret, std::string text, TPlayerColor player);
static void drawIWindow(CInfoWindow * ret, std::string text, PlayerColor player);
/// split text in lines
static std::vector<std::string> breakText(std::string text, size_t maxLineWidth, EFonts font);

12
client/CPlayerInterface.cpp
View File

@ -96,7 +96,7 @@ struct OCM_HLP_CGIN
CPlayerInterface::CPlayerInterface(int Player)
CPlayerInterface::CPlayerInterface(PlayerColor Player)
{
tlog5 << "\tHuman player interface for player " << Player << " being constructed\n";
observerInDuelMode = false;
@ -189,7 +189,7 @@ void CPlayerInterface::yourTurn()
std::string msg = CGI->generaltexth->allTexts[13];
boost::replace_first(msg, "%s", cb->getStartInfo()->playerInfos.find(playerID)->second.name);
std::vector<CComponent*> cmp;
cmp.push_back(new CComponent(CComponent::flag, playerID, 0));
cmp.push_back(new CComponent(CComponent::flag, playerID.getNum(), 0));
showInfoDialog(msg, cmp);
}
else
@ -2045,7 +2045,7 @@ void CPlayerInterface::finishMovement( const TryMoveHero &details, const int3 &h
std::stable_sort(CGI->mh->ttiles[details.end.x][details.end.y][details.end.z].objects.begin(), CGI->mh->ttiles[details.end.x][details.end.y][details.end.z].objects.end(), ocmptwo_cgin);
}
void CPlayerInterface::gameOver(ui8 player, bool victory )
void CPlayerInterface::gameOver(PlayerColor player, bool victory )
{
EVENT_HANDLER_CALLED_BY_CLIENT;
if(LOCPLINT != this)
@ -2076,8 +2076,8 @@ void CPlayerInterface::gameOver(ui8 player, bool victory )
if(!victory && cb->getPlayerStatus(playerID) == EPlayerStatus::INGAME) //enemy has lost
{
std::string txt = CGI->generaltexth->allTexts[5]; //%s has been vanquished!
boost::algorithm::replace_first(txt, "%s", CGI->generaltexth->capColors[player]);
showInfoDialog(txt,std::vector<CComponent*>(1, new CComponent(CComponent::flag, player, 0)));
boost::algorithm::replace_first(txt, "%s", CGI->generaltexth->capColors[player.getNum()]);
showInfoDialog(txt,std::vector<CComponent*>(1, new CComponent(CComponent::flag, player.getNum(), 0)));
}
}
}
@ -2432,7 +2432,7 @@ void CPlayerInterface::artifactDisassembled(const ArtifactLocation &al)
}
}
void CPlayerInterface::playerStartsTurn(ui8 player)
void CPlayerInterface::playerStartsTurn(PlayerColor player)
{
EVENT_HANDLER_CALLED_BY_CLIENT;

6
client/CPlayerInterface.h
View File

@ -179,8 +179,8 @@ public:
void centerView (int3 pos, int focusTime) OVERRIDE;
void objectPropertyChanged(const SetObjectProperty * sop) OVERRIDE;
void objectRemoved(const CGObjectInstance *obj) OVERRIDE;
void gameOver(ui8 player, bool victory) OVERRIDE;
void playerStartsTurn(ui8 player) OVERRIDE; //called before yourTurn on active itnerface
void gameOver(PlayerColor player, bool victory) OVERRIDE;
void playerStartsTurn(PlayerColor player) OVERRIDE; //called before yourTurn on active itnerface
void showComp(const Component &comp, std::string message) OVERRIDE; //display component in the advmapint infobox
void serialize(COSer<CSaveFile> &h, const int version) OVERRIDE; //saving
void serialize(CISer<CLoadFile> &h, const int version) OVERRIDE; //loading
@ -242,7 +242,7 @@ public:
void sendCustomEvent(int code);
void proposeLoadingGame();
CPlayerInterface(int Player);//c-tor
CPlayerInterface(PlayerColor Player);//c-tor
~CPlayerInterface();//d-tor
static CondSh<bool> terminate_cond; // confirm termination

118
client/CPreGame.cpp
View File

@ -66,7 +66,7 @@ void startGame(StartInfo * options, CConnection *serv = NULL);
CGPreGame * CGP = nullptr;
ISelectionScreenInfo *SEL;
static int playerColor; //if more than one player - applies to the first
static PlayerColor playerColor; //if more than one player - applies to the first
/**
* Stores the current name of the savegame.
@ -129,7 +129,7 @@ static void swapPlayers(PlayerSettings &a, PlayerSettings &b)
playerColor = b.color;
}
void setPlayer(PlayerSettings &pset, TPlayerColor player, const std::map<TPlayerColor, std::string> &playerNames)
void setPlayer(PlayerSettings &pset, ui8 player, const std::map<ui8, std::string> &playerNames)
{
if(vstd::contains(playerNames, player))
pset.name = playerNames.find(player)->second;
@ -141,7 +141,7 @@ void setPlayer(PlayerSettings &pset, TPlayerColor player, const std::map<TPlayer
playerColor = pset.color;
}
void updateStartInfo(std::string filename, StartInfo & sInfo, const CMapHeader * mapHeader, const std::map<TPlayerColor, std::string> &playerNames)
void updateStartInfo(std::string filename, StartInfo & sInfo, const CMapHeader * mapHeader, const std::map<ui8, std::string> &playerNames)
{
sInfo.playerInfos.clear();
if(!mapHeader)
@ -150,7 +150,7 @@ void updateStartInfo(std::string filename, StartInfo & sInfo, const CMapHeader *
}
sInfo.mapname = filename;
playerColor = -1;
playerColor = PlayerColor::NEUTRAL;
auto namesIt = playerNames.cbegin();
@ -162,8 +162,8 @@ void updateStartInfo(std::string filename, StartInfo & sInfo, const CMapHeader *
if (!(pinfo.canHumanPlay || pinfo.canComputerPlay))
continue;
PlayerSettings &pset = sInfo.playerInfos[i];
pset.color = i;
PlayerSettings &pset = sInfo.playerInfos[PlayerColor(i)];
pset.color = PlayerColor(i);
if(pinfo.canHumanPlay && namesIt != playerNames.cend())
{
setPlayer(pset, namesIt++->first, playerNames);
@ -270,7 +270,7 @@ void CMenuScreen::showAll(SDL_Surface * to)
CIntObject::showAll(to);
if (pos.h != to->h || pos.w != to->w)
CMessage::drawBorder(1, to, pos.w+28, pos.h+30, pos.x-14, pos.y-15);
CMessage::drawBorder(PlayerColor(1), to, pos.w+28, pos.h+30, pos.x-14, pos.y-15);
}
@ -354,7 +354,7 @@ static boost::function<void()> genCommand(CMenuScreen* menu, std::vector<std::st
}
break; case 4://exit
{
return boost::bind(CInfoWindow::showYesNoDialog, boost::ref(CGI->generaltexth->allTexts[69]), (const std::vector<CComponent*>*)0, do_quit, 0, false, 1);
return boost::bind(CInfoWindow::showYesNoDialog, boost::ref(CGI->generaltexth->allTexts[69]), (const std::vector<CComponent*>*)0, do_quit, 0, false, PlayerColor(1));
}
break; case 5://highscores
{
@ -562,7 +562,7 @@ void CGPreGame::removeFromGui()
GH.popInt(GH.topInt()); //remove background
}
CSelectionScreen::CSelectionScreen(CMenuScreen::EState Type, CMenuScreen::EMultiMode MultiPlayer /*= CMenuScreen::SINGLE_PLAYER*/, const std::map<TPlayerColor, std::string> *Names /*= NULL*/)
CSelectionScreen::CSelectionScreen(CMenuScreen::EState Type, CMenuScreen::EMultiMode MultiPlayer /*= CMenuScreen::SINGLE_PLAYER*/, const std::map<ui8, std::string> *Names /*= NULL*/)
: ISelectionScreenInfo(Names), serverHandlingThread(NULL), mx(new boost::recursive_mutex),
serv(NULL), ongoingClosing(false), myNameID(255)
{
@ -756,7 +756,7 @@ CSelectionScreen::~CSelectionScreen()
serverHandlingThread->join();
delete serverHandlingThread;
}
playerColor = -1;
playerColor = PlayerColor::CANNOT_DETERMINE;
playerNames.clear();
assert(!serv);
@ -858,7 +858,7 @@ void CSelectionScreen::startScenario()
if(screenType == CMenuScreen::newGame)
{
//there must be at least one human player before game can be started
std::map<TPlayerColor, PlayerSettings>::const_iterator i;
std::map<PlayerColor, PlayerSettings>::const_iterator i;
for(i = SEL->sInfo.playerInfos.cbegin(); i != SEL->sInfo.playerInfos.cend(); i++)
if(i->second.playerID != PlayerSettings::PLAYER_AI)
break;
@ -960,7 +960,7 @@ void CSelectionScreen::handleConnection()
void CSelectionScreen::setSInfo(const StartInfo &si)
{
std::map<TPlayerColor, PlayerSettings>::const_iterator i;
std::map<PlayerColor, PlayerSettings>::const_iterator i;
for(i = si.playerInfos.cbegin(); i != si.playerInfos.cend(); i++)
{
if(i->second.playerID == myNameID)
@ -971,7 +971,7 @@ void CSelectionScreen::setSInfo(const StartInfo &si)
}
if(i == si.playerInfos.cend()) //not found
playerColor = -1;
playerColor = PlayerColor::CANNOT_DETERMINE;
sInfo = si;
if(current)
@ -1039,7 +1039,7 @@ void CSelectionScreen::showAll(SDL_Surface *to)
{
CIntObject::showAll(to);
if (bordered && (pos.h != to->h || pos.w != to->w))
CMessage::drawBorder(1, to, pos.w+28, pos.h+30, pos.x-14, pos.y-15);
CMessage::drawBorder(PlayerColor(1), to, pos.w+28, pos.h+30, pos.x-14, pos.y-15);
}
// A new size filter (Small, Medium, ...) has been selected. Populate
@ -1853,7 +1853,7 @@ void RandomMapTab::updateMapInfo()
{
player.canHumanPlay = true;
}
player.team = i;
player.team = TeamID(i);
player.hasMainTown = true;
player.generateHeroAtMainTown = true;
mapInfo.mapHeader->players.push_back(player);
@ -1995,7 +1995,7 @@ void InfoCard::showAll(SDL_Surface * to)
}
else //players list
{
std::map<TPlayerColor, std::string> playerNames = SEL->playerNames;
std::map<ui8, std::string> playerNames = SEL->playerNames;
int playerSoFar = 0;
for (auto i = SEL->sInfo.playerInfos.cbegin(); i != SEL->sInfo.playerInfos.cend(); i++)
{
@ -2079,18 +2079,18 @@ void InfoCard::showAll(SDL_Surface * to)
int fx = 34 + graphics->fonts[FONT_SMALL]->getStringWidth(CGI->generaltexth->allTexts[390]);
int ex = 200 + graphics->fonts[FONT_SMALL]->getStringWidth(CGI->generaltexth->allTexts[391]);
int myT;
TeamID myT;
if(playerColor >= 0)
myT = SEL->current->mapHeader->players[playerColor].team;
if(playerColor < PlayerColor::PLAYER_LIMIT)
myT = SEL->current->mapHeader->players[playerColor.getNum()].team;
else
myT = -1;
myT = TeamID::NO_TEAM;
for (auto i = SEL->sInfo.playerInfos.cbegin(); i != SEL->sInfo.playerInfos.cend(); i++)
{
int *myx = ((i->first == playerColor || SEL->current->mapHeader->players[i->first].team == myT) ? &fx : &ex);
blitAtLoc(sFlags->ourImages[i->first].bitmap, *myx, 399, to);
*myx += sFlags->ourImages[i->first].bitmap->w;
int *myx = ((i->first == playerColor || SEL->current->mapHeader->players[i->first.getNum()].team == myT) ? &fx : &ex);
blitAtLoc(sFlags->ourImages[i->first.getNum()].bitmap, *myx, 399, to);
*myx += sFlags->ourImages[i->first.getNum()].bitmap->w;
}
std::string tob;
@ -2173,9 +2173,9 @@ void InfoCard::showTeamsPopup()
graphics->fonts[FONT_SMALL]->renderTextCenter(bmp, hlp, Colors::WHITE, Point(128, 65 + 50 * i));
for(int j = 0; j < GameConstants::PLAYER_LIMIT; j++)
for(int j = 0; j < PlayerColor::PLAYER_LIMIT_I; j++)
if((SEL->current->mapHeader->players[j].canHumanPlay || SEL->current->mapHeader->players[j].canComputerPlay)
&& SEL->current->mapHeader->players[j].team == i)
&& SEL->current->mapHeader->players[j].team == TeamID(i))
flags.push_back(j);
int curx = 128 - 9*flags.size();
@ -2248,7 +2248,7 @@ void OptionsTab::showAll(SDL_Surface * to)
printAtMiddleLoc(CGI->generaltexth->turnDurations[turnDuration->value], 319,559, FONT_SMALL, Colors::WHITE, to);//Turn duration value
}
void OptionsTab::nextCastle( int player, int dir )
void OptionsTab::nextCastle( PlayerColor player, int dir )
{
if(SEL->isGuest())
{
@ -2258,7 +2258,7 @@ void OptionsTab::nextCastle( int player, int dir )
PlayerSettings &s = SEL->sInfo.playerInfos[player];
si16 &cur = s.castle;
auto & allowed = SEL->current->mapHeader->players[s.color].allowedFactions;
auto & allowed = SEL->current->mapHeader->players[s.color.getNum()].allowedFactions;
if (cur == PlayerSettings::NONE) //no change
return;
@ -2285,7 +2285,7 @@ void OptionsTab::nextCastle( int player, int dir )
}
}
if(s.hero >= 0 && SEL->current->mapHeader->players[s.color].customHeroID < 0) // remove hero unless it set to fixed one in map editor
if(s.hero >= 0 && SEL->current->mapHeader->players[s.color.getNum()].customHeroID < 0) // remove hero unless it set to fixed one in map editor
s.hero = PlayerSettings::RANDOM;
if(cur < 0 && s.bonus == PlayerSettings::RESOURCE)
s.bonus = PlayerSettings::RANDOM;
@ -2297,7 +2297,7 @@ void OptionsTab::nextCastle( int player, int dir )
redraw();
}
void OptionsTab::nextHero( int player, int dir )
void OptionsTab::nextHero( PlayerColor player, int dir )
{
if(SEL->isGuest())
{
@ -2334,7 +2334,7 @@ void OptionsTab::nextHero( int player, int dir )
SEL->propagateOptions();
}
int OptionsTab::nextAllowedHero( int player, int min, int max, int incl, int dir )
int OptionsTab::nextAllowedHero( PlayerColor player, int min, int max, int incl, int dir )
{
if(dir>0)
{
@ -2351,7 +2351,7 @@ int OptionsTab::nextAllowedHero( int player, int min, int max, int incl, int dir
return -1;
}
bool OptionsTab::canUseThisHero( int player, int ID )
bool OptionsTab::canUseThisHero( PlayerColor player, int ID )
{
return CGI->heroh->heroes.size() > ID
&& SEL->sInfo.playerInfos[player].castle == CGI->heroh->heroes[ID]->heroClass->faction
@ -2359,7 +2359,7 @@ bool OptionsTab::canUseThisHero( int player, int ID )
&& SEL->current->mapHeader->allowedHeroes[ID];
}
void OptionsTab::nextBonus( int player, int dir )
void OptionsTab::nextBonus( PlayerColor player, int dir )
{
if(SEL->isGuest())
{
@ -2371,7 +2371,7 @@ void OptionsTab::nextBonus( int player, int dir )
PlayerSettings::Ebonus &ret = s.bonus = static_cast<PlayerSettings::Ebonus>(static_cast<int>(s.bonus) + dir);
if (s.hero==PlayerSettings::NONE &&
!SEL->current->mapHeader->players[s.color].heroesNames.size() &&
!SEL->current->mapHeader->players[s.color.getNum()].heroesNames.size() &&
ret==PlayerSettings::ARTIFACT) //no hero - can't be artifact
{
if (dir<0)
@ -2398,7 +2398,7 @@ void OptionsTab::nextBonus( int player, int dir )
void OptionsTab::recreate()
{
for(std::map<int, PlayerOptionsEntry*>::iterator it = entries.begin(); it != entries.end(); ++it)
for(auto it = entries.begin(); it != entries.end(); ++it)
{
delete it->second;
}
@ -2409,7 +2409,7 @@ void OptionsTab::recreate()
for(auto it = SEL->sInfo.playerInfos.begin(); it != SEL->sInfo.playerInfos.end(); ++it)
{
entries.insert(std::make_pair(it->first, new PlayerOptionsEntry(this, it->second)));
const std::vector<SHeroName> &heroes = SEL->current->mapHeader->players[it->first].heroesNames;
const std::vector<SHeroName> &heroes = SEL->current->mapHeader->players[it->first.getNum()].heroesNames;
for(size_t hi=0; hi<heroes.size(); hi++)
usedHeroes.insert(heroes[hi].heroId);
}
@ -2425,7 +2425,7 @@ void OptionsTab::setTurnLength( int npos )
redraw();
}
void OptionsTab::flagPressed( int color )
void OptionsTab::flagPressed( PlayerColor color )
{
PlayerSettings &clicked = SEL->sInfo.playerInfos[color];
PlayerSettings *old = NULL;
@ -2506,13 +2506,13 @@ void OptionsTab::flagPressed( int color )
}
OptionsTab::PlayerOptionsEntry::PlayerOptionsEntry( OptionsTab *owner, PlayerSettings &S)
: pi(SEL->current->mapHeader->players[S.color]), s(S)
: pi(SEL->current->mapHeader->players[S.color.getNum()]), s(S)
{
OBJ_CONSTRUCTION;
defActions |= SHARE_POS;
int serial = 0;
for(int g=0; g < s.color; ++g)
for(int g=0; g < s.color.getNum(); ++g)
{
PlayerInfo &itred = SEL->current->mapHeader->players[g];
if( itred.canComputerPlay || itred.canHumanPlay)
@ -2527,7 +2527,7 @@ OptionsTab::PlayerOptionsEntry::PlayerOptionsEntry( OptionsTab *owner, PlayerSet
static const char *bgs[] = {"ADOPRPNL.bmp", "ADOPBPNL.bmp", "ADOPYPNL.bmp", "ADOPGPNL.bmp",
"ADOPOPNL.bmp", "ADOPPPNL.bmp", "ADOPTPNL.bmp", "ADOPSPNL.bmp"};
bg = new CPicture(BitmapHandler::loadBitmap(bgs[s.color]), 0, 0, true);
bg = new CPicture(BitmapHandler::loadBitmap(bgs[s.color.getNum()]), 0, 0, true);
if(SEL->screenType == CMenuScreen::newGame)
{
btns[0] = new CAdventureMapButton(CGI->generaltexth->zelp[132], bind(&OptionsTab::nextCastle, owner, s.color, -1), 107, 5, "ADOPLFA.DEF");
@ -2544,7 +2544,7 @@ OptionsTab::PlayerOptionsEntry::PlayerOptionsEntry( OptionsTab *owner, PlayerSet
selectButtons();
assert(SEL->current && SEL->current->mapHeader);
const PlayerInfo &p = SEL->current->mapHeader->players[s.color];
const PlayerInfo &p = SEL->current->mapHeader->players[s.color.getNum()];
assert(p.canComputerPlay || p.canHumanPlay); //someone must be able to control this player
if(p.canHumanPlay && p.canComputerPlay)
whoCanPlay = HUMAN_OR_CPU;
@ -2554,10 +2554,10 @@ OptionsTab::PlayerOptionsEntry::PlayerOptionsEntry( OptionsTab *owner, PlayerSet
whoCanPlay = HUMAN;
if(SEL->screenType != CMenuScreen::scenarioInfo
&& SEL->current->mapHeader->players[s.color].canHumanPlay
&& SEL->current->mapHeader->players[s.color.getNum()].canHumanPlay
&& SEL->multiPlayer != CMenuScreen::MULTI_NETWORK_GUEST)
{
flag = new CAdventureMapButton(CGI->generaltexth->zelp[180], bind(&OptionsTab::flagPressed, owner, s.color), -43, 2, flags[s.color]);
flag = new CAdventureMapButton(CGI->generaltexth->zelp[180], bind(&OptionsTab::flagPressed, owner, s.color), -43, 2, flags[s.color.getNum()]);
flag->hoverable = true;
}
else
@ -2924,7 +2924,7 @@ void OptionsTab::SelectedBox::clickRight( tribool down, bool previousState )
// cases when we do not need to display a message
if (settings.castle == -2 && CPlayerSettingsHelper::type == TOWN )
return;
if (settings.hero == -2 && SEL->current->mapHeader->players[settings.color].customHeroID == -1 && CPlayerSettingsHelper::type == HERO)
if (settings.hero == -2 && SEL->current->mapHeader->players[settings.color.getNum()].customHeroID == -1 && CPlayerSettingsHelper::type == HERO)
return;
GH.pushInt(new CPregameTooltipBox(*this));
@ -3103,7 +3103,7 @@ void CHotSeatPlayers::onChange(std::string newText)
void CHotSeatPlayers::enterSelectionScreen()
{
std::map<TPlayerColor, std::string> names;
std::map<ui8, std::string> names;
for(int i = 0, j = 1; i < ARRAY_COUNT(txt); i++)
if(txt[i]->text.length())
names[j++] = txt[i]->text;
@ -3265,7 +3265,7 @@ void CBonusSelection::showAll(SDL_Surface * to)
show(to);
if (pos.h != to->h || pos.w != to->w)
CMessage::drawBorder(1, to, pos.w+28, pos.h+30, pos.x-14, pos.y-15);
CMessage::drawBorder(PlayerColor(1), to, pos.w+28, pos.h+30, pos.x-14, pos.y-15);
}
void CBonusSelection::loadPositionsOfGraphics()
@ -3314,7 +3314,7 @@ void CBonusSelection::selectMap( int whichOne, bool initialSelect )
auto buffer = reinterpret_cast<const ui8 *>(headerStr.data());
ourHeader = CMapService::loadMapHeader(buffer, headerStr.size()).release();
std::map<TPlayerColor, std::string> names;
std::map<ui8, std::string> names;
names[1] = settings["general"]["playerName"].String();
updateStartInfo(ourCampaign->camp->header.filename, sInfo, ourHeader, names);
sInfo.turnTime = 0;
@ -3368,13 +3368,13 @@ void CBonusSelection::show(SDL_Surface * to)
//flags
int fx = 496 + graphics->fonts[FONT_SMALL]->getStringWidth(CGI->generaltexth->allTexts[390]);
int ex = 629 + graphics->fonts[FONT_SMALL]->getStringWidth(CGI->generaltexth->allTexts[391]);
int myT;
myT = ourHeader->players[playerColor].team;
TeamID myT;
myT = ourHeader->players[playerColor.getNum()].team;
for (auto i = sInfo.playerInfos.cbegin(); i != sInfo.playerInfos.cend(); i++)
{
int *myx = ((i->first == playerColor || ourHeader->players[i->first].team == myT) ? &fx : &ex);
blitAtLoc(sFlags->ourImages[i->first].bitmap, pos.x + *myx, pos.y + 405, to);
*myx += sFlags->ourImages[i->first].bitmap->w;
int *myx = ((i->first == playerColor || ourHeader->players[i->first.getNum()].team == myT) ? &fx : &ex);
blitAtLoc(sFlags->ourImages[i->first.getNum()].bitmap, pos.x + *myx, pos.y + 405, to);
*myx += sFlags->ourImages[i->first.getNum()].bitmap->w;
}
//difficulty
@ -3534,7 +3534,7 @@ void CBonusSelection::updateBonusSelection()
break;
case CScenarioTravel::STravelBonus::PLAYER_PREV_SCENARIO:
{
auto superhero = ourCampaign->camp->scenarios[bonDescs[i].info2].strongestHero(bonDescs[i].info1);
auto superhero = ourCampaign->camp->scenarios[bonDescs[i].info2].strongestHero(PlayerColor(bonDescs[i].info1));
if (!superhero) tlog5 << "No superhero! How could it be transfered?\n";
picNumber = superhero ? superhero->portrait : 0;
desc = CGI->generaltexth->allTexts[719];
@ -3623,11 +3623,11 @@ void CBonusSelection::selectBonus( int id )
const std::vector<CScenarioTravel::STravelBonus> & bonDescs = scenario.travelOptions.bonusesToChoose;
if (bonDescs[id].type == CScenarioTravel::STravelBonus::HERO)
{
std::map<TPlayerColor, std::string> names;
std::map<ui8, std::string> names;
names[1] = settings["general"]["playerName"].String();
for(auto it = sInfo.playerInfos.begin(); it != sInfo.playerInfos.end(); ++it)
{
if(it->first == bonDescs[id].info1)
if(it->first == PlayerColor(bonDescs[id].info1))
::setPlayer(it->second, 1, names);
else
::setPlayer(it->second, 0, names);
@ -3751,7 +3751,7 @@ CSavingScreen::~CSavingScreen()
}
ISelectionScreenInfo::ISelectionScreenInfo(const std::map<TPlayerColor, std::string> *Names /*= NULL*/)
ISelectionScreenInfo::ISelectionScreenInfo(const std::map<ui8, std::string> *Names /*= NULL*/)
{
multiPlayer = CMenuScreen::SINGLE_PLAYER;
assert(!SEL);
@ -3775,12 +3775,12 @@ void ISelectionScreenInfo::updateStartInfo(std::string filename, StartInfo & sIn
::updateStartInfo(filename, sInfo, mapHeader, playerNames);
}
void ISelectionScreenInfo::setPlayer(PlayerSettings &pset, TPlayerColor player)
void ISelectionScreenInfo::setPlayer(PlayerSettings &pset, ui8 player)
{
::setPlayer(pset, player, playerNames);
}
int ISelectionScreenInfo::getIdOfFirstUnallocatedPlayer()
ui8 ISelectionScreenInfo::getIdOfFirstUnallocatedPlayer()
{
for(auto i = playerNames.cbegin(); i != playerNames.cend(); i++)
if(!sInfo.getPlayersSettings(i->first)) //
@ -3882,7 +3882,7 @@ void RequestOptionsChange::apply(CSelectionScreen *selScreen)
if(!selScreen->isHost())
return;
ui8 color = selScreen->sInfo.getPlayersSettings(playerID)->color;
PlayerColor color = selScreen->sInfo.getPlayersSettings(playerID)->color;
switch(what)
{
@ -4051,7 +4051,7 @@ void CCampaignScreen::showAll(SDL_Surface *to)
{
CIntObject::showAll(to);
if (pos.h != to->h || pos.w != to->w)
CMessage::drawBorder(1, to, pos.w+28, pos.h+30, pos.x-14, pos.y-15);
CMessage::drawBorder(PlayerColor(1), to, pos.w+28, pos.h+30, pos.x-14, pos.y-15);
}
void CGPreGame::showLoadingScreen(boost::function<void()> loader)

29
client/CPreGame.h
View File

@ -257,28 +257,29 @@ public:
struct PlayerToRestore
{
int color, id;
void reset() { color = id = -1; }
PlayerColor color;
int id;
void reset() { id = -1; color = PlayerColor::CANNOT_DETERMINE; }
PlayerToRestore(){ reset(); }
} playerToRestore;
std::map<int, PlayerOptionsEntry *> entries; //indexed by color
std::map<PlayerColor, PlayerOptionsEntry *> entries; //indexed by color
void nextCastle(int player, int dir); //dir == -1 or +1
void nextHero(int player, int dir); //dir == -1 or +1
void nextBonus(int player, int dir); //dir == -1 or +1
void nextCastle(PlayerColor player, int dir); //dir == -1 or +1
void nextHero(PlayerColor player, int dir); //dir == -1 or +1
void nextBonus(PlayerColor player, int dir); //dir == -1 or +1
void setTurnLength(int npos);
void flagPressed(int player);
void flagPressed(PlayerColor player);
void recreate();
OptionsTab();
~OptionsTab();
void showAll(SDL_Surface * to);
int nextAllowedHero(int player, int min, int max, int incl, int dir );
int nextAllowedHero(PlayerColor player, int min, int max, int incl, int dir );
bool canUseThisHero(int player, int ID );
bool canUseThisHero(PlayerColor player, int ID );
};
/**
@ -425,19 +426,19 @@ public:
CMenuScreen::EState screenType; //new/save/load#Game
const CMapInfo *current;
StartInfo sInfo;
std::map<TPlayerColor, std::string> playerNames; // id of player <-> player name; 0 is reserved as ID of AI "players"
std::map<ui8, std::string> playerNames; // id of player <-> player name; 0 is reserved as ID of AI "players"
ISelectionScreenInfo(const std::map<TPlayerColor, std::string> *Names = NULL);
ISelectionScreenInfo(const std::map<ui8, std::string> *Names = NULL);
virtual ~ISelectionScreenInfo();
virtual void update(){};
virtual void propagateOptions() {};
virtual void postRequest(ui8 what, ui8 dir) {};
virtual void postChatMessage(const std::string &txt){};
void setPlayer(PlayerSettings &pset, TPlayerColor player);
void setPlayer(PlayerSettings &pset, ui8 player);
void updateStartInfo( std::string filename, StartInfo & sInfo, const CMapHeader * mapHeader );
int getIdOfFirstUnallocatedPlayer(); //returns 0 if none
ui8 getIdOfFirstUnallocatedPlayer(); //returns 0 if none
bool isGuest() const;
bool isHost() const;
@ -465,7 +466,7 @@ public:
bool ongoingClosing;
ui8 myNameID; //used when networking - otherwise all player are "mine"
CSelectionScreen(CMenuScreen::EState Type, CMenuScreen::EMultiMode MultiPlayer = CMenuScreen::SINGLE_PLAYER, const std::map<TPlayerColor, std::string> *Names = NULL);
CSelectionScreen(CMenuScreen::EState Type, CMenuScreen::EMultiMode MultiPlayer = CMenuScreen::SINGLE_PLAYER, const std::map<ui8, std::string> *Names = NULL);
~CSelectionScreen();
void toggleTab(CIntObject *tab);
void changeSelection(const CMapInfo *to);

64
client/Client.cpp
View File

@ -112,7 +112,7 @@ CClient::~CClient(void)
delete applier;
}
void CClient::waitForMoveAndSend(TPlayerColor color)
void CClient::waitForMoveAndSend(PlayerColor color)
{
try
{
@ -175,7 +175,7 @@ void CClient::save(const std::string & fname)
}
SaveGame save_game(fname);
sendRequest((CPackForClient*)&save_game, 255);
sendRequest((CPackForClient*)&save_game, PlayerColor::NEUTRAL);
}
void CClient::endGame( bool closeConnection /*= true*/ )
@ -270,9 +270,9 @@ void CClient::loadGame( const std::string & fname )
for(auto it = gs->scenarioOps->playerInfos.begin();
it != gs->scenarioOps->playerInfos.end(); ++it)
{
*serv << ui8(it->first); //players
*serv << ui8(it->first.getNum()); //players
}
*serv << ui8(GameConstants::NEUTRAL_PLAYER);
*serv << ui8(PlayerColor::NEUTRAL.getNum());
tlog0 <<"Sent info to server: "<<tmh.getDiff()<<std::endl;
serv->enableStackSendingByID();
@ -326,7 +326,7 @@ void CClient::newGame( CConnection *con, StartInfo *si )
// Now after possible random map gen, we know exact player count.
// Inform server about how many players client handles
std::set<TPlayerColor> myPlayers;
std::set<PlayerColor> myPlayers;
for(auto it = gs->scenarioOps->playerInfos.begin(); it != gs->scenarioOps->playerInfos.end(); ++it)
{
if((networkMode == SINGLE) //single - one client has all player
@ -337,7 +337,7 @@ void CClient::newGame( CConnection *con, StartInfo *si )
}
}
if(networkMode != GUEST)
myPlayers.insert(GameConstants::NEUTRAL_PLAYER);
myPlayers.insert(PlayerColor::NEUTRAL);
c << myPlayers;
// Init map handler
@ -352,16 +352,16 @@ void CClient::newGame( CConnection *con, StartInfo *si )
}
int humanPlayers = 0;
int sensibleAILimit = settings["session"]["oneGoodAI"].Bool() ? 1 : GameConstants::PLAYER_LIMIT;
int sensibleAILimit = settings["session"]["oneGoodAI"].Bool() ? 1 : PlayerColor::PLAYER_LIMIT_I;
for(auto it = gs->scenarioOps->playerInfos.begin();
it != gs->scenarioOps->playerInfos.end(); ++it)//initializing interfaces for players
{
TPlayerColor color = it->first;
PlayerColor color = it->first;
gs->currentPlayer = color;
if(!vstd::contains(myPlayers, color))
continue;
tlog5 << "Preparing interface for player " << (int)color << std::endl;
tlog5 << "Preparing interface for player " << color << std::endl;
if(si->mode != StartInfo::DUEL)
{
auto cb = make_shared<CCallback>(gs,color,this);
@ -373,7 +373,7 @@ void CClient::newGame( CConnection *con, StartInfo *si )
else
sensibleAILimit--;
playerint[color] = static_cast<CGameInterface*>(CDynLibHandler::getNewAI(AItoGive));
tlog1 << "Player " << (int)color << " will be lead by " << AItoGive << std::endl;
tlog1 << "Player " << color << " will be lead by " << AItoGive << std::endl;
}
else
{
@ -390,7 +390,7 @@ void CClient::newGame( CConnection *con, StartInfo *si )
{
auto cbc = make_shared<CBattleCallback>(gs, color, this);
battleCallbacks[color] = cbc;
if(!color)
if(color == PlayerColor(0))
battleints[color] = CDynLibHandler::getNewBattleAI(settings["server"]["neutralAI"].String());
else
battleints[color] = CDynLibHandler::getNewBattleAI("StupidAI");
@ -401,13 +401,13 @@ void CClient::newGame( CConnection *con, StartInfo *si )
if(si->mode == StartInfo::DUEL)
{
boost::unique_lock<boost::recursive_mutex> un(*LOCPLINT->pim);
CPlayerInterface *p = new CPlayerInterface(-1);
CPlayerInterface *p = new CPlayerInterface(PlayerColor::NEUTRAL); //TODO: check if neutral really works -- was -1, but CPlayerInterface seems to cooperate with this value not too well
p->observerInDuelMode = true;
battleints[254] = playerint[254] = p;
battleints[PlayerColor::UNFLAGGABLE] = playerint[PlayerColor::UNFLAGGABLE] = p;
privilagedBattleEventReceivers.push_back(p);
GH.curInt = p;
auto cb = make_shared<CCallback>(gs, -1, this);
battleCallbacks[-1] = callbacks[-1] = cb;
auto cb = make_shared<CCallback>(gs, boost::optional<PlayerColor>(), this);
battleCallbacks[PlayerColor::NEUTRAL] = callbacks[PlayerColor::NEUTRAL] = cb;
p->init(cb.get());
battleStarted(gs->curB);
}
@ -443,7 +443,7 @@ void CClient::serialize( Handler &h, const int version )
ui8 players = playerint.size();
h & players;
for(std::map<ui8,CGameInterface *>::iterator i = playerint.begin(); i != playerint.end(); i++)
for(auto i = playerint.begin(); i != playerint.end(); i++)
{
h & i->first & i->second->dllName;
i->second->serialize(h,version);
@ -457,14 +457,14 @@ void CClient::serialize( Handler &h, const int version )
for(int i=0; i < players; i++)
{
std::string dllname;
ui8 pid = 0; //fix for uninitialized warning
PlayerColor pid = PlayerColor(0); //fix for uninitialized warning
h & pid & dllname;
CGameInterface *nInt = NULL;
if(dllname.length())
{
if(pid == GameConstants::NEUTRAL_PLAYER)
if(pid == PlayerColor::NEUTRAL)
{
//CBattleCallback * cbc = new CBattleCallback(gs, pid, this);//FIXME: unused?
CBattleGameInterface *cbgi = CDynLibHandler::getNewBattleAI(dllname);
@ -485,7 +485,7 @@ void CClient::serialize( Handler &h, const int version )
nInt->serialize(h, version);
}
if(!vstd::contains(battleints, GameConstants::NEUTRAL_PLAYER))
if(!vstd::contains(battleints, PlayerColor::NEUTRAL))
loadNeutralBattleAI();
}
}
@ -536,7 +536,7 @@ void CClient::stopConnection()
tlog0 << "Connection has been requested to be closed.\n";
boost::unique_lock<boost::mutex>(*serv->wmx);
CloseServer close_server;
sendRequest(&close_server, 255);
sendRequest(&close_server, PlayerColor::NEUTRAL);
tlog0 << "Sent closing signal to the server\n";
}
@ -564,7 +564,7 @@ void CClient::battleStarted(const BattleInfo * info)
{
BOOST_FOREACH(auto &battleCb, battleCallbacks)
{
if(vstd::contains(info->sides, battleCb.first) || battleCb.first >= GameConstants::PLAYER_LIMIT)
if(vstd::contains(info->sides, battleCb.first) || battleCb.first >= PlayerColor::PLAYER_LIMIT)
battleCb.second->setBattle(info);
}
// BOOST_FOREACH(ui8 side, info->sides)
@ -594,8 +594,8 @@ void CClient::battleStarted(const BattleInfo * info)
battleints[info->sides[0]]->battleStart(info->belligerents[0], info->belligerents[1], info->tile, info->heroes[0], info->heroes[1], 0);
if(vstd::contains(battleints,info->sides[1]))
battleints[info->sides[1]]->battleStart(info->belligerents[0], info->belligerents[1], info->tile, info->heroes[0], info->heroes[1], 1);
if(vstd::contains(battleints,254))
battleints[254]->battleStart(info->belligerents[0], info->belligerents[1], info->tile, info->heroes[0], info->heroes[1], 1);
if(vstd::contains(battleints,PlayerColor::UNFLAGGABLE))
battleints[PlayerColor::UNFLAGGABLE]->battleStart(info->belligerents[0], info->belligerents[1], info->tile, info->heroes[0], info->heroes[1], 1);
if(info->tacticDistance && vstd::contains(battleints,info->sides[info->tacticsSide]))
{
@ -605,17 +605,17 @@ void CClient::battleStarted(const BattleInfo * info)
void CClient::battleFinished()
{
BOOST_FOREACH(ui8 side, gs->curB->sides)
BOOST_FOREACH(PlayerColor side, gs->curB->sides)
if(battleCallbacks.count(side))
battleCallbacks[side]->setBattle(nullptr);
}
void CClient::loadNeutralBattleAI()
{
battleints[GameConstants::NEUTRAL_PLAYER] = CDynLibHandler::getNewBattleAI(settings["server"]["neutralAI"].String());
auto cbc = make_shared<CBattleCallback>(gs, GameConstants::NEUTRAL_PLAYER, this);
battleCallbacks[GameConstants::NEUTRAL_PLAYER] = cbc;
battleints[GameConstants::NEUTRAL_PLAYER]->init(cbc.get());
battleints[PlayerColor::NEUTRAL] = CDynLibHandler::getNewBattleAI(settings["server"]["neutralAI"].String());
auto cbc = make_shared<CBattleCallback>(gs, PlayerColor::NEUTRAL, this);
battleCallbacks[PlayerColor::NEUTRAL] = cbc;
battleints[PlayerColor::NEUTRAL]->init(cbc.get());
}
void CClient::commitPackage( CPackForClient *pack )
@ -623,10 +623,10 @@ void CClient::commitPackage( CPackForClient *pack )
CommitPackage cp;
cp.freePack = false;
cp.packToCommit = pack;
sendRequest(&cp, 255);
sendRequest(&cp, PlayerColor::NEUTRAL);
}
int CClient::getLocalPlayer() const
PlayerColor CClient::getLocalPlayer() const
{
if(LOCPLINT)
return LOCPLINT->playerID;
@ -648,7 +648,7 @@ void CClient::commenceTacticPhaseForInt(CBattleGameInterface *battleInt)
battleInt->yourTacticPhase(gs->curB->tacticDistance);
if(gs && !!gs->curB && gs->curB->tacticDistance) //while awaiting for end of tactics phase, many things can happen (end of battle... or game)
{
MakeAction ma(BattleAction::makeEndOFTacticPhase(battleInt->playerID));
MakeAction ma(BattleAction::makeEndOFTacticPhase(gs->curB->playerToSide(battleInt->playerID)));
sendRequest(&ma, battleInt->playerID);
}
} HANDLE_EXCEPTION
@ -660,7 +660,7 @@ void CClient::invalidatePaths(const CGHeroInstance *h /*= NULL*/)
pathInfo->isValid = false;
}
int CClient::sendRequest(const CPack *request, TPlayerColor player)
int CClient::sendRequest(const CPack *request, PlayerColor player)
{
static ui32 requestCounter = 0;

24
client/Client.h
View File

@ -113,12 +113,12 @@ class CClient : public IGameCallback
{
public:
CCallback *cb;
std::map<TPlayerColor,shared_ptr<CCallback> > callbacks; //callbacks given to player interfaces
std::map<TPlayerColor,shared_ptr<CBattleCallback> > battleCallbacks; //callbacks given to player interfaces
std::map<PlayerColor,shared_ptr<CCallback> > callbacks; //callbacks given to player interfaces
std::map<PlayerColor,shared_ptr<CBattleCallback> > battleCallbacks; //callbacks given to player interfaces
std::vector<IGameEventsReceiver*> privilagedGameEventReceivers; //scripting modules, spectator interfaces
std::vector<IBattleEventsReceiver*> privilagedBattleEventReceivers; //scripting modules, spectator interfaces
std::map<TPlayerColor,CGameInterface *> playerint;
std::map<TPlayerColor,CBattleGameInterface *> battleints;
std::map<PlayerColor,CGameInterface *> playerint;
std::map<PlayerColor,CBattleGameInterface *> battleints;
bool hotSeat;
CConnection *serv;
BattleAction *curbaction;
@ -133,7 +133,7 @@ public:
std::queue<CPack *> packs;
boost::mutex packsM;
void waitForMoveAndSend(TPlayerColor color);
void waitForMoveAndSend(PlayerColor color);
//void sendRequest(const CPackForServer *request, bool waitForRealization);
CClient(void);
CClient(CConnection *con, StartInfo *si);
@ -159,22 +159,22 @@ public:
boost::thread *connectionHandler; //thread running run() method
//////////////////////////////////////////////////////////////////////////
virtual int getLocalPlayer() const OVERRIDE;
virtual PlayerColor getLocalPlayer() const OVERRIDE;
//////////////////////////////////////////////////////////////////////////
//not working yet, will be implement somewhen later with support for local-sim-based gameplay
void changeSpells(const CGHeroInstance * hero, bool give, const std::set<SpellID> &spells) OVERRIDE {};
bool removeObject(const CGObjectInstance * obj) OVERRIDE {return false;};
void setBlockVis(ObjectInstanceID objid, bool bv) OVERRIDE {};
void setOwner(const CGObjectInstance * obj, TPlayerColor owner) OVERRIDE {};
void setOwner(const CGObjectInstance * obj, PlayerColor owner) OVERRIDE {};
void setHoverName(const CGObjectInstance * obj, MetaString * name) OVERRIDE {};
void changePrimSkill(const CGHeroInstance * hero, PrimarySkill::PrimarySkill which, si64 val, bool abs=false) OVERRIDE {};
void changeSecSkill(const CGHeroInstance * hero, SecondarySkill which, int val, bool abs=false) OVERRIDE {};
void showBlockingDialog(BlockingDialog *iw, const CFunctionList<void(ui32)> &callback) OVERRIDE {};
ui32 showBlockingDialog(BlockingDialog *iw) OVERRIDE {return 0;}; //synchronous version of above
void showGarrisonDialog(ObjectInstanceID upobj, ObjectInstanceID hid, bool removableUnits, const boost::function<void()> &cb) OVERRIDE {};
void showThievesGuildWindow(TPlayerColor player, ObjectInstanceID requestingObjId) OVERRIDE {};
void giveResource(TPlayerColor player, Res::ERes which, int val) OVERRIDE {};
void showThievesGuildWindow(PlayerColor player, ObjectInstanceID requestingObjId) OVERRIDE {};
void giveResource(PlayerColor player, Res::ERes which, int val) OVERRIDE {};
void giveCreatures(const CArmedInstance * objid, const CGHeroInstance * h, const CCreatureSet &creatures, bool remove) OVERRIDE {};
void takeCreatures(ObjectInstanceID objid, const std::vector<CStackBasicDescriptor> &creatures) OVERRIDE {};
@ -203,11 +203,11 @@ public:
void startBattleI(const CArmedInstance *army1, const CArmedInstance *army2, int3 tile, boost::function<void(BattleResult*)> cb = 0, bool creatureBank = false) OVERRIDE {}; //if any of armies is hero, hero will be used
void startBattleI(const CArmedInstance *army1, const CArmedInstance *army2, boost::function<void(BattleResult*)> cb = 0, bool creatureBank = false) OVERRIDE {}; //if any of armies is hero, hero will be used, visitable tile of second obj is place of battle
void setAmount(ObjectInstanceID objid, ui32 val) OVERRIDE {};
bool moveHero(ObjectInstanceID hid, int3 dst, ui8 instant, TPlayerColor asker = GameConstants::NEUTRAL_PLAYER) OVERRIDE {return false;};
bool moveHero(ObjectInstanceID hid, int3 dst, ui8 instant, PlayerColor asker = PlayerColor::NEUTRAL) OVERRIDE {return false;};
void giveHeroBonus(GiveBonus * bonus) OVERRIDE {};
void setMovePoints(SetMovePoints * smp) OVERRIDE {};
void setManaPoints(ObjectInstanceID hid, int val) OVERRIDE {};
void giveHero(ObjectInstanceID id, TPlayerColor player) OVERRIDE {};
void giveHero(ObjectInstanceID id, PlayerColor player) OVERRIDE {};
void changeObjPos(ObjectInstanceID objid, int3 newPos, ui8 flags) OVERRIDE {};
void sendAndApply(CPackForClient * info) OVERRIDE {};
void heroExchange(ObjectInstanceID hero1, ObjectInstanceID hero2) OVERRIDE {};
@ -217,7 +217,7 @@ public:
friend class CBattleCallback; //handling players actions
friend void processCommand(const std::string &message, CClient *&client); //handling console
int sendRequest(const CPack *request, TPlayerColor player); //returns ID given to that request
int sendRequest(const CPack *request, PlayerColor player); //returns ID given to that request
void handlePack( CPack * pack ); //applies the given pack and deletes it
void battleStarted(const BattleInfo * info);

26
client/GUIClasses.cpp
View File

@ -644,11 +644,11 @@ bool CGarrisonInt::getSplittingMode()
void CGarrisonInt::setArmy(const CArmedInstance *army, bool bottomGarrison)
{
owned[bottomGarrison] = army ? (army->tempOwner == LOCPLINT->playerID || army->tempOwner == GameConstants::UNFLAGGABLE_PLAYER) : false;
owned[bottomGarrison] = army ? (army->tempOwner == LOCPLINT->playerID || army->tempOwner == PlayerColor::UNFLAGGABLE) : false;
armedObjs[bottomGarrison] = army;
}
CInfoWindow::CInfoWindow(std::string Text, int player, const TCompsInfo &comps, const TButtonsInfo &Buttons, bool delComps)
CInfoWindow::CInfoWindow(std::string Text, PlayerColor player, const TCompsInfo &comps, const TButtonsInfo &Buttons, bool delComps)
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
@ -721,7 +721,7 @@ void CInfoWindow::showAll(SDL_Surface * to)
CIntObject::showAll(to);
}
void CInfoWindow::showYesNoDialog(const std::string & text, const std::vector<CComponent*> *components, const CFunctionList<void( ) > &onYes, const CFunctionList<void()> &onNo, bool DelComps, int player)
void CInfoWindow::showYesNoDialog(const std::string & text, const std::vector<CComponent*> *components, const CFunctionList<void( ) > &onYes, const CFunctionList<void()> &onNo, bool DelComps, PlayerColor player)
{
assert(!LOCPLINT || LOCPLINT->showingDialog->get());
std::vector<std::pair<std::string,CFunctionList<void()> > > pom;
@ -736,7 +736,7 @@ void CInfoWindow::showYesNoDialog(const std::string & text, const std::vector<CC
GH.pushInt(temp);
}
CInfoWindow * CInfoWindow::create(const std::string &text, int playerID /*= 1*/, const std::vector<CComponent*> *components /*= NULL*/, bool DelComps)
CInfoWindow * CInfoWindow::create(const std::string &text, PlayerColor playerID /*= 1*/, const std::vector<CComponent*> *components /*= NULL*/, bool DelComps)
{
std::vector<std::pair<std::string,CFunctionList<void()> > > pom;
pom.push_back(std::pair<std::string,CFunctionList<void()> >("IOKAY.DEF",0));
@ -1262,7 +1262,7 @@ void CSelWindow::selectionChange(unsigned to)
redraw();
}
CSelWindow::CSelWindow(const std::string &Text, int player, int charperline, const std::vector<CSelectableComponent*> &comps, const std::vector<std::pair<std::string,CFunctionList<void()> > > &Buttons, int askID)
CSelWindow::CSelWindow(const std::string &Text, PlayerColor player, int charperline, const std::vector<CSelectableComponent*> &comps, const std::vector<std::pair<std::string,CFunctionList<void()> > > &Buttons, int askID)
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
ID = askID;
@ -2360,8 +2360,8 @@ std::vector<int> *CTradeWindow::getItemsIds(bool Left)
{
case PLAYER:
ids = new std::vector<int>;
for(int i = 0; i < GameConstants::PLAYER_LIMIT; i++)
if(i != LOCPLINT->playerID && LOCPLINT->cb->getPlayerStatus(i) == EPlayerStatus::INGAME)
for(int i = 0; i < PlayerColor::PLAYER_LIMIT_I; i++)
if(PlayerColor(i) != LOCPLINT->playerID && LOCPLINT->cb->getPlayerStatus(PlayerColor(i)) == EPlayerStatus::INGAME)
ids->push_back(i);
break;
@ -4028,7 +4028,7 @@ CGarrisonWindow::CGarrisonWindow( const CArmedInstance *up, const CGHeroInstance
}
new CLabel(275, 30, FONT_BIG, CENTER, Colors::YELLOW, titleText);
new CAnimImage("CREST58", garr->armedObjs[0]->getOwner(), 0, 28, 124);
new CAnimImage("CREST58", garr->armedObjs[0]->getOwner().getNum(), 0, 28, 124);
new CAnimImage("PortraitsLarge", dynamic_cast<const CGHeroInstance*>(garr->armedObjs[1])->portrait, 0, 29, 222);
}
@ -5737,7 +5737,7 @@ CThievesGuildWindow::CThievesGuildWindow(const CGObjectInstance * _owner):
//data for information table:
// fields[row][column] = list of id's of players for this box
static std::vector< std::vector< TPlayerColor > > SThievesGuildInfo::* fields[] =
static std::vector< std::vector< PlayerColor > > SThievesGuildInfo::* fields[] =
{ &SThievesGuildInfo::numOfTowns, &SThievesGuildInfo::numOfHeroes, &SThievesGuildInfo::gold,
&SThievesGuildInfo::woodOre, &SThievesGuildInfo::mercSulfCrystGems, &SThievesGuildInfo::obelisks,
&SThievesGuildInfo::artifacts, &SThievesGuildInfo::army, &SThievesGuildInfo::income };
@ -5769,7 +5769,7 @@ CThievesGuildWindow::CThievesGuildWindow(const CGObjectInstance * _owner):
{
for(int b=0; b<(tgi .* fields[g]).size(); ++b) //by places (1st, 2nd, ...)
{
std::vector<TPlayerColor> &players = (tgi .* fields[g])[b]; //get players with this place in this line
std::vector<PlayerColor> &players = (tgi .* fields[g])[b]; //get players with this place in this line
//position of box
int xpos = 259 + 66 * b;
@ -5788,7 +5788,7 @@ CThievesGuildWindow::CThievesGuildWindow(const CGObjectInstance * _owner):
for (size_t i=0; i< rowLength[j]; i++)
{
new CAnimImage("itgflags", players[i + j*4], 0, rowStartX + i*12, rowStartY);
new CAnimImage("itgflags", players[i + j*4].getNum(), 0, rowStartX + i*12, rowStartY);
}
}
}
@ -5802,7 +5802,7 @@ CThievesGuildWindow::CThievesGuildWindow(const CGObjectInstance * _owner):
{
if(iter.second.portrait >= 0)
{
new CPicture(colorToBox[iter.first], 253 + 66 * counter, 334);
new CPicture(colorToBox[iter.first.getNum()], 253 + 66 * counter, 334);
new CAnimImage("PortraitsSmall", iter.second.portrait, 0, 260 + 66 * counter, 360);
//TODO: r-click info:
// - r-click on hero
@ -6005,7 +6005,7 @@ void CRClickPopup::close()
void CRClickPopup::createAndPush(const std::string &txt, const CInfoWindow::TCompsInfo &comps)
{
int player = LOCPLINT ? LOCPLINT->playerID : 1; //if no player, then use blue
PlayerColor player = LOCPLINT ? LOCPLINT->playerID : PlayerColor(1); //if no player, then use blue
CSimpleWindow * temp = new CInfoWindow(txt, player, comps);
temp->center(Point(GH.current->motion)); //center on mouse

8
client/GUIClasses.h
View File

@ -100,12 +100,12 @@ public:
void showAll(SDL_Surface * to);
void sliderMoved(int to);
CInfoWindow(std::string Text, int player, const TCompsInfo &comps = TCompsInfo(), const TButtonsInfo &Buttons = TButtonsInfo(), bool delComps = true); //c-tor
CInfoWindow(std::string Text, PlayerColor player, const TCompsInfo &comps = TCompsInfo(), const TButtonsInfo &Buttons = TButtonsInfo(), bool delComps = true); //c-tor
CInfoWindow(); //c-tor
~CInfoWindow(); //d-tor
static void showYesNoDialog( const std::string & text, const std::vector<CComponent*> *components, const CFunctionList<void( ) > &onYes, const CFunctionList<void()> &onNo, bool DelComps = true, int player = 1); //use only before the game starts! (showYesNoDialog in LOCPLINT must be used then)
static CInfoWindow *create(const std::string &text, int playerID = 1, const std::vector<CComponent*> *components = NULL, bool DelComps = false);
static void showYesNoDialog( const std::string & text, const std::vector<CComponent*> *components, const CFunctionList<void( ) > &onYes, const CFunctionList<void()> &onNo, bool DelComps = true, PlayerColor player = PlayerColor(1)); //use only before the game starts! (showYesNoDialog in LOCPLINT must be used then)
static CInfoWindow *create(const std::string &text, PlayerColor playerID = PlayerColor(1), const std::vector<CComponent*> *components = NULL, bool DelComps = false);
/// create text from title and description: {title}\n\n description
static std::string genText(std::string title, std::string description);
@ -117,7 +117,7 @@ class CSelWindow : public CInfoWindow
public:
void selectionChange(unsigned to);
void madeChoice(); //looks for selected component and calls callback
CSelWindow(const std::string& text, int player, int charperline ,const std::vector<CSelectableComponent*> &comps, const std::vector<std::pair<std::string,CFunctionList<void()> > > &Buttons, int askID); //c-tor
CSelWindow(const std::string& text, PlayerColor player, int charperline ,const std::vector<CSelectableComponent*> &comps, const std::vector<std::pair<std::string,CFunctionList<void()> > > &Buttons, int askID); //c-tor
CSelWindow(){}; //c-tor
//notification - this class inherits important destructor from CInfoWindow
};

22
client/Graphics.cpp
View File

@ -51,7 +51,7 @@ void Graphics::loadPaletteAndColors()
playerColorPalette = new SDL_Color[256];
neutralColor = new SDL_Color;
playerColors = new SDL_Color[GameConstants::PLAYER_LIMIT];
playerColors = new SDL_Color[PlayerColor::PLAYER_LIMIT_I];
int startPoint = 24; //beginning byte; used to read
for(int i=0; i<256; ++i)
{
@ -278,18 +278,18 @@ void Graphics::loadHeroFlags()
tlog0 << "Loading and transforming heroes' flags: "<<th.getDiff()<<std::endl;
}
void Graphics::blueToPlayersAdv(SDL_Surface * sur, int player)
void Graphics::blueToPlayersAdv(SDL_Surface * sur, PlayerColor player)
{
// if(player==1) //it is actually blue...
// return;
if(sur->format->BitsPerPixel == 8)
{
SDL_Color *palette = NULL;
if(player < GameConstants::PLAYER_LIMIT && player >= 0)
if(player < PlayerColor::PLAYER_LIMIT)
{
palette = playerColorPalette + 32*player;
palette = playerColorPalette + 32*player.getNum();
}
else if(player == 255 || player == -1)
else if(player == PlayerColor::NEUTRAL)
{
palette = neutralColorPalette;
}
@ -321,9 +321,9 @@ void Graphics::blueToPlayersAdv(SDL_Surface * sur, int player)
sort1.push_back(cp[1]);
sort1.push_back(cp[2]);
std::vector< std::pair<long long int, Uint8*> > sort2;
sort2.push_back(std::make_pair(graphics->playerColors[player].r, &(cp[0])));
sort2.push_back(std::make_pair(graphics->playerColors[player].g, &(cp[1])));
sort2.push_back(std::make_pair(graphics->playerColors[player].b, &(cp[2])));
sort2.push_back(std::make_pair(graphics->playerColors[player.getNum()].r, &(cp[0])));
sort2.push_back(std::make_pair(graphics->playerColors[player.getNum()].g, &(cp[1])));
sort2.push_back(std::make_pair(graphics->playerColors[player.getNum()].b, &(cp[2])));
std::sort(sort1.begin(), sort1.end());
if(sort2[0].first>sort2[1].first)
std::swap(sort2[0], sort2[1]);
@ -349,9 +349,9 @@ void Graphics::blueToPlayersAdv(SDL_Surface * sur, int player)
sort1.push_back(cp[1]);
sort1.push_back(cp[0]);
std::vector< std::pair<long long int, Uint8*> > sort2;
sort2.push_back(std::make_pair(graphics->playerColors[player].r, &(cp[2])));
sort2.push_back(std::make_pair(graphics->playerColors[player].g, &(cp[1])));
sort2.push_back(std::make_pair(graphics->playerColors[player].b, &(cp[0])));
sort2.push_back(std::make_pair(graphics->playerColors[player.getNum()].r, &(cp[2])));
sort2.push_back(std::make_pair(graphics->playerColors[player.getNum()].g, &(cp[1])));
sort2.push_back(std::make_pair(graphics->playerColors[player.getNum()].b, &(cp[0])));
std::sort(sort1.begin(), sort1.end());
if(sort2[0].first>sort2[1].first)
std::swap(sort2[0], sort2[1]);

2
client/Graphics.h
View File

@ -74,7 +74,7 @@ public:
void loadHeroAnims();
CDefEssential * loadHeroAnim(const std::string &name, const std::vector<std::pair<int,int> > &rotations);
void loadErmuToPicture();
void blueToPlayersAdv(SDL_Surface * sur, int player); //replaces blue interface colour with a color of player
void blueToPlayersAdv(SDL_Surface * sur, PlayerColor player); //replaces blue interface colour with a color of player
void loadFonts();
};

42
client/NetPacksClient.cpp
View File

@ -76,8 +76,8 @@
#define CALL_IN_ALL_INTERFACES(function, ...) \
do \
{ \
std::map<ui8, CGameInterface*> ints = cl->playerint; \
for(std::map<ui8, CGameInterface*>::iterator i = ints.begin(); i != ints.end(); i++)\
std::map<PlayerColor, CGameInterface*> ints = cl->playerint; \
for(auto i = ints.begin(); i != ints.end(); i++)\
CALL_ONLY_THAT_INTERFACE(i->first, function, __VA_ARGS__); \
} while(0)
@ -261,8 +261,8 @@ void GiveBonus::applyCl( CClient *cl )
break;
case PLAYER:
{
const PlayerState *p = GS(cl)->getPlayer(id);
INTERFACE_CALL_IF_PRESENT(id, playerBonusChanged, *p->getBonusList().back(), true);
const PlayerState *p = GS(cl)->getPlayer(PlayerColor(id));
INTERFACE_CALL_IF_PRESENT(PlayerColor(id), playerBonusChanged, *p->getBonusList().back(), true);
}
break;
}
@ -302,7 +302,7 @@ void RemoveBonus::applyCl( CClient *cl )
case PLAYER:
{
//const PlayerState *p = GS(cl)->getPlayer(id);
INTERFACE_CALL_IF_PRESENT(id, playerBonusChanged, bonus, false);
INTERFACE_CALL_IF_PRESENT(PlayerColor(id), playerBonusChanged, bonus, false);
}
break;
}
@ -327,7 +327,7 @@ void RemoveObject::applyFirstCl( CClient *cl )
int3 pos = o->visitablePos();
//notify interfaces about removal
for(std::map<ui8, CGameInterface*>::iterator i=cl->playerint.begin();i!=cl->playerint.end();i++)
for(auto i=cl->playerint.begin(); i!=cl->playerint.end(); i++)
{
if(GS(cl)->isVisible(o, i->first))
i->second->objectRemoved(o);
@ -344,9 +344,9 @@ void TryMoveHero::applyFirstCl( CClient *cl )
CGHeroInstance *h = GS(cl)->getHero(id);
//check if playerint will have the knowledge about movement - if not, directly update maphandler
for(std::map<ui8, CGameInterface*>::iterator i=cl->playerint.begin();i!=cl->playerint.end();i++)
for(auto i=cl->playerint.begin(); i!=cl->playerint.end(); i++)
{
if(i->first >= GameConstants::PLAYER_LIMIT)
if(i->first >= PlayerColor::PLAYER_LIMIT)
continue;
TeamState *t = GS(cl)->getPlayerTeam(i->first);
if((t->fogOfWarMap[start.x-1][start.y][start.z] || t->fogOfWarMap[end.x-1][end.y][end.z])
@ -375,16 +375,16 @@ void TryMoveHero::applyCl( CClient *cl )
if(result == EMBARK)
CGI->mh->hideObject(h->boat);
int player = h->tempOwner;
PlayerColor player = h->tempOwner;
BOOST_FOREACH(auto &i, cl->playerint)
if(cl->getPlayerRelations(i.first, player) != PlayerRelations::ENEMIES)
i.second->tileRevealed(fowRevealed);
//notify interfaces about move
for(std::map<ui8, CGameInterface*>::iterator i=cl->playerint.begin();i!=cl->playerint.end();i++)
for(auto i=cl->playerint.begin(); i!=cl->playerint.end(); i++)
{
if(i->first >= GameConstants::PLAYER_LIMIT) continue;
if(i->first >= PlayerColor::PLAYER_LIMIT) continue;
TeamState *t = GS(cl)->getPlayerTeam(i->first);
if(t->fogOfWarMap[start.x-1][start.y][start.z] || t->fogOfWarMap[end.x-1][end.y][end.z])
{
@ -435,7 +435,7 @@ void SetAvailableCreatures::applyCl( CClient *cl )
//inform order about the change
int p = -1;
PlayerColor p;
if(dw->ID == Obj::WAR_MACHINE_FACTORY) //War Machines Factory is not flaggable, it's "owned" by visitor
p = cl->getTile(dw->visitablePos())->visitableObjects.back()->tempOwner;
else
@ -450,7 +450,7 @@ void SetHeroesInTown::applyCl( CClient *cl )
CGHeroInstance *hGarr = GS(cl)->getHero(this->garrison);
CGHeroInstance *hVisit = GS(cl)->getHero(this->visiting);
std::set<TPlayerColor> playersToNotify;
std::set<PlayerColor> playersToNotify;
if(vstd::contains(cl->playerint,t->tempOwner)) // our town
playersToNotify.insert(t->tempOwner);
@ -561,7 +561,7 @@ void CommanderLevelUp::applyCl( CClient *cl )
{
CCommanderInstance * commander = GS(cl)->getHero(heroid)->commander;
assert (commander);
ui8 player = commander->armyObj->tempOwner;
PlayerColor player = commander->armyObj->tempOwner;
if (commander->armyObj && vstd::contains(cl->playerint, player)) //is it possible for Commander to exist beyond armed instance?
{
cl->playerint[player]->commanderGotLevel(commander, skills, queryID);
@ -611,7 +611,7 @@ void BattleSetActiveStack::applyCl( CClient *cl )
return;
const CStack * activated = GS(cl)->curB->battleGetStackByID(stack);
int playerToCall = -1; //player that will move activated stack
PlayerColor playerToCall; //player that will move activated stack
if( activated->hasBonusOfType(Bonus::HYPNOTIZED) )
{
playerToCall = ( GS(cl)->curB->sides[0] == activated->owner ? GS(cl)->curB->sides[1] : GS(cl)->curB->sides[0] );
@ -698,7 +698,7 @@ void BattleResultsApplied::applyCl( CClient *cl )
{
INTERFACE_CALL_IF_PRESENT(player1, battleResultsApplied);
INTERFACE_CALL_IF_PRESENT(player2, battleResultsApplied);
INTERFACE_CALL_IF_PRESENT(254, battleResultsApplied);
INTERFACE_CALL_IF_PRESENT(PlayerColor::UNFLAGGABLE, battleResultsApplied);
if(GS(cl)->initialOpts->mode == StartInfo::DUEL)
{
cl->terminate = true;
@ -823,7 +823,7 @@ void SaveGame::applyCl(CClient *cl)
void PlayerMessage::applyCl(CClient *cl)
{
std::ostringstream str;
str << "Player "<<(int)player<<" sends a message: " << text;
str << "Player "<< player <<" sends a message: " << text;
tlog4 << str.str() << std::endl;
if(LOCPLINT)
@ -881,7 +881,7 @@ void OpenWindow::applyCl(CClient *cl)
{
//displays Thieves' Guild window (when hero enters Den of Thieves)
const CGObjectInstance *obj = cl->getObj(ObjectInstanceID(id2));
INTERFACE_CALL_IF_PRESENT(id1, showThievesGuildWindow, obj);
INTERFACE_CALL_IF_PRESENT(PlayerColor(id1), showThievesGuildWindow, obj);
}
break;
case UNIVERSITY_WINDOW:
@ -911,7 +911,7 @@ void OpenWindow::applyCl(CClient *cl)
break;
case PUZZLE_MAP:
{
INTERFACE_CALL_IF_PRESENT(id1, showPuzzleMap);
INTERFACE_CALL_IF_PRESENT(PlayerColor(id1), showPuzzleMap);
}
break;
case TAVERN_WINDOW:
@ -935,7 +935,7 @@ void NewObject::applyCl(CClient *cl)
const CGObjectInstance *obj = cl->getObj(id);
CGI->mh->printObject(obj);
for(std::map<ui8, CGameInterface*>::iterator i=cl->playerint.begin();i!=cl->playerint.end();i++)
for(auto i=cl->playerint.begin(); i!=cl->playerint.end(); i++)
{
if(GS(cl)->isVisible(obj, i->first))
i->second->newObject(obj);
@ -946,7 +946,7 @@ void SetAvailableArtifacts::applyCl(CClient *cl)
{
if(id < 0) //artifact merchants globally
{
for(std::map<ui8, CGameInterface*>::iterator i=cl->playerint.begin();i!=cl->playerint.end();i++)
for(auto i=cl->playerint.begin(); i!=cl->playerint.end(); i++)
i->second->availableArtifactsChanged(NULL);
}
else

8
client/UIFramework/CIntObjectClasses.cpp
View File

@ -162,14 +162,14 @@ void CPicture::createSimpleRect(const Rect &r, bool screenFormat, ui32 color)
freeSurf = true;
}
void CPicture::colorizeAndConvert(int player)
void CPicture::colorizeAndConvert(PlayerColor player)
{
assert(bg);
colorize(player);
convertToScreenBPP();
}
void CPicture::colorize(int player)
void CPicture::colorize(PlayerColor player)
{
assert(bg);
assert(bg->format->BitsPerPixel == 8);
@ -428,7 +428,7 @@ void CAdventureMapButton::setImage(CAnimation* anim, bool playerColoredButton, i
pos.h = image->pos.h;
}
void CAdventureMapButton::setPlayerColor(int player)
void CAdventureMapButton::setPlayerColor(PlayerColor player)
{
if (image)
image->playerColored(player);
@ -1866,7 +1866,7 @@ void CWindowObject::showAll(SDL_Surface *to)
{
CIntObject::showAll(to);
if ((options & BORDERED) && (pos.h != to->h || pos.w != to->w))
CMessage::drawBorder(LOCPLINT ? LOCPLINT->playerID : 1, to, pos.w+28, pos.h+29, pos.x-14, pos.y-15);
CMessage::drawBorder(LOCPLINT ? LOCPLINT->playerID : PlayerColor(1), to, pos.w+28, pos.h+29, pos.x-14, pos.y-15);
}
void CWindowObject::close()

6
client/UIFramework/CIntObjectClasses.h
View File

@ -63,8 +63,8 @@ public:
void show(SDL_Surface * to);
void showAll(SDL_Surface * to);
void convertToScreenBPP();
void colorizeAndConvert(int player);
void colorize(int player);
void colorizeAndConvert(PlayerColor player);
void colorize(PlayerColor player);
};
/// area filled with specific texture
@ -147,7 +147,7 @@ public:
void setIndex(size_t index, bool playerColoredButton=false);
void setImage(CAnimation* anim, bool playerColoredButton=false, int animFlags=0);
void setPlayerColor(int player);
void setPlayerColor(PlayerColor player);
void showAll(SDL_Surface * to);
};

8
client/UIFramework/SDL_Extensions.cpp
View File

@ -580,15 +580,15 @@ void CSDL_Ext::drawDashedBorder(SDL_Surface * sur, const Rect &r, const int3 &co
}
}
void CSDL_Ext::setPlayerColor(SDL_Surface * sur, ui8 player)
void CSDL_Ext::setPlayerColor(SDL_Surface * sur, PlayerColor player)
{
if(player==254)
if(player==PlayerColor::UNFLAGGABLE)
return;
if(sur->format->BitsPerPixel==8)
{
SDL_Color *color = (player == 255
SDL_Color *color = (player == PlayerColor::NEUTRAL
? graphics->neutralColor
: &graphics->playerColors[player]);
: &graphics->playerColors[player.getNum()]);
SDL_SetColors(sur, color, 5, 1);
}
else

2
client/UIFramework/SDL_Extensions.h
View File

@ -176,7 +176,7 @@ namespace CSDL_Ext
void drawBorder(SDL_Surface * sur, int x, int y, int w, int h, const int3 &color);
void drawBorder(SDL_Surface * sur, const SDL_Rect &r, const int3 &color);
void drawDashedBorder(SDL_Surface * sur, const Rect &r, const int3 &color);
void setPlayerColor(SDL_Surface * sur, ui8 player); //sets correct color of flags; -1 for neutral
void setPlayerColor(SDL_Surface * sur, PlayerColor player); //sets correct color of flags; -1 for neutral
std::string processStr(std::string str, std::vector<std::string> & tor); //replaces %s in string
SDL_Surface * newSurface(int w, int h, SDL_Surface * mod=screen); //creates new surface, with flags/format same as in surface given
SDL_Surface * copySurface(SDL_Surface * mod); //returns copy of given surface

10
client/mapHandler.cpp
View File

@ -524,7 +524,7 @@ void CMapHandler::terrainRect( int3 top_tile, ui8 anim, const std::vector< std::
if (!graphics->getDef(obj))
processDef(obj->defInfo);
ui8 color = obj->tempOwner;
PlayerColor color = obj->tempOwner;
//checking if object has non-empty graphic on this tile
if(obj->ID != Obj::HERO && !obj->coveringAt(top_tile.x + bx - obj->pos.x, top_tile.y + by - obj->pos.y))
@ -557,7 +557,7 @@ void CMapHandler::terrainRect( int3 top_tile, ui8 anim, const std::vector< std::
if(themp) //hero
{
if(themp->tempOwner >= GameConstants::PLAYER_LIMIT) //Neutral hero?
if(themp->tempOwner >= PlayerColor::PLAYER_LIMIT) //Neutral hero?
{
tlog1 << "A neutral hero (" << themp->name << ") at " << themp->pos << ". Should not happen!\n";
continue;
@ -613,7 +613,7 @@ void CMapHandler::terrainRect( int3 top_tile, ui8 anim, const std::vector< std::
//printing flag
pp.y+=IMGVAL*2-32;
sr2.y-=16;
CSDL_Ext::blitSurface((graphics->*flg)[color]->ourImages[gg+heroAnim%IMGVAL+35].bitmap, &pp, extSurf, &sr2);
CSDL_Ext::blitSurface((graphics->*flg)[color.getNum()]->ourImages[gg+heroAnim%IMGVAL+35].bitmap, &pp, extSurf, &sr2);
}
else //hero / boat stands still
{
@ -639,7 +639,7 @@ void CMapHandler::terrainRect( int3 top_tile, ui8 anim, const std::vector< std::
bufr.h = 64;
bufr.w = 96;
if(bufr.x-extRect->x>-64)
CSDL_Ext::blitSurface((graphics->*flg)[color]->ourImages[getHeroFrameNum(dir, false) *8+(heroAnim/4)%IMGVAL].bitmap, NULL, extSurf, &bufr);
CSDL_Ext::blitSurface((graphics->*flg)[color.getNum()]->ourImages[getHeroFrameNum(dir, false) *8+(heroAnim/4)%IMGVAL].bitmap, NULL, extSurf, &bufr);
}
}
}
@ -649,7 +649,7 @@ void CMapHandler::terrainRect( int3 top_tile, ui8 anim, const std::vector< std::
SDL_Surface *bitmap = ourImages[(anim+getPhaseShift(obj))%ourImages.size()].bitmap;
//setting appropriate flag color
if(color < 8 || color==255)
if(color < PlayerColor::PLAYER_LIMIT || color==PlayerColor::NEUTRAL)
CSDL_Ext::setPlayerColor(bitmap, color);
if( obj->hasShadowAt(top_tile.x + bx - obj->pos.x, top_tile.y + by - obj->pos.y) )

24
lib/BattleState.cpp
View File

@ -141,8 +141,8 @@ int BattleInfo::calculateSpellDuration( const CSpell * spell, const CGHeroInstan
CStack * BattleInfo::generateNewStack(const CStackInstance &base, bool attackerOwned, SlotID slot, BattleHex position) const
{
int stackID = getIdForNewStack();
int owner = attackerOwned ? sides[0] : sides[1];
assert((owner >= GameConstants::PLAYER_LIMIT) ||
PlayerColor owner = attackerOwned ? sides[0] : sides[1];
assert((owner >= PlayerColor::PLAYER_LIMIT) ||
(base.armyObj && base.armyObj->tempOwner == owner));
CStack * ret = new CStack(&base, owner, stackID, attackerOwned, slot);
@ -154,7 +154,7 @@ CStack * BattleInfo::generateNewStack(const CStackInstance &base, bool attackerO
CStack * BattleInfo::generateNewStack(const CStackBasicDescriptor &base, bool attackerOwned, SlotID slot, BattleHex position) const
{
int stackID = getIdForNewStack();
int owner = attackerOwned ? sides[0] : sides[1];
PlayerColor owner = attackerOwned ? sides[0] : sides[1];
CStack * ret = new CStack(&base, owner, stackID, attackerOwned, slot);
ret->position = position;
ret->state.insert(EBattleStackState::ALIVE); //alive state indication
@ -353,8 +353,8 @@ BattleInfo * BattleInfo::setupBattle( int3 tile, ETerrainType terrain, BFieldTyp
curB->castSpells[0] = curB->castSpells[1] = 0;
curB->sides[0] = armies[0]->tempOwner;
curB->sides[1] = armies[1]->tempOwner;
if(curB->sides[1] == GameConstants::UNFLAGGABLE_PLAYER)
curB->sides[1] = GameConstants::NEUTRAL_PLAYER;
if(curB->sides[1] == PlayerColor::UNFLAGGABLE)
curB->sides[1] = PlayerColor::NEUTRAL;
std::vector<CStack*> & stacks = (curB->stacks);
@ -708,7 +708,7 @@ BattleInfo * BattleInfo::setupBattle( int3 tile, ETerrainType terrain, BFieldTyp
return curB;
}
const CGHeroInstance * BattleInfo::getHero( TPlayerColor player ) const
const CGHeroInstance * BattleInfo::getHero( PlayerColor player ) const
{
assert(sides[0] == player || sides[1] == player);
if(heroes[0] && heroes[0]->getOwner() == player)
@ -717,7 +717,7 @@ const CGHeroInstance * BattleInfo::getHero( TPlayerColor player ) const
return heroes[1];
}
std::vector<ui32> BattleInfo::calculateResistedStacks(const CSpell * sp, const CGHeroInstance * caster, const CGHeroInstance * hero2, const std::set<const CStack*> affectedCreatures, int casterSideOwner, ECastingMode::ECastingMode mode, int usedSpellPower, int spellLevel) const
std::vector<ui32> BattleInfo::calculateResistedStacks(const CSpell * sp, const CGHeroInstance * caster, const CGHeroInstance * hero2, const std::set<const CStack*> affectedCreatures, PlayerColor casterSideOwner, ECastingMode::ECastingMode mode, int usedSpellPower, int spellLevel) const
{
std::vector<ui32> ret;
for(auto it = affectedCreatures.begin(); it != affectedCreatures.end(); ++it)
@ -766,12 +766,12 @@ std::vector<ui32> BattleInfo::calculateResistedStacks(const CSpell * sp, const C
return ret;
}
TPlayerColor BattleInfo::theOtherPlayer(TPlayerColor player) const
PlayerColor BattleInfo::theOtherPlayer(PlayerColor player) const
{
return sides[!whatSide(player)];
}
ui8 BattleInfo::whatSide(TPlayerColor player) const
ui8 BattleInfo::whatSide(PlayerColor player) const
{
for(int i = 0; i < ARRAY_COUNT(sides); i++)
if(sides[i] == player)
@ -842,7 +842,7 @@ BattleInfo::BattleInfo()
setNodeType(BATTLE);
}
CStack::CStack(const CStackInstance *Base, int O, int I, bool AO, SlotID S)
CStack::CStack(const CStackInstance *Base, PlayerColor O, int I, bool AO, SlotID S)
: base(Base), ID(I), owner(O), slot(S), attackerOwned(AO),
counterAttacks(1)
{
@ -856,7 +856,7 @@ CStack::CStack()
init();
setNodeType(STACK_BATTLE);
}
CStack::CStack(const CStackBasicDescriptor *stack, int O, int I, bool AO, SlotID S)
CStack::CStack(const CStackBasicDescriptor *stack, PlayerColor O, int I, bool AO, SlotID S)
: base(NULL), ID(I), owner(O), slot(S), attackerOwned(AO), counterAttacks(1)
{
type = stack->type;
@ -871,7 +871,7 @@ void CStack::init()
ID = -1;
count = baseAmount = -1;
firstHPleft = -1;
owner = GameConstants::NEUTRAL_PLAYER;
owner = PlayerColor::NEUTRAL;
slot = SlotID(255);
attackerOwned = false;
position = BattleHex();

16
lib/BattleState.h
View File

@ -45,7 +45,7 @@ struct DLL_LINKAGE SiegeInfo
struct DLL_LINKAGE BattleInfo : public CBonusSystemNode, public CBattleInfoCallback
{
TPlayerColor sides[2]; //sides[0] - attacker, sides[1] - defender
PlayerColor sides[2]; //sides[0] - attacker, sides[1] - defender
si32 round, activeStack, selectedStack;
CGTownInstance::EFortLevel siege;
const CGTownInstance * town; //used during town siege - id of attacked town; -1 if not town defence
@ -115,10 +115,10 @@ struct DLL_LINKAGE BattleInfo : public CBonusSystemNode, public CBattleInfoCallb
ui32 calculateHealedHP(const CSpell * spell, int usedSpellPower, int spellSchoolLevel, const CStack * stack) const; //healing spells casted by stacks
bool resurrects(SpellID spellid) const; //TODO: move it to spellHandler?
const CGHeroInstance * getHero(TPlayerColor player) const; //returns fighting hero that belongs to given player
const CGHeroInstance * getHero(PlayerColor player) const; //returns fighting hero that belongs to given player
std::vector<ui32> calculateResistedStacks(const CSpell * sp, const CGHeroInstance * caster, const CGHeroInstance * hero2, const std::set<const CStack*> affectedCreatures, int casterSideOwner, ECastingMode::ECastingMode mode, int usedSpellPower, int spellLevel) const;
std::vector<ui32> calculateResistedStacks(const CSpell * sp, const CGHeroInstance * caster, const CGHeroInstance * hero2, const std::set<const CStack*> affectedCreatures, PlayerColor casterSideOwner, ECastingMode::ECastingMode mode, int usedSpellPower, int spellLevel) const;
const CStack * battleGetStack(BattleHex pos, bool onlyAlive); //returns stack at given tile
const CGHeroInstance * battleGetOwner(const CStack * stack) const; //returns hero that owns given stack; NULL if none
@ -128,8 +128,8 @@ struct DLL_LINKAGE BattleInfo : public CBonusSystemNode, public CBattleInfoCallb
static BattleInfo * setupBattle( int3 tile, ETerrainType terrain, BFieldType battlefieldType, const CArmedInstance *armies[2], const CGHeroInstance * heroes[2], bool creatureBank, const CGTownInstance *town );
//bool hasNativeStack(ui8 side) const;
TPlayerColor theOtherPlayer(TPlayerColor player) const;
ui8 whatSide(TPlayerColor player) const;
PlayerColor theOtherPlayer(PlayerColor player) const;
ui8 whatSide(PlayerColor player) const;
static BattlefieldBI::BattlefieldBI battlefieldTypeToBI(BFieldType bfieldType); //converts above to ERM BI format
static int battlefieldTypeToTerrain(int bfieldType); //converts above to ERM BI format
@ -143,7 +143,7 @@ public:
ui32 ID; //unique ID of stack
ui32 baseAmount;
ui32 firstHPleft; //HP of first creature in stack
TPlayerColor owner; //owner - player colour (255 for neutrals)
PlayerColor owner; //owner - player colour (255 for neutrals)
SlotID slot; //slot - position in garrison (may be 255 for neutrals/called creatures)
bool attackerOwned; //if true, this stack is owned by attakcer (this one from left hand side of battle)
BattleHex position; //position on battlefield; -2 - keep, -3 - lower tower, -4 - upper tower
@ -155,8 +155,8 @@ public:
//overrides
const CCreature* getCreature() const {return type;}
CStack(const CStackInstance *base, int O, int I, bool AO, SlotID S); //c-tor
CStack(const CStackBasicDescriptor *stack, int O, int I, bool AO, SlotID S = SlotID(255)); //c-tor
CStack(const CStackInstance *base, PlayerColor O, int I, bool AO, SlotID S); //c-tor
CStack(const CStackBasicDescriptor *stack, PlayerColor O, int I, bool AO, SlotID S = SlotID(255)); //c-tor
CStack(); //c-tor
~CStack();
std::string nodeName() const OVERRIDE;

22
lib/CBattleCallback.cpp
View File

@ -107,7 +107,7 @@ void CCallbackBase::setBattle(const BattleInfo *B)
battle = B;
}
boost::optional<TPlayerColor> CCallbackBase::getPlayerID() const
boost::optional<PlayerColor> CCallbackBase::getPlayerID() const
{
return player;
}
@ -299,7 +299,7 @@ int CBattleInfoEssentials::battleCastSpells(ui8 side) const
return getBattle()->castSpells[side];
}
ESpellCastProblem::ESpellCastProblem CBattleInfoCallback::battleCanCastSpell(TPlayerColor player, ECastingMode::ECastingMode mode) const
ESpellCastProblem::ESpellCastProblem CBattleInfoCallback::battleCanCastSpell(PlayerColor player, ECastingMode::ECastingMode mode) const
{
RETURN_IF_NOT_BATTLE(ESpellCastProblem::INVALID);
const ui8 side = playerToSide(player);
@ -335,7 +335,7 @@ ESpellCastProblem::ESpellCastProblem CBattleInfoCallback::battleCanCastSpell(TPl
return ESpellCastProblem::OK;
}
bool CBattleInfoEssentials::battleCanFlee(TPlayerColor player) const
bool CBattleInfoEssentials::battleCanFlee(PlayerColor player) const
{
RETURN_IF_NOT_BATTLE(false);
ui8 mySide = playerToSide(player);
@ -360,7 +360,7 @@ bool CBattleInfoEssentials::battleCanFlee(TPlayerColor player) const
return true;
}
ui8 CBattleInfoEssentials::playerToSide(TPlayerColor player) const
ui8 CBattleInfoEssentials::playerToSide(PlayerColor player) const
{
RETURN_IF_NOT_BATTLE(-1);
int ret = vstd::find_pos(getBattle()->sides, player);
@ -376,7 +376,7 @@ ui8 CBattleInfoEssentials::battleGetSiegeLevel() const
return getBattle()->siege;
}
bool CBattleInfoEssentials::battleCanSurrender(TPlayerColor player) const
bool CBattleInfoEssentials::battleCanSurrender(PlayerColor player) const
{
RETURN_IF_NOT_BATTLE(false);
//conditions like for fleeing + enemy must have a hero
@ -1535,7 +1535,7 @@ ESpellCastProblem::ESpellCastProblem CBattleInfoCallback::battleIsImmune(const C
return ESpellCastProblem::OK;
}
ESpellCastProblem::ESpellCastProblem CBattleInfoCallback::battleCanCastThisSpell( TPlayerColor player, const CSpell * spell, ECastingMode::ECastingMode mode ) const
ESpellCastProblem::ESpellCastProblem CBattleInfoCallback::battleCanCastThisSpell( PlayerColor player, const CSpell * spell, ECastingMode::ECastingMode mode ) const
{
RETURN_IF_NOT_BATTLE(ESpellCastProblem::INVALID);
const ui8 side = playerToSide(player);
@ -1662,7 +1662,7 @@ ESpellCastProblem::ESpellCastProblem CBattleInfoCallback::battleCanCastThisSpell
return ESpellCastProblem::OK;
}
std::vector<BattleHex> CBattleInfoCallback::battleGetPossibleTargets(int player, const CSpell *spell) const
std::vector<BattleHex> CBattleInfoCallback::battleGetPossibleTargets(PlayerColor player, const CSpell *spell) const
{
std::vector<BattleHex> ret;
RETURN_IF_NOT_BATTLE(ret);
@ -1735,7 +1735,7 @@ ui32 CBattleInfoCallback::battleGetSpellCost(const CSpell * sp, const CGHeroInst
return ret - manaReduction + manaIncrease;
}
ESpellCastProblem::ESpellCastProblem CBattleInfoCallback::battleCanCastThisSpellHere( TPlayerColor player, const CSpell * spell, ECastingMode::ECastingMode mode, BattleHex dest ) const
ESpellCastProblem::ESpellCastProblem CBattleInfoCallback::battleCanCastThisSpellHere( PlayerColor player, const CSpell * spell, ECastingMode::ECastingMode mode, BattleHex dest ) const
{
RETURN_IF_NOT_BATTLE(ESpellCastProblem::INVALID);
ESpellCastProblem::ESpellCastProblem moreGeneralProblem = battleCanCastThisSpell(player, spell, mode);
@ -1862,7 +1862,7 @@ ui32 CBattleInfoCallback::calculateSpellDmg( const CSpell * sp, const CGHeroInst
return ret;
}
std::set<const CStack*> CBattleInfoCallback::getAffectedCreatures(const CSpell * spell, int skillLevel, ui8 attackerOwner, BattleHex destinationTile)
std::set<const CStack*> CBattleInfoCallback::getAffectedCreatures(const CSpell * spell, int skillLevel, PlayerColor attackerOwner, BattleHex destinationTile)
{
std::set<const CStack*> attackedCres; /*std::set to exclude multiple occurrences of two hex creatures*/
@ -1910,7 +1910,7 @@ std::set<const CStack*> CBattleInfoCallback::getAffectedCreatures(const CSpell *
}
if (!possibleHexes.size()) //not enough targets
break;
lightningHex = BattleHex::getClosestTile (attackerOwner, destinationTile, possibleHexes);
lightningHex = BattleHex::getClosestTile (stack->attackerOwned, destinationTile, possibleHexes);
}
}
else if (spell->range[skillLevel].size() > 1) //custom many-hex range
@ -2121,7 +2121,7 @@ SpellID CBattleInfoCallback::getRandomCastedSpell(const CStack * caster) const
return SpellID::NONE;
}
int CBattleInfoCallback::battleGetSurrenderCost(TPlayerColor Player) const
int CBattleInfoCallback::battleGetSurrenderCost(PlayerColor Player) const
{
RETURN_IF_NOT_BATTLE(-3);
if(!battleCanSurrender(Player))

24
lib/CBattleCallback.h
View File

@ -45,9 +45,9 @@ class DLL_LINKAGE CCallbackBase
protected:
CGameState *gs;
boost::optional<TPlayerColor> player; // not set gives access to all information, otherwise callback provides only information "visible" for player
boost::optional<PlayerColor> player; // not set gives access to all information, otherwise callback provides only information "visible" for player
CCallbackBase(CGameState *GS, boost::optional<TPlayerColor> Player)
CCallbackBase(CGameState *GS, boost::optional<PlayerColor> Player)
: battle(nullptr), gs(GS), player(Player)
{}
CCallbackBase()
@ -59,7 +59,7 @@ protected:
public:
boost::shared_mutex &getGsMutex(); //just return a reference to mutex, does not lock nor anything
boost::optional<TPlayerColor> getPlayerID() const;
boost::optional<PlayerColor> getPlayerID() const;
friend class CBattleInfoEssentials;
};
@ -175,9 +175,9 @@ public:
const CStack *battleActiveStack() const;
si8 battleTacticDist() const; //returns tactic distance in current tactics phase; 0 if not in tactics phase
si8 battleGetTacticsSide() const; //returns which side is in tactics phase, undefined if none (?)
bool battleCanFlee(TPlayerColor player) const;
bool battleCanSurrender(TPlayerColor player) const;
ui8 playerToSide(TPlayerColor player) const;
bool battleCanFlee(PlayerColor player) const;
bool battleCanSurrender(PlayerColor player) const;
ui8 playerToSide(PlayerColor player) const;
ui8 battleGetSiegeLevel() const; //returns 0 when there is no siege, 1 if fort, 2 is citadel, 3 is castle
bool battleHasHero(ui8 side) const;
int battleCastSpells(ui8 side) const; //how many spells has given side casted
@ -227,7 +227,7 @@ public:
std::vector<BattleHex> battleGetAvailableHexes(const CStack * stack, bool addOccupiable, std::vector<BattleHex> * attackable = NULL) const; //returns hexes reachable by creature with id ID (valid movement destinations), DOES contain stack current position
int battleGetSurrenderCost(TPlayerColor Player) const; //returns cost of surrendering battle, -1 if surrendering is not possible
int battleGetSurrenderCost(PlayerColor Player) const; //returns cost of surrendering battle, -1 if surrendering is not possible
ReachabilityInfo::TDistances battleGetDistances(const CStack * stack, BattleHex hex = BattleHex::INVALID, BattleHex * predecessors = NULL) const; //returns vector of distances to [dest hex number]
std::set<BattleHex> battleGetAttackedHexes(const CStack* attacker, BattleHex destinationTile, BattleHex attackerPos = BattleHex::INVALID) const;
bool battleCanShoot(const CStack * stack, BattleHex dest) const; //determines if stack with given ID shoot at the selected destination
@ -250,14 +250,14 @@ public:
//*** MAGIC
si8 battleMaxSpellLevel() const; //calculates minimum spell level possible to be cast on battlefield - takes into account artifacts of both heroes; if no effects are set, 0 is returned
ui32 battleGetSpellCost(const CSpell * sp, const CGHeroInstance * caster) const; //returns cost of given spell
ESpellCastProblem::ESpellCastProblem battleCanCastSpell(TPlayerColor player, ECastingMode::ECastingMode mode) const; //returns true if there are no general issues preventing from casting a spell
ESpellCastProblem::ESpellCastProblem battleCanCastThisSpell(TPlayerColor player, const CSpell * spell, ECastingMode::ECastingMode mode) const; //checks if given player can cast given spell
ESpellCastProblem::ESpellCastProblem battleCanCastThisSpellHere(TPlayerColor player, const CSpell * spell, ECastingMode::ECastingMode mode, BattleHex dest) const; //checks if given player can cast given spell at given tile in given mode
ESpellCastProblem::ESpellCastProblem battleCanCastSpell(PlayerColor player, ECastingMode::ECastingMode mode) const; //returns true if there are no general issues preventing from casting a spell
ESpellCastProblem::ESpellCastProblem battleCanCastThisSpell(PlayerColor player, const CSpell * spell, ECastingMode::ECastingMode mode) const; //checks if given player can cast given spell
ESpellCastProblem::ESpellCastProblem battleCanCastThisSpellHere(PlayerColor player, const CSpell * spell, ECastingMode::ECastingMode mode, BattleHex dest) const; //checks if given player can cast given spell at given tile in given mode
ESpellCastProblem::ESpellCastProblem battleCanCreatureCastThisSpell(const CSpell * spell, BattleHex destination) const; //determines if creature can cast a spell here
std::vector<BattleHex> battleGetPossibleTargets(int player, const CSpell *spell) const;
std::vector<BattleHex> battleGetPossibleTargets(PlayerColor player, const CSpell *spell) const;
ui32 calculateSpellBonus(ui32 baseDamage, const CSpell * sp, const CGHeroInstance * caster, const CStack * affectedCreature) const;
ui32 calculateSpellDmg(const CSpell * sp, const CGHeroInstance * caster, const CStack * affectedCreature, int spellSchoolLevel, int usedSpellPower) const; //calculates damage inflicted by spell
std::set<const CStack*> getAffectedCreatures(const CSpell * s, int skillLevel, ui8 attackerOwner, BattleHex destinationTile); //calculates stack affected by given spell
std::set<const CStack*> getAffectedCreatures(const CSpell * s, int skillLevel, PlayerColor attackerOwner, BattleHex destinationTile); //calculates stack affected by given spell
SpellID battleGetRandomStackSpell(const CStack * stack, ERandomSpell mode) const;
SpellID getRandomBeneficialSpell(const CStack * subject) const;

2
lib/CGameInterface.h
View File

@ -57,7 +57,7 @@ class CBattleGameInterface : public IBattleEventsReceiver
{
public:
bool human;
int playerID;
PlayerColor playerID;
std::string dllName;
virtual ~CBattleGameInterface() {};

125
lib/CGameState.cpp
View File

@ -337,7 +337,7 @@ void MetaString::addReplacement(const CStackBasicDescriptor &stack)
addCreReplacement(stack.type->idNumber, stack.count);
}
static CGObjectInstance * createObject(Obj id, int subid, int3 pos, int owner)
static CGObjectInstance * createObject(Obj id, int subid, int3 pos, PlayerColor owner)
{
CGObjectInstance * nobj;
switch(id)
@ -376,11 +376,11 @@ static CGObjectInstance * createObject(Obj id, int subid, int3 pos, int owner)
return nobj;
}
CGHeroInstance * CGameState::HeroesPool::pickHeroFor(bool native, TPlayerColor player, const CTown *town, bmap<ui32, ConstTransitivePtr<CGHeroInstance> > &available, const CHeroClass *bannedClass /*= NULL*/) const
CGHeroInstance * CGameState::HeroesPool::pickHeroFor(bool native, PlayerColor player, const CTown *town, bmap<ui32, ConstTransitivePtr<CGHeroInstance> > &available, const CHeroClass *bannedClass /*= NULL*/) const
{
CGHeroInstance *ret = NULL;
if(player>=GameConstants::PLAYER_LIMIT)
if(player>=PlayerColor::PLAYER_LIMIT)
{
tlog1 << "Cannot pick hero for " << town->typeID << ". Wrong owner!\n";
return NULL;
@ -392,7 +392,7 @@ CGHeroInstance * CGameState::HeroesPool::pickHeroFor(bool native, TPlayerColor p
{
for(auto i=available.begin(); i!=available.end(); i++)
{
if(pavailable.find(i->first)->second & 1<<player
if(pavailable.find(i->first)->second & 1<<player.getNum()
&& i->second->type->heroClass->faction == town->typeID)
{
pool.push_back(i->second); //get all available heroes
@ -400,7 +400,7 @@ CGHeroInstance * CGameState::HeroesPool::pickHeroFor(bool native, TPlayerColor p
}
if(!pool.size())
{
tlog1 << "Cannot pick native hero for " << int(player) << ". Picking any...\n";
tlog1 << "Cannot pick native hero for " << player << ". Picking any...\n";
return pickHeroFor(false, player, town, available);
}
else
@ -414,7 +414,7 @@ CGHeroInstance * CGameState::HeroesPool::pickHeroFor(bool native, TPlayerColor p
for(auto i=available.begin(); i!=available.end(); i++)
{
if ((!bannedClass && (pavailable.find(i->first)->second & (1<<player))) ||
if ((!bannedClass && (pavailable.find(i->first)->second & (1<<player.getNum()))) ||
i->second->type->heroClass != bannedClass)
{
pool.push_back(i->second);
@ -454,7 +454,7 @@ CGHeroInstance * CGameState::HeroesPool::pickHeroFor(bool native, TPlayerColor p
// //applyNL(pack);
// mx->unlock();
//}
int CGameState::pickHero(int owner)
int CGameState::pickHero(PlayerColor owner)
{
int h=-1;
const PlayerSettings &ps = scenarioOps->getIthPlayersSettings(owner);
@ -464,7 +464,7 @@ int CGameState::pickHero(int owner)
if(scenarioOps->mode == StartInfo::CAMPAIGN)
{
auto bonus = scenarioOps->campState->getBonusForCurrentMap();
if(bonus.is_initialized() && bonus->type == CScenarioTravel::STravelBonus::HERO && owner == bonus->info1)
if(bonus.is_initialized() && bonus->type == CScenarioTravel::STravelBonus::HERO && owner == PlayerColor(bonus->info1))
{
if(bonus->info2 != 0xffff && !map->getHero(bonus->info2)) //not random and not taken
{
@ -535,11 +535,11 @@ std::pair<Obj,int> CGameState::pickObject (CGObjectInstance *obj)
return std::make_pair(Obj::RESOURCE,ran()%7); //now it's OH3 style, use %8 for mithril
case Obj::RANDOM_TOWN:
{
int align = (static_cast<CGTownInstance*>(obj))->alignment,
f;
if(align>GameConstants::PLAYER_LIMIT-1)//same as owner / random
PlayerColor align = PlayerColor((static_cast<CGTownInstance*>(obj))->alignment);
ui32 f;
if(align >= PlayerColor::PLAYER_LIMIT)//same as owner / random
{
if(obj->tempOwner > GameConstants::PLAYER_LIMIT-1)
if(obj->tempOwner >= PlayerColor::PLAYER_LIMIT)
f = -1; //random
else
f = scenarioOps->getIthPlayersSettings(obj->tempOwner).castle;
@ -862,7 +862,7 @@ void CGameState::init(StartInfo * si)
tlog0 << "Create random map." << std::endl;
// Create player settings for RMG
std::map<TPlayerColor, CMapGenerator::CPlayerSettings> players;
std::map<PlayerColor, CMapGenerator::CPlayerSettings> players;
BOOST_FOREACH(auto pInfo, scenarioOps->playerInfos)
{
const PlayerSettings & startSettings = pInfo.second;
@ -890,7 +890,7 @@ void CGameState::init(StartInfo * si)
const PlayerInfo & pInfo = map->players[i];
if(pInfo.canComputerPlay || pInfo.canHumanPlay)
{
PlayerSettings & pSettings = scenarioOps->playerInfos[i];
PlayerSettings & pSettings = scenarioOps->playerInfos[PlayerColor(i)];
pSettings.compOnly = !pInfo.canHumanPlay;
pSettings.team = pInfo.team;
pSettings.castle = pInfo.defaultCastle();
@ -898,11 +898,11 @@ void CGameState::init(StartInfo * si)
{
pSettings.name = VLC->generaltexth->allTexts[468];
}
pSettings.color = i;
pSettings.color = PlayerColor(i);
}
else
{
scenarioOps->playerInfos.erase(i);
scenarioOps->playerInfos.erase(PlayerColor(i));
}
}
@ -998,8 +998,8 @@ void CGameState::init(StartInfo * si)
{
if(it->second.castle==-1)
{
int randomID = ran() % map->players[it->first].allowedFactions.size();
auto iter = map->players[it->first].allowedFactions.begin();
int randomID = ran() % map->players[it->first.getNum()].allowedFactions.size();
auto iter = map->players[it->first.getNum()].allowedFactions.begin();
std::advance(iter, randomID);
it->second.castle = *iter;
@ -1033,10 +1033,10 @@ void CGameState::init(StartInfo * si)
for(auto it = scenarioOps->playerInfos.begin();
it != scenarioOps->playerInfos.end(); ++it)
{
std::pair<TPlayerColor,PlayerState> ins(it->first,PlayerState());
std::pair<PlayerColor, PlayerState> ins(it->first,PlayerState());
ins.second.color=ins.first;
ins.second.human = it->second.playerID;
ins.second.team = map->players[ins.first].team;
ins.second.team = map->players[ins.first.getNum()].team;
teams[ins.second.team].id = ins.second.team;//init team
teams[ins.second.team].players.insert(ins.first);//add player to team
players.insert(ins);
@ -1059,7 +1059,7 @@ void CGameState::init(StartInfo * si)
for(auto it = scenarioOps->playerInfos.begin(); it != scenarioOps->playerInfos.end(); ++it)
{
const PlayerInfo &p = map->players[it->first];
const PlayerInfo &p = map->players[it->first.getNum()];
bool generateHero = (p.generateHeroAtMainTown ||
(it->second.playerID != PlayerSettings::PLAYER_AI && campaignGiveHero)) && p.hasMainTown;
if(generateHero && vstd::contains(scenarioOps->playerInfos, it->first))
@ -1272,7 +1272,7 @@ void CGameState::init(StartInfo * si)
for (ui32 i=0; i<map->heroes.size();i++) //heroes instances initialization
{
if (map->heroes[i]->getOwner()<0)
if (map->heroes[i]->getOwner() == PlayerColor::UNFLAGGABLE)
{
tlog2 << "Warning - hero with uninitialized owner!\n";
continue;
@ -1320,7 +1320,7 @@ void CGameState::init(StartInfo * si)
if (chosenBonus.is_initialized() && chosenBonus->isBonusForHero() && chosenBonus->info1 != 0xFFFE) //exclude generated heroes
{
//find human player
int humanPlayer=GameConstants::NEUTRAL_PLAYER;
PlayerColor humanPlayer=PlayerColor::NEUTRAL;
for (auto it=players.begin(); it != players.end(); ++it)
{
if(it->second.human)
@ -1329,7 +1329,7 @@ void CGameState::init(StartInfo * si)
break;
}
}
assert(humanPlayer != GameConstants::NEUTRAL_PLAYER);
assert(humanPlayer != PlayerColor::NEUTRAL);
std::vector<ConstTransitivePtr<CGHeroInstance> > & heroes = players[humanPlayer].heroes;
@ -1448,7 +1448,7 @@ void CGameState::init(StartInfo * si)
PlayerState * owner = getPlayer(map->towns[g]->getOwner());
if (owner)
{
PlayerInfo & pi = map->players[owner->color];
PlayerInfo & pi = map->players[owner->color.getNum()];
if (owner->human && //human-owned
map->towns[g]->pos == pi.posOfMainTown + int3(2, 0, 0))
@ -1558,7 +1558,7 @@ void CGameState::init(StartInfo * si)
vti->possibleSpells -= s->id;
}
vti->possibleSpells.clear();
if(vti->getOwner() != GameConstants::NEUTRAL_PLAYER)
if(vti->getOwner() != PlayerColor::NEUTRAL)
getPlayer(vti->getOwner())->towns.push_back(vti);
}
@ -1591,7 +1591,7 @@ void CGameState::init(StartInfo * si)
for(auto k=players.begin(); k!=players.end(); ++k)
{
if(k->first==GameConstants::NEUTRAL_PLAYER)
if(k->first==PlayerColor::NEUTRAL)
continue;
//init visiting and garrisoned heroes
@ -1697,7 +1697,7 @@ void CGameState::initDuel()
//c->subID = 34;
}
obj->setOwner(i);
obj->setOwner(PlayerColor(i));
for(int j = 0; j < ARRAY_COUNT(dp.sides[i].stacks); j++)
{
@ -1869,11 +1869,11 @@ UpgradeInfo CGameState::getUpgradeInfo(const CStackInstance &stack)
return ret;
}
PlayerRelations::PlayerRelations CGameState::getPlayerRelations( TPlayerColor color1, TPlayerColor color2 )
PlayerRelations::PlayerRelations CGameState::getPlayerRelations( PlayerColor color1, PlayerColor color2 )
{
if ( color1 == color2 )
return PlayerRelations::SAME_PLAYER;
if(color1 == GameConstants::NEUTRAL_PLAYER || color2 == GameConstants::NEUTRAL_PLAYER) //neutral player has no friends
if(color1 == PlayerColor::NEUTRAL || color2 == PlayerColor::NEUTRAL) //neutral player has no friends
return PlayerRelations::ENEMIES;
const TeamState * ts = getPlayerTeam(color1);
@ -2096,19 +2096,19 @@ int3 CGameState::guardingCreaturePosition (int3 pos) const
return int3(-1, -1, -1);
}
bool CGameState::isVisible(int3 pos, TPlayerColor player)
bool CGameState::isVisible(int3 pos, PlayerColor player)
{
if(player == GameConstants::NEUTRAL_PLAYER)
if(player == PlayerColor::NEUTRAL)
return false;
return getPlayerTeam(player)->fogOfWarMap[pos.x][pos.y][pos.z];
}
bool CGameState::isVisible( const CGObjectInstance *obj, boost::optional<TPlayerColor> player )
bool CGameState::isVisible( const CGObjectInstance *obj, boost::optional<PlayerColor> player )
{
if(!player)
return true;
if(*player == GameConstants::NEUTRAL_PLAYER) //-> TODO ??? needed?
if(*player == PlayerColor::NEUTRAL) //-> TODO ??? needed?
return false;
//object is visible when at least one blocked tile is visible
for(int fx=0; fx<8; ++fx)
@ -2176,7 +2176,7 @@ bool CGameState::checkForVisitableDir( const int3 & src, const TerrainTile *pom,
}
int CGameState::victoryCheck( ui8 player ) const
int CGameState::victoryCheck( PlayerColor player ) const
{
const PlayerState *p = CGameInfoCallback::getPlayer(player);
if(map->victoryCondition.condition == EVictoryConditionType::WINSTANDARD || map->victoryCondition.allowNormalVictory
@ -2251,7 +2251,7 @@ int CGameState::victoryCheck( ui8 player ) const
break;
case EVictoryConditionType::BEATHERO:
if(map->victoryCondition.obj->tempOwner >= GameConstants::PLAYER_LIMIT) //target hero not present on map
if(map->victoryCondition.obj->tempOwner >= PlayerColor::PLAYER_LIMIT) //target hero not present on map
return 1;
break;
case EVictoryConditionType::CAPTURECITY:
@ -2310,16 +2310,17 @@ int CGameState::victoryCheck( ui8 player ) const
return 0;
}
ui8 CGameState::checkForStandardWin() const
PlayerColor CGameState::checkForStandardWin() const
{
//std victory condition is:
//all enemies lost
TPlayerColor supposedWinner = 255, winnerTeam = 255;
PlayerColor supposedWinner = PlayerColor::NEUTRAL;
TeamID winnerTeam = TeamID::NO_TEAM;
for(auto i = players.begin(); i != players.end(); i++)
{
if(i->second.status == EPlayerStatus::INGAME && i->first < GameConstants::PLAYER_LIMIT)
if(i->second.status == EPlayerStatus::INGAME && i->first < PlayerColor::PLAYER_LIMIT)
{
if(supposedWinner == 255)
if(supposedWinner == PlayerColor::NEUTRAL)
{
//first player remaining ingame - candidate for victory
supposedWinner = i->second.color;
@ -2328,7 +2329,7 @@ ui8 CGameState::checkForStandardWin() const
else if(winnerTeam != i->second.team)
{
//current candidate has enemy remaining in game -> no vicotry
return 255;
return PlayerColor::NEUTRAL;
}
}
}
@ -2336,7 +2337,7 @@ ui8 CGameState::checkForStandardWin() const
return supposedWinner;
}
bool CGameState::checkForStandardLoss( TPlayerColor player ) const
bool CGameState::checkForStandardLoss( PlayerColor player ) const
{
//std loss condition is: player lost all towns and heroes
const PlayerState &p = *CGameInfoCallback::getPlayer(player);
@ -2345,15 +2346,15 @@ bool CGameState::checkForStandardLoss( TPlayerColor player ) const
struct statsHLP
{
typedef std::pair< TPlayerColor, si64 > TStat;
typedef std::pair< PlayerColor, si64 > TStat;
//converts [<player's color, value>] to vec[place] -> platers
static std::vector< std::vector< TPlayerColor > > getRank( std::vector<TStat> stats )
static std::vector< std::vector< PlayerColor > > getRank( std::vector<TStat> stats )
{
std::sort(stats.begin(), stats.end(), statsHLP());
//put first element
std::vector< std::vector<TPlayerColor> > ret;
std::vector<TPlayerColor> tmp;
std::vector< std::vector<PlayerColor> > ret;
std::vector<PlayerColor> tmp;
tmp.push_back( stats[0].first );
ret.push_back( tmp );
@ -2367,7 +2368,7 @@ struct statsHLP
else
{
//create next occupied rank
std::vector<TPlayerColor> tmp;
std::vector<PlayerColor> tmp;
tmp.push_back(stats[g].first);
ret.push_back(tmp);
}
@ -2381,7 +2382,7 @@ struct statsHLP
return a.second > b.second;
}
static const CGHeroInstance * findBestHero(CGameState * gs, int color)
static const CGHeroInstance * findBestHero(CGameState * gs, PlayerColor color)
{
std::vector<ConstTransitivePtr<CGHeroInstance> > &h = gs->players[color].heroes;
if(!h.size())
@ -2427,12 +2428,12 @@ void CGameState::obtainPlayersStats(SThievesGuildInfo & tgi, int level)
{
#define FILL_FIELD(FIELD, VAL_GETTER) \
{ \
std::vector< std::pair< TPlayerColor, si64 > > stats; \
std::vector< std::pair< PlayerColor, si64 > > stats; \
for(auto g = players.begin(); g != players.end(); ++g) \
{ \
if(g->second.color == GameConstants::NEUTRAL_PLAYER) \
if(g->second.color == PlayerColor::NEUTRAL) \
continue; \
std::pair< ui8, si64 > stat; \
std::pair< PlayerColor, si64 > stat; \
stat.first = g->second.color; \
stat.second = VAL_GETTER; \
stats.push_back(stat); \
@ -2442,7 +2443,7 @@ void CGameState::obtainPlayersStats(SThievesGuildInfo & tgi, int level)
for(auto g = players.begin(); g != players.end(); ++g)
{
if(g->second.color != GameConstants::NEUTRAL_PLAYER)
if(g->second.color != PlayerColor::NEUTRAL)
tgi.playerColors.push_back(g->second.color);
}
@ -2455,7 +2456,7 @@ void CGameState::obtainPlayersStats(SThievesGuildInfo & tgi, int level)
//best hero's portrait
for(auto g = players.cbegin(); g != players.cend(); ++g)
{
if(g->second.color == GameConstants::NEUTRAL_PLAYER)
if(g->second.color == PlayerColor::NEUTRAL)
continue;
const CGHeroInstance * best = statsHLP::findBestHero(this, g->second.color);
InfoAboutHero iah;
@ -2500,7 +2501,7 @@ void CGameState::obtainPlayersStats(SThievesGuildInfo & tgi, int level)
{
for(auto g = players.cbegin(); g != players.cend(); ++g)
{
if(g->second.color == GameConstants::NEUTRAL_PLAYER) //do nothing for neutral player
if(g->second.color == PlayerColor::NEUTRAL) //do nothing for neutral player
continue;
if(g->second.human)
{
@ -2508,7 +2509,7 @@ void CGameState::obtainPlayersStats(SThievesGuildInfo & tgi, int level)
}
else //AI
{
tgi.personality[g->second.color] = map->players[g->second.color].aiTactic;
tgi.personality[g->second.color] = map->players[g->second.color.getNum()].aiTactic;
}
}
@ -2518,7 +2519,7 @@ void CGameState::obtainPlayersStats(SThievesGuildInfo & tgi, int level)
//best creatures belonging to player (highest AI value)
for(auto g = players.cbegin(); g != players.cend(); ++g)
{
if(g->second.color == GameConstants::NEUTRAL_PLAYER) //do nothing for neutral player
if(g->second.color == PlayerColor::NEUTRAL) //do nothing for neutral player
continue;
int bestCre = -1; //best creature's ID
for(int b=0; b<g->second.heroes.size(); ++b)
@ -2539,7 +2540,7 @@ void CGameState::obtainPlayersStats(SThievesGuildInfo & tgi, int level)
#undef FILL_FIELD
}
int CGameState::lossCheck( TPlayerColor player ) const
int CGameState::lossCheck( PlayerColor player ) const
{
const PlayerState *p = CGameInfoCallback::getPlayer(player);
//if(map->lossCondition.typeOfLossCon == lossStandard)
@ -2614,7 +2615,7 @@ void CGameState::buildGlobalTeamPlayerTree()
TeamState *t = &k->second;
t->attachTo(&globalEffects);
BOOST_FOREACH(ui8 teamMember, k->second.players)
BOOST_FOREACH(PlayerColor teamMember, k->second.players)
{
PlayerState *p = getPlayer(teamMember);
assert(p);
@ -2732,7 +2733,7 @@ PlayerState::PlayerState()
std::string PlayerState::nodeName() const
{
return "Player " + (color < VLC->generaltexth->capColors.size() ? VLC->generaltexth->capColors[color] : boost::lexical_cast<std::string>(color));
return "Player " + (color.getNum() < VLC->generaltexth->capColors.size() ? VLC->generaltexth->capColors[color.getNum()] : boost::lexical_cast<std::string>(color));
}
// void PlayerState::getParents(TCNodes &out, const CBonusSystemNode *root /*= NULL*/) const
@ -2750,7 +2751,7 @@ std::string PlayerState::nodeName() const
// }
InfoAboutArmy::InfoAboutArmy():
owner(GameConstants::NEUTRAL_PLAYER)
owner(PlayerColor::NEUTRAL)
{}
InfoAboutArmy::InfoAboutArmy(const CArmedInstance *Army, bool detailed)
@ -3220,7 +3221,7 @@ CGPathNode::EAccessibility CPathfinder::evaluateAccessibility(const TerrainTile
{
BOOST_FOREACH(const CGObjectInstance *obj, tinfo->visitableObjects)
{
if(obj->getPassableness() & 1<<hero->tempOwner) //special object instance specific passableness flag - overwrites other accessibility flags
if(obj->getPassableness() & 1<<hero->tempOwner.getNum()) //special object instance specific passableness flag - overwrites other accessibility flags
{
ret = CGPathNode::ACCESSIBLE;
}
@ -3276,7 +3277,7 @@ bool CPathfinder::goodForLandSeaTransition()
return true;
}
CPathfinder::CPathfinder(CPathsInfo &_out, CGameState *_gs, const CGHeroInstance *_hero) : CGameInfoCallback(_gs, boost::optional<TPlayerColor>()), out(_out), hero(_hero), FoW(getPlayerTeam(hero->tempOwner)->fogOfWarMap)
CPathfinder::CPathfinder(CPathsInfo &_out, CGameState *_gs, const CGHeroInstance *_hero) : CGameInfoCallback(_gs, boost::optional<PlayerColor>()), out(_out), hero(_hero), FoW(getPlayerTeam(hero->tempOwner)->fogOfWarMap)
{
useSubterraneanGates = true;
allowEmbarkAndDisembark = true;

44
lib/CGameState.h
View File

@ -80,7 +80,7 @@ struct ArmyDescriptor : public std::map<SlotID, CStackBasicDescriptor>
struct DLL_LINKAGE InfoAboutArmy
{
ui8 owner;
PlayerColor owner;
std::string name;
ArmyDescriptor army;
@ -143,14 +143,14 @@ struct DLL_LINKAGE InfoAboutTown : public InfoAboutArmy
struct DLL_LINKAGE SThievesGuildInfo
{
std::vector<TPlayerColor> playerColors; //colors of players that are in-game
std::vector<PlayerColor> playerColors; //colors of players that are in-game
std::vector< std::vector< TPlayerColor > > numOfTowns, numOfHeroes, gold, woodOre, mercSulfCrystGems, obelisks, artifacts, army, income; // [place] -> [colours of players]
std::vector< std::vector< PlayerColor > > numOfTowns, numOfHeroes, gold, woodOre, mercSulfCrystGems, obelisks, artifacts, army, income; // [place] -> [colours of players]
std::map<TPlayerColor, InfoAboutHero> colorToBestHero; //maps player's color to his best heros'
std::map<PlayerColor, InfoAboutHero> colorToBestHero; //maps player's color to his best heros'
std::map<TPlayerColor, EAiTactic::EAiTactic> personality; // color to personality // ai tactic
std::map<TPlayerColor, si32> bestCreature; // color to ID // id or -1 if not known
std::map<PlayerColor, EAiTactic::EAiTactic> personality; // color to personality // ai tactic
std::map<PlayerColor, si32> bestCreature; // color to ID // id or -1 if not known
// template <typename Handler> void serialize(Handler &h, const int version)
// {
@ -163,10 +163,10 @@ struct DLL_LINKAGE SThievesGuildInfo
struct DLL_LINKAGE PlayerState : public CBonusSystemNode
{
public:
TPlayerColor color;
PlayerColor color;
bool human; //true if human controlled player, false for AI
ObjectInstanceID currentSelection; //id of hero/town, 0xffffffff if none
ui8 team;
TeamID team;
TResources resources;
std::vector<ConstTransitivePtr<CGHeroInstance> > heroes;
std::vector<ConstTransitivePtr<CGTownInstance> > towns;
@ -199,8 +199,8 @@ public:
struct DLL_LINKAGE TeamState : public CBonusSystemNode
{
public:
ui8 id; //position in gameState::teams
std::set<TPlayerColor> players; // members of this team
TeamID id; //position in gameState::teams
std::set<PlayerColor> players; // members of this team
std::vector<std::vector<std::vector<ui8> > > fogOfWarMap; //true - visible, false - hidden
TeamState();
@ -364,12 +364,12 @@ class DLL_LINKAGE CGameState : public CNonConstInfoCallback
{
public:
ConstTransitivePtr<StartInfo> scenarioOps, initialOpts; //second one is a copy of settings received from pregame (not randomized)
TPlayerColor currentPlayer; //ID of player currently having turn
PlayerColor currentPlayer; //ID of player currently having turn
ConstTransitivePtr<BattleInfo> curB; //current battle
ui32 day; //total number of days in game
ConstTransitivePtr<CMap> map;
bmap<TPlayerColor, PlayerState> players;
bmap<TPlayerColor, TeamState> teams;
bmap<PlayerColor, PlayerState> players;
bmap<TeamID, TeamState> teams;
CBonusSystemNode globalEffects;
bmap<const CGHeroInstance*, const CGObjectInstance*> ongoingVisits;
@ -378,7 +378,7 @@ public:
bmap<ui32, ConstTransitivePtr<CGHeroInstance> > heroesPool; //[subID] - heroes available to buy; NULL if not available
bmap<ui32,ui8> pavailable; // [subid] -> which players can recruit hero (binary flags)
CGHeroInstance * pickHeroFor(bool native, TPlayerColor player, const CTown *town, bmap<ui32, ConstTransitivePtr<CGHeroInstance> > &available, const CHeroClass *bannedClass = NULL) const;
CGHeroInstance * pickHeroFor(bool native, PlayerColor player, const CTown *town, bmap<ui32, ConstTransitivePtr<CGHeroInstance> > &available, const CHeroClass *bannedClass = NULL) const;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -393,22 +393,22 @@ public:
void initDuel();
void randomizeObject(CGObjectInstance *cur);
std::pair<Obj,int> pickObject(CGObjectInstance *obj); //chooses type of object to be randomized, returns <type, subtype>
int pickHero(int owner);
int pickHero(PlayerColor owner);
void giveHeroArtifact(CGHeroInstance *h, ArtifactID aid);
void apply(CPack *pack);
BFieldType battleGetBattlefieldType(int3 tile) const;
UpgradeInfo getUpgradeInfo(const CStackInstance &stack);
PlayerRelations::PlayerRelations getPlayerRelations(TPlayerColor color1, TPlayerColor color2);
PlayerRelations::PlayerRelations getPlayerRelations(PlayerColor color1, PlayerColor color2);
bool checkForVisitableDir(const int3 & src, const int3 & dst) const; //check if src tile is visitable from dst tile
bool checkForVisitableDir(const int3 & src, const TerrainTile *pom, const int3 & dst) const; //check if src tile is visitable from dst tile
void calculatePaths(const CGHeroInstance *hero, CPathsInfo &out, int3 src = int3(-1,-1,-1), int movement = -1); //calculates possible paths for hero, by default uses current hero position and movement left; returns pointer to newly allocated CPath or NULL if path does not exists
int3 guardingCreaturePosition (int3 pos) const;
std::vector<CGObjectInstance*> guardingCreatures (int3 pos) const;
int victoryCheck(TPlayerColor player) const; //checks if given player is winner; -1 if std victory, 1 if special victory, 0 else
int lossCheck(TPlayerColor player) const; //checks if given player is loser; -1 if std loss, 1 if special, 0 else
ui8 checkForStandardWin() const; //returns color of player that accomplished standard victory conditions or 255 if no winner
bool checkForStandardLoss(TPlayerColor player) const; //checks if given player lost the game
int victoryCheck(PlayerColor player) const; //checks if given player is winner; -1 if std victory, 1 if special victory, 0 else
int lossCheck(PlayerColor player) const; //checks if given player is loser; -1 if std loss, 1 if special, 0 else
PlayerColor checkForStandardWin() const; //returns color of player that accomplished standard victory conditions or 255 (NEUTRAL) if no winner
bool checkForStandardLoss(PlayerColor player) const; //checks if given player lost the game
void obtainPlayersStats(SThievesGuildInfo & tgi, int level); //fills tgi with info about other players that is available at given level of thieves' guild
bmap<ui32, ConstTransitivePtr<CGHeroInstance> > unusedHeroesFromPool(); //heroes pool without heroes that are available in taverns
BattleInfo * setupBattle(int3 tile, const CArmedInstance *armies[2], const CGHeroInstance * heroes[2], bool creatureBank, const CGTownInstance *town);
@ -418,8 +418,8 @@ public:
void buildGlobalTeamPlayerTree();
void deserializationFix();
bool isVisible(int3 pos, TPlayerColor player);
bool isVisible(const CGObjectInstance *obj, boost::optional<TPlayerColor> player);
bool isVisible(int3 pos, PlayerColor player);
bool isVisible(const CGObjectInstance *obj, boost::optional<PlayerColor> player);
CGameState(); //c-tor
virtual ~CGameState(); //d-tor

150
lib/CObjectHandler.cpp
View File

@ -43,10 +43,10 @@ std::map<Obj, std::map<int, std::vector<ObjectInstanceID> > > CGTeleport::objs;
std::vector<std::pair<ObjectInstanceID, ObjectInstanceID> > CGTeleport::gates;
IGameCallback * IObjectInterface::cb = NULL;
extern boost::rand48 ran;
std::map <TPlayerColor, std::set <ui8> > CGKeys::playerKeyMap;
std::map <PlayerColor, std::set <ui8> > CGKeys::playerKeyMap;
std::map <si32, std::vector<ObjectInstanceID> > CGMagi::eyelist;
ui8 CGObelisk::obeliskCount; //how many obelisks are on map
std::map<TTeamID, ui8> CGObelisk::visited; //map: team_id => how many obelisks has been visited
std::map<TeamID, ui8> CGObelisk::visited; //map: team_id => how many obelisks has been visited
std::vector<const CArtifact *> CGTownInstance::merchantArtifacts;
std::vector<int> CGTownInstance::universitySkills;
@ -61,7 +61,7 @@ static void openWindow(const OpenWindow::EWindow type, const int id1, const int
IObjectInterface::cb->sendAndApply(&ow);
}
static void showInfoDialog(const TPlayerColor playerID, const ui32 txtID, const ui16 soundID)
static void showInfoDialog(const PlayerColor playerID, const ui32 txtID, const ui16 soundID)
{
InfoWindow iw;
iw.soundID = soundID;
@ -72,13 +72,13 @@ static void showInfoDialog(const TPlayerColor playerID, const ui32 txtID, const
static void showInfoDialog(const ObjectInstanceID heroID, const ui32 txtID, const ui16 soundID)
{
const TPlayerColor playerID = IObjectInterface::cb->getOwner(heroID);
const PlayerColor playerID = IObjectInterface::cb->getOwner(heroID);
showInfoDialog(playerID,txtID,soundID);
}
static void showInfoDialog(const CGHeroInstance* h, const ui32 txtID, const ui16 soundID)
{
const TPlayerColor playerID = h->getOwner();
const PlayerColor playerID = h->getOwner();
showInfoDialog(playerID,txtID,soundID);
}
@ -110,7 +110,7 @@ void IObjectInterface::initObj()
void IObjectInterface::setProperty( ui8 what, ui32 val )
{}
bool IObjectInterface::wasVisited (ui8 player) const
bool IObjectInterface::wasVisited (PlayerColor player) const
{
return false;
}
@ -128,14 +128,24 @@ void IObjectInterface::preInit()
void CPlayersVisited::setPropertyDer( ui8 what, ui32 val )
{
if(what == 10)
players.insert((ui8)val);
players.insert(PlayerColor(val));
}
bool CPlayersVisited::wasVisited( TPlayerColor player ) const
bool CPlayersVisited::wasVisited( PlayerColor player ) const
{
return vstd::contains(players,player);
}
bool CPlayersVisited::wasVisited( TeamID team ) const
{
BOOST_FOREACH(auto i, players)
{
if(cb->getPlayer(i)->team == team)
return true;
}
return false;
}
// Bank helper. Find the creature ID and their number, and store the
// result in storage (either guards or reward creatures).
static void readCreatures(const JsonNode &creature, std::vector< std::pair <CreatureID, ui32> > &storage)
@ -249,7 +259,7 @@ int CObjectHandler::bankObjToIndex (const CGObjectInstance * obj)
return 0;
}
}
int CGObjectInstance::getOwner() const
PlayerColor CGObjectInstance::getOwner() const
{
//if (state)
// return state->owner;
@ -265,7 +275,7 @@ CGObjectInstance::CGObjectInstance()
ID = Obj::NO_OBJ;
subID = -1;
defInfo = NULL;
tempOwner = 254;
tempOwner = PlayerColor::UNFLAGGABLE;
blockVisit = false;
}
CGObjectInstance::~CGObjectInstance()
@ -280,7 +290,7 @@ const std::string & CGObjectInstance::getHoverText() const
{
return hoverName;
}
void CGObjectInstance::setOwner(int ow)
void CGObjectInstance::setOwner(PlayerColor ow)
{
//if (state)
// state->owner = ow;
@ -399,7 +409,7 @@ void CGObjectInstance::setProperty( ui8 what, ui32 val )
switch(what)
{
case ObjProperty::OWNER:
tempOwner = val;
tempOwner = PlayerColor(val);
break;
case ObjProperty::BLOCKVIS:
blockVisit = val;
@ -435,7 +445,7 @@ void CGObjectInstance::getSightTiles(boost::unordered_set<int3, ShashInt3> &tile
{
cb->getTilesInRange(tiles, getSightCenter(), getSightRadious(), tempOwner, 1);
}
void CGObjectInstance::hideTiles(TPlayerColor ourplayer, int radius) const
void CGObjectInstance::hideTiles(PlayerColor ourplayer, int radius) const
{
for (auto i = cb->gameState()->teams.begin(); i != cb->gameState()->teams.end(); i++)
{
@ -1603,7 +1613,7 @@ void CGDwelling::initObj()
hoverName = VLC->generaltexth->creGens[subID];
if(crs->level > 4)
putStack(SlotID(0), new CStackInstance(crs, (crs->growth) * 3));
if (getOwner() != GameConstants::NEUTRAL_PLAYER)
if (getOwner() != PlayerColor::NEUTRAL)
cb->gameState()->players[getOwner()].dwellings.push_back (this);
}
break;
@ -1660,13 +1670,13 @@ void CGDwelling::setProperty(ui8 what, ui32 val)
case ObjProperty::OWNER: //change owner
if (ID == Obj::CREATURE_GENERATOR1) //single generators
{
if (tempOwner != GameConstants::NEUTRAL_PLAYER)
if (tempOwner != PlayerColor::NEUTRAL)
{
std::vector<ConstTransitivePtr<CGDwelling> >* dwellings = &cb->gameState()->players[tempOwner].dwellings;
dwellings->erase (std::find(dwellings->begin(), dwellings->end(), this));
}
if (val != GameConstants::NEUTRAL_PLAYER) //can new owner be neutral?
cb->gameState()->players[val].dwellings.push_back (this);
if (PlayerColor(val) != PlayerColor::NEUTRAL) //can new owner be neutral?
cb->gameState()->players[PlayerColor(val)].dwellings.push_back (this);
}
break;
case ObjProperty::AVAILABLE_CREATURE:
@ -2154,7 +2164,7 @@ void CGTownInstance::newTurn() const
{
//give resources for Rampart, Mystic Pond
if (hasBuilt(BuildingID::MYSTIC_POND, ETownType::RAMPART)
&& cb->getDate(Date::DAY) != 1 && (tempOwner < GameConstants::PLAYER_LIMIT))
&& cb->getDate(Date::DAY) != 1 && (tempOwner < PlayerColor::PLAYER_LIMIT))
{
int resID = rand()%4+2;//bonus to random rare resource
resID = (resID==2)?1:resID;
@ -2171,7 +2181,7 @@ void CGTownInstance::newTurn() const
cb->setObjProperty (id, ObjProperty::STRUCTURE_CLEAR_VISITORS, (*i)->id); //reset visitors for Mana Vortex
}
if (tempOwner == GameConstants::NEUTRAL_PLAYER) //garrison growth for neutral towns
if (tempOwner == PlayerColor::NEUTRAL) //garrison growth for neutral towns
{
std::vector<SlotID> nativeCrits; //slots
for (TSlots::const_iterator it = Slots().begin(); it != Slots().end(); it++)
@ -2231,13 +2241,13 @@ ui8 CGTownInstance::getPassableness() const
{
if (!armedGarrison())//empty castle - anyone can visit
return GameConstants::ALL_PLAYERS;
if ( tempOwner == GameConstants::NEUTRAL_PLAYER )//neutral guarded - no one can visit
if ( tempOwner == PlayerColor::NEUTRAL )//neutral guarded - no one can visit
return 0;
ui8 mask = 0;
TeamState * ts = cb->gameState()->getPlayerTeam(tempOwner);
BOOST_FOREACH(ui8 it, ts->players)
mask |= 1<<it;//allies - add to possible visitors
BOOST_FOREACH(PlayerColor it, ts->players)
mask |= 1<<it.getNum();//allies - add to possible visitors
return mask;
}
@ -2261,12 +2271,12 @@ void CGTownInstance::fightOver( const CGHeroInstance *h, BattleResult *result )
}
}
void CGTownInstance::removeCapitols (ui8 owner) const
void CGTownInstance::removeCapitols (PlayerColor owner) const
{
if (hasCapitol()) // search if there's an older capitol
{
PlayerState* state = cb->gameState()->getPlayer (owner); //get all towns owned by player
for (std::vector<ConstTransitivePtr<CGTownInstance> >::const_iterator i = state->towns.begin(); i < state->towns.end(); ++i)
for (auto i = state->towns.cbegin(); i < state->towns.cend(); ++i)
{
if (*i != this && (*i)->hasCapitol())
{
@ -3407,7 +3417,7 @@ void CGMine::newTurn() const
if(cb->getDate() == 1)
return;
if (tempOwner == GameConstants::NEUTRAL_PLAYER)
if (tempOwner == PlayerColor::NEUTRAL)
return;
cb->giveResource(tempOwner, producedResource, producedQuantity);
@ -3424,13 +3434,13 @@ void CGMine::initObj()
//after map reading tempOwner placeholds bitmask for allowed resources
std::vector<Res::ERes> possibleResources;
for (int i = 0; i < GameConstants::PLAYER_LIMIT; i++)
if(tempOwner & 1<<i)
for (int i = 0; i < PlayerColor::PLAYER_LIMIT_I; i++)
if(tempOwner.getNum() & 1<<i) //NOTE: reuse of tempOwner
possibleResources.push_back(static_cast<Res::ERes>(i));
assert(possibleResources.size());
producedResource = possibleResources[ran()%possibleResources.size()];
tempOwner = GameConstants::NEUTRAL_PLAYER;
tempOwner = PlayerColor::NEUTRAL;
hoverName = VLC->generaltexth->mines[7].first + "\n" + VLC->generaltexth->allTexts[202] + " " + troglodytes->getQuantityTXT(false) + " " + troglodytes->type->namePl;
}
else
@ -3439,10 +3449,10 @@ void CGMine::initObj()
MetaString ms;
ms << std::pair<ui8,ui32>(9,producedResource);
if(tempOwner >= GameConstants::PLAYER_LIMIT)
tempOwner = GameConstants::NEUTRAL_PLAYER;
if(tempOwner >= PlayerColor::PLAYER_LIMIT)
tempOwner = PlayerColor::NEUTRAL;
else
ms << " (" << std::pair<ui8,ui32>(6,23+tempOwner) << ")";
ms << " (" << std::pair<ui8,ui32>(6,23+tempOwner.getNum()) << ")";
ms.toString(hoverName);
}
@ -3454,7 +3464,7 @@ void CGMine::fight(ui32 agreed, const CGHeroInstance *h) const
cb->startBattleI(h, this, boost::bind(&CGMine::endBattle, this, _1, h->tempOwner));
}
void CGMine::endBattle(BattleResult *result, TPlayerColor attackingPlayer) const
void CGMine::endBattle(BattleResult *result, PlayerColor attackingPlayer) const
{
if(result->winner == 0) //attacker won
{
@ -3466,13 +3476,13 @@ void CGMine::endBattle(BattleResult *result, TPlayerColor attackingPlayer) const
}
}
void CGMine::flagMine(TPlayerColor player) const
void CGMine::flagMine(PlayerColor player) const
{
assert(tempOwner != player);
cb->setOwner(this, player); //not ours? flag it!
MetaString ms;
ms << std::pair<ui8,ui32>(9,subID) << "\n(" << std::pair<ui8,ui32>(6,23+player) << ")";
ms << std::pair<ui8,ui32>(9,subID) << "\n(" << std::pair<ui8,ui32>(6,23+player.getNum()) << ")";
if(subID == 7)
{
ms << "(%s)";
@ -3553,7 +3563,7 @@ void CGResource::onHeroVisit( const CGHeroInstance * h ) const
}
}
void CGResource::collectRes( int player ) const
void CGResource::collectRes( PlayerColor player ) const
{
cb->giveResource(player, static_cast<Res::ERes>(subID), amount);
ShowInInfobox sii;
@ -3587,7 +3597,7 @@ void CGVisitableOPW::newTurn() const
cb->setHoverName(this,&ms);
}
}
bool CGVisitableOPW::wasVisited(TPlayerColor player) const
bool CGVisitableOPW::wasVisited(PlayerColor player) const
{
return visited; //TODO: other players should see object as unvisited
}
@ -4184,7 +4194,7 @@ bool CQuest::checkQuest (const CGHeroInstance * h) const
return true;
return false;
case MISSION_PLAYER:
if (m13489val == h->getOwner())
if (m13489val == h->getOwner().getNum())
return true;
return false;
default:
@ -4822,9 +4832,9 @@ void CGWitchHut::onHeroVisit( const CGHeroInstance * h ) const
iw.soundID = soundBase::gazebo;
iw.player = h->getOwner();
if(!wasVisited(h->tempOwner))
cb->setObjProperty(id,10,h->tempOwner);
cb->setObjProperty(id, 10, h->tempOwner.getNum());
ui32 txt_id;
if(h->getSecSkillLevel(SecondarySkill(ability))) //you alredy know this skill
if(h->getSecSkillLevel(SecondarySkill(ability))) //you already know this skill
{
txt_id =172;
}
@ -5403,7 +5413,7 @@ void CGPandoraBox::getText( InfoWindow &iw, bool &afterBattle, int val, int nega
void CGEvent::onHeroVisit( const CGHeroInstance * h ) const
{
if(!(availableFor & (1 << h->tempOwner)))
if(!(availableFor & (1 << h->tempOwner.getNum())))
return;
if(cb->getPlayerSettings(h->tempOwner)->playerID)
{
@ -5471,7 +5481,7 @@ void CGShrine::onHeroVisit( const CGHeroInstance * h ) const
}
if(!wasVisited(h->tempOwner))
cb->setObjProperty(id,10,h->tempOwner);
cb->setObjProperty(id, 10, h->tempOwner.getNum());
InfoWindow iw;
iw.soundID = soundBase::temple;
@ -5666,13 +5676,13 @@ ui8 CGGarrison::getPassableness() const
{
if ( !stacksCount() )//empty - anyone can visit
return GameConstants::ALL_PLAYERS;
if ( tempOwner == GameConstants::NEUTRAL_PLAYER )//neutral guarded - no one can visit
if ( tempOwner == PlayerColor::NEUTRAL )//neutral guarded - no one can visit
return 0;
ui8 mask = 0;
TeamState * ts = cb->gameState()->getPlayerTeam(tempOwner);
BOOST_FOREACH(ui8 it, ts->players)
mask |= 1<<it;//allies - add to possible visitors
BOOST_FOREACH(PlayerColor it, ts->players)
mask |= 1<<it.getNum(); //allies - add to possible visitors
return mask;
}
@ -5758,7 +5768,7 @@ void CGOnceVisitable::onHeroVisit( const CGHeroInstance * h ) const
}
cb->showInfoDialog(&iw);
cb->setObjProperty(id,10,h->getOwner());
cb->setObjProperty(id, 10, h->getOwner().getNum());
}
const std::string & CGOnceVisitable::getHoverText() const
@ -5867,7 +5877,7 @@ void CGOnceVisitable::searchTomb(const CGHeroInstance *h, ui32 accept) const
cb->giveHeroBonus(&gb);
}
cb->showInfoDialog(&iw);
cb->setObjProperty(id,10,h->getOwner());
cb->setObjProperty(id, 10, h->getOwner().getNum());
}
}
@ -6022,7 +6032,7 @@ void CBank::newTurn() const
cb->setObjProperty (id, ObjProperty::BANK_DAYCOUNTER, 1); //daycounter++
}
}
bool CBank::wasVisited (TPlayerColor player) const
bool CBank::wasVisited (PlayerColor player) const
{
return !bc;
}
@ -6289,11 +6299,11 @@ void CGPyramid::endBattle (const CGHeroInstance *h, const BattleResult *result)
}
void CGKeys::setPropertyDer (ui8 what, ui32 val) //101-108 - enable key for player 1-8
{
if (what >= 101 && what <= (100 + GameConstants::PLAYER_LIMIT))
playerKeyMap.find(what-101)->second.insert((ui8)val);
if (what >= 101 && what <= (100 + PlayerColor::PLAYER_LIMIT_I))
playerKeyMap.find(PlayerColor(what-101))->second.insert((ui8)val);
}
bool CGKeys::wasMyColorVisited (TPlayerColor player) const
bool CGKeys::wasMyColorVisited (PlayerColor player) const
{
if (vstd::contains(playerKeyMap[player], subID)) //creates set if it's not there
return true;
@ -6316,7 +6326,7 @@ const std::string CGKeys::getName() const
return name;
}
bool CGKeymasterTent::wasVisited (TPlayerColor player) const
bool CGKeymasterTent::wasVisited (PlayerColor player) const
{
return wasMyColorVisited (player);
}
@ -6326,7 +6336,7 @@ void CGKeymasterTent::onHeroVisit( const CGHeroInstance * h ) const
int txt_id;
if (!wasMyColorVisited (h->getOwner()) )
{
cb->setObjProperty(id, h->tempOwner+101, subID);
cb->setObjProperty(id, h->tempOwner.getNum()+101, subID);
txt_id=19;
}
else
@ -6400,8 +6410,8 @@ void CGBorderGate::onHeroVisit( const CGHeroInstance * h ) const //TODO: passabi
ui8 CGBorderGate::getPassableness() const
{
ui8 ret = 0;
for (int i = 0; i < GameConstants::PLAYER_LIMIT; i++)
ret |= wasMyColorVisited(i)<<i;
for (int i = 0; i < PlayerColor::PLAYER_LIMIT_I; i++)
ret |= wasMyColorVisited(PlayerColor(i))<<i;
return ret;
}
@ -6699,7 +6709,7 @@ void CCartographer::buyMap (const CGHeroInstance *h, ui32 accept) const
//water = 0; land = 1; underground = 2;
cb->getAllTiles (fw.tiles, h->tempOwner, subID - 1, !subID + 1); //reveal appropriate tiles
cb->sendAndApply (&fw);
cb->setObjProperty (id, 10, h->tempOwner);
cb->setObjProperty (id, 10, h->tempOwner.getNum());
}
}
@ -6714,18 +6724,18 @@ void CGObelisk::onHeroVisit( const CGHeroInstance * h ) const
iw.player = h->tempOwner;
TeamState *ts = cb->gameState()->getPlayerTeam(h->tempOwner);
assert(ts);
int team = ts->id;
TeamID team = ts->id;
if(!wasVisited(team))
{
iw.text.addTxt(MetaString::ADVOB_TXT, 96);
cb->sendAndApply(&iw);
cb->setObjProperty(id,20,team); //increment general visited obelisks counter
cb->setObjProperty(id, 20, h->tempOwner.getNum()); //increment general visited obelisks counter
openWindow(OpenWindow::PUZZLE_MAP,h->tempOwner);
openWindow(OpenWindow::PUZZLE_MAP, h->tempOwner.getNum());
cb->setObjProperty(id,10,team); //mark that particular obelisk as visited
cb->setObjProperty(id, 10, h->tempOwner.getNum()); //mark that particular obelisk as visited
}
else
{
@ -6753,12 +6763,12 @@ void CGObelisk::setPropertyDer( ui8 what, ui32 val )
switch(what)
{
case 20:
assert(val < GameConstants::PLAYER_LIMIT);
visited[val]++;
assert(val < PlayerColor::PLAYER_LIMIT_I);
visited[TeamID(val)]++;
if(visited[val] > obeliskCount)
if(visited[TeamID(val)] > obeliskCount)
{
tlog0 << "Error: Visited " << visited[val] << "\t\t" << obeliskCount << std::endl;
tlog0 << "Error: Visited " << visited[TeamID(val)] << "\t\t" << obeliskCount << std::endl;
assert(0);
}
@ -6770,15 +6780,15 @@ void CGLighthouse::onHeroVisit( const CGHeroInstance * h ) const
{
if(h->tempOwner != tempOwner)
{
ui8 oldOwner = tempOwner;
PlayerColor oldOwner = tempOwner;
cb->setOwner(this,h->tempOwner); //not ours? flag it!
showInfoDialog(h,69,soundBase::LIGHTHOUSE);
giveBonusTo(h->tempOwner);
if(oldOwner < GameConstants::PLAYER_LIMIT) //remove bonus from old owner
if(oldOwner < PlayerColor::PLAYER_LIMIT) //remove bonus from old owner
{
RemoveBonus rb(RemoveBonus::PLAYER);
rb.whoID = oldOwner;
rb.whoID = oldOwner.getNum();
rb.source = Bonus::OBJECT;
rb.id = id.getNum();
cb->sendAndApply(&rb);
@ -6788,7 +6798,7 @@ void CGLighthouse::onHeroVisit( const CGHeroInstance * h ) const
void CGLighthouse::initObj()
{
if(tempOwner < GameConstants::PLAYER_LIMIT)
if(tempOwner < PlayerColor::PLAYER_LIMIT)
{
giveBonusTo(tempOwner);
}
@ -6801,12 +6811,12 @@ const std::string & CGLighthouse::getHoverText() const
return hoverName;
}
void CGLighthouse::giveBonusTo( ui8 player ) const
void CGLighthouse::giveBonusTo( PlayerColor player ) const
{
GiveBonus gb(GiveBonus::PLAYER);
gb.bonus.type = Bonus::SEA_MOVEMENT;
gb.bonus.val = 500;
gb.id = player;
gb.id = player.getNum();
gb.bonus.duration = Bonus::PERMANENT;
gb.bonus.source = Bonus::OBJECT;
gb.bonus.sid = id.getNum();
@ -6917,7 +6927,7 @@ void CArmedInstance::armyChanged()
CBonusSystemNode * CArmedInstance::whereShouldBeAttached(CGameState *gs)
{
if(tempOwner < GameConstants::PLAYER_LIMIT)
if(tempOwner < PlayerColor::PLAYER_LIMIT)
return gs->getPlayer(tempOwner);
else
return &gs->globalEffects;

41
lib/CObjectHandler.h
View File

@ -114,11 +114,11 @@ public:
virtual void initObj(); //synchr
virtual void setProperty(ui8 what, ui32 val);//synchr
//unified interface, AI helpers
virtual bool wasVisited (ui8 player) const;
virtual bool wasVisited (PlayerColor player) const;
virtual bool wasVisited (const CGHeroInstance * h) const;
static void preInit(); //called before objs receive their initObj
static void postInit();//caleed after objs receive their initObj
static void postInit();//called after objs receive their initObj
};
class DLL_LINKAGE IBoatGenerator
@ -173,15 +173,15 @@ public:
ObjectInstanceID id;//number of object in map's vector
CGDefInfo * defInfo;
TPlayerColor tempOwner;
PlayerColor tempOwner;
bool blockVisit; //if non-zero then blocks the tile but is visitable from neighbouring tile
virtual ui8 getPassableness() const; //bitmap - if the bit is set the corresponding player can pass through the visitable tiles of object, even if it's blockvis; if not set - default properties from definfo are used
virtual int3 getSightCenter() const; //"center" tile from which the sight distance is calculated
virtual int getSightRadious() const; //sight distance (should be used if player-owned structure)
void getSightTiles(boost::unordered_set<int3, ShashInt3> &tiles) const; //returns reference to the set
int getOwner() const;
void setOwner(int ow);
PlayerColor getOwner() const;
void setOwner(PlayerColor ow);
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 object is visitable at location (x, y) form left top tile of image (x, y in tiles)
@ -193,7 +193,7 @@ public:
std::set<int3> getBlockedPos() const; //returns set of positions blocked by this object
bool isVisitable() const; //returns true if object is visitable
bool operator<(const CGObjectInstance & cmp) const; //screen printing priority comparing
void hideTiles(TPlayerColor ourplayer, int radius) const;
void hideTiles(PlayerColor ourplayer, int radius) const;
CGObjectInstance();
virtual ~CGObjectInstance();
//CGObjectInstance(const CGObjectInstance & right);
@ -235,9 +235,10 @@ public:
class DLL_LINKAGE CPlayersVisited: public CGObjectInstance
{
public:
std::set<TPlayerColor> players; //players that visited this object
std::set<PlayerColor> players; //players that visited this object
bool wasVisited(TPlayerColor player) const;
bool wasVisited(PlayerColor player) const;
bool wasVisited(TeamID team) const;
void setPropertyDer(ui8 what, ui32 val) override;
template <typename Handler> void serialize(Handler &h, const int version)
@ -435,7 +436,7 @@ class DLL_LINKAGE CSpecObjInfo
{
public:
virtual ~CSpecObjInfo(){};
ui8 player; //owner
PlayerColor player; //owner
};
class DLL_LINKAGE CCreGenAsCastleInfo : public virtual CSpecObjInfo
@ -654,7 +655,7 @@ public:
int spellsAtLevel(int level, bool checkGuild) const; //levels are counted from 1 (1 - 5)
bool armedGarrison() const; //true if town has creatures in garrison or garrisoned hero
void removeCapitols (ui8 owner) const;
void removeCapitols (PlayerColor owner) const;
void addHeroToStructureVisitors(const CGHeroInstance *h, si32 structureInstanceID) const; //hero must be visiting or garrisoned in town
CGTownInstance();
@ -928,7 +929,7 @@ public:
void onHeroVisit(const CGHeroInstance * h) const override;
void initObj() override;
void collectRes(int player) const;
void collectRes(PlayerColor player) const;
void fightForRes(ui32 agreed, const CGHeroInstance *h) const;
void endBattle(BattleResult *result, const CGHeroInstance *h) const;
@ -977,12 +978,12 @@ public:
ui32 producedQuantity;
void offerLeavingGuards(const CGHeroInstance *h) const;
void endBattle(BattleResult *result, TPlayerColor attackingPlayer) const;
void endBattle(BattleResult *result, PlayerColor attackingPlayer) const;
void fight(ui32 agreed, const CGHeroInstance *h) const;
void onHeroVisit(const CGHeroInstance * h) const override;
void flagMine(TPlayerColor player) const;
void flagMine(PlayerColor player) const;
void newTurn() const override;
void initObj() override;
template <typename Handler> void serialize(Handler &h, const int version)
@ -998,7 +999,7 @@ class DLL_LINKAGE CGVisitableOPW : public CGObjectInstance //objects visitable O
public:
ui8 visited; //true if object has been visited this week
bool wasVisited(TPlayerColor player) const;
bool wasVisited(PlayerColor player) const;
void onHeroVisit(const CGHeroInstance * h) const override;
void newTurn() const override;
@ -1094,11 +1095,11 @@ public:
class DLL_LINKAGE CGKeys : public CGObjectInstance //Base class for Keymaster and guards
{
public:
static std::map <TPlayerColor, std::set <ui8> > playerKeyMap; //[players][keysowned]
static std::map <PlayerColor, std::set <ui8> > playerKeyMap; //[players][keysowned]
//SubID 0 - lightblue, 1 - green, 2 - red, 3 - darkblue, 4 - brown, 5 - purple, 6 - white, 7 - black
const std::string getName() const; //depending on color
bool wasMyColorVisited (TPlayerColor player) const;
bool wasMyColorVisited (PlayerColor player) const;
const std::string & getHoverText() const override;
@ -1113,7 +1114,7 @@ protected:
class DLL_LINKAGE CGKeymasterTent : public CGKeys
{
public:
bool wasVisited (TPlayerColor player) const;
bool wasVisited (PlayerColor player) const;
void onHeroVisit(const CGHeroInstance * h) const override;
template <typename Handler> void serialize(Handler &h, const int version)
@ -1211,7 +1212,7 @@ class DLL_LINKAGE CBank : public CArmedInstance
void initialize() const;
void reset(ui16 var1);
void newTurn() const override;
bool wasVisited (TPlayerColor player) const override;
bool wasVisited (PlayerColor player) const override;
void onHeroVisit(const CGHeroInstance * h) const override;
virtual void fightGuards (const CGHeroInstance *h, ui32 accept) const;
@ -1290,7 +1291,7 @@ class DLL_LINKAGE CGObelisk : public CPlayersVisited
{
public:
static ui8 obeliskCount; //how many obelisks are on map
static std::map<TTeamID, ui8> visited; //map: team_id => how many obelisks has been visited
static std::map<TeamID, ui8> visited; //map: team_id => how many obelisks has been visited
void onHeroVisit(const CGHeroInstance * h) const override;
void initObj() override;
@ -1315,7 +1316,7 @@ public:
{
h & static_cast<CGObjectInstance&>(*this);
}
void giveBonusTo( ui8 player ) const;
void giveBonusTo( PlayerColor player ) const;
};
class DLL_LINKAGE CGMarket : public CGObjectInstance, public IMarket

2
lib/Connection.cpp
View File

@ -228,7 +228,7 @@ CPack * CConnection::retreivePack()
return ret;
}
void CConnection::sendPackToServer(const CPack &pack, TPlayerColor player, ui32 requestID)
void CConnection::sendPackToServer(const CPack &pack, PlayerColor player, ui32 requestID)
{
boost::unique_lock<boost::mutex> lock(*wmx);
tlog5 << "Sending to server a pack of type " << typeid(pack).name() << std::endl;

6
lib/Connection.h
View File

@ -314,8 +314,8 @@ si32 idToNumber(const T &t, typename boost::enable_if<boost::is_convertible<T,si
return t;
}
template<typename T>
si32 idToNumber(const BaseForID<T> &t)
template<typename T, typename NT>
NT idToNumber(const BaseForID<T, NT> &t)
{
return t.getNum();
}
@ -1291,7 +1291,7 @@ public:
virtual ~CConnection(void);
CPack *retreivePack(); //gets from server next pack (allocates it with new)
void sendPackToServer(const CPack &pack, TPlayerColor player, ui32 requestID);
void sendPackToServer(const CPack &pack, PlayerColor player, ui32 requestID);
void disableStackSendingByID();
void enableStackSendingByID();

5
lib/GameConstants.cpp
View File

@ -19,6 +19,11 @@
#include "CSpellHandler.h"
const SlotID SlotID::COMMANDER_SLOT_PLACEHOLDER = SlotID(-2);
const PlayerColor PlayerColor::CANNOT_DETERMINE = PlayerColor(253);
const PlayerColor PlayerColor::UNFLAGGABLE = PlayerColor(254);
const PlayerColor PlayerColor::NEUTRAL = PlayerColor(255);
const PlayerColor PlayerColor::PLAYER_LIMIT = PlayerColor(PLAYER_LIMIT_I);
const TeamID TeamID::NO_TEAM = TeamID(255);
#define ID_LIKE_OPERATORS_INTERNAL(A, B, AN, BN) \
bool operator==(const A & a, const B & b) \

105
lib/GameConstants.h
View File

@ -22,12 +22,9 @@ namespace GameConstants
const int PUZZLE_MAP_PIECES = 48;
const int PLAYER_LIMIT = 8; //player limit per map
const int MAX_HEROES_PER_PLAYER = 8;
const int AVAILABLE_HEROES_PER_PLAYER = 2;
const int UNFLAGGABLE_PLAYER = 254; //254 - neutral objects (pandora, banks)
const int NEUTRAL_PLAYER=255;
const int ALL_PLAYERS = 255; //bitfield
const ui16 BACKPACK_START = 19;
@ -115,29 +112,29 @@ bool operator OP (const CLASS_NAME & b) const \
return num OP b.num; \
}
#define INSTID_LIKE_CLASS_COMMON(CLASS_NAME) \
public: \
CLASS_NAME() : BaseForID<CLASS_NAME>(-1) {} \
CLASS_NAME(const CLASS_NAME & other): \
BaseForID<CLASS_NAME>(other) \
{ \
} \
CLASS_NAME & operator=(const CLASS_NAME & other) \
{ \
num = other.num; \
return *this; \
} \
explicit CLASS_NAME(si32 id) \
: BaseForID<CLASS_NAME>(id) \
#define INSTID_LIKE_CLASS_COMMON(CLASS_NAME, NUMERIC_NAME) \
public: \
CLASS_NAME() : BaseForID<CLASS_NAME, NUMERIC_NAME>(-1) {} \
CLASS_NAME(const CLASS_NAME & other): \
BaseForID<CLASS_NAME, NUMERIC_NAME>(other) \
{ \
} \
CLASS_NAME & operator=(const CLASS_NAME & other) \
{ \
num = other.num; \
return *this; \
} \
explicit CLASS_NAME(si32 id) \
: BaseForID<CLASS_NAME, NUMERIC_NAME>(id) \
{}
template < typename Derived>
template < typename Derived, typename NumericType>
class BaseForID
{
protected:
si32 num;
NumericType num;
public:
si32 getNum() const
NumericType getNum() const
{
return num;
}
@ -146,50 +143,56 @@ public:
h & num;
}
explicit BaseForID(si32 _num = -1)
explicit BaseForID(NumericType _num = -1)
{
num = _num;
}
OP_DECL_INT(BaseForID<Derived>, ==)
OP_DECL_INT(BaseForID<Derived>, !=)
OP_DECL_INT(BaseForID<Derived>, <)
OP_DECL_INT(BaseForID<Derived>, >)
OP_DECL_INT(BaseForID<Derived>, <=)
OP_DECL_INT(BaseForID<Derived>, >=)
void advance(int change)
{
num += change;
}
typedef BaseForID<Derived, NumericType> __SelfType;
OP_DECL_INT(__SelfType, ==)
OP_DECL_INT(__SelfType, !=)
OP_DECL_INT(__SelfType, <)
OP_DECL_INT(__SelfType, >)
OP_DECL_INT(__SelfType, <=)
OP_DECL_INT(__SelfType, >=)
};
template<typename Der>
std::ostream & operator << (std::ostream & os, BaseForID<Der> id);
template<typename Der, typename Num>
std::ostream & operator << (std::ostream & os, BaseForID<Der, Num> id);
template<typename Der>
std::ostream & operator << (std::ostream & os, BaseForID<Der> id)
template<typename Der, typename Num>
std::ostream & operator << (std::ostream & os, BaseForID<Der, Num> id)
{
return os << id.getNum();
}
class ArtifactInstanceID : public BaseForID<ArtifactInstanceID>
class ArtifactInstanceID : public BaseForID<ArtifactInstanceID, si32>
{
INSTID_LIKE_CLASS_COMMON(ArtifactInstanceID)
INSTID_LIKE_CLASS_COMMON(ArtifactInstanceID, si32)
friend class CGameInfoCallback;
friend class CNonConstInfoCallback;
};
class ObjectInstanceID : public BaseForID<ObjectInstanceID>
class ObjectInstanceID : public BaseForID<ObjectInstanceID, si32>
{
INSTID_LIKE_CLASS_COMMON(ObjectInstanceID)
INSTID_LIKE_CLASS_COMMON(ObjectInstanceID, si32)
friend class CGameInfoCallback;
friend class CNonConstInfoCallback;
};
class SlotID : public BaseForID<SlotID>
class SlotID : public BaseForID<SlotID, si32>
{
INSTID_LIKE_CLASS_COMMON(SlotID)
INSTID_LIKE_CLASS_COMMON(SlotID, si32)
friend class CGameInfoCallback;
friend class CGameInfoCallback;
friend class CNonConstInfoCallback;
DLL_LINKAGE static const SlotID COMMANDER_SLOT_PLACEHOLDER;
@ -200,6 +203,30 @@ class SlotID : public BaseForID<SlotID>
}
};
class PlayerColor : public BaseForID<PlayerColor, ui8>
{
INSTID_LIKE_CLASS_COMMON(PlayerColor, ui8)
DLL_LINKAGE static const PlayerColor CANNOT_DETERMINE; //253
DLL_LINKAGE static const PlayerColor UNFLAGGABLE; //254 - neutral objects (pandora, banks)
DLL_LINKAGE static const PlayerColor NEUTRAL; //255
DLL_LINKAGE static const int PLAYER_LIMIT_I = 8; //player limit per map
DLL_LINKAGE static const PlayerColor PLAYER_LIMIT; //player limit per map
friend class CGameInfoCallback;
friend class CNonConstInfoCallback;
};
class TeamID : public BaseForID<TeamID, ui8>
{
INSTID_LIKE_CLASS_COMMON(TeamID, ui8)
DLL_LINKAGE static const TeamID NO_TEAM;
friend class CGameInfoCallback;
friend class CNonConstInfoCallback;
};
// #ifndef INSTANTIATE_BASE_FOR_ID_HERE
// extern template std::ostream & operator << <ArtifactInstanceID>(std::ostream & os, BaseForID<ArtifactInstanceID> id);
// extern template std::ostream & operator << <ObjectInstanceID>(std::ostream & os, BaseForID<ObjectInstanceID> id);
@ -820,8 +847,6 @@ typedef si64 TExpType;
typedef std::pair<ui32, ui32> TDmgRange;
typedef si32 TBonusSubtype;
typedef si32 TQuantity;
typedef ui8 TPlayerColor;
typedef ui8 TTeamID;
#undef ID_LIKE_CLASS_COMMON

2
lib/HeroBonus.cpp
View File

@ -1522,7 +1522,7 @@ StackOwnerLimiter::StackOwnerLimiter()
{
}
StackOwnerLimiter::StackOwnerLimiter(ui8 Owner)
StackOwnerLimiter::StackOwnerLimiter(PlayerColor Owner)
: owner(Owner)
{
}

4
lib/HeroBonus.h
View File

@ -889,9 +889,9 @@ public:
class DLL_LINKAGE StackOwnerLimiter : public ILimiter //applies only to creatures of given alignment
{
public:
ui8 owner;
PlayerColor owner;
StackOwnerLimiter();
StackOwnerLimiter(ui8 Owner);
StackOwnerLimiter(PlayerColor Owner);
int limit(const BonusLimitationContext &context) const OVERRIDE;

66
lib/IGameCallback.cpp
View File

@ -44,14 +44,14 @@ CGameState * CPrivilagedInfoCallback::gameState ()
return gs;
}
TPlayerColor CGameInfoCallback::getOwner(ObjectInstanceID heroID) const
PlayerColor CGameInfoCallback::getOwner(ObjectInstanceID heroID) const
{
const CGObjectInstance *obj = getObj(heroID);
ERROR_RET_VAL_IF(!obj, "No such object!", -1);
ERROR_RET_VAL_IF(!obj, "No such object!", PlayerColor::CANNOT_DETERMINE);
return obj->tempOwner;
}
int CGameInfoCallback::getResource(TPlayerColor Player, Res::ERes which) const
int CGameInfoCallback::getResource(PlayerColor Player, Res::ERes which) const
{
const PlayerState *p = getPlayer(Player);
ERROR_RET_VAL_IF(!p, "No player info!", -1);
@ -59,7 +59,7 @@ int CGameInfoCallback::getResource(TPlayerColor Player, Res::ERes which) const
return p->resources[which];
}
const CGHeroInstance* CGameInfoCallback::getSelectedHero( TPlayerColor Player ) const
const CGHeroInstance* CGameInfoCallback::getSelectedHero( PlayerColor Player ) const
{
const PlayerState *p = getPlayer(Player);
ERROR_RET_VAL_IF(!p, "No player info!", NULL);
@ -71,14 +71,14 @@ const CGHeroInstance* CGameInfoCallback::getSelectedHero() const
return getSelectedHero(gs->currentPlayer);
}
const PlayerSettings * CGameInfoCallback::getPlayerSettings(TPlayerColor color) const
const PlayerSettings * CGameInfoCallback::getPlayerSettings(PlayerColor color) const
{
return &gs->scenarioOps->getIthPlayersSettings(color);
}
void CPrivilagedInfoCallback::getTilesInRange( boost::unordered_set<int3, ShashInt3> &tiles, int3 pos, int radious, int player/*=-1*/, int mode/*=0*/ ) const
void CPrivilagedInfoCallback::getTilesInRange( boost::unordered_set<int3, ShashInt3> &tiles, int3 pos, int radious, boost::optional<PlayerColor> player/*=uninit*/, int mode/*=0*/ ) const
{
if(player >= GameConstants::PLAYER_LIMIT)
if(!!player && *player >= PlayerColor::PLAYER_LIMIT)
{
tlog1 << "Illegal call to getTilesInRange!\n";
return;
@ -87,7 +87,7 @@ void CPrivilagedInfoCallback::getTilesInRange( boost::unordered_set<int3, ShashI
getAllTiles (tiles, player, -1, 0);
else
{
const TeamState * team = gs->getPlayerTeam(player);
const TeamState * team = !player ? NULL : gs->getPlayerTeam(*player);
for (int xd = std::max<int>(pos.x - radious , 0); xd <= std::min<int>(pos.x + radious, gs->map->width - 1); xd++)
{
for (int yd = std::max<int>(pos.y - radious, 0); yd <= std::min<int>(pos.y + radious, gs->map->height - 1); yd++)
@ -95,7 +95,7 @@ void CPrivilagedInfoCallback::getTilesInRange( boost::unordered_set<int3, ShashI
double distance = pos.dist2d(int3(xd,yd,pos.z)) - 0.5;
if(distance <= radious)
{
if(player < 0
if(!player
|| (mode == 1 && team->fogOfWarMap[xd][yd][pos.z]==0)
|| (mode == -1 && team->fogOfWarMap[xd][yd][pos.z]==1)
)
@ -106,9 +106,9 @@ void CPrivilagedInfoCallback::getTilesInRange( boost::unordered_set<int3, ShashI
}
}
void CPrivilagedInfoCallback::getAllTiles (boost::unordered_set<int3, ShashInt3> &tiles, int Player/*=-1*/, int level, int surface ) const
void CPrivilagedInfoCallback::getAllTiles (boost::unordered_set<int3, ShashInt3> &tiles, boost::optional<PlayerColor> Player/*=uninit*/, int level, int surface ) const
{
if(Player >= GameConstants::PLAYER_LIMIT)
if(!!Player && *Player >= PlayerColor::PLAYER_LIMIT)
{
tlog1 << "Illegal call to getAllTiles !\n";
return;
@ -262,14 +262,14 @@ inline TerrainTile * CNonConstInfoCallback::getTile( int3 pos )
return &gs->map->getTile(pos);
}
const PlayerState * CGameInfoCallback::getPlayer(TPlayerColor color, bool verbose) const
const PlayerState * CGameInfoCallback::getPlayer(PlayerColor color, bool verbose) const
{
ERROR_VERBOSE_OR_NOT_RET_VAL_IF(!hasAccess(color), verbose, "Cannot access player " << color << "info!", NULL);
ERROR_VERBOSE_OR_NOT_RET_VAL_IF(!vstd::contains(gs->players,color), verbose, "Cannot find player " << color << "info!", NULL);
return &gs->players[color];
}
const CTown * CGameInfoCallback::getNativeTown(TPlayerColor color) const
const CTown * CGameInfoCallback::getNativeTown(PlayerColor color) const
{
const PlayerSettings *ps = getPlayerSettings(color);
ERROR_RET_VAL_IF(!ps, "There is no such player!", NULL);
@ -398,7 +398,7 @@ void CGameInfoCallback::getThievesGuildInfo(SThievesGuildInfo & thi, const CGObj
}
}
int CGameInfoCallback::howManyTowns(TPlayerColor Player) const
int CGameInfoCallback::howManyTowns(PlayerColor Player) const
{
ERROR_RET_VAL_IF(!hasAccess(Player), "Access forbidden!", -1);
return gs->players[Player].towns.size();
@ -466,7 +466,7 @@ std::vector < std::string > CGameInfoCallback::getObjDescriptions(int3 pos) cons
return ret;
}
bool CGameInfoCallback::isVisible(int3 pos, boost::optional<TPlayerColor> Player) const
bool CGameInfoCallback::isVisible(int3 pos, boost::optional<PlayerColor> Player) const
{
//boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
return gs->map->isInTheMap(pos) && (!Player || gs->isVisible(pos, *Player));
@ -477,7 +477,7 @@ bool CGameInfoCallback::isVisible(int3 pos) const
return isVisible(pos, player);
}
bool CGameInfoCallback::isVisible( const CGObjectInstance *obj, boost::optional<TPlayerColor> Player ) const
bool CGameInfoCallback::isVisible( const CGObjectInstance *obj, boost::optional<PlayerColor> Player ) const
{
return gs->isVisible(obj, Player);
}
@ -529,7 +529,7 @@ std::vector < const CGObjectInstance * > CGameInfoCallback::getFlaggableObjects(
const TerrainTile *t = getTile(pos);
ERROR_RET_VAL_IF(!t, "Not a valid tile requested!", ret);
BOOST_FOREACH(const CGObjectInstance *obj, t->blockingObjects)
if(obj->tempOwner != 254)
if(obj->tempOwner != PlayerColor::UNFLAGGABLE)
ret.push_back(obj);
// const std::vector < std::pair<const CGObjectInstance*,SDL_Rect> > & objs = CGI->mh->ttiles[pos.x][pos.y][pos.z].objects;
// for(size_t b=0; b<objs.size(); ++b)
@ -665,12 +665,12 @@ const CMapHeader * CGameInfoCallback::getMapHeader() const
return gs->map;
}
bool CGameInfoCallback::hasAccess(boost::optional<TPlayerColor> playerId) const
bool CGameInfoCallback::hasAccess(boost::optional<PlayerColor> playerId) const
{
return !player || gs->getPlayerRelations( *playerId, *player ) != PlayerRelations::ENEMIES;
}
EPlayerStatus::EStatus CGameInfoCallback::getPlayerStatus(TPlayerColor player) const
EPlayerStatus::EStatus CGameInfoCallback::getPlayerStatus(PlayerColor player) const
{
const PlayerState *ps = gs->getPlayer(player, false);
ERROR_RET_VAL_IF(!ps, "No such player!", EPlayerStatus::WRONG);
@ -683,7 +683,7 @@ std::string CGameInfoCallback::getTavernGossip(const CGObjectInstance * townOrTa
return "GOSSIP TEST";
}
PlayerRelations::PlayerRelations CGameInfoCallback::getPlayerRelations( TPlayerColor color1, TPlayerColor color2 ) const
PlayerRelations::PlayerRelations CGameInfoCallback::getPlayerRelations( PlayerColor color1, PlayerColor color2 ) const
{
return gs->getPlayerRelations(color1, color2);
}
@ -693,7 +693,7 @@ bool CGameInfoCallback::canGetFullInfo(const CGObjectInstance *obj) const
return !obj || hasAccess(obj->tempOwner);
}
int CGameInfoCallback::getHeroCount( TPlayerColor player, bool includeGarrisoned ) const
int CGameInfoCallback::getHeroCount( PlayerColor player, bool includeGarrisoned ) const
{
int ret = 0;
const PlayerState *p = gs->getPlayer(player);
@ -718,7 +718,7 @@ bool CGameInfoCallback::isOwnedOrVisited(const CGObjectInstance *obj) const
return visitor->ID == Obj::HERO && canGetFullInfo(visitor); //owned or allied hero is a visitor
}
int CGameInfoCallback::getCurrentPlayer() const
PlayerColor CGameInfoCallback::getCurrentPlayer() const
{
return gs->currentPlayer;
}
@ -727,7 +727,7 @@ CGameInfoCallback::CGameInfoCallback()
{
}
CGameInfoCallback::CGameInfoCallback(CGameState *GS, boost::optional<TPlayerColor> Player)
CGameInfoCallback::CGameInfoCallback(CGameState *GS, boost::optional<PlayerColor> Player)
{
gs = GS;
player = Player;
@ -777,7 +777,7 @@ std::vector < const CGHeroInstance *> CPlayerSpecificInfoCallback::getHeroesInfo
return ret;
}
boost::optional<TPlayerColor> CPlayerSpecificInfoCallback::getMyColor() const
boost::optional<PlayerColor> CPlayerSpecificInfoCallback::getMyColor() const
{
return player;
}
@ -903,17 +903,17 @@ CGTownInstance *CNonConstInfoCallback::getTown(ObjectInstanceID objid)
return const_cast<CGTownInstance*>(CGameInfoCallback::getTown(objid));
}
TeamState *CNonConstInfoCallback::getTeam(ui8 teamID)
TeamState *CNonConstInfoCallback::getTeam(TeamID teamID)
{
return const_cast<TeamState*>(CGameInfoCallback::getTeam(teamID));
}
TeamState *CNonConstInfoCallback::getPlayerTeam(TPlayerColor color)
TeamState *CNonConstInfoCallback::getPlayerTeam(PlayerColor color)
{
return const_cast<TeamState*>(CGameInfoCallback::getPlayerTeam(color));
}
PlayerState * CNonConstInfoCallback::getPlayer( TPlayerColor color, bool verbose )
PlayerState * CNonConstInfoCallback::getPlayer( PlayerColor color, bool verbose )
{
return const_cast<PlayerState*>(CGameInfoCallback::getPlayer(color, verbose));
}
@ -928,15 +928,15 @@ CGObjectInstance * CNonConstInfoCallback::getObjInstance( ObjectInstanceID oid )
return gs->map->objects[oid.num];
}
const TeamState * CGameInfoCallback::getTeam( ui8 teamID ) const
const TeamState * CGameInfoCallback::getTeam( TeamID teamID ) const
{
ERROR_RET_VAL_IF(!vstd::contains(gs->teams, teamID), "Cannot find info for team " << int(teamID), NULL);
ERROR_RET_VAL_IF(!vstd::contains(gs->teams, teamID), "Cannot find info for team " << teamID, NULL);
const TeamState *ret = &gs->teams[teamID];
ERROR_RET_VAL_IF(!!player && !vstd::contains(ret->players, *player), "Illegal attempt to access team data!", NULL);
return ret;
}
const TeamState * CGameInfoCallback::getPlayerTeam( TPlayerColor color ) const
const TeamState * CGameInfoCallback::getPlayerTeam( PlayerColor color ) const
{
const PlayerState * ps = getPlayer(color);
if (ps)
@ -953,7 +953,7 @@ const CGHeroInstance* CGameInfoCallback::getHeroWithSubid( int subid ) const
return NULL;
}
int CGameInfoCallback::getLocalPlayer() const
PlayerColor CGameInfoCallback::getLocalPlayer() const
{
return getCurrentPlayer();
}
@ -978,7 +978,7 @@ void IGameEventRealizer::showInfoDialog( InfoWindow *iw )
commitPackage(iw);
}
void IGameEventRealizer::showInfoDialog(const std::string &msg, TPlayerColor player)
void IGameEventRealizer::showInfoDialog(const std::string &msg, PlayerColor player)
{
InfoWindow iw;
iw.player = player;
@ -1005,7 +1005,7 @@ const CGObjectInstance * IGameCallback::putNewObject(Obj ID, int subID, int3 pos
return getObj(no.id); //id field will be filled during applying on gs
}
const CGCreature * IGameCallback::putNewMonster(int creID, int count, int3 pos)
const CGCreature * IGameCallback::putNewMonster(CreatureID creID, int count, int3 pos)
{
const CGObjectInstance *m = putNewObject(Obj::MONSTER, creID, pos);
setObjProperty(m->id, ObjProperty::MONSTER_COUNT, count);

64
lib/IGameCallback.h
View File

@ -65,10 +65,10 @@ class DLL_LINKAGE CGameInfoCallback : public virtual CCallbackBase
{
protected:
CGameInfoCallback();
CGameInfoCallback(CGameState *GS, boost::optional<TPlayerColor> Player);
bool hasAccess(boost::optional<TPlayerColor> playerId) const;
bool isVisible(int3 pos, boost::optional<TPlayerColor> Player) const;
bool isVisible(const CGObjectInstance *obj, boost::optional<TPlayerColor> Player) const;
CGameInfoCallback(CGameState *GS, boost::optional<PlayerColor> Player);
bool hasAccess(boost::optional<PlayerColor> playerId) const;
bool isVisible(int3 pos, boost::optional<PlayerColor> Player) const;
bool isVisible(const CGObjectInstance *obj, boost::optional<PlayerColor> Player) const;
bool isVisible(const CGObjectInstance *obj) const;
bool canGetFullInfo(const CGObjectInstance *obj) const; //true we player owns obj or ally owns obj or privileged mode
@ -81,15 +81,15 @@ public:
bool isAllowed(int type, int id); //type: 0 - spell; 1- artifact; 2 - secondary skill
//player
const PlayerState * getPlayer(TPlayerColor color, bool verbose = true) const;
int getResource(TPlayerColor Player, Res::ERes which) const;
const PlayerState * getPlayer(PlayerColor color, bool verbose = true) const;
int getResource(PlayerColor Player, Res::ERes which) const;
bool isVisible(int3 pos) const;
PlayerRelations::PlayerRelations getPlayerRelations(TPlayerColor color1, TPlayerColor color2) const;
PlayerRelations::PlayerRelations getPlayerRelations(PlayerColor color1, PlayerColor color2) const;
void getThievesGuildInfo(SThievesGuildInfo & thi, const CGObjectInstance * obj); //get thieves' guild info obtainable while visiting given object
EPlayerStatus::EStatus getPlayerStatus(TPlayerColor player) const; //-1 if no such player
int getCurrentPlayer() const; //player that currently makes move // TODO synchronous turns
virtual int getLocalPlayer() const; //player that is currently owning given client (if not a client, then returns current player)
const PlayerSettings * getPlayerSettings(TPlayerColor color) const;
EPlayerStatus::EStatus getPlayerStatus(PlayerColor player) const; //-1 if no such player
PlayerColor getCurrentPlayer() const; //player that currently makes move // TODO synchronous turns
virtual PlayerColor getLocalPlayer() const; //player that is currently owning given client (if not a client, then returns current player)
const PlayerSettings * getPlayerSettings(PlayerColor color) const;
//armed object
@ -98,11 +98,11 @@ public:
//hero
const CGHeroInstance* getHero(ObjectInstanceID objid) const;
const CGHeroInstance* getHeroWithSubid(int subid) const;
int getHeroCount(TPlayerColor player, bool includeGarrisoned) const;
int getHeroCount(PlayerColor player, bool includeGarrisoned) const;
bool getHeroInfo(const CGObjectInstance *hero, InfoAboutHero &dest) const;
int getSpellCost(const CSpell * sp, const CGHeroInstance * caster) const; //when called during battle, takes into account creatures' spell cost reduction
int estimateSpellDamage(const CSpell * sp, const CGHeroInstance * hero) const; //estimates damage of given spell; returns 0 if spell causes no dmg
const CGHeroInstance* getSelectedHero(TPlayerColor player) const; //NULL if no hero is selected
const CGHeroInstance* getSelectedHero(PlayerColor player) const; //NULL if no hero is selected
const CGHeroInstance* getSelectedHero() const; //of current (active) player
const CArtifactInstance * getArtInstance(ArtifactInstanceID aid) const;
const CGObjectInstance * getObjInstance(ObjectInstanceID oid) const;
@ -113,7 +113,7 @@ public:
std::vector <const CGObjectInstance * > getVisitableObjs(int3 pos, bool verbose = true)const;
std::vector <const CGObjectInstance * > getFlaggableObjects(int3 pos) const;
std::vector <std::string > getObjDescriptions(int3 pos)const; //returns descriptions of objects at pos in order from the lowest to the highest
TPlayerColor getOwner(ObjectInstanceID heroID) const;
PlayerColor getOwner(ObjectInstanceID heroID) const;
const CGObjectInstance *getObjByQuestIdentifier(int identifier) const; //NULL if object has been removed (eg. killed)
//map
@ -126,18 +126,18 @@ public:
//town
const CGTownInstance* getTown(ObjectInstanceID objid) const;
int howManyTowns(TPlayerColor Player) const;
int howManyTowns(PlayerColor Player) const;
const CGTownInstance * getTownInfo(int val, bool mode)const; //mode = 0 -> val = player town serial; mode = 1 -> val = object id (serial)
std::vector<const CGHeroInstance *> getAvailableHeroes(const CGObjectInstance * townOrTavern) const; //heroes that can be recruited
std::string getTavernGossip(const CGObjectInstance * townOrTavern) const;
EBuildingState::EBuildingState canBuildStructure(const CGTownInstance *t, BuildingID ID);//// 0 - no more than one capitol, 1 - lack of water, 2 - forbidden, 3 - Add another level to Mage Guild, 4 - already built, 5 - cannot build, 6 - cannot afford, 7 - build, 8 - lack of requirements
std::set<BuildingID> getBuildingRequiments(const CGTownInstance *t, BuildingID ID);
virtual bool getTownInfo(const CGObjectInstance *town, InfoAboutTown &dest) const;
const CTown *getNativeTown(TPlayerColor color) const;
const CTown *getNativeTown(PlayerColor color) const;
//from gs
const TeamState *getTeam(ui8 teamID) const;
const TeamState *getPlayerTeam(TPlayerColor color) const;
const TeamState *getTeam(TeamID teamID) const;
const TeamState *getPlayerTeam(PlayerColor color) const;
std::set<BuildingID> getBuildingRequiments(const CGTownInstance *t, BuildingID ID) const;
EBuildingState::EBuildingState canBuildStructure(const CGTownInstance *t, BuildingID ID) const;// 0 - no more than one capitol, 1 - lack of water, 2 - forbidden, 3 - Add another level to Mage Guild, 4 - already built, 5 - cannot build, 6 - cannot afford, 7 - build, 8 - lack of requirements
};
@ -149,7 +149,7 @@ public:
int howManyTowns() const;
int howManyHeroes(bool includeGarrisoned = true) const;
int3 getGrailPos(double &outKnownRatio);
boost::optional<TPlayerColor> getMyColor() const;
boost::optional<PlayerColor> getMyColor() const;
std::vector <const CGTownInstance *> getTownsInfo(bool onlyOur = true) const; //true -> only owned; false -> all visible
int getHeroSerial(const CGHeroInstance * hero, bool includeGarrisoned=true) const;
@ -163,7 +163,7 @@ public:
int getResourceAmount(Res::ERes type) const;
TResources getResourceAmount() const;
const std::vector< std::vector< std::vector<ui8> > > & getVisibilityMap()const; //returns visibility map
const PlayerSettings * getPlayerSettings(TPlayerColor color) const;
const PlayerSettings * getPlayerSettings(PlayerColor color) const;
};
class DLL_LINKAGE CPrivilagedInfoCallback : public CGameInfoCallback
@ -171,8 +171,8 @@ class DLL_LINKAGE CPrivilagedInfoCallback : public CGameInfoCallback
public:
CGameState * gameState ();
void getFreeTiles (std::vector<int3> &tiles) const; //used for random spawns
void getTilesInRange(boost::unordered_set<int3, ShashInt3> &tiles, int3 pos, int radious, int player=-1, int mode=0) const; //mode 1 - only unrevealed tiles; mode 0 - all, mode -1 - only unrevealed
void getAllTiles (boost::unordered_set<int3, ShashInt3> &tiles, int player=-1, int level=-1, int surface=0) const; //returns all tiles on given level (-1 - both levels, otherwise number of level); surface: 0 - land and water, 1 - only land, 2 - only water
void getTilesInRange(boost::unordered_set<int3, ShashInt3> &tiles, int3 pos, int radious, boost::optional<PlayerColor> player = boost::optional<PlayerColor>(), int mode=0) const; //mode 1 - only unrevealed tiles; mode 0 - all, mode -1 - only unrevealed
void getAllTiles (boost::unordered_set<int3, ShashInt3> &tiles, boost::optional<PlayerColor> player = boost::optional<PlayerColor>(), int level=-1, int surface=0) const; //returns all tiles on given level (-1 - both levels, otherwise number of level); surface: 0 - land and water, 1 - only land, 2 - only water
ArtifactID getRandomArt (int flags);
ArtifactID getArtSync (ui32 rand, int flags, bool erasePicked); //synchronous
void pickAllowedArtsSet(std::vector<const CArtifact*> &out); //gives 3 treasures, 3 minors, 1 major -> used by Black Market and Artifact Merchant
@ -188,9 +188,9 @@ public:
class DLL_LINKAGE CNonConstInfoCallback : public CPrivilagedInfoCallback
{
public:
PlayerState *getPlayer(TPlayerColor color, bool verbose = true);
TeamState *getTeam(ui8 teamID);//get team by team ID
TeamState *getPlayerTeam(TPlayerColor color);// get team by player color
PlayerState *getPlayer(PlayerColor color, bool verbose = true);
TeamState *getTeam(TeamID teamID);//get team by team ID
TeamState *getPlayerTeam(PlayerColor color);// get team by player color
CGHeroInstance *getHero(ObjectInstanceID objid);
CGTownInstance *getTown(ObjectInstanceID objid);
TerrainTile * getTile(int3 pos);
@ -207,7 +207,7 @@ public:
virtual void setObjProperty(ObjectInstanceID objid, int prop, si64 val);
virtual void showInfoDialog(const std::string &msg, TPlayerColor player);
virtual void showInfoDialog(const std::string &msg, PlayerColor player);
};
class DLL_LINKAGE IGameEventCallback : public IGameEventRealizer
@ -216,15 +216,15 @@ public:
virtual void changeSpells(const CGHeroInstance * hero, bool give, const std::set<SpellID> &spells)=0;
virtual bool removeObject(const CGObjectInstance * obj)=0;
virtual void setBlockVis(ObjectInstanceID objid, bool bv)=0;
virtual void setOwner(const CGObjectInstance * objid, TPlayerColor owner)=0;
virtual void setOwner(const CGObjectInstance * objid, PlayerColor owner)=0;
virtual void setHoverName(const CGObjectInstance * obj, MetaString * name)=0;
virtual void changePrimSkill(const CGHeroInstance * hero, PrimarySkill::PrimarySkill which, si64 val, bool abs=false)=0;
virtual void changeSecSkill(const CGHeroInstance * hero, SecondarySkill which, int val, bool abs=false)=0;
virtual void showBlockingDialog(BlockingDialog *iw, const CFunctionList<void(ui32)> &callback)=0;
virtual ui32 showBlockingDialog(BlockingDialog *iw) =0; //synchronous version of above //TODO:
virtual void showGarrisonDialog(ObjectInstanceID upobj, ObjectInstanceID hid, bool removableUnits, const boost::function<void()> &cb) =0; //cb will be called when player closes garrison window
virtual void showThievesGuildWindow(TPlayerColor player, ObjectInstanceID requestingObjId) =0;
virtual void giveResource(TPlayerColor player, Res::ERes which, int val)=0;
virtual void showThievesGuildWindow(PlayerColor player, ObjectInstanceID requestingObjId) =0;
virtual void giveResource(PlayerColor player, Res::ERes which, int val)=0;
virtual void giveCreatures(const CArmedInstance *objid, const CGHeroInstance * h, const CCreatureSet &creatures, bool remove) =0;
virtual void takeCreatures(ObjectInstanceID objid, const std::vector<CStackBasicDescriptor> &creatures) =0;
@ -251,11 +251,11 @@ public:
virtual void startBattleI(const CArmedInstance *army1, const CArmedInstance *army2, int3 tile, boost::function<void(BattleResult*)> cb = 0, bool creatureBank = false)=0; //if any of armies is hero, hero will be used
virtual void startBattleI(const CArmedInstance *army1, const CArmedInstance *army2, boost::function<void(BattleResult*)> cb = 0, bool creatureBank = false)=0; //if any of armies is hero, hero will be used, visitable tile of second obj is place of battle
virtual void setAmount(ObjectInstanceID objid, ui32 val)=0;
virtual bool moveHero(ObjectInstanceID hid, int3 dst, ui8 instant, TPlayerColor asker = GameConstants::NEUTRAL_PLAYER)=0;
virtual bool moveHero(ObjectInstanceID hid, int3 dst, ui8 instant, PlayerColor asker = PlayerColor::NEUTRAL)=0;
virtual void giveHeroBonus(GiveBonus * bonus)=0;
virtual void setMovePoints(SetMovePoints * smp)=0;
virtual void setManaPoints(ObjectInstanceID hid, int val)=0;
virtual void giveHero(ObjectInstanceID id, TPlayerColor player)=0;
virtual void giveHero(ObjectInstanceID id, PlayerColor player)=0;
virtual void changeObjPos(ObjectInstanceID objid, int3 newPos, ui8 flags)=0;
virtual void sendAndApply(CPackForClient * info)=0;
virtual void heroExchange(ObjectInstanceID hero1, ObjectInstanceID hero2)=0; //when two heroes meet on adventure map
@ -270,7 +270,7 @@ public:
//do sth
const CGObjectInstance *putNewObject(Obj ID, int subID, int3 pos);
const CGCreature *putNewMonster(int creID, int count, int3 pos);
const CGCreature *putNewMonster(CreatureID creID, int count, int3 pos);
friend struct CPack;
friend struct CPackForClient;

4
lib/IGameEventsReceiver.h
View File

@ -128,7 +128,7 @@ public:
virtual void objectPropertyChanged(const SetObjectProperty * sop){}; //eg. mine has been flagged
virtual void objectRemoved(const CGObjectInstance *obj){}; //eg. collected resource, picked artifact, beaten hero
virtual void playerBlocked(int reason){}; //reason: 0 - upcoming battle
virtual void gameOver(TPlayerColor player, bool victory){}; //player lost or won the game
virtual void playerStartsTurn(TPlayerColor player){};
virtual void gameOver(PlayerColor player, bool victory){}; //player lost or won the game
virtual void playerStartsTurn(PlayerColor player){};
virtual void showComp(const Component &comp, std::string message) {}; //display component in the advmapint infobox
};

2
lib/Mapping/CCampaignHandler.cpp
View File

@ -401,7 +401,7 @@ void CCampaignScenario::prepareCrossoverHeroes( std::vector<CGHeroInstance *> he
}
}
const CGHeroInstance * CCampaignScenario::strongestHero( TPlayerColor owner ) const
const CGHeroInstance * CCampaignScenario::strongestHero( PlayerColor owner ) const
{
using boost::adaptors::filtered;
std::function<bool(CGHeroInstance*)> isOwned = [=](const CGHeroInstance *h){ return h->tempOwner == owner; };

2
lib/Mapping/CCampaignHandler.h
View File

@ -112,7 +112,7 @@ public:
std::vector<CGHeroInstance *> crossoverHeroes;
const CGHeroInstance * strongestHero(TPlayerColor owner) const;
const CGHeroInstance * strongestHero(PlayerColor owner) const;
void loadPreconditionRegions(ui32 regions);
void prepareCrossoverHeroes(std::vector<CGHeroInstance *> heroes);

2
lib/Mapping/CMap.cpp
View File

@ -131,7 +131,7 @@ CMapHeader::CMapHeader() : version(EMapFormat::SOD), height(72), width(72),
twoLevel(true), difficulty(1), levelLimit(0), howManyTeams(0), areAnyPlayers(false)
{
allowedHeroes = VLC->heroh->getDefaultAllowedHeroes();
players.resize(GameConstants::PLAYER_LIMIT);
players.resize(PlayerColor::PLAYER_LIMIT_I);
}
CMapHeader::~CMapHeader()

4
lib/Mapping/CMap.h
View File

@ -126,7 +126,7 @@ struct DLL_LINKAGE PlayerInfo
int3 posOfMainTown;
/** The team id to which the player belongs to. The default value is 255 representing that the player belongs to no team. */
ui8 team;
TeamID team;
/** Unused. True if a hero should be generated. */
bool generateHero;
@ -573,7 +573,7 @@ public:
/** Specifies the victory condition. The default value is defeat all enemies. */
VictoryCondition victoryCondition;
/** A list containing information about players. The default size of the vector is GameConstants::PLAYER_LIMIT. */
/** A list containing information about players. The default size of the vector is PlayerColor::PLAYER_LIMIT. */
std::vector<PlayerInfo> players;
/** The number of teams. */

2
lib/Mapping/CMapInfo.cpp
View File

@ -10,7 +10,7 @@
void CMapInfo::countPlayers()
{
actualHumanPlayers = playerAmnt = humanPlayers = 0;
for(int i=0;i<GameConstants::PLAYER_LIMIT;i++)
for(int i=0; i<PlayerColor::PLAYER_LIMIT_I; i++)
{
if(mapHeader->players[i].canHumanPlay)
{

26
lib/Mapping/MapFormatH3M.cpp
View File

@ -379,19 +379,19 @@ void CMapLoaderH3M::readTeamInfo()
if(mapHeader->howManyTeams > 0)
{
// Teams
for(int i = 0; i < GameConstants::PLAYER_LIMIT; ++i)
for(int i = 0; i < PlayerColor::PLAYER_LIMIT_I; ++i)
{
mapHeader->players[i].team = reader.readUInt8();
mapHeader->players[i].team = TeamID(reader.readUInt8());
}
}
else
{
// No alliances
for(int i = 0; i < GameConstants::PLAYER_LIMIT; i++)
for(int i = 0; i < PlayerColor::PLAYER_LIMIT_I; i++)
{
if(mapHeader->players[i].canComputerPlay || mapHeader->players[i].canHumanPlay)
{
mapHeader->players[i].team = mapHeader->howManyTeams++;
mapHeader->players[i].team = TeamID(mapHeader->howManyTeams++);
}
}
}
@ -1070,7 +1070,7 @@ void CMapLoaderH3M::readObjects()
{
CGGarrison * gar = new CGGarrison();
nobj = gar;
nobj->setOwner(reader.readUInt8());
nobj->setOwner(PlayerColor(reader.readUInt8()));
reader.skip(3);
readCreatureSet(gar, 7);
if(map->version > EMapFormat::ROE)
@ -1140,7 +1140,7 @@ void CMapLoaderH3M::readObjects()
case Obj::ABANDONED_MINE:
{
nobj = new CGMine();
nobj->setOwner(reader.readUInt8());
nobj->setOwner(PlayerColor(reader.readUInt8()));
reader.skip(3);
break;
}
@ -1150,7 +1150,7 @@ void CMapLoaderH3M::readObjects()
case Obj::CREATURE_GENERATOR4:
{
nobj = new CGDwelling();
nobj->setOwner(reader.readUInt8());
nobj->setOwner(PlayerColor(reader.readUInt8()));
reader.skip(3);
break;
}
@ -1246,7 +1246,7 @@ void CMapLoaderH3M::readObjects()
break; case Obj::RANDOM_DWELLING_FACTION: spec = new CCreGenLeveledInfo();
}
spec->player = reader.readUInt32();
spec->player = PlayerColor(reader.readUInt32());
//216 and 217
if (auto castleSpec = dynamic_cast<CCreGenAsCastleInfo *>(spec))
@ -1331,7 +1331,7 @@ void CMapLoaderH3M::readObjects()
case Obj::SHIPYARD:
{
nobj = new CGShipyard();
nobj->setOwner(reader.readUInt32());
nobj->setOwner(PlayerColor(reader.readUInt32()));
break;
}
case Obj::HERO_PLACEHOLDER: //hero placeholder
@ -1339,7 +1339,7 @@ void CMapLoaderH3M::readObjects()
CGHeroPlaceholder * hp = new CGHeroPlaceholder();
nobj = hp;
hp->setOwner(reader.readUInt8());
hp->setOwner(PlayerColor(reader.readUInt8()));
int htid = reader.readUInt8();; //hero type id
nobj->subID = htid;
@ -1424,7 +1424,7 @@ void CMapLoaderH3M::readObjects()
case Obj::LIGHTHOUSE: //Lighthouse
{
nobj = new CGLighthouse();
nobj->tempOwner = reader.readUInt32();
nobj->tempOwner = PlayerColor(reader.readUInt32());
break;
}
case Obj::ALTAR_OF_SACRIFICE:
@ -1532,7 +1532,7 @@ CGObjectInstance * CMapLoaderH3M::readHero(ObjectInstanceID idToBeGiven)
map->questIdentifierToId[identifier] = idToBeGiven;
}
ui8 owner = reader.readUInt8();
PlayerColor owner = PlayerColor(reader.readUInt8());
nhi->subID = reader.readUInt8();
for(int j = 0; j < map->predefinedHeroes.size(); ++j)
@ -1884,7 +1884,7 @@ CGTownInstance * CMapLoaderH3M::readTown(int castleID)
{
nt->identifier = reader.readUInt32();
}
nt->tempOwner = reader.readUInt8();
nt->tempOwner = PlayerColor(reader.readUInt8());
bool hasName = reader.readBool();
if(hasName)
{

61
lib/NetPacks.h
View File

@ -65,14 +65,14 @@ struct CPackForClient : public CPack
struct CPackForServer : public CPack
{
TPlayerColor player;
PlayerColor player;
CConnection *c;
CGameState* GS(CGameHandler *gh);
CPackForServer()
{
type = 2;
c = NULL;
player = 255;
player = PlayerColor::NEUTRAL;
};
bool applyGh(CGameHandler *gh);//called after applying to gs
@ -203,7 +203,7 @@ struct PackageApplied : public CPackForClient //94
ui8 result; //0 - something went wrong, request hasn't been realized; 1 - OK
ui32 packType; //type id of applied package
ui32 requestID; //an ID given by client to the request that was applied
TPlayerColor player;
PlayerColor player;
template <typename Handler> void serialize(Handler &h, const int version)
@ -234,7 +234,7 @@ struct PlayerBlocked : public CPackForClient //96
enum EReason { UPCOMING_BATTLE };
EReason reason;
TPlayerColor player;
PlayerColor player;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -248,7 +248,7 @@ struct YourTurn : public CPackForClient //100
void applyCl(CClient *cl);
DLL_LINKAGE void applyGs(CGameState *gs);
TPlayerColor player;
PlayerColor player;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -262,7 +262,7 @@ struct SetResource : public CPackForClient //102
void applyCl(CClient *cl);
DLL_LINKAGE void applyGs(CGameState *gs);
TPlayerColor player;
PlayerColor player;
Res::ERes resid;
TResourceCap val;
@ -277,7 +277,7 @@ struct SetResource : public CPackForClient //102
void applyCl(CClient *cl);
DLL_LINKAGE void applyGs(CGameState *gs);
TPlayerColor player;
PlayerColor player;
TResources res; //res[resid] => res amount
template <typename Handler> void serialize(Handler &h, const int version)
@ -394,7 +394,8 @@ struct FoWChange : public CPackForClient //112
DLL_LINKAGE void applyGs(CGameState *gs);
boost::unordered_set<int3, struct ShashInt3 > tiles;
ui8 player, mode; //mode==0 - hide, mode==1 - reveal
PlayerColor player;
ui8 mode; //mode==0 - hide, mode==1 - reveal
template <typename Handler> void serialize(Handler &h, const int version)
{
h & tiles & player & mode;
@ -415,7 +416,7 @@ struct SetAvailableHeroes : public CPackForClient //113
void applyCl(CClient *cl);
DLL_LINKAGE void applyGs(CGameState *gs);
TPlayerColor player;
PlayerColor player;
si32 hid[GameConstants::AVAILABLE_HEROES_PER_PLAYER]; //-1 if no hero
CSimpleArmy army[GameConstants::AVAILABLE_HEROES_PER_PLAYER];
template <typename Handler> void serialize(Handler &h, const int version)
@ -478,7 +479,7 @@ struct PlayerEndsGame : public CPackForClient //117
void applyCl(CClient *cl);
DLL_LINKAGE void applyGs(CGameState *gs);
TPlayerColor player;
PlayerColor player;
ui8 victory;
template <typename Handler> void serialize(Handler &h, const int version)
@ -558,7 +559,7 @@ struct AddQuest : public CPackForClient //121
void applyCl(CClient *cl){};
DLL_LINKAGE void applyGs(CGameState *gs);
TPlayerColor player;
PlayerColor player;
QuestInfo quest;
template <typename Handler> void serialize(Handler &h, const int version)
@ -758,7 +759,7 @@ struct HeroRecruited : public CPackForClient //515
si32 hid;//subID of hero
ObjectInstanceID tid;
int3 tile;
TPlayerColor player;
PlayerColor player;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -774,7 +775,7 @@ struct GiveHero : public CPackForClient //516
DLL_LINKAGE void applyGs(CGameState *gs);
ObjectInstanceID id; //object id
TPlayerColor player;
PlayerColor player;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -987,7 +988,7 @@ struct ArtifactLocation
}
DLL_LINKAGE const CArmedInstance *relatedObj() const; //hero or the stack owner
DLL_LINKAGE int owningPlayer() const;
DLL_LINKAGE PlayerColor owningPlayer() const;
DLL_LINKAGE CArtifactSet *getHolderArtSet();
DLL_LINKAGE CBonusSystemNode *getHolderNode();
DLL_LINKAGE const CArtifactSet *getHolderArtSet() const;
@ -1106,7 +1107,7 @@ struct NewTurn : public CPackForClient //101
std::set<Hero> heroes; //updates movement and mana points
//std::vector<SetResources> res;//resource list
std::map<TPlayerColor, TResources> res; //player ID => resource value[res_id]
std::map<PlayerColor, TResources> res; //player ID => resource value[res_id]
std::vector<SetAvailableCreatures> cres;//creatures to be placed in towns
ui32 day;
bool resetBuilded;
@ -1150,7 +1151,7 @@ struct InfoWindow : public CPackForClient //103 - displays simple info window
MetaString text;
std::vector<Component> components;
TPlayerColor player;
PlayerColor player;
ui16 soundID;
template <typename Handler> void serialize(Handler &h, const int version)
@ -1273,7 +1274,7 @@ struct BlockingDialog : public Query//2003
MetaString text;
std::vector<Component> components;
TPlayerColor player;
PlayerColor player;
ui8 flags;
ui16 soundID;
@ -1606,7 +1607,7 @@ struct BattleResultsApplied : public CPackForClient //3012
{
BattleResultsApplied(){type = 3012;}
ui8 player1, player2;
PlayerColor player1, player2;
void applyCl(CClient *cl);
template <typename Handler> void serialize(Handler &h, const int version)
@ -1742,7 +1743,7 @@ struct BattleObstaclePlaced : public CPackForClient //3020
struct ShowInInfobox : public CPackForClient //107
{
ShowInInfobox(){type = 107;};
ui8 player;
PlayerColor player;
Component c;
MetaString text;
@ -1757,7 +1758,7 @@ struct AdvmapSpellCast : public CPackForClient //108
{
AdvmapSpellCast(){type = 108;}
const CGHeroInstance * caster;
si32 spellID;
SpellID spellID;
void applyCl(CClient *cl);
template <typename Handler> void serialize(Handler &h, const int version)
@ -2022,7 +2023,7 @@ struct HireHero : public CPackForServer
HireHero(si32 HID, ObjectInstanceID TID):hid(HID),tid(TID){};
si32 hid; //available hero serial
ObjectInstanceID tid; //town (tavern) id
TPlayerColor player;
PlayerColor player;
bool applyGh(CGameHandler *gh);
template <typename Handler> void serialize(Handler &h, const int version)
@ -2049,7 +2050,7 @@ struct QueryReply : public CPackForServer
QueryReply(){type = 6000;};
QueryReply(ui32 QID, ui32 Answer):qid(QID),answer(Answer){type = 6000;};
ui32 qid, answer; //hero and artifact id
TPlayerColor player;
PlayerColor player;
bool applyGh(CGameHandler *gh);
template <typename Handler> void serialize(Handler &h, const int version)
@ -2130,14 +2131,14 @@ struct SaveGame : public CPackForClient, public CPackForServer
struct PlayerMessage : public CPackForClient, public CPackForServer //513
{
PlayerMessage(){CPackForClient::type = 513;};
PlayerMessage(ui8 Player, const std::string &Text)
PlayerMessage(PlayerColor Player, const std::string &Text)
:player(Player),text(Text)
{CPackForClient::type = 513;};
void applyCl(CClient *cl);
void applyGs(CGameState *gs){};
bool applyGh(CGameHandler *gh);
TPlayerColor player;
PlayerColor player;
std::string text;
template <typename Handler> void serialize(Handler &h, const int version)
@ -2154,7 +2155,7 @@ struct SetSelection : public CPackForClient, public CPackForServer //514
bool applyGh(CGameHandler *gh);
void applyCl(CClient *cl);
TPlayerColor player;
PlayerColor player;
ObjectInstanceID id;
template <typename Handler> void serialize(Handler &h, const int version)
@ -2168,7 +2169,7 @@ struct CenterView : public CPackForClient//515
CenterView(){CPackForClient::type = 515;};
void applyCl(CClient *cl);
TPlayerColor player;
PlayerColor player;
int3 pos;
ui32 focusTime; //ms
@ -2301,9 +2302,9 @@ struct RequestOptionsChange : public CPregamePackToHost
enum EWhat {TOWN, HERO, BONUS};
ui8 what;
si8 direction; //-1 or +1
TPlayerColor playerID;
ui8 playerID;
RequestOptionsChange(ui8 What, si8 Dir, TPlayerColor Player)
RequestOptionsChange(ui8 What, si8 Dir, ui8 Player)
:what(What), direction(Dir), playerID(Player)
{}
RequestOptionsChange(){}
@ -2318,7 +2319,7 @@ struct RequestOptionsChange : public CPregamePackToHost
struct PlayerLeft : public CPregamePackToPropagate
{
TPlayerColor playerID;
ui8 playerID;
void apply(CSelectionScreen *selScreen); //that functions are implemented in CPreGame.cpp
@ -2331,7 +2332,7 @@ struct PlayerLeft : public CPregamePackToPropagate
struct PlayersNames : public CPregamePackToPropagate
{
public:
std::map<TPlayerColor, std::string> playerNames;
std::map<ui8, std::string> playerNames;
void apply(CSelectionScreen *selScreen); //that functions are implemented in CPreGame.cpp

24
lib/NetPacksLib.cpp
View File

@ -36,14 +36,14 @@
DLL_LINKAGE void SetResource::applyGs( CGameState *gs )
{
assert(player < GameConstants::PLAYER_LIMIT);
assert(player < PlayerColor::PLAYER_LIMIT);
vstd::amax(val, 0); //new value must be >= 0
gs->getPlayer(player)->resources[resid] = val;
}
DLL_LINKAGE void SetResources::applyGs( CGameState *gs )
{
assert(player < GameConstants::PLAYER_LIMIT);
assert(player < PlayerColor::PLAYER_LIMIT);
gs->getPlayer(player)->resources = res;
}
@ -224,7 +224,7 @@ DLL_LINKAGE void GiveBonus::applyGs( CGameState *gs )
cbsn = gs->getHero(ObjectInstanceID(id));
break;
case PLAYER:
cbsn = gs->getPlayer(id);
cbsn = gs->getPlayer(PlayerColor(id));
break;
case TOWN:
cbsn = gs->getTown(ObjectInstanceID(id));
@ -277,7 +277,7 @@ DLL_LINKAGE void RemoveBonus::applyGs( CGameState *gs )
if (who == HERO)
node = gs->getHero(ObjectInstanceID(whoID));
else
node = gs->getPlayer(whoID);
node = gs->getPlayer(PlayerColor(whoID));
BonusList &bonuses = node->getBonusList();
@ -309,7 +309,7 @@ DLL_LINKAGE void RemoveObject::applyGs( CGameState *gs )
gs->map->heroes -= h;
p->heroes -= h;
h->detachFrom(h->whereShouldBeAttached(gs));
h->tempOwner = 255; //no one owns beaten hero
h->tempOwner = PlayerColor::NEUTRAL; //no one owns beaten hero
if(h->visitedTown)
{
@ -636,10 +636,10 @@ DLL_LINKAGE const CArmedInstance * ArtifactLocation::relatedObj() const
return boost::apply_visitor(ObjectRetriever(), artHolder);
}
DLL_LINKAGE int ArtifactLocation::owningPlayer() const
DLL_LINKAGE PlayerColor ArtifactLocation::owningPlayer() const
{
auto obj = relatedObj();
return obj ? obj->tempOwner : GameConstants::NEUTRAL_PLAYER;
return obj ? obj->tempOwner : PlayerColor::NEUTRAL;
}
DLL_LINKAGE CArtifactSet *ArtifactLocation::getHolderArtSet()
@ -901,9 +901,9 @@ DLL_LINKAGE void NewTurn::applyGs( CGameState *gs )
hero->mana = h.mana;
}
for(std::map<ui8, TResources>::iterator i = res.begin(); i != res.end(); i++)
for(auto i = res.cbegin(); i != res.cend(); i++)
{
assert(i->first < GameConstants::PLAYER_LIMIT);
assert(i->first < PlayerColor::PLAYER_LIMIT);
gs->getPlayer(i->first)->resources = i->second;
}
@ -944,10 +944,10 @@ DLL_LINKAGE void SetObjectProperty::applyGs( CGameState *gs )
if(obj->ID == Obj::TOWN)
{
CGTownInstance *t = static_cast<CGTownInstance*>(obj);
if(t->tempOwner < GameConstants::PLAYER_LIMIT)
if(t->tempOwner < PlayerColor::PLAYER_LIMIT)
gs->getPlayer(t->tempOwner)->towns -= t;
if(val < GameConstants::PLAYER_LIMIT)
gs->getPlayer(val)->towns.push_back(t);
if(val < PlayerColor::PLAYER_LIMIT_I)
gs->getPlayer(PlayerColor(val))->towns.push_back(t);
}
CBonusSystemNode *nodeToMove = cai->whatShouldBeAttached();

8
lib/RMG/CMapGenOptions.cpp
View File

@ -61,14 +61,14 @@ si8 CMapGenOptions::getPlayersCnt() const
void CMapGenOptions::setPlayersCnt(si8 value)
{
if((value >= 1 && value <= GameConstants::PLAYER_LIMIT) || value == RANDOM_SIZE)
if((value >= 1 && value <= PlayerColor::PLAYER_LIMIT_I) || value == RANDOM_SIZE)
{
playersCnt = value;
}
else
{
throw std::runtime_error("Players count of RMG options should be between 1 and " +
boost::lexical_cast<std::string>(GameConstants::PLAYER_LIMIT) + " or CMapGenOptions::RANDOM_SIZE for random.");
boost::lexical_cast<std::string>(PlayerColor::PLAYER_LIMIT) + " or CMapGenOptions::RANDOM_SIZE for random.");
}
}
@ -97,14 +97,14 @@ si8 CMapGenOptions::getCompOnlyPlayersCnt() const
void CMapGenOptions::setCompOnlyPlayersCnt(si8 value)
{
if(value == RANDOM_SIZE || (value >= 0 && value <= GameConstants::PLAYER_LIMIT - playersCnt))
if(value == RANDOM_SIZE || (value >= 0 && value <= PlayerColor::PLAYER_LIMIT_I - playersCnt))
{
compOnlyPlayersCnt = value;
}
else
{
throw std::runtime_error(std::string("Computer only players count of RMG options should be ") +
"between 0 and <GameConstants::PLAYER_LIMIT - " + boost::lexical_cast<std::string>(playersCnt) +
"between 0 and <PlayerColor::PLAYER_LIMIT - " + boost::lexical_cast<std::string>(playersCnt) +
"(playersCount)> or CMapGenOptions::RANDOM_SIZE for random.");
}
}

8
lib/RMG/CMapGenOptions.h
View File

@ -92,14 +92,14 @@ public:
* Gets the count of the players. The default value is RANDOM_SIZE representing a random
* player count.
*
* @return the count of the players ranging from 1 to GameConstants::PLAYER_LIMIT or RANDOM_SIZE for random
* @return the count of the players ranging from 1 to PlayerColor::PLAYER_LIMIT or RANDOM_SIZE for random
*/
si8 getPlayersCnt() const;
/**
* Sets the count of the players.
*
* @param value the count of the players ranging from 1 to GameConstants::PLAYER_LIMIT, RANDOM_SIZE for random
* @param value the count of the players ranging from 1 to PlayerColor::PLAYER_LIMIT, RANDOM_SIZE for random
*/
void setPlayersCnt(si8 value);
@ -121,14 +121,14 @@ public:
/**
* Gets the count of the computer only players. The default value is 0.
*
* @return the count of the computer only players ranging from 0 to <GameConstants::PLAYER_LIMIT - players count> or RANDOM_SIZE for random
* @return the count of the computer only players ranging from 0 to <PlayerColor::PLAYER_LIMIT - players count> or RANDOM_SIZE for random
*/
si8 getCompOnlyPlayersCnt() const;
/**
* Sets the count of the computer only players.
*
* @param value the count of the computer only players ranging from 0 to <GameConstants::PLAYER_LIMIT - players count>, RANDOM_SIZE for random
* @param value the count of the computer only players ranging from 0 to <PlayerColor::PLAYER_LIMIT - players count>, RANDOM_SIZE for random
*/
void setCompOnlyPlayersCnt(si8 value);

36
lib/RMG/CMapGenerator.cpp
View File

@ -11,7 +11,7 @@
#include "../CTownHandler.h"
#include "../StringConstants.h"
CMapGenerator::CMapGenerator(const CMapGenOptions & mapGenOptions, const std::map<TPlayerColor, CPlayerSettings> & players, int randomSeed) :
CMapGenerator::CMapGenerator(const CMapGenOptions & mapGenOptions, const std::map<PlayerColor, CPlayerSettings> & players, int randomSeed) :
mapGenOptions(mapGenOptions), randomSeed(randomSeed), players(players)
{
gen.seed(randomSeed);
@ -57,10 +57,10 @@ void CMapGenerator::validateOptions() const
}
if(mapGenOptions.getPlayersCnt() == CMapGenOptions::RANDOM_SIZE)
{
if(playersCnt != GameConstants::PLAYER_LIMIT)
if(playersCnt != PlayerColor::PLAYER_LIMIT_I)
{
throw std::runtime_error(std::string("If the count of players is random size, ")
+ "the count of the items in the players map should equal GameConstants::PLAYER_LIMIT.");
+ "the count of the items in the players map should equal PlayerColor::PLAYER_LIMIT.");
}
if(playersCnt == mapGenOptions.getPlayersCnt())
{
@ -81,10 +81,10 @@ void CMapGenerator::validateOptions() const
else
{
if(playersCnt != mapGenOptions.getPlayersCnt() || (playersCnt == mapGenOptions.getPlayersCnt()
&& compOnlyPlayersCnt != GameConstants::PLAYER_LIMIT - playersCnt))
&& compOnlyPlayersCnt != PlayerColor::PLAYER_LIMIT_I - playersCnt))
{
throw std::runtime_error(std::string("If the count of players is fixed and the count of comp only players random, ")
+ "the items in the players map should equal GameConstants::PLAYER_LIMIT.");
+ "the items in the players map should equal PlayerColor::PLAYER_LIMIT.");
}
}
}
@ -107,7 +107,7 @@ void CMapGenerator::finalizeMapGenOptions()
{
if(mapGenOptions.getPlayersCnt() == CMapGenOptions::RANDOM_SIZE)
{
mapGenOptions.setPlayersCnt(gen.getInteger(countHumanPlayers(), GameConstants::PLAYER_LIMIT));
mapGenOptions.setPlayersCnt(gen.getInteger(countHumanPlayers(), PlayerColor::PLAYER_LIMIT_I));
// Remove AI players only from the end of the players map if necessary
for(auto itrev = players.end(); itrev != players.begin();)
@ -217,11 +217,11 @@ std::string CMapGenerator::getMapDescription() const
const CPlayerSettings & pSettings = pair.second;
if(pSettings.getPlayerType() == CPlayerSettings::HUMAN)
{
ss << ", " << GameConstants::PLAYER_COLOR_NAMES[pSettings.getColor()] << " is human";
ss << ", " << GameConstants::PLAYER_COLOR_NAMES[pSettings.getColor().getNum()] << " is human";
}
if(pSettings.getStartingTown() != CPlayerSettings::RANDOM_TOWN)
{
ss << ", " << GameConstants::PLAYER_COLOR_NAMES[pSettings.getColor()]
ss << ", " << GameConstants::PLAYER_COLOR_NAMES[pSettings.getColor().getNum()]
<< " town choice is " << ETownType::names[pSettings.getStartingTown()];
}
}
@ -276,9 +276,9 @@ void CMapGenerator::addPlayerInfo()
player.canHumanPlay = true;
}
auto itTeam = std::next(teamNumbers[j].begin(), gen.getInteger(0, teamNumbers[j].size() - 1));
player.team = *itTeam;
player.team = TeamID(*itTeam);
teamNumbers[j].erase(itTeam);
map->players[pSettings.getColor()] = player;
map->players[pSettings.getColor().getNum()] = player;
}
map->howManyTeams = (mapGenOptions.getTeamsCnt() == 0 ? mapGenOptions.getPlayersCnt() : mapGenOptions.getTeamsCnt())
@ -287,7 +287,7 @@ void CMapGenerator::addPlayerInfo()
int CMapGenerator::countHumanPlayers() const
{
return static_cast<int>(boost::count_if(players, [](const std::pair<TPlayerColor, CPlayerSettings> & pair)
return static_cast<int>(boost::count_if(players, [](const std::pair<PlayerColor, CPlayerSettings> & pair)
{
return pair.second.getPlayerType() == CMapGenerator::CPlayerSettings::HUMAN;
}));
@ -308,7 +308,7 @@ void CMapGenerator::genTowns()
for(auto it = players.begin(); it != players.end(); ++it)
{
TPlayerColor owner = it->first;
PlayerColor owner = it->first;
int pos = std::distance(players.begin(), it);
int side = pos % 2;
CGTownInstance * town = new CGTownInstance();
@ -321,7 +321,7 @@ void CMapGenerator::genTowns()
mapMgr->insertObject(town, townPos[side].x, townPos[side].y + (pos / 2) * 5, false);
// Update player info
PlayerInfo & pInfo = map->players[owner];
PlayerInfo & pInfo = map->players[owner.getNum()];
pInfo.allowedFactions.clear();
pInfo.allowedFactions.insert(townTypes[side]);
pInfo.hasMainTown = true;
@ -342,9 +342,9 @@ void CMapGenerator::addHeaderInfo()
addPlayerInfo();
}
TPlayerColor CMapGenerator::getNextPlayerColor() const
PlayerColor CMapGenerator::getNextPlayerColor() const
{
for(TPlayerColor i = 0; i < GameConstants::PLAYER_LIMIT; ++i)
for(PlayerColor i = PlayerColor(0); i < PlayerColor::PLAYER_LIMIT; i.advance(1))
{
if(!players.count(i))
{
@ -359,15 +359,15 @@ CMapGenerator::CPlayerSettings::CPlayerSettings() : color(0), startingTown(RANDO
}
int CMapGenerator::CPlayerSettings::getColor() const
PlayerColor CMapGenerator::CPlayerSettings::getColor() const
{
return color;
}
void CMapGenerator::CPlayerSettings::setColor(int value)
void CMapGenerator::CPlayerSettings::setColor(PlayerColor value)
{
if(value >= 0 && value < GameConstants::PLAYER_LIMIT)
if(value >= PlayerColor(0) && value < PlayerColor::PLAYER_LIMIT)
{
color = value;
}

18
lib/RMG/CMapGenerator.h
View File

@ -46,16 +46,16 @@ public:
/**
* Gets the color of the player. The default value is 0.
*
* @return the color of the player ranging from 0 to GameConstants::PLAYER_LIMIT - 1
* @return the color of the player ranging from 0 to PlayerColor::PLAYER_LIMIT - 1
*/
int getColor() const;
PlayerColor getColor() const;
/**
* Sets the color of the player.
*
* @param value the color of the player ranging from 0 to GameConstants::PLAYER_LIMIT - 1
* @param value the color of the player ranging from 0 to PlayerColor::PLAYER_LIMIT - 1
*/
void setColor(int value);
void setColor(PlayerColor value);
/**
* Gets the starting town of the player. The default value is RANDOM_TOWN.
@ -90,7 +90,7 @@ public:
private:
/** The color of the player. */
int color;
PlayerColor color;
/** The starting town of the player. */
int startingTown;
@ -106,7 +106,7 @@ public:
* @param players the random gen player settings
* @param randomSeed a random seed is required to get random numbers.
*/
CMapGenerator(const CMapGenOptions & mapGenOptions, const std::map<TPlayerColor, CPlayerSettings> & players, int randomSeed);
CMapGenerator(const CMapGenOptions & mapGenOptions, const std::map<PlayerColor, CPlayerSettings> & players, int randomSeed);
/**
* Destructor.
@ -147,7 +147,7 @@ private:
/**
* Counts the amount of human players.
*
* @return the amount of human players ranging from 0 to GameConstants::PLAYER_LIMIT
* @return the amount of human players ranging from 0 to PlayerColor::PLAYER_LIMIT
*/
int countHumanPlayers() const;
@ -171,7 +171,7 @@ private:
*
* @return the next free player color
*/
TPlayerColor getNextPlayerColor() const;
PlayerColor getNextPlayerColor() const;
/** The map options which describes the size of the map and contain player info. */
CMapGenOptions mapGenOptions;
@ -192,5 +192,5 @@ private:
std::unique_ptr<CMapEditManager> mapMgr;
/** The random gen player settings. */
std::map<TPlayerColor, CPlayerSettings> players;
std::map<PlayerColor, CPlayerSettings> players;
};

8
lib/StartInfo.h
View File

@ -35,10 +35,10 @@ struct PlayerSettings
heroPortrait; //-1 if default, else ID
std::string heroName;
TPlayerColor color; //from 0 -
PlayerColor color; //from 0 -
enum EHandicap {NO_HANDICAP, MILD, SEVERE};
EHandicap handicap;//0-no, 1-mild, 2-severe
ui8 team;
TeamID team;
std::string name;
ui8 playerID; //0 - AI, non-0 serves as player id
@ -74,7 +74,7 @@ struct StartInfo
EMode mode;
ui8 difficulty; //0=easy; 4=impossible
typedef bmap<TPlayerColor, PlayerSettings> TPlayerInfos;
typedef bmap<PlayerColor, PlayerSettings> TPlayerInfos;
TPlayerInfos playerInfos; //color indexed
ui32 seedToBeUsed; //0 if not sure (client requests server to decide, will be send in reply pack)
@ -87,7 +87,7 @@ struct StartInfo
shared_ptr<CCampaignState> campState;
PlayerSettings & getIthPlayersSettings(TPlayerColor no)
PlayerSettings & getIthPlayersSettings(PlayerColor no)
{
if(playerInfos.find(no) != playerInfos.end())
return playerInfos[no];

2
lib/StringConstants.h
View File

@ -31,7 +31,7 @@ namespace GameConstants
"demoniac", "heretic", "deathknight", "necromancer", "warlock", "overlord",
"barbarian", "battlemage", "beastmaster", "witch", "planeswalker", "elementalist"
};
const std::string PLAYER_COLOR_NAMES [PLAYER_LIMIT] = {
const std::string PLAYER_COLOR_NAMES [PlayerColor::PLAYER_LIMIT_I] = {
"red", "blue", "tan", "green", "orange", "purple", "teal", "pink"
};
}

217
server/CGameHandler.cpp
View File

@ -67,7 +67,7 @@ template <typename T> class CApplyOnGH;
class CBaseForGHApply
{
public:
virtual bool applyOnGH(CGameHandler *gh, CConnection *c, void *pack, ui8 player) const =0;
virtual bool applyOnGH(CGameHandler *gh, CConnection *c, void *pack, PlayerColor player) const =0;
virtual ~CBaseForGHApply(){}
template<typename U> static CBaseForGHApply *getApplier(const U * t=NULL)
{
@ -78,7 +78,7 @@ public:
template <typename T> class CApplyOnGH : public CBaseForGHApply
{
public:
bool applyOnGH(CGameHandler *gh, CConnection *c, void *pack, ui8 player) const
bool applyOnGH(CGameHandler *gh, CConnection *c, void *pack, PlayerColor player) const
{
T *ptr = static_cast<T*>(pack);
ptr->c = c;
@ -105,7 +105,7 @@ static void giveExp(BattleResult &r)
}
}
PlayerStatus PlayerStatuses::operator[](TPlayerColor player)
PlayerStatus PlayerStatuses::operator[](PlayerColor player)
{
boost::unique_lock<boost::mutex> l(mx);
if(players.find(player) != players.end())
@ -117,13 +117,13 @@ PlayerStatus PlayerStatuses::operator[](TPlayerColor player)
throw std::runtime_error("No such player!");
}
}
void PlayerStatuses::addPlayer(TPlayerColor player)
void PlayerStatuses::addPlayer(PlayerColor player)
{
boost::unique_lock<boost::mutex> l(mx);
players[player];
}
int PlayerStatuses::getQueriesCount(TPlayerColor player)
int PlayerStatuses::getQueriesCount(PlayerColor player)
{
boost::unique_lock<boost::mutex> l(mx);
if(players.find(player) != players.end())
@ -136,7 +136,7 @@ int PlayerStatuses::getQueriesCount(TPlayerColor player)
}
}
bool PlayerStatuses::checkFlag(TPlayerColor player, bool PlayerStatus::*flag)
bool PlayerStatuses::checkFlag(PlayerColor player, bool PlayerStatus::*flag)
{
boost::unique_lock<boost::mutex> l(mx);
if(players.find(player) != players.end())
@ -148,7 +148,7 @@ bool PlayerStatuses::checkFlag(TPlayerColor player, bool PlayerStatus::*flag)
throw std::runtime_error("No such player!");
}
}
void PlayerStatuses::setFlag(TPlayerColor player, bool PlayerStatus::*flag, bool val)
void PlayerStatuses::setFlag(PlayerColor player, bool PlayerStatus::*flag, bool val)
{
boost::unique_lock<boost::mutex> l(mx);
if(players.find(player) != players.end())
@ -161,7 +161,7 @@ void PlayerStatuses::setFlag(TPlayerColor player, bool PlayerStatus::*flag, bool
}
cv.notify_all();
}
void PlayerStatuses::addQuery(TPlayerColor player, ui32 id)
void PlayerStatuses::addQuery(PlayerColor player, ui32 id)
{
boost::unique_lock<boost::mutex> l(mx);
if(players.find(player) != players.end())
@ -174,7 +174,7 @@ void PlayerStatuses::addQuery(TPlayerColor player, ui32 id)
}
cv.notify_all();
}
void PlayerStatuses::removeQuery(TPlayerColor player, ui32 id)
void PlayerStatuses::removeQuery(PlayerColor player, ui32 id)
{
boost::unique_lock<boost::mutex> l(mx);
if(players.find(player) != players.end())
@ -273,7 +273,7 @@ void CGameHandler::levelUpHero(const CGHeroInstance * hero)
hlu.skills.push_back(hero->type->heroClass->chooseSecSkill(basicAndAdv)); //upgrade existing
}
if (hero->tempOwner == GameConstants::NEUTRAL_PLAYER) //choose skill automatically
if (hero->tempOwner == PlayerColor::NEUTRAL) //choose skill automatically
{
sendAndApply (&hlu);
if (hlu.skills.size())
@ -426,7 +426,7 @@ void CGameHandler::levelUpCommander(const CCommanderInstance * c)
}
int skillAmount = clu.skills.size();
if (hero->tempOwner == GameConstants::NEUTRAL_PLAYER) //choose skill automatically
if (hero->tempOwner == PlayerColor::NEUTRAL) //choose skill automatically
{
sendAndApply(&clu);
if (clu.skills.size())
@ -526,9 +526,9 @@ void CGameHandler::endBattle(int3 tile, const CGHeroInstance *hero1, const CGHer
if(!duel)
{
//unblock engaged players
if(bEndArmy1->tempOwner<GameConstants::PLAYER_LIMIT)
if(bEndArmy1->tempOwner<PlayerColor::PLAYER_LIMIT)
states.setFlag(bEndArmy1->tempOwner, &PlayerStatus::engagedIntoBattle, false);
if(bEndArmy2 && bEndArmy2->tempOwner<GameConstants::PLAYER_LIMIT)
if(bEndArmy2 && bEndArmy2->tempOwner<PlayerColor::PLAYER_LIMIT)
states.setFlag(bEndArmy2->tempOwner, &PlayerStatus::engagedIntoBattle, false);
}
@ -539,12 +539,12 @@ void CGameHandler::endBattle(int3 tile, const CGHeroInstance *hero1, const CGHer
if (hero2)
battleResult.data->exp[1] = hero2->calculateXp(battleResult.data->exp[1]);
ui8 sides[2];
PlayerColor sides[2];
for(int i=0; i<2; ++i)
{
sides[i] = gs->curB->sides[i];
}
ui8 loser = sides[!battleResult.data->winner];
PlayerColor loser = sides[!battleResult.data->winner];
CasualtiesAfterBattle cab1(bEndArmy1, gs->curB), cab2(bEndArmy2, gs->curB); //calculate casualties before deleting battle
ChangeSpells cs; //for Eagle Eye
@ -741,7 +741,7 @@ void CGameHandler::endBattle(int3 tile, const CGHeroInstance *hero1, const CGHer
}
visitObjectAfterVictory = false;
winLoseHandle(1<<sides[0] | 1<<sides[1]); //handle victory/loss of engaged players
winLoseHandle(1<<sides[0].getNum() | 1<<sides[1].getNum()); //handle victory/loss of engaged players
if(result == BattleResult::SURRENDER || result == BattleResult::ESCAPE) //loser has escaped or surrendered
{
@ -885,7 +885,7 @@ void CGameHandler::applyBattleEffects(BattleAttack &bat, const CStack *att, cons
bat.bsa.push_back(bsa);
}
}
void CGameHandler::handleConnection(std::set<int> players, CConnection &c)
void CGameHandler::handleConnection(std::set<PlayerColor> players, CConnection &c)
{
setThreadName("CGameHandler::handleConnection");
srand(time(NULL));
@ -895,7 +895,7 @@ void CGameHandler::handleConnection(std::set<int> players, CConnection &c)
while(1)//server should never shut connection first //was: while(!end2)
{
CPack *pack = NULL;
ui8 player = 255;
PlayerColor player = PlayerColor::NEUTRAL;
si32 requestID = -999;
int packType = 0;
@ -905,7 +905,7 @@ void CGameHandler::handleConnection(std::set<int> players, CConnection &c)
packType = typeList.getTypeID(pack); //get the id of type
tlog5 << boost::format("Received client message (request %d by player %d) of type with ID=%d (%s).\n")
% requestID % (int)player % packType % typeid(*pack).name();
% requestID % player.getNum() % packType % typeid(*pack).name();
}
//prepare struct informing that action was applied
@ -918,7 +918,7 @@ void CGameHandler::handleConnection(std::set<int> players, CConnection &c)
CBaseForGHApply *apply = applier->apps[packType]; //and appropriae applier object
if(isBlockedByQueries(pack, packType, player))
{
complain(boost::str(boost::format("Player %d has to answer queries before attempting any further actions (count=%d)!") % (int)player % states.getQueriesCount(player)));
complain(boost::str(boost::format("Player %d has to answer queries before attempting any further actions (count=%d)!") % player.getNum() % states.getQueriesCount(player)));
{
boost::unique_lock<boost::mutex> lock(*c.wmx);
c << &applied;
@ -1164,7 +1164,7 @@ void CGameHandler::newTurn()
bool newWeek = getDate(Date::DAY_OF_WEEK) == 7; //day numbers are confusing, as day was not yet switched
bool newMonth = getDate(Date::DAY_OF_MONTH) == 28;
std::map<ui8, si32> hadGold;//starting gold - for buildings like dwarven treasury
std::map<PlayerColor, si32> hadGold;//starting gold - for buildings like dwarven treasury
srand(time(NULL));
if (firstTurn)
@ -1241,12 +1241,12 @@ void CGameHandler::newTurn()
for ( auto i=gs->players.begin() ; i!=gs->players.end();i++)
{
if(i->first == 255)
if(i->first == PlayerColor::NEUTRAL)
continue;
else if(i->first >= GameConstants::PLAYER_LIMIT)
else if(i->first >= PlayerColor::PLAYER_LIMIT)
assert(0); //illegal player number!
std::pair<TPlayerColor,si32> playerGold(i->first,i->second.resources[Res::GOLD]);
std::pair<PlayerColor, si32> playerGold(i->first, i->second.resources[Res::GOLD]);
hadGold.insert(playerGold);
if(newWeek) //new heroes in tavern
@ -1305,7 +1305,7 @@ void CGameHandler::newTurn()
BOOST_FOREACH(CGTownInstance *t, gs->map->towns)
{
ui8 player = t->tempOwner;
PlayerColor player = t->tempOwner;
handleTownEvents(t, n, newCreas);
if(newWeek) //first day of week
{
@ -1313,7 +1313,7 @@ void CGameHandler::newTurn()
setPortalDwelling(t, true, (n.specialWeek == NewTurn::PLAGUE ? true : false)); //set creatures for Portal of Summoning
if(!firstTurn)
if (t->hasBuilt(BuildingID::TREASURY, ETownType::RAMPART) && player < GameConstants::PLAYER_LIMIT)
if (t->hasBuilt(BuildingID::TREASURY, ETownType::RAMPART) && player < PlayerColor::PLAYER_LIMIT)
n.res[player][Res::GOLD] += hadGold[player]/10; //give 10% of starting gold
SetAvailableCreatures sac;
@ -1356,7 +1356,7 @@ void CGameHandler::newTurn()
n.cres.push_back(sac);
}
if(!firstTurn && player < GameConstants::PLAYER_LIMIT)//not the first day and town not neutral
if(!firstTurn && player < PlayerColor::PLAYER_LIMIT)//not the first day and town not neutral
{
if(t->hasBuilt(BuildingID::RESOURCE_SILO)) //there is resource silo
{
@ -1377,7 +1377,7 @@ void CGameHandler::newTurn()
{
// Skyship, probably easier to handle same as Veil of darkness
//do it every new day after veils apply
if (player != GameConstants::NEUTRAL_PLAYER) //do not reveal fow for neutral player
if (player != PlayerColor::NEUTRAL) //do not reveal fow for neutral player
{
FoWChange fw;
fw.mode = 1;
@ -1480,27 +1480,27 @@ void CGameHandler::newTurn()
{
for (auto i=gs->players.cbegin() ; i!=gs->players.cend();i++)
{
if(i->second.status || i->second.towns.size() || i->second.color >= GameConstants::PLAYER_LIMIT)
if(i->second.status || i->second.towns.size() || i->second.color >= PlayerColor::PLAYER_LIMIT)
continue;
InfoWindow iw;
iw.player = i->first;
iw.components.push_back(Component(Component::FLAG,i->first,0,0));
iw.components.push_back(Component(Component::FLAG, i->first.getNum(), 0, 0));
if(!i->second.daysWithoutCastle)
{
iw.text.addTxt(MetaString::GENERAL_TXT,6); //%s, you have lost your last town. If you do not conquer another town in the next week, you will be eliminated.
iw.text.addReplacement(MetaString::COLOR, i->first);
iw.text.addReplacement(MetaString::COLOR, i->first.getNum());
}
else if(i->second.daysWithoutCastle == 6)
{
iw.text.addTxt(MetaString::ARRAY_TXT,129); //%s, this is your last day to capture a town or you will be banished from this land.
iw.text.addReplacement(MetaString::COLOR, i->first);
iw.text.addReplacement(MetaString::COLOR, i->first.getNum());
}
else
{
iw.text.addTxt(MetaString::ARRAY_TXT,128); //%s, you only have %d days left to capture a town or you will be banished from this land.
iw.text.addReplacement(MetaString::COLOR, i->first);
iw.text.addReplacement(MetaString::COLOR, i->first.getNum());
iw.text.addReplacement(7 - i->second.daysWithoutCastle);
}
sendAndApply(&iw);
@ -1519,13 +1519,13 @@ void CGameHandler::run(bool resume)
(*cc) << gs->initialOpts; // gs->scenarioOps
}
std::set<TPlayerColor> players;
std::set<PlayerColor> players;
(*cc) >> players; //how many players will be handled at that client
tlog0 << "Connection " << cc->connectionID << " will handle " << players.size() << " player: ";
BOOST_FOREACH(TPlayerColor color, players)
BOOST_FOREACH(PlayerColor color, players)
{
tlog0 << static_cast<int>(color) << " ";
tlog0 << color << " ";
{
boost::unique_lock<boost::recursive_mutex> lock(gsm);
connections[color] = cc;
@ -1540,8 +1540,8 @@ void CGameHandler::run(bool resume)
for(std::set<CConnection*>::iterator i = conns.begin(); i!=conns.end();i++)
{
std::set<int> pom;
for(std::map<int,CConnection*>::iterator j = connections.begin(); j!=connections.end();j++)
std::set<PlayerColor> pom;
for(auto j = connections.cbegin(); j!=connections.cend();j++)
if(j->second == *i)
pom.insert(j->first);
@ -1559,7 +1559,7 @@ void CGameHandler::run(bool resume)
if(!resume)
newTurn();
std::map<TPlayerColor,PlayerState>::iterator i;
std::map<PlayerColor,PlayerState>::iterator i;
if(!resume)
i = gs->players.begin();
else
@ -1569,7 +1569,7 @@ void CGameHandler::run(bool resume)
for(; i != gs->players.end(); i++)
{
if((i->second.towns.size()==0 && i->second.heroes.size()==0)
|| i->first>=GameConstants::PLAYER_LIMIT
|| i->first>=PlayerColor::PLAYER_LIMIT
|| i->second.status)
{
continue;
@ -1683,18 +1683,18 @@ void CGameHandler::setAmount(ObjectInstanceID objid, ui32 val)
sendAndApply(&sop);
}
bool CGameHandler::moveHero( ObjectInstanceID hid, int3 dst, ui8 instant, TPlayerColor asker /*= 255*/ )
bool CGameHandler::moveHero( ObjectInstanceID hid, int3 dst, ui8 instant, PlayerColor asker /*= 255*/ )
{
const CGHeroInstance *h = getHero(hid);
if(!h || (asker != GameConstants::NEUTRAL_PLAYER && (instant || h->getOwner() != gs->currentPlayer)) //not turn of that hero or player can't simply teleport hero (at least not with this function)
if(!h || (asker != PlayerColor::NEUTRAL && (instant || h->getOwner() != gs->currentPlayer)) //not turn of that hero or player can't simply teleport hero (at least not with this function)
)
{
tlog1 << "Illegal call to move hero!\n";
return false;
}
tlog5 << "Player " <<int(asker) << " wants to move hero "<< hid.getNum() << " from "<< h->pos << " to " << dst << std::endl;
tlog5 << "Player " << asker << " wants to move hero "<< hid.getNum() << " from "<< h->pos << " to " << dst << std::endl;
int3 hmpos = dst + int3(-1,0,0);
if(!gs->map->isInTheMap(hmpos))
@ -1763,7 +1763,7 @@ bool CGameHandler::moveHero( ObjectInstanceID hid, int3 dst, ui8 instant, TPlaye
{
BOOST_FOREACH(CGObjectInstance *obj, t.visitableObjects)
{
if(obj != h && obj->blockVisit && !(obj->getPassableness() & 1<<h->tempOwner))
if(obj != h && obj->blockVisit && !(obj->getPassableness() & 1<<h->tempOwner.getNum()))
{
applyWithResult(TryMoveHero::BLOCKING_VISIT);
@ -1844,7 +1844,7 @@ bool CGameHandler::moveHero( ObjectInstanceID hid, int3 dst, ui8 instant, TPlaye
}
}
bool CGameHandler::teleportHero(ObjectInstanceID hid, ObjectInstanceID dstid, ui8 source, TPlayerColor asker/* = 255*/)
bool CGameHandler::teleportHero(ObjectInstanceID hid, ObjectInstanceID dstid, ui8 source, PlayerColor asker/* = 255*/)
{
const CGHeroInstance *h = getHero(hid);
const CGTownInstance *t = getTown(dstid);
@ -1866,14 +1866,14 @@ bool CGameHandler::teleportHero(ObjectInstanceID hid, ObjectInstanceID dstid, ui
return true;
}
void CGameHandler::setOwner(const CGObjectInstance * obj, TPlayerColor owner)
void CGameHandler::setOwner(const CGObjectInstance * obj, PlayerColor owner)
{
ui8 oldOwner = getOwner(obj->id);
SetObjectProperty sop(obj->id,1,owner);
PlayerColor oldOwner = getOwner(obj->id);
SetObjectProperty sop(obj->id, 1, owner.getNum());
sendAndApply(&sop);
winLoseHandle(1<<owner | 1<<oldOwner);
if(owner < GameConstants::PLAYER_LIMIT && dynamic_cast<const CGTownInstance *>(obj)) //town captured
winLoseHandle(1<<owner.getNum() | 1<<oldOwner.getNum());
if(owner < PlayerColor::PLAYER_LIMIT && dynamic_cast<const CGTownInstance *>(obj)) //town captured
{
const CGTownInstance * town = dynamic_cast<const CGTownInstance *>(obj);
if (town->hasBuilt(BuildingID::PORTAL_OF_SUMMON, ETownType::DUNGEON))
@ -1927,7 +1927,7 @@ ui32 CGameHandler::showBlockingDialog( BlockingDialog *iw )
return 0;
}
void CGameHandler::giveResource(TPlayerColor player, Res::ERes which, int val) //TODO: cap according to Bersy's suggestion
void CGameHandler::giveResource(PlayerColor player, Res::ERes which, int val) //TODO: cap according to Bersy's suggestion
{
if(!val) return; //don't waste time on empty call
SetResource sr;
@ -2035,7 +2035,7 @@ void CGameHandler::startBattleI(const CArmedInstance *army1, const CArmedInstanc
engageIntoBattle(army1->tempOwner);
engageIntoBattle(army2->tempOwner);
//block engaged players
if(army2->tempOwner < GameConstants::PLAYER_LIMIT)
if(army2->tempOwner < PlayerColor::PLAYER_LIMIT)
states.setFlag(army2->tempOwner,&PlayerStatus::engagedIntoBattle,true);
static const CArmedInstance *armies[2];
@ -2096,7 +2096,7 @@ void CGameHandler::setManaPoints( ObjectInstanceID hid, int val )
sendAndApply(&sm);
}
void CGameHandler::giveHero( ObjectInstanceID id, TPlayerColor player )
void CGameHandler::giveHero( ObjectInstanceID id, PlayerColor player )
{
GiveHero gh;
gh.id = id;
@ -2204,8 +2204,8 @@ void CGameHandler::useScholarSkill(ObjectInstanceID fromHero, ObjectInstanceID t
void CGameHandler::heroExchange(ObjectInstanceID hero1, ObjectInstanceID hero2)
{
TPlayerColor player1 = getHero(hero1)->tempOwner;
TPlayerColor player2 = getHero(hero2)->tempOwner;
PlayerColor player1 = getHero(hero1)->tempOwner;
PlayerColor player2 = getHero(hero2)->tempOwner;
if( gameState()->getPlayerRelations( player1, player2))
{
@ -2218,24 +2218,24 @@ void CGameHandler::heroExchange(ObjectInstanceID hero1, ObjectInstanceID hero2)
}
}
void CGameHandler::prepareNewQuery(Query * queryPack, TPlayerColor player, const boost::function<void(ui32)> &callback)
void CGameHandler::prepareNewQuery(Query * queryPack, PlayerColor player, const boost::function<void(ui32)> &callback)
{
boost::unique_lock<boost::recursive_mutex> lock(gsm);
tlog4 << "Creating a query for player " << (int)player << " with ID=" << QID << std::endl;
tlog4 << "Creating a query for player " << player << " with ID=" << QID << std::endl;
callbacks[QID] = callback;
states.addQuery(player, QID);
queryPack->queryID = QID;
QID++;
}
void CGameHandler::applyAndAsk( Query * sel, TPlayerColor player, boost::function<void(ui32)> &callback )
void CGameHandler::applyAndAsk( Query * sel, PlayerColor player, boost::function<void(ui32)> &callback )
{
boost::unique_lock<boost::recursive_mutex> lock(gsm);
prepareNewQuery(sel, player, callback);
sendAndApply(sel);
}
void CGameHandler::ask( Query * sel, TPlayerColor player, const CFunctionList<void(ui32)> &callback )
void CGameHandler::ask( Query * sel, PlayerColor player, const CFunctionList<void(ui32)> &callback )
{
boost::unique_lock<boost::recursive_mutex> lock(gsm);
prepareNewQuery(sel, player, callback);
@ -2352,7 +2352,7 @@ void CGameHandler::close()
//exit(0);
}
bool CGameHandler::arrangeStacks( ObjectInstanceID id1, ObjectInstanceID id2, ui8 what, SlotID p1, SlotID p2, si32 val, TPlayerColor player )
bool CGameHandler::arrangeStacks( ObjectInstanceID id1, ObjectInstanceID id2, ui8 what, SlotID p1, SlotID p2, si32 val, PlayerColor player )
{
const CArmedInstance *s1 = static_cast<CArmedInstance*>(gs->getObjInstance(id1)),
*s2 = static_cast<CArmedInstance*>(gs->getObjInstance(id2));
@ -2372,8 +2372,8 @@ bool CGameHandler::arrangeStacks( ObjectInstanceID id1, ObjectInstanceID id2, ui
if(what==1) //swap
{
if ( ((s1->tempOwner != player && s1->tempOwner != GameConstants::UNFLAGGABLE_PLAYER) && s1->getStackCount(p1)) //why 254??
|| ((s2->tempOwner != player && s2->tempOwner != GameConstants::UNFLAGGABLE_PLAYER) && s2->getStackCount(p2)))
if ( ((s1->tempOwner != player && s1->tempOwner != PlayerColor::UNFLAGGABLE) && s1->getStackCount(p1)) //why 254??
|| ((s2->tempOwner != player && s2->tempOwner != PlayerColor::UNFLAGGABLE) && s2->getStackCount(p2)))
{
complain("Can't take troops from another player!");
return false;
@ -2384,7 +2384,7 @@ bool CGameHandler::arrangeStacks( ObjectInstanceID id1, ObjectInstanceID id2, ui
else if(what==2)//merge
{
if (( s1->getCreature(p1) != s2->getCreature(p2) && complain("Cannot merge different creatures stacks!"))
|| (((s1->tempOwner != player && s1->tempOwner != GameConstants::UNFLAGGABLE_PLAYER) && s2->getStackCount(p2)) && complain("Can't take troops from another player!")))
|| (((s1->tempOwner != player && s1->tempOwner != PlayerColor::UNFLAGGABLE) && s2->getStackCount(p2)) && complain("Can't take troops from another player!")))
return false;
moveStack(sl1, sl2);
@ -2436,26 +2436,26 @@ bool CGameHandler::arrangeStacks( ObjectInstanceID id1, ObjectInstanceID id2, ui
return true;
}
TPlayerColor CGameHandler::getPlayerAt( CConnection *c ) const
PlayerColor CGameHandler::getPlayerAt( CConnection *c ) const
{
std::set<int> all;
for(std::map<int,CConnection*>::const_iterator i=connections.begin(); i!=connections.end(); i++)
std::set<PlayerColor> all;
for(auto i=connections.cbegin(); i!=connections.cend(); i++)
if(i->second == c)
all.insert(i->first);
switch(all.size())
{
case 0:
return 255;
return PlayerColor::NEUTRAL;
case 1:
return *all.begin();
default:
{
//if we have more than one player at this connection, try to pick active one
if(vstd::contains(all,int(gs->currentPlayer)))
if(vstd::contains(all, gs->currentPlayer))
return gs->currentPlayer;
else
return 253; //cannot say which player is it
return PlayerColor::CANNOT_DETERMINE; //cannot say which player is it
}
}
}
@ -2713,7 +2713,7 @@ bool CGameHandler::upgradeCreature( ObjectInstanceID objid, SlotID pos, Creature
CArmedInstance *obj = static_cast<CArmedInstance*>(gs->getObjInstance(objid));
assert(obj->hasStackAtSlot(pos));
UpgradeInfo ui = gs->getUpgradeInfo(obj->getStack(pos));
int player = obj->tempOwner;
PlayerColor player = obj->tempOwner;
const PlayerState *p = getPlayer(player);
int crQuantity = obj->stacks[pos]->count;
int newIDpos= vstd::find_pos(ui.newID, upgID);//get position of new id in UpgradeInfo
@ -2842,7 +2842,7 @@ bool CGameHandler::garrisonSwap( ObjectInstanceID tid )
bool CGameHandler::moveArtifact(const ArtifactLocation &al1, const ArtifactLocation &al2)
{
ArtifactLocation src = al1, dst = al2;
const int srcPlayer = src.owningPlayer(), dstPlayer = dst.owningPlayer();
const PlayerColor srcPlayer = src.owningPlayer(), dstPlayer = dst.owningPlayer();
const CArmedInstance *srcObj = src.relatedObj(), *dstObj = dst.relatedObj();
// Make sure exchange is even possible between the two heroes.
@ -3080,7 +3080,7 @@ bool CGameHandler::buySecSkill( const IMarket *m, const CGHeroInstance *h, Secon
return true;
}
bool CGameHandler::tradeResources(const IMarket *market, ui32 val, TPlayerColor player, ui32 id1, ui32 id2)
bool CGameHandler::tradeResources(const IMarket *market, ui32 val, PlayerColor player, ui32 id1, ui32 id2)
{
int r1 = gs->getPlayer(player)->resources[id1],
r2 = gs->getPlayer(player)->resources[id2];
@ -3170,7 +3170,7 @@ bool CGameHandler::transformInUndead(const IMarket *market, const CGHeroInstance
return true;
}
bool CGameHandler::sendResources(ui32 val, TPlayerColor player, Res::ERes r1, TPlayerColor r2)
bool CGameHandler::sendResources(ui32 val, PlayerColor player, Res::ERes r1, PlayerColor r2)
{
const PlayerState *p2 = gs->getPlayer(r2, false);
if(!p2 || p2->status != EPlayerStatus::INGAME)
@ -3201,13 +3201,14 @@ bool CGameHandler::setFormation( ObjectInstanceID hid, ui8 formation )
return true;
}
bool CGameHandler::hireHero(const CGObjectInstance *obj, ui8 hid, TPlayerColor player)
bool CGameHandler::hireHero(const CGObjectInstance *obj, ui8 hid, PlayerColor player)
{
const PlayerState *p = gs->getPlayer(player);
const CGTownInstance *t = gs->getTown(obj->id);
static const int GOLD_NEEDED = 2500;
//common preconditions
if( (p->resources[Res::GOLD]<2500 && complain("Not enough gold for buying hero!"))
if( (p->resources[Res::GOLD]<GOLD_NEEDED && complain("Not enough gold for buying hero!"))
|| (getHeroCount(player, false) >= GameConstants::MAX_HEROES_PER_PLAYER && complain("Cannot hire hero, only 8 wandering heroes are allowed!")))
return false;
@ -3264,7 +3265,7 @@ bool CGameHandler::hireHero(const CGObjectInstance *obj, ui8 hid, TPlayerColor p
SetResource sr;
sr.player = player;
sr.resid = Res::GOLD;
sr.val = p->resources[Res::GOLD] - 2500;
sr.val = p->resources[Res::GOLD] - GOLD_NEEDED;
sendAndApply(&sr);
if(t)
@ -3275,7 +3276,7 @@ bool CGameHandler::hireHero(const CGObjectInstance *obj, ui8 hid, TPlayerColor p
return true;
}
bool CGameHandler::queryReply(ui32 qid, ui32 answer, TPlayerColor player)
bool CGameHandler::queryReply(ui32 qid, ui32 answer, PlayerColor player)
{
boost::unique_lock<boost::recursive_mutex> lock(gsm);
states.removeQuery(player, qid);
@ -3396,7 +3397,7 @@ bool CGameHandler::makeBattleAction( BattleAction &ba )
}
case Battle::SURRENDER:
{
int player = gs->curB->sides[ba.side];
PlayerColor player = gs->curB->sides[ba.side];
int cost = gs->curB->battleGetSurrenderCost(player);
if(cost < 0)
complain("Cannot surrender!");
@ -3780,10 +3781,10 @@ bool CGameHandler::makeBattleAction( BattleAction &ba )
return ok;
}
void CGameHandler::playerMessage( TPlayerColor player, const std::string &message )
void CGameHandler::playerMessage( PlayerColor player, const std::string &message )
{
bool cheated=true;
PlayerMessage temp_message(player,message);
PlayerMessage temp_message(player, message);
sendAndApply(&temp_message);
if(message == "vcmiistari") //give all spells and 999 mana
@ -3924,7 +3925,7 @@ void CGameHandler::playerMessage( TPlayerColor player, const std::string &messag
}
}
void CGameHandler::handleSpellCasting( SpellID spellID, int spellLvl, BattleHex destination, ui8 casterSide, TPlayerColor casterColor, const CGHeroInstance * caster, const CGHeroInstance * secHero,
void CGameHandler::handleSpellCasting( SpellID spellID, int spellLvl, BattleHex destination, ui8 casterSide, PlayerColor casterColor, const CGHeroInstance * caster, const CGHeroInstance * secHero,
int usedSpellPower, ECastingMode::ECastingMode mode, const CStack * stack, si32 selectedStack)
{
const CSpell *spell = SpellID(spellID).toSpell();
@ -4415,7 +4416,7 @@ void CGameHandler::handleSpellCasting( SpellID spellID, int spellLvl, BattleHex
std::vector<CStack *> & battleStacks = gs->curB->stacks;
for (size_t j = 0; j < battleStacks.size(); ++j)
{
if(battleStacks[j]->owner == casterSide) //get enemy stacks which can be affected by this spell
if(battleStacks[j]->owner == gs->curB->sides[casterSide]) //get enemy stacks which can be affected by this spell
{
if (!gs->curB->battleIsImmune(NULL, spell, ECastingMode::MAGIC_MIRROR, battleStacks[j]->position))
mirrorTargets.push_back(battleStacks[j]);
@ -4705,9 +4706,9 @@ void CGameHandler::handleTimeEvents()
while(gs->map->events.size() && gs->map->events.front().firstOccurence+1 == gs->day)
{
CMapEvent ev = gs->map->events.front();
for(int player = 0; player < GameConstants::PLAYER_LIMIT; player++)
for(int player = 0; player < PlayerColor::PLAYER_LIMIT_I; player++)
{
PlayerState *pinfo = gs->getPlayer(player);
PlayerState *pinfo = gs->getPlayer(PlayerColor(player));
if( pinfo //player exists
&& (ev.players & 1<<player) //event is enabled to this player
@ -4718,12 +4719,12 @@ void CGameHandler::handleTimeEvents()
{
//give resources
SetResources sr;
sr.player = player;
sr.player = PlayerColor(player);
sr.res = pinfo->resources + ev.resources;
//prepare dialog
InfoWindow iw;
iw.player = player;
iw.player = PlayerColor(player);
iw.text << ev.message;
for (int i=0; i<ev.resources.size(); i++)
@ -4769,12 +4770,12 @@ void CGameHandler::handleTownEvents(CGTownInstance * town, NewTurn &n, std::map<
town->events.sort(evntCmp);
while(town->events.size() && town->events.front().firstOccurence == gs->day)
{
ui8 player = town->tempOwner;
PlayerColor player = town->tempOwner;
CCastleEvent ev = town->events.front();
PlayerState *pinfo = gs->getPlayer(player);
if( pinfo //player exists
&& (ev.players & 1<<player) //event is enabled to this player
&& (ev.players & 1<<player.getNum()) //event is enabled to this player
&& ((ev.computerAffected && !pinfo->human)
|| (ev.humanAffected && pinfo->human) ) )
{
@ -4848,7 +4849,7 @@ bool CGameHandler::complain( const std::string &problem )
return true;
}
ui32 CGameHandler::getQueryResult( TPlayerColor player, int queryID )
ui32 CGameHandler::getQueryResult( PlayerColor player, int queryID )
{
//TODO: write
return 0;
@ -4856,7 +4857,7 @@ ui32 CGameHandler::getQueryResult( TPlayerColor player, int queryID )
void CGameHandler::showGarrisonDialog( ObjectInstanceID upobj, ObjectInstanceID hid, bool removableUnits, const boost::function<void()> &cb )
{
ui8 player = getOwner(hid);
PlayerColor player = getOwner(hid);
GarrisonDialog gd;
gd.hid = hid;
gd.objid = upobj;
@ -4881,11 +4882,11 @@ void CGameHandler::showGarrisonDialog( ObjectInstanceID upobj, ObjectInstanceID
}
}
void CGameHandler::showThievesGuildWindow(TPlayerColor player, ObjectInstanceID requestingObjId)
void CGameHandler::showThievesGuildWindow(PlayerColor player, ObjectInstanceID requestingObjId)
{
OpenWindow ow;
ow.window = OpenWindow::THIEVES_GUILD;
ow.id1 = player;
ow.id1 = player.getNum();
ow.id2 = requestingObjId.getNum();
sendAndApply(&ow);
}
@ -4974,7 +4975,7 @@ bool CGameHandler::buildBoat( ObjectInstanceID objid )
return false;
}
const TPlayerColor playerID = obj->o->tempOwner;
const PlayerColor playerID = obj->o->tempOwner;
TResources boatCost;
obj->getBoatCost(boatCost);
TResources aviable = gs->getPlayer(playerID)->resources;
@ -5008,7 +5009,7 @@ bool CGameHandler::buildBoat( ObjectInstanceID objid )
return true;
}
void CGameHandler::engageIntoBattle( ui8 player )
void CGameHandler::engageIntoBattle( PlayerColor player )
{
if(vstd::contains(states.players, player))
states.setFlag(player,&PlayerStatus::engagedIntoBattle,true);
@ -5023,16 +5024,16 @@ void CGameHandler::engageIntoBattle( ui8 player )
void CGameHandler::winLoseHandle(ui8 players )
{
for(size_t i = 0; i < GameConstants::PLAYER_LIMIT; i++)
for(size_t i = 0; i < PlayerColor::PLAYER_LIMIT_I; i++)
{
if(players & 1<<i && gs->getPlayer(i))
if(players & 1<<i && gs->getPlayer(PlayerColor(i)))
{
checkLossVictory(i);
checkLossVictory(PlayerColor(i));
}
}
}
void CGameHandler::checkLossVictory( TPlayerColor player )
void CGameHandler::checkLossVictory( PlayerColor player )
{
const PlayerState *p = gs->getPlayer(player);
if(p->status) //player already won / lost
@ -5060,7 +5061,7 @@ void CGameHandler::checkLossVictory( TPlayerColor player )
for (auto i = gs->players.cbegin(); i!=gs->players.cend(); i++)
{
if(i->first < GameConstants::PLAYER_LIMIT && i->first != player)//FIXME: skip already eliminated players?
if(i->first < PlayerColor::PLAYER_LIMIT && i->first != player)//FIXME: skip already eliminated players?
{
iw.player = i->first;
sendAndApply(&iw);
@ -5080,11 +5081,11 @@ void CGameHandler::checkLossVictory( TPlayerColor player )
for (auto i = gs->map->objects.cbegin(); i != gs->map->objects.cend(); i++) //unflag objs
{
if(*i && (*i)->tempOwner == player)
setOwner(*i,GameConstants::NEUTRAL_PLAYER);
setOwner(*i,PlayerColor::NEUTRAL);
}
//eliminating one player may cause victory of another:
winLoseHandle(GameConstants::ALL_PLAYERS & ~(1<<player));
winLoseHandle(GameConstants::ALL_PLAYERS & ~(1<<player.getNum()));
}
if(vic && p->human)
@ -5121,7 +5122,7 @@ void CGameHandler::checkLossVictory( TPlayerColor player )
}
}
void CGameHandler::getLossVicMessage( TPlayerColor player, si8 standard, bool victory, InfoWindow &out ) const
void CGameHandler::getLossVicMessage( PlayerColor player, si8 standard, bool victory, InfoWindow &out ) const
{
// const PlayerState *p = gs->getPlayer(player);
// if(!p->human)
@ -5220,8 +5221,8 @@ void CGameHandler::getLossVicMessage( TPlayerColor player, si8 standard, bool vi
else if(standard == 2)
{
out.text.addTxt(MetaString::GENERAL_TXT, 7);//%s, your heroes abandon you, and you are banished from this land.
out.text.addReplacement(MetaString::COLOR, player);
out.components.push_back(Component(Component::FLAG,player,0,0));
out.text.addReplacement(MetaString::COLOR, player.getNum());
out.components.push_back(Component(Component::FLAG, player.getNum(), 0, 0));
}
else //lost all towns and heroes
{
@ -6181,7 +6182,7 @@ void CGameHandler::spawnWanderingMonsters(CreatureID creatureID)
}
}
bool CGameHandler::isBlockedByQueries(const CPack *pack, int packType, TPlayerColor player)
bool CGameHandler::isBlockedByQueries(const CPack *pack, int packType, PlayerColor player)
{
//it's always legal to send query reply (we'll check later if it makes sense)
if(packType == typeList.getTypeID<QueryReply>())
@ -6218,9 +6219,9 @@ CasualtiesAfterBattle::CasualtiesAfterBattle(const CArmedInstance *army, BattleI
{
heroWithDeadCommander = ObjectInstanceID();
int color = army->tempOwner;
if(color == GameConstants::UNFLAGGABLE_PLAYER)
color = GameConstants::NEUTRAL_PLAYER;
PlayerColor color = army->tempOwner;
if(color == PlayerColor::UNFLAGGABLE)
color = PlayerColor::NEUTRAL;
BOOST_FOREACH(CStack *st, bat->stacks)
{

64
server/CGameHandler.h
View File

@ -53,17 +53,17 @@ struct PlayerStatus
class PlayerStatuses
{
public:
std::map<TPlayerColor,PlayerStatus> players;
std::map<PlayerColor,PlayerStatus> players;
boost::mutex mx;
boost::condition_variable cv; //notifies when any changes are made
void addPlayer(TPlayerColor player);
PlayerStatus operator[](TPlayerColor player);
int getQueriesCount(TPlayerColor player); //returns 0 if there is no such player
bool checkFlag(TPlayerColor player, bool PlayerStatus::*flag);
void setFlag(TPlayerColor player, bool PlayerStatus::*flag, bool val);
void addQuery(TPlayerColor player, ui32 id);
void removeQuery(TPlayerColor player, ui32 id);
void addPlayer(PlayerColor player);
PlayerStatus operator[](PlayerColor player);
int getQueriesCount(PlayerColor player); //returns 0 if there is no such player
bool checkFlag(PlayerColor player, bool PlayerStatus::*flag);
void setFlag(PlayerColor player, bool PlayerStatus::*flag, bool val);
void addQuery(PlayerColor player, ui32 id);
void removeQuery(PlayerColor player, ui32 id);
template <typename Handler> void serialize(Handler &h, const int version)
{
h & players;
@ -88,7 +88,7 @@ private:
bool isAllowedExchangeForQuery(ObjectInstanceID id1, ObjectInstanceID id2);
public:
CVCMIServer *s;
std::map<int,CConnection*> connections; //player color -> connection to client with interface of that player
std::map<PlayerColor, CConnection*> connections; //player color -> connection to client with interface of that player
PlayerStatuses states; //player color -> player state
std::set<CConnection*> conns;
@ -100,16 +100,16 @@ public:
std::map<ui32, CFunctionList<void(ui32)> > callbacks; //query id => callback function - for selection and yes/no dialogs
std::map<ui32, std::pair<ObjectInstanceID, ObjectInstanceID> > allowedExchanges;
bool isBlockedByQueries(const CPack *pack, int packType, TPlayerColor player);
bool isBlockedByQueries(const CPack *pack, int packType, PlayerColor player);
bool isAllowedExchange(ObjectInstanceID id1, ObjectInstanceID id2);
bool isAllowedArrangePack(const ArrangeStacks *pack);
void giveSpells(const CGTownInstance *t, const CGHeroInstance *h);
int moveStack(int stack, BattleHex dest); //returned value - travelled distance
void startBattle(const CArmedInstance *armies[2], int3 tile, const CGHeroInstance *heroes[2], bool creatureBank, boost::function<void(BattleResult*)> cb, const CGTownInstance *town = NULL); //use hero=NULL for no hero
void runBattle();
void checkLossVictory(TPlayerColor player);
void checkLossVictory(PlayerColor player);
void winLoseHandle(ui8 players=255); //players: bit field - colours of players to be checked; default: all
void getLossVicMessage(TPlayerColor player, si8 standard, bool victory, InfoWindow &out) const;
void getLossVicMessage(PlayerColor player, si8 standard, bool victory, InfoWindow &out) const;
////used only in endBattle - don't touch elsewhere
boost::function<void(BattleResult*)> * battleEndCallback;
@ -132,7 +132,7 @@ public:
void changeSpells(const CGHeroInstance * hero, bool give, const std::set<SpellID> &spells) OVERRIDE;
bool removeObject(const CGObjectInstance * obj) OVERRIDE;
void setBlockVis(ObjectInstanceID objid, bool bv) OVERRIDE;
void setOwner(const CGObjectInstance * obj, TPlayerColor owner) OVERRIDE;
void setOwner(const CGObjectInstance * obj, PlayerColor owner) OVERRIDE;
void setHoverName(const CGObjectInstance * objid, MetaString * name) OVERRIDE;
void changePrimSkill(const CGHeroInstance * hero, PrimarySkill::PrimarySkill which, si64 val, bool abs=false) OVERRIDE;
void changeSecSkill(const CGHeroInstance * hero, SecondarySkill which, int val, bool abs=false) OVERRIDE;
@ -140,8 +140,8 @@ public:
void showBlockingDialog(BlockingDialog *iw, const CFunctionList<void(ui32)> &callback) OVERRIDE;
ui32 showBlockingDialog(BlockingDialog *iw) OVERRIDE; //synchronous version of above
void showGarrisonDialog(ObjectInstanceID upobj, ObjectInstanceID hid, bool removableUnits, const boost::function<void()> &cb) OVERRIDE;
void showThievesGuildWindow(TPlayerColor player, ObjectInstanceID requestingObjId) OVERRIDE;
void giveResource(TPlayerColor player, Res::ERes which, int val) OVERRIDE;
void showThievesGuildWindow(PlayerColor player, ObjectInstanceID requestingObjId) OVERRIDE;
void giveResource(PlayerColor player, Res::ERes which, int val) OVERRIDE;
void giveCreatures(const CArmedInstance *objid, const CGHeroInstance * h, const CCreatureSet &creatures, bool remove) OVERRIDE;
void takeCreatures(ObjectInstanceID objid, const std::vector<CStackBasicDescriptor> &creatures) OVERRIDE;
@ -169,11 +169,11 @@ public:
void startBattleI(const CArmedInstance *army1, const CArmedInstance *army2, int3 tile, boost::function<void(BattleResult*)> cb = 0, bool creatureBank = false) OVERRIDE; //if any of armies is hero, hero will be used
void startBattleI(const CArmedInstance *army1, const CArmedInstance *army2, boost::function<void(BattleResult*)> cb = 0, bool creatureBank = false) OVERRIDE; //if any of armies is hero, hero will be used, visitable tile of second obj is place of battle//void startBattleI(int heroID, CCreatureSet army, int3 tile, boost::function<void(BattleResult*)> cb) OVERRIDE; //for hero<=>neutral army
void setAmount(ObjectInstanceID objid, ui32 val) OVERRIDE;
bool moveHero(ObjectInstanceID hid, int3 dst, ui8 instant, TPlayerColor asker = GameConstants::NEUTRAL_PLAYER) OVERRIDE;
bool moveHero(ObjectInstanceID hid, int3 dst, ui8 instant, PlayerColor asker = PlayerColor::NEUTRAL) OVERRIDE;
void giveHeroBonus(GiveBonus * bonus) OVERRIDE;
void setMovePoints(SetMovePoints * smp) OVERRIDE;
void setManaPoints(ObjectInstanceID hid, int val) OVERRIDE;
void giveHero(ObjectInstanceID id, TPlayerColor player) OVERRIDE;
void giveHero(ObjectInstanceID id, PlayerColor player) OVERRIDE;
void changeObjPos(ObjectInstanceID objid, int3 newPos, ui8 flags) OVERRIDE;
void heroExchange(ObjectInstanceID hero1, ObjectInstanceID hero2) OVERRIDE;
//////////////////////////////////////////////////////////////////////////
@ -181,7 +181,7 @@ public:
void setPortalDwelling(const CGTownInstance * town, bool forced, bool clear);
bool tryAttackingGuard(const int3 &guardPos, const CGHeroInstance * h);
void visitObjectOnTile(const TerrainTile &t, const CGHeroInstance * h);
bool teleportHero(ObjectInstanceID hid, ObjectInstanceID dstid, ui8 source, TPlayerColor asker = GameConstants::NEUTRAL_PLAYER);
bool teleportHero(ObjectInstanceID hid, ObjectInstanceID dstid, ui8 source, PlayerColor asker = PlayerColor::NEUTRAL);
void vistiCastleObjects (const CGTownInstance *t, const CGHeroInstance *h);
void levelUpHero(const CGHeroInstance * hero, SecondarySkill skill);//handle client respond and send one more request if needed
void levelUpHero(const CGHeroInstance * hero);//initial call - check if hero have remaining levelups & handle them
@ -193,25 +193,25 @@ public:
void commitPackage(CPackForClient *pack) OVERRIDE;
void init(StartInfo *si);
void handleConnection(std::set<int> players, CConnection &c);
TPlayerColor getPlayerAt(CConnection *c) const;
void handleConnection(std::set<PlayerColor> players, CConnection &c);
PlayerColor getPlayerAt(CConnection *c) const;
void playerMessage( TPlayerColor player, const std::string &message);
void playerMessage( PlayerColor player, const std::string &message);
bool makeBattleAction(BattleAction &ba);
bool makeAutomaticAction(const CStack *stack, BattleAction &ba); //used when action is taken by stack without volition of player (eg. unguided catapult attack)
void handleSpellCasting(SpellID spellID, int spellLvl, BattleHex destination, ui8 casterSide, TPlayerColor casterColor, const CGHeroInstance * caster, const CGHeroInstance * secHero,
void handleSpellCasting(SpellID spellID, int spellLvl, BattleHex destination, ui8 casterSide, PlayerColor casterColor, const CGHeroInstance * caster, const CGHeroInstance * secHero,
int usedSpellPower, ECastingMode::ECastingMode mode, const CStack * stack, si32 selectedStack = -1);
bool makeCustomAction(BattleAction &ba);
void stackTurnTrigger(const CStack * stack);
void handleDamageFromObstacle(const CObstacleInstance &obstacle, const CStack * curStack); //checks if obstacle is land mine and handles possible consequences
void removeObstacle(const CObstacleInstance &obstacle);
bool queryReply( ui32 qid, ui32 answer, TPlayerColor player );
bool hireHero( const CGObjectInstance *obj, ui8 hid, TPlayerColor player );
bool queryReply( ui32 qid, ui32 answer, PlayerColor player );
bool hireHero( const CGObjectInstance *obj, ui8 hid, PlayerColor player );
bool buildBoat( ObjectInstanceID objid );
bool setFormation( ObjectInstanceID hid, ui8 formation );
bool tradeResources(const IMarket *market, ui32 val, TPlayerColor player, ui32 id1, ui32 id2);
bool tradeResources(const IMarket *market, ui32 val, PlayerColor player, ui32 id1, ui32 id2);
bool sacrificeCreatures(const IMarket *market, const CGHeroInstance *hero, SlotID slot, ui32 count);
bool sendResources(ui32 val, TPlayerColor player, Res::ERes r1, TPlayerColor r2);
bool sendResources(ui32 val, PlayerColor player, Res::ERes r1, PlayerColor r2);
bool sellCreatures(ui32 count, const IMarket *market, const CGHeroInstance * hero, SlotID slot, Res::ERes resourceID);
bool transformInUndead(const IMarket *market, const CGHeroInstance * hero, SlotID slot);
bool assembleArtifacts (ObjectInstanceID heroID, ArtifactPosition artifactSlot, bool assemble, ArtifactID assembleTo);
@ -226,14 +226,14 @@ public:
bool buildStructure(ObjectInstanceID tid, BuildingID bid, bool force=false);//force - for events: no cost, no checkings
bool razeStructure(ObjectInstanceID tid, BuildingID bid);
bool disbandCreature( ObjectInstanceID id, SlotID pos );
bool arrangeStacks( ObjectInstanceID id1, ObjectInstanceID id2, ui8 what, SlotID p1, SlotID p2, si32 val, TPlayerColor player);
bool arrangeStacks( ObjectInstanceID id1, ObjectInstanceID id2, ui8 what, SlotID p1, SlotID p2, si32 val, PlayerColor player);
void save(const std::string &fname);
void close();
void handleTimeEvents();
void handleTownEvents(CGTownInstance *town, NewTurn &n, std::map<ObjectInstanceID, std::map<si32, si32> > &newCreas);
bool complain(const std::string &problem); //sends message to all clients, prints on the logs and return true
void objectVisited( const CGObjectInstance * obj, const CGHeroInstance * h );
void engageIntoBattle( TPlayerColor player );
void engageIntoBattle( PlayerColor player );
bool dig(const CGHeroInstance *h);
bool castSpell(const CGHeroInstance *h, SpellID spellID, const int3 &pos);
void moveArmy(const CArmedInstance *src, const CArmedInstance *dst, bool allowMerging);
@ -243,12 +243,12 @@ public:
h & QID & states;
}
ui32 getQueryResult(TPlayerColor player, int queryID);
ui32 getQueryResult(PlayerColor player, int queryID);
void sendMessageToAll(const std::string &message);
void sendMessageTo(CConnection &c, const std::string &message);
void applyAndAsk(Query * sel, TPlayerColor player, boost::function<void(ui32)> &callback);
void prepareNewQuery(Query * queryPack, TPlayerColor player, const boost::function<void(ui32)> &callback = 0); //generates unique query id and writes it to the pack; blocks the player till query is answered (then callback is called)
void ask(Query * sel, TPlayerColor player, const CFunctionList<void(ui32)> &callback);
void applyAndAsk(Query * sel, PlayerColor player, boost::function<void(ui32)> &callback);
void prepareNewQuery(Query * queryPack, PlayerColor player, const boost::function<void(ui32)> &callback = 0); //generates unique query id and writes it to the pack; blocks the player till query is answered (then callback is called)
void ask(Query * sel, PlayerColor player, const CFunctionList<void(ui32)> &callback);
void sendToAllClients(CPackForClient * info);
void sendAndApply(CPackForClient * info);
void applyAndSend(CPackForClient * info);

12
server/NetPacksServer.cpp
View File

@ -21,7 +21,7 @@
return false;} while(0)
#define WRONG_PLAYER_MSG(expectedplayer) do {std::ostringstream oss;\
oss << "You were identified as player " << (int)gh->getPlayerAt(c) << " while expecting " << (int)expectedplayer;\
oss << "You were identified as player " << gh->getPlayerAt(c) << " while expecting " << expectedplayer;\
tlog1 << oss.str() << std::endl; \
if(c) { SystemMessage temp_message(oss.str()); boost::unique_lock<boost::mutex> lock(*c->wmx); *c << &temp_message; } } while(0)
@ -67,7 +67,7 @@ bool CloseServer::applyGh( CGameHandler *gh )
bool EndTurn::applyGh( CGameHandler *gh )
{
int player = GS(gh)->currentPlayer;
PlayerColor player = GS(gh)->currentPlayer;
ERROR_IF_NOT(player);
if(gh->states.checkFlag(player, &PlayerStatus::engagedIntoBattle))
COMPLAIN_AND_RETURN("Cannot end turn when in battle!");
@ -158,12 +158,12 @@ bool TradeOnMarketplace::applyGh( CGameHandler *gh )
if(!m)
COMPLAIN_AND_RETURN("market is not-a-market! :/");
ui8 player = market->tempOwner;
PlayerColor player = market->tempOwner;
if(player >= GameConstants::PLAYER_LIMIT)
if(player >= PlayerColor::PLAYER_LIMIT)
player = gh->getTile(market->visitablePos())->visitableObjects.back()->tempOwner;
if(player >= GameConstants::PLAYER_LIMIT)
if(player >= PlayerColor::PLAYER_LIMIT)
COMPLAIN_AND_RETURN("No player can use this market!");
if(hero && (player != hero->tempOwner || hero->visitablePos() != market->visitablePos()))
@ -176,7 +176,7 @@ bool TradeOnMarketplace::applyGh( CGameHandler *gh )
case EMarketMode::RESOURCE_RESOURCE:
return gh->tradeResources(m, val, player, r1, r2);
case EMarketMode::RESOURCE_PLAYER:
return gh->sendResources(val, player, static_cast<Res::ERes>(r1), static_cast<TPlayerColor>(r2));
return gh->sendResources(val, player, static_cast<Res::ERes>(r1), PlayerColor(r2));
case EMarketMode::CREATURE_RESOURCE:
if(!hero)
COMPLAIN_AND_RETURN("Only hero can sell creatures!");