games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-24 22:14:36 +02:00
Code Issues Releases Activity

c++03 -> c++11 switch:

Browse Source 
- use std versions of function, bind and ref
- OVERRIDE -> override
- NULL -> nullptr
- use std versions of random distributions

NOTE: this may be last revision that supports gcc-4.5
This commit is contained in:
Ivan Savenko 2013-06-26 11:18:27 +00:00
parent 1a2c8de6ad
commit 2b45e13c5c
110 changed files with 1523 additions and 1567 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
AI/BattleAI/BattleAI.cpp
View File

@ -31,7 +31,7 @@ struct Priorities
} priorities;
int distToNearestNeighbour(BattleHex hex, const ReachabilityInfo::TDistances& dists, BattleHex *chosenHex = NULL)
int distToNearestNeighbour(BattleHex hex, const ReachabilityInfo::TDistances& dists, BattleHex *chosenHex = nullptr)
{
int ret = 1000000;
BOOST_FOREACH(BattleHex n, hex.neighbouringTiles())
@ -145,7 +145,7 @@ BattleAction CBattleAI::activeStack( const CStack * stack )
{
ThreatMap threatsToUs(stack);
auto dists = cbc->battleGetDistances(stack);
const EnemyInfo &ei= *range::min_element(targets.unreachableEnemies, boost::bind(isCloser, _1, _2, boost::ref(dists)));
const EnemyInfo &ei= *range::min_element(targets.unreachableEnemies, std::bind(isCloser, _1, _2, std::ref(dists)));
if(distToNearestNeighbour(ei.s->position, dists) < GameConstants::BFIELD_SIZE)
{
return goTowards(stack, ei.s->position);
@ -592,7 +592,7 @@ ThreatMap::ThreatMap(const CStack *Endangered) : endangered(Endangered)
}
}
const TBonusListPtr StackWithBonuses::getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root /*= NULL*/, const std::string &cachingStr /*= ""*/) const
const TBonusListPtr StackWithBonuses::getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root /*= nullptr*/, const std::string &cachingStr /*= ""*/) const
{
TBonusListPtr ret = make_shared<BonusList>();
const TBonusListPtr originalList = stack->getAllBonuses(selector, limit, root, cachingStr);

42
AI/BattleAI/BattleAI.h
View File

@ -13,7 +13,7 @@ public:
const CStack *stack;
mutable std::vector<Bonus> bonusesToAdd;
virtual const TBonusListPtr getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root = NULL, const std::string &cachingStr = "") const OVERRIDE;
virtual const TBonusListPtr getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root = nullptr, const std::string &cachingStr = "") const override;
};
struct EnemyInfo
@ -120,27 +120,27 @@ public:
CBattleAI(void);
~CBattleAI(void);
void init(shared_ptr<CBattleCallback> CB) OVERRIDE;
void actionFinished(const BattleAction &action) OVERRIDE;//occurs AFTER every action taken by any stack or by the hero
void actionStarted(const BattleAction &action) OVERRIDE;//occurs BEFORE every action taken by any stack or by the hero
BattleAction activeStack(const CStack * stack) OVERRIDE; //called when it's turn of that stack
void init(shared_ptr<CBattleCallback> CB) override;
void actionFinished(const BattleAction &action) override;//occurs AFTER every action taken by any stack or by the hero
void actionStarted(const BattleAction &action) override;//occurs BEFORE every action taken by any stack or by the hero
BattleAction activeStack(const CStack * stack) override; //called when it's turn of that stack
void battleAttack(const BattleAttack *ba) OVERRIDE; //called when stack is performing attack
void battleStacksAttacked(const std::vector<BattleStackAttacked> & bsa) OVERRIDE; //called when stack receives damage (after battleAttack())
void battleEnd(const BattleResult *br) OVERRIDE;
//void battleResultsApplied() OVERRIDE; //called when all effects of last battle are applied
void battleNewRoundFirst(int round) OVERRIDE; //called at the beginning of each turn before changes are applied;
void battleNewRound(int round) OVERRIDE; //called at the beggining of each turn, round=-1 is the tactic phase, round=0 is the first "normal" turn
void battleStackMoved(const CStack * stack, std::vector<BattleHex> dest, int distance) OVERRIDE;
void battleSpellCast(const BattleSpellCast *sc) OVERRIDE;
void battleStacksEffectsSet(const SetStackEffect & sse) OVERRIDE;//called when a specific effect is set to stacks
//void battleTriggerEffect(const BattleTriggerEffect & bte) OVERRIDE;
void battleStart(const CCreatureSet *army1, const CCreatureSet *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool side) OVERRIDE; //called by engine when battle starts; side=0 - left, side=1 - right
void battleStacksHealedRes(const std::vector<std::pair<ui32, ui32> > & healedStacks, bool lifeDrain, bool tentHeal, si32 lifeDrainFrom) OVERRIDE; //called when stacks are healed / resurrected first element of pair - stack id, second - healed hp
void battleNewStackAppeared(const CStack * stack) OVERRIDE; //not called at the beginning of a battle or by resurrection; called eg. when elemental is summoned
void battleObstaclesRemoved(const std::set<si32> & removedObstacles) OVERRIDE; //called when a certain set of obstacles is removed from batlefield; IDs of them are given
void battleCatapultAttacked(const CatapultAttack & ca) OVERRIDE; //called when catapult makes an attack
void battleStacksRemoved(const BattleStacksRemoved & bsr) OVERRIDE; //called when certain stack is completely removed from battlefield
void battleAttack(const BattleAttack *ba) override; //called when stack is performing attack
void battleStacksAttacked(const std::vector<BattleStackAttacked> & bsa) override; //called when stack receives damage (after battleAttack())
void battleEnd(const BattleResult *br) override;
//void battleResultsApplied() override; //called when all effects of last battle are applied
void battleNewRoundFirst(int round) override; //called at the beginning of each turn before changes are applied;
void battleNewRound(int round) override; //called at the beggining of each turn, round=-1 is the tactic phase, round=0 is the first "normal" turn
void battleStackMoved(const CStack * stack, std::vector<BattleHex> dest, int distance) override;
void battleSpellCast(const BattleSpellCast *sc) override;
void battleStacksEffectsSet(const SetStackEffect & sse) override;//called when a specific effect is set to stacks
//void battleTriggerEffect(const BattleTriggerEffect & bte) override;
void battleStart(const CCreatureSet *army1, const CCreatureSet *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool side) override; //called by engine when battle starts; side=0 - left, side=1 - right
void battleStacksHealedRes(const std::vector<std::pair<ui32, ui32> > & healedStacks, bool lifeDrain, bool tentHeal, si32 lifeDrainFrom) override; //called when stacks are healed / resurrected first element of pair - stack id, second - healed hp
void battleNewStackAppeared(const CStack * stack) override; //not called at the beginning of a battle or by resurrection; called eg. when elemental is summoned
void battleObstaclesRemoved(const std::set<si32> & removedObstacles) override; //called when a certain set of obstacles is removed from batlefield; IDs of them are given
void battleCatapultAttacked(const CatapultAttack & ca) override; //called when catapult makes an attack
void battleStacksRemoved(const BattleStacksRemoved & bsr) override; //called when certain stack is completely removed from battlefield
BattleAction goTowards(const CStack * stack, BattleHex hex );
BattleAction useCatapult(const CStack * stack);

4
AI/StupidAI/StupidAI.cpp
View File

@ -60,7 +60,7 @@ bool isMoreProfitable(const EnemyInfo &ei1, const EnemyInfo& ei2)
return (ei1.adi-ei1.adr) < (ei2.adi - ei2.adr);
}
int distToNearestNeighbour(BattleHex hex, const ReachabilityInfo::TDistances& dists, BattleHex *chosenHex = NULL)
int distToNearestNeighbour(BattleHex hex, const ReachabilityInfo::TDistances& dists, BattleHex *chosenHex = nullptr)
{
int ret = 1000000;
BOOST_FOREACH(BattleHex n, hex.neighbouringTiles())
@ -157,7 +157,7 @@ BattleAction CStupidAI::activeStack( const CStack * stack )
else if(enemiesUnreachable.size()) //due to #955 - a buggy battle may occur when there are no enemies
{
assert(enemiesUnreachable.size());
const EnemyInfo &ei= *std::min_element(enemiesUnreachable.begin(), enemiesUnreachable.end(), boost::bind(isCloser, _1, _2, boost::ref(dists)));
const EnemyInfo &ei= *std::min_element(enemiesUnreachable.begin(), enemiesUnreachable.end(), std::bind(isCloser, _1, _2, std::ref(dists)));
assert(ei.s);
if(distToNearestNeighbour(ei.s->position, dists) < GameConstants::BFIELD_SIZE)
{

44
AI/StupidAI/StupidAI.h
View File

@ -12,32 +12,32 @@ public:
CStupidAI(void);
~CStupidAI(void);
void init(shared_ptr<CBattleCallback> CB) OVERRIDE;
void actionFinished(const BattleAction &action) OVERRIDE;//occurs AFTER every action taken by any stack or by the hero
void actionStarted(const BattleAction &action) OVERRIDE;//occurs BEFORE every action taken by any stack or by the hero
BattleAction activeStack(const CStack * stack) OVERRIDE; //called when it's turn of that stack
void init(shared_ptr<CBattleCallback> CB) override;
void actionFinished(const BattleAction &action) override;//occurs AFTER every action taken by any stack or by the hero
void actionStarted(const BattleAction &action) override;//occurs BEFORE every action taken by any stack or by the hero
BattleAction activeStack(const CStack * stack) override; //called when it's turn of that stack
void battleAttack(const BattleAttack *ba) OVERRIDE; //called when stack is performing attack
void battleStacksAttacked(const std::vector<BattleStackAttacked> & bsa) OVERRIDE; //called when stack receives damage (after battleAttack())
void battleEnd(const BattleResult *br) OVERRIDE;
//void battleResultsApplied() OVERRIDE; //called when all effects of last battle are applied
void battleNewRoundFirst(int round) OVERRIDE; //called at the beginning of each turn before changes are applied;
void battleNewRound(int round) OVERRIDE; //called at the beggining of each turn, round=-1 is the tactic phase, round=0 is the first "normal" turn
void battleStackMoved(const CStack * stack, std::vector<BattleHex> dest, int distance) OVERRIDE;
void battleSpellCast(const BattleSpellCast *sc) OVERRIDE;
void battleStacksEffectsSet(const SetStackEffect & sse) OVERRIDE;//called when a specific effect is set to stacks
//void battleTriggerEffect(const BattleTriggerEffect & bte) OVERRIDE;
void battleStart(const CCreatureSet *army1, const CCreatureSet *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool side) OVERRIDE; //called by engine when battle starts; side=0 - left, side=1 - right
void battleStacksHealedRes(const std::vector<std::pair<ui32, ui32> > & healedStacks, bool lifeDrain, bool tentHeal, si32 lifeDrainFrom) OVERRIDE; //called when stacks are healed / resurrected first element of pair - stack id, second - healed hp
void battleNewStackAppeared(const CStack * stack) OVERRIDE; //not called at the beginning of a battle or by resurrection; called eg. when elemental is summoned
void battleObstaclesRemoved(const std::set<si32> & removedObstacles) OVERRIDE; //called when a certain set of obstacles is removed from batlefield; IDs of them are given
void battleCatapultAttacked(const CatapultAttack & ca) OVERRIDE; //called when catapult makes an attack
void battleStacksRemoved(const BattleStacksRemoved & bsr) OVERRIDE; //called when certain stack is completely removed from battlefield
void battleAttack(const BattleAttack *ba) override; //called when stack is performing attack
void battleStacksAttacked(const std::vector<BattleStackAttacked> & bsa) override; //called when stack receives damage (after battleAttack())
void battleEnd(const BattleResult *br) override;
//void battleResultsApplied() override; //called when all effects of last battle are applied
void battleNewRoundFirst(int round) override; //called at the beginning of each turn before changes are applied;
void battleNewRound(int round) override; //called at the beggining of each turn, round=-1 is the tactic phase, round=0 is the first "normal" turn
void battleStackMoved(const CStack * stack, std::vector<BattleHex> dest, int distance) override;
void battleSpellCast(const BattleSpellCast *sc) override;
void battleStacksEffectsSet(const SetStackEffect & sse) override;//called when a specific effect is set to stacks
//void battleTriggerEffect(const BattleTriggerEffect & bte) override;
void battleStart(const CCreatureSet *army1, const CCreatureSet *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool side) override; //called by engine when battle starts; side=0 - left, side=1 - right
void battleStacksHealedRes(const std::vector<std::pair<ui32, ui32> > & healedStacks, bool lifeDrain, bool tentHeal, si32 lifeDrainFrom) override; //called when stacks are healed / resurrected first element of pair - stack id, second - healed hp
void battleNewStackAppeared(const CStack * stack) override; //not called at the beginning of a battle or by resurrection; called eg. when elemental is summoned
void battleObstaclesRemoved(const std::set<si32> & removedObstacles) override; //called when a certain set of obstacles is removed from batlefield; IDs of them are given
void battleCatapultAttacked(const CatapultAttack & ca) override; //called when catapult makes an attack
void battleStacksRemoved(const BattleStacksRemoved & bsr) override; //called when certain stack is completely removed from battlefield
BattleAction goTowards(const CStack * stack, BattleHex hex );
virtual void saveGame(COSer<CSaveFile> &h, const int version) OVERRIDE;
virtual void loadGame(CISer<CLoadFile> &h, const int version) OVERRIDE;
virtual void saveGame(COSer<CSaveFile> &h, const int version) override;
virtual void loadGame(CISer<CLoadFile> &h, const int version) override;
};

11
AI/VCAI/StdInc.h
View File

@ -1,15 +1,4 @@
#pragma once
#include "../../Global.h"
#include <cassert>
#include <boost/lexical_cast.hpp>
#include <boost/format.hpp>
#include <boost/range/algorithm.hpp>
#include <boost/type_traits.hpp>
#include <boost/foreach.hpp>
#include <boost/thread/tss.hpp>
#include "Fuzzy.h"
#include <fstream>
#include <queue>

41
AI/VCAI/VCAI.cpp
View File

@ -140,8 +140,8 @@ void removeDuplicates(std::vector<T> &vec)
struct AtScopeExit
{
boost::function<void()> foo;
AtScopeExit(const boost::function<void()> &FOO) : foo(FOO)
std::function<void()> foo;
AtScopeExit(const std::function<void()> &FOO) : foo(FOO)
{}
~AtScopeExit()
{
@ -149,7 +149,7 @@ struct AtScopeExit
}
};
void foreach_tile_pos(boost::function<void(const int3& pos)> foo)
void foreach_tile_pos(std::function<void(const int3& pos)> foo)
{
for(int i = 0; i < cb->getMapSize().x; i++)
for(int j = 0; j < cb->getMapSize().y; j++)
@ -157,7 +157,7 @@ void foreach_tile_pos(boost::function<void(const int3& pos)> foo)
foo(int3(i,j,k));
}
void foreach_neighbour(const int3 &pos, boost::function<void(const int3& pos)> foo)
void foreach_neighbour(const int3 &pos, std::function<void(const int3& pos)> foo)
{
BOOST_FOREACH(const int3 &dir, dirs)
{
@ -177,7 +177,7 @@ const unsigned char &retreiveTileN(const std::vector< std::vector< std::vector<u
return vectors[pos.x][pos.y][pos.z];
}
void foreach_tile(std::vector< std::vector< std::vector<unsigned char> > > &vectors, boost::function<void(unsigned char &in)> foo)
void foreach_tile(std::vector< std::vector< std::vector<unsigned char> > > &vectors, std::function<void(unsigned char &in)> foo)
{
for(auto i = vectors.begin(); i != vectors.end(); i++)
for(auto j = i->begin(); j != i->end(); j++)
@ -323,7 +323,10 @@ ui64 evaluateDanger(crint3 tile, const CGHeroInstance *visitor)
auto visitableObjects = cb->getVisitableObjs(tile);
// in some scenarios hero happens to be "under" the object (eg town). Then we consider ONLY the hero.
if(vstd::contains_if(visitableObjects, objWithID<Obj::HERO>))
erase_if(visitableObjects, ! boost::bind(objWithID<Obj::HERO>, _1));
erase_if(visitableObjects, [](const CGObjectInstance * obj)
{
return !objWithID<Obj::HERO>(obj);
});
if(const CGObjectInstance * dangerousObject = backOrNull(visitableObjects))
{
@ -532,7 +535,7 @@ void VCAI::gameOver(PlayerColor player, bool victory)
// {
// //play dirty: crash the whole engine to avoid lose
// //that way AI is unbeatable!
// *(int*)NULL = 666;
// *(int*)nullptr = 666;
// }
// TODO - at least write some insults on stdout
@ -579,7 +582,7 @@ void VCAI::heroVisit(const CGHeroInstance *visitor, const CGObjectInstance *visi
}
}
void VCAI::availableArtifactsChanged(const CGBlackMarket *bm /*= NULL*/)
void VCAI::availableArtifactsChanged(const CGBlackMarket *bm /*= nullptr*/)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
@ -1560,7 +1563,7 @@ void VCAI::battleStart(const CCreatureSet *army1, const CCreatureSet *army2, int
NET_EVENT_HANDLER;
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
const CGObjectInstance *presumedEnemy = backOrNull(cb->getVisitableObjs(tile)); //may be nullptr 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);
CAdventureAI::battleStart(army1, army2, tile, hero1, hero2, side);
}
@ -1649,7 +1652,7 @@ const CGObjectInstance * VCAI::lookForArt(int aid) const
return obj;
}
return NULL;
return nullptr;
//TODO what if more than one artifact is available? return them all or some slection criteria
}
@ -1673,17 +1676,17 @@ HeroPtr VCAI::getHeroWithGrail() const
if(h->hasArt(2)) //grail
return h;
return NULL;
return nullptr;
}
const CGObjectInstance * VCAI::getUnvisitedObj(const boost::function<bool(const CGObjectInstance *)> &predicate)
const CGObjectInstance * VCAI::getUnvisitedObj(const std::function<bool(const CGObjectInstance *)> &predicate)
{
//TODO smarter definition of unvisited
BOOST_FOREACH(const CGObjectInstance *obj, visitableObjs)
if(predicate(obj) && !vstd::contains(alreadyVisited, obj))
return obj;
return NULL;
return nullptr;
}
bool VCAI::isAccessibleForHero(const int3 & pos, HeroPtr h, bool includeAllies /*= false*/) const
@ -1986,7 +1989,7 @@ const CGTownInstance * VCAI::findTownWithTavern() const
if(t->hasBuilt(BuildingID::TAVERN) && !t->visitingHero)
return t;
return NULL;
return nullptr;
}
std::vector<HeroPtr> VCAI::getUnblockedHeroes() const
@ -2009,7 +2012,7 @@ HeroPtr VCAI::primaryHero() const
boost::sort(hs, compareHeroStrength);
if(hs.empty())
return NULL;
return nullptr;
return hs.back();
}
@ -2498,7 +2501,7 @@ void VCAI::finish()
makingTurn->interrupt();
}
void VCAI::requestActionASAP(boost::function<void()> whatToDo)
void VCAI::requestActionASAP(std::function<void()> whatToDo)
{
// static boost::mutex m;
// boost::unique_lock<boost::mutex> mylock(m);
@ -2834,7 +2837,7 @@ TSubgoal CGoal::whatToDoToAchieve()
break;
case FIND_OBJ:
{
const CGObjectInstance * o = NULL;
const CGObjectInstance * o = nullptr;
if (resID > -1) //specified
{
BOOST_FOREACH(const CGObjectInstance *obj, ai->visitableObjs)
@ -3071,7 +3074,7 @@ TSubgoal CGoal::whatToDoToAchieve()
return CGoal(EXPLORE);
if(hero && !ai->isAccessibleForHero(tile, hero))
hero = NULL;
hero = nullptr;
if(!hero)
{
@ -3384,7 +3387,7 @@ TSubgoal CGoal::whatToDoToAchieve()
else
{
boost::sort(objs, isCloser);
HeroPtr h = NULL;
HeroPtr h = nullptr;
BOOST_FOREACH(const CGObjectInstance *obj, objs)
{ //find safe dwelling
auto pos = obj->visitablePos();

136
AI/VCAI/VCAI.h
View File

@ -154,12 +154,12 @@ struct CGoal
aid = -1;
resID = -1;
tile = int3(-1, -1, -1);
town = NULL;
town = nullptr;
}
bool invalid() const;
static TSubgoal goVisitOrLookFor(const CGObjectInstance *obj); //if obj is NULL, then we'll explore
static TSubgoal goVisitOrLookFor(const CGObjectInstance *obj); //if obj is nullptr, then we'll explore
static TSubgoal lookForArtSmart(int aid); //checks non-standard ways of obtaining art (merchants, quests, etc.)
static TSubgoal tryRecruitHero();
@ -229,9 +229,9 @@ struct SectorMap
struct CIssueCommand : CGoal
{
boost::function<bool()> command;
std::function<bool()> command;
CIssueCommand(boost::function<bool()> _command): CGoal(ISSUE_COMMAND), command(_command) {}
CIssueCommand(std::function<bool()> _command): CGoal(ISSUE_COMMAND), command(_command) {}
};
@ -304,69 +304,69 @@ public:
int3 explorationNewPoint(int radius, HeroPtr h, std::vector<std::vector<int3> > &tiles);
void recruitHero();
virtual std::string getBattleAIName() const OVERRIDE;
virtual std::string getBattleAIName() const override;
virtual void init(shared_ptr<CCallback> CB) OVERRIDE;
virtual void yourTurn() OVERRIDE;
virtual void init(shared_ptr<CCallback> CB) override;
virtual void yourTurn() override;
virtual void heroGotLevel(const CGHeroInstance *hero, PrimarySkill::PrimarySkill pskill, std::vector<SecondarySkill> &skills, QueryID queryID) OVERRIDE; //pskill is gained primary skill, interface has to choose one of given skills and call callback with selection id
virtual void commanderGotLevel (const CCommanderInstance * commander, std::vector<ui32> skills, QueryID queryID) OVERRIDE; //TODO
virtual void showBlockingDialog(const std::string &text, const std::vector<Component> &components, QueryID askID, const int soundID, bool selection, bool cancel) OVERRIDE; //Show a dialog, player must take decision. If selection then he has to choose between one of given components, if cancel he is allowed to not choose. After making choice, CCallback::selectionMade should be called with number of selected component (1 - n) or 0 for cancel (if allowed) and askID.
virtual void showGarrisonDialog(const CArmedInstance *up, const CGHeroInstance *down, bool removableUnits, QueryID queryID) OVERRIDE; //all stacks operations between these objects become allowed, interface has to call onEnd when done
virtual void saveGame(COSer<CSaveFile> &h, const int version) OVERRIDE; //saving
virtual void loadGame(CISer<CLoadFile> &h, const int version) OVERRIDE; //loading
virtual void finish() OVERRIDE;
virtual void heroGotLevel(const CGHeroInstance *hero, PrimarySkill::PrimarySkill pskill, std::vector<SecondarySkill> &skills, QueryID queryID) override; //pskill is gained primary skill, interface has to choose one of given skills and call callback with selection id
virtual void commanderGotLevel (const CCommanderInstance * commander, std::vector<ui32> skills, QueryID queryID) override; //TODO
virtual void showBlockingDialog(const std::string &text, const std::vector<Component> &components, QueryID askID, const int soundID, bool selection, bool cancel) override; //Show a dialog, player must take decision. If selection then he has to choose between one of given components, if cancel he is allowed to not choose. After making choice, CCallback::selectionMade should be called with number of selected component (1 - n) or 0 for cancel (if allowed) and askID.
virtual void showGarrisonDialog(const CArmedInstance *up, const CGHeroInstance *down, bool removableUnits, QueryID queryID) override; //all stacks operations between these objects become allowed, interface has to call onEnd when done
virtual void saveGame(COSer<CSaveFile> &h, const int version) override; //saving
virtual void loadGame(CISer<CLoadFile> &h, const int version) override; //loading
virtual void finish() override;
virtual void availableCreaturesChanged(const CGDwelling *town) OVERRIDE;
virtual void heroMoved(const TryMoveHero & details) OVERRIDE;
virtual void stackChagedCount(const StackLocation &location, const TQuantity &change, bool isAbsolute) OVERRIDE;
virtual void heroInGarrisonChange(const CGTownInstance *town) OVERRIDE;
virtual void centerView(int3 pos, int focusTime) OVERRIDE;
virtual void tileHidden(const boost::unordered_set<int3, ShashInt3> &pos) OVERRIDE;
virtual void artifactMoved(const ArtifactLocation &src, const ArtifactLocation &dst) OVERRIDE;
virtual void artifactAssembled(const ArtifactLocation &al) OVERRIDE;
virtual void showTavernWindow(const CGObjectInstance *townOrTavern) OVERRIDE;
virtual void showThievesGuildWindow (const CGObjectInstance * obj) OVERRIDE;
virtual void playerBlocked(int reason) OVERRIDE;
virtual void showPuzzleMap() OVERRIDE;
virtual void showShipyardDialog(const IShipyard *obj) 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;
virtual void artifactDisassembled(const ArtifactLocation &al) OVERRIDE;
virtual void heroVisit(const CGHeroInstance *visitor, const CGObjectInstance *visitedObj, bool start) OVERRIDE;
virtual void availableArtifactsChanged(const CGBlackMarket *bm = NULL) OVERRIDE;
virtual void heroVisitsTown(const CGHeroInstance* hero, const CGTownInstance * town) OVERRIDE;
virtual void tileRevealed(const boost::unordered_set<int3, ShashInt3> &pos) OVERRIDE;
virtual void heroExchangeStarted(ObjectInstanceID hero1, ObjectInstanceID hero2, QueryID query) OVERRIDE;
virtual void heroPrimarySkillChanged(const CGHeroInstance * hero, int which, si64 val) OVERRIDE;
virtual void showRecruitmentDialog(const CGDwelling *dwelling, const CArmedInstance *dst, int level) OVERRIDE;
virtual void heroMovePointsChanged(const CGHeroInstance * hero) OVERRIDE;
virtual void stackChangedType(const StackLocation &location, const CCreature &newType) OVERRIDE;
virtual void stacksRebalanced(const StackLocation &src, const StackLocation &dst, TQuantity count) OVERRIDE;
virtual void newObject(const CGObjectInstance * obj) OVERRIDE;
virtual void showHillFortWindow(const CGObjectInstance *object, const CGHeroInstance *visitor) OVERRIDE;
virtual void playerBonusChanged(const Bonus &bonus, bool gain) OVERRIDE;
virtual void newStackInserted(const StackLocation &location, const CStackInstance &stack) OVERRIDE;
virtual void heroCreated(const CGHeroInstance*) OVERRIDE;
virtual void advmapSpellCast(const CGHeroInstance * caster, int spellID) OVERRIDE;
virtual void showInfoDialog(const std::string &text, const std::vector<Component*> &components, int soundID) OVERRIDE;
virtual void requestRealized(PackageApplied *pa) OVERRIDE;
virtual void receivedResource(int type, int val) OVERRIDE;
virtual void stacksSwapped(const StackLocation &loc1, const StackLocation &loc2) OVERRIDE;
virtual void objectRemoved(const CGObjectInstance *obj) OVERRIDE;
virtual void showUniversityWindow(const IMarket *market, const CGHeroInstance *visitor) OVERRIDE;
virtual void heroManaPointsChanged(const CGHeroInstance * hero) OVERRIDE;
virtual void heroSecondarySkillChanged(const CGHeroInstance * hero, int which, int val) OVERRIDE;
virtual void battleResultsApplied() OVERRIDE;
virtual void objectPropertyChanged(const SetObjectProperty * sop) OVERRIDE;
virtual void buildChanged(const CGTownInstance *town, BuildingID buildingID, int what) OVERRIDE;
virtual void heroBonusChanged(const CGHeroInstance *hero, const Bonus &bonus, bool gain) OVERRIDE;
virtual void showMarketWindow(const IMarket *market, const CGHeroInstance *visitor) OVERRIDE;
virtual void availableCreaturesChanged(const CGDwelling *town) override;
virtual void heroMoved(const TryMoveHero & details) override;
virtual void stackChagedCount(const StackLocation &location, const TQuantity &change, bool isAbsolute) override;
virtual void heroInGarrisonChange(const CGTownInstance *town) override;
virtual void centerView(int3 pos, int focusTime) override;
virtual void tileHidden(const boost::unordered_set<int3, ShashInt3> &pos) override;
virtual void artifactMoved(const ArtifactLocation &src, const ArtifactLocation &dst) override;
virtual void artifactAssembled(const ArtifactLocation &al) override;
virtual void showTavernWindow(const CGObjectInstance *townOrTavern) override;
virtual void showThievesGuildWindow (const CGObjectInstance * obj) override;
virtual void playerBlocked(int reason) override;
virtual void showPuzzleMap() override;
virtual void showShipyardDialog(const IShipyard *obj) 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;
virtual void artifactDisassembled(const ArtifactLocation &al) override;
virtual void heroVisit(const CGHeroInstance *visitor, const CGObjectInstance *visitedObj, bool start) override;
virtual void availableArtifactsChanged(const CGBlackMarket *bm = nullptr) override;
virtual void heroVisitsTown(const CGHeroInstance* hero, const CGTownInstance * town) override;
virtual void tileRevealed(const boost::unordered_set<int3, ShashInt3> &pos) override;
virtual void heroExchangeStarted(ObjectInstanceID hero1, ObjectInstanceID hero2, QueryID query) override;
virtual void heroPrimarySkillChanged(const CGHeroInstance * hero, int which, si64 val) override;
virtual void showRecruitmentDialog(const CGDwelling *dwelling, const CArmedInstance *dst, int level) override;
virtual void heroMovePointsChanged(const CGHeroInstance * hero) override;
virtual void stackChangedType(const StackLocation &location, const CCreature &newType) override;
virtual void stacksRebalanced(const StackLocation &src, const StackLocation &dst, TQuantity count) override;
virtual void newObject(const CGObjectInstance * obj) override;
virtual void showHillFortWindow(const CGObjectInstance *object, const CGHeroInstance *visitor) override;
virtual void playerBonusChanged(const Bonus &bonus, bool gain) override;
virtual void newStackInserted(const StackLocation &location, const CStackInstance &stack) override;
virtual void heroCreated(const CGHeroInstance*) override;
virtual void advmapSpellCast(const CGHeroInstance * caster, int spellID) override;
virtual void showInfoDialog(const std::string &text, const std::vector<Component*> &components, int soundID) override;
virtual void requestRealized(PackageApplied *pa) override;
virtual void receivedResource(int type, int val) override;
virtual void stacksSwapped(const StackLocation &loc1, const StackLocation &loc2) override;
virtual void objectRemoved(const CGObjectInstance *obj) override;
virtual void showUniversityWindow(const IMarket *market, const CGHeroInstance *visitor) override;
virtual void heroManaPointsChanged(const CGHeroInstance * hero) override;
virtual void heroSecondarySkillChanged(const CGHeroInstance * hero, int which, int val) override;
virtual void battleResultsApplied() override;
virtual void objectPropertyChanged(const SetObjectProperty * sop) override;
virtual void buildChanged(const CGTownInstance *town, BuildingID buildingID, int what) override;
virtual void heroBonusChanged(const CGHeroInstance *hero, const Bonus &bonus, bool gain) override;
virtual void showMarketWindow(const IMarket *market, const CGHeroInstance *visitor) override;
virtual void battleStart(const CCreatureSet *army1, const CCreatureSet *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool side) OVERRIDE;
virtual void battleEnd(const BattleResult *br) OVERRIDE;
virtual void battleStart(const CCreatureSet *army1, const CCreatureSet *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool side) override;
virtual void battleEnd(const BattleResult *br) override;
void makeTurn();
void makeTurnInternal();
@ -413,7 +413,7 @@ public:
bool isAccessible(const int3 &pos);
HeroPtr getHeroWithGrail() const;
const CGObjectInstance *getUnvisitedObj(const boost::function<bool(const CGObjectInstance *)> &predicate);
const CGObjectInstance *getUnvisitedObj(const std::function<bool(const CGObjectInstance *)> &predicate);
bool isAccessibleForHero(const int3 & pos, HeroPtr h, bool includeAllies = false) const;
const CGTownInstance *findTownWithTavern() const;
@ -424,10 +424,10 @@ public:
bool containsSavedRes(const TResources &cost) const;
void checkHeroArmy (HeroPtr h);
void requestSent(const CPackForServer *pack, int requestID) OVERRIDE;
void requestSent(const CPackForServer *pack, int requestID) override;
void answerQuery(QueryID queryID, int selection);
//special function that can be called ONLY from game events handling thread and will send request ASAP
void requestActionASAP(boost::function<void()> whatToDo);
void requestActionASAP(std::function<void()> whatToDo);
template <typename Handler> void serializeInternal(Handler &h, const int version)
@ -453,7 +453,7 @@ public:
{
};
const char *what() const throw () OVERRIDE
const char *what() const throw () override
{
return msg.c_str();
}
@ -471,7 +471,7 @@ public:
{
};
const char *what() const throw () OVERRIDE
const char *what() const throw () override
{
return goal.name().c_str();
}

2
CCallback.cpp
View File

@ -216,7 +216,7 @@ void CCallback::buyArtifact(const CGHeroInstance *hero, ArtifactID aid)
sendRequest(&pack);
}
void CCallback::trade(const CGObjectInstance *market, EMarketMode::EMarketMode mode, int id1, int id2, int val1, const CGHeroInstance *hero/* = NULL*/)
void CCallback::trade(const CGObjectInstance *market, EMarketMode::EMarketMode mode, int id1, int id2, int val1, const CGHeroInstance *hero/* = nullptr*/)
{
TradeOnMarketplace pack;
pack.market = market;

14
CCallback.h
View File

@ -56,7 +56,7 @@ public:
virtual bool upgradeCreature(const CArmedInstance *obj, SlotID stackPos, CreatureID newID=CreatureID::NONE)=0; //if newID==-1 then best possible upgrade will be made
virtual void swapGarrisonHero(const CGTownInstance *town)=0;
virtual void trade(const CGObjectInstance *market, EMarketMode::EMarketMode mode, int id1, int id2, int val1, const CGHeroInstance *hero = NULL)=0; //mode==0: sell val1 units of id1 resource for id2 resiurce
virtual void trade(const CGObjectInstance *market, EMarketMode::EMarketMode mode, int id1, int id2, int val1, const CGHeroInstance *hero = nullptr)=0; //mode==0: sell val1 units of id1 resource for id2 resiurce
virtual int selectionMade(int selection, QueryID queryID) =0;
virtual int swapCreatures(const CArmedInstance *s1, const CArmedInstance *s2, SlotID p1, SlotID p2)=0;//swaps creatures between two possibly different garrisons // TODO: AI-unsafe code - fix it!
@ -89,8 +89,8 @@ protected:
public:
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
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
friend class CCallback;
friend class CClient;
@ -135,14 +135,14 @@ public:
//bool moveArtifact(const CGHeroInstance * hero, ui16 src, const CStackInstance * stack, ui16 dest); // TODO: unify classes
//bool moveArtifact(const CStackInstance * stack, ui16 src , const CGHeroInstance * hero, ui16 dest); // TODO: unify classes
bool assembleArtifacts(const CGHeroInstance * hero, ArtifactPosition artifactSlot, bool assemble, ArtifactID assembleTo);
bool buildBuilding(const CGTownInstance *town, BuildingID buildingID) OVERRIDE;
bool buildBuilding(const CGTownInstance *town, BuildingID buildingID) override;
void recruitCreatures(const CGObjectInstance *obj, CreatureID ID, ui32 amount, si32 level=-1);
bool dismissCreature(const CArmedInstance *obj, SlotID stackPos);
bool upgradeCreature(const CArmedInstance *obj, SlotID stackPos, CreatureID newID=CreatureID::NONE) OVERRIDE;
bool upgradeCreature(const CArmedInstance *obj, SlotID stackPos, CreatureID newID=CreatureID::NONE) override;
void endTurn();
void swapGarrisonHero(const CGTownInstance *town);
void buyArtifact(const CGHeroInstance *hero, ArtifactID aid) OVERRIDE;
void trade(const CGObjectInstance *market, EMarketMode::EMarketMode mode, int id1, int id2, int val1, const CGHeroInstance *hero = NULL);
void buyArtifact(const CGHeroInstance *hero, ArtifactID aid) override;
void trade(const CGObjectInstance *market, EMarketMode::EMarketMode mode, int id1, int id2, int val1, const CGHeroInstance *hero = nullptr);
void setFormation(const CGHeroInstance * hero, bool tight);
void setSelection(const CArmedInstance * obj);
void recruitHero(const CGObjectInstance *townOrTavern, const CGHeroInstance *hero);

80
Global.h
View File

@ -35,23 +35,20 @@ static_assert(sizeof(bool) == 1, "Bool needs to be 1 byte in size.");
//defining available c++11 features
//initialization lists - only gcc-4.4 or later
#if defined(__clang__) || (defined(__GNUC__) && (GCC_VERSION >= 440))
#if defined(__clang__) || defined(__GNUC__)
#define CPP11_USE_INITIALIZERS_LIST
#endif
//nullptr - only msvc and gcc-4.6 or later, othervice define it as NULL
#if !defined(_MSC_VER) && !(defined(__GNUC__) && (GCC_VERSION >= 460)) && !(defined(__clang__))
//nullptr - only msvc and gcc-4.6 or later, othervice define it as nullptr
#if (defined(__GNUC__)) && (GCC_VERSION < 460)
#define nullptr NULL
#endif
//override keyword - only msvc and gcc-4.7 or later.
#if !defined(_MSC_VER) && !(defined(__GNUC__) && (GCC_VERSION >= 470)) && !(defined(__clang__))
#if !defined(_MSC_VER) && !defined(__clang__) && !(defined(__GNUC__) && (GCC_VERSION >= 470))
#define override
#endif
//workaround to support existing code
#define OVERRIDE override
/* ---------------------------------------------------------------------------- */
/* Suppress some compiler warnings */
/* ---------------------------------------------------------------------------- */
@ -72,6 +69,7 @@ static_assert(sizeof(bool) == 1, "Bool needs to be 1 byte in size.");
#include <climits>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <fstream>
#include <iomanip>
#include <iostream>
@ -79,6 +77,7 @@ static_assert(sizeof(bool) == 1, "Bool needs to be 1 byte in size.");
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
@ -93,12 +92,11 @@ static_assert(sizeof(bool) == 1, "Bool needs to be 1 byte in size.");
#define BOOST_THREAD_VERSION 3
#endif
#define BOOST_THREAD_DONT_PROVIDE_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE 1
#define BOOST_BIND_NO_PLACEHOLDERS
//#define BOOST_SYSTEM_NO_DEPRECATED 1
#include <boost/algorithm/string.hpp>
#include <boost/assert.hpp>
#include <boost/assign.hpp>
#include <boost/bind.hpp>
#include <boost/cstdint.hpp>
#include <boost/current_function.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
@ -106,17 +104,15 @@ static_assert(sizeof(bool) == 1, "Bool needs to be 1 byte in size.");
#include <boost/filesystem.hpp>
#include <boost/foreach.hpp>
#include <boost/format.hpp>
#include <boost/function.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/logic/tribool.hpp>
#include <boost/program_options.hpp>
#include <boost/optional.hpp>
#include <boost/range/algorithm.hpp>
#include <boost/program_options.hpp>
#include <boost/range/adaptor/filtered.hpp>
#include <boost/range/algorithm.hpp>
#include <boost/thread.hpp>
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>
#include <boost/unordered_map.hpp>
#include <boost/variant.hpp>
#ifdef ANDROID
@ -129,6 +125,7 @@ static_assert(sizeof(bool) == 1, "Bool needs to be 1 byte in size.");
using std::shared_ptr;
using std::unique_ptr;
using std::make_shared;
using namespace std::placeholders;
namespace range = boost::range;
/* ---------------------------------------------------------------------------- */
@ -153,37 +150,33 @@ typedef boost::lock_guard<boost::recursive_mutex> TLockGuardRec;
/* ---------------------------------------------------------------------------- */
// Import + Export macro declarations
#ifdef _WIN32
#ifdef __GNUC__
#define DLL_EXPORT __attribute__((dllexport))
# ifdef __GNUC__
# define DLL_EXPORT __attribute__((dllexport))
# else
# define DLL_EXPORT __declspec(dllexport)
# endif
#else
#define DLL_EXPORT __declspec(dllexport)
#endif
#else
#if defined(__GNUC__) && GCC_VERSION >= 400
#define DLL_EXPORT __attribute__ ((visibility("default")))
#else
#define DLL_EXPORT
#endif
# ifdef __GNUC__
# define DLL_EXPORT __attribute__ ((visibility("default")))
# endif
#endif
#ifdef _WIN32
#ifdef __GNUC__
#define DLL_IMPORT __attribute__((dllimport))
# ifdef __GNUC__
# define DLL_IMPORT __attribute__((dllimport))
# else
# define DLL_IMPORT __declspec(dllimport)
# endif
#else
#define DLL_IMPORT __declspec(dllimport)
#endif
#else
#if defined(__GNUC__) && GCC_VERSION >= 400
#define DLL_IMPORT __attribute__ ((visibility("default")))
#else
#define DLL_IMPORT
#endif
# ifdef __GNUC__
# define DLL_IMPORT __attribute__ ((visibility("default")))
# endif
#endif
#ifdef VCMI_DLL
#define DLL_LINKAGE DLL_EXPORT
# define DLL_LINKAGE DLL_EXPORT
#else
#define DLL_LINKAGE DLL_IMPORT
# define DLL_LINKAGE DLL_IMPORT
#endif
#define THROW_FORMAT(message, formatting_elems) throw std::runtime_error(boost::str(boost::format(message) % formatting_elems))
@ -246,11 +239,6 @@ public:
bmap()
{}
#if 0 // What is _Myt? gcc\clang does not have that
bmap(const typename std::map<KeyT, ValT>::_Myt& _Right)
: std::map<KeyT, ValT>(_Right)
{}
#endif
explicit bmap(const typename std::map<KeyT, ValT>::key_compare& _Pred)
: std::map<KeyT, ValT>(_Pred)
{}
@ -439,12 +427,12 @@ namespace vstd
return assigner<t1,t2>(a1,a2);
}
//deleted pointer and sets it to NULL
//deleted pointer and sets it to nullptr
template <typename T>
void clear_pointer(T* &ptr)
{
delete ptr;
ptr = NULL;
ptr = nullptr;
}
template<typename T>
@ -550,7 +538,7 @@ namespace vstd
});
}
static inline int retreiveRandNum(const boost::function<int()> &randGen)
static inline int retreiveRandNum(const std::function<int()> &randGen)
{
if (randGen)
return randGen();
@ -558,7 +546,7 @@ namespace vstd
return rand();
}
template <typename T> const T & pickRandomElementOf(const std::vector<T> &v, const boost::function<int()> &randGen)
template <typename T> const T & pickRandomElementOf(const std::vector<T> &v, const std::function<int()> &randGen)
{
return v.at(retreiveRandNum(randGen) % v.size());
}
@ -570,7 +558,7 @@ namespace vstd
}
template <typename Container>
typename Container::value_type backOrNull(const Container &c) //returns last element of container or NULL if it is empty (to be used with containers of pointers)
typename Container::value_type backOrNull(const Container &c) //returns last element of container or nullptr if it is empty (to be used with containers of pointers)
{
if(c.size())
return c.back();
@ -579,7 +567,7 @@ namespace vstd
}
template <typename Container>
typename Container::value_type frontOrNull(const Container &c) //returns first element of container or NULL if it is empty (to be used with containers of pointers)
typename Container::value_type frontOrNull(const Container &c) //returns first element of container or nullptr if it is empty (to be used with containers of pointers)
{
if(c.size())
return c.front();

12
client/AdventureMapClasses.cpp
View File

@ -97,11 +97,11 @@ CList::CList(int Size, Point position, std::string btnUp, std::string btnDown, s
list = new CListBox(create, destroy, Point(1,scrollUp->pos.h), Point(0, 32), size, listAmount);
//assign callback only after list was created
scrollUp->callback = boost::bind(&CListBox::moveToPrev, list);
scrollDown = new CAdventureMapButton(CGI->generaltexth->zelp[helpDown], boost::bind(&CListBox::moveToNext, list), 0, scrollUp->pos.h + 32*size, btnDown);
scrollUp->callback = std::bind(&CListBox::moveToPrev, list);
scrollDown = new CAdventureMapButton(CGI->generaltexth->zelp[helpDown], std::bind(&CListBox::moveToNext, list), 0, scrollUp->pos.h + 32*size, btnDown);
scrollDown->callback += boost::bind(&CList::update, this);
scrollUp->callback += boost::bind(&CList::update, this);
scrollDown->callback += std::bind(&CList::update, this);
scrollUp->callback += std::bind(&CList::update, this);
update();
}
@ -236,7 +236,7 @@ CIntObject * CHeroList::createHeroItem(size_t index)
}
CHeroList::CHeroList(int size, Point position, std::string btnUp, std::string btnDown):
CList(size, position, btnUp, btnDown, LOCPLINT->wanderingHeroes.size(), 303, 304, boost::bind(&CHeroList::createHeroItem, this, _1))
CList(size, position, btnUp, btnDown, LOCPLINT->wanderingHeroes.size(), 303, 304, std::bind(&CHeroList::createHeroItem, this, _1))
{
}
@ -321,7 +321,7 @@ std::string CTownList::CTownItem::getHoverText()
}
CTownList::CTownList(int size, Point position, std::string btnUp, std::string btnDown):
CList(size, position, btnUp, btnDown, LOCPLINT->towns.size(), 306, 307, boost::bind(&CTownList::createTownItem, this, _1))
CList(size, position, btnUp, btnDown, LOCPLINT->towns.size(), 306, 307, std::bind(&CTownList::createTownItem, this, _1))
{
}

82
client/CAdvmapInterface.cpp
View File

@ -55,7 +55,7 @@ CAdvMapInt *adventureInt;
CTerrainRect::CTerrainRect()
:curHoveredTile(-1,-1,-1), currentPath(NULL)
:curHoveredTile(-1,-1,-1), currentPath(nullptr)
{
tilesw=(ADVOPT.advmapW+31)/32;
tilesh=(ADVOPT.advmapH+31)/32;
@ -199,7 +199,7 @@ void CTerrainRect::showPath(const SDL_Rect * extRect, SDL_Surface * to)
if (hvx<0 && hvy<0)
{
Rect dstRect = genRect(32, 32, x + moveX, y + moveY);
CSDL_Ext::blit8bppAlphaTo24bpp(arrows->ourImages[pn].bitmap, NULL, to, &dstRect);
CSDL_Ext::blit8bppAlphaTo24bpp(arrows->ourImages[pn].bitmap, nullptr, to, &dstRect);
}
else if(hvx<0)
{
@ -225,7 +225,7 @@ void CTerrainRect::showPath(const SDL_Rect * extRect, SDL_Surface * to)
if (hvx<0 && hvy<0)
{
Rect dstRect = genRect(32, 32, x, y);
CSDL_Ext::blit8bppAlphaTo24bpp(arrows->ourImages[pn].bitmap, NULL, to, &dstRect);
CSDL_Ext::blit8bppAlphaTo24bpp(arrows->ourImages[pn].bitmap, nullptr, to, &dstRect);
}
else if(hvx<0)
{
@ -364,34 +364,34 @@ CAdvMapInt::CAdvMapInt():
minimap(Rect(ADVOPT.minimapX, ADVOPT.minimapY, ADVOPT.minimapW, ADVOPT.minimapH)),
statusbar(ADVOPT.statusbarX,ADVOPT.statusbarY,ADVOPT.statusbarG),
kingOverview(CGI->generaltexth->zelp[293].first,CGI->generaltexth->zelp[293].second,
boost::bind(&CAdvMapInt::fshowOverview,this),&ADVOPT.kingOverview, SDLK_k),
std::bind(&CAdvMapInt::fshowOverview,this),&ADVOPT.kingOverview, SDLK_k),
underground(CGI->generaltexth->zelp[294].first,CGI->generaltexth->zelp[294].second,
boost::bind(&CAdvMapInt::fswitchLevel,this),&ADVOPT.underground, SDLK_u),
std::bind(&CAdvMapInt::fswitchLevel,this),&ADVOPT.underground, SDLK_u),
questlog(CGI->generaltexth->zelp[295].first,CGI->generaltexth->zelp[295].second,
boost::bind(&CAdvMapInt::fshowQuestlog,this),&ADVOPT.questlog, SDLK_q),
std::bind(&CAdvMapInt::fshowQuestlog,this),&ADVOPT.questlog, SDLK_q),
sleepWake(CGI->generaltexth->zelp[296].first,CGI->generaltexth->zelp[296].second,
boost::bind(&CAdvMapInt::fsleepWake,this), &ADVOPT.sleepWake, SDLK_w),
std::bind(&CAdvMapInt::fsleepWake,this), &ADVOPT.sleepWake, SDLK_w),
moveHero(CGI->generaltexth->zelp[297].first,CGI->generaltexth->zelp[297].second,
boost::bind(&CAdvMapInt::fmoveHero,this), &ADVOPT.moveHero, SDLK_m),
std::bind(&CAdvMapInt::fmoveHero,this), &ADVOPT.moveHero, SDLK_m),
spellbook(CGI->generaltexth->zelp[298].first,CGI->generaltexth->zelp[298].second,
boost::bind(&CAdvMapInt::fshowSpellbok,this), &ADVOPT.spellbook, SDLK_c),
std::bind(&CAdvMapInt::fshowSpellbok,this), &ADVOPT.spellbook, SDLK_c),
advOptions(CGI->generaltexth->zelp[299].first,CGI->generaltexth->zelp[299].second,
boost::bind(&CAdvMapInt::fadventureOPtions,this), &ADVOPT.advOptions, SDLK_a),
std::bind(&CAdvMapInt::fadventureOPtions,this), &ADVOPT.advOptions, SDLK_a),
sysOptions(CGI->generaltexth->zelp[300].first,CGI->generaltexth->zelp[300].second,
boost::bind(&CAdvMapInt::fsystemOptions,this), &ADVOPT.sysOptions, SDLK_o),
std::bind(&CAdvMapInt::fsystemOptions,this), &ADVOPT.sysOptions, SDLK_o),
nextHero(CGI->generaltexth->zelp[301].first,CGI->generaltexth->zelp[301].second,
boost::bind(&CAdvMapInt::fnextHero,this), &ADVOPT.nextHero, SDLK_h),
std::bind(&CAdvMapInt::fnextHero,this), &ADVOPT.nextHero, SDLK_h),
endTurn(CGI->generaltexth->zelp[302].first,CGI->generaltexth->zelp[302].second,
boost::bind(&CAdvMapInt::fendTurn,this), &ADVOPT.endTurn, SDLK_e),
std::bind(&CAdvMapInt::fendTurn,this), &ADVOPT.endTurn, SDLK_e),
heroList(ADVOPT.hlistSize, Point(ADVOPT.hlistX, ADVOPT.hlistY), ADVOPT.hlistAU, ADVOPT.hlistAD),
townList(ADVOPT.tlistSize, Point(ADVOPT.tlistX, ADVOPT.tlistY), ADVOPT.tlistAU, ADVOPT.tlistAD),
@ -399,12 +399,12 @@ infoBar(Rect(ADVOPT.infoboxX, ADVOPT.infoboxY, 192, 192) )
{
duringAITurn = false;
state = NA;
spellBeingCasted = NULL;
spellBeingCasted = nullptr;
pos.x = pos.y = 0;
pos.w = screen->w;
pos.h = screen->h;
selection = NULL;
townList.onSelect = boost::bind(&CAdvMapInt::selectionChanged,this);
selection = nullptr;
townList.onSelect = std::bind(&CAdvMapInt::selectionChanged,this);
adventureInt=this;
bg = BitmapHandler::loadBitmap(ADVOPT.mainGraphic);
scrollingDir = 0;
@ -527,7 +527,7 @@ void CAdvMapInt::fendTurn()
for (int i = 0; i < LOCPLINT->wanderingHeroes.size(); i++)
if (!isHeroSleeping(LOCPLINT->wanderingHeroes[i]) && (LOCPLINT->wanderingHeroes[i]->movement > 0))
{
LOCPLINT->showYesNoDialog(CGI->generaltexth->allTexts[55], boost::bind(&CAdvMapInt::endingTurn, this), 0, false);
LOCPLINT->showYesNoDialog(CGI->generaltexth->allTexts[55], std::bind(&CAdvMapInt::endingTurn, this), 0, false);
return;
}
}
@ -698,7 +698,7 @@ void CAdvMapInt::setHeroSleeping(const CGHeroInstance *hero, bool sleep)
LOCPLINT->sleepingHeroes += hero;
else
LOCPLINT->sleepingHeroes -= hero;
updateNextHero(NULL);
updateNextHero(nullptr);
}
void CAdvMapInt::show(SDL_Surface * to)
@ -721,8 +721,8 @@ void CAdvMapInt::show(SDL_Surface * to)
if((animValHitCount % (4/scrollSpeed)) == 0
&& (
(GH.topInt() == this)
|| SDL_GetKeyState(NULL)[SDLK_LCTRL]
|| SDL_GetKeyState(NULL)[SDLK_RCTRL]
|| SDL_GetKeyState(nullptr)[SDLK_LCTRL]
|| SDL_GetKeyState(nullptr)[SDLK_RCTRL]
)
)
{
@ -799,7 +799,11 @@ void CAdvMapInt::keyPressed(const SDL_KeyboardEvent & key)
{
//find first town with tavern
auto itr = range::find_if(LOCPLINT->towns, boost::bind(&CGTownInstance::hasBuilt, _1, BuildingID::TAVERN));
auto itr = range::find_if(LOCPLINT->towns, [](const CGTownInstance * town)
{
return town->hasBuilt(BuildingID::TAVERN);
});
if(itr != LOCPLINT->towns.end())
LOCPLINT->showThievesGuildWindow(*itr);
else
@ -878,7 +882,7 @@ void CAdvMapInt::keyPressed(const SDL_KeyboardEvent & key)
if(LOCPLINT->ctrlPressed()) //CTRL + T => open marketplace
{
//check if we have any marketplace
const CGTownInstance *townWithMarket = NULL;
const CGTownInstance *townWithMarket = nullptr;
BOOST_FOREACH(const CGTownInstance *t, LOCPLINT->cb->getTownsInfo())
{
if(t->hasBuilt(BuildingID::MARKETPLACE))
@ -937,7 +941,7 @@ void CAdvMapInt::keyPressed(const SDL_KeyboardEvent & key)
terrain.currentPath = &path;
if(!LOCPLINT->cb->getPath2(h->getPosition(false) + dir, path))
{
terrain.currentPath = NULL;
terrain.currentPath = nullptr;
return;
}
@ -986,7 +990,7 @@ void CAdvMapInt::select(const CArmedInstance *sel, bool centerView /*= true*/)
assert(sel);
LOCPLINT->cb->setSelection(sel);
selection = sel;
if (LOCPLINT->battleInt == NULL && LOCPLINT->makingTurn)
if (LOCPLINT->battleInt == nullptr && LOCPLINT->makingTurn)
{
auto pos = sel->visitablePos();
auto tile = LOCPLINT->cb->getTile(pos);
@ -996,7 +1000,7 @@ void CAdvMapInt::select(const CArmedInstance *sel, bool centerView /*= true*/)
if(centerView)
centerOn(sel);
terrain.currentPath = NULL;
terrain.currentPath = nullptr;
if(sel->ID==Obj::TOWN)
{
auto town = dynamic_cast<const CGTownInstance*>(sel);
@ -1005,8 +1009,8 @@ void CAdvMapInt::select(const CArmedInstance *sel, bool centerView /*= true*/)
townList.select(town);
heroList.select(nullptr);
updateSleepWake(NULL);
updateMoveHero(NULL);
updateSleepWake(nullptr);
updateMoveHero(nullptr);
}
else //hero selected
{
@ -1028,7 +1032,7 @@ void CAdvMapInt::select(const CArmedInstance *sel, bool centerView /*= true*/)
void CAdvMapInt::mouseMoved( const SDL_MouseMotionEvent & sEvent )
{
//adventure map scrolling with mouse
if(!SDL_GetKeyState(NULL)[SDLK_LCTRL] && isActive())
if(!SDL_GetKeyState(nullptr)[SDLK_LCTRL] && isActive())
{
if(sEvent.x<15)
{
@ -1452,7 +1456,7 @@ void CAdvMapInt::leaveCastingMode(bool cast /*= false*/, int3 dest /*= int3(-1,
{
assert(spellBeingCasted);
SpellID id = spellBeingCasted->id;
spellBeingCasted = NULL;
spellBeingCasted = nullptr;
terrain.deactivate();
activate();
@ -1467,7 +1471,7 @@ const CGHeroInstance * CAdvMapInt::curHero() const
if(selection && selection->ID == Obj::HERO)
return static_cast<const CGHeroInstance *>(selection);
else
return NULL;
return nullptr;
}
const CGTownInstance * CAdvMapInt::curTown() const
@ -1475,7 +1479,7 @@ const CGTownInstance * CAdvMapInt::curTown() const
if(selection && selection->ID == Obj::TOWN)
return static_cast<const CGTownInstance *>(selection);
else
return NULL;
return nullptr;
}
const IShipyard * CAdvMapInt::ourInaccessibleShipyard(const CGObjectInstance *obj) const
@ -1483,7 +1487,7 @@ const IShipyard * CAdvMapInt::ourInaccessibleShipyard(const CGObjectInstance *ob
const IShipyard *ret = IShipyard::castFrom(obj);
if(!ret || obj->tempOwner != player || CCS->curh->type || (CCS->curh->frame != 6 && CCS->curh->frame != 0))
return NULL;
return nullptr;
return ret;
}
@ -1513,19 +1517,19 @@ CAdventureOptions::CAdventureOptions():
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
exit = new CAdventureMapButton("","",boost::bind(&CAdventureOptions::close, this), 204, 313, "IOK6432.DEF",SDLK_RETURN);
exit = new CAdventureMapButton("","",std::bind(&CAdventureOptions::close, this), 204, 313, "IOK6432.DEF",SDLK_RETURN);
exit->assignedKeys.insert(SDLK_ESCAPE);
scenInfo = new CAdventureMapButton("","", boost::bind(&CAdventureOptions::close, this), 24, 198, "ADVINFO.DEF",SDLK_i);
scenInfo = new CAdventureMapButton("","", std::bind(&CAdventureOptions::close, this), 24, 198, "ADVINFO.DEF",SDLK_i);
scenInfo->callback += CAdventureOptions::showScenarioInfo;
//viewWorld = new CAdventureMapButton("","",boost::bind(&CGuiHandler::popIntTotally, &GH, this), 204, 313, "IOK6432.DEF",SDLK_RETURN);
//viewWorld = new CAdventureMapButton("","",std::bind(&CGuiHandler::popIntTotally, &GH, this), 204, 313, "IOK6432.DEF",SDLK_RETURN);
puzzle = new CAdventureMapButton("","", boost::bind(&CAdventureOptions::close, this), 24, 81, "ADVPUZ.DEF");
puzzle->callback += boost::bind(&CPlayerInterface::showPuzzleMap, LOCPLINT);
puzzle = new CAdventureMapButton("","", std::bind(&CAdventureOptions::close, this), 24, 81, "ADVPUZ.DEF");
puzzle->callback += std::bind(&CPlayerInterface::showPuzzleMap, LOCPLINT);
dig = new CAdventureMapButton("","", boost::bind(&CAdventureOptions::close, this), 24, 139, "ADVDIG.DEF");
dig = new CAdventureMapButton("","", std::bind(&CAdventureOptions::close, this), 24, 139, "ADVDIG.DEF");
if(const CGHeroInstance *h = adventureInt->curHero())
dig->callback += boost::bind(&CPlayerInterface::tryDiggging, LOCPLINT, h);
dig->callback += std::bind(&CPlayerInterface::tryDiggging, LOCPLINT, h);
else
dig->block(true);
}

4
client/CAdvmapInterface.h
View File

@ -128,7 +128,7 @@ public:
CTownList townList;
CInfoBar infoBar;
const CSpell *spellBeingCasted; //NULL if none
const CSpell *spellBeingCasted; //nullptr if none
const CArmedInstance *selection; //currently selected town/hero
@ -178,7 +178,7 @@ public:
void leaveCastingMode(bool cast = false, int3 dest = int3(-1, -1, -1));
const CGHeroInstance * curHero() const;
const CGTownInstance * curTown() const;
const IShipyard * ourInaccessibleShipyard(const CGObjectInstance *obj) const; //checks if obj is our ashipyard and cursor is 0,0 -> returns shipyard or NULL else
const IShipyard * ourInaccessibleShipyard(const CGObjectInstance *obj) const; //checks if obj is our ashipyard and cursor is 0,0 -> returns shipyard or nullptr else
//button updates
void updateSleepWake(const CGHeroInstance *h);
void updateMoveHero(const CGHeroInstance *h, tribool hasPath = boost::logic::indeterminate);

36
client/CAnimation.cpp
View File

@ -123,8 +123,8 @@ static CFileCache animationCache;
*************************************************************************/
CDefFile::CDefFile(std::string Name):
data(NULL),
palette(NULL)
data(nullptr),
palette(nullptr)
{
//First 8 colors in def palette used for transparency
static SDL_Color H3Palette[8] =
@ -340,8 +340,8 @@ const std::map<size_t, size_t > CDefFile::getEntries() const
SDLImageLoader::SDLImageLoader(SDLImage * Img):
image(Img),
lineStart(NULL),
position(NULL)
lineStart(nullptr),
position(nullptr)
{
}
@ -394,8 +394,8 @@ SDLImageLoader::~SDLImageLoader()
CompImageLoader::CompImageLoader(CompImage * Img):
image(Img),
position(NULL),
entry(NULL),
position(nullptr),
entry(nullptr),
currentLine(0)
{
@ -550,7 +550,7 @@ void CompImageLoader::EndLine()
{
currentLine++;
image->line[currentLine] = position - image->surf;
entry = NULL;
entry = nullptr;
}
@ -586,7 +586,7 @@ void IImage::increaseRef()
}
SDLImage::SDLImage(CDefFile *data, size_t frame, size_t group, bool compressed):
surf(NULL)
surf(nullptr)
{
SDLImageLoader loader(this);
data->loadFrame(frame, group, loader);
@ -607,7 +607,7 @@ SDLImage::SDLImage(std::string filename, bool compressed):
{
surf = BitmapHandler::loadBitmap(filename);
if (surf == NULL)
if (surf == nullptr)
{
logGlobal->errorStream() << "Error: failed to load image "<<filename;
}
@ -672,9 +672,9 @@ SDLImage::~SDLImage()
}
CompImage::CompImage(const CDefFile *data, size_t frame, size_t group):
surf(NULL),
line(NULL),
palette(NULL)
surf(nullptr),
line(nullptr),
palette(nullptr)
{
CompImageLoader loader(this);
@ -854,7 +854,7 @@ void CompImage::BlitBlock(ui8 type, ui8 size, ui8 *&data, ui8 *&dest, ui8 alpha)
void CompImage::playerColored(PlayerColor player)
{
SDL_Color *pal = NULL;
SDL_Color *pal = nullptr;
if(player < PlayerColor::PLAYER_LIMIT)
{
pal = graphics->playerColorPalette + 32*player.getNum();
@ -900,7 +900,7 @@ IImage * CAnimation::getFromExtraDef(std::string filename)
{
size_t pos = filename.find(':');
if (pos == -1)
return NULL;
return nullptr;
CAnimation anim(filename.substr(0, pos));
pos++;
size_t frame = atoi(filename.c_str()+pos);
@ -1052,7 +1052,7 @@ CDefFile * CAnimation::getFile() const
if (CResourceHandler::get()->existsResource(identifier))
return new CDefFile(name);
return NULL;
return nullptr;
}
void CAnimation::printError(size_t frame, size_t group, std::string type) const
@ -1079,7 +1079,7 @@ CAnimation::CAnimation():
name(""),
compressed(false)
{
init(NULL);
init(nullptr);
loadedAnims.insert(this);
}
@ -1114,7 +1114,7 @@ IImage * CAnimation::getImage(size_t frame, size_t group, bool verbose) const
}
if (verbose)
printError(frame, group, "GetImage");
return NULL;
return nullptr;
}
void CAnimation::load()
@ -1494,7 +1494,7 @@ void CCreatureAnim::reset()
void CCreatureAnim::startPreview(bool warMachine)
{
callback = boost::bind(&CCreatureAnim::loopPreview, this, warMachine);
callback = std::bind(&CCreatureAnim::loopPreview, this, warMachine);
}
void CCreatureAnim::clearAndSet(EAnimType type)

10
client/CAnimation.h
View File

@ -61,7 +61,7 @@ class IImage
public:
//draws image on surface "where" at position
virtual void draw(SDL_Surface *where, int posX=0, int posY=0, Rect *src=NULL, ui8 alpha=255) const=0;
virtual void draw(SDL_Surface *where, int posX=0, int posY=0, Rect *src=nullptr, ui8 alpha=255) const=0;
//decrease ref count, returns true if image can be deleted (refCount <= 0)
bool decreaseRef();
@ -97,7 +97,7 @@ public:
SDLImage(SDL_Surface * from, bool extraRef);
~SDLImage();
void draw(SDL_Surface *where, int posX=0, int posY=0, Rect *src=NULL, ui8 alpha=255) const;
void draw(SDL_Surface *where, int posX=0, int posY=0, Rect *src=nullptr, ui8 alpha=255) const;
void playerColored(PlayerColor player);
int width() const;
int height() const;
@ -143,7 +143,7 @@ public:
CompImage(SDL_Surface * surf);
~CompImage();
void draw(SDL_Surface *where, int posX=0, int posY=0, Rect *src=NULL, ui8 alpha=255) const;
void draw(SDL_Surface *where, int posX=0, int posY=0, Rect *src=nullptr, ui8 alpha=255) const;
void playerColored(PlayerColor player);
int width() const;
int height() const;
@ -201,7 +201,7 @@ public:
//add custom surface to the selected position.
void setCustom(std::string filename, size_t frame, size_t group=0);
//get pointer to image from specific group, NULL if not found
//get pointer to image from specific group, nullptr if not found
IImage * getImage(size_t frame, size_t group=0, bool verbose=true) const;
//all available frames
@ -287,7 +287,7 @@ protected:
public:
//called when next animation sequence is required
boost::function<void()> callback;
std::function<void()> callback;
//Set per-surface alpha, 0 = transparent, 255 = opaque
void setAlpha(ui32 alphaValue);

4
client/CBitmapHandler.cpp
View File

@ -103,14 +103,14 @@ SDL_Surface * BitmapHandler::loadBitmapFromDir(std::string path, std::string fna
if(!fname.size())
{
logGlobal->warnStream() << "Call to loadBitmap with void fname!";
return NULL;
return nullptr;
}
if (!CResourceHandler::get()->existsResource(ResourceID(path + fname, EResType::IMAGE)))
{
return nullptr;
}
SDL_Surface * ret=NULL;
SDL_Surface * ret=nullptr;
auto readFile = CResourceHandler::get()->loadData(
ResourceID(path + fname, EResType::IMAGE));

60
client/CCastleInterface.cpp
View File

@ -63,12 +63,12 @@ CBuildingRect::CBuildingRect(CCastleBuildings * Par, const CGTownInstance *Town,
if (!str->borderName.empty())
border = BitmapHandler::loadBitmap(str->borderName, true);
else
border = NULL;
border = nullptr;
if (!str->areaName.empty())
area = BitmapHandler::loadBitmap(str->areaName);
else
area = NULL;
area = nullptr;
}
CBuildingRect::~CBuildingRect()
@ -97,7 +97,7 @@ void CBuildingRect::hover(bool on)
if(parent->selectedBuilding == this)
{
parent->selectedBuilding = NULL;
parent->selectedBuilding = nullptr;
GH.statusbar->clear();
}
}
@ -237,7 +237,7 @@ void CBuildingRect::mouseMoved (const SDL_MouseMotionEvent & sEvent)
{
if(parent->selectedBuilding == this)
{
parent->selectedBuilding = NULL;
parent->selectedBuilding = nullptr;
GH.statusbar->clear();
}
}
@ -436,7 +436,7 @@ void CHeroGSlot::set(const CGHeroInstance *newHero)
else if(!upg && owner->showEmpty) //up garrison
image = new CAnimImage("CREST58", LOCPLINT->castleInt->town->getOwner().getNum(), 0, 0, 0);
else
image = NULL;
image = nullptr;
}
template <class ptr>
@ -456,7 +456,7 @@ SORTHELP<CStructure> structSorter;
CCastleBuildings::CCastleBuildings(const CGTownInstance* Town):
town(Town),
selectedBuilding(NULL)
selectedBuilding(nullptr)
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
@ -575,7 +575,7 @@ const CGHeroInstance* CCastleBuildings::getHero()
return town->visitingHero;
if (town->garrisonHero)
return town->garrisonHero;
return NULL;
return nullptr;
}
void CCastleBuildings::buildingClicked(BuildingID building)
@ -753,7 +753,7 @@ void CCastleBuildings::enterCastleGate()
for(size_t i=0;i<Towns.size();i++)
{
const CGTownInstance *t = Towns[i];
if (t->id != this->town->id && t->visitingHero == NULL && //another town, empty and this is
if (t->id != this->town->id && t->visitingHero == nullptr && //another town, empty and this is
t->hasBuilt(BuildingID::CASTLE_GATE, ETownType::INFERNO))
{
availableTowns.push_back(t->id.getNum());//add to the list
@ -761,7 +761,7 @@ void CCastleBuildings::enterCastleGate()
}
CPicture *titlePic = new CPicture (LOCPLINT->castleInt->bicons->ourImages[BuildingID::CASTLE_GATE].bitmap, 0,0, false);//will be deleted by selection window
GH.pushInt (new CObjectListWindow(availableTowns, titlePic, CGI->generaltexth->jktexts[40],
CGI->generaltexth->jktexts[41], boost::bind (&CCastleInterface::castleTeleport, LOCPLINT->castleInt, _1)));
CGI->generaltexth->jktexts[41], std::bind (&CCastleInterface::castleTeleport, LOCPLINT->castleInt, _1)));
}
void CCastleBuildings::enterDwelling(int level)
@ -833,7 +833,7 @@ void CCastleBuildings::enterTownHall()
else
{
LOCPLINT->showInfoDialog(CGI->generaltexth->allTexts[673]);
(dynamic_cast<CInfoWindow*>(GH.topInt()))->buttons[0]->callback += boost::bind(&CCastleBuildings::openTownHall, this);
(dynamic_cast<CInfoWindow*>(GH.topInt()))->buttons[0]->callback += std::bind(&CCastleBuildings::openTownHall, this);
}
}
else
@ -854,8 +854,8 @@ void CCastleBuildings::openTownHall()
CCastleInterface::CCastleInterface(const CGTownInstance * Town, const CGTownInstance * from):
CWindowObject(PLAYER_COLORED | BORDERED),
hall(NULL),
fort(NULL),
hall(nullptr),
fort(nullptr),
town(Town)
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
@ -876,12 +876,12 @@ CCastleInterface::CCastleInterface(const CGTownInstance * Town, const CGTownInst
income = new CLabel(195, 443, FONT_SMALL, CENTER);
icon = new CAnimImage("ITPT", 0, 0, 15, 387);
exit = new CAdventureMapButton(CGI->generaltexth->tcommands[8], "", boost::bind(&CCastleInterface::close,this), 744, 544, "TSBTNS", SDLK_RETURN);
exit = new CAdventureMapButton(CGI->generaltexth->tcommands[8], "", std::bind(&CCastleInterface::close,this), 744, 544, "TSBTNS", SDLK_RETURN);
exit->assignedKeys.insert(SDLK_ESCAPE);
exit->setOffset(4);
split = new CAdventureMapButton(CGI->generaltexth->tcommands[3], "", boost::bind(&CGarrisonInt::splitClick,garr), 744, 382, "TSBTNS.DEF");
split->callback += boost::bind(&HeroSlots::splitClicked, heroes);
split = new CAdventureMapButton(CGI->generaltexth->tcommands[3], "", std::bind(&CGarrisonInt::splitClick,garr), 744, 382, "TSBTNS.DEF");
split->callback += std::bind(&HeroSlots::splitClicked, heroes);
garr->addSplitBtn(split);
Rect barRect(9, 182, 732, 18);
@ -893,7 +893,7 @@ CCastleInterface::CCastleInterface(const CGTownInstance * Town, const CGTownInst
townlist->select(from);
townlist->select(town); //this will scroll list to select current town
townlist->onSelect = boost::bind(&CCastleInterface::townChange, this);
townlist->onSelect = std::bind(&CCastleInterface::townChange, this);
recreateIcons();
CCS->musich->playMusic(town->town->clientInfo.musicTheme, true);
@ -903,7 +903,7 @@ CCastleInterface::CCastleInterface(const CGTownInstance * Town, const CGTownInst
CCastleInterface::~CCastleInterface()
{
LOCPLINT->castleInt = NULL;
LOCPLINT->castleInt = nullptr;
delete bicons;
}
@ -987,8 +987,8 @@ CCreaInfo::CCreaInfo(Point position, const CGTownInstance *Town, int Level, bool
if ( town->creatures.size() <= level || town->creatures[level].second.empty())
{
level = -1;
label = NULL;
picture = NULL;
label = nullptr;
picture = nullptr;
return;//No creature
}
addUsedEvents(LCLICK | RCLICK | HOVER);
@ -1092,7 +1092,7 @@ void CCreaInfo::clickRight(tribool down, bool previousState)
CTownInfo::CTownInfo(int posX, int posY, const CGTownInstance* Town, bool townHall):
town(Town),
building(NULL)
building(nullptr)
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
addUsedEvents(RCLICK | HOVER);
@ -1298,7 +1298,7 @@ CHallInterface::CHallInterface(const CGTownInstance *Town):
title = new CLabel(399, 12, FONT_MEDIUM, CENTER, Colors::WHITE, town->town->buildings[BuildingID(town->hallLevel()+BuildingID::VILLAGE_HALL)]->Name());
exit = new CAdventureMapButton(CGI->generaltexth->hcommands[8], "",
boost::bind(&CHallInterface::close,this), 748, 556, "TPMAGE1.DEF", SDLK_RETURN);
std::bind(&CHallInterface::close,this), 748, 556, "TPMAGE1.DEF", SDLK_RETURN);
exit->assignedKeys.insert(SDLK_ESCAPE);
auto & boxList = town->town->clientInfo.hallSlots;
@ -1307,7 +1307,7 @@ CHallInterface::CHallInterface(const CGTownInstance *Town):
{
for(size_t col=0; col<boxList[row].size(); col++) //for each box
{
const CBuilding *building = NULL;
const CBuilding *building = nullptr;
for(size_t item=0; item<boxList[row][col].size(); item++)//we are looking for the first not build structure
{
auto buildingID = boxList[row][col][item];
@ -1391,12 +1391,12 @@ CBuildWindow::CBuildWindow(const CGTownInstance *Town, const CBuilding * Buildin
if(!rightClick)
{ //normal window
buy = new CAdventureMapButton(boost::str(boost::format(CGI->generaltexth->allTexts[595]) % building->Name()),
"", boost::bind(&CBuildWindow::buyFunc,this), 45, 446,"IBUY30", SDLK_RETURN);
"", std::bind(&CBuildWindow::buyFunc,this), 45, 446,"IBUY30", SDLK_RETURN);
buy->borderColor = Colors::METALLIC_GOLD;
buy->borderEnabled = true;
cancel = new CAdventureMapButton(boost::str(boost::format(CGI->generaltexth->allTexts[596]) % building->Name()),
"", boost::bind(&CBuildWindow::close,this), 290, 445, "ICANCEL", SDLK_ESCAPE);
"", std::bind(&CBuildWindow::close,this), 290, 445, "ICANCEL", SDLK_ESCAPE);
cancel->borderColor = Colors::METALLIC_GOLD;
cancel->borderEnabled = true;
buy->block(state!=7 || LOCPLINT->playerID != town->tempOwner);
@ -1428,7 +1428,7 @@ CFortScreen::CFortScreen(const CGTownInstance * town):
title = new CLabel(400, 12, FONT_BIG, CENTER, Colors::WHITE, fortBuilding->Name());
std::string text = boost::str(boost::format(CGI->generaltexth->fcommands[6]) % fortBuilding->Name());
exit = new CAdventureMapButton(text, "", boost::bind(&CFortScreen::close,this) ,748, 556, "TPMAGE1", SDLK_RETURN);
exit = new CAdventureMapButton(text, "", std::bind(&CFortScreen::close,this) ,748, 556, "TPMAGE1", SDLK_RETURN);
exit->assignedKeys.insert(SDLK_ESCAPE);
std::vector<Point> positions;
@ -1518,7 +1518,7 @@ void LabeledValue::hover(bool on)
CFortScreen::RecruitArea::RecruitArea(int posX, int posY, const CGTownInstance *Town, BuildingID buildingID, int Level):
town(Town),
level(Level),
availableCount(NULL)
availableCount(nullptr)
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
pos.x +=posX;
@ -1532,7 +1532,7 @@ CFortScreen::RecruitArea::RecruitArea(int posX, int posY, const CGTownInstance *
icons = new CPicture("TPCAINFO", 261, 3);
buildingPic = new CAnimImage(town->town->clientInfo.buildingsIcons, buildingID, 0, 4, 21);
const CCreature* creature = NULL;
const CCreature* creature = nullptr;
if (!town->creatures[level].second.empty())
creature = CGI->creh->creatures[town->creatures[level].second.back()];
@ -1608,7 +1608,7 @@ CMageGuildScreen::CMageGuildScreen(CCastleInterface * owner):
Rect barRect(7, 556, 737, 18);
statusBar = new CGStatusBar(new CPicture(*background, barRect, 7, 556, false));
exit = new CAdventureMapButton(CGI->generaltexth->allTexts[593],"",boost::bind(&CMageGuildScreen::close,this), 748, 556,"TPMAGE1.DEF",SDLK_RETURN);
exit = new CAdventureMapButton(CGI->generaltexth->allTexts[593],"",std::bind(&CMageGuildScreen::close,this), 748, 556,"TPMAGE1.DEF",SDLK_RETURN);
exit->assignedKeys.insert(SDLK_ESCAPE);
std::vector<std::vector<Point> > positions;
@ -1685,10 +1685,10 @@ CBlacksmithDialog::CBlacksmithDialog(bool possible, CreatureID creMachineID, Art
boost::lexical_cast<std::string>(CGI->arth->artifacts[aid]->price));
std::string text = boost::str(boost::format(CGI->generaltexth->allTexts[595]) % creature->nameSing);
buy = new CAdventureMapButton(text,"",boost::bind(&CBlacksmithDialog::close, this), 42, 312,"IBUY30.DEF",SDLK_RETURN);
buy = new CAdventureMapButton(text,"",std::bind(&CBlacksmithDialog::close, this), 42, 312,"IBUY30.DEF",SDLK_RETURN);
text = boost::str(boost::format(CGI->generaltexth->allTexts[596]) % creature->nameSing);
cancel = new CAdventureMapButton(text,"",boost::bind(&CBlacksmithDialog::close, this), 224, 312,"ICANCEL.DEF",SDLK_ESCAPE);
cancel = new CAdventureMapButton(text,"",std::bind(&CBlacksmithDialog::close, this), 224, 312,"ICANCEL.DEF",SDLK_ESCAPE);
if(possible)
buy->callback += [=]{ LOCPLINT->cb->buyArtifact(LOCPLINT->cb->getHero(hid),aid); };

2
client/CCastleInterface.h
View File

@ -84,7 +84,7 @@ public:
int upg; //0 - up garrison, 1 - down garrison
CAnimImage *image;
CAnimImage *selection; //selection border. NULL if not selected
CAnimImage *selection; //selection border. nullptr if not selected
void setHighlight(bool on);
void set(const CGHeroInstance *newHero);

76
client/CCreatureWindow.cpp
View File

@ -52,7 +52,7 @@ CCreatureWindow::CCreatureWindow (const CStack &stack, CreWinType Type):
else
{
CStackInstance * s = new CStackInstance(stack.type, 1); //TODO: war machines and summons should be regular stacks
init(s, &stack, NULL);
init(s, &stack, nullptr);
delete s;
}
}
@ -73,11 +73,11 @@ CCreatureWindow::CCreatureWindow(CreatureID Cid, CreWinType Type, int creatureCo
OBJ_CONSTRUCTION_CAPTURING_ALL;
CStackInstance * stack = new CStackInstance(Cid, creatureCount); //TODO: simplify?
init(stack, CGI->creh->creatures[Cid], NULL);
init(stack, CGI->creh->creatures[Cid], nullptr);
delete stack;
}
CCreatureWindow::CCreatureWindow(const CStackInstance &st, CreWinType Type, boost::function<void()> Upg, boost::function<void()> Dsm, UpgradeInfo *ui):
CCreatureWindow::CCreatureWindow(const CStackInstance &st, CreWinType Type, std::function<void()> Upg, std::function<void()> Dsm, UpgradeInfo *ui):
CWindowObject(PLAYER_COLORED | (Type == OTHER ? RCLICK_POPUP : 0 ) ),
type(Type),
dismiss(0),
@ -104,14 +104,14 @@ CCreatureWindow::CCreatureWindow(const CStackInstance &st, CreWinType Type, boos
{
CFunctionList<void()> fs;
fs += Upg;
fs += boost::bind(&CCreatureWindow::close,this);
fs += std::bind(&CCreatureWindow::close,this);
CFunctionList<void()> cfl;
cfl = boost::bind(&CPlayerInterface::showYesNoDialog, LOCPLINT, CGI->generaltexth->allTexts[207], fs, 0, false, boost::ref(upgResCost));
cfl = std::bind(&CPlayerInterface::showYesNoDialog, LOCPLINT, CGI->generaltexth->allTexts[207], fs, 0, false, std::ref(upgResCost));
upgrade = new CAdventureMapButton("",CGI->generaltexth->zelp[446].second,cfl,385, 148,"IVIEWCR.DEF",SDLK_u);
}
else
{
upgrade = new CAdventureMapButton("",CGI->generaltexth->zelp[446].second,boost::function<void()>(),385, 148,"IVIEWCR.DEF");
upgrade = new CAdventureMapButton("",CGI->generaltexth->zelp[446].second,std::function<void()>(),385, 148,"IVIEWCR.DEF");
upgrade->callback.funcs.clear();
upgrade->setOffset(2);
}
@ -122,9 +122,9 @@ CCreatureWindow::CCreatureWindow(const CStackInstance &st, CreWinType Type, boos
CFunctionList<void()> fs[2];
//on dismiss confirmed
fs[0] += Dsm; //dismiss
fs[0] += boost::bind(&CCreatureWindow::close,this);//close this window
fs[0] += std::bind(&CCreatureWindow::close,this);//close this window
CFunctionList<void()> cfl;
cfl = boost::bind(&CPlayerInterface::showYesNoDialog,LOCPLINT,CGI->generaltexth->allTexts[12],fs[0],fs[1],false,std::vector<CComponent*>());
cfl = std::bind(&CPlayerInterface::showYesNoDialog,LOCPLINT,CGI->generaltexth->allTexts[12],fs[0],fs[1],false,std::vector<CComponent*>());
dismiss = new CAdventureMapButton("",CGI->generaltexth->zelp[445].second,cfl,333, 148,"IVIEWCR2.DEF",SDLK_d);
}
}
@ -146,18 +146,18 @@ CCreatureWindow::CCreatureWindow (const CCommanderInstance * Commander, const CS
init(commander, commander, dynamic_cast<const CGHeroInstance*>(commander->armyObj));
}
boost::function<void()> Dsm;
std::function<void()> Dsm;
CFunctionList<void()> fs[2];
//on dismiss confirmed
fs[0] += Dsm; //dismiss
fs[0] += boost::bind(&CCreatureWindow::close,this);//close this window
fs[0] += std::bind(&CCreatureWindow::close,this);//close this window
CFunctionList<void()> cfl;
cfl = boost::bind(&CPlayerInterface::showYesNoDialog,LOCPLINT,CGI->generaltexth->allTexts[12],fs[0],fs[1],false,std::vector<CComponent*>());
cfl = std::bind(&CPlayerInterface::showYesNoDialog,LOCPLINT,CGI->generaltexth->allTexts[12],fs[0],fs[1],false,std::vector<CComponent*>());
if (type < COMMANDER_LEVEL_UP) //can dismiss only in regular window
dismiss = new CAdventureMapButton("",CGI->generaltexth->zelp[445].second, cfl, 333, 148,"IVIEWCR2.DEF", SDLK_d);
}
CCreatureWindow::CCreatureWindow (std::vector<ui32> &skills, const CCommanderInstance * Commander, boost::function<void(ui32)> callback):
CCreatureWindow::CCreatureWindow (std::vector<ui32> &skills, const CCommanderInstance * Commander, std::function<void(ui32)> callback):
CWindowObject(PLAYER_COLORED),
type(COMMANDER_LEVEL_UP),
commander (Commander),
@ -169,21 +169,21 @@ CCreatureWindow::CCreatureWindow (std::vector<ui32> &skills, const CCommanderIns
init(commander, commander, dynamic_cast<const CGHeroInstance*>(commander->armyObj));
boost::function<void()> Dsm;
std::function<void()> Dsm;
CFunctionList<void()> fs[2];
//on dismiss confirmed
fs[0] += Dsm; //dismiss
fs[0] += boost::bind(&CCreatureWindow::close,this);//close this window
fs[0] += std::bind(&CCreatureWindow::close,this);//close this window
CFunctionList<void()> cfl;
cfl = boost::bind(&CPlayerInterface::showYesNoDialog,LOCPLINT,CGI->generaltexth->allTexts[12],fs[0],fs[1],false,std::vector<CComponent*>());
cfl = std::bind(&CPlayerInterface::showYesNoDialog,LOCPLINT,CGI->generaltexth->allTexts[12],fs[0],fs[1],false,std::vector<CComponent*>());
if (type < COMMANDER_LEVEL_UP) //can dismiss only in regular window
dismiss = new CAdventureMapButton("",CGI->generaltexth->zelp[445].second, cfl, 333, 148,"IVIEWCR2.DEF", SDLK_d);
}
void CCreatureWindow::init(const CStackInstance *Stack, const CBonusSystemNode *StackNode, const CGHeroInstance *HeroOwner)
{
creatureArtifact = NULL; //may be set later
artifactImage = NULL;
creatureArtifact = nullptr; //may be set later
artifactImage = nullptr;
stack = Stack;
c = stack->type;
if(!StackNode)
@ -199,7 +199,7 @@ void CCreatureWindow::init(const CStackInstance *Stack, const CBonusSystemNode *
count = boost::lexical_cast<std::string>(Stack->count);
if (type < COMMANDER)
commander = NULL;
commander = nullptr;
bool creArt = false;
displayedArtifact = ArtifactPosition::CREATURE_SLOT; // 0
@ -229,7 +229,7 @@ void CCreatureWindow::init(const CStackInstance *Stack, const CBonusSystemNode *
{
ui32 index = selectableSkills.size();
CSelectableSkill * selectableSkill = new CSelectableSkill();
selectableSkill->callback = boost::bind(&CCreatureWindow::selectSkill, this, index);
selectableSkill->callback = std::bind(&CCreatureWindow::selectSkill, this, index);
if (option < 100)
{
@ -324,13 +324,13 @@ void CCreatureWindow::init(const CStackInstance *Stack, const CBonusSystemNode *
setBackground("CreWin" + boost::lexical_cast<std::string>(bonusRows) + ".pcx"); //1 to 4 rows for now
//Buttons
ok = new CAdventureMapButton("",CGI->generaltexth->zelp[445].second, boost::bind(&CCreatureWindow::close,this), 489, 148, "hsbtns.def", SDLK_RETURN);
ok = new CAdventureMapButton("",CGI->generaltexth->zelp[445].second, std::bind(&CCreatureWindow::close,this), 489, 148, "hsbtns.def", SDLK_RETURN);
ok->assignedKeys.insert(SDLK_ESCAPE);
if (type <= BATTLE) //in battle or info window
{
upgrade = NULL;
dismiss = NULL;
upgrade = nullptr;
dismiss = nullptr;
}
anim = new CCreaturePic(22, 48, c);
@ -403,10 +403,10 @@ void CCreatureWindow::init(const CStackInstance *Stack, const CBonusSystemNode *
if (type > BATTLE && type < COMMANDER_BATTLE) //artifact buttons inactive in battle
{
//TODO: disable buttons if no artifact is equipped
leftArtRoll = new CAdventureMapButton(std::string(), std::string(), boost::bind (&CCreatureWindow::scrollArt, this, -1), 437, 98, "hsbtns3.def", SDLK_LEFT);
rightArtRoll = new CAdventureMapButton(std::string(), std::string(), boost::bind (&CCreatureWindow::scrollArt, this, +1), 516, 98, "hsbtns5.def", SDLK_RIGHT);
leftArtRoll = new CAdventureMapButton(std::string(), std::string(), std::bind (&CCreatureWindow::scrollArt, this, -1), 437, 98, "hsbtns3.def", SDLK_LEFT);
rightArtRoll = new CAdventureMapButton(std::string(), std::string(), std::bind (&CCreatureWindow::scrollArt, this, +1), 516, 98, "hsbtns5.def", SDLK_RIGHT);
if (heroOwner)
passArtToHero = new CAdventureMapButton(std::string(), std::string(), boost::bind (&CCreatureWindow::passArtifactToHero, this), 437, 148, "OVBUTN1.DEF", SDLK_HOME);
passArtToHero = new CAdventureMapButton(std::string(), std::string(), std::bind (&CCreatureWindow::passArtifactToHero, this), 437, 148, "OVBUTN1.DEF", SDLK_HOME);
}
}
@ -437,7 +437,7 @@ void CCreatureWindow::init(const CStackInstance *Stack, const CBonusSystemNode *
if (bonusItems.size() > (bonusRows << 1)) //only after graphics are created
{
slider = new CSlider(528, 231 + commanderOffset, bonusRows*60, boost::bind (&CCreatureWindow::sliderMoved, this, _1),
slider = new CSlider(528, 231 + commanderOffset, bonusRows*60, std::bind (&CCreatureWindow::sliderMoved, this, _1),
bonusRows, (bonusItems.size() + 1) >> 1, 0, false, 0);
}
else //slider automatically places bonus Items
@ -624,13 +624,13 @@ void CCreatureWindow::setArt(const CArtifactInstance *art)
creatureArtifact = art;
if (creatureArtifact)
{
if (artifactImage == NULL)
if (artifactImage == nullptr)
artifactImage = new CAnimImage("ARTIFACT", creatureArtifact->artType->iconIndex, 0, 466, 100);
else
artifactImage->setFrame(creatureArtifact->artType->iconIndex);
}
else
artifactImage = NULL;
artifactImage = nullptr;
redraw();
}
@ -704,7 +704,7 @@ CBonusItem::CBonusItem(const Rect &Pos, const std::string &Name, const std::stri
if (graphicsName.size())
bonusGraphics = new CPicture(graphicsName, 26, 232);
else
bonusGraphics = NULL;
bonusGraphics = nullptr;
removeUsedEvents(ALL); //no actions atm
}
@ -737,7 +737,7 @@ void CCreInfoWindow::show(SDL_Surface * to)
creatureCount->showAll(to);
}
CCreInfoWindow::CCreInfoWindow(const CStackInstance &stack, bool LClicked, boost::function<void()> upgradeFunc, boost::function<void()> dismissFunc, UpgradeInfo *upgradeInfo):
CCreInfoWindow::CCreInfoWindow(const CStackInstance &stack, bool LClicked, std::function<void()> upgradeFunc, std::function<void()> dismissFunc, UpgradeInfo *upgradeInfo):
CWindowObject(PLAYER_COLORED | (LClicked ? 0 : RCLICK_POPUP), "CRSTKPU")
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
@ -746,7 +746,7 @@ CCreInfoWindow::CCreInfoWindow(const CStackInstance &stack, bool LClicked, boost
//additional buttons if opened with left click
if(LClicked)
{
boost::function<void()> closeFunc = boost::bind(&CCreInfoWindow::close,this);
std::function<void()> closeFunc = std::bind(&CCreInfoWindow::close,this);
if(upgradeFunc && upgradeInfo)
{
@ -761,11 +761,11 @@ CCreInfoWindow::CCreInfoWindow(const CStackInstance &stack, bool LClicked, boost
onUpgrade += upgradeFunc;
onUpgrade += closeFunc;
boost::function<void()> dialog = boost::bind(&CPlayerInterface::showYesNoDialog,
std::function<void()> dialog = std::bind(&CPlayerInterface::showYesNoDialog,
LOCPLINT,
CGI->generaltexth->allTexts[207],
onUpgrade, 0, false,
boost::ref(upgResCost));
std::ref(upgResCost));
upgrade = new CAdventureMapButton("", CGI->generaltexth->zelp[446].second, dialog, 76, 237, "IVIEWCR", SDLK_u);
upgrade->block(!LOCPLINT->cb->getResourceAmount().canAfford(upgradeCost));
@ -777,7 +777,7 @@ CCreInfoWindow::CCreInfoWindow(const CStackInstance &stack, bool LClicked, boost
onDismiss += dismissFunc;
onDismiss += closeFunc;
boost::function<void()> dialog = boost::bind(&CPlayerInterface::showYesNoDialog,
std::function<void()> dialog = std::bind(&CPlayerInterface::showYesNoDialog,
LOCPLINT,
CGI->generaltexth->allTexts[12],
onDismiss, 0, true, std::vector<CComponent*>());
@ -792,7 +792,7 @@ CCreInfoWindow::CCreInfoWindow(int creatureID, bool LClicked, int creatureCount)
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
const CCreature *creature = CGI->creh->creatures[creatureID];
init(creature, NULL, NULL, creatureCount, LClicked);
init(creature, nullptr, nullptr, creatureCount, LClicked);
}
CCreInfoWindow::CCreInfoWindow(const CStack &stack, bool LClicked):
@ -869,9 +869,9 @@ void CCreInfoWindow::init(const CCreature *creature, const CBonusSystemNode *sta
}
else
{
abilityText = NULL;
abilityText = nullptr;
ok = new CAdventureMapButton("", CGI->generaltexth->zelp[445].second,
boost::bind(&CCreInfoWindow::close,this), 216, 237, "IOKAY.DEF", SDLK_RETURN);
std::bind(&CCreInfoWindow::close,this), 216, 237, "IOKAY.DEF", SDLK_RETURN);
ok->assignedKeys.insert(SDLK_ESCAPE);
}
@ -913,7 +913,7 @@ CIntObject * createCreWindow(CreatureID Cid, CCreatureWindow::CreWinType Type, i
return new CCreatureWindow(Cid, Type, creatureCount);
}
CIntObject * createCreWindow(const CStackInstance *s, CCreatureWindow::CreWinType type, boost::function<void()> Upg, boost::function<void()> Dsm, UpgradeInfo *ui)
CIntObject * createCreWindow(const CStackInstance *s, CCreatureWindow::CreWinType type, std::function<void()> Upg, std::function<void()> Dsm, UpgradeInfo *ui)
{
if(settings["general"]["classicCreatureWindow"].Bool())
return new CCreInfoWindow(*s, type==CCreatureWindow::HERO, Upg, Dsm, ui);

18
client/CCreatureWindow.h
View File

@ -82,15 +82,15 @@ public:
void artifactDisassembled (const ArtifactLocation &artLoc) {return;};
void artifactAssembled (const ArtifactLocation &artLoc) {return;};
boost::function<void()> dsm; //dismiss button callback
boost::function<void()> Upg; //upgrade button callback
boost::function<void(ui32)> levelUp; //choose commander skill to level up
std::function<void()> dsm; //dismiss button callback
std::function<void()> Upg; //upgrade button callback
std::function<void(ui32)> levelUp; //choose commander skill to level up
CCreatureWindow(const CStack & stack, CreWinType type); //battle c-tor
CCreatureWindow (const CStackInstance &stack, CreWinType Type); //pop-up c-tor
CCreatureWindow(const CStackInstance &st, CreWinType Type, boost::function<void()> Upg, boost::function<void()> Dsm, UpgradeInfo *ui); //full garrison window
CCreatureWindow(const CCommanderInstance * commander, const CStack * stack = NULL); //commander window
CCreatureWindow(std::vector<ui32> &skills, const CCommanderInstance * commander, boost::function<void(ui32)> callback);
CCreatureWindow(const CStackInstance &st, CreWinType Type, std::function<void()> Upg, std::function<void()> Dsm, UpgradeInfo *ui); //full garrison window
CCreatureWindow(const CCommanderInstance * commander, const CStack * stack = nullptr); //commander window
CCreatureWindow(std::vector<ui32> &skills, const CCommanderInstance * commander, std::function<void(ui32)> callback);
CCreatureWindow(CreatureID Cid, CreWinType Type, int creatureCount); //c-tor
void init(const CStackInstance *stack, const CBonusSystemNode *stackNode, const CGHeroInstance *heroOwner);
@ -123,7 +123,7 @@ public:
class CSelectableSkill : public LRClickableAreaWText
{
public:
boost::function<void()> callback; //TODO: create more generic clickable class than AdvMapButton?
std::function<void()> callback; //TODO: create more generic clickable class than AdvMapButton?
virtual void clickLeft(tribool down, bool previousState);
virtual void clickRight(tribool down, bool previousState){};
@ -146,7 +146,7 @@ public:
CAdventureMapButton * dismiss, * upgrade, * ok;
CCreInfoWindow(const CStackInstance & st, bool LClicked, boost::function<void()> Upg = 0, boost::function<void()> Dsm = 0, UpgradeInfo * ui = NULL);
CCreInfoWindow(const CStackInstance & st, bool LClicked, std::function<void()> Upg = 0, std::function<void()> Dsm = 0, UpgradeInfo * ui = nullptr);
CCreInfoWindow(const CStack & st, bool LClicked = 0);
CCreInfoWindow(int Cid, bool LClicked, int creatureCount);
~CCreInfoWindow();
@ -159,4 +159,4 @@ public:
CIntObject *createCreWindow(const CStack *s, bool lclick = false);
CIntObject *createCreWindow(CreatureID Cid, CCreatureWindow::CreWinType Type, int creatureCount);
CIntObject *createCreWindow(const CStackInstance *s, CCreatureWindow::CreWinType type, boost::function<void()> Upg = 0, boost::function<void()> Dsm = 0, UpgradeInfo *ui = NULL);
CIntObject *createCreWindow(const CStackInstance *s, CCreatureWindow::CreWinType type, std::function<void()> Upg = 0, std::function<void()> Dsm = 0, UpgradeInfo *ui = nullptr);

4
client/CDefHandler.cpp
View File

@ -40,7 +40,7 @@ CDefHandler::~CDefHandler()
if (ourImages[i].bitmap)
{
SDL_FreeSurface(ourImages[i].bitmap);
ourImages[i].bitmap=NULL;
ourImages[i].bitmap=nullptr;
}
}
}
@ -130,7 +130,7 @@ void CDefHandler::expand(ui8 N,ui8 & BL, ui8 & BR)
SDL_Surface * CDefHandler::getSprite (int SIndex, const ui8 * FDef, const BMPPalette * palette) const
{
SDL_Surface * ret=NULL;
SDL_Surface * ret=nullptr;
ui32 BaseOffset,
SpriteWidth, SpriteHeight, //format of sprite

2
client/CGameInfo.cpp
View File

@ -18,7 +18,7 @@ CClientState * CCS;
CGameInfo::CGameInfo()
{
mh = NULL;
mh = nullptr;
}
void CGameInfo::setFromLib()

26
client/CHeroWindow.cpp
View File

@ -41,13 +41,13 @@
using namespace boost::assign;
const TBonusListPtr CHeroWithMaybePickedArtifact::getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root /*= NULL*/, const std::string &cachingStr /*= ""*/) const
const TBonusListPtr CHeroWithMaybePickedArtifact::getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root /*= nullptr*/, const std::string &cachingStr /*= ""*/) const
{
TBonusListPtr out(new BonusList);
TBonusListPtr heroBonuses = hero->getAllBonuses(selector, limit, hero);
TBonusListPtr bonusesFromPickedUpArtifact;
CArtifactsOfHero::SCommonPart *cp = cww->artSets.size() ? cww->artSets.front()->commonInfo : NULL;
CArtifactsOfHero::SCommonPart *cp = cww->artSets.size() ? cww->artSets.front()->commonInfo : nullptr;
if(cp && cp->src.art && cp->src.valid() && cp->src.AOH && cp->src.AOH->getHero() == hero)
{
bonusesFromPickedUpArtifact = cp->src.art->getAllBonuses(selector, limit, hero);
@ -103,20 +103,20 @@ CHeroWindow::CHeroWindow(const CGHeroInstance *hero):
//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);
quitButton = new CAdventureMapButton(CGI->generaltexth->heroscrn[17], std::string(),boost::bind(&CHeroWindow::close,this), 609, 516, "hsbtns.def", SDLK_RETURN);
quitButton = new CAdventureMapButton(CGI->generaltexth->heroscrn[17], std::string(),std::bind(&CHeroWindow::close,this), 609, 516, "hsbtns.def", SDLK_RETURN);
quitButton->assignedKeys.insert(SDLK_ESCAPE);
dismissButton = new CAdventureMapButton(std::string(), CGI->generaltexth->heroscrn[28], boost::bind(&CHeroWindow::dismissCurrent,this), 454, 429, "hsbtns2.def", SDLK_d);
questlogButton = new CAdventureMapButton(CGI->generaltexth->heroscrn[0], std::string(), boost::bind(&CHeroWindow::questlog,this), 314, 429, "hsbtns4.def", SDLK_q);
dismissButton = new CAdventureMapButton(std::string(), CGI->generaltexth->heroscrn[28], std::bind(&CHeroWindow::dismissCurrent,this), 454, 429, "hsbtns2.def", SDLK_d);
questlogButton = new CAdventureMapButton(CGI->generaltexth->heroscrn[0], std::string(), std::bind(&CHeroWindow::questlog,this), 314, 429, "hsbtns4.def", SDLK_q);
formations = new CHighlightableButtonsGroup(0);
formations->addButton(map_list_of(0,CGI->generaltexth->heroscrn[23]),CGI->generaltexth->heroscrn[29], "hsbtns6.def", 481, 483, 0, 0, SDLK_t);
formations->addButton(map_list_of(0,CGI->generaltexth->heroscrn[24]),CGI->generaltexth->heroscrn[30], "hsbtns7.def", 481, 519, 1, 0, SDLK_l);
tacticsButton = new CHighlightableButton(0, 0, map_list_of(0,CGI->generaltexth->heroscrn[26])(3,CGI->generaltexth->heroscrn[25]), CGI->generaltexth->heroscrn[31], false, "hsbtns8.def", NULL, 539, 483, SDLK_b);
tacticsButton = new CHighlightableButton(0, 0, map_list_of(0,CGI->generaltexth->heroscrn[26])(3,CGI->generaltexth->heroscrn[25]), CGI->generaltexth->heroscrn[31], false, "hsbtns8.def", nullptr, 539, 483, SDLK_b);
if (hero->commander)
{
commanderButton = new CAdventureMapButton ("Commander", "Commander info", boost::bind(&CHeroWindow::commanderWindow, this), 317, 18, "chftke.def", SDLK_c, NULL, false);
commanderButton = new CAdventureMapButton ("Commander", "Commander info", std::bind(&CHeroWindow::commanderWindow, this), 317, 18, "chftke.def", SDLK_c, nullptr, false);
}
@ -183,7 +183,7 @@ void CHeroWindow::update(const CGHeroInstance * hero, bool redrawNeeded /*= fals
{
if(!hero) //something strange... no hero? it shouldn't happen
{
logGlobal->errorStream() << "Set NULL hero? no way...";
logGlobal->errorStream() << "Set nullptr hero? no way...";
return;
}
@ -201,13 +201,13 @@ void CHeroWindow::update(const CGHeroInstance * hero, bool redrawNeeded /*= fals
portraitImage->setFrame(curHero->portrait);
{
CAdventureMapButton * split = NULL;
CAdventureMapButton * split = nullptr;
OBJ_CONSTRUCTION_CAPTURING_ALL;
if(!garr)
{
garr = new CGarrisonInt(15, 485, 8, Point(), background->bg, Point(15,485), curHero);
split = new CAdventureMapButton(CGI->generaltexth->allTexts[256], CGI->generaltexth->heroscrn[32],
boost::bind(&CGarrisonInt::splitClick,garr), 539, 519, "hsbtns9.def", false, NULL, false); //deleted by garrison destructor
std::bind(&CGarrisonInt::splitClick,garr), 539, 519, "hsbtns9.def", false, nullptr, false); //deleted by garrison destructor
boost::algorithm::replace_first(split->hoverTexts[0],"%s",CGI->generaltexth->allTexts[43]);
garr->addSplitBtn(split);
@ -282,7 +282,7 @@ void CHeroWindow::update(const CGHeroInstance * hero, bool redrawNeeded /*= fals
//setting formations
formations->onChange = 0;
formations->select(curHero->formation,true);
formations->onChange = boost::bind(&CCallback::setFormation, LOCPLINT->cb.get(), curHero, _1);
formations->onChange = std::bind(&CCallback::setFormation, LOCPLINT->cb.get(), curHero, _1);
morale->set(&heroWArt);
luck->set(&heroWArt);
@ -293,8 +293,8 @@ void CHeroWindow::update(const CGHeroInstance * hero, bool redrawNeeded /*= fals
void CHeroWindow::dismissCurrent()
{
CFunctionList<void()> ony = boost::bind(&CHeroWindow::close,this);
ony += boost::bind(&CCallback::dismissHero, LOCPLINT->cb.get(), curHero);
CFunctionList<void()> ony = std::bind(&CHeroWindow::close,this);
ony += std::bind(&CCallback::dismissHero, LOCPLINT->cb.get(), curHero);
LOCPLINT->showYesNoDialog(CGI->generaltexth->allTexts[22], ony, 0, false);
}

2
client/CHeroWindow.h
View File

@ -46,7 +46,7 @@ public:
CWindowWithArtifacts *cww;
CHeroWithMaybePickedArtifact(CWindowWithArtifacts *Cww, const CGHeroInstance *Hero);
const TBonusListPtr getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root = NULL, const std::string &cachingStr = "") const OVERRIDE;
const TBonusListPtr getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root = nullptr, const std::string &cachingStr = "") const override;
};
class CHeroWindow: public CWindowObject, public CWindowWithGarrison, public CWindowWithArtifacts

50
client/CKingdomInterface.cpp
View File

@ -32,8 +32,8 @@ InfoBox::InfoBox(Point position, InfoPos Pos, InfoSize Size, IInfoBoxData *Data)
size(Size),
infoPos(Pos),
data(Data),
value(NULL),
name(NULL)
value(nullptr),
name(nullptr)
{
assert(data);
addUsedEvents(LCLICK | RCLICK);
@ -253,7 +253,7 @@ bool InfoBoxAbstractHeroData::prepareMessage(std::string &text, CComponent **com
{
case HERO_SPECIAL:
text = CGI->heroh->heroes[getSubID()]->specDescr;
*comp = NULL;
*comp = nullptr;
return true;
case HERO_PRIMARY_SKILL:
text = CGI->generaltexth->arraytxt[2+getSubID()];
@ -261,11 +261,11 @@ bool InfoBoxAbstractHeroData::prepareMessage(std::string &text, CComponent **com
return true;
case HERO_MANA:
text = CGI->generaltexth->allTexts[149];
*comp = NULL;
*comp = nullptr;
return true;
case HERO_EXPERIENCE:
text = CGI->generaltexth->allTexts[241];
*comp = NULL;
*comp = nullptr;
return true;
case HERO_SECONDARY_SKILL:
{
@ -383,7 +383,7 @@ bool InfoBoxHeroData::prepareMessage(std::string &text, CComponent**comp)
boost::replace_first(text, "%s", boost::lexical_cast<std::string>(hero->name));
boost::replace_first(text, "%d", boost::lexical_cast<std::string>(hero->mana));
boost::replace_first(text, "%d", boost::lexical_cast<std::string>(hero->manaLimit()));
*comp = NULL;
*comp = nullptr;
return true;
case HERO_EXPERIENCE:
@ -391,7 +391,7 @@ bool InfoBoxHeroData::prepareMessage(std::string &text, CComponent**comp)
boost::replace_first(text, "%d", boost::lexical_cast<std::string>(hero->level));
boost::replace_first(text, "%d", boost::lexical_cast<std::string>(CGI->heroh->reqExp(hero->level+1)));
boost::replace_first(text, "%d", boost::lexical_cast<std::string>(hero->exp));
*comp = NULL;
*comp = nullptr;
return true;
default:
@ -462,7 +462,7 @@ CKingdomInterface::CKingdomInterface():
OBJ_CONSTRUCTION_CAPTURING_ALL;
ui32 footerPos = conf.go()->ac.overviewSize * 116;
tabArea = new CTabbedInt(boost::bind(&CKingdomInterface::createMainTab, this, _1), CTabbedInt::DestroyFunc(), Point(4,4));
tabArea = new CTabbedInt(std::bind(&CKingdomInterface::createMainTab, this, _1), CTabbedInt::DestroyFunc(), Point(4,4));
std::vector<const CGObjectInstance * > ownedObjects = LOCPLINT->cb->getMyObjects();
generateObjectsList(ownedObjects);
@ -522,7 +522,7 @@ void CKingdomInterface::generateObjectsList(const std::vector<const CGObjectInst
{
objects.push_back(element.second);
}
dwellingsList = new CListBox(boost::bind(&CKingdomInterface::createOwnedObject, this, _1), CListBox::DestroyFunc(),
dwellingsList = new CListBox(std::bind(&CKingdomInterface::createOwnedObject, this, _1), CListBox::DestroyFunc(),
Point(740,44), Point(0,57), dwellSize, visibleObjects.size());
}
@ -535,7 +535,7 @@ CIntObject* CKingdomInterface::createOwnedObject(size_t index)
return new InfoBox(Point(), InfoBox::POS_CORNER, InfoBox::SIZE_SMALL,
new InfoBoxCustom(value,"", "FLAGPORT", obj.imageID, obj.hoverText));
}
return NULL;
return nullptr;
}
CIntObject * CKingdomInterface::createMainTab(size_t index)
@ -545,7 +545,7 @@ CIntObject * CKingdomInterface::createMainTab(size_t index)
{
case 0: return new CKingdHeroList(size);
case 1: return new CKingdTownList(size);
default:return NULL;
default:return nullptr;
}
}
@ -603,30 +603,30 @@ void CKingdomInterface::generateButtons()
//Main control buttons
btnHeroes = new CAdventureMapButton (CGI->generaltexth->overview[11], CGI->generaltexth->overview[6],
boost::bind(&CKingdomInterface::activateTab, this, 0),748,28+footerPos,"OVBUTN1.DEF", SDLK_h);
std::bind(&CKingdomInterface::activateTab, this, 0),748,28+footerPos,"OVBUTN1.DEF", SDLK_h);
btnHeroes->block(true);
btnTowns = new CAdventureMapButton (CGI->generaltexth->overview[12], CGI->generaltexth->overview[7],
boost::bind(&CKingdomInterface::activateTab, this, 1),748,64+footerPos,"OVBUTN6.DEF", SDLK_t);
std::bind(&CKingdomInterface::activateTab, this, 1),748,64+footerPos,"OVBUTN6.DEF", SDLK_t);
btnExit = new CAdventureMapButton (CGI->generaltexth->allTexts[600],"",
boost::bind(&CKingdomInterface::close, this),748,99+footerPos,"OVBUTN1.DEF", SDLK_RETURN);
std::bind(&CKingdomInterface::close, this),748,99+footerPos,"OVBUTN1.DEF", SDLK_RETURN);
btnExit->assignedKeys.insert(SDLK_ESCAPE);
btnExit->setOffset(3);
//Object list control buttons
dwellTop = new CAdventureMapButton ("", "", boost::bind(&CListBox::moveToPos, dwellingsList, 0),
dwellTop = new CAdventureMapButton ("", "", std::bind(&CListBox::moveToPos, dwellingsList, 0),
733, 4, "OVBUTN4.DEF");
dwellBottom = new CAdventureMapButton ("", "", boost::bind(&CListBox::moveToPos, dwellingsList, -1),
dwellBottom = new CAdventureMapButton ("", "", std::bind(&CListBox::moveToPos, dwellingsList, -1),
733, footerPos+2, "OVBUTN4.DEF");
dwellBottom->setOffset(2);
dwellUp = new CAdventureMapButton ("", "", boost::bind(&CListBox::moveToPrev, dwellingsList),
dwellUp = new CAdventureMapButton ("", "", std::bind(&CListBox::moveToPrev, dwellingsList),
733, 24, "OVBUTN4.DEF");
dwellUp->setOffset(4);
dwellDown = new CAdventureMapButton ("", "", boost::bind(&CListBox::moveToNext, dwellingsList),
dwellDown = new CAdventureMapButton ("", "", std::bind(&CListBox::moveToNext, dwellingsList),
733, footerPos-18, "OVBUTN4.DEF");
dwellDown->setOffset(6);
}
@ -684,7 +684,7 @@ CKingdHeroList::CKingdHeroList(size_t maxSize)
ui32 townCount = LOCPLINT->cb->howManyHeroes(false);
ui32 size = conf.go()->ac.overviewSize*116 + 19;
heroes = new CListBox(boost::bind(&CKingdHeroList::createHeroItem, this, _1), boost::bind(&CKingdHeroList::destroyHeroItem, this, _1),
heroes = new CListBox(std::bind(&CKingdHeroList::createHeroItem, this, _1), std::bind(&CKingdHeroList::destroyHeroItem, this, _1),
Point(19,21), Point(0,116), maxSize, townCount, 0, 1, Rect(-19, -21, size, size) );
}
@ -737,7 +737,7 @@ CKingdTownList::CKingdTownList(size_t maxSize)
ui32 townCount = LOCPLINT->cb->howManyTowns();
ui32 size = conf.go()->ac.overviewSize*116 + 19;
towns = new CListBox(boost::bind(&CKingdTownList::createTownItem, this, _1), CListBox::DestroyFunc(),
towns = new CListBox(std::bind(&CKingdTownList::createTownItem, this, _1), CListBox::DestroyFunc(),
Point(19,21), Point(0,116), maxSize, townCount, 0, 1, Rect(-19, -21, size, size) );
}
@ -784,7 +784,7 @@ CTownItem::CTownItem(const CGTownInstance* Town):
hall = new CTownInfo( 69, 31, town, true);
fort = new CTownInfo(111, 31, town, false);
garr = new CGarrisonInt(313, 3, 4, Point(232,0), NULL, Point(313,2), town->getUpperArmy(), town->visitingHero, true, true, true);
garr = new CGarrisonInt(313, 3, 4, Point(232,0), nullptr, Point(313,2), town->getUpperArmy(), town->visitingHero, true, true, true);
heroes = new HeroSlots(town, Point(244,6), Point(475,6), garr, false);
size_t iconIndex = town->town->clientInfo.icons[town->hasFort()][town->builded >= CGI->modh->settings.MAX_BUILDING_PER_TURN];
@ -886,7 +886,7 @@ CHeroItem::CHeroItem(const CGHeroInstance* Hero, CArtifactsOfHero::SCommonPart *
heroArts->commonInfo = artsCommonPart;
heroArts->setHero(hero);
artsTabs = new CTabbedInt(boost::bind(&CHeroItem::onTabSelected, this, _1), boost::bind(&CHeroItem::onTabDeselected, this, _1));
artsTabs = new CTabbedInt(std::bind(&CHeroItem::onTabSelected, this, _1), std::bind(&CHeroItem::onTabDeselected, this, _1));
artButtons = new CHighlightableButtonsGroup(0);
for (size_t it = 0; it<3; it++)
@ -900,11 +900,11 @@ CHeroItem::CHeroItem(const CGHeroInstance* Hero, CArtifactsOfHero::SCommonPart *
artButtons->addButton(tooltip, overlay, "OVBUTN3",364+it*112, 46, it);
artButtons->buttons[it]->addTextOverlay(CGI->generaltexth->allTexts[stringID[it]], FONT_SMALL, Colors::YELLOW);
}
artButtons->onChange += boost::bind(&CTabbedInt::setActive, artsTabs, _1);
artButtons->onChange += boost::bind(&CHeroItem::onArtChange, this, _1);
artButtons->onChange += std::bind(&CTabbedInt::setActive, artsTabs, _1);
artButtons->onChange += std::bind(&CHeroItem::onArtChange, this, _1);
artButtons->select(0,0);
garr = new CGarrisonInt(6, 78, 4, Point(), NULL, Point(), hero, NULL, true, true);
garr = new CGarrisonInt(6, 78, 4, Point(), nullptr, Point(), hero, nullptr, true, true);
portrait = new CAnimImage("PortraitsLarge", hero->portrait, 0, 5, 6);
heroArea = new CHeroArea(5, 6, hero);

29
client/CMT.cpp
View File

@ -1,7 +1,6 @@
// CMT.cpp : Defines the entry point for the console application.
//
#include "StdInc.h"
#include <boost/filesystem/operations.hpp>
#include <SDL_mixer.h>
#include "gui/SDL_Extensions.h"
#include "CGameInfo.h"
@ -68,9 +67,9 @@ namespace po = boost::program_options;
std::string NAME_AFFIX = "client";
std::string NAME = GameConstants::VCMI_VERSION + std::string(" (") + NAME_AFFIX + ')'; //application name
CGuiHandler GH;
static CClient *client=NULL;
SDL_Surface *screen = NULL, //main screen surface
*screen2 = NULL,//and hlp surface (used to store not-active interfaces layer)
static CClient *client=nullptr;
SDL_Surface *screen = nullptr, //main screen surface
*screen2 = nullptr,//and hlp surface (used to store not-active interfaces layer)
*screenBuf = screen; //points to screen (if only advmapint is present) or screen2 (else) - should be used when updating controls which are not regularly redrawed
static boost::thread *mainGUIThread;
@ -89,7 +88,7 @@ void dispose();
void playIntro();
static void listenForEvents();
//void requestChangingResolution();
void startGame(StartInfo * options, CConnection *serv = NULL);
void startGame(StartInfo * options, CConnection *serv = nullptr);
#ifndef _WIN32
#ifndef _GNU_SOURCE
@ -212,7 +211,7 @@ int main(int argc, char** argv)
// Check that game data is prepared. Otherwise run vcmibuilder helper application
FILE* check = fopen((VCMIDirs::get().localPath() + "/game_data_prepared").c_str(), "r");
if (check == NULL) {
if (check == nullptr) {
system("open ./vcmibuilder.app");
return 0;
}
@ -276,7 +275,7 @@ int main(int argc, char** argv)
CStopWatch total, pomtime;
std::cout.flags(std::ios::unitbuf);
console = new CConsoleHandler;
*console->cb = boost::bind(&processCommand, _1);
*console->cb = std::bind(&processCommand, _1);
console->start();
atexit(dispose);
@ -314,7 +313,7 @@ int main(int argc, char** argv)
logGlobal->infoStream() <<"Loading settings: "<<pomtime.getDiff();
logGlobal->infoStream() << NAME;
srand ( time(NULL) );
srand ( time(nullptr) );
const JsonNode& video = settings["video"];
@ -367,7 +366,7 @@ int main(int argc, char** argv)
{
if(!vm.count("battle") && !vm.count("nointro"))
playIntro();
SDL_FillRect(screen,NULL,0);
SDL_FillRect(screen,nullptr,0);
}
CSDL_Ext::update(screen);
@ -408,7 +407,7 @@ int main(int argc, char** argv)
if(!gNoGUI)
{
mainGUIThread = new boost::thread(&CGuiHandler::run, boost::ref(GH));
mainGUIThread = new boost::thread(&CGuiHandler::run, &GH);
listenForEvents();
}
else
@ -560,7 +559,7 @@ void processCommand(const std::string &message)
}
else if(cn=="crash")
{
int *ptr = NULL;
int *ptr = nullptr;
*ptr = 666;
//disaster!
}
@ -769,7 +768,7 @@ static void setScreenRes(int w, int h, int bpp, bool fullscreen, bool resetVideo
SDL_InitSubSystem(SDL_INIT_VIDEO);
}
if((screen = SDL_SetVideoMode(w, h, suggestedBpp, SDL_SWSURFACE|(fullscreen?SDL_FULLSCREEN:0))) == NULL)
if((screen = SDL_SetVideoMode(w, h, suggestedBpp, SDL_SWSURFACE|(fullscreen?SDL_FULLSCREEN:0))) == nullptr)
{
logGlobal->errorStream() << "Requested screen resolution is not available (" << w << "x" << h << "x" << suggestedBpp << "bpp)";
throw std::runtime_error("Requested screen resolution is not available\n");
@ -914,7 +913,7 @@ static void listenForEvents()
}
}
void startGame(StartInfo * options, CConnection *serv/* = NULL*/)
void startGame(StartInfo * options, CConnection *serv/* = nullptr*/)
{
if(vm.count("onlyAI"))
{
@ -959,10 +958,10 @@ void handleQuit()
GH.terminate = true;
mainGUIThread->join();
delete mainGUIThread;
mainGUIThread = NULL;
mainGUIThread = nullptr;
}
delete console;
console = NULL;
console = nullptr;
boost::this_thread::sleep(boost::posix_time::milliseconds(750));
if(!gNoGUI)
SDL_Quit();

10
client/CMessage.cpp
View File

@ -65,7 +65,7 @@ namespace
{
CDefHandler * ok, *cancel;
std::vector<std::vector<SDL_Surface*> > piecesOfBox; //in colors of all players
SDL_Surface * background = NULL;
SDL_Surface * background = nullptr;
}
void CMessage::init()
@ -352,16 +352,16 @@ void CMessage::drawBorder(PlayerColor playerColor, SDL_Surface * ret, int w, int
//corners
Rect dstR(x, y, box[0]->w, box[0]->h);
CSDL_Ext::blitSurface(box[0], NULL, ret, &dstR);
CSDL_Ext::blitSurface(box[0], nullptr, ret, &dstR);
dstR=Rect(x+w-box[1]->w, y, box[1]->w, box[1]->h);
CSDL_Ext::blitSurface(box[1], NULL, ret, &dstR);
CSDL_Ext::blitSurface(box[1], nullptr, ret, &dstR);
dstR=Rect(x, y+h-box[2]->h+1, box[2]->w, box[2]->h);
CSDL_Ext::blitSurface(box[2], NULL, ret, &dstR);
CSDL_Ext::blitSurface(box[2], nullptr, ret, &dstR);
dstR=Rect(x+w-box[3]->w, y+h-box[3]->h+1, box[3]->w, box[3]->h);
CSDL_Ext::blitSurface(box[3], NULL, ret, &dstR);
CSDL_Ext::blitSurface(box[3], nullptr, ret, &dstR);
}
ComponentResolved::ComponentResolved( CComponent *Comp ):

18
client/CMusicHandler.cpp
View File

@ -83,7 +83,7 @@ void CSoundHandler::onVolumeChange(const JsonNode &volumeNode)
CSoundHandler::CSoundHandler():
listener(settings.listen["general"]["sound"])
{
listener(boost::bind(&CSoundHandler::onVolumeChange, this, _1));
listener(std::bind(&CSoundHandler::onVolumeChange, this, _1));
// Vectors for helper(s)
pickupSounds += soundBase::pickup01, soundBase::pickup02, soundBase::pickup03,
@ -269,9 +269,9 @@ void CSoundHandler::setVolume(ui32 percent)
Mix_Volume(-1, (MIX_MAX_VOLUME * volume)/100);
}
void CSoundHandler::setCallback(int channel, boost::function<void()> function)
void CSoundHandler::setCallback(int channel, std::function<void()> function)
{
std::map<int, boost::function<void()> >::iterator iter;
std::map<int, std::function<void()> >::iterator iter;
iter = callbacks.find(channel);
//channel not found. It may have finished so fire callback now
@ -283,7 +283,7 @@ void CSoundHandler::setCallback(int channel, boost::function<void()> function)
void CSoundHandler::soundFinishedCallback(int channel)
{
std::map<int, boost::function<void()> >::iterator iter;
std::map<int, std::function<void()> >::iterator iter;
iter = callbacks.find(channel);
assert(iter != callbacks.end());
@ -302,7 +302,7 @@ void CMusicHandler::onVolumeChange(const JsonNode &volumeNode)
CMusicHandler::CMusicHandler():
listener(settings.listen["general"]["music"])
{
listener(boost::bind(&CMusicHandler::onVolumeChange, this, _1));
listener(std::bind(&CMusicHandler::onVolumeChange, this, _1));
// Map music IDs
// Vectors for helper
const std::string setEnemy[] = {"AITheme0", "AITheme1", "AITheme2"};
@ -338,7 +338,7 @@ void CMusicHandler::release()
{
boost::mutex::scoped_lock guard(musicMutex);
Mix_HookMusicFinished(NULL);
Mix_HookMusicFinished(nullptr);
current.reset();
next.reset();
@ -416,7 +416,7 @@ void CMusicHandler::stopMusic(int fade_ms)
boost::mutex::scoped_lock guard(musicMutex);
if (current.get() != NULL)
if (current.get() != nullptr)
current->stop(fade_ms);
next.reset();
}
@ -433,7 +433,7 @@ void CMusicHandler::musicFinishedCallback(void)
{
boost::mutex::scoped_lock guard(musicMutex);
if (current.get() != NULL)
if (current.get() != nullptr)
{
//return if current music still not finished
if (current->play())
@ -442,7 +442,7 @@ void CMusicHandler::musicFinishedCallback(void)
current.reset();
}
if (current.get() == NULL && next.get() != NULL)
if (current.get() == nullptr && next.get() != nullptr)
{
current.reset(next.release());
current->play();

6
client/CMusicHandler.h
View File

@ -47,8 +47,8 @@ private:
Mix_Chunk *GetSoundChunk(std::string &sound);
//have entry for every currently active channel
//boost::function will be NULL if callback was not set
std::map<int, boost::function<void()> > callbacks;
//std::function will be nullptr if callback was not set
std::map<int, std::function<void()> > callbacks;
public:
CSoundHandler();
@ -65,7 +65,7 @@ public:
int playSoundFromSet(std::vector<soundBase::soundID> &sound_vec);
void stopSound(int handler);
void setCallback(int channel, boost::function<void()> function);
void setCallback(int channel, std::function<void()> function);
void soundFinishedCallback(int channel);
std::map<const CSpell*, std::string> spellSounds;

34
client/CPlayerInterface.cpp
View File

@ -112,11 +112,11 @@ CPlayerInterface::CPlayerInterface(PlayerColor Player)
howManyPeople++;
GH.defActionsDef = 0;
LOCPLINT = this;
curAction = NULL;
curAction = nullptr;
playerID=Player;
human=true;
castleInt = NULL;
battleInt = NULL;
castleInt = nullptr;
battleInt = nullptr;
//pim = new boost::recursive_mutex;
makingTurn = false;
showingDialog = new CondSh<bool>(false);
@ -138,12 +138,12 @@ CPlayerInterface::~CPlayerInterface()
if(adventureInt->active & CIntObject::KEYBOARD)
adventureInt->deactivateKeyboard();
delete adventureInt;
adventureInt = NULL;
adventureInt = nullptr;
}
delete cingconsole;
LOCPLINT = NULL;
LOCPLINT = nullptr;
}
void CPlayerInterface::init(shared_ptr<CCallback> CB)
{
@ -165,7 +165,7 @@ void CPlayerInterface::yourTurn()
LOCPLINT = this;
GH.curInt = this;
adventureInt->selection = NULL;
adventureInt->selection = nullptr;
if(firstCall)
{
@ -520,7 +520,7 @@ void CPlayerInterface::heroInGarrisonChange(const CGTownInstance *town)
wanderingHeroes.push_back(town->visitingHero);
}
adventureInt->heroList.update();
adventureInt->updateNextHero(NULL);
adventureInt->updateNextHero(nullptr);
if(CCastleInterface *c = castleInt)
{
@ -749,7 +749,7 @@ void CPlayerInterface::actionFinished(const BattleAction &action)
battleInt->endAction(curAction);
delete curAction;
curAction = NULL;
curAction = nullptr;
}
BattleAction CPlayerInterface::activeStack(const CStack * stack) //called when it's turn of that stack
@ -792,7 +792,7 @@ BattleAction CPlayerInterface::activeStack(const CStack * stack) //called when i
//tidy up
BattleAction ret = *(b->givenCommand->data);
delete b->givenCommand->data;
b->givenCommand->data = NULL;
b->givenCommand->data = nullptr;
//return command
logGlobal->traceStream() << "Giving command for " << stack->nodeName();
@ -1325,12 +1325,12 @@ bool CPlayerInterface::moveHero( const CGHeroInstance *h, CGPath path )
bool CPlayerInterface::shiftPressed() const
{
return SDL_GetKeyState(NULL)[SDLK_LSHIFT] || SDL_GetKeyState(NULL)[SDLK_RSHIFT];
return SDL_GetKeyState(nullptr)[SDLK_LSHIFT] || SDL_GetKeyState(nullptr)[SDLK_RSHIFT];
}
bool CPlayerInterface::altPressed() const
{
return SDL_GetKeyState(NULL)[SDLK_LALT] || SDL_GetKeyState(NULL)[SDLK_RALT];
return SDL_GetKeyState(nullptr)[SDLK_LALT] || SDL_GetKeyState(nullptr)[SDLK_RALT];
}
void CPlayerInterface::showGarrisonDialog( const CArmedInstance *up, const CGHeroInstance *down, bool removableUnits, QueryID queryID)
@ -1468,7 +1468,7 @@ void CPlayerInterface::initializeHeroTownList()
towns.push_back(allTowns[i]);
if (adventureInt)
adventureInt->updateNextHero(NULL);
adventureInt->updateNextHero(nullptr);
}
void CPlayerInterface::showRecruitmentDialog(const CGDwelling *dwelling, const CArmedInstance *dst, int level)
@ -1547,7 +1547,7 @@ void CPlayerInterface::objectRemoved( const CGObjectInstance *obj )
bool CPlayerInterface::ctrlPressed() const
{
return SDL_GetKeyState(NULL)[SDLK_LCTRL] || SDL_GetKeyState(NULL)[SDLK_RCTRL];
return SDL_GetKeyState(nullptr)[SDLK_LCTRL] || SDL_GetKeyState(nullptr)[SDLK_RCTRL];
}
void CPlayerInterface::update()
@ -2133,7 +2133,7 @@ void CPlayerInterface::eraseCurrentPathOf( const CGHeroInstance * ho, bool check
assert(ho == adventureInt->selection);
paths.erase(ho);
adventureInt->terrain.currentPath = NULL;
adventureInt->terrain.currentPath = nullptr;
adventureInt->updateMoveHero(ho, false);
}
@ -2165,7 +2165,7 @@ CGPath * CPlayerInterface::getAndVerifyPath(const CGHeroInstance * h)
}
}
return NULL;
return nullptr;
}
void CPlayerInterface::acceptTurn()
@ -2193,7 +2193,7 @@ void CPlayerInterface::acceptTurn()
//show new day animation and sound on infobar
adventureInt->infoBar.showDate();
adventureInt->updateNextHero(NULL);
adventureInt->updateNextHero(nullptr);
adventureInt->showAll(screen);
if(settings["session"]["autoSkip"].Bool() && !LOCPLINT->shiftPressed())
@ -2286,7 +2286,7 @@ void CPlayerInterface::showHillFortWindow(const CGObjectInstance *object, const
GH.pushInt(chfw);
}
void CPlayerInterface::availableArtifactsChanged(const CGBlackMarket *bm /*= NULL*/)
void CPlayerInterface::availableArtifactsChanged(const CGBlackMarket *bm /*= nullptr*/)
{
EVENT_HANDLER_CALLED_BY_CLIENT;
if(CMarketplaceWindow *cmw = dynamic_cast<CMarketplaceWindow*>(GH.topInt()))

144
client/CPlayerInterface.h
View File

@ -97,12 +97,12 @@ public:
static const int SAVES_COUNT = 5;
static int howManyPeople;
CCastleInterface * castleInt; //NULL if castle window isn't opened
static CBattleInterface * battleInt; //NULL if no battle
CCastleInterface * castleInt; //nullptr if castle window isn't opened
static CBattleInterface * battleInt; //nullptr if no battle
CInGameConsole * cingconsole;
shared_ptr<CCallback> cb; //to communicate with engine
const BattleAction *curAction; //during the battle - action currently performed by active stack (or NULL)
const BattleAction *curAction; //during the battle - action currently performed by active stack (or nullptr)
std::list<CInfoWindow *> dialogs; //queue of dialogs awaiting to be shown (not currently shown!)
@ -133,13 +133,13 @@ public:
int getLastIndex(std::string namePrefix);
//overridden funcs from CGameInterface
void buildChanged(const CGTownInstance *town, BuildingID buildingID, int what) OVERRIDE; //what: 1 - built, 2 - demolished
void stackChagedCount(const StackLocation &location, const TQuantity &change, bool isAbsolute) OVERRIDE; //if absolute, change is the new count; otherwise count was modified by adding change
void stackChangedType(const StackLocation &location, const CCreature &newType) OVERRIDE; //used eg. when upgrading creatures
void stacksErased(const StackLocation &location) OVERRIDE; //stack removed from previously filled slot
void stacksSwapped(const StackLocation &loc1, const StackLocation &loc2) OVERRIDE;
void newStackInserted(const StackLocation &location, const CStackInstance &stack) OVERRIDE; //new stack inserted at given (previously empty position)
void stacksRebalanced(const StackLocation &src, const StackLocation &dst, TQuantity count) OVERRIDE; //moves creatures from src stack to dst slot, may be used for merging/splittint/moving stacks
void buildChanged(const CGTownInstance *town, BuildingID buildingID, int what) override; //what: 1 - built, 2 - demolished
void stackChagedCount(const StackLocation &location, const TQuantity &change, bool isAbsolute) override; //if absolute, change is the new count; otherwise count was modified by adding change
void stackChangedType(const StackLocation &location, const CCreature &newType) override; //used eg. when upgrading creatures
void stacksErased(const StackLocation &location) override; //stack removed from previously filled slot
void stacksSwapped(const StackLocation &loc1, const StackLocation &loc2) override;
void newStackInserted(const StackLocation &location, const CStackInstance &stack) override; //new stack inserted at given (previously empty position)
void stacksRebalanced(const StackLocation &src, const StackLocation &dst, TQuantity count) override; //moves creatures from src stack to dst slot, may be used for merging/splittint/moving stacks
void artifactPut(const ArtifactLocation &al);
void artifactRemoved(const ArtifactLocation &al);
@ -147,70 +147,70 @@ public:
void artifactAssembled(const ArtifactLocation &al);
void artifactDisassembled(const ArtifactLocation &al);
void heroCreated(const CGHeroInstance* hero) OVERRIDE;
void heroGotLevel(const CGHeroInstance *hero, PrimarySkill::PrimarySkill pskill, std::vector<SecondarySkill> &skills, QueryID queryID) OVERRIDE;
void commanderGotLevel (const CCommanderInstance * commander, std::vector<ui32> skills, QueryID queryID) OVERRIDE;
void heroInGarrisonChange(const CGTownInstance *town) OVERRIDE;
void heroMoved(const TryMoveHero & details) OVERRIDE;
void heroPrimarySkillChanged(const CGHeroInstance * hero, int which, si64 val) OVERRIDE;
void heroSecondarySkillChanged(const CGHeroInstance * hero, int which, int val) OVERRIDE;
void heroManaPointsChanged(const CGHeroInstance * hero) OVERRIDE;
void heroMovePointsChanged(const CGHeroInstance * hero) OVERRIDE;
void heroVisitsTown(const CGHeroInstance* hero, const CGTownInstance * town) OVERRIDE;
void receivedResource(int type, int val) OVERRIDE;
void showInfoDialog(const std::string &text, const std::vector<Component*> &components, int soundID) OVERRIDE;
void showRecruitmentDialog(const CGDwelling *dwelling, const CArmedInstance *dst, int level) OVERRIDE;
void showShipyardDialog(const IShipyard *obj) OVERRIDE; //obj may be town or shipyard;
void showBlockingDialog(const std::string &text, const std::vector<Component> &components, QueryID askID, int soundID, bool selection, bool cancel) OVERRIDE; //Show a dialog, player must take decision. If selection then he has to choose between one of given components, if cancel he is allowed to not choose. After making choice, CCallback::selectionMade should be called with number of selected component (1 - n) or 0 for cancel (if allowed) and askID.
void showGarrisonDialog(const CArmedInstance *up, const CGHeroInstance *down, bool removableUnits, QueryID queryID) OVERRIDE;
void showPuzzleMap() OVERRIDE;
void showMarketWindow(const IMarket *market, const CGHeroInstance *visitor) OVERRIDE;
void showUniversityWindow(const IMarket *market, const CGHeroInstance *visitor) OVERRIDE;
void showHillFortWindow(const CGObjectInstance *object, const CGHeroInstance *visitor) OVERRIDE;
void showTavernWindow(const CGObjectInstance *townOrTavern) OVERRIDE;
void showThievesGuildWindow (const CGObjectInstance * obj) OVERRIDE;
void showQuestLog() OVERRIDE;
void advmapSpellCast(const CGHeroInstance * caster, int spellID) OVERRIDE; //called when a hero casts a spell
void tileHidden(const boost::unordered_set<int3, ShashInt3> &pos) OVERRIDE; //called when given tiles become hidden under fog of war
void tileRevealed(const boost::unordered_set<int3, ShashInt3> &pos) OVERRIDE; //called when fog of war disappears from given tiles
void newObject(const CGObjectInstance * obj) OVERRIDE;
void availableArtifactsChanged(const CGBlackMarket *bm = NULL) OVERRIDE; //bm may be NULL, then artifacts are changed in the global pool (used by merchants in towns)
void yourTurn() OVERRIDE;
void availableCreaturesChanged(const CGDwelling *town) OVERRIDE;
void heroBonusChanged(const CGHeroInstance *hero, const Bonus &bonus, bool gain) OVERRIDE;//if gain hero received bonus, else he lost it
void playerBonusChanged(const Bonus &bonus, bool gain) OVERRIDE;
void requestRealized(PackageApplied *pa) OVERRIDE;
void heroExchangeStarted(ObjectInstanceID hero1, ObjectInstanceID hero2, QueryID query) OVERRIDE;
void centerView (int3 pos, int focusTime) OVERRIDE;
void objectPropertyChanged(const SetObjectProperty * sop) OVERRIDE;
void objectRemoved(const CGObjectInstance *obj) OVERRIDE;
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 saveGame(COSer<CSaveFile> &h, const int version) OVERRIDE; //saving
void loadGame(CISer<CLoadFile> &h, const int version) OVERRIDE; //loading
void heroCreated(const CGHeroInstance* hero) override;
void heroGotLevel(const CGHeroInstance *hero, PrimarySkill::PrimarySkill pskill, std::vector<SecondarySkill> &skills, QueryID queryID) override;
void commanderGotLevel (const CCommanderInstance * commander, std::vector<ui32> skills, QueryID queryID) override;
void heroInGarrisonChange(const CGTownInstance *town) override;
void heroMoved(const TryMoveHero & details) override;
void heroPrimarySkillChanged(const CGHeroInstance * hero, int which, si64 val) override;
void heroSecondarySkillChanged(const CGHeroInstance * hero, int which, int val) override;
void heroManaPointsChanged(const CGHeroInstance * hero) override;
void heroMovePointsChanged(const CGHeroInstance * hero) override;
void heroVisitsTown(const CGHeroInstance* hero, const CGTownInstance * town) override;
void receivedResource(int type, int val) override;
void showInfoDialog(const std::string &text, const std::vector<Component*> &components, int soundID) override;
void showRecruitmentDialog(const CGDwelling *dwelling, const CArmedInstance *dst, int level) override;
void showShipyardDialog(const IShipyard *obj) override; //obj may be town or shipyard;
void showBlockingDialog(const std::string &text, const std::vector<Component> &components, QueryID askID, int soundID, bool selection, bool cancel) override; //Show a dialog, player must take decision. If selection then he has to choose between one of given components, if cancel he is allowed to not choose. After making choice, CCallback::selectionMade should be called with number of selected component (1 - n) or 0 for cancel (if allowed) and askID.
void showGarrisonDialog(const CArmedInstance *up, const CGHeroInstance *down, bool removableUnits, QueryID queryID) override;
void showPuzzleMap() override;
void showMarketWindow(const IMarket *market, const CGHeroInstance *visitor) override;
void showUniversityWindow(const IMarket *market, const CGHeroInstance *visitor) override;
void showHillFortWindow(const CGObjectInstance *object, const CGHeroInstance *visitor) override;
void showTavernWindow(const CGObjectInstance *townOrTavern) override;
void showThievesGuildWindow (const CGObjectInstance * obj) override;
void showQuestLog() override;
void advmapSpellCast(const CGHeroInstance * caster, int spellID) override; //called when a hero casts a spell
void tileHidden(const boost::unordered_set<int3, ShashInt3> &pos) override; //called when given tiles become hidden under fog of war
void tileRevealed(const boost::unordered_set<int3, ShashInt3> &pos) override; //called when fog of war disappears from given tiles
void newObject(const CGObjectInstance * obj) override;
void availableArtifactsChanged(const CGBlackMarket *bm = nullptr) override; //bm may be nullptr, then artifacts are changed in the global pool (used by merchants in towns)
void yourTurn() override;
void availableCreaturesChanged(const CGDwelling *town) override;
void heroBonusChanged(const CGHeroInstance *hero, const Bonus &bonus, bool gain) override;//if gain hero received bonus, else he lost it
void playerBonusChanged(const Bonus &bonus, bool gain) override;
void requestRealized(PackageApplied *pa) override;
void heroExchangeStarted(ObjectInstanceID hero1, ObjectInstanceID hero2, QueryID query) override;
void centerView (int3 pos, int focusTime) override;
void objectPropertyChanged(const SetObjectProperty * sop) override;
void objectRemoved(const CGObjectInstance *obj) override;
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 saveGame(COSer<CSaveFile> &h, const int version) override; //saving
void loadGame(CISer<CLoadFile> &h, const int version) override; //loading
//for battles
void actionFinished(const BattleAction& action) OVERRIDE;//occurs AFTER action taken by active stack or by the hero
void actionStarted(const BattleAction& action) OVERRIDE;//occurs BEFORE action taken by active stack or by the hero
BattleAction activeStack(const CStack * stack) OVERRIDE; //called when it's turn of that stack
void battleAttack(const BattleAttack *ba) OVERRIDE; //stack performs attack
void battleEnd(const BattleResult *br) OVERRIDE; //end of battle
void battleNewRoundFirst(int round) OVERRIDE; //called at the beginning of each turn before changes are applied; used for HP regen handling
void battleNewRound(int round) OVERRIDE; //called at the beginning of each turn, round=-1 is the tactic phase, round=0 is the first "normal" turn
void battleStackMoved(const CStack * stack, std::vector<BattleHex> dest, int distance) OVERRIDE;
void battleSpellCast(const BattleSpellCast *sc) OVERRIDE;
void battleStacksEffectsSet(const SetStackEffect & sse) OVERRIDE; //called when a specific effect is set to stacks
void battleTriggerEffect(const BattleTriggerEffect & bte) OVERRIDE; //various one-shot effect
void battleStacksAttacked(const std::vector<BattleStackAttacked> & bsa) OVERRIDE;
void battleStart(const CCreatureSet *army1, const CCreatureSet *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool side) OVERRIDE; //called by engine when battle starts; side=0 - left, side=1 - right
void battleStacksHealedRes(const std::vector<std::pair<ui32, ui32> > & healedStacks, bool lifeDrain, bool tentHeal, si32 lifeDrainFrom) OVERRIDE; //called when stacks are healed / resurrected
void battleNewStackAppeared(const CStack * stack) OVERRIDE; //not called at the beginning of a battle or by resurrection; called eg. when elemental is summoned
void battleObstaclesRemoved(const std::set<si32> & removedObstacles) OVERRIDE; //called when a certain set of obstacles is removed from batlefield; IDs of them are given
void battleCatapultAttacked(const CatapultAttack & ca) OVERRIDE; //called when catapult makes an attack
void battleStacksRemoved(const BattleStacksRemoved & bsr) OVERRIDE; //called when certain stack is completely removed from battlefield
void battleObstaclePlaced(const CObstacleInstance &obstacle) OVERRIDE;
void yourTacticPhase(int distance) OVERRIDE;
void actionFinished(const BattleAction& action) override;//occurs AFTER action taken by active stack or by the hero
void actionStarted(const BattleAction& action) override;//occurs BEFORE action taken by active stack or by the hero
BattleAction activeStack(const CStack * stack) override; //called when it's turn of that stack
void battleAttack(const BattleAttack *ba) override; //stack performs attack
void battleEnd(const BattleResult *br) override; //end of battle
void battleNewRoundFirst(int round) override; //called at the beginning of each turn before changes are applied; used for HP regen handling
void battleNewRound(int round) override; //called at the beginning of each turn, round=-1 is the tactic phase, round=0 is the first "normal" turn
void battleStackMoved(const CStack * stack, std::vector<BattleHex> dest, int distance) override;
void battleSpellCast(const BattleSpellCast *sc) override;
void battleStacksEffectsSet(const SetStackEffect & sse) override; //called when a specific effect is set to stacks
void battleTriggerEffect(const BattleTriggerEffect & bte) override; //various one-shot effect
void battleStacksAttacked(const std::vector<BattleStackAttacked> & bsa) override;
void battleStart(const CCreatureSet *army1, const CCreatureSet *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool side) override; //called by engine when battle starts; side=0 - left, side=1 - right
void battleStacksHealedRes(const std::vector<std::pair<ui32, ui32> > & healedStacks, bool lifeDrain, bool tentHeal, si32 lifeDrainFrom) override; //called when stacks are healed / resurrected
void battleNewStackAppeared(const CStack * stack) override; //not called at the beginning of a battle or by resurrection; called eg. when elemental is summoned
void battleObstaclesRemoved(const std::set<si32> & removedObstacles) override; //called when a certain set of obstacles is removed from batlefield; IDs of them are given
void battleCatapultAttacked(const CatapultAttack & ca) override; //called when catapult makes an attack
void battleStacksRemoved(const BattleStacksRemoved & bsr) override; //called when certain stack is completely removed from battlefield
void battleObstaclePlaced(const CObstacleInstance &obstacle) override;
void yourTacticPhase(int distance) override;
//-------------//
void showArtifactAssemblyDialog(ui32 artifactID, ui32 assembleTo, bool assemble, CFunctionList<void()> onYes, CFunctionList<void()> onNo);

132
client/CPreGame.cpp
View File

@ -53,15 +53,15 @@
*
*/
namespace fs = boost::filesystem;
using boost::bind;
using boost::ref;
using std::bind;
using std::ref;
#if _MSC_VER >= 1600
//#define bind boost::bind
//#define ref boost::ref
//#define bind std::bind
//#define ref std::ref
#endif
void startGame(StartInfo * options, CConnection *serv = NULL);
void startGame(StartInfo * options, CConnection *serv = nullptr);
CGPreGame * CGP = nullptr;
ISelectionScreenInfo *SEL;
@ -92,8 +92,8 @@ struct EvilHlpStruct
}
else
{
serv = NULL;
sInfo = NULL;
serv = nullptr;
sInfo = nullptr;
}
}
@ -206,7 +206,7 @@ class CBaseForPGApply
public:
virtual void applyOnPG(CSelectionScreen *selScr, void *pack) const =0;
virtual ~CBaseForPGApply(){};
template<typename U> static CBaseForPGApply *getApplier(const U * t=NULL)
template<typename U> static CBaseForPGApply *getApplier(const U * t=nullptr)
{
return new CApplyOnPG<U>;
}
@ -222,7 +222,7 @@ public:
}
};
static CApplier<CBaseForPGApply> *applier = NULL;
static CApplier<CBaseForPGApply> *applier = nullptr;
static CPicture* createPicture(const JsonNode& config)
{
@ -253,7 +253,7 @@ CMenuScreen::CMenuScreen(const JsonNode& configNode):
//Hardcoded entry
menuNameToEntry.push_back("credits");
tabs = new CTabbedInt(boost::bind(&CMenuScreen::createTab, this, _1), CTabbedInt::DestroyFunc());
tabs = new CTabbedInt(std::bind(&CMenuScreen::createTab, this, _1), CTabbedInt::DestroyFunc());
tabs->type |= REDRAW_PARENT;
}
@ -302,8 +302,8 @@ void CMenuScreen::switchToTab(size_t index)
tabs->setActive(index);
}
//funciton for std::string -> boost::function conversion for main menu
static boost::function<void()> genCommand(CMenuScreen* menu, std::vector<std::string> menuType, const std::string &string)
//funciton for std::string -> std::function conversion for main menu
static std::function<void()> genCommand(CMenuScreen* menu, std::vector<std::string> menuType, const std::string &string)
{
static const std::vector<std::string> commandType = boost::assign::list_of
("to")("campaigns")("start")("load")("exit")("highscores");
@ -326,11 +326,11 @@ static boost::function<void()> genCommand(CMenuScreen* menu, std::vector<std::st
{
size_t index2 = std::find(menuType.begin(), menuType.end(), commands.front()) - menuType.begin();
if ( index2 != menuType.size())
return boost::bind(&CMenuScreen::switchToTab, menu, index2);
return std::bind(&CMenuScreen::switchToTab, menu, index2);
}
break; case 1://open campaign selection window
{
return boost::bind(&CGPreGame::openCampaignScreen, CGP, commands.front());
return std::bind(&CGPreGame::openCampaignScreen, CGP, commands.front());
}
break; case 2://start
{
@ -338,38 +338,38 @@ static boost::function<void()> genCommand(CMenuScreen* menu, std::vector<std::st
{
case 0: return bind(&CGPreGame::openSel, CGP, CMenuScreen::newGame, CMenuScreen::SINGLE_PLAYER);
case 1: return &pushIntT<CMultiMode>;
case 2: return boost::bind(&CGPreGame::openSel, CGP, CMenuScreen::campaignList, CMenuScreen::SINGLE_PLAYER);
case 3: return boost::function<void()>();//TODO: start tutorial
case 2: return std::bind(&CGPreGame::openSel, CGP, CMenuScreen::campaignList, CMenuScreen::SINGLE_PLAYER);
case 3: return std::function<void()>();//TODO: start tutorial
}
}
break; case 3://load
{
switch (std::find(gameType.begin(), gameType.end(), commands.front()) - gameType.begin())
{
case 0: return boost::bind(&CGPreGame::openSel, CGP, CMenuScreen::loadGame, CMenuScreen::SINGLE_PLAYER);
case 1: return boost::bind(&CGPreGame::openSel, CGP, CMenuScreen::loadGame, CMenuScreen::MULTI_HOT_SEAT);
case 2: return boost::function<void()>();//TODO: load campaign
case 3: return boost::function<void()>();//TODO: load tutorial
case 0: return std::bind(&CGPreGame::openSel, CGP, CMenuScreen::loadGame, CMenuScreen::SINGLE_PLAYER);
case 1: return std::bind(&CGPreGame::openSel, CGP, CMenuScreen::loadGame, CMenuScreen::MULTI_HOT_SEAT);
case 2: return std::function<void()>();//TODO: load campaign
case 3: return std::function<void()>();//TODO: load tutorial
}
}
break; case 4://exit
{
return boost::bind(CInfoWindow::showYesNoDialog, boost::ref(CGI->generaltexth->allTexts[69]), (const std::vector<CComponent*>*)0, do_quit, 0, false, PlayerColor(1));
return std::bind(CInfoWindow::showYesNoDialog, std::ref(CGI->generaltexth->allTexts[69]), (const std::vector<CComponent*>*)0, do_quit, 0, false, PlayerColor(1));
}
break; case 5://highscores
{
return boost::function<void()>(); //TODO: high scores &pushIntT<CHighScores>;
return std::function<void()>(); //TODO: high scores &pushIntT<CHighScores>;
}
}
}
}
logGlobal->errorStream()<<"Failed to parse command: "<<string;
return boost::function<void()>();
return std::function<void()>();
}
CAdventureMapButton* CMenuEntry::createButton(CMenuScreen* parent, const JsonNode& button)
{
boost::function<void()> command = genCommand(parent, parent->menuNameToEntry, button["command"].String());
std::function<void()> command = genCommand(parent, parent->menuNameToEntry, button["command"].String());
std::pair<std::string, std::string> help;
if (!button["help"].isNull() && button["help"].Float() > 0)
@ -437,8 +437,8 @@ void CreditsScreen::show(SDL_Surface * to)
SDL_SetClipRect(screen, &creditsArea);
redraw();
CIntObject::showAll(to);
SDL_SetClipRect(screen, NULL);
SDL_SetClipRect(screenBuf, NULL);
SDL_SetClipRect(screen, nullptr);
SDL_SetClipRect(screenBuf, nullptr);
//end of credits, close this screen
if (credits->pos.y + credits->pos.h < 0)
@ -520,7 +520,7 @@ void CGPreGame::update()
GH.updateTime();
GH.handleEvents();
//if (GH.curInt == NULL) // no redraw, when a new game was created
//if (GH.curInt == nullptr) // no redraw, when a new game was created
//return;
GH.topInt()->show(screen);
@ -562,9 +562,9 @@ void CGPreGame::removeFromGui()
GH.popInt(GH.topInt()); //remove background
}
CSelectionScreen::CSelectionScreen(CMenuScreen::EState Type, CMenuScreen::EMultiMode MultiPlayer /*= CMenuScreen::SINGLE_PLAYER*/, const std::map<ui8, std::string> * Names /*= NULL*/, const std::string & Address /*=""*/, const std::string & Port /*= ""*/)
: ISelectionScreenInfo(Names), serverHandlingThread(NULL), mx(new boost::recursive_mutex),
serv(NULL), ongoingClosing(false), myNameID(255)
CSelectionScreen::CSelectionScreen(CMenuScreen::EState Type, CMenuScreen::EMultiMode MultiPlayer /*= CMenuScreen::SINGLE_PLAYER*/, const std::map<ui8, std::string> * Names /*= nullptr*/, const std::string & Address /*=""*/, const std::string & Port /*= ""*/)
: ISelectionScreenInfo(Names), serverHandlingThread(nullptr), mx(new boost::recursive_mutex),
serv(nullptr), ongoingClosing(false), myNameID(255)
{
CGPreGame::create(); //we depend on its graphics
screenType = Type;
@ -574,7 +574,7 @@ CSelectionScreen::CSelectionScreen(CMenuScreen::EState Type, CMenuScreen::EMulti
bool network = (MultiPlayer == CMenuScreen::MULTI_NETWORK_GUEST || MultiPlayer == CMenuScreen::MULTI_NETWORK_HOST);
CServerHandler *sh = NULL;
CServerHandler *sh = nullptr;
if(multiPlayer == CMenuScreen::MULTI_NETWORK_HOST)
{
sh = new CServerHandler;
@ -605,16 +605,16 @@ CSelectionScreen::CSelectionScreen(CMenuScreen::EState Type, CMenuScreen::EMulti
}
sInfo.difficulty = 1;
current = NULL;
current = nullptr;
sInfo.mode = (Type == CMenuScreen::newGame ? StartInfo::NEW_GAME : StartInfo::LOAD_GAME);
sInfo.turnTime = 0;
curTab = NULL;
curTab = nullptr;
card = new InfoCard(network); //right info card
if (screenType == CMenuScreen::campaignList)
{
opt = NULL;
opt = nullptr;
}
else
{
@ -794,7 +794,7 @@ void CSelectionScreen::toggleTab(CIntObject *tab)
}
else
{
curTab = NULL;
curTab = nullptr;
};
GH.totalRedraw();
}
@ -814,7 +814,7 @@ void CSelectionScreen::changeSelection(const CMapInfo * to)
SEL->sInfo.difficulty = to->scenarioOpts->difficulty;
if(screenType != CMenuScreen::campaignList)
{
updateStartInfo(to ? to->fileURI : "", sInfo, to ? to->mapHeader.get() : NULL);
updateStartInfo(to ? to->fileURI : "", sInfo, to ? to->mapHeader.get() : nullptr);
if(screenType == CMenuScreen::newGame)
{
if(to && to->isRandomMap)
@ -910,7 +910,7 @@ void CSelectionScreen::startScenario()
StartInfo * si = new StartInfo(sInfo);
CGP->removeFromGui();
CGP->showLoadingScreen(boost::bind(&startGame, si, (CConnection *)nullptr));
CGP->showLoadingScreen(std::bind(&startGame, si, (CConnection *)nullptr));
}
else
{
@ -920,7 +920,7 @@ void CSelectionScreen::startScenario()
saveGameName = "Saves/" + sel->txt->text;
CFunctionList<void()> overWrite;
overWrite += boost::bind(&CCallback::save, LOCPLINT->cb.get(), saveGameName);
overWrite += std::bind(&CCallback::save, LOCPLINT->cb.get(), saveGameName);
overWrite += bind(&CGuiHandler::popIntTotally, &GH, this);
if(CResourceHandler::get()->existsResource(ResourceID(saveGameName, EResType::CLIENT_SAVEGAME)))
@ -950,7 +950,7 @@ void CSelectionScreen::handleConnection()
assert(serv);
while(serv)
{
CPackForSelectionScreen *pack = NULL;
CPackForSelectionScreen *pack = nullptr;
*serv >> pack;
logNetwork->traceStream() << "Received a pack of type " << typeid(*pack).name();
assert(pack);
@ -1093,7 +1093,7 @@ void SelectionTab::filter( int size, bool selectFirst )
else
{
slider->block(true);
onSelect(NULL);
onSelect(nullptr);
}
}
@ -1189,14 +1189,14 @@ void SelectionTab::parseCampaigns(const std::vector<ResourceID> & files )
}
}
SelectionTab::SelectionTab(CMenuScreen::EState Type, const boost::function<void(CMapInfo *)> &OnSelect, CMenuScreen::EMultiMode MultiPlayer /*= CMenuScreen::SINGLE_PLAYER*/)
:bg(NULL), onSelect(OnSelect)
SelectionTab::SelectionTab(CMenuScreen::EState Type, const std::function<void(CMapInfo *)> &OnSelect, CMenuScreen::EMultiMode MultiPlayer /*= CMenuScreen::SINGLE_PLAYER*/)
:bg(nullptr), onSelect(OnSelect)
{
OBJ_CONSTRUCTION;
selectionPos = 0;
addUsedEvents(LCLICK | WHEEL | KEYBOARD | DOUBLECLICK);
slider = NULL;
txt = NULL;
slider = nullptr;
txt = nullptr;
tabType = Type;
if (Type != CMenuScreen::campaignList)
@ -1936,14 +1936,14 @@ void CChatBox::addNewMessage(const std::string &text)
}
InfoCard::InfoCard( bool Network )
: bg(NULL), network(Network), chatOn(false), chat(NULL), playerListBg(NULL),
difficulty(NULL), sizes(NULL), sFlags(NULL)
: bg(nullptr), network(Network), chatOn(false), chat(nullptr), playerListBg(nullptr),
difficulty(nullptr), sizes(nullptr), sFlags(nullptr)
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
pos.x += 393;
pos.y += 6;
addUsedEvents(RCLICK);
mapDescription = NULL;
mapDescription = nullptr;
Rect descriptionRect(26, 149, 320, 115);
mapDescription = new CTextBox("", descriptionRect, 1);
@ -2244,7 +2244,7 @@ void InfoCard::setChat(bool activateChat)
}
OptionsTab::OptionsTab():
turnDuration(NULL)
turnDuration(nullptr)
{
OBJ_CONSTRUCTION;
bg = new CPicture("ADVOPTBK", 0, 6);
@ -2453,7 +2453,7 @@ void OptionsTab::setTurnLength( int npos )
void OptionsTab::flagPressed( PlayerColor color )
{
PlayerSettings &clicked = SEL->sInfo.playerInfos[color];
PlayerSettings *old = NULL;
PlayerSettings *old = nullptr;
if(SEL->playerNames.size() == 1) //single player -> just swap
{
@ -2564,7 +2564,7 @@ OptionsTab::PlayerOptionsEntry::PlayerOptionsEntry( OptionsTab *owner, PlayerSet
}
else
for(int i = 0; i < 6; i++)
btns[i] = NULL;
btns[i] = nullptr;
selectButtons();
@ -2586,7 +2586,7 @@ OptionsTab::PlayerOptionsEntry::PlayerOptionsEntry( OptionsTab *owner, PlayerSet
flag->hoverable = true;
}
else
flag = NULL;
flag = nullptr;
town = new SelectedBox(Point(119, 2), s, TOWN);
hero = new SelectedBox(Point(195, 2), s, HERO);
@ -3103,7 +3103,7 @@ CHotSeatPlayers::CHotSeatPlayers(const std::string &firstPlayer)
for(int i = 0; i < ARRAY_COUNT(txt); i++)
{
txt[i] = new CTextInput(Rect(60, 85 + i*30, 280, 16), *bg);
txt[i]->cb += boost::bind(&CHotSeatPlayers::onChange, this, _1);
txt[i]->cb += std::bind(&CHotSeatPlayers::onChange, this, _1);
}
ok = new CAdventureMapButton(CGI->generaltexth->zelp[560], bind(&CHotSeatPlayers::enterSelectionScreen, this), 95, 338, "MUBCHCK.DEF", SDLK_RETURN);
@ -3195,7 +3195,7 @@ void CBonusSelection::init()
{
regions.push_back(new CRegion(this, true, true, g));
regions[regions.size()-1]->rclickText = ourCampaign->camp->scenarios[g].regionText;
if (highlightedRegion == NULL)
if (highlightedRegion == nullptr)
{
highlightedRegion = regions.back();
selectMap(g, true);
@ -3609,7 +3609,7 @@ void CBonusSelection::startMap()
auto exitCb = [si]()
{
CGP->showLoadingScreen(boost::bind(&startGame, si, (CConnection *)nullptr));
CGP->showLoadingScreen(std::bind(&startGame, si, (CConnection *)nullptr));
};
if (scenario.prolog.hasPrologEpilog)
@ -3771,12 +3771,12 @@ CSavingScreen::~CSavingScreen()
}
ISelectionScreenInfo::ISelectionScreenInfo(const std::map<ui8, std::string> *Names /*= NULL*/)
ISelectionScreenInfo::ISelectionScreenInfo(const std::map<ui8, std::string> *Names /*= nullptr*/)
{
multiPlayer = CMenuScreen::SINGLE_PLAYER;
assert(!SEL);
SEL = this;
current = NULL;
current = nullptr;
if(Names && Names->size()) //if have custom set of player names - use it
playerNames = *Names;
@ -3787,7 +3787,7 @@ ISelectionScreenInfo::ISelectionScreenInfo(const std::map<ui8, std::string> *Nam
ISelectionScreenInfo::~ISelectionScreenInfo()
{
assert(SEL == this);
SEL = NULL;
SEL = nullptr;
}
void ISelectionScreenInfo::updateStartInfo(std::string filename, StartInfo & sInfo, const CMapHeader * mapHeader)
@ -3953,11 +3953,11 @@ void StartWithCurrentSettings::apply(CSelectionScreen *selScreen)
*selScreen->serv << this; //resend to confirm
}
selScreen->serv = NULL; //hide it so it won't be deleted
selScreen->serv = nullptr; //hide it so it won't be deleted
vstd::clear_pointer(selScreen->serverHandlingThread); //detach us
saveGameName.clear();
CGP->showLoadingScreen(boost::bind(&startGame, startingInfo.sInfo, startingInfo.serv));
CGP->showLoadingScreen(std::bind(&startGame, startingInfo.sInfo, startingInfo.serv));
throw 666; //EVIL, EVIL, EVIL workaround to kill thread (does "goto catch" outside listening loop)
}
@ -4037,7 +4037,7 @@ CAdventureMapButton* CCampaignScreen::createExitButton(const JsonNode& button)
if (!button["help"].isNull() && button["help"].Float() > 0)
help = CGI->generaltexth->zelp[button["help"].Float()];
boost::function<void()> close = boost::bind(&CGuiHandler::popIntTotally, &GH, this);
std::function<void()> close = std::bind(&CGuiHandler::popIntTotally, &GH, this);
return new CAdventureMapButton(help, close, button["x"].Float(), button["y"].Float(), button["name"].String(), button["hotkey"].Float());
}
@ -4074,7 +4074,7 @@ void CCampaignScreen::showAll(SDL_Surface *to)
CMessage::drawBorder(PlayerColor(1), to, pos.w+28, pos.h+30, pos.x-14, pos.y-15);
}
void CGPreGame::showLoadingScreen(boost::function<void()> loader)
void CGPreGame::showLoadingScreen(std::function<void()> loader)
{
if (GH.listInt.size() && GH.listInt.front() == CGP) //pregame active
CGP->removeFromGui();
@ -4090,7 +4090,7 @@ std::string CLoadingScreen::getBackground()
return conf[ rand() % conf.size() ].String();
}
CLoadingScreen::CLoadingScreen(boost::function<void ()> loader):
CLoadingScreen::CLoadingScreen(std::function<void ()> loader):
CWindowObject(BORDERED, getBackground()),
loadingThread(loader)
{
@ -4163,11 +4163,11 @@ CSimpleJoinScreen::CSimpleJoinScreen()
title = new CTextBox("Enter address:", boxRect, 0, FONT_BIG, CENTER, Colors::WHITE);
address = new CTextInput(Rect(25, 68, 175, 16), *bg);
address->cb += boost::bind(&CSimpleJoinScreen::onChange, this, _1);
address->cb += std::bind(&CSimpleJoinScreen::onChange, this, _1);
port = new CTextInput(Rect(25, 115, 175, 16), *bg);
port->cb += boost::bind(&CSimpleJoinScreen::onChange, this, _1);
port->filters.add(boost::bind(&CTextInput::numberFilter, _1, _2, 0, 65535));
port->cb += std::bind(&CSimpleJoinScreen::onChange, this, _1);
port->filters.add(std::bind(&CTextInput::numberFilter, _1, _2, 0, 65535));
ok = new CAdventureMapButton(CGI->generaltexth->zelp[560], bind(&CSimpleJoinScreen::enterSelectionScreen, this), 26, 142, "MUBCHCK.DEF", SDLK_RETURN);
cancel = new CAdventureMapButton(CGI->generaltexth->zelp[561], bind(&CGuiHandler::popIntTotally, ref(GH), this), 142, 142, "MUBCANC.DEF", SDLK_ESCAPE);
@ -4184,7 +4184,7 @@ void CSimpleJoinScreen::enterSelectionScreen()
std::string textPort = port->text;
GH.popIntTotally(this);
GH.pushInt(new CSelectionScreen(CMenuScreen::newGame, CMenuScreen::MULTI_NETWORK_GUEST, NULL, textAddress, textPort));
GH.pushInt(new CSelectionScreen(CMenuScreen::newGame, CMenuScreen::MULTI_NETWORK_GUEST, nullptr, textAddress, textPort));
}
void CSimpleJoinScreen::onChange(const std::string & newText)

12
client/CPreGame.h
View File

@ -157,7 +157,7 @@ public:
std::vector<CMapInfo> allItems;
std::vector<CMapInfo*> curItems;
size_t selectionPos;
boost::function<void(CMapInfo *)> onSelect;
std::function<void(CMapInfo *)> onSelect;
ESortBy sortingBy;
bool ascending;
@ -181,7 +181,7 @@ public:
void clickLeft(tribool down, bool previousState);
void keyPressed(const SDL_KeyboardEvent & key);
void onDoubleClick();
SelectionTab(CMenuScreen::EState Type, const boost::function<void(CMapInfo *)> &OnSelect, CMenuScreen::EMultiMode MultiPlayer = CMenuScreen::SINGLE_PLAYER);
SelectionTab(CMenuScreen::EState Type, const std::function<void(CMapInfo *)> &OnSelect, CMenuScreen::EMultiMode MultiPlayer = CMenuScreen::SINGLE_PLAYER);
~SelectionTab();
};
@ -321,7 +321,7 @@ public:
StartInfo sInfo;
std::map<ui8, std::string> playerNames; // id of player <-> player name; 0 is reserved as ID of AI "players"
ISelectionScreenInfo(const std::map<ui8, std::string> *Names = NULL);
ISelectionScreenInfo(const std::map<ui8, std::string> *Names = nullptr);
virtual ~ISelectionScreenInfo();
virtual void update(){};
virtual void propagateOptions() {};
@ -359,7 +359,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<ui8, std::string> * Names = NULL, const std::string & Address = "", const std::string & Port = "");
CSelectionScreen(CMenuScreen::EState Type, CMenuScreen::EMultiMode MultiPlayer = CMenuScreen::SINGLE_PLAYER, const std::map<ui8, std::string> * Names = nullptr, const std::string & Address = "", const std::string & Port = "");
~CSelectionScreen();
void toggleTab(CIntObject *tab);
void changeSelection(const CMapInfo *to);
@ -591,7 +591,7 @@ public:
static CGPreGame * create();
void removeFromGui();
static void showLoadingScreen(boost::function<void()> loader);
static void showLoadingScreen(std::function<void()> loader);
};
class CLoadingScreen : public CWindowObject
@ -600,7 +600,7 @@ class CLoadingScreen : public CWindowObject
std::string getBackground();
public:
CLoadingScreen(boost::function<void()> loader);
CLoadingScreen(std::function<void()> loader);
~CLoadingScreen();
void showAll(SDL_Surface *to);

14
client/CQuestLog.cpp
View File

@ -66,7 +66,7 @@ void CQuestIcon::showAll(SDL_Surface * to)
CQuestMinimap::CQuestMinimap (const Rect & position) :
CMinimap (position),
currentQuest (NULL)
currentQuest (nullptr)
{
}
@ -90,7 +90,7 @@ void CQuestMinimap::addQuestMarks (const QuestInfo * q)
CQuestIcon * pic = new CQuestIcon ("VwSymbol.def", 3, x, y);
pic->moveBy (Point ( -pic->pos.w/2, -pic->pos.h/2));
pic->callback = boost::bind (&CQuestMinimap::iconClicked, this);
pic->callback = std::bind (&CQuestMinimap::iconClicked, this);
icons.push_back(pic);
}
@ -119,9 +119,9 @@ void CQuestMinimap::showAll(SDL_Surface * to)
CQuestLog::CQuestLog (const std::vector<QuestInfo> & Quests) :
CWindowObject(PLAYER_COLORED, "QuestLog.pcx"),
questIndex(0),
currentQuest(NULL),
currentQuest(nullptr),
quests (Quests),
slider(NULL)
slider(nullptr)
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
init();
@ -131,10 +131,10 @@ void CQuestLog::init()
{
minimap = new CQuestMinimap (Rect (47, 33, 144, 144));
description = new CTextBox ("", Rect(245, 33, 350, 355), 1, FONT_MEDIUM, TOPLEFT, Colors::WHITE);
ok = new CAdventureMapButton("",CGI->generaltexth->zelp[445].second, boost::bind(&CQuestLog::close,this), 547, 401, "IOKAY.DEF", SDLK_RETURN);
ok = new CAdventureMapButton("",CGI->generaltexth->zelp[445].second, std::bind(&CQuestLog::close,this), 547, 401, "IOKAY.DEF", SDLK_RETURN);
if (quests.size() > QUEST_COUNT)
slider = new CSlider(203, 199, 230, boost::bind (&CQuestLog::sliderMoved, this, _1), QUEST_COUNT, quests.size(), false, 0);
slider = new CSlider(203, 199, 230, std::bind (&CQuestLog::sliderMoved, this, _1), QUEST_COUNT, quests.size(), false, 0);
for (int i = 0; i < quests.size(); ++i)
{
@ -143,7 +143,7 @@ void CQuestLog::init()
if (quests[i].obj)
text.addReplacement (quests[i].obj->getHoverText()); //get name of the object
CQuestLabel * label = new CQuestLabel (28, 199 + i * 24, FONT_SMALL, TOPLEFT, Colors::WHITE, text.toString());
label->callback = boost::bind(&CQuestLog::selectQuest, this, i);
label->callback = std::bind(&CQuestLog::selectQuest, this, i);
label->setBounds (172, 30);
labels.push_back(label);
}

4
client/CQuestLog.h
View File

@ -36,7 +36,7 @@ const int QUEST_COUNT = 9;
class CQuestLabel : public LRClickableAreaWText, public CBoundedLabel
{
public:
boost::function<void()> callback;
std::function<void()> callback;
CQuestLabel (int x=0, int y=0, EFonts Font = FONT_SMALL, EAlignment Align = TOPLEFT, const SDL_Color &Color = Colors::WHITE, const std::string &Text = "")
: CBoundedLabel (x, y, FONT_SMALL, TOPLEFT, Colors::WHITE, Text){};
@ -47,7 +47,7 @@ public:
class CQuestIcon : public CAnimImage
{
public:
boost::function<void()> callback; //TODO: merge with other similiar classes?
std::function<void()> callback; //TODO: merge with other similiar classes?
CQuestIcon (const std::string &defname, int index, int x=0, int y=0);

32
client/CSpellWindow.cpp
View File

@ -31,8 +31,8 @@
*
*/
SpellbookInteractiveArea::SpellbookInteractiveArea(const SDL_Rect & myRect, boost::function<void()> funcL,
const std::string & textR, boost::function<void()> funcHon, boost::function<void()> funcHoff, CPlayerInterface * _myInt)
SpellbookInteractiveArea::SpellbookInteractiveArea(const SDL_Rect & myRect, std::function<void()> funcL,
const std::string & textR, std::function<void()> funcHon, std::function<void()> funcHoff, CPlayerInterface * _myInt)
{
addUsedEvents(LCLICK | RCLICK | HOVER);
pos = myRect;
@ -159,29 +159,29 @@ CSpellWindow::CSpellWindow(const SDL_Rect &, const CGHeroInstance * _myHero, CPl
statusBar = new CGStatusBar(7 + pos.x, 569 + pos.y, "Spelroll.bmp");
SDL_Rect temp_rect = genRect(45, 35, 479 + pos.x, 405 + pos.y);
exitBtn = new SpellbookInteractiveArea(temp_rect, boost::bind(&CSpellWindow::fexitb, this), CGI->generaltexth->zelp[460].second, boost::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[460].first)), boost::bind(&CGStatusBar::clear, statusBar), myInt);
exitBtn = new SpellbookInteractiveArea(temp_rect, std::bind(&CSpellWindow::fexitb, this), CGI->generaltexth->zelp[460].second, std::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[460].first)), std::bind(&CGStatusBar::clear, statusBar), myInt);
temp_rect = genRect(45, 35, 221 + pos.x, 405 + pos.y);
battleSpells = new SpellbookInteractiveArea(temp_rect, boost::bind(&CSpellWindow::fbattleSpellsb, this), CGI->generaltexth->zelp[453].second, boost::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[453].first)), boost::bind(&CGStatusBar::clear, statusBar), myInt);
battleSpells = new SpellbookInteractiveArea(temp_rect, std::bind(&CSpellWindow::fbattleSpellsb, this), CGI->generaltexth->zelp[453].second, std::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[453].first)), std::bind(&CGStatusBar::clear, statusBar), myInt);
temp_rect = genRect(45, 35, 355 + pos.x, 405 + pos.y);
adventureSpells = new SpellbookInteractiveArea(temp_rect, boost::bind(&CSpellWindow::fadvSpellsb, this), CGI->generaltexth->zelp[452].second, boost::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[452].first)), boost::bind(&CGStatusBar::clear, statusBar), myInt);
adventureSpells = new SpellbookInteractiveArea(temp_rect, std::bind(&CSpellWindow::fadvSpellsb, this), CGI->generaltexth->zelp[452].second, std::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[452].first)), std::bind(&CGStatusBar::clear, statusBar), myInt);
temp_rect = genRect(45, 35, 418 + pos.x, 405 + pos.y);
manaPoints = new SpellbookInteractiveArea(temp_rect, boost::bind(&CSpellWindow::fmanaPtsb, this), CGI->generaltexth->zelp[459].second, boost::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[459].first)), boost::bind(&CGStatusBar::clear, statusBar), myInt);
manaPoints = new SpellbookInteractiveArea(temp_rect, std::bind(&CSpellWindow::fmanaPtsb, this), CGI->generaltexth->zelp[459].second, std::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[459].first)), std::bind(&CGStatusBar::clear, statusBar), myInt);
temp_rect = genRect(36, 56, 549 + pos.x, 94 + pos.y);
selectSpellsA = new SpellbookInteractiveArea(temp_rect, boost::bind(&CSpellWindow::selectSchool, this, 0), CGI->generaltexth->zelp[454].second, boost::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[454].first)), boost::bind(&CGStatusBar::clear, statusBar), myInt);
selectSpellsA = new SpellbookInteractiveArea(temp_rect, std::bind(&CSpellWindow::selectSchool, this, 0), CGI->generaltexth->zelp[454].second, std::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[454].first)), std::bind(&CGStatusBar::clear, statusBar), myInt);
temp_rect = genRect(36, 56, 549 + pos.x, 151 + pos.y);
selectSpellsE = new SpellbookInteractiveArea(temp_rect, boost::bind(&CSpellWindow::selectSchool, this, 3), CGI->generaltexth->zelp[457].second, boost::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[457].first)), boost::bind(&CGStatusBar::clear, statusBar), myInt);
selectSpellsE = new SpellbookInteractiveArea(temp_rect, std::bind(&CSpellWindow::selectSchool, this, 3), CGI->generaltexth->zelp[457].second, std::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[457].first)), std::bind(&CGStatusBar::clear, statusBar), myInt);
temp_rect = genRect(36, 56, 549 + pos.x, 210 + pos.y);
selectSpellsF = new SpellbookInteractiveArea(temp_rect, boost::bind(&CSpellWindow::selectSchool, this, 1), CGI->generaltexth->zelp[455].second, boost::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[455].first)), boost::bind(&CGStatusBar::clear, statusBar), myInt);
selectSpellsF = new SpellbookInteractiveArea(temp_rect, std::bind(&CSpellWindow::selectSchool, this, 1), CGI->generaltexth->zelp[455].second, std::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[455].first)), std::bind(&CGStatusBar::clear, statusBar), myInt);
temp_rect = genRect(36, 56, 549 + pos.x, 270 + pos.y);
selectSpellsW = new SpellbookInteractiveArea(temp_rect, boost::bind(&CSpellWindow::selectSchool, this, 2), CGI->generaltexth->zelp[456].second, boost::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[456].first)), boost::bind(&CGStatusBar::clear, statusBar), myInt);
selectSpellsW = new SpellbookInteractiveArea(temp_rect, std::bind(&CSpellWindow::selectSchool, this, 2), CGI->generaltexth->zelp[456].second, std::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[456].first)), std::bind(&CGStatusBar::clear, statusBar), myInt);
temp_rect = genRect(36, 56, 549 + pos.x, 330 + pos.y);
selectSpellsAll = new SpellbookInteractiveArea(temp_rect, boost::bind(&CSpellWindow::selectSchool, this, 4), CGI->generaltexth->zelp[458].second, boost::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[458].first)), boost::bind(&CGStatusBar::clear, statusBar), myInt);
selectSpellsAll = new SpellbookInteractiveArea(temp_rect, std::bind(&CSpellWindow::selectSchool, this, 4), CGI->generaltexth->zelp[458].second, std::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[458].first)), std::bind(&CGStatusBar::clear, statusBar), myInt);
temp_rect = genRect(leftCorner->h, leftCorner->w, 97 + pos.x, 77 + pos.y);
lCorner = new SpellbookInteractiveArea(temp_rect, boost::bind(&CSpellWindow::fLcornerb, this), CGI->generaltexth->zelp[450].second, boost::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[450].first)), boost::bind(&CGStatusBar::clear, statusBar), myInt);
lCorner = new SpellbookInteractiveArea(temp_rect, std::bind(&CSpellWindow::fLcornerb, this), CGI->generaltexth->zelp[450].second, std::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[450].first)), std::bind(&CGStatusBar::clear, statusBar), myInt);
temp_rect = genRect(rightCorner->h, rightCorner->w, 487 + pos.x, 72 + pos.y);
rCorner = new SpellbookInteractiveArea(temp_rect, boost::bind(&CSpellWindow::fRcornerb, this), CGI->generaltexth->zelp[451].second, boost::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[451].first)), boost::bind(&CGStatusBar::clear, statusBar), myInt);
rCorner = new SpellbookInteractiveArea(temp_rect, std::bind(&CSpellWindow::fRcornerb, this), CGI->generaltexth->zelp[451].second, std::bind(&CGStatusBar::print, statusBar, (CGI->generaltexth->zelp[451].first)), std::bind(&CGStatusBar::clear, statusBar), myInt);
//areas for spells
int xpos = 117 + pos.x, ypos = 90 + pos.y;
@ -758,7 +758,7 @@ void CSpellWindow::SpellArea::clickLeft(tribool down, bool previousState)
for(size_t i=0;i<Towns.size();i++)
{
const CGTownInstance *t = Towns[i];
if (t->visitingHero == NULL) //empty town and this is
if (t->visitingHero == nullptr) //empty town and this is
{
availableTowns.push_back(t->id.getNum());//add to the list
}
@ -769,7 +769,7 @@ void CSpellWindow::SpellArea::clickLeft(tribool down, bool previousState)
GH.pushInt (new CObjectListWindow(availableTowns,
new CPicture(graphics->spellscr->ourImages[spell].bitmap, 0, 0, false),
CGI->generaltexth->jktexts[40], CGI->generaltexth->jktexts[41],
boost::bind (&CSpellWindow::teleportTo, owner, _1, h)));
std::bind (&CSpellWindow::teleportTo, owner, _1, h)));
}
return;
}
@ -790,7 +790,7 @@ void CSpellWindow::SpellArea::clickRight(tribool down, bool previousState)
{
std::string dmgInfo;
const CGHeroInstance * hero = owner->myHero;
int causedDmg = owner->myInt->cb->estimateSpellDamage( CGI->spellh->spells[mySpell], (hero ? hero : NULL));
int causedDmg = owner->myInt->cb->estimateSpellDamage( CGI->spellh->spells[mySpell], (hero ? hero : nullptr));
if(causedDmg == 0 || mySpell == 57) //Titan's Lightning Bolt already has damage info included
dmgInfo = "";
else

10
client/CSpellWindow.h
View File

@ -24,18 +24,18 @@ class CPlayerInterface;
class SpellbookInteractiveArea : public CIntObject
{
private:
boost::function<void()> onLeft;
std::function<void()> onLeft;
std::string textOnRclick;
boost::function<void()> onHoverOn;
boost::function<void()> onHoverOff;
std::function<void()> onHoverOn;
std::function<void()> onHoverOff;
CPlayerInterface * myInt;
public:
void clickLeft(tribool down, bool previousState);
void clickRight(tribool down, bool previousState);
void hover(bool on);
SpellbookInteractiveArea(const SDL_Rect & myRect, boost::function<void()> funcL, const std::string & textR,
boost::function<void()> funcHon, boost::function<void()> funcHoff, CPlayerInterface * _myInt);//c-tor
SpellbookInteractiveArea(const SDL_Rect & myRect, std::function<void()> funcL, const std::string & textR,
std::function<void()> funcHon, std::function<void()> funcHoff, CPlayerInterface * _myInt);//c-tor
};
/// The spell window

91
client/CVideoHandler.cpp
View File

@ -23,9 +23,6 @@ static bool keyDown()
#ifdef _WIN32
#include <boost/algorithm/string/predicate.hpp>
void checkForError(bool throwing = true)
{
int error = GetLastError();
@ -34,13 +31,13 @@ void checkForError(bool throwing = true)
logGlobal->errorStream() << "Error " << error << " encountered!";
std::string msg;
char* pTemp = NULL;
char* pTemp = nullptr;
FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, error, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), (LPSTR)&pTemp, 1, NULL );
nullptr, error, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), (LPSTR)&pTemp, 1, nullptr );
logGlobal->errorStream() << "Error: " << pTemp;
msg = pTemp;
LocalFree( pTemp );
pTemp = NULL;
pTemp = nullptr;
if(throwing)
throw std::runtime_error(msg);
}
@ -75,7 +72,7 @@ void *DLLHandler::FindAddress(const char *symbol)
if(!dll)
{
logGlobal->errorStream() << "Cannot look for " << symbol << " because DLL hasn't been appropriately loaded!";
return NULL;
return nullptr;
}
ret = (void*) GetProcAddress(dll,symbol);
if(!ret)
@ -100,7 +97,7 @@ DLLHandler::~DLLHandler()
DLLHandler::DLLHandler()
{
dll = NULL;
dll = nullptr;
}
CBIKHandler::CBIKHandler()
@ -117,10 +114,10 @@ CBIKHandler::CBIKHandler()
binkClose = (BinkClose)FindAddress("_BinkClose@4");
hBinkFile = NULL;
hBink = NULL;
hBinkFile = nullptr;
hBink = nullptr;
buffer = NULL;
buffer = nullptr;
bufferSize = 0;
}
@ -131,7 +128,7 @@ bool CBIKHandler::open(std::string name)
name.c_str(), // file name
GENERIC_READ, // access mode
FILE_SHARE_READ, // share mode
NULL, // Security Descriptor
nullptr, // Security Descriptor
OPEN_EXISTING, // how to create
FILE_ATTRIBUTE_NORMAL,//FILE_FLAG_SEQUENTIAL_SCAN, // file attributes
0 // handle to template file
@ -146,7 +143,7 @@ bool CBIKHandler::open(std::string name)
{
void *waveout = GetProcAddress(dll,"_BinkOpenWaveOut@4");
if(waveout)
binkSetSoundSystem(waveout,NULL);
binkSetSoundSystem(waveout,nullptr);
}
@ -162,7 +159,7 @@ bool CBIKHandler::open(std::string name)
checkErrorAndClean:
CloseHandle(hBinkFile);
hBinkFile = NULL;
hBinkFile = nullptr;
checkForError();
throw std::runtime_error("BIK failed opening video!");
}
@ -213,12 +210,12 @@ bool CBIKHandler::nextFrame()
void CBIKHandler::close()
{
binkClose(hBink);
hBink = NULL;
hBink = nullptr;
CloseHandle(hBinkFile);
hBinkFile = NULL;
hBinkFile = nullptr;
delete [] buffer;
buffer = NULL;
buffer = nullptr;
bufferSize = 0;
}
@ -256,7 +253,7 @@ void CBIKHandler::allocBuffer(int Bpp)
void CBIKHandler::freeBuffer()
{
delete [] buffer;
buffer = NULL;
buffer = nullptr;
bufferSize = 0;
}
@ -271,7 +268,7 @@ bool CSmackPlayer::wait()
return ptrSmackWait(data);
}
CSmackPlayer::CSmackPlayer() : data(NULL)
CSmackPlayer::CSmackPlayer() : data(nullptr)
{
Instantiate("smackw32.dll");
ptrSmackNextFrame = (SmackNextFrame)FindAddress("_SmackNextFrame@4");
@ -293,7 +290,7 @@ CSmackPlayer::~CSmackPlayer()
void CSmackPlayer::close()
{
ptrSmackClose(data);
data = NULL;
data = nullptr;
}
bool CSmackPlayer::open( std::string name )
@ -397,7 +394,7 @@ void CSmackPlayer::redraw( int x, int y, SDL_Surface *dst, bool update )
CVideoPlayer::CVideoPlayer()
{
current = NULL;
current = nullptr;
}
CVideoPlayer::~CVideoPlayer()
@ -452,7 +449,7 @@ void CVideoPlayer::close()
}
current->close();
current = NULL;
current = nullptr;
if(!DeleteFileA(fname.c_str()))
{
logGlobal->errorStream() << "Cannot remove temporarily extracted video file: " << fname;
@ -594,12 +591,12 @@ static si64 lodSeek(void * opaque, si64 pos, int whence)
CVideoPlayer::CVideoPlayer()
{
format = NULL;
frame = NULL;
codec = NULL;
sws = NULL;
overlay = NULL;
dest = NULL;
format = nullptr;
frame = nullptr;
codec = nullptr;
sws = nullptr;
overlay = nullptr;
dest = nullptr;
context = nullptr;
// Register codecs. TODO: May be overkill. Should call a
@ -637,7 +634,7 @@ bool CVideoPlayer::open(std::string fname, bool loop, bool useOverlay)
static const int BUFFER_SIZE = 4096;
unsigned char * buffer = (unsigned char *)av_malloc(BUFFER_SIZE);// will be freed by ffmpeg
context = avio_alloc_context( buffer, BUFFER_SIZE, 0, (void *)this, lodRead, NULL, lodSeek);
context = avio_alloc_context( buffer, BUFFER_SIZE, 0, (void *)this, lodRead, nullptr, lodSeek);
format = avformat_alloc_context();
format->pb = context;
@ -652,7 +649,7 @@ bool CVideoPlayer::open(std::string fname, bool loop, bool useOverlay)
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(53, 17, 0)
if (av_find_stream_info(format) < 0)
#else
if (avformat_find_stream_info(format, NULL) < 0)
if (avformat_find_stream_info(format, nullptr) < 0)
#endif
return false;
@ -677,7 +674,7 @@ bool CVideoPlayer::open(std::string fname, bool loop, bool useOverlay)
// Find the decoder for the video stream
codec = avcodec_find_decoder(codecContext->codec_id);
if (codec == NULL)
if (codec == nullptr)
{
// Unsupported codec
return false;
@ -687,11 +684,11 @@ bool CVideoPlayer::open(std::string fname, bool loop, bool useOverlay)
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(53, 6, 0)
if ( avcodec_open(codecContext, codec) < 0 )
#else
if ( avcodec_open2(codecContext, codec, NULL) < 0 )
if ( avcodec_open2(codecContext, codec, nullptr) < 0 )
#endif
{
// Could not open codec
codec = NULL;
codec = nullptr;
return false;
}
@ -712,7 +709,7 @@ bool CVideoPlayer::open(std::string fname, bool loop, bool useOverlay)
destRect.h = codecContext->height;
}
if (overlay == NULL && dest == NULL)
if (overlay == nullptr && dest == nullptr)
return false;
// Convert the image into YUV format that SDL uses
@ -720,7 +717,7 @@ bool CVideoPlayer::open(std::string fname, bool loop, bool useOverlay)
{
sws = sws_getContext(codecContext->width, codecContext->height,
codecContext->pix_fmt, codecContext->width, codecContext->height,
PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);
PIX_FMT_YUV420P, SWS_BICUBIC, nullptr, nullptr, nullptr);
}
else
{
@ -751,10 +748,10 @@ bool CVideoPlayer::open(std::string fname, bool loop, bool useOverlay)
sws = sws_getContext(codecContext->width, codecContext->height,
codecContext->pix_fmt, codecContext->width, codecContext->height,
screenFormat, SWS_BICUBIC, NULL, NULL, NULL);
screenFormat, SWS_BICUBIC, nullptr, nullptr, nullptr);
}
if (sws == NULL)
if (sws == nullptr)
return false;
pos.w = codecContext->width;
@ -770,7 +767,7 @@ bool CVideoPlayer::nextFrame()
int frameFinished = 0;
bool gotError = false;
if (sws == NULL)
if (sws == nullptr)
return false;
while(!frameFinished)
@ -841,7 +838,7 @@ bool CVideoPlayer::nextFrame()
void CVideoPlayer::show( int x, int y, SDL_Surface *dst, bool update )
{
if (sws == NULL)
if (sws == nullptr)
return;
pos.x = x;
@ -859,7 +856,7 @@ void CVideoPlayer::redraw( int x, int y, SDL_Surface *dst, bool update )
void CVideoPlayer::update( int x, int y, SDL_Surface *dst, bool forceRedraw, bool update )
{
if (sws == NULL)
if (sws == nullptr)
return;
if (refreshCount <= 0)
@ -892,39 +889,39 @@ void CVideoPlayer::close()
if (sws)
{
sws_freeContext(sws);
sws = NULL;
sws = nullptr;
}
if (overlay)
{
SDL_FreeYUVOverlay(overlay);
overlay = NULL;
overlay = nullptr;
}
if (dest)
{
SDL_FreeSurface(dest);
dest = NULL;
dest = nullptr;
}
if (frame)
{
av_free(frame);
frame = NULL;
frame = nullptr;
}
if (codec)
{
avcodec_close(codecContext);
codec = NULL;
codecContext = NULL;
codec = nullptr;
codecContext = nullptr;
}
if (format)
{
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(53, 17, 0)
av_close_input_file(format);
format = NULL;
format = nullptr;
#else
avformat_close_input(&format);
#endif

28
client/Client.cpp
View File

@ -58,7 +58,7 @@ public:
virtual void applyOnClBefore(CClient *cl, void *pack) const =0;
virtual ~CBaseForCLApply(){}
template<typename U> static CBaseForCLApply *getApplier(const U * t=NULL)
template<typename U> static CBaseForCLApply *getApplier(const U * t=nullptr)
{
return new CApplyOnCL<U>;
}
@ -136,7 +136,7 @@ void CClient::run()
setThreadName("CClient::run");
try
{
CPack *pack = NULL;
CPack *pack = nullptr;
while(!terminate)
{
pack = serv->retreivePack(); //get the package from the server
@ -144,12 +144,12 @@ void CClient::run()
if (terminate)
{
delete pack;
pack = NULL;
pack = nullptr;
break;
}
handlePack(pack);
pack = NULL;
pack = nullptr;
}
}
//catch only asio exceptions
@ -189,7 +189,7 @@ void CClient::endGame( bool closeConnection /*= true*/ )
stopConnection();
logNetwork->infoStream() << "Closed connection.";
GH.curInt = NULL;
GH.curInt = nullptr;
LOCPLINT->terminate_cond.setn(true);
{
boost::unique_lock<boost::recursive_mutex> un(*LOCPLINT->pim);
@ -198,14 +198,14 @@ void CClient::endGame( bool closeConnection /*= true*/ )
GH.topInt()->deactivate();
GH.listInt.clear();
GH.objsToBlit.clear();
GH.statusbar = NULL;
GH.statusbar = nullptr;
logNetwork->infoStream() << "Removed GUI.";
vstd::clear_pointer(const_cast<CGameInfo*>(CGI)->mh);
vstd::clear_pointer(gs);
logNetwork->infoStream() << "Deleted mapHandler and gameState.";
LOCPLINT = NULL;
LOCPLINT = nullptr;
}
playerint.clear();
@ -297,7 +297,7 @@ void CClient::newGame( CConnection *con, StartInfo *si )
{
enum {SINGLE, HOST, GUEST} networkMode = SINGLE;
if (con == NULL)
if (con == nullptr)
{
CServerHandler sh;
serv = sh.connectToServer();
@ -556,14 +556,14 @@ void CClient::stopConnection()
logNetwork->infoStream() << "Connection handler thread joined";
delete connectionHandler;
connectionHandler = NULL;
connectionHandler = nullptr;
}
if (serv) //and delete connection
{
serv->close();
delete serv;
serv = NULL;
serv = nullptr;
logNetwork->warnStream() << "Our socket has been closed.";
}
}
@ -660,7 +660,7 @@ void CClient::commenceTacticPhaseForInt(shared_ptr<CBattleGameInterface> battleI
} HANDLE_EXCEPTION
}
void CClient::invalidatePaths(const CGHeroInstance *h /*= NULL*/)
void CClient::invalidatePaths(const CGHeroInstance *h /*= nullptr*/)
{
if(!h || pathInfo->hero == h)
pathInfo->isValid = false;
@ -807,8 +807,8 @@ CConnection * CServerHandler::connectToServer()
CServerHandler::CServerHandler(bool runServer /*= false*/)
{
serverThread = NULL;
shared = NULL;
serverThread = nullptr;
shared = nullptr;
port = boost::lexical_cast<std::string>(settings["server"]["port"].Float());
verbose = true;
@ -843,7 +843,7 @@ void CServerHandler::callServer()
CConnection * CServerHandler::justConnectToServer(const std::string &host, const std::string &port)
{
CConnection *ret = NULL;
CConnection *ret = nullptr;
while(!ret)
{
try

97
client/Client.h
View File

@ -30,8 +30,6 @@ class CScriptingModule;
struct CPathsInfo;
namespace boost { class thread; }
void processCommand(const std::string &message, CClient *&client);
/// structure to handle running server and connecting to it
class CServerHandler
{
@ -156,7 +154,7 @@ public:
void campaignMapFinished( shared_ptr<CCampaignState> camp );
void finishCampaign( shared_ptr<CCampaignState> camp );
void proposeNextMission(shared_ptr<CCampaignState> camp);
void invalidatePaths(const CGHeroInstance *h = NULL); //invalidates paths for hero h or for any hero if h is NULL => they'll got recalculated when the next query comes
void invalidatePaths(const CGHeroInstance *h = nullptr); //invalidates paths for hero h or for any hero if h is nullptr => they'll got recalculated when the next query comes
void calculatePaths(const CGHeroInstance *h);
void updatePaths(); //calls calculatePaths for same hero for which we previously calculated paths
@ -164,74 +162,73 @@ public:
boost::thread *connectionHandler; //thread running run() method
//////////////////////////////////////////////////////////////////////////
virtual PlayerColor 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, 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 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, 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) OVERRIDE {};
void showGarrisonDialog(ObjectInstanceID upobj, ObjectInstanceID hid, bool removableUnits) OVERRIDE {};
void showThievesGuildWindow(PlayerColor player, ObjectInstanceID requestingObjId) OVERRIDE {};
void giveResource(PlayerColor player, Res::ERes which, int val) OVERRIDE {};
virtual void giveResources(PlayerColor player, TResources resources) OVERRIDE {};
void showBlockingDialog(BlockingDialog *iw) override {};
void showGarrisonDialog(ObjectInstanceID upobj, ObjectInstanceID hid, bool removableUnits) override {};
void showThievesGuildWindow(PlayerColor player, ObjectInstanceID requestingObjId) override {};
void giveResource(PlayerColor player, Res::ERes which, int val) override {};
virtual void giveResources(PlayerColor player, TResources resources) 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 {};
bool changeStackType(const StackLocation &sl, CCreature *c) OVERRIDE {return false;};
bool changeStackCount(const StackLocation &sl, TQuantity count, bool absoluteValue = false) OVERRIDE {return false;};
bool insertNewStack(const StackLocation &sl, const CCreature *c, TQuantity count) OVERRIDE {return false;};
void giveCreatures(const CArmedInstance * objid, const CGHeroInstance * h, const CCreatureSet &creatures, bool remove) override {};
void takeCreatures(ObjectInstanceID objid, const std::vector<CStackBasicDescriptor> &creatures) override {};
bool changeStackType(const StackLocation &sl, CCreature *c) override {return false;};
bool changeStackCount(const StackLocation &sl, TQuantity count, bool absoluteValue = false) override {return false;};
bool insertNewStack(const StackLocation &sl, const CCreature *c, TQuantity count) override {return false;};
bool eraseStack(const StackLocation &sl, bool forceRemoval = false){return false;};
bool swapStacks(const StackLocation &sl1, const StackLocation &sl2) OVERRIDE {return false;}
bool addToSlot(const StackLocation &sl, const CCreature *c, TQuantity count) OVERRIDE {return false;}
void tryJoiningArmy(const CArmedInstance *src, const CArmedInstance *dst, bool removeObjWhenFinished, bool allowMerging) OVERRIDE {}
bool moveStack(const StackLocation &src, const StackLocation &dst, TQuantity count = -1) OVERRIDE {return false;}
bool swapStacks(const StackLocation &sl1, const StackLocation &sl2) override {return false;}
bool addToSlot(const StackLocation &sl, const CCreature *c, TQuantity count) override {return false;}
void tryJoiningArmy(const CArmedInstance *src, const CArmedInstance *dst, bool removeObjWhenFinished, bool allowMerging) override {}
bool moveStack(const StackLocation &src, const StackLocation &dst, TQuantity count = -1) override {return false;}
void removeAfterVisit(const CGObjectInstance *object) OVERRIDE {};
void removeAfterVisit(const CGObjectInstance *object) override {};
void giveHeroNewArtifact(const CGHeroInstance *h, const CArtifact *artType, ArtifactPosition pos) OVERRIDE {};
void giveHeroArtifact(const CGHeroInstance *h, const CArtifactInstance *a, ArtifactPosition pos) OVERRIDE {};
void putArtifact(const ArtifactLocation &al, const CArtifactInstance *a) OVERRIDE {};
void removeArtifact(const ArtifactLocation &al) OVERRIDE {};
bool moveArtifact(const ArtifactLocation &al1, const ArtifactLocation &al2) OVERRIDE {return false;};
void synchronizeArtifactHandlerLists() OVERRIDE {};
void giveHeroNewArtifact(const CGHeroInstance *h, const CArtifact *artType, ArtifactPosition pos) override {};
void giveHeroArtifact(const CGHeroInstance *h, const CArtifactInstance *a, ArtifactPosition pos) override {};
void putArtifact(const ArtifactLocation &al, const CArtifactInstance *a) override {};
void removeArtifact(const ArtifactLocation &al) override {};
bool moveArtifact(const ArtifactLocation &al1, const ArtifactLocation &al2) override {return false;};
void synchronizeArtifactHandlerLists() override {};
void showCompInfo(ShowInInfobox * comp) OVERRIDE {};
void heroVisitCastle(const CGTownInstance * obj, const CGHeroInstance * hero) OVERRIDE {};
void stopHeroVisitCastle(const CGTownInstance * obj, const CGHeroInstance * hero) OVERRIDE {};
void showCompInfo(ShowInInfobox * comp) override {};
void heroVisitCastle(const CGTownInstance * obj, const CGHeroInstance * hero) override {};
void stopHeroVisitCastle(const CGTownInstance * obj, const CGHeroInstance * hero) override {};
//void giveHeroArtifact(int artid, int hid, int position){};
//void giveNewArtifact(int hid, int position){};
void startBattlePrimary(const CArmedInstance *army1, const CArmedInstance *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool creatureBank = false, const CGTownInstance *town = NULL) OVERRIDE {}; //use hero=NULL for no hero
void startBattleI(const CArmedInstance *army1, const CArmedInstance *army2, int3 tile, bool creatureBank = false) OVERRIDE {}; //if any of armies is hero, hero will be used
void startBattleI(const CArmedInstance *army1, const CArmedInstance *army2, 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 teleporting, 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, PlayerColor player) OVERRIDE {};
void changeObjPos(ObjectInstanceID objid, int3 newPos, ui8 flags) OVERRIDE {};
void sendAndApply(CPackForClient * info) OVERRIDE {};
void heroExchange(ObjectInstanceID hero1, ObjectInstanceID hero2) OVERRIDE {};
void startBattlePrimary(const CArmedInstance *army1, const CArmedInstance *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool creatureBank = false, const CGTownInstance *town = nullptr) override {}; //use hero=nullptr for no hero
void startBattleI(const CArmedInstance *army1, const CArmedInstance *army2, int3 tile, bool creatureBank = false) override {}; //if any of armies is hero, hero will be used
void startBattleI(const CArmedInstance *army1, const CArmedInstance *army2, 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 teleporting, 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, PlayerColor player) override {};
void changeObjPos(ObjectInstanceID objid, int3 newPos, ui8 flags) override {};
void sendAndApply(CPackForClient * info) override {};
void heroExchange(ObjectInstanceID hero1, ObjectInstanceID hero2) override {};
//////////////////////////////////////////////////////////////////////////
friend class CCallback; //handling players actions
friend class CBattleCallback; //handling players actions
friend void processCommand(const std::string &message, CClient *&client); //handling console
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);
void commenceTacticPhaseForInt(shared_ptr<CBattleGameInterface> battleInt); //will be called as separate thread
void commitPackage(CPackForClient *pack) OVERRIDE;
void commitPackage(CPackForClient *pack) override;
//////////////////////////////////////////////////////////////////////////

325
client/GUIClasses.cpp
View File

@ -236,7 +236,7 @@ void CGarrisonSlot::hover (bool on)
else
{
logGlobal->warnStream() << "Warning - shouldn't be - highlighted void slot "<<owner->getSelection();
logGlobal->warnStream() << "Highlighted set to NULL";
logGlobal->warnStream() << "Highlighted set to nullptr";
owner->selectSlot(nullptr);
}
}
@ -319,10 +319,10 @@ void CGarrisonSlot::clickLeft(tribool down, bool previousState)
bool canUpgrade = getObj()->tempOwner == LOCPLINT->playerID && pom.oldID>=0; //upgrade is possible
bool canDismiss = getObj()->tempOwner == LOCPLINT->playerID && (getObj()->stacksCount()>1 || !getObj()->needsLastStack());
boost::function<void()> upgr = NULL;
boost::function<void()> dism = NULL;
if (canUpgrade) upgr = boost::bind(&CCallback::upgradeCreature, LOCPLINT->cb.get(), getObj(), ID, pom.newID[0]);
if (canDismiss) dism = boost::bind(&CCallback::dismissCreature, LOCPLINT->cb.get(), getObj(), ID);
std::function<void()> upgr = nullptr;
std::function<void()> dism = nullptr;
if (canUpgrade) upgr = std::bind(&CCallback::upgradeCreature, LOCPLINT->cb.get(), getObj(), ID, pom.newID[0]);
if (canDismiss) dism = std::bind(&CCallback::dismissCreature, LOCPLINT->cb.get(), getObj(), ID);
owner->selectSlot(nullptr);
owner->setSplittingMode(false);
@ -373,7 +373,7 @@ void CGarrisonSlot::clickLeft(tribool down, bool previousState)
int countLeft = owner->getSelection()->myStack ? owner->getSelection()->myStack->count : 0;
int countRight = myStack ? myStack->count : 0;
GH.pushInt(new CSplitWindow(owner->getSelection()->creature, boost::bind(&CGarrisonInt::splitStacks, owner, _1, _2),
GH.pushInt(new CSplitWindow(owner->getSelection()->creature, std::bind(&CGarrisonInt::splitStacks, owner, _1, _2),
minLeft, minRight, countLeft, countRight));
refr = true;
}
@ -447,7 +447,7 @@ void CGarrisonSlot::update()
{
addUsedEvents(LCLICK | RCLICK | HOVER);
myStack = getObj()->getStackPtr(ID);
creature = myStack ? myStack->type : NULL;
creature = myStack ? myStack->type : nullptr;
}
else
{
@ -533,7 +533,7 @@ void CGarrisonInt::createSet(std::vector<CGarrisonSlot*> &ret, const CCreatureSe
for(int i=0; i<ret.size(); i++)
if(!ret[i])
ret[i] = new CGarrisonSlot(this, posX + (i*distance), posY, SlotID(i), Upg, NULL);
ret[i] = new CGarrisonSlot(this, posX + (i*distance), posY, SlotID(i), Upg, nullptr);
if (twoRows)
for (int i=4; i<ret.size(); i++)
@ -655,7 +655,7 @@ CInfoWindow::CInfoWindow(std::string Text, PlayerColor player, const TCompsInfo
ID = QueryID(-1);
for(int i=0;i<Buttons.size();i++)
{
CAdventureMapButton *button = new CAdventureMapButton("","",boost::bind(&CInfoWindow::close,this),0,0,Buttons[i].first);
CAdventureMapButton *button = new CAdventureMapButton("","",std::bind(&CInfoWindow::close,this),0,0,Buttons[i].first);
button->borderColor = Colors::METALLIC_GOLD;
button->borderEnabled = true;
button->callback.add(Buttons[i].second); //each button will close the window apart from call-defined actions
@ -690,7 +690,7 @@ CInfoWindow::CInfoWindow()
{
ID = QueryID(-1);
setDelComps(false);
text = NULL;
text = nullptr;
}
void CInfoWindow::close()
@ -735,7 +735,7 @@ void CInfoWindow::showYesNoDialog(const std::string & text, const std::vector<CC
GH.pushInt(temp);
}
CInfoWindow * CInfoWindow::create(const std::string &text, PlayerColor 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 /*= nullptr*/, bool DelComps)
{
std::vector<std::pair<std::string,CFunctionList<void()> > > pom;
pom.push_back(std::pair<std::string,CFunctionList<void()> >("IOKAY.DEF",0));
@ -1030,7 +1030,7 @@ void CSelectableComponent::init()
selected = false;
}
CSelectableComponent::CSelectableComponent(const Component &c, boost::function<void()> OnSelect):
CSelectableComponent::CSelectableComponent(const Component &c, std::function<void()> OnSelect):
CComponent(c),onSelect(OnSelect)
{
type |= REDRAW_PARENT;
@ -1038,7 +1038,7 @@ CSelectableComponent::CSelectableComponent(const Component &c, boost::function<v
init();
}
CSelectableComponent::CSelectableComponent(Etype Type, int Sub, int Val, ESize imageSize, boost::function<void()> OnSelect):
CSelectableComponent::CSelectableComponent(Etype Type, int Sub, int Val, ESize imageSize, std::function<void()> OnSelect):
CComponent(Type,Sub,Val, imageSize),onSelect(OnSelect)
{
type |= REDRAW_PARENT;
@ -1229,7 +1229,7 @@ CComponentBox::CComponentBox(std::vector<CComponent *> _components, Rect positio
placeComponents(false);
}
CComponentBox::CComponentBox(std::vector<CSelectableComponent *> _components, Rect position, boost::function<void(int newID)> _onSelect):
CComponentBox::CComponentBox(std::vector<CSelectableComponent *> _components, Rect position, std::function<void(int newID)> _onSelect):
components(_components.begin(), _components.end()),
selected(nullptr),
onSelect(_onSelect)
@ -1243,7 +1243,7 @@ CComponentBox::CComponentBox(std::vector<CSelectableComponent *> _components, Re
int key = SDLK_1;
BOOST_FOREACH(auto & comp, _components)
{
comp->onSelect = boost::bind(&CComponentBox::selectionChanged, this, comp);
comp->onSelect = std::bind(&CComponentBox::selectionChanged, this, comp);
comp->assignedKeys.insert(key++);
}
selectionChanged(_components.front());
@ -1269,8 +1269,8 @@ CSelWindow::CSelWindow(const std::string &Text, PlayerColor player, int charperl
{
buttons.push_back(new CAdventureMapButton("","",Buttons[i].second,0,0,Buttons[i].first));
if(!i && askID.getNum() >= 0)
buttons.back()->callback += boost::bind(&CSelWindow::madeChoice,this);
buttons[i]->callback += boost::bind(&CInfoWindow::close,this); //each button will close the window apart from call-defined actions
buttons.back()->callback += std::bind(&CSelWindow::madeChoice,this);
buttons[i]->callback += std::bind(&CInfoWindow::close,this); //each button will close the window apart from call-defined actions
}
text = new CTextBox(Text, Rect(0, 0, 250, 100), 0, FONT_MEDIUM, CENTER, Colors::WHITE);
@ -1279,14 +1279,14 @@ CSelWindow::CSelWindow(const std::string &Text, PlayerColor player, int charperl
buttons.back()->assignedKeys.insert(SDLK_ESCAPE); //last button - reacts on escape
if(buttons.size() > 1 && askID.getNum() >= 0) //cancel button functionality
buttons.back()->callback += boost::bind(&CCallback::selectionMade,LOCPLINT->cb.get(),0,askID);
buttons.back()->callback += std::bind(&CCallback::selectionMade,LOCPLINT->cb.get(),0,askID);
for(int i=0;i<comps.size();i++)
{
comps[i]->recActions = 255;
addChild(comps[i]);
components.push_back(comps[i]);
comps[i]->onSelect = boost::bind(&CSelWindow::selectionChange,this,i);
comps[i]->onSelect = std::bind(&CSelWindow::selectionChange,this,i);
if(i<9)
comps[i]->assignedKeys.insert(SDLK_1+i);
}
@ -1509,7 +1509,7 @@ void CRecruitmentWindow::showAll(SDL_Surface * to)
drawBorder(to, pos.x + 289, pos.y + 312, 66, 34, int3(173,142,66));
}
CRecruitmentWindow::CRecruitmentWindow(const CGDwelling *Dwelling, int Level, const CArmedInstance *Dst, const boost::function<void(CreatureID,int)> &Recruit, int y_offset):
CRecruitmentWindow::CRecruitmentWindow(const CGDwelling *Dwelling, int Level, const CArmedInstance *Dst, const std::function<void(CreatureID,int)> &Recruit, int y_offset):
CWindowObject(PLAYER_COLORED, "TPRCRT"),
onRecruit(Recruit),
level(Level),
@ -1523,11 +1523,11 @@ CRecruitmentWindow::CRecruitmentWindow(const CGDwelling *Dwelling, int Level, co
new CGStatusBar(new CPicture(*background, Rect(8, pos.h - 26, pos.w - 16, 19), 8, pos.h - 26));
slider = new CSlider(176,279,135,0,0,0,0,true);
slider->moved = boost::bind(&CRecruitmentWindow::sliderMoved,this, _1);
slider->moved = std::bind(&CRecruitmentWindow::sliderMoved,this, _1);
maxButton = new CAdventureMapButton(CGI->generaltexth->zelp[553],boost::bind(&CSlider::moveToMax,slider),134,313,"IRCBTNS.DEF",SDLK_m);
buyButton = new CAdventureMapButton(CGI->generaltexth->zelp[554],boost::bind(&CRecruitmentWindow::buy,this),212,313,"IBY6432.DEF",SDLK_RETURN);
cancelButton = new CAdventureMapButton(CGI->generaltexth->zelp[555],boost::bind(&CRecruitmentWindow::close,this),290,313,"ICN6432.DEF",SDLK_ESCAPE);
maxButton = new CAdventureMapButton(CGI->generaltexth->zelp[553],std::bind(&CSlider::moveToMax,slider),134,313,"IRCBTNS.DEF",SDLK_m);
buyButton = new CAdventureMapButton(CGI->generaltexth->zelp[554],std::bind(&CRecruitmentWindow::buy,this),212,313,"IBY6432.DEF",SDLK_RETURN);
cancelButton = new CAdventureMapButton(CGI->generaltexth->zelp[555],std::bind(&CRecruitmentWindow::close,this),290,313,"ICN6432.DEF",SDLK_ESCAPE);
title = new CLabel(243, 32, FONT_BIG, CENTER, Colors::YELLOW);
availableValue = new CLabel(205, 253, FONT_SMALL, CENTER, Colors::WHITE);
@ -1620,7 +1620,7 @@ void CRecruitmentWindow::sliderMoved(int to)
totalCostValue->set(selected->creature->cost * to);
}
CSplitWindow::CSplitWindow(const CCreature * creature, boost::function<void(int, int)> callback_,
CSplitWindow::CSplitWindow(const CCreature * creature, std::function<void(int, int)> callback_,
int leftMin_, int rightMin_, int leftAmount_, int rightAmount_):
CWindowObject(PLAYER_COLORED, "GPUCRDIV"),
callback(callback_),
@ -1636,17 +1636,17 @@ CSplitWindow::CSplitWindow(const CCreature * creature, boost::function<void(int,
int leftMax = total - rightMin;
int rightMax = total - leftMin;
ok = new CAdventureMapButton("", "", boost::bind(&CSplitWindow::apply, this), 20, 263, "IOK6432", SDLK_RETURN);
cancel = new CAdventureMapButton("", "", boost::bind(&CSplitWindow::close, this), 214, 263, "ICN6432", SDLK_ESCAPE);
ok = new CAdventureMapButton("", "", std::bind(&CSplitWindow::apply, this), 20, 263, "IOK6432", SDLK_RETURN);
cancel = new CAdventureMapButton("", "", std::bind(&CSplitWindow::close, this), 214, 263, "ICN6432", SDLK_ESCAPE);
int sliderPositions = total - leftMin - rightMin;
leftInput = new CTextInput(Rect(20, 218, 100, 36), FONT_BIG, boost::bind(&CSplitWindow::setAmountText, this, _1, true));
rightInput = new CTextInput(Rect(176, 218, 100, 36), FONT_BIG, boost::bind(&CSplitWindow::setAmountText, this, _1, false));
leftInput = new CTextInput(Rect(20, 218, 100, 36), FONT_BIG, std::bind(&CSplitWindow::setAmountText, this, _1, true));
rightInput = new CTextInput(Rect(176, 218, 100, 36), FONT_BIG, std::bind(&CSplitWindow::setAmountText, this, _1, false));
//add filters to allow only number input
leftInput->filters.add(boost::bind(&CTextInput::numberFilter, _1, _2, leftMin, leftMax));
rightInput->filters.add(boost::bind(&CTextInput::numberFilter, _1, _2, rightMin, rightMax));
leftInput->filters.add(std::bind(&CTextInput::numberFilter, _1, _2, leftMin, leftMax));
rightInput->filters.add(std::bind(&CTextInput::numberFilter, _1, _2, rightMin, rightMax));
leftInput->setTxt(boost::lexical_cast<std::string>(leftAmount), false);
rightInput->setTxt(boost::lexical_cast<std::string>(rightAmount), false);
@ -1654,7 +1654,7 @@ CSplitWindow::CSplitWindow(const CCreature * creature, boost::function<void(int,
animLeft = new CCreaturePic(20, 54, creature, true, false);
animRight = new CCreaturePic(177, 54,creature, true, false);
slider = new CSlider(21, 194, 257, boost::bind(&CSplitWindow::sliderMoved, this, _1), 0, sliderPositions, rightAmount - rightMin, true);
slider = new CSlider(21, 194, 257, std::bind(&CSplitWindow::sliderMoved, this, _1), 0, sliderPositions, rightAmount - rightMin, true);
std::string title = CGI->generaltexth->allTexts[256];
boost::algorithm::replace_first(title,"%s", creature->namePl);
@ -1694,7 +1694,7 @@ void CSplitWindow::sliderMoved(int to)
setAmount(rightMin + to, false);
}
CLevelWindow::CLevelWindow(const CGHeroInstance *hero, PrimarySkill::PrimarySkill pskill, std::vector<SecondarySkill> &skills, boost::function<void(ui32)> callback):
CLevelWindow::CLevelWindow(const CGHeroInstance *hero, PrimarySkill::PrimarySkill pskill, std::vector<SecondarySkill> &skills, std::function<void(ui32)> callback):
CWindowObject(PLAYER_COLORED, "LVLUPBKG"),
cb(callback)
{
@ -1703,7 +1703,7 @@ CLevelWindow::CLevelWindow(const CGHeroInstance *hero, PrimarySkill::PrimarySkil
LOCPLINT->showingDialog->setn(true);
new CAnimImage("PortraitsLarge", hero->portrait, 0, 170, 66);
new CAdventureMapButton("", "", boost::bind(&CLevelWindow::close, this), 297, 413, "IOKAY", SDLK_RETURN);
new CAdventureMapButton("", "", std::bind(&CLevelWindow::close, this), 297, 413, "IOKAY", SDLK_RETURN);
//%s has gained a level.
new CLabel(192, 33, FONT_MEDIUM, CENTER, Colors::WHITE,
@ -1815,7 +1815,7 @@ void CObjectListWindow::CItem::clickLeft(tribool down, bool previousState)
}
CObjectListWindow::CObjectListWindow(const std::vector<int> &_items, CPicture * titlePic, std::string _title, std::string _descr,
boost::function<void(int)> Callback):
std::function<void(int)> Callback):
CWindowObject(PLAYER_COLORED, "TPGATE"),
onSelect(Callback)
{
@ -1829,7 +1829,7 @@ CObjectListWindow::CObjectListWindow(const std::vector<int> &_items, CPicture *
}
CObjectListWindow::CObjectListWindow(const std::vector<std::string> &_items, CPicture * titlePic, std::string _title, std::string _descr,
boost::function<void(int)> Callback):
std::function<void(int)> Callback):
CWindowObject(PLAYER_COLORED, "TPGATE"),
onSelect(Callback)
{
@ -1848,9 +1848,9 @@ void CObjectListWindow::init(CPicture * titlePic, std::string _title, std::strin
title = new CLabel(152, 27, FONT_BIG, CENTER, Colors::YELLOW, _title);
descr = new CLabel(145, 133, FONT_SMALL, CENTER, Colors::WHITE, _descr);
ok = new CAdventureMapButton("","",boost::bind(&CObjectListWindow::elementSelected, this),15,402,"IOKAY.DEF", SDLK_RETURN);
ok = new CAdventureMapButton("","",std::bind(&CObjectListWindow::elementSelected, this),15,402,"IOKAY.DEF", SDLK_RETURN);
ok->block(true);
exit = new CAdventureMapButton("","",boost::bind(&CGuiHandler::popIntTotally,&GH, this),228,402,"ICANCEL.DEF",SDLK_ESCAPE);
exit = new CAdventureMapButton("","",std::bind(&CGuiHandler::popIntTotally,&GH, this),228,402,"ICANCEL.DEF",SDLK_ESCAPE);
if (titlePic)
{
@ -1860,7 +1860,7 @@ void CObjectListWindow::init(CPicture * titlePic, std::string _title, std::strin
titleImage->pos.x = pos.w/2 + pos.x - titleImage->pos.w/2;
titleImage->pos.y =75 + pos.y - titleImage->pos.h/2;
}
list = new CListBox(boost::bind(&CObjectListWindow::genItem, this, _1), CListBox::DestroyFunc(),
list = new CListBox(std::bind(&CObjectListWindow::genItem, this, _1), CListBox::DestroyFunc(),
Point(14, 151), Point(0, 25), 9, items.size(), 0, 1, Rect(262, -32, 256, 256) );
list->type |= REDRAW_PARENT;
}
@ -1869,12 +1869,12 @@ CIntObject * CObjectListWindow::genItem(size_t index)
{
if (index < items.size())
return new CItem(this, index, items[index].second);
return NULL;
return nullptr;
}
void CObjectListWindow::elementSelected()
{
boost::function<void(int)> toCall = onSelect;//save
std::function<void(int)> toCall = onSelect;//save
int where = items[selected].first; //required variables
GH.popIntTotally(this);//then destroy window
toCall(where);//and send selected object
@ -1945,7 +1945,7 @@ CTradeWindow::CTradeableItem::CTradeableItem(Point pos, EType Type, int ID, bool
left(Left)
{
downSelection = false;
hlp = NULL;
hlp = nullptr;
image = nullptr;
setType(Type);
}
@ -2204,7 +2204,7 @@ const CArtifactInstance * CTradeWindow::CTradeableItem::getArtInstance() const
case ARTIFACT_INSTANCE:
return (const CArtifactInstance *)hlp;
default:
return NULL;
return nullptr;
}
}
@ -2222,9 +2222,9 @@ CTradeWindow::CTradeWindow(std::string bgName, const IMarket *Market, const CGHe
CWindowObject(PLAYER_COLORED, bgName),
market(Market),
hero(Hero),
arts(NULL),
hLeft(NULL),
hRight(NULL),
arts(nullptr),
hLeft(nullptr),
hRight(nullptr),
readyToTrade(false)
{
type |= BLOCK_ADV_HOTKEYS;
@ -2298,7 +2298,7 @@ void CTradeWindow::initItems(bool Left)
artSets.push_back(arts);
if(mode == EMarketMode::ARTIFACT_RESOURCE)
arts->highlightModeCallback = boost::bind(&CTradeWindow::artifactSelected, this, _1);
arts->highlightModeCallback = std::bind(&CTradeWindow::artifactSelected, this, _1);
return;
}
@ -2332,7 +2332,7 @@ void CTradeWindow::initItems(bool Left)
std::vector<int> *CTradeWindow::getItemsIds(bool Left)
{
std::vector<int> *ids = NULL;
std::vector<int> *ids = nullptr;
if(mode == EMarketMode::ARTIFACT_EXP)
return new std::vector<int>(22, -1);
@ -2485,7 +2485,7 @@ void CTradeWindow::removeItem(CTradeableItem * t)
if(hRight == t)
{
hRight = NULL;
hRight = nullptr;
selectionChanged(false);
}
}
@ -2501,7 +2501,7 @@ void CTradeWindow::setMode(EMarketMode::EMarketMode Mode)
{
const IMarket *m = market;
const CGHeroInstance *h = hero;
CTradeWindow *nwindow = NULL;
CTradeWindow *nwindow = nullptr;
GH.popIntTotally(this);
@ -2526,7 +2526,7 @@ void CTradeWindow::artifactSelected(CArtPlace *slot)
if(slot->ourArt)
hLeft = items[1][0];
else
hLeft = NULL;
hLeft = nullptr;
selectionChanged(true);
}
@ -2597,22 +2597,22 @@ CMarketplaceWindow::CMarketplaceWindow(const IMarket *Market, const CGHeroInstan
initItems(false);
initItems(true);
ok = new CAdventureMapButton(CGI->generaltexth->zelp[600],boost::bind(&CGuiHandler::popIntTotally,&GH,this),516,520,"IOK6432.DEF",SDLK_RETURN);
ok = new CAdventureMapButton(CGI->generaltexth->zelp[600],std::bind(&CGuiHandler::popIntTotally,&GH,this),516,520,"IOK6432.DEF",SDLK_RETURN);
ok->assignedKeys.insert(SDLK_ESCAPE);
deal = new CAdventureMapButton(CGI->generaltexth->zelp[595],boost::bind(&CMarketplaceWindow::makeDeal,this),307,520,"TPMRKB.DEF");
deal = new CAdventureMapButton(CGI->generaltexth->zelp[595],std::bind(&CMarketplaceWindow::makeDeal,this),307,520,"TPMRKB.DEF");
deal->block(true);
if(sliderNeeded)
{
slider = new CSlider(231,490,137,0,0,0);
slider->moved = boost::bind(&CMarketplaceWindow::sliderMoved,this,_1);
max = new CAdventureMapButton(CGI->generaltexth->zelp[596],boost::bind(&CMarketplaceWindow::setMax,this),229,520,"IRCBTNS.DEF");
slider->moved = std::bind(&CMarketplaceWindow::sliderMoved,this,_1);
max = new CAdventureMapButton(CGI->generaltexth->zelp[596],std::bind(&CMarketplaceWindow::setMax,this),229,520,"IRCBTNS.DEF");
max->block(true);
}
else
{
slider = NULL;
max = NULL;
slider = nullptr;
max = nullptr;
deal->moveBy(Point(-30, 0));
}
@ -2659,22 +2659,22 @@ CMarketplaceWindow::CMarketplaceWindow(const IMarket *Market, const CGHeroInstan
int specialOffset = mode == EMarketMode::ARTIFACT_RESOURCE ? 35 : 0; //in selling artifacts mode we need to move res-res and art-res buttons down
if(printButtonFor(EMarketMode::RESOURCE_PLAYER))
new CAdventureMapButton(CGI->generaltexth->zelp[612],boost::bind(&CMarketplaceWindow::setMode,this, EMarketMode::RESOURCE_PLAYER), 18, 520,"TPMRKBU1.DEF");
new CAdventureMapButton(CGI->generaltexth->zelp[612],std::bind(&CMarketplaceWindow::setMode,this, EMarketMode::RESOURCE_PLAYER), 18, 520,"TPMRKBU1.DEF");
if(printButtonFor(EMarketMode::RESOURCE_RESOURCE))
new CAdventureMapButton(CGI->generaltexth->zelp[605],boost::bind(&CMarketplaceWindow::setMode,this, EMarketMode::RESOURCE_RESOURCE), 516, 450 + specialOffset,"TPMRKBU5.DEF");
new CAdventureMapButton(CGI->generaltexth->zelp[605],std::bind(&CMarketplaceWindow::setMode,this, EMarketMode::RESOURCE_RESOURCE), 516, 450 + specialOffset,"TPMRKBU5.DEF");
if(printButtonFor(EMarketMode::CREATURE_RESOURCE))
new CAdventureMapButton(CGI->generaltexth->zelp[599],boost::bind(&CMarketplaceWindow::setMode,this, EMarketMode::CREATURE_RESOURCE), 516, 485,"TPMRKBU4.DEF"); //was y=450, changed to not overlap res-res in some conditions
new CAdventureMapButton(CGI->generaltexth->zelp[599],std::bind(&CMarketplaceWindow::setMode,this, EMarketMode::CREATURE_RESOURCE), 516, 485,"TPMRKBU4.DEF"); //was y=450, changed to not overlap res-res in some conditions
if(printButtonFor(EMarketMode::RESOURCE_ARTIFACT))
new CAdventureMapButton(CGI->generaltexth->zelp[598],boost::bind(&CMarketplaceWindow::setMode,this, EMarketMode::RESOURCE_ARTIFACT), 18, 450 + specialOffset,"TPMRKBU2.DEF");
new CAdventureMapButton(CGI->generaltexth->zelp[598],std::bind(&CMarketplaceWindow::setMode,this, EMarketMode::RESOURCE_ARTIFACT), 18, 450 + specialOffset,"TPMRKBU2.DEF");
if(printButtonFor(EMarketMode::ARTIFACT_RESOURCE))
new CAdventureMapButton(CGI->generaltexth->zelp[613],boost::bind(&CMarketplaceWindow::setMode,this, EMarketMode::ARTIFACT_RESOURCE), 18, 485,"TPMRKBU3.DEF"); //was y=450, changed to not overlap res-art in some conditions
new CAdventureMapButton(CGI->generaltexth->zelp[613],std::bind(&CMarketplaceWindow::setMode,this, EMarketMode::ARTIFACT_RESOURCE), 18, 485,"TPMRKBU3.DEF"); //was y=450, changed to not overlap res-art in some conditions
updateTraderText();
}
CMarketplaceWindow::~CMarketplaceWindow()
{
hLeft = hRight = NULL;
hLeft = hRight = nullptr;
for(int i=0;i<items[1].size();i++)
delete items[1][i];
for(int i=0;i<items[0].size();i++)
@ -2727,8 +2727,8 @@ void CMarketplaceWindow::makeDeal()
}
madeTransaction = true;
hLeft = NULL;
hRight = NULL;
hLeft = nullptr;
hRight = nullptr;
selectionChanged(true);
}
@ -2995,7 +2995,7 @@ void CMarketplaceWindow::updateTraderText()
traderText->setTxt(CGI->generaltexth->allTexts[gnrtxtnr]);
}
CAltarWindow::CAltarWindow(const IMarket *Market, const CGHeroInstance *Hero /*= NULL*/, EMarketMode::EMarketMode Mode)
CAltarWindow::CAltarWindow(const IMarket *Market, const CGHeroInstance *Hero /*= nullptr*/, EMarketMode::EMarketMode Mode)
:CTradeWindow((Mode == EMarketMode::CREATURE_EXP ? "ALTARMON.bmp" : "ALTRART2.bmp"), Market, Hero, Mode)
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
@ -3012,12 +3012,12 @@ CAltarWindow::CAltarWindow(const IMarket *Market, const CGHeroInstance *Hero /*=
new CTextBox(CGI->generaltexth->allTexts[480], Rect(320, 56, 256, 40), 0, FONT_SMALL, CENTER, Colors::YELLOW);
slider = new CSlider(231,481,137,0,0,0);
slider->moved = boost::bind(&CAltarWindow::sliderMoved,this,_1);
max = new CAdventureMapButton(CGI->generaltexth->zelp[578],boost::bind(&CSlider::moveToMax, slider),147,520,"IRCBTNS.DEF");
slider->moved = std::bind(&CAltarWindow::sliderMoved,this,_1);
max = new CAdventureMapButton(CGI->generaltexth->zelp[578],std::bind(&CSlider::moveToMax, slider),147,520,"IRCBTNS.DEF");
sacrificedUnits.resize(GameConstants::ARMY_SIZE, 0);
sacrificeAll = new CAdventureMapButton(CGI->generaltexth->zelp[579],boost::bind(&CAltarWindow::SacrificeAll,this),393,520,"ALTARMY.DEF");
sacrificeBackpack = NULL;
sacrificeAll = new CAdventureMapButton(CGI->generaltexth->zelp[579],std::bind(&CAltarWindow::SacrificeAll,this),393,520,"ALTARMY.DEF");
sacrificeBackpack = nullptr;
initItems(true);
mimicCres();
@ -3030,13 +3030,13 @@ CAltarWindow::CAltarWindow(const IMarket *Market, const CGHeroInstance *Hero /*=
//%s's Creatures
new CLabel(302, 423, FONT_SMALL, CENTER, Colors::YELLOW, CGI->generaltexth->allTexts[478]);
sacrificeAll = new CAdventureMapButton(CGI->generaltexth->zelp[571], boost::bind(&CAltarWindow::SacrificeAll,this),393,520,"ALTFILL.DEF");
sacrificeAll = new CAdventureMapButton(CGI->generaltexth->zelp[571], std::bind(&CAltarWindow::SacrificeAll,this),393,520,"ALTFILL.DEF");
sacrificeAll->block(hero->artifactsInBackpack.empty() && hero->artifactsWorn.empty());
sacrificeBackpack = new CAdventureMapButton(CGI->generaltexth->zelp[570],boost::bind(&CAltarWindow::SacrificeBackpack,this),147,520,"ALTEMBK.DEF");
sacrificeBackpack = new CAdventureMapButton(CGI->generaltexth->zelp[570],std::bind(&CAltarWindow::SacrificeBackpack,this),147,520,"ALTEMBK.DEF");
sacrificeBackpack->block(hero->artifactsInBackpack.empty());
slider = NULL;
max = NULL;
slider = nullptr;
max = nullptr;
initItems(true);
initItems(false);
@ -3051,15 +3051,15 @@ CAltarWindow::CAltarWindow(const IMarket *Market, const CGHeroInstance *Hero /*=
new CGStatusBar(new CPicture(*background, Rect(8, pos.h - 26, pos.w - 16, 19), 8, pos.h - 26));
ok = new CAdventureMapButton(CGI->generaltexth->zelp[568],boost::bind(&CGuiHandler::popIntTotally,&GH,this),516,520,"IOK6432.DEF",SDLK_RETURN);
ok = new CAdventureMapButton(CGI->generaltexth->zelp[568],std::bind(&CGuiHandler::popIntTotally,&GH,this),516,520,"IOK6432.DEF",SDLK_RETURN);
ok->assignedKeys.insert(SDLK_ESCAPE);
deal = new CAdventureMapButton(CGI->generaltexth->zelp[585],boost::bind(&CAltarWindow::makeDeal,this),269,520,"ALTSACR.DEF");
deal = new CAdventureMapButton(CGI->generaltexth->zelp[585],std::bind(&CAltarWindow::makeDeal,this),269,520,"ALTSACR.DEF");
if(Hero->getAlignment() != ::EAlignment::EVIL && Mode == EMarketMode::CREATURE_EXP)
new CAdventureMapButton(CGI->generaltexth->zelp[580], boost::bind(&CTradeWindow::setMode,this, EMarketMode::ARTIFACT_EXP), 516, 421, "ALTART.DEF");
new CAdventureMapButton(CGI->generaltexth->zelp[580], std::bind(&CTradeWindow::setMode,this, EMarketMode::ARTIFACT_EXP), 516, 421, "ALTART.DEF");
if(Hero->getAlignment() != ::EAlignment::GOOD && Mode == EMarketMode::ARTIFACT_EXP)
new CAdventureMapButton(CGI->generaltexth->zelp[572], boost::bind(&CTradeWindow::setMode,this, EMarketMode::CREATURE_EXP), 516, 421, "ALTSACC.DEF");
new CAdventureMapButton(CGI->generaltexth->zelp[572], std::bind(&CTradeWindow::setMode,this, EMarketMode::CREATURE_EXP), 516, 421, "ALTSACC.DEF");
expPerUnit.resize(GameConstants::ARMY_SIZE, 0);
getExpValues();
@ -3167,7 +3167,7 @@ void CAltarWindow::SacrificeAll()
for(auto i = hero->artifactsWorn.cbegin(); i != hero->artifactsWorn.cend(); i++)
{
if(i->second.artifact->artType->id != ArtifactID::ART_LOCK) //ignore locks from assembled artifacts
moveFromSlotToAltar(i->first, NULL, i->second.artifact);
moveFromSlotToAltar(i->first, nullptr, i->second.artifact);
}
SacrificeBackpack();
@ -3183,7 +3183,10 @@ void CAltarWindow::selectionChanged(bool side)
CTradeableItem *&selected = side ? hLeft : hRight;
CTradeableItem *&theOther = side ? hRight : hLeft;
theOther = *std::find_if(items[!side].begin(), items[!side].end(), boost::bind(&CTradeableItem::serial, _1) == selected->serial);
theOther = *std::find_if(items[!side].begin(), items[!side].end(), [&](const CTradeableItem * item)
{
return item->serial == selected->serial;
});
int stackCount = 0;
for (int i = 0; i < GameConstants::ARMY_SIZE; i++)
@ -3244,8 +3247,10 @@ void CAltarWindow::garrisonChanged()
BOOST_FOREACH(CTradeableItem *t, empty)
{
removeItem(*std::find_if(items[0].begin(), items[0].end(), boost::bind(&CTradeableItem::serial, _1) == t->serial));
removeItem(t);
removeItem(*std::find_if(items[0].begin(), items[0].end(), [&](const CTradeableItem * item)
{
return item->serial == t->serial;
}));
}
initSubs(true);
@ -3290,7 +3295,7 @@ void CAltarWindow::setExpToLevel()
void CAltarWindow::blockTrade()
{
hLeft = hRight = NULL;
hLeft = hRight = nullptr;
readyToTrade = false;
if(slider)
{
@ -3327,7 +3332,7 @@ void CAltarWindow::SacrificeBackpack()
continue;
}
putOnAltar(NULL, hero->artifactsInBackpack[i].artifact);
putOnAltar(nullptr, hero->artifactsInBackpack[i].artifact);
}
arts->scrollBackpack(0);
@ -3401,7 +3406,7 @@ void CAltarWindow::moveFromSlotToAltar(ArtifactPosition slotID, CTradeableItem*
{
arts->commonInfo->src.clear();
arts->commonInfo->dst.clear();
CCS->curh->dragAndDropCursor(NULL);
CCS->curh->dragAndDropCursor(nullptr);
arts->unmarkSlots(false);
}
}
@ -3466,31 +3471,31 @@ CSystemOptionsWindow::CSystemOptionsWindow():
//setting up buttons
load = new CAdventureMapButton (CGI->generaltexth->zelp[321].first, CGI->generaltexth->zelp[321].second,
boost::bind(&CSystemOptionsWindow::bloadf, this), 246, 298, "SOLOAD.DEF", SDLK_l);
std::bind(&CSystemOptionsWindow::bloadf, this), 246, 298, "SOLOAD.DEF", SDLK_l);
load->swappedImages = true;
load->update();
save = new CAdventureMapButton (CGI->generaltexth->zelp[322].first, CGI->generaltexth->zelp[322].second,
boost::bind(&CSystemOptionsWindow::bsavef, this), 357, 298, "SOSAVE.DEF", SDLK_s);
std::bind(&CSystemOptionsWindow::bsavef, this), 357, 298, "SOSAVE.DEF", SDLK_s);
save->swappedImages = true;
save->update();
restart = new CAdventureMapButton (CGI->generaltexth->zelp[323].first, CGI->generaltexth->zelp[323].second,
boost::bind(&CSystemOptionsWindow::brestartf, this), 246, 357, "SORSTRT", SDLK_r);
std::bind(&CSystemOptionsWindow::brestartf, this), 246, 357, "SORSTRT", SDLK_r);
restart->swappedImages = true;
restart->update();
mainMenu = new CAdventureMapButton (CGI->generaltexth->zelp[320].first, CGI->generaltexth->zelp[320].second,
boost::bind(&CSystemOptionsWindow::bmainmenuf, this), 357, 357, "SOMAIN.DEF", SDLK_m);
std::bind(&CSystemOptionsWindow::bmainmenuf, this), 357, 357, "SOMAIN.DEF", SDLK_m);
mainMenu->swappedImages = true;
mainMenu->update();
quitGame = new CAdventureMapButton (CGI->generaltexth->zelp[324].first, CGI->generaltexth->zelp[324].second,
boost::bind(&CSystemOptionsWindow::bquitf, this), 246, 415, "soquit.def", SDLK_q);
std::bind(&CSystemOptionsWindow::bquitf, this), 246, 415, "soquit.def", SDLK_q);
quitGame->swappedImages = true;
quitGame->update();
backToMap = new CAdventureMapButton (CGI->generaltexth->zelp[325].first, CGI->generaltexth->zelp[325].second,
boost::bind(&CSystemOptionsWindow::breturnf, this), 357, 415, "soretrn.def", SDLK_RETURN);
std::bind(&CSystemOptionsWindow::breturnf, this), 357, 415, "soretrn.def", SDLK_RETURN);
backToMap->swappedImages = true;
backToMap->update();
backToMap->assignedKeys.insert(SDLK_ESCAPE);
@ -3501,44 +3506,44 @@ CSystemOptionsWindow::CSystemOptionsWindow():
heroMoveSpeed->addButton(boost::assign::map_list_of(0,CGI->generaltexth->zelp[351].second),CGI->generaltexth->zelp[351].second, "sysopb3.def", 124, 77, 4);
heroMoveSpeed->addButton(boost::assign::map_list_of(0,CGI->generaltexth->zelp[352].second),CGI->generaltexth->zelp[352].second, "sysopb4.def", 172, 77, 8);
heroMoveSpeed->select(settings["adventure"]["heroSpeed"].Float(), 1);
heroMoveSpeed->onChange = boost::bind(&CSystemOptionsWindow::setHeroMoveSpeed, this, _1);
heroMoveSpeed->onChange = std::bind(&CSystemOptionsWindow::setHeroMoveSpeed, this, _1);
mapScrollSpeed = new CHighlightableButtonsGroup(0);
mapScrollSpeed->addButton(boost::assign::map_list_of(0,CGI->generaltexth->zelp[357].second),CGI->generaltexth->zelp[357].second, "sysopb9.def", 28, 210, 1);
mapScrollSpeed->addButton(boost::assign::map_list_of(0,CGI->generaltexth->zelp[358].second),CGI->generaltexth->zelp[358].second, "sysob10.def", 92, 210, 2);
mapScrollSpeed->addButton(boost::assign::map_list_of(0,CGI->generaltexth->zelp[359].second),CGI->generaltexth->zelp[359].second, "sysob11.def", 156, 210, 4);
mapScrollSpeed->select(settings["adventure"]["scrollSpeed"].Float(), 1);
mapScrollSpeed->onChange = boost::bind(&CSystemOptionsWindow::setMapScrollingSpeed, this, _1);
mapScrollSpeed->onChange = std::bind(&CSystemOptionsWindow::setMapScrollingSpeed, this, _1);
musicVolume = new CHighlightableButtonsGroup(0, true);
for(int i=0; i<10; ++i)
musicVolume->addButton(boost::assign::map_list_of(0,CGI->generaltexth->zelp[326+i].second),CGI->generaltexth->zelp[326+i].second, "syslb.def", 29 + 19*i, 359, i*11);
musicVolume->select(CCS->musich->getVolume(), 1);
musicVolume->onChange = boost::bind(&CSystemOptionsWindow::setMusicVolume, this, _1);
musicVolume->onChange = std::bind(&CSystemOptionsWindow::setMusicVolume, this, _1);
effectsVolume = new CHighlightableButtonsGroup(0, true);
for(int i=0; i<10; ++i)
effectsVolume->addButton(boost::assign::map_list_of(0,CGI->generaltexth->zelp[336+i].second),CGI->generaltexth->zelp[336+i].second, "syslb.def", 29 + 19*i, 425, i*11);
effectsVolume->select(CCS->soundh->getVolume(), 1);
effectsVolume->onChange = boost::bind(&CSystemOptionsWindow::setSoundVolume, this, _1);
effectsVolume->onChange = std::bind(&CSystemOptionsWindow::setSoundVolume, this, _1);
showReminder = new CHighlightableButton(
boost::bind(&CSystemOptionsWindow::toggleReminder, this, true), boost::bind(&CSystemOptionsWindow::toggleReminder, this, false),
std::map<int,std::string>(), CGI->generaltexth->zelp[361].second, false, "sysopchk.def", NULL, 246, 87, false);
std::bind(&CSystemOptionsWindow::toggleReminder, this, true), std::bind(&CSystemOptionsWindow::toggleReminder, this, false),
std::map<int,std::string>(), CGI->generaltexth->zelp[361].second, false, "sysopchk.def", nullptr, 246, 87, false);
quickCombat = new CHighlightableButton(
boost::bind(&CSystemOptionsWindow::toggleQuickCombat, this, true), boost::bind(&CSystemOptionsWindow::toggleQuickCombat, this, false),
std::map<int,std::string>(), CGI->generaltexth->zelp[362].second, false, "sysopchk.def", NULL, 246, 87+32, false);
std::bind(&CSystemOptionsWindow::toggleQuickCombat, this, true), std::bind(&CSystemOptionsWindow::toggleQuickCombat, this, false),
std::map<int,std::string>(), CGI->generaltexth->zelp[362].second, false, "sysopchk.def", nullptr, 246, 87+32, false);
newCreatureWin = new CHighlightableButton(
boost::bind(&CSystemOptionsWindow::toggleCreatureWin, this, true), boost::bind(&CSystemOptionsWindow::toggleCreatureWin, this, false),
std::map<int,std::string>(), cwHelp, false, "sysopchk.def", NULL, 246, 183, false);
std::bind(&CSystemOptionsWindow::toggleCreatureWin, this, true), std::bind(&CSystemOptionsWindow::toggleCreatureWin, this, false),
std::map<int,std::string>(), cwHelp, false, "sysopchk.def", nullptr, 246, 183, false);
fullscreen = new CHighlightableButton(
boost::bind(&CSystemOptionsWindow::toggleFullscreen, this, true), boost::bind(&CSystemOptionsWindow::toggleFullscreen, this, false),
std::map<int,std::string>(), fsHelp, false, "sysopchk.def", NULL, 246, 215, false);
std::bind(&CSystemOptionsWindow::toggleFullscreen, this, true), std::bind(&CSystemOptionsWindow::toggleFullscreen, this, false),
std::map<int,std::string>(), fsHelp, false, "sysopchk.def", nullptr, 246, 215, false);
showReminder->select(settings["adventure"]["heroReminder"].Bool());
quickCombat->select(settings["adventure"]["quickCombat"].Bool());
@ -3547,7 +3552,7 @@ CSystemOptionsWindow::CSystemOptionsWindow():
onFullscreenChanged([&](const JsonNode &newState){ fullscreen->select(newState.Bool());});
gameResButton = new CAdventureMapButton("", rsHelp, boost::bind(&CSystemOptionsWindow::selectGameRes, this), 28, 275,"SYSOB12", SDLK_g);
gameResButton = new CAdventureMapButton("", rsHelp, std::bind(&CSystemOptionsWindow::selectGameRes, this), 28, 275,"SYSOB12", SDLK_g);
std::string resText;
resText += boost::lexical_cast<std::string>(settings["video"]["screenRes"]["width"].Float());
@ -3572,8 +3577,8 @@ void CSystemOptionsWindow::selectGameRes()
items.push_back(resX + 'x' + resY);
}
GH.pushInt(new CObjectListWindow(items, NULL, rsLabel, rsHelp,
boost::bind(&CSystemOptionsWindow::setGameRes, this, _1)));
GH.pushInt(new CObjectListWindow(items, nullptr, rsLabel, rsHelp,
std::bind(&CSystemOptionsWindow::setGameRes, this, _1)));
}
void CSystemOptionsWindow::setGameRes(int index)
@ -3680,9 +3685,9 @@ CTavernWindow::CTavernWindow(const CGObjectInstance *TavernObj):
new CTextBox(LOCPLINT->cb->getTavernGossip(tavernObj), Rect(32, 190, 330, 68), 0, FONT_SMALL, CENTER, Colors::WHITE);
new CGStatusBar(new CPicture(*background, Rect(8, pos.h - 26, pos.w - 16, 19), 8, pos.h - 26));
cancel = new CAdventureMapButton(CGI->generaltexth->tavernInfo[7],"", boost::bind(&CTavernWindow::close, this), 310, 428, "ICANCEL.DEF", SDLK_ESCAPE);
recruit = new CAdventureMapButton("", "", boost::bind(&CTavernWindow::recruitb, this), 272, 355, "TPTAV01.DEF", SDLK_RETURN);
thiefGuild = new CAdventureMapButton(CGI->generaltexth->tavernInfo[5],"", boost::bind(&CTavernWindow::thievesguildb, this), 22, 428, "TPTAV02.DEF", SDLK_t);
cancel = new CAdventureMapButton(CGI->generaltexth->tavernInfo[7],"", std::bind(&CTavernWindow::close, this), 310, 428, "ICANCEL.DEF", SDLK_ESCAPE);
recruit = new CAdventureMapButton("", "", std::bind(&CTavernWindow::recruitb, this), 272, 355, "TPTAV01.DEF", SDLK_RETURN);
thiefGuild = new CAdventureMapButton(CGI->generaltexth->tavernInfo[5],"", std::bind(&CTavernWindow::thievesguildb, this), 22, 428, "TPTAV02.DEF", SDLK_t);
if(LOCPLINT->cb->getResourceAmount(Res::GOLD) < 2500) //not enough gold
{
@ -4024,11 +4029,11 @@ CGarrisonWindow::CGarrisonWindow( const CArmedInstance *up, const CGHeroInstance
garr = new CGarrisonInt(92, 127, 4, Point(0,96), background->bg, Point(93,127), up, down, removableUnits);
{
CAdventureMapButton *split = new CAdventureMapButton(CGI->generaltexth->tcommands[3],"",boost::bind(&CGarrisonInt::splitClick,garr),88,314,"IDV6432.DEF");
CAdventureMapButton *split = new CAdventureMapButton(CGI->generaltexth->tcommands[3],"",std::bind(&CGarrisonInt::splitClick,garr),88,314,"IDV6432.DEF");
removeChild(split);
garr->addSplitBtn(split);
}
quit = new CAdventureMapButton(CGI->generaltexth->tcommands[8],"",boost::bind(&CGarrisonWindow::close,this),399,314,"IOK6432.DEF",SDLK_RETURN);
quit = new CAdventureMapButton(CGI->generaltexth->tcommands[8],"",std::bind(&CGarrisonWindow::close,this),399,314,"IOK6432.DEF",SDLK_RETURN);
std::string titleText;
if (garr->armedObjs[1]->tempOwner == garr->armedObjs[0]->tempOwner)
@ -4259,7 +4264,7 @@ void CArtPlace::clickRight(tribool down, bool previousState)
ourArt->artType->id,
combination->id,
true,
boost::bind(&CCallback::assembleArtifacts, LOCPLINT->cb.get(), ourOwner->curHero, slotID, true, combination->id),
std::bind(&CCallback::assembleArtifacts, LOCPLINT->cb.get(), ourOwner->curHero, slotID, true, combination->id),
0);
if(assemblyPossibilities.size() > 2)
@ -4277,7 +4282,7 @@ void CArtPlace::clickRight(tribool down, bool previousState)
ourArt->artType->id,
0,
false,
boost::bind(&CCallback::assembleArtifacts, LOCPLINT->cb.get(), ourOwner->curHero, slotID, false, ArtifactID()),
std::bind(&CCallback::assembleArtifacts, LOCPLINT->cb.get(), ourOwner->curHero, slotID, false, ArtifactID()),
0);
return;
}
@ -4333,7 +4338,7 @@ void CArtPlace::deselect ()
ourOwner->getArtPlace(i)->pickSlot(false);
}
CCS->curh->dragAndDropCursor(NULL);
CCS->curh->dragAndDropCursor(nullptr);
ourOwner->unmarkSlots();
ourOwner->commonInfo->src.clear();
if(slotID >= GameConstants::BACKPACK_START)
@ -4460,7 +4465,7 @@ CComponent * LRClickableAreaWTextComp::createComponent() const
if(baseType >= 0)
return new CComponent(CComponent::Etype(baseType), type, bonusValue);
else
return NULL;
return nullptr;
}
void LRClickableAreaWTextComp::clickRight(tribool down, bool previousState)
@ -4536,7 +4541,7 @@ void CArtifactsOfHero::SCommonPart::reset()
{
src.clear();
dst.clear();
CCS->curh->dragAndDropCursor(NULL);
CCS->curh->dragAndDropCursor(nullptr);
}
void CArtifactsOfHero::setHero(const CGHeroInstance * hero)
@ -4579,7 +4584,7 @@ void CArtifactsOfHero::setHero(const CGHeroInstance * hero)
// CCS->curh->dragAndDropCursor(graphics->artDefs->ourImages[commonInfo->srcArtifact->id].bitmap);
// markPossibleSlots(commonInfo->srcArtifact);
// }
// else if (commonInfo->destAOH != NULL)
// else if (commonInfo->destAOH != nullptr)
// {
// // Reset all parameters.
// commonInfo->reset();
@ -4615,7 +4620,7 @@ void CArtifactsOfHero::dispose()
{
//vstd::clear_pointer(curHero);
//unmarkSlots(false);
CCS->curh->dragAndDropCursor(NULL);
CCS->curh->dragAndDropCursor(nullptr);
}
void CArtifactsOfHero::scrollBackpack(int dir)
@ -4741,7 +4746,7 @@ void CArtifactsOfHero::setSlotData(CArtPlace* artPlace, ArtifactPosition slotID)
artPlace->lockSlot(asi->locked);
}
else
artPlace->setArtifact(NULL);
artPlace->setArtifact(nullptr);
}
/**
@ -4751,15 +4756,15 @@ void CArtifactsOfHero::eraseSlotData (CArtPlace* artPlace, ArtifactPosition slot
{
artPlace->pickSlot(false);
artPlace->slotID = slotID;
artPlace->setArtifact(NULL);
artPlace->setArtifact(nullptr);
}
CArtifactsOfHero::CArtifactsOfHero(std::vector<CArtPlace *> ArtWorn, std::vector<CArtPlace *> Backpack,
CAdventureMapButton *leftScroll, CAdventureMapButton *rightScroll, bool createCommonPart):
curHero(NULL),
curHero(nullptr),
artWorn(ArtWorn), backpack(Backpack),
backpackPos(0), commonInfo(NULL), updateState(false),
backpackPos(0), commonInfo(nullptr), updateState(false),
leftArtRoll(leftScroll), rightArtRoll(rightScroll),
allowedAssembling(true), highlightModeCallback(0)
{
@ -4783,12 +4788,12 @@ CArtifactsOfHero::CArtifactsOfHero(std::vector<CArtPlace *> ArtWorn, std::vector
eraseSlotData(backpack[s], ArtifactPosition(GameConstants::BACKPACK_START + s));
}
leftArtRoll->callback += boost::bind(&CArtifactsOfHero::scrollBackpack,this,-1);
rightArtRoll->callback += boost::bind(&CArtifactsOfHero::scrollBackpack,this,+1);
leftArtRoll->callback += std::bind(&CArtifactsOfHero::scrollBackpack,this,-1);
rightArtRoll->callback += std::bind(&CArtifactsOfHero::scrollBackpack,this,+1);
}
CArtifactsOfHero::CArtifactsOfHero(const Point& position, bool createCommonPart /*= false*/)
: curHero(NULL), backpackPos(0), commonInfo(NULL), updateState(false), allowedAssembling(true), highlightModeCallback(0)
: curHero(nullptr), backpackPos(0), commonInfo(nullptr), updateState(false), allowedAssembling(true), highlightModeCallback(0)
{
if(createCommonPart)
{
@ -4828,8 +4833,8 @@ CArtifactsOfHero::CArtifactsOfHero(const Point& position, bool createCommonPart
backpack.push_back(add);
}
leftArtRoll = new CAdventureMapButton(std::string(), std::string(), boost::bind(&CArtifactsOfHero::scrollBackpack,this,-1), 379, 364, "hsbtns3.def", SDLK_LEFT);
rightArtRoll = new CAdventureMapButton(std::string(), std::string(), boost::bind(&CArtifactsOfHero::scrollBackpack,this,+1), 632, 364, "hsbtns5.def", SDLK_RIGHT);
leftArtRoll = new CAdventureMapButton(std::string(), std::string(), std::bind(&CArtifactsOfHero::scrollBackpack,this,-1), 379, 364, "hsbtns3.def", SDLK_LEFT);
rightArtRoll = new CAdventureMapButton(std::string(), std::string(), std::bind(&CArtifactsOfHero::scrollBackpack,this,+1), 632, 364, "hsbtns5.def", SDLK_RIGHT);
}
CArtifactsOfHero::~CArtifactsOfHero()
@ -4920,7 +4925,7 @@ void CArtifactsOfHero::artifactMoved(const ArtifactLocation &src, const Artifact
assert(dst.slot >= GameConstants::BACKPACK_START);
commonInfo->reset();
CArtPlace *ap = NULL;
CArtPlace *ap = nullptr;
BOOST_FOREACH(CArtifactsOfHero *aoh, commonInfo->participants)
{
if(dst.isHolder(aoh->curHero))
@ -4998,7 +5003,7 @@ CArtPlace * CArtifactsOfHero::getArtPlace(int slot)
return ap;
}
return NULL;
return nullptr;
}
void CArtifactsOfHero::artifactAssembled(const ArtifactLocation &al)
@ -5035,7 +5040,7 @@ void CArtifactsOfHero::updateSlot(ArtifactPosition slotID)
void CExchangeWindow::questlog(int whichHero)
{
CCS->curh->dragAndDropCursor(NULL);
CCS->curh->dragAndDropCursor(nullptr);
}
void CExchangeWindow::prepareBackground()
@ -5174,30 +5179,30 @@ CExchangeWindow::CExchangeWindow(ObjectInstanceID hero1, ObjectInstanceID hero2,
}
//buttons
quit = new CAdventureMapButton(CGI->generaltexth->zelp[600], boost::bind(&CExchangeWindow::close, this), 732, 567, "IOKAY.DEF", SDLK_RETURN);
quit = new CAdventureMapButton(CGI->generaltexth->zelp[600], std::bind(&CExchangeWindow::close, this), 732, 567, "IOKAY.DEF", SDLK_RETURN);
if(queryID.getNum() > 0)
quit->callback += [=]{ LOCPLINT->cb->selectionMade(0, queryID); };
questlogButton[0] = new CAdventureMapButton(CGI->generaltexth->heroscrn[0], "", boost::bind(&CExchangeWindow::questlog,this, 0), 10, 44, "hsbtns4.def");
questlogButton[1] = new CAdventureMapButton(CGI->generaltexth->heroscrn[0], "", boost::bind(&CExchangeWindow::questlog,this, 1), 740, 44, "hsbtns4.def");
questlogButton[0] = new CAdventureMapButton(CGI->generaltexth->heroscrn[0], "", std::bind(&CExchangeWindow::questlog,this, 0), 10, 44, "hsbtns4.def");
questlogButton[1] = new CAdventureMapButton(CGI->generaltexth->heroscrn[0], "", std::bind(&CExchangeWindow::questlog,this, 1), 740, 44, "hsbtns4.def");
Rect barRect(5, 578, 725, 18);
ourBar = new CGStatusBar(new CPicture(*background, barRect, 5, 578, false));
//garrison interface
garr = new CGarrisonInt(69, 131, 4, Point(418,0), *background, Point(69,131), heroInst[0],heroInst[1], true, true);
garr->addSplitBtn(new CAdventureMapButton(CGI->generaltexth->tcommands[3], "", boost::bind(&CGarrisonInt::splitClick, garr), 10, 132, "TSBTNS.DEF"));
garr->addSplitBtn(new CAdventureMapButton(CGI->generaltexth->tcommands[3], "", boost::bind(&CGarrisonInt::splitClick, garr), 740, 132, "TSBTNS.DEF"));
garr->addSplitBtn(new CAdventureMapButton(CGI->generaltexth->tcommands[3], "", std::bind(&CGarrisonInt::splitClick, garr), 10, 132, "TSBTNS.DEF"));
garr->addSplitBtn(new CAdventureMapButton(CGI->generaltexth->tcommands[3], "", std::bind(&CGarrisonInt::splitClick, garr), 740, 132, "TSBTNS.DEF"));
}
CExchangeWindow::~CExchangeWindow() //d-tor
{
delete artifs[0]->commonInfo;
artifs[0]->commonInfo = NULL;
artifs[1]->commonInfo = NULL;
artifs[0]->commonInfo = nullptr;
artifs[1]->commonInfo = nullptr;
}
CShipyardWindow::CShipyardWindow(const std::vector<si32> &cost, int state, int boatType, const boost::function<void()> &onBuy):
CShipyardWindow::CShipyardWindow(const std::vector<si32> &cost, int state, int boatType, const std::function<void()> &onBuy):
CWindowObject(PLAYER_COLORED, "TPSHIP")
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
@ -5220,8 +5225,8 @@ CShipyardWindow::CShipyardWindow(const std::vector<si32> &cost, int state, int b
goldPic = new CAnimImage("RESOURCE", Res::GOLD, 0, 100, 244);
woodPic = new CAnimImage("RESOURCE", Res::WOOD, 0, 196, 244);
quit = new CAdventureMapButton(CGI->generaltexth->allTexts[599], "", boost::bind(&CShipyardWindow::close, this), 224, 312, "ICANCEL", SDLK_RETURN);
build = new CAdventureMapButton(CGI->generaltexth->allTexts[598], "", boost::bind(&CShipyardWindow::close, this), 42, 312, "IBUY30", SDLK_RETURN);
quit = new CAdventureMapButton(CGI->generaltexth->allTexts[599], "", std::bind(&CShipyardWindow::close, this), 224, 312, "ICANCEL", SDLK_RETURN);
build = new CAdventureMapButton(CGI->generaltexth->allTexts[598], "", std::bind(&CShipyardWindow::close, this), 42, 312, "IBUY30", SDLK_RETURN);
build->callback += onBuy;
for(Res::ERes i = Res::WOOD; i <= Res::GOLD; vstd::advance(i, 1))
@ -5247,7 +5252,7 @@ CPuzzleWindow::CPuzzleWindow(const int3 &GrailPos, double discoveredRatio):
OBJ_CONSTRUCTION_CAPTURING_ALL;
CCS->soundh->playSound(soundBase::OBELISK);
quitb = new CAdventureMapButton(CGI->generaltexth->allTexts[599], "", boost::bind(&CPuzzleWindow::close, this), 670, 538, "IOK6432.DEF", SDLK_RETURN);
quitb = new CAdventureMapButton(CGI->generaltexth->allTexts[599], "", std::bind(&CPuzzleWindow::close, this), 670, 538, "IOK6432.DEF", SDLK_RETURN);
quitb->assignedKeys.insert(SDLK_ESCAPE);
quitb->borderColor = Colors::METALLIC_GOLD;
quitb->borderEnabled = true;
@ -5386,9 +5391,9 @@ CTransformerWindow::CTransformerWindow(const CGHeroInstance * _hero, const CGTow
if ( army->getCreature(SlotID(i)) )
items.push_back(new CItem(this, army->getStackCount(SlotID(i)), i));
all = new CAdventureMapButton(CGI->generaltexth->zelp[590],boost::bind(&CTransformerWindow::addAll,this), 146,416,"ALTARMY.DEF",SDLK_a);
convert= new CAdventureMapButton(CGI->generaltexth->zelp[591],boost::bind(&CTransformerWindow::makeDeal,this), 269,416,"ALTSACR.DEF",SDLK_RETURN);
cancel = new CAdventureMapButton(CGI->generaltexth->zelp[592],boost::bind(&CTransformerWindow::close, this),392,416,"ICANCEL.DEF",SDLK_ESCAPE);
all = new CAdventureMapButton(CGI->generaltexth->zelp[590],std::bind(&CTransformerWindow::addAll,this), 146,416,"ALTARMY.DEF",SDLK_a);
convert= new CAdventureMapButton(CGI->generaltexth->zelp[591],std::bind(&CTransformerWindow::makeDeal,this), 269,416,"ALTSACR.DEF",SDLK_RETURN);
cancel = new CAdventureMapButton(CGI->generaltexth->zelp[592],std::bind(&CTransformerWindow::close, this),392,416,"ICANCEL.DEF",SDLK_ESCAPE);
bar = new CGStatusBar(new CPicture(*background, Rect(8, pos.h - 26, pos.w - 16, 19), 8, pos.h - 26));
new CLabel(153, 29,FONT_SMALL, CENTER, Colors::YELLOW, CGI->generaltexth->allTexts[485]);//holding area
@ -5448,7 +5453,7 @@ void CUniversityWindow::CItem::showAll(SDL_Surface * to)
break;
case 2: bar = parent->green;
break;
default:bar = NULL;
default:bar = nullptr;
break;
}
assert(bar);
@ -5507,7 +5512,7 @@ CUniversityWindow::CUniversityWindow(const CGHeroInstance * _hero, const IMarket
items.push_back(new CItem(this, list[i], 54+i*104, 234));
cancel = new CAdventureMapButton(CGI->generaltexth->zelp[632],
boost::bind(&CUniversityWindow::close, this),200,313,"IOKAY.DEF",SDLK_RETURN);
std::bind(&CUniversityWindow::close, this),200,313,"IOKAY.DEF",SDLK_RETURN);
bar = new CGStatusBar(new CPicture(*background, Rect(8, pos.h - 26, pos.w - 16, 19), 8, pos.h - 26));
}
@ -5540,11 +5545,11 @@ CUnivConfirmWindow::CUnivConfirmWindow(CUniversityWindow * PARENT, int SKILL, bo
boost::replace_first(text, "%s", CGI->generaltexth->skillName[SKILL]);
boost::replace_first(text, "%d", "2000");
confirm= new CAdventureMapButton(hoverText, text, boost::bind(&CUnivConfirmWindow::makeDeal, this, SKILL),
confirm= new CAdventureMapButton(hoverText, text, std::bind(&CUnivConfirmWindow::makeDeal, this, SKILL),
148,299,"IBY6432.DEF",SDLK_RETURN);
confirm->block(!available);
cancel = new CAdventureMapButton(CGI->generaltexth->zelp[631],boost::bind(&CUnivConfirmWindow::close, this),
cancel = new CAdventureMapButton(CGI->generaltexth->zelp[631],std::bind(&CUnivConfirmWindow::close, this),
252,299,"ICANCEL.DEF",SDLK_ESCAPE);
bar = new CGStatusBar(new CPicture(*background, Rect(8, pos.h - 26, pos.w - 16, 19), 8, pos.h - 26));
}
@ -5577,19 +5582,19 @@ CHillFortWindow::CHillFortWindow(const CGHeroInstance *visitor, const CGObjectIn
for (int i=0; i<slotsCount; i++)
{
currState[i] = getState(SlotID(i));
upgrade[i] = new CAdventureMapButton(getTextForSlot(SlotID(i)),"",boost::bind(&CHillFortWindow::makeDeal, this, SlotID(i)),
upgrade[i] = new CAdventureMapButton(getTextForSlot(SlotID(i)),"",std::bind(&CHillFortWindow::makeDeal, this, SlotID(i)),
107+i*76, 171, "", SDLK_1+i, &files);
upgrade[i]->block(currState[i] == -1);
}
files.clear();
files += "APHLF4R.DEF", "APHLF4Y.DEF", "APHLF4G.DEF";
currState[slotsCount] = getState(SlotID(slotsCount));
upgradeAll = new CAdventureMapButton(CGI->generaltexth->allTexts[432],"",boost::bind(&CHillFortWindow::makeDeal, this, SlotID(slotsCount)),
upgradeAll = new CAdventureMapButton(CGI->generaltexth->allTexts[432],"",std::bind(&CHillFortWindow::makeDeal, this, SlotID(slotsCount)),
30, 231, "", SDLK_0, &files);
quit = new CAdventureMapButton("","",boost::bind(&CHillFortWindow::close, this), 294, 275, "IOKAY.DEF", SDLK_RETURN);
quit = new CAdventureMapButton("","",std::bind(&CHillFortWindow::close, this), 294, 275, "IOKAY.DEF", SDLK_RETURN);
bar = new CGStatusBar(new CPicture(*background, Rect(8, pos.h - 26, pos.w - 16, 19), 8, pos.h - 26));
garr = new CGarrisonInt(108, 60, 18, Point(),background->bg,Point(108,60),hero,NULL);
garr = new CGarrisonInt(108, 60, 18, Point(),background->bg,Point(108,60),hero,nullptr);
updateGarrisons();
}
@ -5747,7 +5752,7 @@ CThievesGuildWindow::CThievesGuildWindow(const CGObjectInstance * _owner):
SThievesGuildInfo tgi; //info to be displayed
LOCPLINT->cb->getThievesGuildInfo(tgi, owner);
exitb = new CAdventureMapButton (CGI->generaltexth->allTexts[600], "", boost::bind(&CThievesGuildWindow::close,this), 748, 556, "TPMAGE1", SDLK_RETURN);
exitb = new CAdventureMapButton (CGI->generaltexth->allTexts[600], "", std::bind(&CThievesGuildWindow::close,this), 748, 556, "TPMAGE1", SDLK_RETURN);
exitb->assignedKeys.insert(SDLK_ESCAPE);
statusBar = new CGStatusBar(3, 555, "TStatBar.bmp", 742);
@ -5927,7 +5932,7 @@ void MoraleLuckBox::set(const IBonusBearer *node)
}
MoraleLuckBox::MoraleLuckBox(bool Morale, const Rect &r, bool Small):
image(NULL),
image(nullptr),
morale(Morale),
small(Small)
{
@ -5947,7 +5952,7 @@ void CWindowWithArtifacts::artifactRemoved(const ArtifactLocation &artLoc)
void CWindowWithArtifacts::artifactMoved(const ArtifactLocation &artLoc, const ArtifactLocation &destLoc)
{
CArtifactsOfHero *destaoh = NULL;
CArtifactsOfHero *destaoh = nullptr;
BOOST_FOREACH(CArtifactsOfHero *aoh, artSets)
{
aoh->artifactMoved(artLoc, destLoc);
@ -5957,7 +5962,7 @@ void CWindowWithArtifacts::artifactMoved(const ArtifactLocation &artLoc, const A
}
//Make sure the status bar is updated so it does not display old text
if(destaoh != NULL && destaoh->getArtPlace(destLoc.slot) != NULL)
if(destaoh != nullptr && destaoh->getArtPlace(destLoc.slot) != nullptr)
{
destaoh->getArtPlace(destLoc.slot)->hover(true);
}
@ -5978,8 +5983,8 @@ void CWindowWithArtifacts::artifactAssembled(const ArtifactLocation &artLoc)
void CArtifactsOfHero::SCommonPart::Artpos::clear()
{
slotID = ArtifactPosition::PRE_FIRST;
AOH = NULL;
art = NULL;
AOH = nullptr;
art = nullptr;
}
CArtifactsOfHero::SCommonPart::Artpos::Artpos()
@ -5993,7 +5998,7 @@ void CArtifactsOfHero::SCommonPart::Artpos::setTo(const CArtPlace *place, bool d
AOH = place->ourOwner;
if(slotID >= 19 && dontTakeBackpack)
art = NULL;
art = nullptr;
else
art = place->ourArt;
}
@ -6100,7 +6105,7 @@ CIntObject * CRClickPopup::createInfoWin(Point position, const CGObjectInstance
case Obj::GARRISON2:
return new CInfoBoxPopup(position, dynamic_cast<const CGGarrison *>(specific));
default:
return NULL;
return nullptr;
}
}

54
client/GUIClasses.h
View File

@ -105,7 +105,7 @@ public:
~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, 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);
static CInfoWindow *create(const std::string &text, PlayerColor playerID = PlayerColor(1), const std::vector<CComponent*> *components = nullptr, bool DelComps = false);
/// create text from title and description: {title}\n\n description
static std::string genText(std::string title, std::string description);
@ -160,7 +160,7 @@ public:
void show(SDL_Surface * to);
CInfoPopup(SDL_Surface * Bitmap, int x, int y, bool Free=false); //c-tor
CInfoPopup(SDL_Surface * Bitmap, const Point &p, EAlignment alignment, bool Free=false); //c-tor
CInfoPopup(SDL_Surface * Bitmap = NULL, bool Free = false); //default c-tor
CInfoPopup(SDL_Surface * Bitmap = nullptr, bool Free = false); //default c-tor
void init(int x, int y);
~CInfoPopup(); //d-tor
@ -227,14 +227,14 @@ class CSelectableComponent : public CComponent, public CKeyShortcut
void init();
public:
bool selected; //if true, this component is selected
boost::function<void()> onSelect; //function called on selection change
std::function<void()> onSelect; //function called on selection change
void showAll(SDL_Surface * to);
void select(bool on);
void clickLeft(tribool down, bool previousState); //call-in
CSelectableComponent(Etype Type, int Sub, int Val, ESize imageSize=large, boost::function<void()> OnSelect = 0); //c-tor
CSelectableComponent(const Component &c, boost::function<void()> OnSelect = 0); //c-tor
CSelectableComponent(Etype Type, int Sub, int Val, ESize imageSize=large, std::function<void()> OnSelect = 0); //c-tor
CSelectableComponent(const Component &c, std::function<void()> OnSelect = 0); //c-tor
};
/// box with multiple components (up to 8?)
@ -244,7 +244,7 @@ class CComponentBox : public CIntObject
std::vector<CComponent *> components;
CSelectableComponent * selected;
boost::function<void(int newID)> onSelect;
std::function<void(int newID)> onSelect;
void selectionChanged(CSelectableComponent * newSelection);
@ -269,7 +269,7 @@ public:
/// constructor for selectable components
/// will also create "or" labels between components
/// onSelect - optional function that will be called every time on selection change
CComponentBox(std::vector<CSelectableComponent *> components, Rect position, boost::function<void(int newID)> onSelect = 0);
CComponentBox(std::vector<CSelectableComponent *> components, Rect position, std::function<void(int newID)> onSelect = 0);
};
////////////////////////////////////////////////////////////////////////////////
@ -314,7 +314,7 @@ class CGarrisonSlot : public CIntObject
{
SlotID ID; //for identification
CGarrisonInt *owner;
const CStackInstance *myStack; //NULL if slot is empty
const CStackInstance *myStack; //nullptr if slot is empty
const CCreature *creature;
int upg; //0 - up garrison, 1 - down garrison
@ -330,7 +330,7 @@ public:
void clickRight(tribool down, bool previousState);
void clickLeft(tribool down, bool previousState);
void update();
CGarrisonSlot(CGarrisonInt *Owner, int x, int y, SlotID IID, int Upg=0, const CStackInstance * Creature=NULL);
CGarrisonSlot(CGarrisonInt *Owner, int x, int y, SlotID IID, int Upg=0, const CStackInstance * Creature=nullptr);
friend class CGarrisonInt;
};
@ -383,7 +383,7 @@ public:
//removableUnits - you can take units from top;
//smallImgs - units images size 64x58 or 32x32;
//twoRows - display slots in 2 row (1st row = 4 slots, 2nd = 3 slots)
CGarrisonInt(int x, int y, int inx, const Point &garsOffset, SDL_Surface *pomsur, const Point &SurOffset, const CArmedInstance *s1, const CArmedInstance *s2=NULL, bool _removableUnits = true, bool smallImgs = false, bool _twoRows=false); //c-tor
CGarrisonInt(int x, int y, int inx, const Point &garsOffset, SDL_Surface *pomsur, const Point &SurOffset, const CArmedInstance *s1, const CArmedInstance *s2=nullptr, bool _removableUnits = true, bool smallImgs = false, bool _twoRows=false); //c-tor
};
/// draws picture with creature on background, use Animated=true to get animation
@ -430,7 +430,7 @@ class CRecruitmentWindow : public CWindowObject
void createItems(TResources res);
};
boost::function<void(CreatureID,int)> onRecruit; //void (int ID, int amount) <-- call to recruit creatures
std::function<void(CreatureID,int)> onRecruit; //void (int ID, int amount) <-- call to recruit creatures
int level;
const CArmedInstance *dst;
@ -454,14 +454,14 @@ class CRecruitmentWindow : public CWindowObject
void showAll(SDL_Surface *to);
public:
const CGDwelling * const dwelling;
CRecruitmentWindow(const CGDwelling *Dwelling, int Level, const CArmedInstance *Dst, const boost::function<void(CreatureID,int)> & Recruit, int y_offset = 0); //creatures - pairs<creature_ID,amount> //c-tor
CRecruitmentWindow(const CGDwelling *Dwelling, int Level, const CArmedInstance *Dst, const std::function<void(CreatureID,int)> & Recruit, int y_offset = 0); //creatures - pairs<creature_ID,amount> //c-tor
void availableCreaturesChanged();
};
/// Split window where creatures can be split up into two single unit stacks
class CSplitWindow : public CWindowObject
{
boost::function<void(int, int)> callback;
std::function<void(int, int)> callback;
int leftAmount;
int rightAmount;
@ -485,7 +485,7 @@ public:
* leftMin, rightMin - minimal amount of creatures in each stack
* leftAmount, rightAmount - amount of creatures in each stack
*/
CSplitWindow(const CCreature * creature, boost::function<void(int, int)> callback,
CSplitWindow(const CCreature * creature, std::function<void(int, int)> callback,
int leftMin, int rightMin, int leftAmount, int rightAmount);
};
@ -493,12 +493,12 @@ public:
class CLevelWindow : public CWindowObject
{
CComponentBox * box; //skills to select
boost::function<void(ui32)> cb;
std::function<void(ui32)> cb;
void selectionChanged(unsigned to);
public:
CLevelWindow(const CGHeroInstance *hero, PrimarySkill::PrimarySkill pskill, std::vector<SecondarySkill> &skills, boost::function<void(ui32)> callback); //c-tor
CLevelWindow(const CGHeroInstance *hero, PrimarySkill::PrimarySkill pskill, std::vector<SecondarySkill> &skills, std::function<void(ui32)> callback); //c-tor
~CLevelWindow(); //d-tor
};
@ -530,7 +530,7 @@ class CObjectListWindow : public CWindowObject
void clickLeft(tribool down, bool previousState);
};
boost::function<void(int)> onSelect;//called when OK button is pressed, returns id of selected item.
std::function<void(int)> onSelect;//called when OK button is pressed, returns id of selected item.
CLabel * title;
CLabel * descr;
@ -544,12 +544,12 @@ class CObjectListWindow : public CWindowObject
public:
size_t selected;//index of currently selected item
/// Callback will be called when OK button is pressed, returns id of selected item. initState = initially selected item
/// Image can be NULL
/// Image can be nullptr
///item names will be taken from map objects
CObjectListWindow(const std::vector<int> &_items, CPicture * titlePic, std::string _title, std::string _descr,
boost::function<void(int)> Callback);
std::function<void(int)> Callback);
CObjectListWindow(const std::vector<std::string> &_items, CPicture * titlePic, std::string _title, std::string _descr,
boost::function<void(int)> Callback);
std::function<void(int)> Callback);
CIntObject *genItem(size_t index);
void elementSelected();//call callback and close this window
@ -625,7 +625,7 @@ public:
CArtifactsOfHero *arts;
//all indexes: 1 = left, 0 = right
std::vector<CTradeableItem*> items[2];
CTradeableItem *hLeft, *hRight; //highlighted items (NULL if no highlight)
CTradeableItem *hLeft, *hRight; //highlighted items (nullptr if no highlight)
EType itemsType[2];
EMarketMode::EMarketMode mode;//0 - res<->res; 1 - res<->plauer; 2 - buy artifact; 3 - sell artifact
@ -640,7 +640,7 @@ public:
void initSubs(bool Left);
void initTypes();
void initItems(bool Left);
std::vector<int> *getItemsIds(bool Left); //NULL if default
std::vector<int> *getItemsIds(bool Left); //nullptr if default
void getPositionsFor(std::vector<Rect> &poss, bool Left, EType type) const;
void removeItems(const std::set<CTradeableItem *> &toRemove);
void removeItem(CTradeableItem * t);
@ -671,7 +671,7 @@ public:
void sliderMoved(int to);
void makeDeal();
void selectionChanged(bool side); //true == left
CMarketplaceWindow(const IMarket *Market, const CGHeroInstance *Hero = NULL, EMarketMode::EMarketMode Mode = EMarketMode::RESOURCE_RESOURCE); //c-tor
CMarketplaceWindow(const IMarket *Market, const CGHeroInstance *Hero = nullptr, EMarketMode::EMarketMode Mode = EMarketMode::RESOURCE_RESOURCE); //c-tor
~CMarketplaceWindow(); //d-tor
Point selectionOffset(bool Left) const;
@ -908,7 +908,7 @@ public:
CArtifactsOfHero * ourOwner;
const CArtifactInstance * ourArt; // should be changed only with setArtifact()
CArtPlace(Point position, const CArtifactInstance * Art = NULL); //c-tor
CArtPlace(Point position, const CArtifactInstance * Art = nullptr); //c-tor
void clickLeft(tribool down, bool previousState);
void clickRight(tribool down, bool previousState);
void select ();
@ -955,7 +955,7 @@ public:
CAdventureMapButton * leftArtRoll, * rightArtRoll;
bool allowedAssembling;
std::multiset<const CArtifactInstance*> artifactsOnAltar; //artifacts id that are technically present in backpack but in GUI are moved to the altar - they'll be omitted in backpack slots
boost::function<void(CArtPlace*)> highlightModeCallback; //if set, clicking on art place doesn't pick artifact but highlights the slot and calls this function
std::function<void(CArtPlace*)> highlightModeCallback; //if set, clicking on art place doesn't pick artifact but highlights the slot and calls this function
void realizeCurrentTransaction(); //calls callback with parameters stored in commonInfo
void artifactMoved(const ArtifactLocation &src, const ArtifactLocation &dst);
@ -1057,7 +1057,7 @@ public:
CGStatusBar * statusBar;
CShipyardWindow(const std::vector<si32> &cost, int state, int boatType, const boost::function<void()> &onBuy);
CShipyardWindow(const std::vector<si32> &cost, int state, int boatType, const std::function<void()> &onBuy);
};
/// Puzzle screen which gets uncovered when you visit obilisks
@ -1099,7 +1099,7 @@ public:
const CArmedInstance *army;//object with army for transforming (hero or town)
const CGHeroInstance *hero;//only if we have hero in town
const CGTownInstance *town;//market, town garrison is used if hero == NULL
const CGTownInstance *town;//market, town garrison is used if hero == nullptr
std::vector<CItem*> items;
CAdventureMapButton *all, *convert, *cancel;

20
client/Graphics.cpp
View File

@ -42,7 +42,7 @@ using namespace CSDL_Ext;
*
*/
Graphics * graphics = NULL;
Graphics * graphics = nullptr;
void Graphics::loadPaletteAndColors()
{
@ -121,12 +121,12 @@ void Graphics::initializeBattleGraphics()
Graphics::Graphics()
{
std::vector<Task> tasks; //preparing list of graphics to load
tasks += boost::bind(&Graphics::loadFonts,this);
tasks += boost::bind(&Graphics::loadPaletteAndColors,this);
tasks += boost::bind(&Graphics::loadHeroFlags,this);
tasks += boost::bind(&Graphics::initializeBattleGraphics,this);
tasks += boost::bind(&Graphics::loadErmuToPicture,this);
tasks += boost::bind(&Graphics::initializeImageLists,this);
tasks += std::bind(&Graphics::loadFonts,this);
tasks += std::bind(&Graphics::loadPaletteAndColors,this);
tasks += std::bind(&Graphics::loadHeroFlags,this);
tasks += std::bind(&Graphics::initializeBattleGraphics,this);
tasks += std::bind(&Graphics::loadErmuToPicture,this);
tasks += std::bind(&Graphics::initializeImageLists,this);
tasks += GET_DEF_ESS(resources32,"RESOURCE.DEF");
tasks += GET_DEF_ESS(spellscr,"SPELLSCR.DEF");
tasks += GET_DEF_ESS(heroMoveArrows,"ADAG.DEF");
@ -199,7 +199,7 @@ CDefEssential * Graphics::loadHeroAnim( const std::string &name, const std::vect
return anim;
}
void Graphics::loadHeroFlags(std::pair<std::vector<CDefEssential *> Graphics::*, std::vector<const char *> > &pr, bool mode)
void Graphics::loadHeroFlagsDetail(std::pair<std::vector<CDefEssential *> Graphics::*, std::vector<const char *> > &pr, bool mode)
{
for(int i=0;i<8;i++)
(this->*pr.first).push_back(CDefHandler::giveDefEss(pr.second[i]));
@ -273,7 +273,7 @@ void Graphics::loadHeroFlags()
boost::thread_group grupa;
for(int g=3; g>=0; --g)
{
grupa.create_thread(boost::bind(&Graphics::loadHeroFlags,this,boost::ref(pr[g]),true));
grupa.create_thread(std::bind(&Graphics::loadHeroFlagsDetail, this, std::ref(pr[g]), true));
}
grupa.join_all();
logGlobal->infoStream() << "Loading and transforming heroes' flags: "<<th.getDiff();
@ -285,7 +285,7 @@ void Graphics::blueToPlayersAdv(SDL_Surface * sur, PlayerColor player)
// return;
if(sur->format->BitsPerPixel == 8)
{
SDL_Color *palette = NULL;
SDL_Color *palette = nullptr;
if(player < PlayerColor::PLAYER_LIMIT)
{
palette = playerColorPalette + 32*player.getNum();

2
client/Graphics.h
View File

@ -74,7 +74,7 @@ public:
void initializeBattleGraphics();
void loadPaletteAndColors();
void loadHeroFlags();
void loadHeroFlags(std::pair<std::vector<CDefEssential *> Graphics::*, std::vector<const char *> > &pr, bool mode);
void loadHeroFlagsDetail(std::pair<std::vector<CDefEssential *> Graphics::*, std::vector<const char *> > &pr, bool mode);
void loadHeroAnims();
CDefEssential * loadHeroAnim(const std::string &name, const std::vector<std::pair<int,int> > &rotations);
void loadErmuToPicture();

6
client/NetPacksClient.cpp
View File

@ -476,7 +476,7 @@ void SetHeroesInTown::applyCl( CClient *cl )
// void SetHeroArtifacts::applyCl( CClient *cl )
// {
// // CGHeroInstance *h = GS(cl)->getHero(hid);
// // CGameInterface *player = (vstd::contains(cl->playerint,h->tempOwner) ? cl->playerint[h->tempOwner] : NULL);
// // CGameInterface *player = (vstd::contains(cl->playerint,h->tempOwner) ? cl->playerint[h->tempOwner] : nullptr);
// // if(!player)
// // return;
//
@ -632,7 +632,7 @@ void BattleSetActiveStack::applyCl( CClient *cl )
playerToCall = activated->owner;
}
if( vstd::contains(cl->battleints, playerToCall) )
boost::thread( boost::bind(&CClient::waitForMoveAndSend, cl, playerToCall) );
boost::thread( std::bind(&CClient::waitForMoveAndSend, cl, playerToCall) );
}
void BattleTriggerEffect::applyCl(CClient * cl)
@ -924,7 +924,7 @@ void SetAvailableArtifacts::applyCl(CClient *cl)
if(id < 0) //artifact merchants globally
{
for(auto i=cl->playerint.begin(); i!=cl->playerint.end(); i++)
i->second->availableArtifactsChanged(NULL);
i->second->availableArtifactsChanged(nullptr);
}
else
{

14
client/battle/CBattleAnimations.cpp
View File

@ -26,7 +26,7 @@ void CBattleAnimation::endAnim()
{
if(it->first == this)
{
it->first = NULL;
it->first = nullptr;
}
}
@ -97,7 +97,7 @@ CAttackAnimation::CAttackAnimation(CBattleInterface *_owner, const CStack *attac
: CBattleStackAnimation(_owner, attacker), dest(_dest), attackedStack(defender), attackingStack(attacker)
{
assert(attackingStack && "attackingStack is NULL in CBattleAttack::CBattleAttack !\n");
assert(attackingStack && "attackingStack is nullptr in CBattleAttack::CBattleAttack !\n");
bool isCatapultAttack = attackingStack->hasBonusOfType(Bonus::CATAPULT)
&& owner->curInt->cb->battleHexToWallPart(_dest) >= 0;
@ -120,7 +120,7 @@ bool CDefenceAnimation::init()
// return false;
//}
if(attacker == NULL && owner->battleEffects.size() > 0)
if(attacker == nullptr && owner->battleEffects.size() > 0)
return false;
ui32 lowestMoveID = owner->animIDhelper + 5;
@ -134,7 +134,7 @@ bool CDefenceAnimation::init()
if(attAnim && attAnim->stack->ID != stack->ID)
continue;
if(attacker != NULL)
if(attacker != nullptr)
{
int attackerAnimType = owner->creAnims[attacker->ID]->getType();
if( ( attackerAnimType == CCreatureAnim::ATTACK_UP ||
@ -222,7 +222,7 @@ void CDefenceAnimation::endAnim()
//printing info to console
//if(attacker!=NULL)
//if(attacker!=nullptr)
// owner->printConsoleAttacked(stack, dmg, amountKilled, attacker);
//const CStack * attacker = owner->curInt->cb->battleGetStackByID(IDby, false);
@ -604,7 +604,7 @@ CReverseAnimation::CReverseAnimation(CBattleInterface * _owner, const CStack * s
bool CReverseAnimation::init()
{
if(myAnim() == NULL || myAnim()->getType() == CCreatureAnim::DEATH)
if(myAnim() == nullptr || myAnim()->getType() == CCreatureAnim::DEATH)
{
endAnim();
@ -978,7 +978,7 @@ bool CSpellEffectAnimation::init()
}
// Correction for 2-hex creatures.
if (destStack != NULL && destStack->doubleWide())
if (destStack != nullptr && destStack->doubleWide())
be.x += (destStack->attackerOwned ? -1 : 1)*tilePos.w/2;
owner->battleEffects.push_back(be);

124
client/battle/CBattleInterface.cpp
View File

@ -92,11 +92,11 @@ CBattleInterface::CBattleInterface(const CCreatureSet * army1, const CCreatureSe
CGHeroInstance *hero1, CGHeroInstance *hero2,
const SDL_Rect & myRect,
shared_ptr<CPlayerInterface> att, shared_ptr<CPlayerInterface> defen)
: background(nullptr), queue(NULL), attackingHeroInstance(hero1), defendingHeroInstance(hero2), animCount(0),
activeStack(NULL), stackToActivate(NULL), selectedStack(NULL), mouseHoveredStack(-1), lastMouseHoveredStackAnimationTime(-1), previouslyHoveredHex(-1),
currentlyHoveredHex(-1), attackingHex(-1), stackCanCastSpell(false), creatureCasting(false), spellDestSelectMode(false), spellSelMode(NO_LOCATION), spellToCast(NULL), sp(NULL),
siegeH(NULL), attackerInt(att), defenderInt(defen), curInt(att), animIDhelper(0),
givenCommand(NULL), myTurn(false), resWindow(NULL), moveStarted(false), moveSh(-1), bresult(NULL)
: background(nullptr), queue(nullptr), attackingHeroInstance(hero1), defendingHeroInstance(hero2), animCount(0),
activeStack(nullptr), stackToActivate(nullptr), selectedStack(nullptr), mouseHoveredStack(-1), lastMouseHoveredStackAnimationTime(-1), previouslyHoveredHex(-1),
currentlyHoveredHex(-1), attackingHex(-1), stackCanCastSpell(false), creatureCasting(false), spellDestSelectMode(false), spellSelMode(NO_LOCATION), spellToCast(nullptr), sp(nullptr),
siegeH(nullptr), attackerInt(att), defenderInt(defen), curInt(att), animIDhelper(0),
givenCommand(nullptr), myTurn(false), resWindow(nullptr), moveStarted(false), moveSh(-1), bresult(nullptr)
{
OBJ_CONSTRUCTION;
@ -109,7 +109,7 @@ CBattleInterface::CBattleInterface(const CCreatureSet * army1, const CCreatureSe
animsAreDisplayed.setn(false);
pos = myRect;
strongInterest = true;
givenCommand = new CondSh<BattleAction *>(NULL);
givenCommand = new CondSh<BattleAction *>(nullptr);
if(attackerInt && attackerInt->cb->battleGetTacticDist()) //hot-seat -> check tactics for both players (defender may be local human)
tacticianInterface = attackerInt;
@ -215,19 +215,19 @@ CBattleInterface::CBattleInterface(const CCreatureSet * army1, const CCreatureSe
// blitAt(menu, pos.x, 556 + pos.y);
//preparing buttons and console
bOptions = new CAdventureMapButton (CGI->generaltexth->zelp[381].first, CGI->generaltexth->zelp[381].second, boost::bind(&CBattleInterface::bOptionsf,this), 3, 561, "icm003.def", SDLK_o);
bSurrender = new CAdventureMapButton (CGI->generaltexth->zelp[379].first, CGI->generaltexth->zelp[379].second, boost::bind(&CBattleInterface::bSurrenderf,this), 54, 561, "icm001.def", SDLK_s);
bFlee = new CAdventureMapButton (CGI->generaltexth->zelp[380].first, CGI->generaltexth->zelp[380].second, boost::bind(&CBattleInterface::bFleef,this), 105, 561, "icm002.def", SDLK_r);
bOptions = new CAdventureMapButton (CGI->generaltexth->zelp[381].first, CGI->generaltexth->zelp[381].second, std::bind(&CBattleInterface::bOptionsf,this), 3, 561, "icm003.def", SDLK_o);
bSurrender = new CAdventureMapButton (CGI->generaltexth->zelp[379].first, CGI->generaltexth->zelp[379].second, std::bind(&CBattleInterface::bSurrenderf,this), 54, 561, "icm001.def", SDLK_s);
bFlee = new CAdventureMapButton (CGI->generaltexth->zelp[380].first, CGI->generaltexth->zelp[380].second, std::bind(&CBattleInterface::bFleef,this), 105, 561, "icm002.def", SDLK_r);
bFlee->block(!curInt->cb->getMyColor() || !curInt->cb->battleCanFlee());
bSurrender->block(!curInt->cb->getMyColor() || curInt->cb->battleGetSurrenderCost() < 0);
bAutofight = new CAdventureMapButton (CGI->generaltexth->zelp[382].first, CGI->generaltexth->zelp[382].second, boost::bind(&CBattleInterface::bAutofightf,this), 157, 561, "icm004.def", SDLK_a);
bSpell = new CAdventureMapButton (CGI->generaltexth->zelp[385].first, CGI->generaltexth->zelp[385].second, boost::bind(&CBattleInterface::bSpellf,this), 645, 561, "icm005.def", SDLK_c);
bAutofight = new CAdventureMapButton (CGI->generaltexth->zelp[382].first, CGI->generaltexth->zelp[382].second, std::bind(&CBattleInterface::bAutofightf,this), 157, 561, "icm004.def", SDLK_a);
bSpell = new CAdventureMapButton (CGI->generaltexth->zelp[385].first, CGI->generaltexth->zelp[385].second, std::bind(&CBattleInterface::bSpellf,this), 645, 561, "icm005.def", SDLK_c);
bSpell->block(true);
bWait = new CAdventureMapButton (CGI->generaltexth->zelp[386].first, CGI->generaltexth->zelp[386].second, boost::bind(&CBattleInterface::bWaitf,this), 696, 561, "icm006.def", SDLK_w);
bDefence = new CAdventureMapButton (CGI->generaltexth->zelp[387].first, CGI->generaltexth->zelp[387].second, boost::bind(&CBattleInterface::bDefencef,this), 747, 561, "icm007.def", SDLK_d);
bWait = new CAdventureMapButton (CGI->generaltexth->zelp[386].first, CGI->generaltexth->zelp[386].second, std::bind(&CBattleInterface::bWaitf,this), 696, 561, "icm006.def", SDLK_w);
bDefence = new CAdventureMapButton (CGI->generaltexth->zelp[387].first, CGI->generaltexth->zelp[387].second, std::bind(&CBattleInterface::bDefencef,this), 747, 561, "icm007.def", SDLK_d);
bDefence->assignedKeys.insert(SDLK_SPACE);
bConsoleUp = new CAdventureMapButton (std::string(), std::string(), boost::bind(&CBattleInterface::bConsoleUpf,this), 624, 561, "ComSlide.def", SDLK_UP);
bConsoleDown = new CAdventureMapButton (std::string(), std::string(), boost::bind(&CBattleInterface::bConsoleDownf,this), 624, 580, "ComSlide.def", SDLK_DOWN);
bConsoleUp = new CAdventureMapButton (std::string(), std::string(), std::bind(&CBattleInterface::bConsoleUpf,this), 624, 561, "ComSlide.def", SDLK_UP);
bConsoleDown = new CAdventureMapButton (std::string(), std::string(), std::bind(&CBattleInterface::bConsoleDownf,this), 624, 580, "ComSlide.def", SDLK_DOWN);
bConsoleDown->setOffset(2);
console = new CBattleConsole();
console->pos.x += 211;
@ -236,8 +236,8 @@ CBattleInterface::CBattleInterface(const CCreatureSet * army1, const CCreatureSe
console->pos.h = 38;
if(tacticsMode)
{
btactNext = new CAdventureMapButton(std::string(), std::string(), boost::bind(&CBattleInterface::bTacticNextStack,this, (CStack*)NULL), 213, 560, "icm011.def", SDLK_SPACE);
btactEnd = new CAdventureMapButton(std::string(), std::string(), boost::bind(&CBattleInterface::bEndTacticPhase,this), 419, 560, "icm012.def", SDLK_RETURN);
btactNext = new CAdventureMapButton(std::string(), std::string(), std::bind(&CBattleInterface::bTacticNextStack,this, (CStack*)nullptr), 213, 560, "icm011.def", SDLK_SPACE);
btactEnd = new CAdventureMapButton(std::string(), std::string(), std::bind(&CBattleInterface::bEndTacticPhase,this), 419, 560, "icm012.def", SDLK_RETURN);
bDefence->block(true);
bWait->block(true);
menu = BitmapHandler::loadBitmap("COPLACBR.BMP");
@ -245,7 +245,7 @@ CBattleInterface::CBattleInterface(const CCreatureSet * army1, const CCreatureSe
else
{
menu = BitmapHandler::loadBitmap("CBAR.BMP");
btactEnd = btactNext = NULL;
btactEnd = btactNext = nullptr;
}
graphics->blueToPlayersAdv(menu, curInt->playerID);
@ -258,12 +258,12 @@ CBattleInterface::CBattleInterface(const CCreatureSet * army1, const CCreatureSe
else
battleImage = hero1->type->heroClass->imageBattleMale;
attackingHero = new CBattleHero(battleImage, false, hero1->tempOwner, hero1->tempOwner == curInt->playerID ? hero1 : NULL, this);
attackingHero = new CBattleHero(battleImage, false, hero1->tempOwner, hero1->tempOwner == curInt->playerID ? hero1 : nullptr, this);
attackingHero->pos = genRect(attackingHero->dh->ourImages[0].bitmap->h, attackingHero->dh->ourImages[0].bitmap->w, pos.x - 43, pos.y - 19);
}
else
{
attackingHero = NULL;
attackingHero = nullptr;
}
if(hero2) // defending hero
{
@ -273,12 +273,12 @@ CBattleInterface::CBattleInterface(const CCreatureSet * army1, const CCreatureSe
else
battleImage = hero2->type->heroClass->imageBattleMale;
defendingHero = new CBattleHero(battleImage, true, hero2->tempOwner, hero2->tempOwner == curInt->playerID ? hero2 : NULL, this);
defendingHero = new CBattleHero(battleImage, true, hero2->tempOwner, hero2->tempOwner == curInt->playerID ? hero2 : nullptr, this);
defendingHero->pos = genRect(defendingHero->dh->ourImages[0].bitmap->h, defendingHero->dh->ourImages[0].bitmap->w, pos.x + 693, pos.y - 19);
}
else
{
defendingHero = NULL;
defendingHero = nullptr;
}
//preparing cells and hexes
@ -402,7 +402,7 @@ CBattleInterface::CBattleInterface(const CCreatureSet * army1, const CCreatureSe
CBattleInterface::~CBattleInterface()
{
curInt->battleInt = NULL;
curInt->battleInt = nullptr;
givenCommand->cond.notify_all(); //that two lines should make any activeStack waiting thread to finish
@ -589,7 +589,7 @@ void CBattleInterface::show(SDL_Surface * to)
SDL_SetClipRect(to, &pos);
//printing background and hexes
if(activeStack != NULL && creAnims[activeStack->ID]->getType() != CCreatureAnim::MOVING) //show everything with range
if(activeStack != nullptr && creAnims[activeStack->ID]->getType() != CCreatureAnim::MOVING) //show everything with range
{
blitAt(backgroundWithHexes, pos.x, pos.y, to);
}
@ -599,7 +599,7 @@ void CBattleInterface::show(SDL_Surface * to)
blitAt(background, pos.x, pos.y, to);
if(settings["battle"]["cellBorders"].Bool())
{
CSDL_Ext::blit8bppAlphaTo24bpp(cellBorders, NULL, to, &pos);
CSDL_Ext::blit8bppAlphaTo24bpp(cellBorders, nullptr, to, &pos);
}
//Blit absolute obstacles
BOOST_FOREACH(auto &oi, curInt->cb->battleGetAllObstacles())
@ -644,7 +644,7 @@ void CBattleInterface::show(SDL_Surface * to)
int x = 14 + ((shadedHex/GameConstants::BFIELD_WIDTH)%2==0 ? 22 : 0) + 44*(shadedHex%GameConstants::BFIELD_WIDTH) + pos.x;
int y = 86 + 42 * (shadedHex/GameConstants::BFIELD_WIDTH) + pos.y;
SDL_Rect temp_rect = genRect(cellShade->h, cellShade->w, x, y);
CSDL_Ext::blit8bppAlphaTo24bpp(cellShade, NULL, to, &temp_rect);
CSDL_Ext::blit8bppAlphaTo24bpp(cellShade, nullptr, to, &temp_rect);
}
}
}
@ -658,12 +658,12 @@ void CBattleInterface::show(SDL_Surface * to)
int x = 14 + ((hex/GameConstants::BFIELD_WIDTH)%2==0 ? 22 : 0) + 44*(hex%GameConstants::BFIELD_WIDTH) + pos.x;
int y = 86 + 42 * (hex/GameConstants::BFIELD_WIDTH) + pos.y;
SDL_Rect temp_rect = genRect(cellShade->h, cellShade->w, x, y);
CSDL_Ext::blit8bppAlphaTo24bpp(cellShade, NULL, to, &temp_rect);
CSDL_Ext::blit8bppAlphaTo24bpp(cellShade, nullptr, to, &temp_rect);
}
}
//patch by ench0: show enemy stack movement shadow
// activeStack == NULL means it is opponent's turn...
// activeStack == nullptr means it is opponent's turn...
if(activeStack && settings["battle"]["stackRange"].Bool())
{
// display the movement shadow of the stack at b (i.e. stack under mouse)
@ -676,7 +676,7 @@ void CBattleInterface::show(SDL_Surface * to)
int x = 14 + ((hex / GameConstants::BFIELD_WIDTH ) % 2 == 0 ? 22 : 0) + 44 * (hex % GameConstants::BFIELD_WIDTH) + pos.x;
int y = 86 + 42 * (hex / GameConstants::BFIELD_WIDTH) + pos.y;
SDL_Rect temp_rect = genRect (cellShade->h, cellShade->w, x, y);
CSDL_Ext::blit8bppAlphaTo24bpp (cellShade, NULL, to, &temp_rect);
CSDL_Ext::blit8bppAlphaTo24bpp (cellShade, nullptr, to, &temp_rect);
}
}
}
@ -685,7 +685,7 @@ void CBattleInterface::show(SDL_Surface * to)
int x = 14 + ((b/GameConstants::BFIELD_WIDTH)%2==0 ? 22 : 0) + 44*(b%GameConstants::BFIELD_WIDTH) + pos.x;
int y = 86 + 42 * (b/GameConstants::BFIELD_WIDTH) + pos.y;
SDL_Rect temp_rect = genRect(cellShade->h, cellShade->w, x, y);
CSDL_Ext::blit8bppAlphaTo24bpp(cellShade, NULL, to, &temp_rect);
CSDL_Ext::blit8bppAlphaTo24bpp(cellShade, nullptr, to, &temp_rect);
}
}
}
@ -750,7 +750,7 @@ void CBattleInterface::show(SDL_Surface * to)
int preSize = pendingAnims.size();
for(std::list<std::pair<CBattleAnimation *, bool> >::iterator it = pendingAnims.begin(); it != pendingAnims.end(); ++it)
{
if(it->first == NULL)
if(it->first == nullptr)
{
pendingAnims.erase(it);
it = pendingAnims.begin();
@ -767,7 +767,7 @@ void CBattleInterface::show(SDL_Surface * to)
bool changedStack = false;
//activation of next stack
if(pendingAnims.size() == 0 && stackToActivate != NULL)
if(pendingAnims.size() == 0 && stackToActivate != nullptr)
{
activateStack();
changedStack = true;
@ -892,7 +892,7 @@ void CBattleInterface::show(SDL_Surface * to)
{
SDL_Surface * bitmapToBlit = it->anim->ourImages[(it->frame)%it->anim->ourImages.size()].bitmap;
SDL_Rect temp_rect = genRect(bitmapToBlit->h, bitmapToBlit->w, it->x, it->y);
SDL_BlitSurface(bitmapToBlit, NULL, to, &temp_rect);
SDL_BlitSurface(bitmapToBlit, nullptr, to, &temp_rect);
}
}
@ -1228,7 +1228,7 @@ void CBattleInterface::bFleef()
if( curInt->cb->battleCanFlee() )
{
CFunctionList<void()> ony = boost::bind(&CBattleInterface::reallyFlee,this);
CFunctionList<void()> ony = std::bind(&CBattleInterface::reallyFlee,this);
curInt->showYesNoDialog(CGI->generaltexth->allTexts[28], ony, 0, false); //Are you sure you want to retreat?
}
else
@ -1341,7 +1341,7 @@ void CBattleInterface::bWaitf()
if(spellDestSelectMode) //we are casting a spell
return;
if(activeStack != NULL)
if(activeStack != nullptr)
giveCommand(Battle::WAIT,0,activeStack->ID);
}
@ -1350,7 +1350,7 @@ void CBattleInterface::bDefencef()
if(spellDestSelectMode) //we are casting a spell
return;
if(activeStack != NULL)
if(activeStack != nullptr)
giveCommand(Battle::DEFEND,0,activeStack->ID);
}
@ -1422,7 +1422,7 @@ void CBattleInterface::stackRemoved(int stackID)
void CBattleInterface::stackActivated(const CStack * stack) //TODO: check it all before game state is changed due to abilities
{
//givenCommand = NULL;
//givenCommand = nullptr;
stackToActivate = stack;
waitForAnims();
//if(pendingAnims.size() == 0)
@ -1541,14 +1541,14 @@ void CBattleInterface::giveCommand(Battle::ActionType action, BattleHex tile, ui
{
logGlobal->traceStream() << "Setting command for " << (stack ? stack->nodeName() : "hero");
myTurn = false;
activeStack = NULL;
activeStack = nullptr;
givenCommand->setn(ba);
}
else
{
curInt->cb->battleMakeTacticAction(ba);
vstd::clear_pointer(ba);
activeStack = NULL;
activeStack = nullptr;
//next stack will be activated when action ends
}
}
@ -1580,7 +1580,7 @@ const CGHeroInstance * CBattleInterface::getActiveHero()
const CStack * attacker = activeStack;
if (!attacker)
{
return NULL;
return nullptr;
}
if (attacker->attackerOwned)
@ -1601,7 +1601,7 @@ void CBattleInterface::stackIsCatapulting(const CatapultAttack & ca)
for(std::set< std::pair< std::pair< ui8, si16 >, ui8> >::const_iterator it = ca.attackedParts.begin(); it != ca.attackedParts.end(); ++it)
{
const CStack * stack = curInt->cb->battleGetStackByID(ca.attacker);
addNewAnim(new CShootingAnimation(this, stack, it->first.second, NULL, true, it->second));
addNewAnim(new CShootingAnimation(this, stack, it->first.second, nullptr, true, it->second));
SDL_FreeSurface(siegeH->walls[it->first.first + 2]);
siegeH->walls[it->first.first + 2] = BitmapHandler::loadBitmap(
@ -1618,7 +1618,7 @@ void CBattleInterface::battleFinished(const BattleResult& br)
animsAreDisplayed.waitUntil(false);
}
displayBattleFinished();
activeStack = NULL;
activeStack = nullptr;
}
void CBattleInterface::displayBattleFinished()
@ -1635,7 +1635,7 @@ void CBattleInterface::spellCast( const BattleSpellCast * sc )
const CSpell &spell = *CGI->spellh->spells[sc->id];
//spell opening battle is cast when no stack is active
if(sc->castedByHero && ( activeStack == NULL || sc->side == !activeStack->attackerOwned) )
if(sc->castedByHero && ( activeStack == nullptr || sc->side == !activeStack->attackerOwned) )
bSpell->block(true);
std::vector< std::string > anims; //for magic arrow and ice bolt
@ -1931,7 +1931,7 @@ void CBattleInterface::battleStacksEffectsSet(const SetStackEffect & sse)
}
if (activeStack != NULL) //it can be -1 when a creature casts effect
if (activeStack != nullptr) //it can be -1 when a creature casts effect
{
redrawBackgroundWithHexes(activeStack);
}
@ -2052,7 +2052,7 @@ int CBattleInterface::getAnimSpeed() const
void CBattleInterface::activateStack()
{
activeStack = stackToActivate;
stackToActivate = NULL;
stackToActivate = nullptr;
const CStack *s = activeStack;
myTurn = true;
@ -2067,7 +2067,7 @@ void CBattleInterface::activateStack()
ESpellCastProblem::ESpellCastProblem spellcastingProblem;
bool canCastSpells = curInt->cb->battleCanCastSpell(&spellcastingProblem);
bSpell->block(!canCastSpells && spellcastingProblem != ESpellCastProblem::MAGIC_IS_BLOCKED); //if magic is blocked, we leave button active, so the message can be displayed (cf bug #97)
bSurrender->block((curInt == attackerInt ? defendingHeroInstance : attackingHeroInstance) == NULL);
bSurrender->block((curInt == attackerInt ? defendingHeroInstance : attackingHeroInstance) == nullptr);
bFlee->block(!curInt->cb->battleCanFlee());
bSurrender->block(curInt->cb->battleGetSurrenderCost() < 0);
@ -2118,8 +2118,8 @@ void CBattleInterface::endCastingSpell()
assert(spellDestSelectMode);
delete spellToCast;
spellToCast = NULL;
sp = NULL;
spellToCast = nullptr;
sp = nullptr;
spellDestSelectMode = false;
CCS->curh->changeGraphic(ECursor::COMBAT, ECursor::COMBAT_POINTER);
@ -2281,7 +2281,7 @@ void CBattleInterface::showAliveStack(const CStack *stack, SDL_Surface * to)
(moveInside ? amountNormal->w + 10 : 0) * (stack->attackerOwned ? -1 : +1);
int yAdd = 260 + ((stack->attackerOwned || moveInside) ? 0 : -15);
//blitting amount background box
SDL_Surface *amountBG = NULL;
SDL_Surface *amountBG = nullptr;
TBonusListPtr spellEffects = stack->getSpellBonuses();
if(!spellEffects->size())
{
@ -2309,7 +2309,7 @@ void CBattleInterface::showAliveStack(const CStack *stack, SDL_Surface * to)
}
}
SDL_Rect temp_rect = genRect(amountNormal->h, amountNormal->w, creAnims[ID]->pos.x + xAdd, creAnims[ID]->pos.y + yAdd);
SDL_BlitSurface(amountBG, NULL, to, &temp_rect);
SDL_BlitSurface(amountBG, nullptr, to, &temp_rect);
//blitting amount
Point textPos(creAnims[ID]->pos.x + xAdd + 15, creAnims[ID]->pos.y + yAdd + 5);
@ -2363,7 +2363,7 @@ void CBattleInterface::showPieceOfWall(SDL_Surface * to, int hex, const std::vec
if(posToSeek != -1)
{
const CStack *turret = NULL;
const CStack *turret = nullptr;
BOOST_FOREACH(const CStack *s, stacks)
{
@ -2422,7 +2422,7 @@ void CBattleInterface::redrawBackgroundWithHexes(const CStack * activeStack)
}
if(settings["battle"]["cellBorders"].Bool())
CSDL_Ext::blit8bppAlphaTo24bpp(cellBorders, NULL, backgroundWithHexes, NULL);
CSDL_Ext::blit8bppAlphaTo24bpp(cellBorders, nullptr, backgroundWithHexes, nullptr);
if(settings["battle"]["stackRange"].Bool())
{
@ -2435,7 +2435,7 @@ void CBattleInterface::redrawBackgroundWithHexes(const CStack * activeStack)
int x = 58 + (i%2==0 ? 22 : 0) + 44*j;
int y = 86 + 42 * i;
SDL_Rect temp_rect = genRect(cellShade->h, cellShade->w, x, y);
CSDL_Ext::blit8bppAlphaTo24bpp(cellShade, NULL, backgroundWithHexes, &temp_rect);
CSDL_Ext::blit8bppAlphaTo24bpp(cellShade, nullptr, backgroundWithHexes, &temp_rect);
}
}
}
@ -2468,7 +2468,7 @@ void CBattleInterface::printConsoleAttacked( const CStack * defender, int dmg, i
void CBattleInterface::projectileShowHelper(SDL_Surface * to)
{
if(to == NULL)
if(to == nullptr)
to = screen;
std::list< std::list<ProjectileInfo>::iterator > toBeDeleted;
for(std::list<ProjectileInfo>::iterator it=projectiles.begin(); it!=projectiles.end(); ++it)
@ -2493,12 +2493,12 @@ void CBattleInterface::projectileShowHelper(SDL_Surface * to)
if(it->reverse)
{
SDL_Surface * rev = CSDL_Ext::rotate01(idToProjectile[it->creID]->ourImages[it->frameNum].bitmap);
CSDL_Ext::blit8bppAlphaTo24bpp(rev, NULL, to, &dst);
CSDL_Ext::blit8bppAlphaTo24bpp(rev, nullptr, to, &dst);
SDL_FreeSurface(rev);
}
else
{
CSDL_Ext::blit8bppAlphaTo24bpp(idToProjectile[it->creID]->ourImages[it->frameNum].bitmap, NULL, to, &dst);
CSDL_Ext::blit8bppAlphaTo24bpp(idToProjectile[it->creID]->ourImages[it->frameNum].bitmap, nullptr, to, &dst);
}
// Update projectile
@ -2719,7 +2719,7 @@ void CBattleInterface::waitForAnims()
void CBattleInterface::bEndTacticPhase()
{
activeStack = NULL;
activeStack = nullptr;
btactEnd->block(true);
tacticsMode = false;
}
@ -2729,7 +2729,7 @@ static bool immobile(const CStack *s)
return !s->Speed(0, true); //should bound stacks be immobile?
}
void CBattleInterface::bTacticNextStack(const CStack *current /*= NULL*/)
void CBattleInterface::bTacticNextStack(const CStack *current /*= nullptr*/)
{
if(!current)
current = activeStack;
@ -3103,7 +3103,7 @@ void CBattleInterface::handleHex(BattleHex myNumber, int eventType)
isCastingPossible = true;
break;
case RANDOM_GENIE_SPELL: //we assume that teleport / sacrifice will never be avaliable as random spell
sp = NULL;
sp = nullptr;
consoleMsg = boost::str(boost::format(CGI->generaltexth->allTexts[301]) % shere->getName()); //Cast a spell on %
creatureCasting = true;
isCastingPossible = true;
@ -3147,7 +3147,7 @@ void CBattleInterface::handleHex(BattleHex myNumber, int eventType)
realizeAction = [=]{ GH.pushInt(createCreWindow(shere, true)); };
//setting console text
const time_t curTime = time(NULL);
const time_t curTime = time(nullptr);
CCreatureAnimation *hoveredStackAnim = creAnims[shere->ID];
if (shere->ID != mouseHoveredStack
@ -3245,7 +3245,7 @@ void CBattleInterface::handleHex(BattleHex myNumber, int eventType)
curInt->cb->battleMakeAction(spellToCast);
endCastingSpell();
}
selectedStack = NULL;
selectedStack = nullptr;
}
};
}
@ -3271,7 +3271,7 @@ bool CBattleInterface::isCastingPossibleHere (const CStack * sactive, const CSta
else //hero casting
spellID = spellToCast->additionalInfo;
sp = NULL;
sp = nullptr;
if (spellID >= 0)
sp = CGI->spellh->spells[spellID];

8
client/battle/CBattleInterface.h
View File

@ -124,8 +124,8 @@ private:
std::map< int, bool > creDir; // <creatureID, if false reverse creature's animation> //TODO: move it to battle callback
ui8 animCount;
const CStack * activeStack; //number of active stack; NULL - no one
const CStack * stackToActivate; //when animation is playing, we should wait till the end to make the next stack active; NULL of none
const CStack * activeStack; //number of active stack; nullptr - no one
const CStack * stackToActivate; //when animation is playing, we should wait till the end to make the next stack active; nullptr of none
const CStack * selectedStack; //for Teleport / Sacrifice
void activateStack(); //sets activeStack to stackToActivate etc.
int mouseHoveredStack; //stack hovered by mouse; if -1 -> none
@ -220,7 +220,7 @@ public:
std::vector<CClickableHex*> bfield; //11 lines, 17 hexes on each
//std::vector< CBattleObstacle * > obstacles; //vector of obstacles on the battlefield
SDL_Surface * cellBorder, * cellShade;
CondSh<BattleAction *> *givenCommand; //data != NULL if we have i.e. moved current unit
CondSh<BattleAction *> *givenCommand; //data != nullptr if we have i.e. moved current unit
bool myTurn; //if true, interface is active (commands can be ordered)
CBattleResultWindow * resWindow; //window of end of battle
@ -241,7 +241,7 @@ public:
void bDefencef();
void bConsoleUpf();
void bConsoleDownf();
void bTacticNextStack(const CStack *current = NULL);
void bTacticNextStack(const CStack *current = nullptr);
void bEndTacticPhase();
//end of button handle funcs
//napisz tu klase odpowiadajaca za wyswietlanie bitwy i obsluge uzytkownika, polecenia ma przekazywac callbackiem

28
client/battle/CBattleInterfaceClasses.cpp
View File

@ -134,13 +134,13 @@ void CBattleHero::show(SDL_Surface * to)
}
CSDL_Ext::blit8bppAlphaTo24bpp(
flag->ourImages[flagAnim].bitmap,
NULL,
nullptr,
screen,
&temp_rect);
//animation of hero
SDL_Rect rect = pos;
CSDL_Ext::blit8bppAlphaTo24bpp(dh->ourImages[currentFrame].bitmap, NULL, to, &rect);
CSDL_Ext::blit8bppAlphaTo24bpp(dh->ourImages[currentFrame].bitmap, nullptr, to, &rect);
if ( ++animCount == 4 )
{
@ -165,7 +165,7 @@ void CBattleHero::clickLeft(tribool down, bool previousState)
if(myOwner->spellDestSelectMode) //we are casting a spell
return;
if(!down && myHero != NULL && myOwner->myTurn && myOwner->curInt->cb->battleCanCastSpell()) //check conditions
if(!down && myHero != nullptr && myOwner->myTurn && myOwner->curInt->cb->battleCanCastSpell()) //check conditions
{
for(int it=0; it<GameConstants::BFIELD_SIZE; ++it) //do nothing when any hex is hovered - hero's animation overlaps battlefield
{
@ -248,11 +248,11 @@ CBattleOptionsWindow::CBattleOptionsWindow(const SDL_Rect & position, CBattleInt
background = new CPicture("comopbck.bmp");
background->colorize(owner->curInt->playerID);
viewGrid = new CHighlightableButton(boost::bind(&CBattleInterface::setPrintCellBorders, owner, true), boost::bind(&CBattleInterface::setPrintCellBorders, owner, false), boost::assign::map_list_of(0,CGI->generaltexth->zelp[427].first)(3,CGI->generaltexth->zelp[427].first), CGI->generaltexth->zelp[427].second, false, "sysopchk.def", NULL, 25, 56, false);
viewGrid = new CHighlightableButton(std::bind(&CBattleInterface::setPrintCellBorders, owner, true), std::bind(&CBattleInterface::setPrintCellBorders, owner, false), boost::assign::map_list_of(0,CGI->generaltexth->zelp[427].first)(3,CGI->generaltexth->zelp[427].first), CGI->generaltexth->zelp[427].second, false, "sysopchk.def", nullptr, 25, 56, false);
viewGrid->select(settings["battle"]["cellBorders"].Bool());
movementShadow = new CHighlightableButton(boost::bind(&CBattleInterface::setPrintStackRange, owner, true), boost::bind(&CBattleInterface::setPrintStackRange, owner, false), boost::assign::map_list_of(0,CGI->generaltexth->zelp[428].first)(3,CGI->generaltexth->zelp[428].first), CGI->generaltexth->zelp[428].second, false, "sysopchk.def", NULL, 25, 89, false);
movementShadow = new CHighlightableButton(std::bind(&CBattleInterface::setPrintStackRange, owner, true), std::bind(&CBattleInterface::setPrintStackRange, owner, false), boost::assign::map_list_of(0,CGI->generaltexth->zelp[428].first)(3,CGI->generaltexth->zelp[428].first), CGI->generaltexth->zelp[428].second, false, "sysopchk.def", nullptr, 25, 89, false);
movementShadow->select(settings["battle"]["stackRange"].Bool());
mouseShadow = new CHighlightableButton(boost::bind(&CBattleInterface::setPrintMouseShadow, owner, true), boost::bind(&CBattleInterface::setPrintMouseShadow, owner, false), boost::assign::map_list_of(0,CGI->generaltexth->zelp[429].first)(3,CGI->generaltexth->zelp[429].first), CGI->generaltexth->zelp[429].second, false, "sysopchk.def", NULL, 25, 122, false);
mouseShadow = new CHighlightableButton(std::bind(&CBattleInterface::setPrintMouseShadow, owner, true), std::bind(&CBattleInterface::setPrintMouseShadow, owner, false), boost::assign::map_list_of(0,CGI->generaltexth->zelp[429].first)(3,CGI->generaltexth->zelp[429].first), CGI->generaltexth->zelp[429].second, false, "sysopchk.def", nullptr, 25, 122, false);
mouseShadow->select(settings["battle"]["mouseShadow"].Bool());
animSpeeds = new CHighlightableButtonsGroup(0);
@ -260,12 +260,12 @@ CBattleOptionsWindow::CBattleOptionsWindow(const SDL_Rect & position, CBattleInt
animSpeeds->addButton(boost::assign::map_list_of(0,CGI->generaltexth->zelp[423].first),CGI->generaltexth->zelp[423].second, "sysob10.def", 92, 225, 2);
animSpeeds->addButton(boost::assign::map_list_of(0,CGI->generaltexth->zelp[424].first),CGI->generaltexth->zelp[424].second, "sysob11.def",156, 225, 4);
animSpeeds->select(owner->getAnimSpeed(), 1);
animSpeeds->onChange = boost::bind(&CBattleInterface::setAnimSpeed, owner, _1);
animSpeeds->onChange = std::bind(&CBattleInterface::setAnimSpeed, owner, _1);
setToDefault = new CAdventureMapButton (CGI->generaltexth->zelp[393], boost::bind(&CBattleOptionsWindow::bDefaultf,this), 246, 359, "codefaul.def");
setToDefault = new CAdventureMapButton (CGI->generaltexth->zelp[393], std::bind(&CBattleOptionsWindow::bDefaultf,this), 246, 359, "codefaul.def");
setToDefault->swappedImages = true;
setToDefault->update();
exit = new CAdventureMapButton (CGI->generaltexth->zelp[392], boost::bind(&CBattleOptionsWindow::bExitf,this), 357, 359, "soretrn.def",SDLK_RETURN);
exit = new CAdventureMapButton (CGI->generaltexth->zelp[392], std::bind(&CBattleOptionsWindow::bExitf,this), 357, 359, "soretrn.def",SDLK_RETURN);
exit->swappedImages = true;
exit->update();
@ -312,7 +312,7 @@ CBattleResultWindow::CBattleResultWindow(const BattleResult &br, const SDL_Rect
CPicture * bg = new CPicture("CPRESULT");
bg->colorize(owner.playerID);
exit = new CAdventureMapButton ("", "", boost::bind(&CBattleResultWindow::bExitf,this), 384, 505, "iok6432.def", SDLK_RETURN);
exit = new CAdventureMapButton ("", "", std::bind(&CBattleResultWindow::bExitf,this), 384, 505, "iok6432.def", SDLK_RETURN);
exit->borderColor = Colors::METALLIC_GOLD;
exit->borderEnabled = true;
@ -531,7 +531,7 @@ void CClickableHex::hover(bool on)
}
}
CClickableHex::CClickableHex() : setAlterText(false), myNumber(-1), accessible(true), hovered(false), strictHovered(false), myInterface(NULL)
CClickableHex::CClickableHex() : setAlterText(false), myNumber(-1), accessible(true), hovered(false), strictHovered(false), myInterface(nullptr)
{
addUsedEvents(LCLICK | RCLICK | HOVER | MOVE);
}
@ -553,7 +553,7 @@ void CClickableHex::mouseMoved(const SDL_MouseMotionEvent &sEvent)
if(hovered && strictHovered) //print attacked creature to console
{
const CStack * attackedStack = myInterface->curInt->cb->battleGetStackByPos(myNumber);
if(myInterface->console->alterTxt.size() == 0 &&attackedStack != NULL &&
if(myInterface->console->alterTxt.size() == 0 &&attackedStack != nullptr &&
attackedStack->owner != myInterface->curInt->playerID &&
attackedStack->alive())
{
@ -582,7 +582,7 @@ void CClickableHex::clickLeft(tribool down, bool previousState)
void CClickableHex::clickRight(tribool down, bool previousState)
{
const CStack * myst = myInterface->curInt->cb->battleGetStackByPos(myNumber); //stack info
if(hovered && strictHovered && myst!=NULL)
if(hovered && strictHovered && myst!=nullptr)
{
if(!myst->alive()) return;
@ -616,7 +616,7 @@ CStackQueue::CStackQueue(bool Embedded, CBattleInterface * _owner)
OBJ_CONSTRUCTION_CAPTURING_ALL;
if(embedded)
{
bg = NULL;
bg = nullptr;
pos.w = QUEUE_SIZE * 37;
pos.h = 46;
pos.x = screen->w/2 - pos.w/2;

2
client/battle/CCreatureAnimation.cpp
View File

@ -163,7 +163,7 @@ void CCreatureAnimation::playOnce( CCreatureAnim::EAnimType type )
template<int bpp>
int CCreatureAnimation::nextFrameT(SDL_Surface * dest, int x, int y, bool attacker, ui8 animCount, bool IncrementFrame /*= true*/, bool yellowBorder /*= false*/, bool blueBorder /*= false*/, SDL_Rect * destRect /*= NULL*/)
int CCreatureAnimation::nextFrameT(SDL_Surface * dest, int x, int y, bool attacker, ui8 animCount, bool IncrementFrame /*= true*/, bool yellowBorder /*= false*/, bool blueBorder /*= false*/, SDL_Rect * destRect /*= nullptr*/)
{
//increasing frame number
int SIndex = curFrame;

6
client/battle/CCreatureAnimation.h
View File

@ -52,8 +52,8 @@ private:
CCreatureAnim::EAnimType type; //type of animation being displayed (-1 - whole animation, >0 - specified part [default: -1])
template<int bpp>
int nextFrameT(SDL_Surface * dest, int x, int y, bool attacker, ui8 animCount, bool incrementFrame = true, bool yellowBorder = false, bool blueBorder = false, SDL_Rect * destRect = NULL); //0 - success, any other - error //print next
int nextFrameMiddle(SDL_Surface * dest, int x, int y, bool attacker, ui8 animCount, bool IncrementFrame = true, bool yellowBorder = false, bool blueBorder = false, SDL_Rect * destRect = NULL); //0 - success, any other - error //print next
int nextFrameT(SDL_Surface * dest, int x, int y, bool attacker, ui8 animCount, bool incrementFrame = true, bool yellowBorder = false, bool blueBorder = false, SDL_Rect * destRect = nullptr); //0 - success, any other - error //print next
int nextFrameMiddle(SDL_Surface * dest, int x, int y, bool attacker, ui8 animCount, bool IncrementFrame = true, bool yellowBorder = false, bool blueBorder = false, SDL_Rect * destRect = nullptr); //0 - success, any other - error //print next
std::map<int, std::vector<int> > frameGroups; //groups of frames; [groupID] -> vector of frame IDs in group
bool once;
@ -66,7 +66,7 @@ public:
void setType(CCreatureAnim::EAnimType type); //sets type of animation and cleares framecount
CCreatureAnim::EAnimType getType() const; //returns type of animation
int nextFrame(SDL_Surface * dest, int x, int y, bool attacker, ui8 animCount, bool incrementFrame = true, bool yellowBorder = false, bool blueBorder = false, SDL_Rect * destRect = NULL); //0 - success, any other - error //print next
int nextFrame(SDL_Surface * dest, int x, int y, bool attacker, ui8 animCount, bool incrementFrame = true, bool yellowBorder = false, bool blueBorder = false, SDL_Rect * destRect = nullptr); //0 - success, any other - error //print next
void incrementFrame();
int getFrame() const; // Gets the current frame ID relative to DEF file.
int getAnimationFrame() const; // Gets the current frame ID relative to frame group.

2
client/gui/CCursorHandler.cpp
View File

@ -97,7 +97,7 @@ void CCursorHandler::drawRestored()
shiftPos(x, y);
SDL_Rect temp_rect = genRect(40, 40, x, y);
SDL_BlitSurface(help, NULL, screen, &temp_rect);
SDL_BlitSurface(help, nullptr, screen, &temp_rect);
//blitAt(help,x,y);
}

2
client/gui/CCursorHandler.h
View File

@ -49,7 +49,7 @@ public:
/**
* Replaces the cursor with a custom image.
*
* @param image Image to replace cursor with or NULL to use the normal
* @param image Image to replace cursor with or nullptr to use the normal
* cursor. CursorHandler takes ownership of object
*/
void dragAndDropCursor (CAnimImage * image);

12
client/gui/CGuiHandler.cpp
View File

@ -136,7 +136,7 @@ void CGuiHandler::popInts( int howMany )
IShowActivatable * CGuiHandler::topInt()
{
if(!listInt.size())
return NULL;
return nullptr;
else
return listInt.front();
}
@ -303,7 +303,7 @@ void CGuiHandler::handleEvent(SDL_Event *sEvent)
(*i)->clickRight(boost::logic::indeterminate, prev);
}
}
current = NULL;
current = nullptr;
} //event end
@ -397,10 +397,10 @@ void CGuiHandler::run()
CGuiHandler::CGuiHandler()
:lastClick(-500, -500)
{
curInt = NULL;
current = NULL;
curInt = nullptr;
current = nullptr;
terminate = false;
statusbar = NULL;
statusbar = nullptr;
// Creates the FPS manager and sets the framerate to 48 which is doubled the value of the original Heroes 3 FPS rate
mainFPSmng = new CFramerateManager(48);
@ -414,7 +414,7 @@ CGuiHandler::~CGuiHandler()
void CGuiHandler::breakEventHandling()
{
current = NULL;
current = nullptr;
}
void CGuiHandler::drawFPSCounter()

2
client/gui/CGuiHandler.h
View File

@ -67,7 +67,7 @@ public:
//objs to blit
std::vector<IShowable*> objsToBlit;
SDL_Event * current; //current event - can be set to NULL to stop handling event
SDL_Event * current; //current event - can be set to nullptr to stop handling event
IUpdateable *curInt;
Point lastClick;

2
client/gui/CIntObject.cpp
View File

@ -257,7 +257,7 @@ void CIntObject::removeChild(CIntObject *child, bool adjustPosition /*= false*/)
assert(vstd::contains(children, child));
assert(child->parent_m == this);
children -= child;
child->parent_m = NULL;
child->parent_m = nullptr;
if(adjustPosition)
child->pos -= pos;
}

56
client/gui/CIntObjectClasses.cpp
View File

@ -97,7 +97,7 @@ CPicture::~CPicture()
void CPicture::init()
{
needRefresh = false;
srcRect = NULL;
srcRect = nullptr;
}
void CPicture::show(SDL_Surface * to)
@ -158,7 +158,7 @@ void CPicture::createSimpleRect(const Rect &r, bool screenFormat, ui32 color)
else
bg = SDL_CreateRGBSurface(SDL_SWSURFACE, r.w, r.h, 8, 0, 0, 0, 0);
SDL_FillRect(bg, NULL, color);
SDL_FillRect(bg, nullptr, color);
freeSurf = true;
}
@ -200,8 +200,8 @@ CButtonBase::CButtonBase()
swappedImages = keepFrame = false;
bitmapOffset = 0;
state=NORMAL;
image = NULL;
text = NULL;
image = nullptr;
text = nullptr;
}
CButtonBase::~CButtonBase()
@ -304,7 +304,7 @@ CAdventureMapButton::CAdventureMapButton( const std::string &Name, const std::st
init(Callback, pom, HelpBox, info->playerColoured, info->defName, &info->additionalDefs, info->x, info->y, key);
}
CAdventureMapButton::CAdventureMapButton( const std::pair<std::string, std::string> &help, const CFunctionList<void()> &Callback, int x, int y, const std::string &defName, int key/*=0*/, std::vector<std::string> * add /*= NULL*/, bool playerColoredButton /*= false */ )
CAdventureMapButton::CAdventureMapButton( const std::pair<std::string, std::string> &help, const CFunctionList<void()> &Callback, int x, int y, const std::string &defName, int key/*=0*/, std::vector<std::string> * add /*= nullptr*/, bool playerColoredButton /*= false */ )
{
std::map<int,std::string> pom;
pom[0] = help.first;
@ -357,7 +357,7 @@ void CAdventureMapButton::hover (bool on)
std::string *name = (vstd::contains(hoverTexts,getState()))
? (&hoverTexts[getState()])
: (vstd::contains(hoverTexts,0) ? (&hoverTexts[0]) : NULL);
: (vstd::contains(hoverTexts,0) ? (&hoverTexts[0]) : nullptr);
if(name && name->size() && !isBlocked()) //if there is no name, there is nohing to display also
{
if (LOCPLINT && LOCPLINT->battleInt) //for battle buttons
@ -491,7 +491,7 @@ CHighlightableButton::CHighlightableButton( const CFunctionList<void()> &onSelec
init(onSelect,Name,HelpBox,playerColoredButton,defName,add,x,y,key);
}
CHighlightableButton::CHighlightableButton( const std::pair<std::string, std::string> &help, const CFunctionList<void()> &onSelect, int x, int y, const std::string &defName, int myid, int key/*=0*/, std::vector<std::string> * add /*= NULL*/, bool playerColoredButton /*= false */ )
CHighlightableButton::CHighlightableButton( const std::pair<std::string, std::string> &help, const CFunctionList<void()> &onSelect, int x, int y, const std::string &defName, int myid, int key/*=0*/, std::vector<std::string> * add /*= nullptr*/, bool playerColoredButton /*= false */ )
: onlyOn(false), selected(false) // TODO: callback2(???)
{
ID = myid;
@ -500,7 +500,7 @@ CHighlightableButton::CHighlightableButton( const std::pair<std::string, std::st
init(onSelect, pom, help.second, playerColoredButton, defName, add, x, y, key);
}
CHighlightableButton::CHighlightableButton( const std::string &Name, const std::string &HelpBox, const CFunctionList<void()> &onSelect, int x, int y, const std::string &defName, int myid, int key/*=0*/, std::vector<std::string> * add /*= NULL*/, bool playerColoredButton /*= false */ )
CHighlightableButton::CHighlightableButton( const std::string &Name, const std::string &HelpBox, const CFunctionList<void()> &onSelect, int x, int y, const std::string &defName, int myid, int key/*=0*/, std::vector<std::string> * add /*= nullptr*/, bool playerColoredButton /*= false */ )
: onlyOn(false), selected(false) // TODO: callback2(???)
{
ID = myid;
@ -516,7 +516,7 @@ void CHighlightableButtonsGroup::addButton(CHighlightableButton* bt)
addChild(bt);
bt->recActions = defActions;//FIXME: not needed?
bt->callback += boost::bind(&CHighlightableButtonsGroup::selectionChanged,this,bt->ID);
bt->callback += std::bind(&CHighlightableButtonsGroup::selectionChanged,this,bt->ID);
bt->onlyOn = true;
buttons.push_back(bt);
}
@ -530,7 +530,7 @@ void CHighlightableButtonsGroup::addButton(const std::map<int,std::string> &tool
bt->setOffset(buttons.size()-3);
}
bt->ID = uid;
bt->callback += boost::bind(&CHighlightableButtonsGroup::selectionChanged,this,bt->ID);
bt->callback += std::bind(&CHighlightableButtonsGroup::selectionChanged,this,bt->ID);
bt->onlyOn = true;
buttons.push_back(bt);
}
@ -546,7 +546,7 @@ CHighlightableButtonsGroup::~CHighlightableButtonsGroup()
void CHighlightableButtonsGroup::select(int id, bool mode)
{
CHighlightableButton *bt = NULL;
CHighlightableButton *bt = nullptr;
if(mode)
{
for(size_t i=0;i<buttons.size() && !bt; ++i)
@ -723,7 +723,7 @@ CSlider::~CSlider()
}
CSlider::CSlider(int x, int y, int totalw, boost::function<void(int)> Moved, int Capacity, int Amount, int Value, bool Horizontal, int style)
CSlider::CSlider(int x, int y, int totalw, std::function<void(int)> Moved, int Capacity, int Amount, int Value, bool Horizontal, int style)
:capacity(Capacity),amount(Amount),horizontal(Horizontal), moved(Moved)
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
@ -753,9 +753,9 @@ CSlider::CSlider(int x, int y, int totalw, boost::function<void(int)> Moved, int
right->pos.y = pos.y + totalw - 16;
}
left->callback = boost::bind(&CSlider::moveLeft,this);
right->callback = boost::bind(&CSlider::moveRight,this);
slider->callback = boost::bind(&CSlider::sliderClicked,this);
left->callback = std::bind(&CSlider::moveLeft,this);
right->callback = std::bind(&CSlider::moveRight,this);
slider->callback = std::bind(&CSlider::sliderClicked,this);
left->pos.w = left->pos.h = right->pos.w = right->pos.h = slider->pos.w = slider->pos.h = 16;
if(horizontal)
{
@ -892,7 +892,7 @@ CIntObject* CObjectList::createItem(size_t index)
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
CIntObject * item = createObject(index);
if (item == NULL)
if (item == nullptr)
item = new CIntObject();
item->recActions = defActions;
@ -903,7 +903,7 @@ CIntObject* CObjectList::createItem(size_t index)
CTabbedInt::CTabbedInt(CreateFunc create, DestroyFunc destroy, Point position, size_t ActiveID):
CObjectList(create, destroy),
activeTab(NULL),
activeTab(nullptr),
activeID(ActiveID)
{
pos += position;
@ -948,7 +948,7 @@ CListBox::CListBox(CreateFunc create, DestroyFunc destroy, Point Pos, Point Item
if (Slider & 1)
{
OBJ_CONSTRUCTION_CAPTURING_ALL;
slider = new CSlider(SliderPos.x, SliderPos.y, SliderPos.w, boost::bind(&CListBox::moveToPos, this, _1),
slider = new CSlider(SliderPos.x, SliderPos.y, SliderPos.w, std::bind(&CListBox::moveToPos, this, _1),
VisibleSize, TotalSize, InitialPos, Slider & 2, Slider & 4);
}
reset();
@ -1095,7 +1095,7 @@ CSimpleWindow::~CSimpleWindow()
if (bitmap)
{
SDL_FreeSurface(bitmap);
bitmap=NULL;
bitmap=nullptr;
}
}
@ -1170,7 +1170,7 @@ CLabel::CLabel(int x, int y, EFonts Font /*= FONT_SMALL*/, EAlignment Align, con
pos.x += x;
pos.y += y;
pos.w = pos.h = 0;
bg = NULL;
bg = nullptr;
ignoreLeadingWhitespace = false;
if (alignment == TOPLEFT) // causes issues for MIDDLE
@ -1315,7 +1315,7 @@ void CLabelGroup::add(int x, int y, const std::string &text)
}
CTextBox::CTextBox(std::string Text, const Rect &rect, int SliderStyle, EFonts Font /*= FONT_SMALL*/, EAlignment Align /*= TOPLEFT*/, const SDL_Color &Color /*= Colors::WHITE*/)
:CBoundedLabel(rect.x, rect.y, Font, Align, Color, Text), sliderStyle(SliderStyle), slider(NULL)
:CBoundedLabel(rect.x, rect.y, Font, Align, Color, Text), sliderStyle(SliderStyle), slider(nullptr)
{
type |= REDRAW_PARENT;
autoRedraw = false;
@ -1341,7 +1341,7 @@ void CTextBox::recalculateLines(const std::string &Txt)
{
lines = CMessage::breakText(Txt, pos.w - 32 - 10, font);
OBJ_CONSTRUCTION_CAPTURING_ALL;
slider = new CSlider(pos.w - 32, 0, pos.h, boost::bind(&CTextBox::sliderMoved, this, _1), lineCapacity, lines.size(), 0, false, sliderStyle);
slider = new CSlider(pos.w - 32, 0, pos.h, std::bind(&CTextBox::sliderMoved, this, _1), lineCapacity, lines.size(), 0, false, sliderStyle);
if(active)
slider->activate();
}
@ -1512,9 +1512,9 @@ CTextInput::CTextInput(const Rect &Pos, SDL_Surface *srf)
bg = new CPicture(Pos, 0, true);
Rect hlp = Pos;
if(srf)
CSDL_Ext::blitSurface(srf, &hlp, *bg, NULL);
CSDL_Ext::blitSurface(srf, &hlp, *bg, nullptr);
else
SDL_FillRect(*bg, NULL, 0);
SDL_FillRect(*bg, nullptr, 0);
pos.w = bg->pos.w;
pos.h = bg->pos.h;
bg->pos = pos;
@ -1639,7 +1639,7 @@ CFocusable::CFocusable()
CFocusable::~CFocusable()
{
if(inputWithFocus == this)
inputWithFocus = NULL;
inputWithFocus = nullptr;
focusables -= this;
}
@ -1814,9 +1814,9 @@ void CWindowObject::setShadow(bool on)
Uint32 shadowColor = SDL_MapRGBA(shadowCornerTempl->format, 0, 0, 0, 192);
//fill with shadow body color
SDL_FillRect(shadowCornerTempl, NULL, shadowColor);
SDL_FillRect(shadowBottomTempl, NULL, shadowColor);
SDL_FillRect(shadowRightTempl, NULL, shadowColor);
SDL_FillRect(shadowCornerTempl, nullptr, shadowColor);
SDL_FillRect(shadowBottomTempl, nullptr, shadowColor);
SDL_FillRect(shadowRightTempl, nullptr, shadowColor);
//fill last row and column with more transparent color
blitAlphaCol(shadowRightTempl , size-1);

24
client/gui/CIntObjectClasses.h
View File

@ -27,7 +27,7 @@ class CSimpleWindow : public CIntObject
public:
SDL_Surface * bitmap; //background
virtual void show(SDL_Surface * to);
CSimpleWindow():bitmap(NULL){}; //c-tor
CSimpleWindow():bitmap(nullptr){}; //c-tor
virtual ~CSimpleWindow(); //d-tor
};
@ -37,7 +37,7 @@ class CPicture : public CIntObject
void setSurface(SDL_Surface *to);
public:
SDL_Surface * bg;
Rect * srcRect; //if NULL then whole surface will be used
Rect * srcRect; //if nullptr then whole surface will be used
bool freeSurf; //whether surface will be freed upon CPicture destruction
bool needRefresh;//Surface needs to be displayed each frame
@ -139,8 +139,8 @@ public:
void hover (bool on);
CAdventureMapButton(); //c-tor
CAdventureMapButton( const std::string &Name, const std::string &HelpBox, const CFunctionList<void()> &Callback, int x, int y, const std::string &defName, int key=0, std::vector<std::string> * add = NULL, bool playerColoredButton = false );//c-tor
CAdventureMapButton( const std::pair<std::string, std::string> &help, const CFunctionList<void()> &Callback, int x, int y, const std::string &defName, int key=0, std::vector<std::string> * add = NULL, bool playerColoredButton = false );//c-tor
CAdventureMapButton( const std::string &Name, const std::string &HelpBox, const CFunctionList<void()> &Callback, int x, int y, const std::string &defName, int key=0, std::vector<std::string> * add = nullptr, bool playerColoredButton = false );//c-tor
CAdventureMapButton( const std::pair<std::string, std::string> &help, const CFunctionList<void()> &Callback, int x, int y, const std::string &defName, int key=0, std::vector<std::string> * add = nullptr, bool playerColoredButton = false );//c-tor
CAdventureMapButton( const std::string &Name, const std::string &HelpBox, const CFunctionList<void()> &Callback, config::ButtonInfo *info, int key=0);//c-tor
void init(const CFunctionList<void()> &Callback, const std::map<int,std::string> &Name, const std::string &HelpBox, bool playerColoredButton, const std::string &defName, std::vector<std::string> * add, int x, int y, int key );
@ -157,8 +157,8 @@ class CHighlightableButton
{
public:
CHighlightableButton(const CFunctionList<void()> &onSelect, const CFunctionList<void()> &onDeselect, const std::map<int,std::string> &Name, const std::string &HelpBox, bool playerColoredButton, const std::string &defName, std::vector<std::string> * add, int x, int y, int key=0);
CHighlightableButton(const std::pair<std::string, std::string> &help, const CFunctionList<void()> &onSelect, int x, int y, const std::string &defName, int myid, int key=0, std::vector<std::string> * add = NULL, bool playerColoredButton = false );//c-tor
CHighlightableButton(const std::string &Name, const std::string &HelpBox, const CFunctionList<void()> &onSelect, int x, int y, const std::string &defName, int myid, int key=0, std::vector<std::string> * add = NULL, bool playerColoredButton = false );//c-tor
CHighlightableButton(const std::pair<std::string, std::string> &help, const CFunctionList<void()> &onSelect, int x, int y, const std::string &defName, int myid, int key=0, std::vector<std::string> * add = nullptr, bool playerColoredButton = false );//c-tor
CHighlightableButton(const std::string &Name, const std::string &HelpBox, const CFunctionList<void()> &onSelect, int x, int y, const std::string &defName, int myid, int key=0, std::vector<std::string> * add = nullptr, bool playerColoredButton = false );//c-tor
bool onlyOn;//button can not be de-selected
bool selected;//state of highlightable button
int ID; //for identification
@ -200,7 +200,7 @@ public:
bool wheelScrolling;
bool keyScrolling;
boost::function<void(int)> moved;
std::function<void(int)> moved;
void redrawSlider();
void sliderClicked();
@ -216,7 +216,7 @@ public:
void mouseMoved (const SDL_MouseMotionEvent & sEvent);
void showAll(SDL_Surface * to);
CSlider(int x, int y, int totalw, boost::function<void(int)> Moved, int Capacity, int Amount,
CSlider(int x, int y, int totalw, std::function<void(int)> Moved, int Capacity, int Amount,
int Value=0, bool Horizontal=true, int style = 0); //style 0 - brown, 1 - blue
~CSlider();
void moveToMax();
@ -226,8 +226,8 @@ public:
class CObjectList : public CIntObject
{
public:
typedef boost::function<CIntObject* (size_t)> CreateFunc;
typedef boost::function<void(CIntObject *)> DestroyFunc;
typedef std::function<CIntObject* (size_t)> CreateFunc;
typedef std::function<void(CIntObject *)> DestroyFunc;
private:
CreateFunc createObject;
@ -445,7 +445,7 @@ public:
CTextInput(const Rect &Pos, EFonts font, const CFunctionList<void(const std::string &)> &CB);
CTextInput(const Rect &Pos, const Point &bgOffset, const std::string &bgName, const CFunctionList<void(const std::string &)> &CB);
CTextInput(const Rect &Pos, SDL_Surface *srf = NULL);
CTextInput(const Rect &Pos, SDL_Surface *srf = nullptr);
void clickLeft(tribool down, bool previousState) override;
void keyPressed(const SDL_KeyboardEvent & key) override;
@ -454,7 +454,7 @@ public:
//Filter that will block all characters not allowed in filenames
static void filenameFilter(std::string &text, const std::string & oldText);
//Filter that will allow only input of numbers in range min-max (min-max are allowed)
//min-max should be set via something like boost::bind
//min-max should be set via something like std::bind
static void numberFilter(std::string &text, const std::string & oldText, int minValue, int maxValue);
};

6
client/gui/Fonts.cpp
View File

@ -243,14 +243,14 @@ size_t CTrueTypeFont::getLineHeight() const
size_t CTrueTypeFont::getSymbolWidth(char data) const
{
int advance;
TTF_GlyphMetrics(font.get(), data, NULL, NULL, NULL, NULL, &advance);
TTF_GlyphMetrics(font.get(), data, nullptr, nullptr, nullptr, nullptr, &advance);
return advance;
}
size_t CTrueTypeFont::getStringWidth(const std::string & data) const
{
int width;
TTF_SizeText(font.get(), data.c_str(), &width, NULL);
TTF_SizeText(font.get(), data.c_str(), &width, nullptr);
return width;
}
@ -273,7 +273,7 @@ void CTrueTypeFont::renderText(SDL_Surface * surface, const std::string & data,
assert(rendered);
Rect rect(pos.x, pos.y, rendered->w, rendered->h);
SDL_BlitSurface(rendered, NULL, surface, &rect);
SDL_BlitSurface(rendered, nullptr, surface, &rect);
SDL_FreeSurface(rendered);
}
}

16
client/gui/SDL_Extensions.cpp
View File

@ -53,7 +53,7 @@ void blitAt(SDL_Surface * src, int x, int y, SDL_Surface * dst)
{
if(!dst) dst = screen;
SDL_Rect pom = genRect(src->h,src->w,x,y);
CSDL_Ext::blitSurface(src,NULL,dst,&pom);
CSDL_Ext::blitSurface(src,nullptr,dst,&pom);
}
void blitAt(SDL_Surface * src, const SDL_Rect & pos, SDL_Surface * dst)
@ -395,7 +395,7 @@ int CSDL_Ext::blit8bppAlphaTo24bppT(const SDL_Surface * src, const SDL_Rect * sr
/* Make sure the surfaces aren't locked */
if ( ! src || ! dst )
{
SDL_SetError("SDL_UpperBlit: passed a NULL surface");
SDL_SetError("SDL_UpperBlit: passed a nullptr surface");
return -1;
}
if ( src->locked || dst->locked )
@ -404,8 +404,8 @@ int CSDL_Ext::blit8bppAlphaTo24bppT(const SDL_Surface * src, const SDL_Rect * sr
return -1;
}
/* If the destination rectangle is NULL, use the entire dest surface */
if ( dstRect == NULL )
/* If the destination rectangle is nullptr, use the entire dest surface */
if ( dstRect == nullptr )
{
fulldst.x = fulldst.y = 0;
dstRect = &fulldst;
@ -614,7 +614,7 @@ case BytesPerPixel: \
CASE_BPP(4)
default:
logGlobal->errorStream() << (int)dest->format->BitsPerPixel << "bpp is not supported!";
return NULL;
return nullptr;
}
}
@ -628,7 +628,7 @@ TColorPutterAlpha CSDL_Ext::getPutterAlphaFor(SDL_Surface * const &dest, int inc
CASE_BPP(4)
default:
logGlobal->errorStream() << (int)dest->format->BitsPerPixel << "bpp is not supported!";
return NULL;
return nullptr;
}
#undef CASE_BPP
}
@ -716,7 +716,7 @@ BlitterWithRotationVal CSDL_Ext::getBlitterWithRotation(SDL_Surface *dest)
}
assert(0);
return NULL;
return nullptr;
}
BlitterWithRotationVal CSDL_Ext::getBlitterWithRotationAndAlpha(SDL_Surface *dest)
@ -732,7 +732,7 @@ BlitterWithRotationVal CSDL_Ext::getBlitterWithRotationAndAlpha(SDL_Surface *des
}
assert(0);
return NULL;
return nullptr;
}
template<int bpp>

16
client/mapHandler.cpp
View File

@ -245,7 +245,7 @@ static void processDef (const CGDefInfo* def)
{
if(def->id == Obj::EVENT)
{
graphics->advmapobjGraphics[def->name] = NULL;
graphics->advmapobjGraphics[def->name] = nullptr;
return;
}
CDefEssential * ourDef = graphics->getDef(def);
@ -543,7 +543,7 @@ void CMapHandler::terrainRect( int3 top_tile, ui8 anim, const std::vector< std::
pp.w = sr.w;
const CGHeroInstance * themp = (obj->ID != Obj::HERO
? NULL
? nullptr
: static_cast<const CGHeroInstance*>(obj));
//print hero / boat and flag
@ -551,8 +551,8 @@ void CMapHandler::terrainRect( int3 top_tile, ui8 anim, const std::vector< std::
{
const int IMGVAL = 8; //frames per group of movement animation
ui8 dir;
std::vector<Cimage> * iv = NULL;
std::vector<CDefEssential *> Graphics::*flg = NULL;
std::vector<Cimage> * iv = nullptr;
std::vector<CDefEssential *> Graphics::*flg = nullptr;
SDL_Surface * tb = nullptr; //surface to blitted
if(themp) //hero
@ -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.getNum()]->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, nullptr, extSurf, &bufr);
}
}
}
@ -665,7 +665,7 @@ void CMapHandler::terrainRect( int3 top_tile, ui8 anim, const std::vector< std::
{
if(bx == grailPosRel.x && by == grailPosRel.y)
{
CSDL_Ext::blit8bppAlphaTo24bpp(graphics->heroMoveArrows->ourImages[0].bitmap, NULL, extSurf, &sr);
CSDL_Ext::blit8bppAlphaTo24bpp(graphics->heroMoveArrows->ourImages[0].bitmap, nullptr, extSurf, &sr);
}
}
}
@ -1077,8 +1077,8 @@ CMapHandler::~CMapHandler()
CMapHandler::CMapHandler()
{
frameW = frameH = 0;
graphics->FoWfullHide = NULL;
graphics->FoWpartialHide = NULL;
graphics->FoWfullHide = nullptr;
graphics->FoWpartialHide = nullptr;
}
void CMapHandler::getTerrainDescr( const int3 &pos, std::string & out, bool terName )

25
lib/BattleState.cpp
View File

@ -2,7 +2,6 @@
#include "BattleState.h"
#include <numeric>
#include <boost/random/linear_congruential.hpp>
#include "VCMI_Lib.h"
#include "CObjectHandler.h"
#include "CHeroHandler.h"
@ -23,7 +22,7 @@
* Full text of license available in license.txt file, in main folder
*
*/
extern boost::rand48 ran;
extern std::minstd_rand ran;
const CStack * BattleInfo::getNextStack() const
{
@ -33,7 +32,7 @@ const CStack * BattleInfo::getNextStack() const
if(hlp.size())
return hlp[0];
else
return NULL;
return nullptr;
}
int BattleInfo::getAvaliableHex(CreatureID creID, bool attackerOwned, int initialPos) const
@ -193,7 +192,7 @@ bool BattleInfo::resurrects(SpellID spellid) const
const CStack * BattleInfo::battleGetStack(BattleHex pos, bool onlyAlive)
{
CStack * stack = NULL;
CStack * stack = nullptr;
for(ui32 g=0; g<stacks.size(); ++g)
{
if(stacks[g]->position == pos
@ -299,7 +298,7 @@ struct RangeGenerator
{
};
RangeGenerator(int _min, int _max, boost::function<int()> _myRand)
RangeGenerator(int _min, int _max, std::function<int()> _myRand)
{
myRand = _myRand;
min = _min;
@ -317,7 +316,7 @@ struct RangeGenerator
}
//get number fulfilling predicate. Never gives the same number twice.
int getSuchNumber(boost::function<bool(int)> goodNumberPred = 0)
int getSuchNumber(std::function<bool(int)> goodNumberPred = 0)
{
int ret = -1;
do
@ -343,7 +342,7 @@ struct RangeGenerator
int min, remainingCount;
std::vector<bool> remaining;
boost::function<int()> myRand;
std::function<int()> myRand;
};
BattleInfo * BattleInfo::setupBattle( int3 tile, ETerrainType terrain, BFieldType battlefieldType, const CArmedInstance *armies[2], const CGHeroInstance * heroes[2], bool creatureBank, const CGTownInstance *town )
@ -376,7 +375,7 @@ BattleInfo * BattleInfo::setupBattle( int3 tile, ETerrainType terrain, BFieldTyp
}
else
{
curB->town = NULL;
curB->town = nullptr;
curB->siege = CGTownInstance::NONE;
curB->terrainType = terrain;
}
@ -391,7 +390,7 @@ BattleInfo * BattleInfo::setupBattle( int3 tile, ETerrainType terrain, BFieldTyp
}
//randomize obstacles
if (town == NULL && !creatureBank) //do it only when it's not siege and not creature bank
if (town == nullptr && !creatureBank) //do it only when it's not siege and not creature bank
{
const int ABSOLUTE_OBSTACLES_COUNT = 34, USUAL_OBSTACLES_COUNT = 91; //shouldn't be changes if we want H3-like obstacle placement
@ -857,7 +856,7 @@ CStack::CStack()
setNodeType(STACK_BATTLE);
}
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)
: base(nullptr), ID(I), owner(O), slot(S), attackerOwned(AO), counterAttacks(1)
{
type = stack->type;
count = baseAmount = stack->count;
@ -866,8 +865,8 @@ CStack::CStack(const CStackBasicDescriptor *stack, PlayerColor O, int I, bool AO
void CStack::init()
{
base = NULL;
type = NULL;
base = nullptr;
type = nullptr;
ID = -1;
count = baseAmount = -1;
firstHPleft = -1;
@ -1111,7 +1110,7 @@ const CGHeroInstance * CStack::getMyHero() const
if(n->getNodeType() == HERO)
return dynamic_cast<const CGHeroInstance *>(n);
return NULL;
return nullptr;
}
std::string CStack::nodeName() const

18
lib/BattleState.h
View File

@ -86,12 +86,12 @@ struct DLL_LINKAGE BattleInfo : public CBonusSystemNode, public CBattleInfoCallb
const CStack * getNextStack() const; //which stack will have turn after current one
//void getStackQueue(std::vector<const CStack *> &out, int howMany, int turn = 0, int lastMoved = -1) const; //returns stack in order of their movement action
//void getAccessibilityMap(bool *accessibility, bool twoHex, bool attackerOwned, bool addOccupiable, std::set<BattleHex> & occupyable, bool flying, const CStack* stackToOmmit = NULL) const; //send pointer to at least 187 allocated bytes
//void getAccessibilityMap(bool *accessibility, bool twoHex, bool attackerOwned, bool addOccupiable, std::set<BattleHex> & occupyable, bool flying, const CStack* stackToOmmit = nullptr) const; //send pointer to at least 187 allocated bytes
//static bool isAccessible(BattleHex hex, bool * accessibility, bool twoHex, bool attackerOwned, bool flying, bool lastPos); //helper for makeBFS
int getAvaliableHex(CreatureID creID, bool attackerOwned, int initialPos = -1) const; //find place for summon / clone effects
//void makeBFS(BattleHex start, bool*accessibility, BattleHex *predecessor, int *dists, bool twoHex, bool attackerOwned, bool flying, bool fillPredecessors) const; //*accessibility must be prepared bool[187] array; last two pointers must point to the at least 187-elements int arrays - there is written result
std::pair< std::vector<BattleHex>, int > getPath(BattleHex start, BattleHex dest, const CStack *stack); //returned value: pair<path, length>; length may be different than number of elements in path since flying vreatures jump between distant hexes
//std::vector<BattleHex> getAccessibility(const CStack * stack, bool addOccupiable, std::vector<BattleHex> * attackable = NULL, bool forPassingBy = false) const; //returns vector of accessible tiles (taking into account the creature range)
//std::vector<BattleHex> getAccessibility(const CStack * stack, bool addOccupiable, std::vector<BattleHex> * attackable = nullptr, bool forPassingBy = false) const; //returns vector of accessible tiles (taking into account the creature range)
//bool isObstacleVisibleForSide(const CObstacleInstance &obstacle, ui8 side) const;
shared_ptr<CObstacleInstance> getObstacleOnTile(BattleHex tile) const;
@ -108,7 +108,7 @@ struct DLL_LINKAGE BattleInfo : public CBonusSystemNode, public CBattleInfoCallb
CStack * generateNewStack(const CStackBasicDescriptor &base, bool attackerOwned, SlotID slot, BattleHex position) const; //helper for CGameHandler::setupBattle and spells addign new stacks to the battlefield
int getIdForNewStack() const; //suggest a currently unused ID that'd suitable for generating a new stack
//std::pair<const CStack *, BattleHex> getNearestStack(const CStack * closest, boost::logic::tribool attackerOwned) const; //if attackerOwned is indetermnate, returened stack is of any owner; hex is the number of hex we should be looking from; returns (nerarest creature, predecessorHex)
ui32 calculateHealedHP(const CGHeroInstance * caster, const CSpell * spell, const CStack * stack, const CStack * sacrificedStack = NULL) const; //Sacrifice
ui32 calculateHealedHP(const CGHeroInstance * caster, const CSpell * spell, const CStack * stack, const CStack * sacrificedStack = nullptr) const; //Sacrifice
ui32 calculateHealedHP(int healedHealth, const CSpell * spell, const CStack * stack) const; //for Archangel
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?
@ -119,7 +119,7 @@ struct DLL_LINKAGE BattleInfo : public CBonusSystemNode, public CBattleInfoCallb
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
const CGHeroInstance * battleGetOwner(const CStack * stack) const; //returns hero that owns given stack; nullptr if none
void localInit();
void localInitStack(CStack * s);
@ -136,7 +136,7 @@ struct DLL_LINKAGE BattleInfo : public CBonusSystemNode, public CBattleInfoCallb
class DLL_LINKAGE CStack : public CBonusSystemNode, public CStackBasicDescriptor
{
public:
const CStackInstance *base; //garrison slot from which stack originates (NULL for war machines, summoned cres, etc)
const CStackInstance *base; //garrison slot from which stack originates (nullptr for war machines, summoned cres, etc)
ui32 ID; //unique ID of stack
ui32 baseAmount;
@ -157,7 +157,7 @@ public:
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;
std::string nodeName() const override;
void init(); //set initial (invalid) values
void postInit(); //used to finish initialization when inheriting creature parameters is working
@ -173,7 +173,7 @@ public:
si32 magicResistance() const; //include aura of resistance
static void stackEffectToFeature(std::vector<Bonus> & sf, const Bonus & sse);
std::vector<si32> activeSpells() const; //returns vector of active spell IDs sorted by time of cast
const CGHeroInstance *getMyHero() const; //if stack belongs to hero (directly or was by him summoned) returns hero, NULL otherwise
const CGHeroInstance *getMyHero() const; //if stack belongs to hero (directly or was by him summoned) returns hero, nullptr otherwise
static inline Bonus featureGenerator(Bonus::BonusType type, si16 subtype, si32 value, ui16 turnsRemain, si32 additionalInfo = 0, Bonus::LimitEffect limit = Bonus::NO_LIMIT)
{
@ -204,7 +204,7 @@ public:
h & ID & baseAmount & firstHPleft & owner & slot & attackerOwned & position & state & counterAttacks
& shots & casts & count;
const CArmedInstance *army = (base ? base->armyObj : NULL);
const CArmedInstance *army = (base ? base->armyObj : nullptr);
SlotID slot = (base ? base->armyObj->findStack(base) : SlotID());
if(h.saving)
@ -222,7 +222,7 @@ public:
}
else if(!army || slot == SlotID() || !army->hasStackAtSlot(slot))
{
base = NULL;
base = nullptr;
logGlobal->warnStream() << type->nameSing << " doesn't have a base stack!";
}
else

17
lib/CArtHandler.cpp
View File

@ -3,7 +3,6 @@
#include "filesystem/CResourceLoader.h"
#include "CGeneralTextHandler.h"
#include <boost/random/linear_congruential.hpp>
#include "VCMI_Lib.h"
#include "CModHandler.h"
#include "CSpellHandler.h"
@ -23,7 +22,7 @@ using namespace boost::assign;
*
*/
extern boost::rand48 ran;
extern std::minstd_rand ran;
// Note: list must match entries in ArtTraits.txt
#define ART_POS_LIST \
ART_POS(SPELLBOOK) \
@ -494,7 +493,7 @@ void CArtHandler::giveArtBonus( ArtifactID aid, Bonus::BonusType type, int val,
giveArtBonus(aid, createBonus(type, val, subtype, valType, limiter, additionalInfo));
}
void CArtHandler::giveArtBonus(ArtifactID aid, Bonus::BonusType type, int val, int subtype, shared_ptr<IPropagator> propagator /*= NULL*/, int additionalInfo)
void CArtHandler::giveArtBonus(ArtifactID aid, Bonus::BonusType type, int val, int subtype, shared_ptr<IPropagator> propagator /*= nullptr*/, int additionalInfo)
{
giveArtBonus(aid, createBonus(type, val, subtype, propagator, additionalInfo));
}
@ -967,7 +966,7 @@ void CCombinedArtifactInstance::removeFrom(ArtifactLocation al)
CArtifactInstance * CCombinedArtifactInstance::figureMainConstituent(const ArtifactLocation al)
{
CArtifactInstance *mainConstituent = NULL; //it'll be replaced with combined artifact, not a lock
CArtifactInstance *mainConstituent = nullptr; //it'll be replaced with combined artifact, not a lock
BOOST_FOREACH(ConstituentInfo &ci, constituentsInfo)
if(ci.slot == al.slot)
mainConstituent = ci.art;
@ -1006,7 +1005,7 @@ bool CCombinedArtifactInstance::isPart(const CArtifactInstance *supposedPart) co
return false;
}
CCombinedArtifactInstance::ConstituentInfo::ConstituentInfo(CArtifactInstance *Art /*= NULL*/, ArtifactPosition Slot /*= -1*/)
CCombinedArtifactInstance::ConstituentInfo::ConstituentInfo(CArtifactInstance *Art /*= nullptr*/, ArtifactPosition Slot /*= -1*/)
{
art = Art;
slot = Slot;
@ -1025,7 +1024,7 @@ const CArtifactInstance* CArtifactSet::getArt(ArtifactPosition pos, bool exclude
return si->artifact;
}
return NULL;
return nullptr;
}
CArtifactInstance* CArtifactSet::getArt(ArtifactPosition pos, bool excludeLocked /*= true*/)
@ -1072,7 +1071,7 @@ const CArtifactInstance * CArtifactSet::getArtByInstanceId( ArtifactInstanceID a
if(i.artifact->id == artInstId)
return i.artifact;
return NULL;
return nullptr;
}
bool CArtifactSet::hasArt(ui32 aid, bool onlyWorn /*= false*/) const
@ -1088,12 +1087,12 @@ const ArtSlotInfo * CArtifactSet::getSlot(ArtifactPosition pos) const
{
int backpackPos = (int)pos - GameConstants::BACKPACK_START;
if(backpackPos < 0 || backpackPos >= artifactsInBackpack.size())
return NULL;
return nullptr;
else
return &artifactsInBackpack[backpackPos];
}
return NULL;
return nullptr;
}
bool CArtifactSet::isPositionFree(ArtifactPosition pos, bool onlyLockCheck /*= false*/) const

8
lib/CArtHandler.h
View File

@ -67,7 +67,7 @@ public:
ui32 price;
bmap<ArtBearer::ArtBearer, std::vector<ArtifactPosition> > possibleSlots; //Bearer Type => ids of slots where artifact can be placed
std::unique_ptr<std::vector<CArtifact *> > constituents; // Artifacts IDs a combined artifact consists of, or NULL.
std::unique_ptr<std::vector<CArtifact *> > constituents; // Artifacts IDs a combined artifact consists of, or nullptr.
std::vector<CArtifact *> constituentOf; // Reverse map of constituents - combined arts that include this art
EartClass aClass;
ArtifactID id;
@ -157,7 +157,7 @@ public:
}
bool operator==(const ConstituentInfo &rhs) const;
ConstituentInfo(CArtifactInstance *art = NULL, ArtifactPosition slot = ArtifactPosition::PRE_FIRST);
ConstituentInfo(CArtifactInstance *art = nullptr, ArtifactPosition slot = ArtifactPosition::PRE_FIRST);
};
std::vector<ConstituentInfo> constituentsInfo;
@ -272,8 +272,8 @@ public:
void eraseArtSlot(ArtifactPosition slot);
const ArtSlotInfo *getSlot(ArtifactPosition pos) const;
const CArtifactInstance* getArt(ArtifactPosition pos, bool excludeLocked = true) const; //NULL - no artifact
CArtifactInstance* getArt(ArtifactPosition pos, bool excludeLocked = true); //NULL - no artifact
const CArtifactInstance* getArt(ArtifactPosition pos, bool excludeLocked = true) const; //nullptr - no artifact
CArtifactInstance* getArt(ArtifactPosition pos, bool excludeLocked = true); //nullptr - no artifact
ArtifactPosition getArtPos(int aid, bool onlyWorn = true) const; //looks for equipped artifact with given ID and returns its slot ID or -1 if none(if more than one such artifact lower ID is returned)
ArtifactPosition getArtPos(const CArtifactInstance *art) const;
const CArtifactInstance *getArtByInstanceId(ArtifactInstanceID artInstId) const;

26
lib/CBattleCallback.cpp
View File

@ -210,8 +210,8 @@ const CGTownInstance * CBattleInfoEssentials::battleGetDefendedTown() const
RETURN_IF_NOT_BATTLE(nullptr);
if(!getBattle() || getBattle()->town == NULL)
return NULL;
if(!getBattle() || getBattle()->town == nullptr)
return nullptr;
return getBattle()->town;
}
@ -503,7 +503,7 @@ void CBattleInfoCallback::battleGetStackQueue(std::vector<const CStack *> &out,
//let's define a huge lambda
auto takeStack = [&](std::vector<const CStack *> &st) -> const CStack*
{
const CStack *ret = NULL;
const CStack *ret = nullptr;
unsigned i, //fastest stack
j=0; //fastest stack of the other side
for(i = 0; i < st.size(); i++)
@ -514,7 +514,7 @@ void CBattleInfoCallback::battleGetStackQueue(std::vector<const CStack *> &out,
if(i == st.size())
return nullptr;
const CStack *fastest = st[i], *other = NULL;
const CStack *fastest = st[i], *other = nullptr;
int bestSpeed = fastest->Speed(turn);
if(fastest->attackerOwned != lastMoved)
@ -546,9 +546,9 @@ void CBattleInfoCallback::battleGetStackQueue(std::vector<const CStack *> &out,
assert(ret);
if(ret == fastest)
st[i] = NULL;
st[i] = nullptr;
else
st[j] = NULL;
st[j] = nullptr;
lastMoved = ret->attackerOwned;
return ret;
@ -998,7 +998,7 @@ TDmgRange CBattleInfoCallback::battleEstimateDamage(const CStack * attacker, con
return battleEstimateDamage(bai, retaliationDmg);
}
std::pair<ui32, ui32> CBattleInfoCallback::battleEstimateDamage(const BattleAttackInfo &bai, std::pair<ui32, ui32> * retaliationDmg /*= NULL*/) const
std::pair<ui32, ui32> CBattleInfoCallback::battleEstimateDamage(const BattleAttackInfo &bai, std::pair<ui32, ui32> * retaliationDmg /*= nullptr*/) const
{
RETURN_IF_NOT_BATTLE(std::make_pair(0, 0));
@ -1225,7 +1225,7 @@ std::pair<const CStack *, BattleHex> CBattleInfoCallback::getNearestStack(const
return std::make_pair(minimal->stack, reachability.predecessors[minimal->stack->position]);
}
else
return std::make_pair<const CStack * , BattleHex>(NULL, BattleHex::INVALID);
return std::make_pair<const CStack * , BattleHex>(nullptr, BattleHex::INVALID);
}
si8 CBattleInfoCallback::battleGetTacticDist() const
@ -1424,7 +1424,7 @@ bool CBattleInfoCallback::isToReverse (BattleHex hexFrom, BattleHex hexTo, bool
}
}
ReachabilityInfo::TDistances CBattleInfoCallback::battleGetDistances(const CStack * stack, BattleHex hex /*= BattleHex::INVALID*/, BattleHex * predecessors /*= NULL*/) const
ReachabilityInfo::TDistances CBattleInfoCallback::battleGetDistances(const CStack * stack, BattleHex hex /*= BattleHex::INVALID*/, BattleHex * predecessors /*= nullptr*/) const
{
ReachabilityInfo::TDistances ret;
ret.fill(-1);
@ -1811,7 +1811,7 @@ ESpellCastProblem::ESpellCastProblem CBattleInfoCallback::battleCanCastThisSpell
if (mode == ECastingMode::HERO_CASTING)
return battleIsImmune(battleGetFightingHero(playerToSide(player)), spell, mode, dest);
else
return battleIsImmune(NULL, spell, mode, dest);
return battleIsImmune(nullptr, spell, mode, dest);
}
ui32 CBattleInfoCallback::calculateSpellBonus(ui32 baseDamage, const CSpell * sp, const CGHeroInstance * caster, const CStack * affectedCreature) const
@ -1999,13 +1999,13 @@ std::set<const CStack*> CBattleInfoCallback::getAffectedCreatures(const CSpell *
return attackedCres;
}
const CStack * CBattleInfoCallback::getStackIf(boost::function<bool(const CStack*)> pred) const
const CStack * CBattleInfoCallback::getStackIf(std::function<bool(const CStack*)> pred) const
{
RETURN_IF_NOT_BATTLE(nullptr);
auto stacks = battleGetAllStacks();
auto stackItr = range::find_if(stacks, pred);
return stackItr == stacks.end()
? NULL
? nullptr
: *stackItr;
}
@ -2172,7 +2172,7 @@ int CBattleInfoCallback::battleGetSurrenderCost(PlayerColor Player) const
si8 CBattleInfoCallback::battleMaxSpellLevel() const
{
const CBonusSystemNode *node = NULL;
const CBonusSystemNode *node = nullptr;
if(const CGHeroInstance *h = battleGetFightingHero(battleGetMySide()))
node = h;
//TODO else use battle node

14
lib/CBattleCallback.h
View File

@ -36,7 +36,7 @@ class CBattleInfoEssentials;
//Basic class for various callbacks (interfaces called by players to get info about game and so forth)
class DLL_LINKAGE CCallbackBase
{
const BattleInfo *battle; //battle to which the player is engaged, NULL if none or not applicable
const BattleInfo *battle; //battle to which the player is engaged, nullptr if none or not applicable
const BattleInfo * getBattle() const
{
@ -171,7 +171,7 @@ public:
bool battleHasNativeStack(ui8 side) const;
ui8 battleGetWallState(int partOfWall) const; //for determining state of a part of the wall; format: parameter [0] - keep, [1] - bottom tower, [2] - bottom wall, [3] - below gate, [4] - over gate, [5] - upper wall, [6] - uppert tower, [7] - gate; returned value: 1 - intact, 2 - damaged, 3 - destroyed; 0 - no battle
int battleGetMoatDmg() const; //what dmg unit will suffer if ending turn in the moat
const CGTownInstance * battleGetDefendedTown() const; //returns defended town if current battle is a siege, NULL instead
const CGTownInstance * battleGetDefendedTown() const; //returns defended town if current battle is a siege, nullptr instead
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 (?)
@ -226,10 +226,10 @@ public:
void battleGetStackCountOutsideHexes(bool *ac) const; // returns hexes which when in front of a stack cause us to move the amount box back
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
std::vector<BattleHex> battleGetAvailableHexes(const CStack * stack, bool addOccupiable, std::vector<BattleHex> * attackable = nullptr) const; //returns hexes reachable by creature with id ID (valid movement destinations), DOES contain stack current position
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]
ReachabilityInfo::TDistances battleGetDistances(const CStack * stack, BattleHex hex = BattleHex::INVALID, BattleHex * predecessors = nullptr) 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
bool battleIsStackBlocked(const CStack * stack) const; //returns true if there is neighboring enemy stack
@ -240,8 +240,8 @@ public:
TDmgRange calculateDmgRange(const CStack* attacker, const CStack* defender, bool shooting, ui8 charge, bool lucky, bool unlucky, bool deathBlow, bool ballistaDoubleDmg) const; //charge - number of hexes travelled before attack (for champion's jousting); returns pair <min dmg, max dmg>
//hextowallpart //int battleGetWallUnderHex(BattleHex hex) const; //returns part of destructible wall / gate / keep under given hex or -1 if not found
std::pair<ui32, ui32> battleEstimateDamage(const BattleAttackInfo &bai, std::pair<ui32, ui32> * retaliationDmg = NULL) const; //estimates damage dealt by attacker to defender; it may be not precise especially when stack has randomly working bonuses; returns pair <min dmg, max dmg>
std::pair<ui32, ui32> battleEstimateDamage(const CStack * attacker, const CStack * defender, std::pair<ui32, ui32> * retaliationDmg = NULL) const; //estimates damage dealt by attacker to defender; it may be not precise especially when stack has randomly working bonuses; returns pair <min dmg, max dmg>
std::pair<ui32, ui32> battleEstimateDamage(const BattleAttackInfo &bai, std::pair<ui32, ui32> * retaliationDmg = nullptr) const; //estimates damage dealt by attacker to defender; it may be not precise especially when stack has randomly working bonuses; returns pair <min dmg, max dmg>
std::pair<ui32, ui32> battleEstimateDamage(const CStack * attacker, const CStack * defender, std::pair<ui32, ui32> * retaliationDmg = nullptr) const; //estimates damage dealt by attacker to defender; it may be not precise especially when stack has randomly working bonuses; returns pair <min dmg, max dmg>
si8 battleHasDistancePenalty( const CStack * stack, BattleHex destHex ) const;
si8 battleHasDistancePenalty(const IBonusBearer *bonusBearer, BattleHex shooterPosition, BattleHex destHex ) const;
si8 battleHasWallPenalty(const CStack * stack, BattleHex destHex) const; //checks if given stack has wall penalty
@ -268,7 +268,7 @@ public:
ESpellCastProblem::ESpellCastProblem battleIsImmune(const CGHeroInstance * caster, const CSpell * spell, ECastingMode::ECastingMode mode, BattleHex dest) const;
const CStack * getStackIf(boost::function<bool(const CStack*)> pred) const;
const CStack * getStackIf(std::function<bool(const CStack*)> pred) const;
si8 battleHasShootingPenalty(const CStack * stack, BattleHex destHex)
{

4
lib/CConfigHandler.cpp
View File

@ -135,7 +135,7 @@ void SettingsListener::nodeInvalidated(const std::vector<std::string> &changedPa
callback(parent.getNode(path));
}
void SettingsListener::operator() (boost::function<void(const JsonNode&)> _callback)
void SettingsListener::operator() (std::function<void(const JsonNode&)> _callback)
{
callback = _callback;
}
@ -200,7 +200,7 @@ static void setGem(AdventureMapConfig &ac, const int gem, const JsonNode &g)
ac.gemG.push_back(g["graphic"].String());
}
CConfigHandler::CConfigHandler(void): current(NULL)
CConfigHandler::CConfigHandler(void): current(nullptr)
{
}

4
lib/CConfigHandler.h
View File

@ -63,7 +63,7 @@ class DLL_LINKAGE SettingsListener
// Path to this node
std::vector<std::string> path;
// Callback
boost::function<void(const JsonNode&)> callback;
std::function<void(const JsonNode&)> callback;
SettingsListener(SettingsStorage &_parent, const std::vector<std::string> &_path);
@ -75,7 +75,7 @@ public:
~SettingsListener();
// assign callback function
void operator()(boost::function<void(const JsonNode&)> _callback);
void operator()(std::function<void(const JsonNode&)> _callback);
friend class SettingsStorage;
};

14
lib/CConsoleHandler.cpp
View File

@ -61,9 +61,9 @@ void printWinError()
logGlobal->errorStream() << "Error " << error << " encountered:";
//Get error description
char* pTemp = NULL;
char* pTemp = nullptr;
FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, error, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), (LPSTR)&pTemp, 1, NULL);
nullptr, error, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), (LPSTR)&pTemp, 1, nullptr);
logGlobal->errorStream() << pTemp;
LocalFree( pTemp );
}
@ -124,9 +124,9 @@ LONG WINAPI onUnhandledException(EXCEPTION_POINTERS* exception)
MINIDUMP_EXCEPTION_INFORMATION meinfo = {threadId, exception, TRUE};
//create file where dump will be placed
char *mname = NULL;
char *mname = nullptr;
char buffer[MAX_PATH + 1];
HMODULE hModule = NULL;
HMODULE hModule = nullptr;
GetModuleFileNameA(hModule, buffer, MAX_PATH);
mname = strrchr(buffer, '\\');
if (mname != 0)
@ -228,7 +228,7 @@ CConsoleHandler::CConsoleHandler() : thread(nullptr)
#else
defColor = "\x1b[0m";
#endif
cb = new boost::function<void(const std::string &)>;
cb = new std::function<void(const std::string &)>;
}
CConsoleHandler::~CConsoleHandler()
{
@ -248,11 +248,11 @@ void CConsoleHandler::end()
#endif
thread->join();
delete thread;
thread = NULL;
thread = nullptr;
}
}
void CConsoleHandler::start()
{
thread = new boost::thread(boost::bind(&CConsoleHandler::run,console));
thread = new boost::thread(std::bind(&CConsoleHandler::run,console));
}

2
lib/CConsoleHandler.h
View File

@ -75,7 +75,7 @@ public:
#endif
}
boost::function<void(const std::string &)> *cb; //function to be called when message is received
std::function<void(const std::string &)> *cb; //function to be called when message is received
private:
int run();

2
lib/CCreatureHandler.cpp
View File

@ -1046,7 +1046,7 @@ CCreatureHandler::~CCreatureHandler()
creature.dellNull();
}
CreatureID CCreatureHandler::pickRandomMonster(const boost::function<int()> &randGen, int tier) const
CreatureID CCreatureHandler::pickRandomMonster(const std::function<int()> &randGen, int tier) const
{
int r = 0;
if(tier == -1) //pick any allowed creature

2
lib/CCreatureHandler.h
View File

@ -184,7 +184,7 @@ public:
std::vector <std::pair <Bonus*, std::pair <ui8, ui8> > > skillRequirements; // first - Bonus, second - which two skills are needed to use it
void deserializationFix();
CreatureID pickRandomMonster(const boost::function<int()> &randGen = 0, int tier = -1) const; //tier <1 - CREATURES_PER_TOWN> or -1 for any
CreatureID pickRandomMonster(const std::function<int()> &randGen = 0, int tier = -1) const; //tier <1 - CREATURES_PER_TOWN> or -1 for any
void addBonusForTier(int tier, Bonus *b); //tier must be <1-7>
void addBonusForAllCreatures(Bonus *b);

22
lib/CCreatureSet.cpp
View File

@ -37,7 +37,7 @@ const CCreature* CCreatureSet::getCreature(SlotID slot) const
if (i != stacks.end())
return i->second->type;
else
return NULL;
return nullptr;
}
bool CCreatureSet::setCreature(SlotID slot, CreatureID type, TQuantity quantity) /*slots 0 to 6 */
@ -281,7 +281,7 @@ const CStackInstance* CCreatureSet::getStackPtr(SlotID slot) const
{
if(hasStackAtSlot(slot))
return stacks.find(slot)->second;
else return NULL;
else return nullptr;
}
void CCreatureSet::eraseStack(SlotID slot)
@ -386,7 +386,7 @@ CStackInstance * CCreatureSet::detachStack(SlotID slot)
//if(CArmedInstance *armedObj = castToArmyObj())
{
ret->setArmyObj(NULL); //detaches from current armyobj
ret->setArmyObj(nullptr); //detaches from current armyobj
}
assert(!ret->armyObj); //we failed detaching?
@ -477,9 +477,9 @@ void CStackInstance::init()
{
experience = 0;
count = 0;
type = NULL;
type = nullptr;
idRand = -1;
_armyObj = NULL;
_armyObj = nullptr;
setNodeType(STACK_INSTANCE);
}
@ -549,7 +549,7 @@ void CStackInstance::setType(CreatureID creID)
if(creID >= 0 && creID < VLC->creh->creatures.size())
setType(VLC->creh->creatures[creID]);
else
setType((const CCreature*)NULL);
setType((const CCreature*)nullptr);
}
void CStackInstance::setType(const CCreature *c)
@ -638,10 +638,10 @@ std::string CStackInstance::nodeName() const
void CStackInstance::deserializationFix()
{
const CCreature *backup = type;
type = NULL;
type = nullptr;
setType(backup);
const CArmedInstance *armyBackup = _armyObj;
_armyObj = NULL;
_armyObj = nullptr;
setArmyObj(armyBackup);
artDeserializationFix(this);
}
@ -689,9 +689,9 @@ void CCommanderInstance::init()
experience = 0;
level = 1;
count = 1;
type = NULL;
type = nullptr;
idRand = -1;
_armyObj = NULL;
_armyObj = nullptr;
setNodeType (CBonusSystemNode::COMMANDER);
secondarySkills.resize (ECommander::SPELL_POWER + 1);
}
@ -748,7 +748,7 @@ bool CCommanderInstance::gainsLevel() const
CStackBasicDescriptor::CStackBasicDescriptor()
{
type = NULL;
type = nullptr;
count = -1;
}

16
lib/CCreatureSet.h
View File

@ -78,8 +78,8 @@ public:
void setArmyObj(const CArmedInstance *ArmyObj);
virtual void giveStackExp(TExpType exp);
bool valid(bool allowUnrandomized) const;
ArtBearer::ArtBearer bearerType() const OVERRIDE; //from CArtifactSet
virtual std::string nodeName() const OVERRIDE; //from CBonusSystemnode
ArtBearer::ArtBearer bearerType() const override; //from CArtifactSet
virtual std::string nodeName() const override; //from CBonusSystemnode
void deserializationFix();
};
@ -95,7 +95,7 @@ public:
std::vector <ui8> secondarySkills; //ID -> level
std::set <ui8> specialSKills;
//std::vector <CArtifactInstance *> arts;
void init() OVERRIDE;
void init() override;
CCommanderInstance();
CCommanderInstance (CreatureID id);
~CCommanderInstance();
@ -106,8 +106,8 @@ public:
bool gainsLevel() const; //true if commander has lower level than should upon his experience
ui64 getPower() const {return 0;};
int getExpRank() const;
int getLevel() const OVERRIDE;
ArtBearer::ArtBearer bearerType() const OVERRIDE; //from CArtifactSet
int getLevel() const override;
ArtBearer::ArtBearer bearerType() const override; //from CArtifactSet
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -133,8 +133,8 @@ class DLL_LINKAGE CSimpleArmy : public IArmyDescriptor
{
public:
TSimpleSlots army;
void clear() OVERRIDE;
bool setCreature(SlotID slot, CreatureID cre, TQuantity count) OVERRIDE;
void clear() override;
bool setCreature(SlotID slot, CreatureID cre, TQuantity count) override;
operator bool() const;
template <typename Handler> void serialize(Handler &h, const int version)
@ -181,7 +181,7 @@ public:
void setToArmy(CSimpleArmy &src); //erases all our army and moves stacks from src to us; src MUST NOT be an armed object! WARNING: use it wisely. Or better do not use at all.
const CStackInstance& getStack(SlotID slot) const; //stack must exist
const CStackInstance* getStackPtr(SlotID slot) const; //if stack doesn't exist, returns NULL
const CStackInstance* getStackPtr(SlotID slot) const; //if stack doesn't exist, returns nullptr
const CCreature* getCreature(SlotID slot) const; //workaround of map issue;
int getStackCount (SlotID slot) const;
TExpType getStackExperience(SlotID slot) const;

2
lib/CGameInterface.h
View File

@ -105,7 +105,7 @@ class DLL_LINKAGE CGlobalAI : public CGameInterface // AI class (to derivate)
{
public:
CGlobalAI();
virtual BattleAction activeStack(const CStack * stack) OVERRIDE;
virtual BattleAction activeStack(const CStack * stack) override;
};
//class to be inherited by adventure-only AIs, it cedes battle actions to given battle-AI

59
lib/CGameState.cpp
View File

@ -1,7 +1,6 @@
#include "StdInc.h"
#include "CGameState.h"
#include <boost/random/linear_congruential.hpp>
#include "mapping/CCampaignHandler.h"
#include "CDefObjInfoHandler.h"
#include "CArtHandler.h"
@ -28,7 +27,7 @@
#include "rmg/CMapGenerator.h"
#include "CStopWatch.h"
DLL_LINKAGE boost::rand48 ran;
DLL_LINKAGE std::minstd_rand ran;
class CGObjectInstance;
#ifdef min
@ -55,7 +54,7 @@ class CBaseForGSApply
public:
virtual void applyOnGS(CGameState *gs, void *pack) const =0;
virtual ~CBaseForGSApply(){};
template<typename U> static CBaseForGSApply *getApplier(const U * t=NULL)
template<typename U> static CBaseForGSApply *getApplier(const U * t=nullptr)
{
return new CApplyOnGS<U>;
}
@ -73,7 +72,7 @@ public:
}
};
static CApplier<CBaseForGSApply> *applierGs = NULL;
static CApplier<CBaseForGSApply> *applierGs = nullptr;
class IObjectCaller
{
@ -102,7 +101,7 @@ class CObjectCallersHandler
public:
std::vector<IObjectCaller*> apps;
template<typename T> void registerType(const T * t=NULL)
template<typename T> void registerType(const T * t=nullptr)
{
apps.push_back(new CObjectCaller<T>);
}
@ -129,7 +128,7 @@ public:
//for (size_t i = 0; i < apps.size(); i++)
//apps[i]->postInit();
}
} *objCaller = NULL;
} *objCaller = nullptr;
void MetaString::getLocalString(const std::pair<ui8,ui32> &txt, std::string &dst) const
{
@ -364,7 +363,7 @@ static CGObjectInstance * createObject(Obj id, int subid, int3 pos, PlayerColor
if(!nobj->defInfo)
logGlobal->warnStream() <<"No def declaration for " <<id <<" "<<subid;
nobj->pos = pos;
//nobj->state = NULL;//new CLuaObjectScript();
//nobj->state = nullptr;//new CLuaObjectScript();
nobj->tempOwner = owner;
nobj->defInfo->id = id;
nobj->defInfo->subid = subid;
@ -376,14 +375,14 @@ static CGObjectInstance * createObject(Obj id, int subid, int3 pos, PlayerColor
return nobj;
}
CGHeroInstance * CGameState::HeroesPool::pickHeroFor(bool native, PlayerColor 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 /*= nullptr*/) const
{
CGHeroInstance *ret = NULL;
CGHeroInstance *ret = nullptr;
if(player>=PlayerColor::PLAYER_LIMIT)
{
logGlobal->errorStream() << "Cannot pick hero for " << town->faction->index << ". Wrong owner!";
return NULL;
return nullptr;
}
std::vector<CGHeroInstance *> pool;
@ -522,15 +521,15 @@ std::pair<Obj,int> CGameState::pickObject (CGObjectInstance *obj)
case Obj::RANDOM_HERO:
return std::make_pair(Obj::HERO, pickHero(obj->tempOwner));
case Obj::RANDOM_MONSTER:
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(boost::ref(ran)));
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran)));
case Obj::RANDOM_MONSTER_L1:
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(boost::ref(ran), 1));
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 1));
case Obj::RANDOM_MONSTER_L2:
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(boost::ref(ran), 2));
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 2));
case Obj::RANDOM_MONSTER_L3:
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(boost::ref(ran), 3));
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 3));
case Obj::RANDOM_MONSTER_L4:
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(boost::ref(ran), 4));
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 4));
case Obj::RANDOM_RESOURCE:
return std::make_pair(Obj::RESOURCE,ran()%7); //now it's OH3 style, use %8 for mithril
case Obj::RANDOM_TOWN:
@ -559,11 +558,11 @@ std::pair<Obj,int> CGameState::pickObject (CGObjectInstance *obj)
return std::make_pair(Obj::TOWN,f);
}
case Obj::RANDOM_MONSTER_L5:
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(boost::ref(ran), 5));
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 5));
case Obj::RANDOM_MONSTER_L6:
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(boost::ref(ran), 6));
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 6));
case Obj::RANDOM_MONSTER_L7:
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(boost::ref(ran), 7));
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 7));
case Obj::RANDOM_DWELLING:
case Obj::RANDOM_DWELLING_LVL:
case Obj::RANDOM_DWELLING_FACTION:
@ -856,7 +855,7 @@ void CGameState::init(StartInfo * si)
ran.seed((boost::int32_t)si->seedToBeUsed);
scenarioOps = new StartInfo(*si);
initialOpts = new StartInfo(*si);
si = NULL;
si = nullptr;
switch(scenarioOps->mode)
{
@ -1522,11 +1521,11 @@ void CGameState::initDuel()
const CArmedInstance *armies[2] = {0};
const CGHeroInstance *heroes[2] = {0};
CGTownInstance *town = NULL;
CGTownInstance *town = nullptr;
for(int i = 0; i < 2; i++)
{
CArmedInstance *obj = NULL;
CArmedInstance *obj = nullptr;
if(dp.sides[i].heroId >= 0)
{
const DuelParameters::SideSettings &ss = dp.sides[i];
@ -1678,8 +1677,8 @@ UpgradeInfo CGameState::getUpgradeInfo(const CStackInstance &stack)
UpgradeInfo ret;
const CCreature *base = stack.type;
const CGHeroInstance *h = stack.armyObj->ID == Obj::HERO ? static_cast<const CGHeroInstance*>(stack.armyObj) : NULL;
const CGTownInstance *t = NULL;
const CGHeroInstance *h = stack.armyObj->ID == Obj::HERO ? static_cast<const CGHeroInstance*>(stack.armyObj) : nullptr;
const CGTownInstance *t = nullptr;
if(stack.armyObj->ID == Obj::TOWN)
t = static_cast<const CGTownInstance *>(stack.armyObj);
@ -2077,7 +2076,7 @@ int CGameState::victoryCheck( PlayerColor player ) const
int total = 0; //creature counter
for(size_t i = 0; i < map->objects.size(); i++)
{
const CArmedInstance *ai = NULL;
const CArmedInstance *ai = nullptr;
if(map->objects[i]
&& map->objects[i]->tempOwner == player //object controlled by player
&& (ai = dynamic_cast<const CArmedInstance*>(map->objects[i].get()))) //contains army
@ -2251,7 +2250,7 @@ struct statsHLP
{
std::vector<ConstTransitivePtr<CGHeroInstance> > &h = gs->players[color].heroes;
if(!h.size())
return NULL;
return nullptr;
//best hero will be that with highest exp
int best = 0;
for(int b=1; b<h.size(); ++b)
@ -2608,7 +2607,7 @@ std::vector<std::pair<CGHeroInstance*, ObjectInstanceID> > CGameState::campaignH
logGlobal->warnStream() << "Warning, no hero to replace!";
map->removeBlockVisTiles(hp, true);
delete hp;
map->objects[g] = NULL;
map->objects[g] = nullptr;
}
//we don't have to remove hero from Xheroes because it would destroy the order and duplicates shouldn't happen
}
@ -2673,7 +2672,7 @@ CGPathNode::CGPathNode()
land = 0;
moveRemains = 0;
turns = 255;
theNodeBefore = NULL;
theNodeBefore = nullptr;
}
bool CGPathNode::reachable() const
@ -2703,7 +2702,7 @@ bool CPathsInfo::getPath( const int3 &dst, CGPath &out )
CPathsInfo::CPathsInfo( const int3 &Sizes )
:sizes(Sizes)
{
hero = NULL;
hero = nullptr;
nodes = new CGPathNode**[sizes.x];
for(int i = 0; i < sizes.x; i++)
{
@ -2781,7 +2780,7 @@ void InfoAboutHero::assign(const InfoAboutHero & iah)
{
InfoAboutArmy::operator = (iah);
details = (iah.details ? new Details(*iah.details) : NULL);
details = (iah.details ? new Details(*iah.details) : nullptr);
hclass = iah.hclass;
portrait = iah.portrait;
}
@ -3054,7 +3053,7 @@ void CPathfinder::initializeGraph()
node.coord.y = j;
node.coord.z = k;
node.land = tinfo->terType != ETerrainType::WATER;
node.theNodeBefore = NULL;
node.theNodeBefore = nullptr;
}
}
}

10
lib/CGameState.h
View File

@ -179,7 +179,7 @@ public:
ui8 daysWithoutCastle;
PlayerState();
std::string nodeName() const OVERRIDE;
std::string nodeName() const override;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -350,7 +350,7 @@ private:
public:
CPathfinder(CPathsInfo &_out, CGameState *_gs, const CGHeroInstance *_hero);
void calculatePaths(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
void calculatePaths(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 nullptr if path does not exists
};
@ -370,10 +370,10 @@ public:
struct DLL_LINKAGE HeroesPool
{
bmap<ui32, ConstTransitivePtr<CGHeroInstance> > heroesPool; //[subID] - heroes available to buy; NULL if not available
bmap<ui32, ConstTransitivePtr<CGHeroInstance> > heroesPool; //[subID] - heroes available to buy; nullptr if not available
bmap<ui32,ui8> pavailable; // [subid] -> which players can recruit hero (binary flags)
CGHeroInstance * pickHeroFor(bool native, PlayerColor 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 = nullptr) const;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -401,7 +401,7 @@ public:
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
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 nullptr if path does not exists
int3 guardingCreaturePosition (int3 pos) const;
std::vector<CGObjectInstance*> guardingCreatures (int3 pos) const;
int victoryCheck(PlayerColor player) const; //checks if given player is winner; -1 if std victory, 1 if special victory, 0 else

8
lib/CModHandler.cpp
View File

@ -45,7 +45,7 @@ void CIdentifierStorage::checkIdentifier(std::string & ID)
}
CIdentifierStorage::ObjectCallback::ObjectCallback(std::string localScope, std::string remoteScope, std::string type,
std::string name, const boost::function<void(si32)> & callback):
std::string name, const std::function<void(si32)> & callback):
localScope(localScope),
remoteScope(remoteScope),
type(type),
@ -81,21 +81,21 @@ void CIdentifierStorage::requestIdentifier(ObjectCallback callback)
scheduledRequests.push_back(callback);
}
void CIdentifierStorage::requestIdentifier(std::string scope, std::string type, std::string name, const boost::function<void(si32)> & callback)
void CIdentifierStorage::requestIdentifier(std::string scope, std::string type, std::string name, const std::function<void(si32)> & callback)
{
auto pair = splitString(name, ':'); // remoteScope:name
requestIdentifier(ObjectCallback(scope, pair.first, type, pair.second, callback));
}
void CIdentifierStorage::requestIdentifier(std::string type, const JsonNode & name, const boost::function<void(si32)> & callback)
void CIdentifierStorage::requestIdentifier(std::string type, const JsonNode & name, const std::function<void(si32)> & callback)
{
auto pair = splitString(name.String(), ':'); // remoteScope:name
requestIdentifier(ObjectCallback(name.meta, pair.first, type, pair.second, callback));
}
void CIdentifierStorage::requestIdentifier(const JsonNode & name, const boost::function<void(si32)> & callback)
void CIdentifierStorage::requestIdentifier(const JsonNode & name, const std::function<void(si32)> & callback)
{
auto pair = splitString(name.String(), ':'); // remoteScope:<type.name>
auto pair2 = splitString(pair.second, '.'); // type.name

10
lib/CModHandler.h
View File

@ -31,9 +31,9 @@ class CIdentifierStorage
std::string remoteScope; /// scope in which this object must be found
std::string type; /// type, e.g. creature, faction, hero, etc
std::string name; /// string ID
boost::function<void(si32)> callback;
std::function<void(si32)> callback;
ObjectCallback(std::string localScope, std::string remoteScope, std::string type, std::string name, const boost::function<void(si32)> & callback);
ObjectCallback(std::string localScope, std::string remoteScope, std::string type, std::string name, const std::function<void(si32)> & callback);
};
struct ObjectData // entry created on ID registration
@ -53,9 +53,9 @@ class CIdentifierStorage
public:
/// request identifier for specific object name. If ID is not yet resolved callback will be queued
/// and will be called later
void requestIdentifier(std::string scope, std::string type, std::string name, const boost::function<void(si32)> & callback);
void requestIdentifier(std::string type, const JsonNode & name, const boost::function<void(si32)> & callback);
void requestIdentifier(const JsonNode & name, const boost::function<void(si32)> & callback);
void requestIdentifier(std::string scope, std::string type, std::string name, const std::function<void(si32)> & callback);
void requestIdentifier(std::string type, const JsonNode & name, const std::function<void(si32)> & callback);
void requestIdentifier(const JsonNode & name, const std::function<void(si32)> & callback);
/// registers new object, calls all associated callbacks
void registerObject(std::string scope, std::string type, std::string name, si32 identifier);

68
lib/CObjectHandler.cpp
View File

@ -18,7 +18,6 @@
#include "CSpellHandler.h"
#include "CModHandler.h"
#include "../client/CSoundBase.h"
#include <boost/random/linear_congruential.hpp>
#include "CTownHandler.h"
#include "CCreatureHandler.h"
#include "VCMI_Lib.h"
@ -41,8 +40,8 @@ using namespace boost::assign;
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;
IGameCallback * IObjectInterface::cb = nullptr;
extern std::minstd_rand ran;
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
@ -304,7 +303,7 @@ CGObjectInstance::CGObjectInstance()
//state = new CLuaObjectScript();
ID = Obj::NO_OBJ;
subID = -1;
defInfo = NULL;
defInfo = nullptr;
tempOwner = PlayerColor::UNFLAGGABLE;
blockVisit = false;
}
@ -312,7 +311,7 @@ CGObjectInstance::~CGObjectInstance()
{
//if (state)
// delete state;
//state=NULL;
//state=nullptr;
}
const std::string & CGObjectInstance::getHoverText() const
@ -336,9 +335,9 @@ int CGObjectInstance::getHeight() const //returns height of object graphic in ti
}
bool CGObjectInstance::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)
{
if(defInfo==NULL)
if(defInfo==nullptr)
{
logGlobal->warnStream() << "Warning: VisitableAt for obj "<< id.getNum() <<": NULL defInfo!";
logGlobal->warnStream() << "Warning: VisitableAt for obj "<< id.getNum() <<": nullptr defInfo!";
return false;
}
@ -351,7 +350,7 @@ bool CGObjectInstance::visitableAt(int x, int y) const //returns true if object
}
bool CGObjectInstance::blockingAt(int x, int y) const
{
if(x<0 || y<0 || x>=getWidth() || y>=getHeight() || defInfo==NULL)
if(x<0 || y<0 || x>=getWidth() || y>=getHeight() || defInfo==nullptr)
return false;
if((defInfo->blockMap[y+6-getHeight()] >> (7-(8-getWidth()+x) )) & 1)
return false;
@ -754,10 +753,10 @@ CGHeroInstance::CGHeroInstance()
isStanding = true;
moveDir = 4;
exp = 0xffffffff;
visitedTown = NULL;
type = NULL;
boat = NULL;
commander = NULL;
visitedTown = nullptr;
type = nullptr;
boat = nullptr;
commander = nullptr;
sex = 0xff;
secSkills.push_back(std::make_pair(SecondarySkill::DEFAULT, -1));
}
@ -842,7 +841,7 @@ void CGHeroInstance::initHero()
mana = manaLimit();
}
void CGHeroInstance::initArmy(IArmyDescriptor *dst /*= NULL*/)
void CGHeroInstance::initArmy(IArmyDescriptor *dst /*= nullptr*/)
{
if(!dst)
dst = this;
@ -1206,7 +1205,7 @@ void CGHeroInstance::Updatespecialty() //TODO: calculate special value of bonuse
break; //use only hero skills as bonuses to avoid feedback loop
case Bonus::PRIMARY_SKILL: //for creatures, that is
{
const CCreature * cre = NULL;
const CCreature * cre = nullptr;
int creLevel = 0;
if (auto creatureLimiter = std::dynamic_pointer_cast<CCreatureTypeLimiter>(b->limiter)) //TODO: more general eveluation of bonuses?
{
@ -2167,7 +2166,7 @@ void CGTownInstance::onHeroVisit(const CGHeroInstance * h) const
{
if(armedGarrison() || visitingHero)
{
const CGHeroInstance *defendingHero = NULL;
const CGHeroInstance *defendingHero = nullptr;
const CArmedInstance *defendingArmy = this;
if(visitingHero)
@ -2183,7 +2182,7 @@ void CGTownInstance::onHeroVisit(const CGHeroInstance * h) const
//TODO
//"borrowing" army from garrison to visiting hero
cb->startBattlePrimary(h, defendingArmy, getSightCenter(), h, defendingHero, false, (outsideTown ? NULL : this));
cb->startBattlePrimary(h, defendingArmy, getSightCenter(), h, defendingHero, false, (outsideTown ? nullptr : this));
}
else
{
@ -2581,10 +2580,10 @@ void CGTownInstance::setVisitingHero(CGHeroInstance *h)
else
{
PlayerState *p = cb->gameState()->getPlayer(visitingHero->tempOwner);
visitingHero->visitedTown = NULL;
visitingHero->visitedTown = nullptr;
visitingHero->detachFrom(&townAndVis);
visitingHero->attachTo(p);
visitingHero = NULL;
visitingHero = nullptr;
}
}
@ -2604,11 +2603,11 @@ void CGTownInstance::setGarrisonedHero(CGHeroInstance *h)
else
{
PlayerState *p = cb->gameState()->getPlayer(garrisonHero->tempOwner);
garrisonHero->visitedTown = NULL;
garrisonHero->visitedTown = nullptr;
garrisonHero->inTownGarrison = false;
garrisonHero->detachFrom(this);
garrisonHero->attachTo(p);
garrisonHero = NULL;
garrisonHero = nullptr;
}
updateMoraleBonusFromArmy(); //avoid giving morale bonus for same army twice
}
@ -3954,7 +3953,10 @@ void CGTeleport::postInit() //matches subterranean gates into pairs
}
//sort by position
std::sort(gatesSplit[0].begin(), gatesSplit[0].end(), boost::bind(&CGObjectInstance::pos, _1) < boost::bind(&CGObjectInstance::pos, _2));
std::sort(gatesSplit[0].begin(), gatesSplit[0].end(), [](const CGObjectInstance * a, const CGObjectInstance * b)
{
return a->pos < b->pos;
});
for(size_t i = 0; i < gatesSplit[0].size(); i++)
{
@ -3978,7 +3980,7 @@ void CGTeleport::postInit() //matches subterranean gates into pairs
if(best.first >= 0) //found pair
{
gates.push_back(std::make_pair(cur->id, gatesSplit[1][best.first]->id));
gatesSplit[1][best.first] = NULL;
gatesSplit[1][best.first] = nullptr;
}
else
{
@ -4956,7 +4958,7 @@ const CGHeroInstance * CGSeerHut::getHeroToKill(bool allowNull) const
{
const CGObjectInstance *o = cb->getObjByQuestIdentifier(quest->m13489val);
if(allowNull && !o)
return NULL;
return nullptr;
assert(o && o->ID == Obj::HERO);
return static_cast<const CGHeroInstance*>(o);
}
@ -4965,7 +4967,7 @@ const CGCreature * CGSeerHut::getCreatureToKill(bool allowNull) const
{
const CGObjectInstance *o = cb->getObjByQuestIdentifier(quest->m13489val);
if(allowNull && !o)
return NULL;
return nullptr;
assert(o && o->ID == Obj::MONSTER);
return static_cast<const CGCreature*>(o);
}
@ -6080,7 +6082,7 @@ void CGOnceVisitable::blockingDialogAnswered(const CGHeroInstance *hero, ui32 an
void CBank::initObj()
{
index = VLC->objh->bankObjToIndex(this);
bc = NULL;
bc = nullptr;
daycounter = 0;
multiplier = 1;
}
@ -6150,7 +6152,7 @@ void CBank::setPropertyDer (ui8 what, ui32 val)
reset (val%100);
break;
case ObjProperty::BANK_CLEAR_CONFIG:
bc = NULL;
bc = nullptr;
break;
case ObjProperty::BANK_CLEAR_ARTIFACTS: //remove rewards from Derelict Ship
artifacts.clear();
@ -6210,7 +6212,7 @@ void CBank::setPropertyDer (ui8 what, ui32 val)
void CBank::newTurn() const
{
if (bc == NULL)
if (bc == nullptr)
{
if (cb->getDate() == 1)
initialize(); //initialize on first day
@ -6415,7 +6417,7 @@ void CBank::battleFinished(const CGHeroInstance *hero, const BattleResult &resul
cb->showInfoDialog(&iw);
cb->giveCreatures(this, hero, ourArmy, false);
}
cb->setObjProperty (id, ObjProperty::BANK_CLEAR_CONFIG, 0); //bc = NULL
cb->setObjProperty (id, ObjProperty::BANK_CLEAR_CONFIG, 0); //bc = nullptr
}
}
@ -6659,7 +6661,7 @@ void CGMagi::onHeroVisit(const CGHeroInstance * h) const
}
void CGBoat::initObj()
{
hero = NULL;
hero = nullptr;
}
void CGSirens::initObj()
@ -6804,7 +6806,7 @@ IShipyard::IShipyard(const CGObjectInstance *O)
IShipyard * IShipyard::castFrom( CGObjectInstance *obj )
{
if(!obj)
return NULL;
return nullptr;
if(obj->ID == Obj::TOWN)
{
@ -6816,7 +6818,7 @@ IShipyard * IShipyard::castFrom( CGObjectInstance *obj )
}
else
{
return NULL;
return nullptr;
}
}
@ -7047,7 +7049,7 @@ void CArmedInstance::randomizeArmy(int type)
CArmedInstance::CArmedInstance()
{
battle = NULL;
battle = nullptr;
}
//int CArmedInstance::valOfGlobalBonuses(CSelector selector) const
@ -7294,7 +7296,7 @@ const IMarket * IMarket::castFrom(const CGObjectInstance *obj, bool verbose /*=
default:
if(verbose)
logGlobal->errorStream() << "Cannot cast to IMarket object with ID " << obj->ID;
return NULL;
return nullptr;
}
}

70
lib/CObjectHandler.h
View File

@ -81,8 +81,8 @@ public:
CQuest(){missionType = MISSION_NONE;}; //default constructor
virtual bool checkQuest (const CGHeroInstance * h) const; //determines whether the quest is complete or not
virtual void getVisitText (MetaString &text, std::vector<Component> &components, bool isCustom, bool FirstVisit, const CGHeroInstance * h = NULL) const;
virtual void getCompletionText (MetaString &text, std::vector<Component> &components, bool isCustom, const CGHeroInstance * h = NULL) const;
virtual void getVisitText (MetaString &text, std::vector<Component> &components, bool isCustom, bool FirstVisit, const CGHeroInstance * h = nullptr) const;
virtual void getCompletionText (MetaString &text, std::vector<Component> &components, bool isCustom, const CGHeroInstance * h = nullptr) const;
virtual void getRolloverText (MetaString &text, bool onHover) const; //hover or quest log entry
virtual void completeQuest (const CGHeroInstance * h) const {};
virtual void addReplacements(MetaString &out, const std::string &base) const;
@ -141,7 +141,7 @@ public:
enum EGeneratorState {GOOD, BOAT_ALREADY_BUILT, TILE_BLOCKED, NO_WATER};
EGeneratorState state() const; //0 - can buid, 1 - there is already a boat at dest tile, 2 - dest tile is blocked, 3 - no water
void getProblemText(MetaString &out, const CGHeroInstance *visitor = NULL) const;
void getProblemText(MetaString &out, const CGHeroInstance *visitor = nullptr) const;
};
class DLL_LINKAGE IShipyard : public IBoatGenerator
@ -395,7 +395,7 @@ public:
double getHeroStrength() const;
ui64 getTotalStrength() const;
TExpType calculateXp(TExpType exp) const; //apply learning skill
ui8 getSpellSchoolLevel(const CSpell * spell, int *outSelectedSchool = NULL) const; //returns level on which given spell would be cast by this hero (0 - none, 1 - basic etc); optionally returns number of selected school by arg - 0 - air magic, 1 - fire magic, 2 - water magic, 3 - earth magic,
ui8 getSpellSchoolLevel(const CSpell * spell, int *outSelectedSchool = nullptr) const; //returns level on which given spell would be cast by this hero (0 - none, 1 - basic etc); optionally returns number of selected school by arg - 0 - air magic, 1 - fire magic, 2 - water magic, 3 - earth magic,
bool canCastThisSpell(const CSpell * spell) const; //determines if this hero can cast given spell; takes into account existing spell in spellbook, existing spellbook and artifact bonuses
CStackBasicDescriptor calculateNecromancy (const BattleResult &battleResult) const;
void showNecromancyDialog(const CStackBasicDescriptor &raisedStack) const;
@ -411,7 +411,7 @@ public:
void putArtifact(ArtifactPosition pos, CArtifactInstance *art);
void putInBackpack(CArtifactInstance *art);
void initExp();
void initArmy(IArmyDescriptor *dst = NULL);
void initArmy(IArmyDescriptor *dst = nullptr);
//void giveArtifact (ui32 aid);
void initHeroDefInfo();
void pushPrimSkill(PrimarySkill::PrimarySkill which, int val);
@ -477,8 +477,8 @@ public:
void onHeroVisit(const CGHeroInstance * h) const override;
void newTurn() const override;
void setProperty(ui8 what, ui32 val) override;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const OVERRIDE;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const OVERRIDE;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const override;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const override;
private:
void heroAcceptsCreatures(const CGHeroInstance *h) const;
@ -495,7 +495,7 @@ public:
void onHeroVisit(const CGHeroInstance * h) const override;
void initObj() override;
bool wasVisited (const CGHeroInstance * h) const override;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const OVERRIDE;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const override;
template <typename Handler> void serialize(Handler &h, const int version)
@ -533,7 +533,7 @@ public:
void onHeroVisit (const CGHeroInstance * h) const override;
COPWBonus (BuildingID index, CGTownInstance *TOWN);
COPWBonus (){ID = BuildingID::NONE; town = NULL;};
COPWBonus (){ID = BuildingID::NONE; town = nullptr;};
template <typename Handler> void serialize(Handler &h, const int version)
{
h & static_cast<CGTownBuilding&>(*this);
@ -551,7 +551,7 @@ public:
void onHeroVisit (const CGHeroInstance * h) const override;
CTownBonus (BuildingID index, CGTownInstance *TOWN);
CTownBonus (){ID = BuildingID::NONE; town = NULL;};
CTownBonus (){ID = BuildingID::NONE; town = nullptr;};
template <typename Handler> void serialize(Handler &h, const int version)
{
h & static_cast<CGTownBuilding&>(*this);
@ -672,7 +672,7 @@ public:
void onHeroVisit(const CGHeroInstance * h) const override;
void onHeroLeave(const CGHeroInstance * h) const override;
void initObj() override;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const OVERRIDE;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const override;
protected:
void setPropertyDer(ui8 what, ui32 val) override;
};
@ -697,9 +697,9 @@ public:
void initObj() override;
void onHeroVisit(const CGHeroInstance * h) const override;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const OVERRIDE;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const OVERRIDE;
void heroLevelUpDone(const CGHeroInstance *hero) const OVERRIDE;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const override;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const override;
void heroLevelUpDone(const CGHeroInstance *hero) const override;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -756,8 +756,8 @@ public:
const std::string & getHoverText() const override;
void initObj() override;
void newTurn() const override;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const OVERRIDE;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const OVERRIDE;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const override;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const override;
struct DLL_LINKAGE RestoredCreature // info about merging stacks after battle back into one
@ -810,7 +810,7 @@ public:
CQuest * quest;
IQuestObject(){quest = new CQuest;};
virtual void getVisitText (MetaString &text, std::vector<Component> &components, bool isCustom, bool FirstVisit, const CGHeroInstance * h = NULL) const;
virtual void getVisitText (MetaString &text, std::vector<Component> &components, bool isCustom, bool FirstVisit, const CGHeroInstance * h = nullptr) const;
virtual bool checkQuest (const CGHeroInstance * h) const;
template <typename Handler> void serialize(Handler &h, const int version)
@ -833,14 +833,14 @@ public:
const std::string & getHoverText() const override;
void newTurn() const override;
void onHeroVisit(const CGHeroInstance * h) const override;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const OVERRIDE;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const override;
int checkDirection() const; //calculates the region of map where monster is placed
void setObjToKill(); //remember creatures / heroes to kill after they are initialized
const CGHeroInstance *getHeroToKill(bool allowNull = false) const;
const CGCreature *getCreatureToKill(bool allowNull = false) const;
void getRolloverText (MetaString &text, bool onHover) const;
void getCompletionText(MetaString &text, std::vector<Component> &components, bool isCustom, const CGHeroInstance * h = NULL) const;
void getCompletionText(MetaString &text, std::vector<Component> &components, bool isCustom, const CGHeroInstance * h = nullptr) const;
void finishQuest (const CGHeroInstance * h, ui32 accept) const; //common for both objects
void completeQuest (const CGHeroInstance * h) const;
@ -907,7 +907,7 @@ public:
ui8 getPassableness() const;
void onHeroVisit(const CGHeroInstance * h) const override;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const OVERRIDE;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const override;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -923,8 +923,8 @@ public:
std::string message;
void onHeroVisit(const CGHeroInstance * h) const override;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const OVERRIDE;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const OVERRIDE;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const override;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const override;
void pick( const CGHeroInstance * h ) const;
void initObj() override;
@ -944,8 +944,8 @@ public:
void onHeroVisit(const CGHeroInstance * h) const override;
void initObj() override;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const OVERRIDE;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const OVERRIDE;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const override;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const override;
void collectRes(PlayerColor player) const;
@ -963,7 +963,7 @@ public:
void onHeroVisit(const CGHeroInstance * h) const override;
void initObj() override;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const OVERRIDE;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const override;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -994,8 +994,8 @@ public:
ui32 producedQuantity;
void onHeroVisit(const CGHeroInstance * h) const override;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const OVERRIDE;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const OVERRIDE;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const override;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const override;
void flagMine(PlayerColor player) const;
void newTurn() const override;
@ -1143,9 +1143,9 @@ public:
CGBorderGuard() : IQuestObject(){};
void initObj() override;
void onHeroVisit(const CGHeroInstance * h) const override;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const OVERRIDE;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const override;
void getVisitText (MetaString &text, std::vector<Component> &components, bool isCustom, bool FirstVisit, const CGHeroInstance * h = NULL) const;
void getVisitText (MetaString &text, std::vector<Component> &components, bool isCustom, bool FirstVisit, const CGHeroInstance * h = nullptr) const;
void getRolloverText (MetaString &text, bool onHover) const;
bool checkQuest (const CGHeroInstance * h) const;
@ -1181,7 +1181,7 @@ public:
CGBoat()
{
hero = NULL;
hero = nullptr;
direction = 4;
}
template <typename Handler> void serialize(Handler &h, const int version)
@ -1201,7 +1201,7 @@ public:
void onHeroVisit(const CGHeroInstance * h) const override;
const std::string & getHoverText() const override;
void initObj() override;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const OVERRIDE;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const override;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -1226,8 +1226,8 @@ class DLL_LINKAGE CBank : public CArmedInstance
void newTurn() const override;
bool wasVisited (PlayerColor player) const override;
void onHeroVisit(const CGHeroInstance * h) const override;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const OVERRIDE;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const OVERRIDE;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const override;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const override;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -1246,7 +1246,7 @@ public:
const std::string & getHoverText() const override;
void newTurn() const override {}; //empty, no reset
void onHeroVisit(const CGHeroInstance * h) const override;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const OVERRIDE;
void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const override;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -1284,7 +1284,7 @@ class DLL_LINKAGE CCartographer : public CPlayersVisited
///behaviour varies depending on surface and floor
public:
void onHeroVisit(const CGHeroInstance * h) const override;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const OVERRIDE;
void blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) const override;
template <typename Handler> void serialize(Handler &h, const int version)
{

8
lib/CObstacleInstance.h
View File

@ -56,7 +56,7 @@ struct DLL_LINKAGE CObstacleInstance
struct DLL_LINKAGE MoatObstacle : CObstacleInstance
{
virtual std::vector<BattleHex> getAffectedTiles() const OVERRIDE; //for special effects (not blocking)
virtual std::vector<BattleHex> getAffectedTiles() const override; //for special effects (not blocking)
};
struct DLL_LINKAGE SpellCreatedObstacle : CObstacleInstance
@ -69,10 +69,10 @@ struct DLL_LINKAGE SpellCreatedObstacle : CObstacleInstance
SpellCreatedObstacle();
virtual std::vector<BattleHex> getAffectedTiles() const OVERRIDE; //for special effects (not blocking)
virtual bool visibleForSide(ui8 side, bool hasNativeStack) const OVERRIDE; //0 attacker
virtual std::vector<BattleHex> getAffectedTiles() const override; //for special effects (not blocking)
virtual bool visibleForSide(ui8 side, bool hasNativeStack) const override; //0 attacker
virtual void battleTurnPassed() OVERRIDE;
virtual void battleTurnPassed() override;
template <typename Handler> void serialize(Handler &h, const int version)
{

33
lib/CRandomGenerator.h
View File

@ -11,28 +11,11 @@
#pragma once
#include <boost/version.hpp>
#include <boost/random/mersenne_twister.hpp>
#if BOOST_VERSION >= 104700
#include <boost/random/uniform_int_distribution.hpp>
#include <boost/random/uniform_real_distribution.hpp>
#else
#include <boost/random/uniform_int.hpp>
#include <boost/random/uniform_real.hpp>
#endif
#include <boost/random/variate_generator.hpp>
typedef boost::mt19937 TGenerator;
#if BOOST_VERSION >= 104700
typedef boost::random::uniform_int_distribution<int> TIntDist;
typedef boost::random::uniform_real_distribution<double> TRealDist;
#else
typedef boost::uniform_int<int> TIntDist;
typedef boost::uniform_real<double> TRealDist;
#endif
typedef boost::variate_generator<TGenerator &, TIntDist> TRandI;
typedef boost::variate_generator<TGenerator &, TRealDist> TRand;
typedef std::mt19937 TGenerator;
typedef std::uniform_int_distribution<int> TIntDist;
typedef std::uniform_real_distribution<double> TRealDist;
typedef std::function<int()> TRandI;
typedef std::function<double()> TRand;
/// The random generator randomly generates integers and real numbers("doubles") between
/// a given range. This is a header only class and mainly a wrapper for
@ -55,8 +38,7 @@ public:
/// e.g.: auto a = gen.getRangeI(0,10); a(); a(); a();
TRandI getRangeI(int lower, int upper)
{
TIntDist range(lower, upper);
return TRandI(gen, range);
return std::bind(TIntDist(lower, upper), gen);
}
int getInteger(int lower, int upper)
@ -68,8 +50,7 @@ public:
/// e.g.: auto a = gen.getRangeI(0,10); a(); a(); a();
TRand getRange(double lower, double upper)
{
TRealDist range(lower, upper);
return TRand(gen, range);
return std::bind(TRealDist(lower, upper), gen);
}
double getDouble(double lower, double upper)

2
lib/CSpellHandler.h
View File

@ -48,7 +48,7 @@ public:
CSpell();
~CSpell();
std::vector<BattleHex> rangeInHexes(BattleHex centralHex, ui8 schoolLvl, ui8 side, bool *outDroppedHexes = NULL ) const; //convert range to specific hexes; last optional out parameter is set to true, if spell would cover unavailable hexes (that are not included in ret)
std::vector<BattleHex> rangeInHexes(BattleHex centralHex, ui8 schoolLvl, ui8 side, bool *outDroppedHexes = nullptr ) const; //convert range to specific hexes; last optional out parameter is set to true, if spell would cover unavailable hexes (that are not included in ret)
si16 mainEffectAnim; //main spell effect animation, in AC format (or -1 when none)
ETargetType getTargetType() const;

4
lib/CThreadHelper.cpp
View File

@ -16,7 +16,7 @@
*
*/
CThreadHelper::CThreadHelper(std::vector<boost::function<void()> > *Tasks, int Threads)
CThreadHelper::CThreadHelper(std::vector<std::function<void()> > *Tasks, int Threads)
{
currentTask = 0; amount = Tasks->size();
tasks = Tasks;
@ -26,7 +26,7 @@ void CThreadHelper::run()
{
boost::thread_group grupa;
for(int i=0;i<threads;i++)
grupa.create_thread(boost::bind(&CThreadHelper::processTasks,this));
grupa.create_thread(std::bind(&CThreadHelper::processTasks,this));
grupa.join_all();
}
void CThreadHelper::processTasks()

14
lib/CThreadHelper.h
View File

@ -13,7 +13,7 @@
*
*/
typedef boost::function<void()> Task;
typedef std::function<void()> Task;
/// Can assign CPU work to other threads/cores
class DLL_LINKAGE CThreadHelper
@ -25,11 +25,11 @@ class DLL_LINKAGE CThreadHelper
void processTasks();
public:
CThreadHelper(std::vector<boost::function<void()> > *Tasks, int Threads);
CThreadHelper(std::vector<std::function<void()> > *Tasks, int Threads);
void run();
};
template <typename T> inline void setData(T * data, boost::function<T()> func)
template <typename T> inline void setData(T * data, std::function<T()> func)
{
*data = func();
}
@ -37,16 +37,16 @@ template <typename T> inline void setData(T * data, boost::function<T()> func)
void DLL_LINKAGE setThreadName(const std::string &name);
#define GET_DATA(TYPE,DESTINATION,FUNCTION_TO_GET) \
(boost::bind(&setData<TYPE>,&DESTINATION,FUNCTION_TO_GET))
(std::bind(&setData<TYPE>,&DESTINATION,FUNCTION_TO_GET))
#define GET_SURFACE(SUR_DESTINATION, SUR_NAME) \
(GET_DATA \
(SDL_Surface*,SUR_DESTINATION,\
boost::function<SDL_Surface*()>(boost::bind(&BitmapHandler::loadBitmap,SUR_NAME,true))))
std::function<SDL_Surface*()>(std::bind(&BitmapHandler::loadBitmap,SUR_NAME,true))))
#define GET_DEF(DESTINATION, DEF_NAME) \
(GET_DATA \
(CDefHandler*,DESTINATION,\
boost::function<CDefHandler*()>(boost::bind(CDefHandler::giveDef,DEF_NAME))))
std::function<CDefHandler*()>(std::bind(CDefHandler::giveDef,DEF_NAME))))
#define GET_DEF_ESS(DESTINATION, DEF_NAME) \
(GET_DATA \
(CDefEssential*,DESTINATION,\
boost::function<CDefEssential*()>(boost::bind(CDefHandler::giveDefEss,DEF_NAME))))
std::function<CDefEssential*()>(std::bind(CDefHandler::giveDefEss,DEF_NAME))))

6
lib/Connection.cpp
View File

@ -60,7 +60,7 @@ void CConnection::init()
wmx = new boost::mutex;
rmx = new boost::mutex;
handler = NULL;
handler = nullptr;
receivedStop = sendStop = false;
static int cid = 1;
connectionID = cid++;
@ -199,7 +199,7 @@ void CConnection::close()
{
socket->close();
delete socket;
socket = NULL;
socket = nullptr;
}
}
@ -220,7 +220,7 @@ void CConnection::reportState(CLogger * out)
CPack * CConnection::retreivePack()
{
CPack *ret = NULL;
CPack *ret = nullptr;
boost::unique_lock<boost::mutex> lock(*rmx);
logNetwork->traceStream() << "Listening... ";
*this >> ret;

26
lib/Connection.h
View File

@ -91,19 +91,19 @@ class DLL_LINKAGE CTypeList
public:
CTypeList();
ui16 registerType(const std::type_info *type);
template <typename T> ui16 registerType(const T * t = NULL)
template <typename T> ui16 registerType(const T * t = nullptr)
{
return registerType(getTypeInfo(t));
}
ui16 getTypeID(const std::type_info *type);
template <typename T> ui16 getTypeID(const T * t = NULL)
template <typename T> ui16 getTypeID(const T * t = nullptr)
{
return getTypeID(getTypeInfo(t));
}
template <typename T> const std::type_info * getTypeInfo(const T * t = NULL)
template <typename T> const std::type_info * getTypeInfo(const T * t = nullptr)
{
if(t)
return &typeid(*t);
@ -351,7 +351,7 @@ public:
template <typename T, typename U>
const VectorisedObjectInfo<T, U> *getVectorisedTypeInfo()
{
const std::type_info *myType = NULL;
const std::type_info *myType = nullptr;
//
// if(boost::is_base_of<CGObjectInstance, T>::value) //ugly workaround to support also types derived from CGObjectInstance -> if we encounter one, treat it aas CGObj..
// myType = &typeid(CGObjectInstance);
@ -360,7 +360,7 @@ public:
TTypeVecMap::iterator i = vectors.find(myType);
if(i == vectors.end())
return NULL;
return nullptr;
else
{
assert(!i->second.empty());
@ -374,7 +374,7 @@ public:
T* getVectorItemFromId(const VectorisedObjectInfo<T, U> &oInfo, U id) const
{
/* if(id < 0)
return NULL;*/
return nullptr;*/
si32 idAsNumber = idToNumber(id);
assert(oInfo.vector);
@ -557,7 +557,7 @@ public:
delete iter->second;
}
template<typename T> void registerType(const T * t=NULL)
template<typename T> void registerType(const T * t=nullptr)
{
ui16 ID = typeList.registerType(t);
savers[ID] = new CPointerSaver<COSer<Serializer>,T>;
@ -593,11 +593,11 @@ public:
template <typename T>
void savePointer(const T &data)
{
//write if pointer is not NULL
ui8 hlp = (data!=NULL);
//write if pointer is not nullptr
ui8 hlp = (data!=nullptr);
*this << hlp;
//if pointer is NULL then we don't need anything more...
//if pointer is nullptr then we don't need anything more...
if(!hlp)
return;
@ -873,7 +873,7 @@ public:
delete iter->second;
}
template<typename T> void registerType(const T * t=NULL)
template<typename T> void registerType(const T * t=nullptr)
{
ui16 ID = typeList.registerType(t);
loaders[ID] = new CPointerLoader<CISer<Serializer>,T>;
@ -980,7 +980,7 @@ public:
*this >> hlp;
if(!hlp)
{
data = NULL;
data = nullptr;
return;
}
@ -1374,7 +1374,7 @@ public:
for(iter = apps.begin(); iter != apps.end(); iter++)
delete iter->second;
}
template<typename U> void registerType(const U * t=NULL)
template<typename U> void registerType(const U * t=nullptr)
{
ui16 ID = typeList.registerType(t);
apps[ID] = T::getApplier(t);

4
lib/ConstTransitivePtr.h
View File

@ -20,7 +20,7 @@ class ConstTransitivePtr
: ptr(const_cast<T*>(Ptr))
{}
public:
ConstTransitivePtr(T *Ptr = NULL)
ConstTransitivePtr(T *Ptr = nullptr)
: ptr(Ptr)
{}
@ -64,7 +64,7 @@ public:
void dellNull()
{
delete ptr;
ptr = NULL;
ptr = nullptr;
}
template <typename Handler> void serialize(Handler &h, const int version)

32
lib/HeroBonus.cpp
View File

@ -187,7 +187,7 @@ const Bonus * BonusList::getFirst(const CSelector &selector) const
if(selector(b))
return &*b;
}
return NULL;
return nullptr;
}
Bonus * BonusList::getFirst(const CSelector &select)
@ -198,7 +198,7 @@ Bonus * BonusList::getFirst(const CSelector &select)
if(select(b))
return &*b;
}
return NULL;
return nullptr;
}
void BonusList::getModifiersWDescr(TModDescr &out) const
@ -248,7 +248,7 @@ int BonusList::valOfBonuses(const CSelector &select) const
// void BonusList::limit(const CBonusSystemNode &node)
// {
// remove_if(boost::bind(&CBonusSystemNode::isLimitedOnUs, boost::ref(node), _1));
// remove_if(std::bind(&CBonusSystemNode::isLimitedOnUs, std::ref(node), _1));
// }
@ -329,7 +329,7 @@ int IBonusBearer::valOfBonuses(Bonus::BonusType type, int subtype /*= -1*/) cons
int IBonusBearer::valOfBonuses(const CSelector &selector, const std::string &cachingStr) const
{
CSelector limit = 0;
TBonusListPtr hlp = getAllBonuses(selector, limit, NULL, cachingStr);
TBonusListPtr hlp = getAllBonuses(selector, limit, nullptr, cachingStr);
return hlp->totalValue();
}
bool IBonusBearer::hasBonus(const CSelector &selector, const std::string &cachingStr /*= ""*/) const
@ -374,12 +374,12 @@ int IBonusBearer::getBonusesCount(const CSelector &selector, const std::string &
const TBonusListPtr IBonusBearer::getBonuses(const CSelector &selector, const std::string &cachingStr /*= ""*/) const
{
return getAllBonuses(selector, 0, NULL, cachingStr);
return getAllBonuses(selector, 0, nullptr, cachingStr);
}
const TBonusListPtr IBonusBearer::getBonuses(const CSelector &selector, const CSelector &limit, const std::string &cachingStr /*= ""*/) const
{
return getAllBonuses(selector, limit, NULL, cachingStr);
return getAllBonuses(selector, limit, nullptr, cachingStr);
}
bool IBonusBearer::hasBonusFrom(Bonus::BonusSource source, ui32 sourceID) const
@ -512,7 +512,7 @@ const Bonus * IBonusBearer::getEffect(ui16 id, int turn /*= 0*/) const
return &(*it);
}
}
return NULL;
return nullptr;
}
ui8 IBonusBearer::howManyEffectsSet(ui16 id) const
@ -558,7 +558,7 @@ Bonus * CBonusSystemNode::getBonusLocalFirst(const CSelector &selector)
return ret;
}
return NULL;
return nullptr;
}
const Bonus * CBonusSystemNode::getBonusLocalFirst( const CSelector &selector ) const
@ -604,7 +604,7 @@ void CBonusSystemNode::getAllBonusesRec(BonusList &out) const
bonuses.getAllBonuses(out);
}
const TBonusListPtr CBonusSystemNode::getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root /*= NULL*/, const std::string &cachingStr /*= ""*/) const
const TBonusListPtr CBonusSystemNode::getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root /*= nullptr*/, const std::string &cachingStr /*= ""*/) const
{
bool limitOnUs = (!root || root == this); //caching won't work when we want to limit bonuses against an external node
if (CBonusSystemNode::cachingEnabled && limitOnUs)
@ -657,7 +657,7 @@ const TBonusListPtr CBonusSystemNode::getAllBonuses(const CSelector &selector, c
}
}
const TBonusListPtr CBonusSystemNode::getAllBonusesWithoutCaching(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root /*= NULL*/) const
const TBonusListPtr CBonusSystemNode::getAllBonusesWithoutCaching(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root /*= nullptr*/) const
{
auto ret = make_shared<BonusList>();
@ -1099,7 +1099,7 @@ const CSpell * Bonus::sourceSpell() const
{
if(source == SPELL_EFFECT)
return SpellID(sid).toSpell();
return NULL;
return nullptr;
}
std::string Bonus::Description() const
@ -1250,7 +1250,7 @@ const CStack * retreiveStackBattle(const CBonusSystemNode *node)
case CBonusSystemNode::STACK_BATTLE:
return static_cast<const CStack*>(node);
default:
return NULL;
return nullptr;
}
}
@ -1263,7 +1263,7 @@ const CStackInstance * retreiveStackInstance(const CBonusSystemNode *node)
case CBonusSystemNode::STACK_BATTLE:
return (static_cast<const CStack*>(node))->base;
default:
return NULL;
return nullptr;
}
}
@ -1277,7 +1277,7 @@ const CCreature * retrieveCreature(const CBonusSystemNode *node)
const CStackInstance *csi = retreiveStackInstance(node);
if(csi)
return csi->type;
return NULL;
return nullptr;
}
}
@ -1360,7 +1360,7 @@ CCreatureTypeLimiter::CCreatureTypeLimiter(const CCreature &Creature, bool Inclu
CCreatureTypeLimiter::CCreatureTypeLimiter()
{
creature = NULL;
creature = nullptr;
includeUpgrades = false;
}
@ -1410,7 +1410,7 @@ bool IPropagator::shouldBeAttached(CBonusSystemNode *dest)
// CBonusSystemNode * CPropagatorNodeType::getDestNode(CBonusSystemNode *source, CBonusSystemNode *redParent, CBonusSystemNode *redChild)
// {
// return NULL;
// return nullptr;
// }
CPropagatorNodeType::CPropagatorNodeType()

32
lib/HeroBonus.h
View File

@ -27,7 +27,7 @@ typedef std::vector<std::pair<int,std::string> > TModDescr; //modifiers values a
typedef std::set<CBonusSystemNode*> TNodes;
typedef std::set<const CBonusSystemNode*> TCNodes;
typedef std::vector<CBonusSystemNode *> TNodesVector;
typedef boost::function<bool(const Bonus*)> CSelector;
typedef std::function<bool(const Bonus*)> CSelector;
@ -373,7 +373,7 @@ public:
void push_back(Bonus* const &x);
std::vector<Bonus*>::iterator erase (const int position);
void clear();
void resize(std::vector<Bonus*>::size_type sz, Bonus* c = NULL );
void resize(std::vector<Bonus*>::size_type sz, Bonus* c = nullptr );
void insert(std::vector<Bonus*>::iterator position, std::vector<Bonus*>::size_type n, Bonus* const &x);
Bonus *const &operator[] (std::vector<Bonus*>::size_type n) { return bonuses[n]; }
Bonus *const &operator[] (std::vector<Bonus*>::size_type n) const { return bonuses[n]; }
@ -474,7 +474,7 @@ public:
CPropagatorNodeType();
CPropagatorNodeType(int NodeType);
bool shouldBeAttached(CBonusSystemNode *dest);
//CBonusSystemNode *getDestNode(CBonusSystemNode *source, CBonusSystemNode *redParent, CBonusSystemNode *redChild) OVERRIDE;
//CBonusSystemNode *getDestNode(CBonusSystemNode *source, CBonusSystemNode *redParent, CBonusSystemNode *redChild) override;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -508,9 +508,9 @@ class DLL_LINKAGE IBonusBearer
public:
//new bonusing node interface
// * selector is predicate that tests if HeroBonus matches our criteria
// * root is node on which call was made (NULL will be replaced with this)
// * root is node on which call was made (nullptr will be replaced with this)
//interface
virtual const TBonusListPtr getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root = NULL, const std::string &cachingStr = "") const = 0;
virtual const TBonusListPtr getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root = nullptr, const std::string &cachingStr = "") const = 0;
void getModifiersWDescr(TModDescr &out, const CSelector &selector, const std::string &cachingStr = "") const; //out: pairs<modifier value, modifier description>
int getBonusesCount(const CSelector &selector, const std::string &cachingStr = "") const;
int valOfBonuses(const CSelector &selector, const std::string &cachingStr = "") const;
@ -577,7 +577,7 @@ private:
void getBonusesRec(BonusList &out, const CSelector &selector, const CSelector &limit) const;
void getAllBonusesRec(BonusList &out) const;
const TBonusListPtr getAllBonusesWithoutCaching(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root = NULL) const;
const TBonusListPtr getAllBonusesWithoutCaching(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root = nullptr) const;
public:
@ -586,7 +586,7 @@ public:
void limitBonuses(const BonusList &allBonuses, BonusList &out) const; //out will bo populed with bonuses that are not limited here
TBonusListPtr limitBonuses(const BonusList &allBonuses) const; //same as above, returns out by val for convienence
const TBonusListPtr getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root = NULL, const std::string &cachingStr = "") const;
const TBonusListPtr getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root = nullptr, const std::string &cachingStr = "") const;
void getParents(TCNodes &out) const; //retrieves list of parent nodes (nodes to inherit bonuses from),
const Bonus *getBonusLocalFirst(const CSelector &selector) const;
@ -651,7 +651,7 @@ public:
namespace NBonus
{
//set of methods that may be safely called with NULL objs
//set of methods that may be safely called with nullptr objs
DLL_LINKAGE int valOf(const CBonusSystemNode *obj, Bonus::BonusType type, int subtype = -1); //subtype -> subtype of bonus, if -1 then any
DLL_LINKAGE bool hasOfType(const CBonusSystemNode *obj, Bonus::BonusType type, int subtype = -1);//determines if hero has a bonus of given type (and optionally subtype)
//DLL_LINKAGE const HeroBonus * get(const CBonusSystemNode *obj, int from, int id );
@ -796,7 +796,7 @@ class DLL_LINKAGE LimiterList : public ILimiter
std::vector<TLimiterPtr> limiters;
public:
int limit(const BonusLimitationContext &context) const OVERRIDE;
int limit(const BonusLimitationContext &context) const override;
void add(TLimiterPtr limiter);
};
@ -810,7 +810,7 @@ public:
CCreatureTypeLimiter(const CCreature &Creature, bool IncludeUpgrades = true);
void setCreature (CreatureID id);
int limit(const BonusLimitationContext &context) const OVERRIDE;
int limit(const BonusLimitationContext &context) const override;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -829,7 +829,7 @@ public:
HasAnotherBonusLimiter(Bonus::BonusType bonus = Bonus::NONE);
HasAnotherBonusLimiter(Bonus::BonusType bonus, TBonusSubtype _subtype);
int limit(const BonusLimitationContext &context) const OVERRIDE;
int limit(const BonusLimitationContext &context) const override;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -845,7 +845,7 @@ public:
CreatureNativeTerrainLimiter();
CreatureNativeTerrainLimiter(int TerrainType);
int limit(const BonusLimitationContext &context) const OVERRIDE;
int limit(const BonusLimitationContext &context) const override;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -861,7 +861,7 @@ public:
CreatureFactionLimiter();
CreatureFactionLimiter(int TerrainType);
int limit(const BonusLimitationContext &context) const OVERRIDE;
int limit(const BonusLimitationContext &context) const override;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -877,7 +877,7 @@ public:
CreatureAlignmentLimiter();
CreatureAlignmentLimiter(si8 Alignment);
int limit(const BonusLimitationContext &context) const OVERRIDE;
int limit(const BonusLimitationContext &context) const override;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -893,7 +893,7 @@ public:
StackOwnerLimiter();
StackOwnerLimiter(PlayerColor Owner);
int limit(const BonusLimitationContext &context) const OVERRIDE;
int limit(const BonusLimitationContext &context) const override;
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -909,7 +909,7 @@ public:
RankRangeLimiter();
RankRangeLimiter(ui8 Min, ui8 Max = 255);
int limit(const BonusLimitationContext &context) const OVERRIDE;
int limit(const BonusLimitationContext &context) const override;
template <typename Handler> void serialize(Handler &h, const int version)
{

52
lib/IGameCallback.cpp
View File

@ -1,8 +1,6 @@
#include "StdInc.h"
#include "IGameCallback.h"
#include <boost/random/linear_congruential.hpp>
#include "CGameState.h"
#include "mapping/CMap.h"
#include "CObjectHandler.h"
@ -38,7 +36,7 @@
#define ERROR_RET_IF(cond, txt) do {if(cond){logGlobal->errorStream() << BOOST_CURRENT_FUNCTION << ": " << txt; return;}} while(0)
#define ERROR_RET_VAL_IF(cond, txt, retVal) do {if(cond){logGlobal->errorStream() << BOOST_CURRENT_FUNCTION << ": " << txt; return retVal;}} while(0)
extern boost::rand48 ran;
extern std::minstd_rand ran;
CGameState * CPrivilagedInfoCallback::gameState ()
{
@ -63,7 +61,7 @@ int CGameInfoCallback::getResource(PlayerColor Player, Res::ERes which) const
const CGHeroInstance* CGameInfoCallback::getSelectedHero( PlayerColor Player ) const
{
const PlayerState *p = getPlayer(Player);
ERROR_RET_VAL_IF(!p, "No player info!", NULL);
ERROR_RET_VAL_IF(!p, "No player info!", nullptr);
return getHero(p->currentSelection);
}
@ -88,7 +86,7 @@ void CPrivilagedInfoCallback::getTilesInRange( boost::unordered_set<int3, ShashI
getAllTiles (tiles, player, -1, 0);
else
{
const TeamState * team = !player ? NULL : gs->getPlayerTeam(*player);
const TeamState * team = !player ? nullptr : 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++)
@ -259,27 +257,27 @@ template DLL_LINKAGE void CPrivilagedInfoCallback::saveCommonState<CSaveFile>(CS
TerrainTile * CNonConstInfoCallback::getTile( int3 pos )
{
if(!gs->map->isInTheMap(pos))
return NULL;
return nullptr;
return &gs->map->getTile(pos);
}
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);
ERROR_VERBOSE_OR_NOT_RET_VAL_IF(!hasAccess(color), verbose, "Cannot access player " << color << "info!", nullptr);
ERROR_VERBOSE_OR_NOT_RET_VAL_IF(!vstd::contains(gs->players,color), verbose, "Cannot find player " << color << "info!", nullptr);
return &gs->players[color];
}
const CTown * CGameInfoCallback::getNativeTown(PlayerColor color) const
{
const PlayerSettings *ps = getPlayerSettings(color);
ERROR_RET_VAL_IF(!ps, "There is no such player!", NULL);
ERROR_RET_VAL_IF(!ps, "There is no such player!", nullptr);
return VLC->townh->factions[ps->castle]->town;
}
const CGObjectInstance * CGameInfoCallback::getObjByQuestIdentifier(int identifier) const
{
ERROR_RET_VAL_IF(!vstd::contains(gs->map->questIdentifierToId, identifier), "There is no object with such quest identifier!", NULL);
ERROR_RET_VAL_IF(!vstd::contains(gs->map->questIdentifierToId, identifier), "There is no object with such quest identifier!", nullptr);
return getObj(gs->map->questIdentifierToId[identifier]);
}
@ -294,7 +292,7 @@ const CGObjectInstance* CGameInfoCallback::getObj(ObjectInstanceID objid, bool v
{
if(verbose)
logGlobal->errorStream() << "Cannot get object with id " << oid;
return NULL;
return nullptr;
}
const CGObjectInstance *ret = gs->map->objects[oid];
@ -302,14 +300,14 @@ const CGObjectInstance* CGameInfoCallback::getObj(ObjectInstanceID objid, bool v
{
if(verbose)
logGlobal->errorStream() << "Cannot get object with id " << oid << ". Object was removed.";
return NULL;
return nullptr;
}
if(!isVisible(ret, player))
{
if(verbose)
logGlobal->errorStream() << "Cannot get object with id " << oid << ". Object is not visible.";
return NULL;
return nullptr;
}
return ret;
@ -321,7 +319,7 @@ const CGHeroInstance* CGameInfoCallback::getHero(ObjectInstanceID objid) const
if(obj)
return dynamic_cast<const CGHeroInstance*>(obj);
else
return NULL;
return nullptr;
}
const CGTownInstance* CGameInfoCallback::getTown(ObjectInstanceID objid) const
{
@ -329,7 +327,7 @@ const CGTownInstance* CGameInfoCallback::getTown(ObjectInstanceID objid) const
if(obj)
return dynamic_cast<const CGTownInstance*>(obj);
else
return NULL;
return nullptr;
}
void CGameInfoCallback::getUpgradeInfo(const CArmedInstance *obj, SlotID stackPos, UpgradeInfo &out) const
@ -371,7 +369,7 @@ int CGameInfoCallback::estimateSpellDamage(const CSpell * sp, const CGHeroInstan
{
if (hero) //but we see hero's spellbook
return gs->curB->calculateSpellDmg(
sp, hero, NULL, hero->getSpellSchoolLevel(sp), hero->getPrimSkillLevel(PrimarySkill::SPELL_POWER));
sp, hero, nullptr, hero->getSpellSchoolLevel(sp), hero->getPrimSkillLevel(PrimarySkill::SPELL_POWER));
else
return 0; //mage guild
}
@ -379,7 +377,7 @@ int CGameInfoCallback::estimateSpellDamage(const CSpell * sp, const CGHeroInstan
//const CGHeroInstance * ourHero = gs->curB->heroes[0]->tempOwner == player ? gs->curB->heroes[0] : gs->curB->heroes[1];
const CGHeroInstance * ourHero = hero;
return gs->curB->calculateSpellDmg(
sp, ourHero, NULL, ourHero->getSpellSchoolLevel(sp), ourHero->getPrimSkillLevel(PrimarySkill::SPELL_POWER));
sp, ourHero, nullptr, ourHero->getSpellSchoolLevel(sp), ourHero->getPrimSkillLevel(PrimarySkill::SPELL_POWER));
}
void CGameInfoCallback::getThievesGuildInfo(SThievesGuildInfo & thi, const CGObjectInstance * obj)
@ -493,7 +491,7 @@ bool CGameInfoCallback::isVisible(const CGObjectInstance *obj) const
// if()
// const CArmedInstance *armi = dynamic_cast<const CArmedInstance*>(obj);
// if(!armi)
// return NULL;
// return nullptr;
// else
// return armi;
// }
@ -559,7 +557,7 @@ std::vector<const CGHeroInstance *> CGameInfoCallback::getAvailableHeroes(const
const TerrainTile * CGameInfoCallback::getTile( int3 tile, bool verbose) const
{
ERROR_VERBOSE_OR_NOT_RET_VAL_IF(!isVisible(tile), verbose, tile << " is not visible!", NULL);
ERROR_VERBOSE_OR_NOT_RET_VAL_IF(!isVisible(tile), verbose, tile << " is not visible!", nullptr);
//boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
return &gs->map->getTile(tile);
@ -858,7 +856,7 @@ const CGHeroInstance* CPlayerSpecificInfoCallback::getHeroBySerial(int serialId,
{
ASSERT_IF_CALLED_WITH_PLAYER
const PlayerState *p = getPlayer(*player);
ERROR_RET_VAL_IF(!p, "No player info", NULL);
ERROR_RET_VAL_IF(!p, "No player info", nullptr);
if (!includeGarrisoned)
{
@ -866,7 +864,7 @@ const CGHeroInstance* CPlayerSpecificInfoCallback::getHeroBySerial(int serialId,
if(p->heroes[i]->inTownGarrison)
serialId++;
}
ERROR_RET_VAL_IF(serialId < 0 || serialId >= p->heroes.size(), "No player info", NULL);
ERROR_RET_VAL_IF(serialId < 0 || serialId >= p->heroes.size(), "No player info", nullptr);
return p->heroes[serialId];
}
@ -874,8 +872,8 @@ const CGTownInstance* CPlayerSpecificInfoCallback::getTownBySerial(int serialId)
{
ASSERT_IF_CALLED_WITH_PLAYER
const PlayerState *p = getPlayer(*player);
ERROR_RET_VAL_IF(!p, "No player info", NULL);
ERROR_RET_VAL_IF(serialId < 0 || serialId >= p->towns.size(), "No player info", NULL);
ERROR_RET_VAL_IF(!p, "No player info", nullptr);
ERROR_RET_VAL_IF(serialId < 0 || serialId >= p->towns.size(), "No player info", nullptr);
return p->towns[serialId];
}
@ -930,9 +928,9 @@ CGObjectInstance * CNonConstInfoCallback::getObjInstance( ObjectInstanceID oid )
const TeamState * CGameInfoCallback::getTeam( TeamID teamID ) const
{
ERROR_RET_VAL_IF(!vstd::contains(gs->teams, teamID), "Cannot find info for team " << teamID, NULL);
ERROR_RET_VAL_IF(!vstd::contains(gs->teams, teamID), "Cannot find info for team " << teamID, nullptr);
const TeamState *ret = &gs->teams[teamID];
ERROR_RET_VAL_IF(!!player && !vstd::contains(ret->players, *player), "Illegal attempt to access team data!", NULL);
ERROR_RET_VAL_IF(!!player && !vstd::contains(ret->players, *player), "Illegal attempt to access team data!", nullptr);
return ret;
}
@ -941,7 +939,7 @@ const TeamState * CGameInfoCallback::getPlayerTeam( PlayerColor color ) const
const PlayerState * ps = getPlayer(color);
if (ps)
return getTeam(ps->team);
return NULL;
return nullptr;
}
const CGHeroInstance* CGameInfoCallback::getHeroWithSubid( int subid ) const
@ -950,7 +948,7 @@ const CGHeroInstance* CGameInfoCallback::getHeroWithSubid( int subid ) const
if(h->subID == subid)
return h;
return NULL;
return nullptr;
}
PlayerColor CGameInfoCallback::getLocalPlayer() const

6
lib/IGameCallback.h
View File

@ -102,7 +102,7 @@ public:
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(PlayerColor player) const; //NULL if no hero is selected
const CGHeroInstance* getSelectedHero(PlayerColor player) const; //nullptr 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;
@ -114,7 +114,7 @@ public:
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
PlayerColor getOwner(ObjectInstanceID heroID) const;
const CGObjectInstance *getObjByQuestIdentifier(int identifier) const; //NULL if object has been removed (eg. killed)
const CGObjectInstance *getObjByQuestIdentifier(int identifier) const; //nullptr if object has been removed (eg. killed)
//map
int3 guardingCreaturePosition (int3 pos) const;
@ -249,7 +249,7 @@ public:
virtual void showCompInfo(ShowInInfobox * comp)=0;
virtual void heroVisitCastle(const CGTownInstance * obj, const CGHeroInstance * hero)=0;
virtual void stopHeroVisitCastle(const CGTownInstance * obj, const CGHeroInstance * hero)=0;
virtual void startBattlePrimary(const CArmedInstance *army1, const CArmedInstance *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool creatureBank = false, const CGTownInstance *town = NULL)=0; //use hero=NULL for no hero
virtual void startBattlePrimary(const CArmedInstance *army1, const CArmedInstance *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool creatureBank = false, const CGTownInstance *town = nullptr)=0; //use hero=nullptr for no hero
virtual void startBattleI(const CArmedInstance *army1, const CArmedInstance *army2, int3 tile, bool creatureBank = false)=0; //if any of armies is hero, hero will be used
virtual void startBattleI(const CArmedInstance *army1, const CArmedInstance *army2, 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;

2
lib/IGameEventsReceiver.h
View File

@ -117,7 +117,7 @@ public:
virtual void tileHidden(const boost::unordered_set<int3, ShashInt3> &pos){};
virtual void tileRevealed(const boost::unordered_set<int3, ShashInt3> &pos){};
virtual void newObject(const CGObjectInstance * obj){}; //eg. ship built in shipyard
virtual void availableArtifactsChanged(const CGBlackMarket *bm = NULL){}; //bm may be NULL, then artifacts are changed in the global pool (used by merchants in towns)
virtual void availableArtifactsChanged(const CGBlackMarket *bm = nullptr){}; //bm may be nullptr, then artifacts are changed in the global pool (used by merchants in towns)
virtual void centerView (int3 pos, int focusTime){};
virtual void availableCreaturesChanged(const CGDwelling *town){};
virtual void heroBonusChanged(const CGHeroInstance *hero, const Bonus &bonus, bool gain){};//if gain hero received bonus, else he lost it

2
lib/JsonNode.cpp
View File

@ -140,7 +140,7 @@ void JsonNode::setType(JsonType Type)
if (type == Type)
return;
//Reset node to NULL
//Reset node to nullptr
if (Type != DATA_NULL)
setType(DATA_NULL);

2
lib/JsonNode.h
View File

@ -68,7 +68,7 @@ public:
void setMeta(std::string metadata, bool recursive = true);
/// Convert node to another type. Converting to NULL will clear all data
/// Convert node to another type. Converting to nullptr will clear all data
void setType(JsonType Type);
JsonType getType() const;

6
lib/NetPacks.h
View File

@ -71,7 +71,7 @@ struct CPackForServer : public CPack
CPackForServer()
{
type = 2;
c = NULL;
c = nullptr;
player = PlayerColor::NEUTRAL;
};
@ -2269,7 +2269,7 @@ struct SelectMap : public CPregamePackToPropagate
}
SelectMap()
{
mapInfo = NULL;
mapInfo = nullptr;
free = true;
}
~SelectMap()
@ -2301,7 +2301,7 @@ struct UpdateStartOptions : public CPregamePackToPropagate
}
UpdateStartOptions()
{
options = NULL;
options = nullptr;
free = true;
}
~UpdateStartOptions()

34
lib/NetPacksLib.cpp
View File

@ -144,7 +144,7 @@ DLL_LINKAGE void HeroVisitCastle::applyGs( CGameState *gs )
if(start())
t->setVisitingHero(h);
else
t->setVisitingHero(NULL);
t->setVisitingHero(nullptr);
}
DLL_LINKAGE void ChangeSpells::applyGs( CGameState *gs )
@ -217,7 +217,7 @@ DLL_LINKAGE void SetAvailableHeroes::applyGs( CGameState *gs )
DLL_LINKAGE void GiveBonus::applyGs( CGameState *gs )
{
CBonusSystemNode *cbsn = NULL;
CBonusSystemNode *cbsn = nullptr;
switch(who)
{
case HERO:
@ -316,10 +316,10 @@ DLL_LINKAGE void RemoveObject::applyGs( CGameState *gs )
if(h->visitedTown)
{
if(h->inTownGarrison)
h->visitedTown->garrisonHero = NULL;
h->visitedTown->garrisonHero = nullptr;
else
h->visitedTown->visitingHero = NULL;
h->visitedTown = NULL;
h->visitedTown->visitingHero = nullptr;
h->visitedTown = nullptr;
}
//return hero to the pool, so he may reappear in tavern
@ -327,7 +327,7 @@ DLL_LINKAGE void RemoveObject::applyGs( CGameState *gs )
if(!vstd::contains(gs->hpool.pavailable, h->subID))
gs->hpool.pavailable[h->subID] = 0xff;
gs->map->objects[id.getNum()] = NULL;
gs->map->objects[id.getNum()] = nullptr;
return;
@ -336,14 +336,14 @@ DLL_LINKAGE void RemoveObject::applyGs( CGameState *gs )
auto quest = dynamic_cast<const CQuest *>(obj);
if (quest)
{
gs->map->quests[quest->qid] = NULL;
gs->map->quests[quest->qid] = nullptr;
BOOST_FOREACH (auto &player, gs->players)
{
BOOST_FOREACH (auto &q, player.second.quests)
{
if (q.obj == obj)
{
q.obj = NULL;
q.obj = nullptr;
}
}
}
@ -415,9 +415,9 @@ void TryMoveHero::applyGs( CGameState *gs )
CGBoat *b = const_cast<CGBoat *>(h->boat);
b->direction = h->moveDir;
b->pos = start;
b->hero = NULL;
b->hero = nullptr;
gs->map->addBlockVisTiles(b);
h->boat = NULL;
h->boat = nullptr;
}
if(start!=end && (result == SUCCESS || result == TELEPORTATION || result == EMBARK || result == DISEMBARK))
@ -472,9 +472,9 @@ DLL_LINKAGE void SetHeroesInTown::applyGs( CGameState *gs )
bool newGarrisonComesFromVisiting = g && g == t->visitingHero;
if(newVisitorComesFromGarrison)
t->setGarrisonedHero(NULL);
t->setGarrisonedHero(nullptr);
if(newGarrisonComesFromVisiting)
t->setVisitingHero(NULL);
t->setVisitingHero(nullptr);
if(!newGarrisonComesFromVisiting || v)
t->setVisitingHero(v);
if(!newVisitorComesFromGarrison || g)
@ -543,7 +543,7 @@ DLL_LINKAGE void GiveHero::applyGs( CGameState *gs )
DLL_LINKAGE void NewObject::applyGs( CGameState *gs )
{
CGObjectInstance *o = NULL;
CGObjectInstance *o = nullptr;
switch(ID)
{
case Obj::BOAT:
@ -607,7 +607,7 @@ DLL_LINKAGE const CStackInstance * StackLocation::getStack()
if(!army->hasStackAtSlot(slot))
{
logNetwork->warnStream() << "Warning: " << army->nodeName() << " dont have a stack at slot " << slot;
return NULL;
return nullptr;
}
return &army->getStack(slot);
}
@ -664,10 +664,10 @@ DLL_LINKAGE const CArtifactInstance *ArtifactLocation::getArt() const
else
{
logNetwork->warnStream() << "ArtifactLocation::getArt: That location is locked!";
return NULL;
return nullptr;
}
}
return NULL;
return nullptr;
}
DLL_LINKAGE const CArtifactSet * ArtifactLocation::getHolderArtSet() const
@ -1130,7 +1130,7 @@ void BattleResult::applyGs( CGameState *gs )
CBonusSystemNode::treeHasChanged();
}
gs->curB->belligerents[0]->battle = gs->curB->belligerents[1]->battle = NULL;
gs->curB->belligerents[0]->battle = gs->curB->belligerents[1]->battle = nullptr;
gs->curB.dellNull();
}

2
lib/StartInfo.h
View File

@ -104,7 +104,7 @@ struct StartInfo
if(it->second.playerID == nameID)
return &it->second;
return NULL;
return nullptr;
}
template <typename Handler>

Some files were not shown because too many files have changed in this diff Show More