games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2025-05-31 22:59:54 +02:00
Code Issues Releases Activity

unified guardians names

Browse Source
This commit is contained in:
Łukasz Wychrystenko 2008-12-26 01:46:53 +00:00
parent b356524aee
commit b54a3bfb7c
47 changed files with 3683 additions and 3645 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
AI_Base.h
View File

@ -1,8 +1,5 @@
#ifndef __AI_BASE_H__ #ifndef __AI_BASE_H__
#define __AI_BASE_H__ #define __AI_BASE_H__
#ifndef __AI_BASE_H__
#define __AI_BASE_H__
#include <vector> #include <vector>
#include <iostream> #include <iostream>
@ -11,4 +8,3 @@
#define AI_INTERFACE_VER 1 #define AI_INTERFACE_VER 1
#endif // __AI_BASE_H__ #endif // __AI_BASE_H__
#endif // __AI_BASE_H__

7
AdventureMapButton.h
View File

@ -1,5 +1,5 @@
#ifndef ADVENTUREMAPBUTTON_H #ifndef __ADVENTUREMAPBUTTON_H__
#define ADVENTUREMAPBUTTON_H #define __ADVENTUREMAPBUTTON_H__
@ -95,4 +95,5 @@ public:
int Value=0, bool Horizontal=true); int Value=0, bool Horizontal=true);
~CSlider(); ~CSlider();
}; };
#endif //ADVENTUREMAPBUTTON_H
#endif // __ADVENTUREMAPBUTTON_H__

7
CBattleInterface.h
View File

@ -1,5 +1,5 @@
#ifndef CBATTLEINTERFACE_H #ifndef __CBATTLEINTERFACE_H__
#define CBATTLEINTERFACE_H #define __CBATTLEINTERFACE_H__
@ -255,4 +255,5 @@ public:
friend class CBattleReslutWindow; friend class CBattleReslutWindow;
friend class CPlayerInterface; friend class CPlayerInterface;
}; };
#endif //CBATTLEINTERFACE_H
#endif // __CBATTLEINTERFACE_H__

379
CCallback.h
View File

@ -1,189 +1,190 @@
#ifndef CCALLBACK_H #ifndef __CCALLBACK_H__
#define CCALLBACK_H #define __CCALLBACK_H__
#include "global.h" #include "global.h"
#ifdef _WIN32 #ifdef _WIN32
#include "tchar.h" #include "tchar.h"
#else #else
#include "tchar_amigaos4.h" //XXX this is mingw header are we need this for something? for 'true' #include "tchar_amigaos4.h" //XXX this is mingw header are we need this for something? for 'true'
//support of unicode we should use ICU or some boost wraper areound it //support of unicode we should use ICU or some boost wraper areound it
//(boost using this lib during compilation i dont know what for exactly) //(boost using this lib during compilation i dont know what for exactly)
#endif #endif
#include "CGameState.h" #include "CGameState.h"
class CGHeroInstance; class CGHeroInstance;
class CGameState; class CGameState;
struct CPath; struct CPath;
class CGObjectInstance; class CGObjectInstance;
class CArmedInstance; class CArmedInstance;
class SComponent; class SComponent;
class IChosen; class IChosen;
class CSelectableComponent; class CSelectableComponent;
struct BattleAction; struct BattleAction;
class CGTownInstance; class CGTownInstance;
struct StartInfo; struct StartInfo;
class CStack; class CStack;
struct lua_State; struct lua_State;
class CClient; class CClient;
//structure gathering info about upgrade possibilites //structure gathering info about upgrade possibilites
class ICallback class ICallback
{ {
public: public:
virtual bool moveHero(int ID, CPath * path, int idtype, int pathType=0)=0;//idtype: 0 - position in vector of heroes (of that player); 1 - ID of hero virtual bool moveHero(int ID, CPath * path, int idtype, int pathType=0)=0;//idtype: 0 - position in vector of heroes (of that player); 1 - ID of hero
//pathType: 0 - nodes are manifestation pos, 1 - nodes are object pos //pathType: 0 - nodes are manifestation pos, 1 - nodes are object pos
virtual int swapCreatures(const CGObjectInstance *s1, const CGObjectInstance *s2, int p1, int p2)=0;//swaps creatures between two posiibly different garrisons // TODO: AI-unsafe code - fix it! virtual int swapCreatures(const CGObjectInstance *s1, const CGObjectInstance *s2, int p1, int p2)=0;//swaps creatures between two posiibly different garrisons // TODO: AI-unsafe code - fix it!
virtual int mergeStacks(const CGObjectInstance *s1, const CGObjectInstance *s2, int p1, int p2)=0;//joins first stack tothe second (creatures must be same type) virtual int mergeStacks(const CGObjectInstance *s1, const CGObjectInstance *s2, int p1, int p2)=0;//joins first stack tothe second (creatures must be same type)
virtual int splitStack(const CGObjectInstance *s1, const CGObjectInstance *s2, int p1, int p2, int val)=0;//split creatures from the first stack virtual int splitStack(const CGObjectInstance *s1, const CGObjectInstance *s2, int p1, int p2, int val)=0;//split creatures from the first stack
virtual bool dismissHero(const CGHeroInstance * hero)=0; //dismisses diven hero; true - successfuly, false - not successfuly virtual bool dismissHero(const CGHeroInstance * hero)=0; //dismisses diven hero; true - successfuly, false - not successfuly
virtual bool swapArifacts(const CGHeroInstance * hero1, ui16 pos1, const CGHeroInstance * hero2, ui16 pos2)=0; //swaps artifacts between two given heroes virtual bool swapArifacts(const CGHeroInstance * hero1, ui16 pos1, const CGHeroInstance * hero2, ui16 pos2)=0; //swaps artifacts between two given heroes
virtual void recruitCreatures(const CGObjectInstance *obj, ui32 ID, ui32 amount)=0; virtual void recruitCreatures(const CGObjectInstance *obj, ui32 ID, ui32 amount)=0;
virtual bool dismissCreature(const CArmedInstance *obj, int stackPos)=0; virtual bool dismissCreature(const CArmedInstance *obj, int stackPos)=0;
virtual bool upgradeCreature(const CArmedInstance *obj, int stackPos, int newID=-1)=0; //if newID==-1 then best possible upgrade will be made virtual bool upgradeCreature(const CArmedInstance *obj, int stackPos, int newID=-1)=0; //if newID==-1 then best possible upgrade will be made
virtual void endTurn()=0; virtual void endTurn()=0;
virtual void swapGarrisonHero(const CGTownInstance *town)=0; virtual void swapGarrisonHero(const CGTownInstance *town)=0;
virtual void buyArtifact(const CGHeroInstance *hero, int aid)=0; //used to buy artifacts in towns (including spell book in the guild and war machines in blacksmith) virtual void buyArtifact(const CGHeroInstance *hero, int aid)=0; //used to buy artifacts in towns (including spell book in the guild and war machines in blacksmith)
virtual void trade(int mode, int id1, int id2, int val1)=0; //mode==0: sell val1 units of id1 resource for id2 resiurce virtual void trade(int mode, int id1, int id2, int val1)=0; //mode==0: sell val1 units of id1 resource for id2 resiurce
virtual void setFormation(const CGHeroInstance * hero, bool tight)=0; virtual void setFormation(const CGHeroInstance * hero, bool tight)=0;
virtual void setSelection(const CArmedInstance * obj)=0; virtual void setSelection(const CArmedInstance * obj)=0;
virtual void recruitHero(const CGTownInstance *town, const CGHeroInstance *hero)=0; virtual void recruitHero(const CGTownInstance *town, const CGHeroInstance *hero)=0;
//get info //get info
virtual bool verifyPath(CPath * path, bool blockSea)const =0; virtual bool verifyPath(CPath * path, bool blockSea)const =0;
virtual int getDate(int mode=0)const =0; //mode=0 - total days in game, mode=1 - day of week, mode=2 - current week, mode=3 - current month virtual int getDate(int mode=0)const =0; //mode=0 - total days in game, mode=1 - day of week, mode=2 - current week, mode=3 - current month
virtual std::vector< std::vector< std::vector<unsigned char> > > & getVisibilityMap()const =0; //returns visibility map (TODO: make it const) virtual std::vector< std::vector< std::vector<unsigned char> > > & getVisibilityMap()const =0; //returns visibility map (TODO: make it const)
virtual const CGHeroInstance * getHeroInfo(int val, int mode=2)const =0; //mode = 0 -> val = serial; mode = 1 -> val = ID virtual const CGHeroInstance * getHeroInfo(int val, int mode=2)const =0; //mode = 0 -> val = serial; mode = 1 -> val = ID
virtual int getResourceAmount(int type)const =0; virtual int getResourceAmount(int type)const =0;
virtual int howManyHeroes()const =0; virtual int howManyHeroes()const =0;
virtual const CGTownInstance * getTownInfo(int val, bool mode)const =0; //mode = 0 -> val = serial; mode = 1 -> val = ID virtual const CGTownInstance * getTownInfo(int val, bool mode)const =0; //mode = 0 -> val = serial; mode = 1 -> val = ID
virtual int howManyTowns()const =0; virtual int howManyTowns()const =0;
virtual std::vector < std::string > getObjDescriptions(int3 pos)const =0; //returns descriptions of objects at pos in order from the lowest to the highest virtual std::vector < std::string > getObjDescriptions(int3 pos)const =0; //returns descriptions of objects at pos in order from the lowest to the highest
virtual std::vector < const CGHeroInstance *> getHeroesInfo(bool onlyOur=true)const =0; virtual std::vector < const CGHeroInstance *> getHeroesInfo(bool onlyOur=true)const =0;
virtual bool isVisible(int3 pos)const =0; virtual bool isVisible(int3 pos)const =0;
virtual int getMyColor()const =0; virtual int getMyColor()const =0;
virtual int getMySerial()const =0; virtual int getMySerial()const =0;
virtual int getHeroSerial(const CGHeroInstance * hero)const =0; virtual int getHeroSerial(const CGHeroInstance * hero)const =0;
virtual const CCreatureSet* getGarrison(const CGObjectInstance *obj)const =0; virtual const CCreatureSet* getGarrison(const CGObjectInstance *obj)const =0;
virtual UpgradeInfo getUpgradeInfo(const CArmedInstance *obj, int stackPos)const =0; virtual UpgradeInfo getUpgradeInfo(const CArmedInstance *obj, int stackPos)const =0;
virtual const StartInfo * getStartInfo()const =0; virtual const StartInfo * getStartInfo()const =0;
virtual std::vector < const CGObjectInstance * > getBlockingObjs(int3 pos)const =0; virtual std::vector < const CGObjectInstance * > getBlockingObjs(int3 pos)const =0;
virtual std::vector < const CGObjectInstance * > getVisitableObjs(int3 pos)const =0; virtual std::vector < const CGObjectInstance * > getVisitableObjs(int3 pos)const =0;
virtual void getMarketOffer(int t1, int t2, int &give, int &rec, int mode=0)const =0; virtual void getMarketOffer(int t1, int t2, int &give, int &rec, int mode=0)const =0;
virtual std::vector < const CGObjectInstance * > getFlaggableObjects(int3 pos) const =0; virtual std::vector < const CGObjectInstance * > getFlaggableObjects(int3 pos) const =0;
virtual int3 getMapSize() const =0; //returns size of map - z is 1 for one - level map and 2 for two level map virtual int3 getMapSize() const =0; //returns size of map - z is 1 for one - level map and 2 for two level map
virtual std::vector<const CGHeroInstance *> getAvailableHeroes(const CGTownInstance * town) const =0; //heroes that can be recruited virtual std::vector<const CGHeroInstance *> getAvailableHeroes(const CGTownInstance * town) const =0; //heroes that can be recruited
//battle //battle
virtual int battleGetBattlefieldType()=0; // 1. sand/shore 2. sand/mesas 3. dirt/birches 4. dirt/hills 5. dirt/pines 6. grass/hills 7. grass/pines 8. lava 9. magic plains 10. snow/mountains 11. snow/trees 12. subterranean 13. swamp/trees 14. fiery fields 15. rock lands 16. magic clouds 17. lucid pools 18. holy ground 19. clover field 20. evil fog 21. "favourable winds" text on magic plains background 22. cursed ground 23. rough 24. ship to ship 25. ship virtual int battleGetBattlefieldType()=0; // 1. sand/shore 2. sand/mesas 3. dirt/birches 4. dirt/hills 5. dirt/pines 6. grass/hills 7. grass/pines 8. lava 9. magic plains 10. snow/mountains 11. snow/trees 12. subterranean 13. swamp/trees 14. fiery fields 15. rock lands 16. magic clouds 17. lucid pools 18. holy ground 19. clover field 20. evil fog 21. "favourable winds" text on magic plains background 22. cursed ground 23. rough 24. ship to ship 25. ship
virtual int battleGetObstaclesAtTile(int tile)=0; //returns bitfield virtual int battleGetObstaclesAtTile(int tile)=0; //returns bitfield
virtual int battleGetStack(int pos)=0; //returns ID of stack on the tile virtual int battleGetStack(int pos)=0; //returns ID of stack on the tile
virtual CStack * battleGetStackByID(int ID)=0; //returns stack info by given ID virtual CStack * battleGetStackByID(int ID)=0; //returns stack info by given ID
virtual CStack * battleGetStackByPos(int pos)=0; //returns stack info by given pos virtual CStack * battleGetStackByPos(int pos)=0; //returns stack info by given pos
virtual int battleGetPos(int stack)=0; //returns position (tile ID) of stack virtual int battleGetPos(int stack)=0; //returns position (tile ID) of stack
virtual int battleMakeAction(BattleAction* action)=0;//for casting spells by hero - DO NOT use it for moving active stack virtual int battleMakeAction(BattleAction* action)=0;//for casting spells by hero - DO NOT use it for moving active stack
virtual std::map<int, CStack> battleGetStacks()=0; //returns stacks on battlefield virtual std::map<int, CStack> battleGetStacks()=0; //returns stacks on battlefield
virtual std::vector<CStack> battleGetStackQueue()=0; //returns vector of stack in order of their move sequence virtual std::vector<CStack> battleGetStackQueue()=0; //returns vector of stack in order of their move sequence
virtual CCreature battleGetCreature(int number)=0; //returns type of creature by given number of stack virtual CCreature battleGetCreature(int number)=0; //returns type of creature by given number of stack
//virtual bool battleMoveCreature(int ID, int dest)=0; //moves creature with id ID to dest if possible //virtual bool battleMoveCreature(int ID, int dest)=0; //moves creature with id ID to dest if possible
virtual std::vector<int> battleGetAvailableHexes(int ID)=0; //reutrns numbers of hexes reachable by creature with id ID virtual std::vector<int> battleGetAvailableHexes(int ID)=0; //reutrns numbers of hexes reachable by creature with id ID
virtual bool battleIsStackMine(int ID)=0; //returns true if stack with id ID belongs to caller virtual bool battleIsStackMine(int ID)=0; //returns true if stack with id ID belongs to caller
virtual bool battleCanShoot(int ID, int dest)=0; //returns true if unit with id ID can shoot to dest virtual bool battleCanShoot(int ID, int dest)=0; //returns true if unit with id ID can shoot to dest
}; };
struct HeroMoveDetails struct HeroMoveDetails
{ {
HeroMoveDetails(){}; HeroMoveDetails(){};
HeroMoveDetails(int3 Src, int3 Dst, CGHeroInstance*Ho); HeroMoveDetails(int3 Src, int3 Dst, CGHeroInstance*Ho);
int3 src, dst; //source and destination points int3 src, dst; //source and destination points
CGHeroInstance * ho; //object instance of this hero CGHeroInstance * ho; //object instance of this hero
int owner, style; //style: 0 - normal move, 1 - teleport, 2 - instant jump int owner, style; //style: 0 - normal move, 1 - teleport, 2 - instant jump
bool successful; bool successful;
}; };
class CCallback : public ICallback class CCallback : public ICallback
{ {
private: private:
CCallback(CGameState * GS, int Player, CClient *C):gs(GS), cl(C), player(Player){}; CCallback(CGameState * GS, int Player, CClient *C):gs(GS), cl(C), player(Player){};
CGameState * gs; CGameState * gs;
CClient *cl; CClient *cl;
bool isVisible(int3 pos, int Player) const; bool isVisible(int3 pos, int Player) const;
bool isVisible(CGObjectInstance *obj, int Player) const; bool isVisible(CGObjectInstance *obj, int Player) const;
protected: protected:
int player; int player;
public: public:
//commands //commands
bool moveHero(int ID, CPath * path, int idtype, int pathType=0);//idtype: 0 - position in vector of heroes (of that player); 1 - ID of hero bool moveHero(int ID, CPath * path, int idtype, int pathType=0);//idtype: 0 - position in vector of heroes (of that player); 1 - ID of hero
//pathType: 0 - nodes are manifestation pos, 1 - nodes are object pos //pathType: 0 - nodes are manifestation pos, 1 - nodes are object pos
void selectionMade(int selection, int asker); void selectionMade(int selection, int asker);
int swapCreatures(const CGObjectInstance *s1, const CGObjectInstance *s2, int p1, int p2); int swapCreatures(const CGObjectInstance *s1, const CGObjectInstance *s2, int p1, int p2);
int mergeStacks(const CGObjectInstance *s1, const CGObjectInstance *s2, int p1, int p2); //first goes to the second int mergeStacks(const CGObjectInstance *s1, const CGObjectInstance *s2, int p1, int p2); //first goes to the second
int splitStack(const CGObjectInstance *s1, const CGObjectInstance *s2, int p1, int p2, int val); int splitStack(const CGObjectInstance *s1, const CGObjectInstance *s2, int p1, int p2, int val);
bool dismissHero(const CGHeroInstance * hero); bool dismissHero(const CGHeroInstance * hero);
bool swapArifacts(const CGHeroInstance * hero1, ui16 pos1, const CGHeroInstance * hero2, ui16 pos2); bool swapArifacts(const CGHeroInstance * hero1, ui16 pos1, const CGHeroInstance * hero2, ui16 pos2);
bool buildBuilding(const CGTownInstance *town, si32 buildingID); bool buildBuilding(const CGTownInstance *town, si32 buildingID);
void recruitCreatures(const CGObjectInstance *obj, ui32 ID, ui32 amount); void recruitCreatures(const CGObjectInstance *obj, ui32 ID, ui32 amount);
bool dismissCreature(const CArmedInstance *obj, int stackPos); bool dismissCreature(const CArmedInstance *obj, int stackPos);
bool upgradeCreature(const CArmedInstance *obj, int stackPos, int newID=-1); bool upgradeCreature(const CArmedInstance *obj, int stackPos, int newID=-1);
void endTurn(); void endTurn();
void swapGarrisonHero(const CGTownInstance *town); void swapGarrisonHero(const CGTownInstance *town);
void buyArtifact(const CGHeroInstance *hero, int aid); void buyArtifact(const CGHeroInstance *hero, int aid);
void trade(int mode, int id1, int id2, int val1); void trade(int mode, int id1, int id2, int val1);
void setFormation(const CGHeroInstance * hero, bool tight); void setFormation(const CGHeroInstance * hero, bool tight);
void setSelection(const CArmedInstance * obj); void setSelection(const CArmedInstance * obj);
void recruitHero(const CGTownInstance *town, const CGHeroInstance *hero); void recruitHero(const CGTownInstance *town, const CGHeroInstance *hero);
//get info //get info
bool verifyPath(CPath * path, bool blockSea) const; bool verifyPath(CPath * path, bool blockSea) const;
int getDate(int mode=0) const; //mode=0 - total days in game, mode=1 - day of week, mode=2 - current week, mode=3 - current month int getDate(int mode=0) const; //mode=0 - total days in game, mode=1 - day of week, mode=2 - current week, mode=3 - current month
std::vector< std::vector< std::vector<unsigned char> > > & getVisibilityMap() const; //returns visibility map (TODO: make it const) std::vector< std::vector< std::vector<unsigned char> > > & getVisibilityMap() const; //returns visibility map (TODO: make it const)
const CGHeroInstance * getHeroInfo(int val, int mode=2) const; //mode = 0 -> val = serial; mode = 1 -> val = ID const CGHeroInstance * getHeroInfo(int val, int mode=2) const; //mode = 0 -> val = serial; mode = 1 -> val = ID
int getResourceAmount(int type) const; int getResourceAmount(int type) const;
std::vector<si32> getResourceAmount() const; std::vector<si32> getResourceAmount() const;
int howManyHeroes() const; int howManyHeroes() const;
const CGTownInstance * getTownInfo(int val, bool mode) const; //mode = 0 -> val = serial; mode = 1 -> val = ID const CGTownInstance * getTownInfo(int val, bool mode) const; //mode = 0 -> val = serial; mode = 1 -> val = ID
std::vector < const CGTownInstance *> getTownsInfo(bool onlyOur=true) const; std::vector < const CGTownInstance *> getTownsInfo(bool onlyOur=true) const;
int howManyTowns()const; int howManyTowns()const;
std::vector < std::string > getObjDescriptions(int3 pos) const; //returns descriptions of objects at pos in order from the lowest to the highest std::vector < std::string > getObjDescriptions(int3 pos) const; //returns descriptions of objects at pos in order from the lowest to the highest
std::vector < const CGHeroInstance *> getHeroesInfo(bool onlyOur=true) const; std::vector < const CGHeroInstance *> getHeroesInfo(bool onlyOur=true) const;
bool isVisible(int3 pos) const; bool isVisible(int3 pos) const;
int getMyColor() const; int getMyColor() const;
int getHeroSerial(const CGHeroInstance * hero) const; int getHeroSerial(const CGHeroInstance * hero) const;
int getMySerial() const; int getMySerial() const;
const CCreatureSet* getGarrison(const CGObjectInstance *obj) const; const CCreatureSet* getGarrison(const CGObjectInstance *obj) const;
UpgradeInfo getUpgradeInfo(const CArmedInstance *obj, int stackPos) const; UpgradeInfo getUpgradeInfo(const CArmedInstance *obj, int stackPos) const;
const StartInfo * getStartInfo() const; const StartInfo * getStartInfo() const;
std::vector < const CGObjectInstance * > getBlockingObjs(int3 pos) const; std::vector < const CGObjectInstance * > getBlockingObjs(int3 pos) const;
std::vector < const CGObjectInstance * > getVisitableObjs(int3 pos) const; std::vector < const CGObjectInstance * > getVisitableObjs(int3 pos) const;
void getMarketOffer(int t1, int t2, int &give, int &rec, int mode=0) const; void getMarketOffer(int t1, int t2, int &give, int &rec, int mode=0) const;
std::vector < const CGObjectInstance * > getFlaggableObjects(int3 pos) const; std::vector < const CGObjectInstance * > getFlaggableObjects(int3 pos) const;
int3 getMapSize() const; //returns size of map - z is 1 for one - level map and 2 for two level map int3 getMapSize() const; //returns size of map - z is 1 for one - level map and 2 for two level map
std::vector<const CGHeroInstance *> getAvailableHeroes(const CGTownInstance * town) const; //heroes that can be recruited std::vector<const CGHeroInstance *> getAvailableHeroes(const CGTownInstance * town) const; //heroes that can be recruited
//battle //battle
int battleGetBattlefieldType(); // 1. sand/shore 2. sand/mesas 3. dirt/birches 4. dirt/hills 5. dirt/pines 6. grass/hills 7. grass/pines 8. lava 9. magic plains 10. snow/mountains 11. snow/trees 12. subterranean 13. swamp/trees 14. fiery fields 15. rock lands 16. magic clouds 17. lucid pools 18. holy ground 19. clover field 20. evil fog 21. "favourable winds" text on magic plains background 22. cursed ground 23. rough 24. ship to ship 25. ship int battleGetBattlefieldType(); // 1. sand/shore 2. sand/mesas 3. dirt/birches 4. dirt/hills 5. dirt/pines 6. grass/hills 7. grass/pines 8. lava 9. magic plains 10. snow/mountains 11. snow/trees 12. subterranean 13. swamp/trees 14. fiery fields 15. rock lands 16. magic clouds 17. lucid pools 18. holy ground 19. clover field 20. evil fog 21. "favourable winds" text on magic plains background 22. cursed ground 23. rough 24. ship to ship 25. ship
int battleGetObstaclesAtTile(int tile); //returns bitfield int battleGetObstaclesAtTile(int tile); //returns bitfield
int battleGetStack(int pos); //returns ID of stack on the tile int battleGetStack(int pos); //returns ID of stack on the tile
CStack * battleGetStackByID(int ID); //returns stack info by given ID CStack * battleGetStackByID(int ID); //returns stack info by given ID
CStack * battleGetStackByPos(int pos); //returns stack info by given pos CStack * battleGetStackByPos(int pos); //returns stack info by given pos
int battleGetPos(int stack); //returns position (tile ID) of stack int battleGetPos(int stack); //returns position (tile ID) of stack
int battleMakeAction(BattleAction* action);//for casting spells by hero - DO NOT use it for moving active stack int battleMakeAction(BattleAction* action);//for casting spells by hero - DO NOT use it for moving active stack
std::map<int, CStack> battleGetStacks(); //returns stacks on battlefield std::map<int, CStack> battleGetStacks(); //returns stacks on battlefield
std::vector<CStack> battleGetStackQueue(); //returns vector of stack in order of their move sequence std::vector<CStack> battleGetStackQueue(); //returns vector of stack in order of their move sequence
CCreature battleGetCreature(int number); //returns type of creature by given number of stack CCreature battleGetCreature(int number); //returns type of creature by given number of stack
std::vector<int> battleGetAvailableHexes(int ID); //reutrns numbers of hexes reachable by creature with id ID std::vector<int> battleGetAvailableHexes(int ID); //reutrns numbers of hexes reachable by creature with id ID
bool battleIsStackMine(int ID); //returns true if stack with id ID belongs to caller bool battleIsStackMine(int ID); //returns true if stack with id ID belongs to caller
bool battleCanShoot(int ID, int dest); //returns true if unit with id ID can shoot to dest bool battleCanShoot(int ID, int dest); //returns true if unit with id ID can shoot to dest
//XXX hmmm _tmain on _GNUC_ wtf? //XXX hmmm _tmain on _GNUC_ wtf?
//friends //friends
friend class CClient; friend class CClient;
#ifndef __GNUC__ #ifndef __GNUC__
friend int _tmain(int argc, _TCHAR* argv[]); friend int _tmain(int argc, _TCHAR* argv[]);
#else #else
friend int main(int argc, char** argv); friend int main(int argc, char** argv);
#endif #endif
}; };
#endif //CCALLBACK_H
#endif // __CCALLBACK_H__

7
CCastleInterface.h
View File

@ -1,5 +1,5 @@
#ifndef CCASTLEINTERFACE_H #ifndef __CCASTLEINTERFACE_H__
#define CCASTLEINTERFACE_H #define __CCASTLEINTERFACE_H__
@ -225,4 +225,5 @@ public:
void activate(); void activate();
void deactivate(); void deactivate();
}; };
#endif //CCASTLEINTERFACE_H
#endif // __CCASTLEINTERFACE_H__

83
CConsoleHandler.h
View File

@ -1,41 +1,42 @@
#ifndef CCONSOLEHANDLER_H #ifndef __CCONSOLEHANDLER_H__
#define CCONSOLEHANDLER_H #define __CCONSOLEHANDLER_H__
#ifndef _WIN32 #ifndef _WIN32
#define WORD std::string #define WORD std::string
#endif #endif
#ifndef _WIN32 #ifndef _WIN32
#define _kill_thread(a,b) pthread_cancel(a); #define _kill_thread(a,b) pthread_cancel(a);
#else #else
#define _kill_thread(a,b) TerminateThread(a,b); #define _kill_thread(a,b) TerminateThread(a,b);
#endif #endif
namespace boost namespace boost
{ {
template<typename signature> template<typename signature>
class function; class function;
} }
class DLL_EXPORT CConsoleHandler class DLL_EXPORT CConsoleHandler
{ {
public: public:
boost::function<void(const std::string &)> *cb; boost::function<void(const std::string &)> *cb;
int curLvl; int curLvl;
int run(); int run();
void setColor(int level); void setColor(int level);
CConsoleHandler(); CConsoleHandler();
~CConsoleHandler(); ~CConsoleHandler();
#ifndef _WIN32 #ifndef _WIN32
static void killConsole(pthread_t hThread); //for windows only, use native handle to the thread static void killConsole(pthread_t hThread); //for windows only, use native handle to the thread
#else #else
static void killConsole(void *hThread); //for windows only, use native handle to the thread static void killConsole(void *hThread); //for windows only, use native handle to the thread
#endif #endif
template<typename T> void print(const T &data, int level) template<typename T> void print(const T &data, int level)
{ {
setColor(level); setColor(level);
std::cout << data << std::flush; std::cout << data << std::flush;
setColor(-1); setColor(-1);
} }
}; };
#endif //CCONSOLEHANDLER_H
#endif // __CCONSOLEHANDLER_H__

57
CCursorHandler.h
View File

@ -1,28 +1,29 @@
#ifndef CCURSORHANDLER_H #ifndef __CCURSORHANDLER_H__
#define CCURSORHANDLER_H #define __CCURSORHANDLER_H__
#include "global.h" #include "global.h"
#include <vector> #include <vector>
struct SDL_Thread; struct SDL_Thread;
class CDefHandler; class CDefHandler;
struct SDL_Surface; struct SDL_Surface;
class CCursorHandler //handles cursor class CCursorHandler //handles cursor
{ {
public: public:
int mode, number; int mode, number;
SDL_Surface * help; SDL_Surface * help;
bool Show; bool Show;
std::vector<CDefHandler*> cursors; std::vector<CDefHandler*> cursors;
int xpos, ypos; //position of cursor int xpos, ypos; //position of cursor
void initCursor(); //inits cursorHandler void initCursor(); //inits cursorHandler
void cursorMove(const int & x, const int & y); //change cursor's positions to (x, y) void cursorMove(const int & x, const int & y); //change cursor's positions to (x, y)
void changeGraphic(const int & type, const int & no); //changes cursor graphic for type type (0 - adventure, 1 - combat, 2 - default, 3 - spellbook) and frame no (not used for type 3) void changeGraphic(const int & type, const int & no); //changes cursor graphic for type type (0 - adventure, 1 - combat, 2 - default, 3 - spellbook) and frame no (not used for type 3)
void draw1(); void draw1();
void draw2(); void draw2();
void hide(){Show=0;}; void hide(){Show=0;};
void show(){Show=1;}; void show(){Show=1;};
}; };
#endif //CCURSORHANDLER_H
#endif // __CCURSORHANDLER_H__

133
CGameInfo.h
View File

@ -1,66 +1,67 @@
#ifndef CGAMEINFO_H #ifndef __CGAMEINFO_H__
#define CGAMEINFO_H #define __CGAMEINFO_H__
#include "global.h" #include "global.h"
#include <vector> #include <vector>
class CMapHandler; class CMapHandler;
class CArtHandler; class CArtHandler;
class CHeroHandler; class CHeroHandler;
class CCreatureHandler; class CCreatureHandler;
class CAbilityHandler; class CAbilityHandler;
class CSpellHandler; class CSpellHandler;
class CAmbarCendamo; class CAmbarCendamo;
class CPreGameTextHandler; class CPreGameTextHandler;
class CBuildingHandler; class CBuildingHandler;
class CObjectHandler; class CObjectHandler;
class CMusicHandler; class CMusicHandler;
class CSemiLodHandler; class CSemiLodHandler;
class CDefObjInfoHandler; class CDefObjInfoHandler;
class CTownHandler; class CTownHandler;
class CLodHandler; class CLodHandler;
class CGeneralTextHandler; class CGeneralTextHandler;
class CConsoleHandler; class CConsoleHandler;
class CPathfinder; class CPathfinder;
class CCursorHandler; class CCursorHandler;
class CScreenHandler; class CScreenHandler;
class CGameState; class CGameState;
class CMapHandler; class CMapHandler;
class CGameInterface; class CGameInterface;
class CPreGame; class CPreGame;
class CDefHandler; class CDefHandler;
/* /*
CGameInfo class CGameInfo class
for allowing different functions for modifying game informations for allowing different functions for modifying game informations
*/ */
class CGameInfo class CGameInfo
{ {
public: public:
CGameState * state; CGameState * state;
CArtHandler * arth; CArtHandler * arth;
CHeroHandler * heroh; CHeroHandler * heroh;
CCreatureHandler * creh; CCreatureHandler * creh;
CAbilityHandler * abilh; CAbilityHandler * abilh;
CSpellHandler * spellh; CSpellHandler * spellh;
CMapHandler * mh; CMapHandler * mh;
CBuildingHandler * buildh; CBuildingHandler * buildh;
CObjectHandler * objh; CObjectHandler * objh;
CMusicHandler * mush; CMusicHandler * mush;
CSemiLodHandler * sspriteh; CSemiLodHandler * sspriteh;
CDefObjInfoHandler * dobjinfo; CDefObjInfoHandler * dobjinfo;
CTownHandler * townh; CTownHandler * townh;
CLodHandler * spriteh; CLodHandler * spriteh;
CLodHandler * bitmaph; CLodHandler * bitmaph;
CGeneralTextHandler * generaltexth; CGeneralTextHandler * generaltexth;
CConsoleHandler * consoleh; CConsoleHandler * consoleh;
CPathfinder * pathf; CPathfinder * pathf;
CCursorHandler * curh; CCursorHandler * curh;
CScreenHandler * screenh; CScreenHandler * screenh;
}; };
#endif //CGAMEINFO_H
#endif // __CGAMEINFO_H__

203
CGameInterface.h
View File

@ -1,101 +1,102 @@
#ifndef CGAMEINTERFACE_H #ifndef __CGAMEINTERFACE_H__
#define CGAMEINTERFACE_H #define __CGAMEINTERFACE_H__
#include "global.h" #include "global.h"
#include <set> #include <set>
#include <vector> #include <vector>
#include "lib/BattleAction.h" #include "lib/BattleAction.h"
#include "client/FunctionList.h" #include "client/FunctionList.h"
using namespace boost::logic; using namespace boost::logic;
class CCallback; class CCallback;
class ICallback; class ICallback;
class CGlobalAI; class CGlobalAI;
class CGHeroInstance; class CGHeroInstance;
class Component; class Component;
class CSelectableComponent; class CSelectableComponent;
struct HeroMoveDetails; struct HeroMoveDetails;
class CGHeroInstance; class CGHeroInstance;
class CGTownInstance; class CGTownInstance;
class CGObjectInstance; class CGObjectInstance;
class CCreatureSet; class CCreatureSet;
class CArmedInstance; class CArmedInstance;
struct BattleResult; struct BattleResult;
struct BattleAttack; struct BattleAttack;
struct BattleStackAttacked; struct BattleStackAttacked;
struct SpellCasted; struct SpellCasted;
class CObstacle class CObstacle
{ {
int ID; int ID;
int position; int position;
//TODO: add some kind of the blockmap //TODO: add some kind of the blockmap
}; };
struct StackState struct StackState
{ {
StackState(){attackBonus=defenseBonus=healthBonus=speedBonus=morale=luck=shotsLeft=currentHealth=0;}; StackState(){attackBonus=defenseBonus=healthBonus=speedBonus=morale=luck=shotsLeft=currentHealth=0;};
int attackBonus, defenseBonus, healthBonus, speedBonus; int attackBonus, defenseBonus, healthBonus, speedBonus;
int currentHealth; int currentHealth;
int shotsLeft; int shotsLeft;
std::set<int> effects; //IDs of spells affecting stack std::set<int> effects; //IDs of spells affecting stack
int morale, luck; int morale, luck;
}; };
class CGameInterface class CGameInterface
{ {
public: public:
bool human; bool human;
int playerID, serialID; int playerID, serialID;
virtual void buildChanged(const CGTownInstance *town, int buildingID, int what){}; //what: 1 - built, 2 - demolished virtual void buildChanged(const CGTownInstance *town, int buildingID, int what){}; //what: 1 - built, 2 - demolished
virtual void garrisonChanged(const CGObjectInstance * obj){}; virtual void garrisonChanged(const CGObjectInstance * obj){};
virtual void heroArtifactSetChanged(const CGHeroInstance*hero){}; virtual void heroArtifactSetChanged(const CGHeroInstance*hero){};
virtual void heroCreated(const CGHeroInstance*){}; virtual void heroCreated(const CGHeroInstance*){};
virtual void heroGotLevel(const CGHeroInstance *hero, int pskill, std::vector<ui16> &skills, boost::function<void(ui32)> &callback)=0; //pskill is gained primary skill, interface has to choose one of given skills and call callback with selection id virtual void heroGotLevel(const CGHeroInstance *hero, int pskill, std::vector<ui16> &skills, boost::function<void(ui32)> &callback)=0; //pskill is gained primary skill, interface has to choose one of given skills and call callback with selection id
virtual void heroInGarrisonChange(const CGTownInstance *town){}; virtual void heroInGarrisonChange(const CGTownInstance *town){};
virtual void heroKilled(const CGHeroInstance*){}; virtual void heroKilled(const CGHeroInstance*){};
virtual void heroMoved(const HeroMoveDetails & details){}; virtual void heroMoved(const HeroMoveDetails & details){};
virtual void heroPrimarySkillChanged(const CGHeroInstance * hero, int which, int val){}; virtual void heroPrimarySkillChanged(const CGHeroInstance * hero, int which, int val){};
virtual void heroManaPointsChanged(const CGHeroInstance * hero){} //not called at the beginning of turn and after spell casts virtual void heroManaPointsChanged(const CGHeroInstance * hero){} //not called at the beginning of turn and after spell casts
virtual void heroMovePointsChanged(const CGHeroInstance * hero){} //not called at the beginning of turn and after movement virtual void heroMovePointsChanged(const CGHeroInstance * hero){} //not called at the beginning of turn and after movement
virtual void heroVisitsTown(const CGHeroInstance* hero, const CGTownInstance * town){}; virtual void heroVisitsTown(const CGHeroInstance* hero, const CGTownInstance * town){};
virtual void init(ICallback * CB){}; virtual void init(ICallback * CB){};
virtual void receivedResource(int type, int val){}; virtual void receivedResource(int type, int val){};
virtual void showInfoDialog(std::string &text, const std::vector<Component*> &components){}; virtual void showInfoDialog(std::string &text, const std::vector<Component*> &components){};
virtual void showSelDialog(std::string &text, const std::vector<Component*> &components, ui32 askID){}; virtual void showSelDialog(std::string &text, const std::vector<Component*> &components, ui32 askID){};
virtual void showYesNoDialog(std::string &text, const std::vector<Component*> &components, ui32 askID){}; virtual void showYesNoDialog(std::string &text, const std::vector<Component*> &components, ui32 askID){};
virtual void tileHidden(const std::set<int3> &pos){}; virtual void tileHidden(const std::set<int3> &pos){};
virtual void tileRevealed(const std::set<int3> &pos){}; virtual void tileRevealed(const std::set<int3> &pos){};
virtual void yourTurn(){}; virtual void yourTurn(){};
virtual void availableCreaturesChanged(const CGTownInstance *town){}; virtual void availableCreaturesChanged(const CGTownInstance *town){};
//battle call-ins //battle call-ins
virtual void actionFinished(const BattleAction *action){};//occurs AFTER every action taken by any stack or by the hero virtual void actionFinished(const BattleAction *action){};//occurs AFTER every action taken by any stack or by the hero
virtual void actionStarted(const BattleAction *action){};//occurs BEFORE every action taken by any stack or by the hero virtual void actionStarted(const BattleAction *action){};//occurs BEFORE every action taken by any stack or by the hero
virtual BattleAction activeStack(int stackID)=0; //called when it's turn of that stack virtual BattleAction activeStack(int stackID)=0; //called when it's turn of that stack
virtual void battleAttack(BattleAttack *ba){}; //called when stack is performing attack virtual void battleAttack(BattleAttack *ba){}; //called when stack is performing attack
virtual void battleStackAttacked(BattleStackAttacked * bsa){}; //called when stack receives damage (after battleAttack()) virtual void battleStackAttacked(BattleStackAttacked * bsa){}; //called when stack receives damage (after battleAttack())
virtual void battleEnd(BattleResult *br){}; virtual void battleEnd(BattleResult *br){};
virtual void battleNewRound(int round){}; //called at the beggining of each turn, round=-1 is the tactic phase, round=0 is the first "normal" turn virtual void battleNewRound(int round){}; //called at the beggining of each turn, round=-1 is the tactic phase, round=0 is the first "normal" turn
virtual void battleStackMoved(int ID, int dest){}; virtual void battleStackMoved(int ID, int dest){};
virtual void battleSpellCasted(SpellCasted *sc){}; virtual void battleSpellCasted(SpellCasted *sc){};
virtual void battleStart(CCreatureSet *army1, CCreatureSet *army2, int3 tile, CGHeroInstance *hero1, CGHeroInstance *hero2, bool side){}; //called by engine when battle starts; side=0 - left, side=1 - right virtual void battleStart(CCreatureSet *army1, CCreatureSet *army2, int3 tile, CGHeroInstance *hero1, CGHeroInstance *hero2, bool side){}; //called by engine when battle starts; side=0 - left, side=1 - right
virtual void battlefieldPrepared(int battlefieldType, std::vector<CObstacle*> obstacles){}; //called when battlefield is prepared, prior the battle beginning virtual void battlefieldPrepared(int battlefieldType, std::vector<CObstacle*> obstacles){}; //called when battlefield is prepared, prior the battle beginning
}; };
class CAIHandler class CAIHandler
{ {
public: public:
static CGlobalAI * getNewAI(CCallback * cb, std::string dllname); static CGlobalAI * getNewAI(CCallback * cb, std::string dllname);
}; };
class CGlobalAI : public CGameInterface // AI class (to derivate) class CGlobalAI : public CGameInterface // AI class (to derivate)
{ {
public: public:
//CGlobalAI(); //CGlobalAI();
virtual void yourTurn(){}; virtual void yourTurn(){};
virtual void heroKilled(const CGHeroInstance*){}; virtual void heroKilled(const CGHeroInstance*){};
virtual void heroCreated(const CGHeroInstance*){}; virtual void heroCreated(const CGHeroInstance*){};
virtual void battleStackMoved(int ID, int dest, bool startMoving, bool endMoving){}; virtual void battleStackMoved(int ID, int dest, bool startMoving, bool endMoving){};
virtual void battleStackAttacking(int ID, int dest){}; virtual void battleStackAttacking(int ID, int dest){};
virtual void battleStackIsAttacked(int ID, int dmg, int killed, int IDby, bool byShooting){}; virtual void battleStackIsAttacked(int ID, int dmg, int killed, int IDby, bool byShooting){};
virtual BattleAction activeStack(int stackID) {BattleAction ba; ba.actionType = 3; ba.stackNumber = stackID; return ba;}; virtual BattleAction activeStack(int stackID) {BattleAction ba; ba.actionType = 3; ba.stackNumber = stackID; return ba;};
}; };
#endif //CGAMEINTERFACE_H
#endif // __CGAMEINTERFACE_H__

443
CGameState.h
View File

@ -1,221 +1,222 @@
#ifndef CGAMESTATE_H #ifndef __CGAMESTATE_H__
#define CGAMESTATE_H #define __CGAMESTATE_H__
#include "global.h" #include "global.h"
#ifndef _MSC_VER #ifndef _MSC_VER
#include "hch/CCreatureHandler.h" #include "hch/CCreatureHandler.h"
#include "lib/VCMI_Lib.h" #include "lib/VCMI_Lib.h"
#endif #endif
#include <set> #include <set>
#include <vector> #include <vector>
#ifdef _WIN32 #ifdef _WIN32
#include <tchar.h> #include <tchar.h>
#else #else
#include "tchar_amigaos4.h" #include "tchar_amigaos4.h"
#endif #endif
class CTown; class CTown;
class CScriptCallback; class CScriptCallback;
class CCallback; class CCallback;
class CLuaCallback; class CLuaCallback;
class CCPPObjectScript; class CCPPObjectScript;
class CCreatureSet; class CCreatureSet;
class CStack; class CStack;
class CGHeroInstance; class CGHeroInstance;
class CGTownInstance; class CGTownInstance;
class CArmedInstance; class CArmedInstance;
class CGDefInfo; class CGDefInfo;
class CObjectScript; class CObjectScript;
class CGObjectInstance; class CGObjectInstance;
class CCreature; class CCreature;
struct Mapa; struct Mapa;
struct StartInfo; struct StartInfo;
struct SDL_Surface; struct SDL_Surface;
class CMapHandler; class CMapHandler;
class CPathfinder; class CPathfinder;
struct IPack; struct IPack;
namespace boost namespace boost
{ {
class shared_mutex; class shared_mutex;
} }
struct DLL_EXPORT PlayerState struct DLL_EXPORT PlayerState
{ {
public: public:
ui8 color, serial; ui8 color, serial;
ui32 currentSelection; //id of hero/town, 0xffffffff if none ui32 currentSelection; //id of hero/town, 0xffffffff if none
std::vector<std::vector<std::vector<ui8> > > fogOfWarMap; //true - visible, false - hidden std::vector<std::vector<std::vector<ui8> > > fogOfWarMap; //true - visible, false - hidden
std::vector<si32> resources; std::vector<si32> resources;
std::vector<CGHeroInstance *> heroes; std::vector<CGHeroInstance *> heroes;
std::vector<CGTownInstance *> towns; std::vector<CGTownInstance *> towns;
std::vector<CGHeroInstance *> availableHeroes; //heroes available in taverns std::vector<CGHeroInstance *> availableHeroes; //heroes available in taverns
PlayerState():color(-1),currentSelection(0xffffffff){}; PlayerState():color(-1),currentSelection(0xffffffff){};
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & color & serial & currentSelection & fogOfWarMap & resources; h & color & serial & currentSelection & fogOfWarMap & resources;
//TODO: vectors of heroes/towns //TODO: vectors of heroes/towns
} }
}; };
struct DLL_EXPORT BattleInfo struct DLL_EXPORT BattleInfo
{ {
ui8 side1, side2; ui8 side1, side2;
si32 round, activeStack; si32 round, activeStack;
ui8 siege; // = 0 ordinary battle = 1 a siege with a Fort = 2 a siege with a Citadel = 3 a siege with a Castle ui8 siege; // = 0 ordinary battle = 1 a siege with a Fort = 2 a siege with a Citadel = 3 a siege with a Castle
int3 tile; //for background and bonuses int3 tile; //for background and bonuses
si32 hero1, hero2; si32 hero1, hero2;
CCreatureSet army1, army2; CCreatureSet army1, army2;
std::vector<CStack*> stacks; std::vector<CStack*> stacks;
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & side1 & side2 & round & activeStack & siege & tile & stacks & army1 & army2 & hero1 & hero2; h & side1 & side2 & round & activeStack & siege & tile & stacks & army1 & army2 & hero1 & hero2;
} }
CStack * getNextStack(); //which stack will have turn after current one CStack * getNextStack(); //which stack will have turn after current one
std::vector<CStack> getStackQueue(); //returns stack in order of their movement action std::vector<CStack> getStackQueue(); //returns stack in order of their movement action
CStack * getStack(int stackID); CStack * getStack(int stackID);
CStack * getStackT(int tileID); CStack * getStackT(int tileID);
void getAccessibilityMap(bool *accessibility, int stackToOmmit=-1); //send pointer to at least 187 allocated bytes void getAccessibilityMap(bool *accessibility, int stackToOmmit=-1); //send pointer to at least 187 allocated bytes
void getAccessibilityMapForTwoHex(bool *accessibility, bool atackerSide, int stackToOmmit=-1); //send pointer to at least 187 allocated bytes void getAccessibilityMapForTwoHex(bool *accessibility, bool atackerSide, int stackToOmmit=-1); //send pointer to at least 187 allocated bytes
void makeBFS(int start, bool*accessibility, int *predecessor, int *dists); //*accessibility must be prepared bool[187] array; last two pointers must point to the at least 187-elements int arrays - there is written result void makeBFS(int start, bool*accessibility, int *predecessor, int *dists); //*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::vector<int> getPath(int start, int dest, bool*accessibility); std::vector<int> getPath(int start, int dest, bool*accessibility);
std::vector<int> getAccessibility(int stackID); //returns vector of accessible tiles (taking into account the creature range) std::vector<int> getAccessibility(int stackID); //returns vector of accessible tiles (taking into account the creature range)
bool isStackBlocked(int ID); //returns true if there is neighbouring enemy stack bool isStackBlocked(int ID); //returns true if there is neighbouring enemy stack
static signed char mutualPosition(int hex1, int hex2); //returns info about mutual position of given hexes (-1 - they're distant, 0 - left top, 1 - right top, 2 - right, 3 - right bottom, 4 - left bottom, 5 - left) static signed char mutualPosition(int hex1, int hex2); //returns info about mutual position of given hexes (-1 - they're distant, 0 - left top, 1 - right top, 2 - right, 3 - right bottom, 4 - left bottom, 5 - left)
static std::vector<int> neighbouringTiles(int hex); static std::vector<int> neighbouringTiles(int hex);
static int calculateDmg(const CStack* attacker, const CStack* defender, const CGHeroInstance * attackerHero, const CGHeroInstance * defendingHero, bool shooting); //TODO: add additional conditions and require necessary data static int calculateDmg(const CStack* attacker, const CStack* defender, const CGHeroInstance * attackerHero, const CGHeroInstance * defendingHero, bool shooting); //TODO: add additional conditions and require necessary data
void calculateCasualties(std::set<std::pair<ui32,si32> > *casualties); void calculateCasualties(std::set<std::pair<ui32,si32> > *casualties);
}; };
class DLL_EXPORT CStack class DLL_EXPORT CStack
{ {
public: public:
ui32 ID; //unique ID of stack ui32 ID; //unique ID of stack
CCreature * creature; CCreature * creature;
ui32 amount, baseAmount; ui32 amount, baseAmount;
ui32 firstHPleft; //HP of first creature in stack ui32 firstHPleft; //HP of first creature in stack
ui8 owner, slot; //owner - player colour (255 for neutrals), slot - position in garrison (may be 255 for neutrals/called creatures) ui8 owner, slot; //owner - player colour (255 for neutrals), slot - position in garrison (may be 255 for neutrals/called creatures)
ui8 attackerOwned; //if true, this stack is owned by attakcer (this one from left hand side of battle) ui8 attackerOwned; //if true, this stack is owned by attakcer (this one from left hand side of battle)
ui16 position; //position on battlefield ui16 position; //position on battlefield
ui8 counterAttacks; //how many counter attacks can be performed more in this turn (by default set at the beginning of the round to 1) ui8 counterAttacks; //how many counter attacks can be performed more in this turn (by default set at the beginning of the round to 1)
si16 shots; //how many shots left si16 shots; //how many shots left
std::set<EAbilities> abilities; std::set<EAbilities> abilities;
std::set<ECombatInfo> state; std::set<ECombatInfo> state;
struct StackEffect struct StackEffect
{ {
ui16 id; //spell id ui16 id; //spell id
ui8 level; //skill level ui8 level; //skill level
ui16 turnsRemain; ui16 turnsRemain;
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & id & level & turnsRemain; h & id & level & turnsRemain;
} }
}; };
std::vector<StackEffect> effects; std::vector<StackEffect> effects;
CStack(CCreature * C, int A, int O, int I, bool AO, int S); CStack(CCreature * C, int A, int O, int I, bool AO, int S);
CStack() : creature(NULL),amount(-1),owner(255), position(-1), ID(-1), attackerOwned(true), firstHPleft(-1), slot(255), baseAmount(-1), counterAttacks(1), effects(), state(), abilities(){} CStack() : creature(NULL),amount(-1),owner(255), position(-1), ID(-1), attackerOwned(true), firstHPleft(-1), slot(255), baseAmount(-1), counterAttacks(1), effects(), state(), abilities(){}
const StackEffect * getEffect(ui16 id) const; //effect id (SP) const StackEffect * getEffect(ui16 id) const; //effect id (SP)
ui32 speed() const; ui32 speed() const;
template <typename Handler> void save(Handler &h, const int version) template <typename Handler> void save(Handler &h, const int version)
{ {
h & creature->idNumber; h & creature->idNumber;
} }
template <typename Handler> void load(Handler &h, const int version) template <typename Handler> void load(Handler &h, const int version)
{ {
ui32 id; ui32 id;
h & id; h & id;
creature = &VLC->creh->creatures[id]; creature = &VLC->creh->creatures[id];
abilities = creature->abilities; abilities = creature->abilities;
} }
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & ID & amount & baseAmount & firstHPleft & owner & slot & attackerOwned & position & state & counterAttacks h & ID & amount & baseAmount & firstHPleft & owner & slot & attackerOwned & position & state & counterAttacks
& shots; & shots;
if(h.saving) if(h.saving)
save(h,version); save(h,version);
else else
load(h,version); load(h,version);
} }
bool alive() const bool alive() const
{ {
return vstd::contains(state,ALIVE); return vstd::contains(state,ALIVE);
} }
}; };
struct UpgradeInfo struct UpgradeInfo
{ {
int oldID; //creature to be upgraded int oldID; //creature to be upgraded
std::vector<int> newID; //possible upgrades std::vector<int> newID; //possible upgrades
std::vector<std::set<std::pair<int,int> > > cost; // cost[upgrade_serial] -> set of pairs<resource_ID,resource_amount> std::vector<std::set<std::pair<int,int> > > cost; // cost[upgrade_serial] -> set of pairs<resource_ID,resource_amount>
UpgradeInfo(){oldID = -1;}; UpgradeInfo(){oldID = -1;};
}; };
class DLL_EXPORT CGameState class DLL_EXPORT CGameState
{ {
private: private:
StartInfo* scenarioOps; StartInfo* scenarioOps;
ui32 seed; ui32 seed;
ui8 currentPlayer; //ID of player currently having turn ui8 currentPlayer; //ID of player currently having turn
BattleInfo *curB; //current battle BattleInfo *curB; //current battle
ui32 day; //total number of days in game ui32 day; //total number of days in game
Mapa * map; Mapa * map;
std::map<ui8,PlayerState> players; //ID <-> player state std::map<ui8,PlayerState> players; //ID <-> player state
std::map<int, CGDefInfo*> villages, forts, capitols; //def-info for town graphics std::map<int, CGDefInfo*> villages, forts, capitols; //def-info for town graphics
std::vector<ui32> resVals; std::vector<ui32> resVals;
struct DLL_EXPORT HeroesPool struct DLL_EXPORT HeroesPool
{ {
std::map<ui32,CGHeroInstance *> heroesPool; //[subID] - heroes available to buy; NULL if not available std::map<ui32,CGHeroInstance *> heroesPool; //[subID] - heroes available to buy; NULL if not available
std::map<ui32,ui8> pavailable; // [subid] -> which players can recruit hero std::map<ui32,ui8> pavailable; // [subid] -> which players can recruit hero
CGHeroInstance * pickHeroFor(bool native, int player, const CTown *town, int notThatOne=-1); CGHeroInstance * pickHeroFor(bool native, int player, const CTown *town, int notThatOne=-1);
} hpool; //we have here all heroes available on this map that are not hired } hpool; //we have here all heroes available on this map that are not hired
boost::shared_mutex *mx; boost::shared_mutex *mx;
CGameState(); CGameState();
~CGameState(); ~CGameState();
void init(StartInfo * si, Mapa * map, int Seed); void init(StartInfo * si, Mapa * map, int Seed);
void loadTownDInfos(); void loadTownDInfos();
void applyNL(IPack * pack); void applyNL(IPack * pack);
void apply(IPack * pack); void apply(IPack * pack);
void randomizeObject(CGObjectInstance *cur); void randomizeObject(CGObjectInstance *cur);
std::pair<int,int> pickObject(CGObjectInstance *obj); std::pair<int,int> pickObject(CGObjectInstance *obj);
int pickHero(int owner); int pickHero(int owner);
CGHeroInstance *getHero(int objid); CGHeroInstance *getHero(int objid);
CGTownInstance *getTown(int objid); CGTownInstance *getTown(int objid);
bool battleMoveCreatureStack(int ID, int dest); bool battleMoveCreatureStack(int ID, int dest);
bool battleAttackCreatureStack(int ID, int dest); bool battleAttackCreatureStack(int ID, int dest);
bool battleShootCreatureStack(int ID, int dest); bool battleShootCreatureStack(int ID, int dest);
int battleGetStack(int pos); //returns ID of stack at given tile int battleGetStack(int pos); //returns ID of stack at given tile
UpgradeInfo getUpgradeInfo(CArmedInstance *obj, int stackPos); UpgradeInfo getUpgradeInfo(CArmedInstance *obj, int stackPos);
float getMarketEfficiency(int player, int mode=0); float getMarketEfficiency(int player, int mode=0);
std::set<int3> tilesToReveal(int3 pos, int radious, int player) const; //if player==-1 => adds all tiles in radious std::set<int3> tilesToReveal(int3 pos, int radious, int player) const; //if player==-1 => adds all tiles in radious
public: public:
int getDate(int mode=0) const; //mode=0 - total days in game, mode=1 - day of week, mode=2 - current week, mode=3 - current month int getDate(int mode=0) const; //mode=0 - total days in game, mode=1 - day of week, mode=2 - current week, mode=3 - current month
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & scenarioOps & seed & currentPlayer & day & map & players & resVals; h & scenarioOps & seed & currentPlayer & day & map & players & resVals;
if(!h.saving) if(!h.saving)
{ {
loadTownDInfos(); loadTownDInfos();
} }
//TODO: hero pool //TODO: hero pool
} }
friend class CCallback; friend class CCallback;
friend class CPathfinder;; friend class CPathfinder;;
friend class CLuaCallback; friend class CLuaCallback;
friend class CClient; friend class CClient;
friend void initGameState(Mapa * map, CGameInfo * cgi); friend void initGameState(Mapa * map, CGameInfo * cgi);
friend class CScriptCallback; friend class CScriptCallback;
friend class CMapHandler; friend class CMapHandler;
friend class CGameHandler; friend class CGameHandler;
}; };
#endif //CGAMESTATE_H
#endif // __CGAMESTATE_H__

7
CHeroWindow.h
View File

@ -1,5 +1,5 @@
#ifndef CHEROWINDOW_H #ifndef __CHEROWINDOW_H__
#define CHEROWINDOW_H #define __CHEROWINDOW_H__
#include "CPlayerInterface.h" #include "CPlayerInterface.h"
@ -130,4 +130,5 @@ public:
friend void CArtPlace::clickLeft(tribool down); friend void CArtPlace::clickLeft(tribool down);
friend class CPlayerInterface; friend class CPlayerInterface;
}; };
#endif //CHEROWINDOW_H
#endif // __CHEROWINDOW_H__

47
CLuaHandler.h
View File

@ -1,23 +1,24 @@
#ifndef CLUAHANDLER_H #ifndef __CLUAHANDLER_H__
#define CLUAHANDLER_H #define __CLUAHANDLER_H__
#include "global.h" #include "global.h"
#if (LUA_VERSION_NUM < 500) #if (LUA_VERSION_NUM < 500)
# define LUA_OPEN_LIB(L, lib) lib(L) # define LUA_OPEN_LIB(L, lib) lib(L)
#else #else
# define LUA_OPEN_LIB(L, lib) \ # define LUA_OPEN_LIB(L, lib) \
lua_pushcfunction((L), lib); \ lua_pushcfunction((L), lib); \
lua_pcall((L), 0, 0, 0); lua_pcall((L), 0, 0, 0);
#endif #endif
class CLuaHandler class CLuaHandler
{ {
public: public:
CLuaHandler(); CLuaHandler();
static std::vector<std::string> * searchForScripts(std::string fol); static std::vector<std::string> * searchForScripts(std::string fol);
static std::vector<std::string> * functionList(std::string file); static std::vector<std::string> * functionList(std::string file);
~CLuaHandler(); ~CLuaHandler();
void test(); void test();
}; };
#endif //CLUAHANDLER_H
#endif // __CLUAHANDLER_H__

105
CMessage.h
View File

@ -1,52 +1,53 @@
#ifndef CMESSAGE_H #ifndef __CMESSAGE_H__
#define CMESSAGE_H #define __CMESSAGE_H__
#include "global.h" #include "global.h"
#include <SDL_ttf.h> #include <SDL_ttf.h>
#include <SDL.h> #include <SDL.h>
#include "CPreGame.h" #include "CPreGame.h"
enum EWindowType {infoOnly, infoOK, yesOrNO}; enum EWindowType {infoOnly, infoOK, yesOrNO};
class CPreGame; class CPreGame;
class MapSel; class MapSel;
class CSimpleWindow; class CSimpleWindow;
class CInfoWindow; class CInfoWindow;
class CDefHandler; class CDefHandler;
class SComponent; class SComponent;
class CSelWindow; class CSelWindow;
class CSelectableComponent; class CSelectableComponent;
namespace NMessage namespace NMessage
{ {
extern CDefHandler * ok, *cancel; extern CDefHandler * ok, *cancel;
extern std::vector<std::vector<SDL_Surface*> > piecesOfBox; //in colors of all players extern std::vector<std::vector<SDL_Surface*> > piecesOfBox; //in colors of all players
extern SDL_Surface * background ; extern SDL_Surface * background ;
} }
class CMessage class CMessage
{ {
public: public:
static std::pair<int,int> getMaxSizes(std::vector<std::vector<SDL_Surface*> > * txtg); static std::pair<int,int> getMaxSizes(std::vector<std::vector<SDL_Surface*> > * txtg);
static std::pair<int, int> getMaxSizes(std::vector< std::vector<SComponent*> > * komp); static std::pair<int, int> getMaxSizes(std::vector< std::vector<SComponent*> > * komp);
static std::vector<std::vector<SDL_Surface*> > * drawText(std::vector<std::string> * brtext); static std::vector<std::vector<SDL_Surface*> > * drawText(std::vector<std::string> * brtext);
static SDL_Surface * blitTextOnSur(std::vector<std::vector<SDL_Surface*> > * txtg, int & curh, SDL_Surface * ret); static SDL_Surface * blitTextOnSur(std::vector<std::vector<SDL_Surface*> > * txtg, int & curh, SDL_Surface * ret);
static SDL_Surface * blitCompsOnSur(std::vector<SComponent*> & comps, int maxw, int inter, int & curh, SDL_Surface * ret); static SDL_Surface * blitCompsOnSur(std::vector<SComponent*> & comps, int maxw, int inter, int & curh, SDL_Surface * ret);
static SDL_Surface * blitCompsOnSur(SDL_Surface *_or, std::vector< std::vector<SComponent*> > *komp, int inter, int &curh, SDL_Surface *ret); static SDL_Surface * blitCompsOnSur(SDL_Surface *_or, std::vector< std::vector<SComponent*> > *komp, int inter, int &curh, SDL_Surface *ret);
static void drawIWindow(CInfoWindow * ret, std::string text, int player, int charperline); static void drawIWindow(CInfoWindow * ret, std::string text, int player, int charperline);
static std::vector< std::vector<SComponent*> > * breakComps(std::vector<SComponent*> &comps, int maxw, SDL_Surface* _or=NULL); static std::vector< std::vector<SComponent*> > * breakComps(std::vector<SComponent*> &comps, int maxw, SDL_Surface* _or=NULL);
static CSelWindow * genSelWindow(std::string text, int player, int charperline, std::vector<CSelectableComponent*> & comps, int owner); static CSelWindow * genSelWindow(std::string text, int player, int charperline, std::vector<CSelectableComponent*> & comps, int owner);
static CSimpleWindow * genWindow(std::string text, int player, int Lmar=35, int Rmar=35, int Tmar=35, int Bmar=35);//supports h3 text formatting; player sets color of window, Lmar/Rmar/Tmar/Bmar are Left/Right/Top/Bottom margins static CSimpleWindow * genWindow(std::string text, int player, int Lmar=35, int Rmar=35, int Tmar=35, int Bmar=35);//supports h3 text formatting; player sets color of window, Lmar/Rmar/Tmar/Bmar are Left/Right/Top/Bottom margins
static SDL_Surface * genMessage(std::string title, std::string text, EWindowType type=infoOnly, static SDL_Surface * genMessage(std::string title, std::string text, EWindowType type=infoOnly,
std::vector<CDefHandler*> *addPics=NULL, void * cb=NULL); std::vector<CDefHandler*> *addPics=NULL, void * cb=NULL);
static SDL_Surface * drawBox1(int w, int h, int playerColor=1); static SDL_Surface * drawBox1(int w, int h, int playerColor=1);
static void drawBorder(int playerColor, SDL_Surface * ret, int w, int h, int x=0, int y=0); static void drawBorder(int playerColor, SDL_Surface * ret, int w, int h, int x=0, int y=0);
static SDL_Surface * drawBoxTextBitmapSub(int player, std::string text, SDL_Surface* bitmap, std::string sub, int charperline=30, int imgToBmp=55); static SDL_Surface * drawBoxTextBitmapSub(int player, std::string text, SDL_Surface* bitmap, std::string sub, int charperline=30, int imgToBmp=55);
static std::vector<std::string> * breakText(std::string text, size_t line=30, bool userBreak=true, bool ifor=true); //line - chars per line static std::vector<std::string> * breakText(std::string text, size_t line=30, bool userBreak=true, bool ifor=true); //line - chars per line
CMessage(); CMessage();
static void init(); static void init();
static void dispose(); static void dispose();
}; };
// //
#endif //CMESSAGE_H
#endif // __CMESSAGE_H__

85
CPathfinder.h
View File

@ -1,42 +1,43 @@
#ifndef CPATHFINDER_H #ifndef __CPATHFINDER_H__
#define CPATHFINDER_H #define __CPATHFINDER_H__
#include "global.h" #include "global.h"
#include <queue> #include <queue>
#include <vector> #include <vector>
class CGHeroInstance; class CGHeroInstance;
struct CPathNode struct CPathNode
{ {
bool accesible; //true if a hero can be on this node bool accesible; //true if a hero can be on this node
int dist; //distance from the first node of searching; -1 is infinity int dist; //distance from the first node of searching; -1 is infinity
CPathNode * theNodeBefore; CPathNode * theNodeBefore;
int3 coord; //coordiantes int3 coord; //coordiantes
bool visited; bool visited;
}; };
struct CPath struct CPath
{ {
std::vector<CPathNode> nodes; //just get node by node std::vector<CPathNode> nodes; //just get node by node
int3 startPos(); // start point int3 startPos(); // start point
int3 endPos(); //destination point int3 endPos(); //destination point
}; };
/** /**
* main pathfinder class * main pathfinder class
*/ */
class CPathfinder class CPathfinder
{ {
private: private:
std::vector< std::vector<CPathNode> > graph; std::vector< std::vector<CPathNode> > graph;
void processNode(CPathNode & dp, const CGHeroInstance * hero, std::queue<CPathNode> & mq, const CPathNode & cp, const int3 & src, bool diagonal); //helper function for getPath void processNode(CPathNode & dp, const CGHeroInstance * hero, std::queue<CPathNode> & mq, const CPathNode & cp, const int3 & src, bool diagonal); //helper function for getPath
bool checkForVisitableDir(const int3 & src, const int3 & dst) const; bool checkForVisitableDir(const int3 & src, const int3 & dst) const;
public: public:
CPath * getPath(int3 src, int3 dest, const CGHeroInstance * hero, unsigned char type=0); //calculates path between src and dest; returns pointer to CPath or NULL if path does not exists; type - type of calculation: 0 - positions are normal positions of hero; 1 - given places are tiles blocked by hero CPath * getPath(int3 src, int3 dest, const CGHeroInstance * hero, unsigned char type=0); //calculates path between src and dest; returns pointer to CPath or NULL if path does not exists; type - type of calculation: 0 - positions are normal positions of hero; 1 - given places are tiles blocked by hero
CPath * getPath(const int3 & src, const int3 & dest, const CGHeroInstance * hero, int (*getDist)(int3 & a, int3 & b), unsigned char type=0); //calculates path between src and dest; returns pointer to CPath or NULL if path does not exists; uses getDist to calculate distance; type - type of calculation: 0 - positions are normal positions of hero; 1 - given places are tiles blocked by hero CPath * getPath(const int3 & src, const int3 & dest, const CGHeroInstance * hero, int (*getDist)(int3 & a, int3 & b), unsigned char type=0); //calculates path between src and dest; returns pointer to CPath or NULL if path does not exists; uses getDist to calculate distance; type - type of calculation: 0 - positions are normal positions of hero; 1 - given places are tiles blocked by hero
static void convertPath(CPath * path, unsigned int mode); //mode=0 -> from 'manifest' to 'object' static void convertPath(CPath * path, unsigned int mode); //mode=0 -> from 'manifest' to 'object'
}; };
#endif //CPATHFINDER_H
#endif // __CPATHFINDER_H__

1433
CPlayerInterface.h
View File

File diff suppressed because it is too large Load Diff

593
CPreGame.h
View File

@ -1,296 +1,297 @@
#ifndef CPREGAME_H #ifndef __CPREGAME_H__
#define CPREGAME_H #define __CPREGAME_H__
#include "global.h" #include "global.h"
#include <set> #include <set>
#include <SDL.h> #include <SDL.h>
#include "StartInfo.h" #include "StartInfo.h"
#include "CMessage.h" #include "CMessage.h"
#include "map.h" #include "map.h"
#include "hch/CMusicHandler.h" #include "hch/CMusicHandler.h"
#include <boost/function.hpp> #include <boost/function.hpp>
#include <boost/bind.hpp> #include <boost/bind.hpp>
#include <cstdlib> #include <cstdlib>
class CPreGame; class CPreGame;
class CDefHandler; class CDefHandler;
extern CPreGame * CPG; extern CPreGame * CPG;
typedef void(CPreGame::*ttt)(); typedef void(CPreGame::*ttt)();
class CGroup; class CGroup;
class CPoinGroup ; class CPoinGroup ;
class IntSelBut; class IntSelBut;
struct HighButton struct HighButton
{ {
int ID; int ID;
int type; int type;
SDL_Rect pos; SDL_Rect pos;
CDefHandler* imgs; CDefHandler* imgs;
int state; int state;
HighButton( SDL_Rect Pos, CDefHandler* Imgs, bool Sel=false, int id=-1); HighButton( SDL_Rect Pos, CDefHandler* Imgs, bool Sel=false, int id=-1);
HighButton(); HighButton();
~HighButton(); ~HighButton();
bool selectable, selected; bool selectable, selected;
bool highlightable, highlighted; bool highlightable, highlighted;
virtual void show(); virtual void show();
virtual void press(bool down=true); virtual void press(bool down=true);
virtual void hover(bool on=true)=0; virtual void hover(bool on=true)=0;
virtual void select(bool on=true)=0; virtual void select(bool on=true)=0;
}; };
struct Button: public HighButton struct Button: public HighButton
{ {
CGroup *ourGroup; CGroup *ourGroup;
Button( SDL_Rect Pos, boost::function<void()> Fun,CDefHandler* Imgs, bool Sel=false, CGroup* gr=NULL, int id=-1); Button( SDL_Rect Pos, boost::function<void()> Fun,CDefHandler* Imgs, bool Sel=false, CGroup* gr=NULL, int id=-1);
Button(); Button();
boost::function<void()> fun; boost::function<void()> fun;
virtual void hover(bool on=true); virtual void hover(bool on=true);
virtual void select(bool on=true); virtual void select(bool on=true);
}; };
struct SetrButton: public Button struct SetrButton: public Button
{ {
int key, * poin; int key, * poin;
virtual void press(bool down=true); virtual void press(bool down=true);
SetrButton(); SetrButton();
}; };
class Slider class Slider
{ {
public: public:
bool vertical; // false means horizontal bool vertical; // false means horizontal
SDL_Rect pos; // position SDL_Rect pos; // position
Button *up, *down, //or left/right Button *up, *down, //or left/right
*slider; *slider;
int positionsAmnt, capacity;// capacity - amount of positions dispplayed at once int positionsAmnt, capacity;// capacity - amount of positions dispplayed at once
int whereAreWe; // first displayed thing int whereAreWe; // first displayed thing
bool moving; bool moving;
boost::function<void(int)> fun; boost::function<void(int)> fun;
void clickDown(int x, int y, bool bzgl=true); void clickDown(int x, int y, bool bzgl=true);
void clickUp(int x, int y, bool bzgl=true); void clickUp(int x, int y, bool bzgl=true);
void mMove(int x, int y, bool bzgl=true); void mMove(int x, int y, bool bzgl=true);
void moveUp(); void moveUp();
void moveDown(); void moveDown();
void deactivate(); void deactivate();
void activate(); void activate();
Slider(int x, int y, int h, int amnt, int cap, bool ver); Slider(int x, int y, int h, int amnt, int cap, bool ver);
~Slider(); ~Slider();
void updateSlid(); void updateSlid();
void handleIt(SDL_Event sev); void handleIt(SDL_Event sev);
}; };
struct IntBut: public Button struct IntBut: public Button
{ {
public: public:
int key; int key;
int * what; int * what;
IntBut(); IntBut();
void set(); void set();
}; };
class CGroup class CGroup
{ {
public: public:
Button * selected; Button * selected;
int type; // 1=sinsel int type; // 1=sinsel
CGroup():selected(NULL),type(0){}; CGroup():selected(NULL),type(0){};
}; };
class CPoinGroup :public CGroup class CPoinGroup :public CGroup
{ {
public: public:
int * gdzie; //where (po polsku, bo by by�o s�owo kluczowe :/) int * gdzie; //where (po polsku, bo by by�o s�owo kluczowe :/)
void setYour(IntSelBut * your); void setYour(IntSelBut * your);
}; };
struct IntSelBut: public Button struct IntSelBut: public Button
{ {
public: public:
CPoinGroup * ourPoinGroup; CPoinGroup * ourPoinGroup;
int key; int key;
IntSelBut(){}; IntSelBut(){};
IntSelBut( SDL_Rect Pos, boost::function<void()> Fun,CDefHandler* Imgs, bool Sel=false, CPoinGroup* gr=NULL, int My=-1); IntSelBut( SDL_Rect Pos, boost::function<void()> Fun,CDefHandler* Imgs, bool Sel=false, CPoinGroup* gr=NULL, int My=-1);
void select(bool on=true); void select(bool on=true);
}; };
class PreGameTab class PreGameTab
{ {
public: public:
bool showed; bool showed;
virtual void init()=0; virtual void init()=0;
virtual void show()=0; virtual void show()=0;
virtual void hide()=0; virtual void hide()=0;
PreGameTab(); PreGameTab();
}; };
class RanSel : public PreGameTab class RanSel : public PreGameTab
{ {
Button horcpl[9], horcte[9], conpl[9], conte[8], water[4], monster[4], //last is random Button horcpl[9], horcte[9], conpl[9], conte[8], water[4], monster[4], //last is random
size[4], twoLevel, showRand; size[4], twoLevel, showRand;
CGroup *Ghorcpl, *Ghorcte, *Gconpl, *Gconte, *Gwater, *Gmonster, *Gsize; CGroup *Ghorcpl, *Ghorcte, *Gconpl, *Gconte, *Gwater, *Gmonster, *Gsize;
}; };
class Options : public PreGameTab class Options : public PreGameTab
{ {
bool inited; bool inited;
struct OptionSwitch:public HighButton struct OptionSwitch:public HighButton
{ {
void hover(bool on=true){}; void hover(bool on=true){};
void select(bool on=true){}; void select(bool on=true){};
OptionSwitch( SDL_Rect Pos, CDefHandler* Imgs, bool Left, int Which) OptionSwitch( SDL_Rect Pos, CDefHandler* Imgs, bool Left, int Which)
:HighButton(Pos,Imgs,false,7),left(Left),which(Which) :HighButton(Pos,Imgs,false,7),left(Left),which(Which)
{selectable=false;highlightable=false;} {selectable=false;highlightable=false;}
void press(bool down=true); void press(bool down=true);
bool left; bool left;
int playerID; int playerID;
int serialID; int serialID;
int which; //-1=castle;0=hero;1=bonus int which; //-1=castle;0=hero;1=bonus
}; };
struct PlayerFlag:public HighButton struct PlayerFlag:public HighButton
{ {
int color; int color;
PlayerFlag(SDL_Rect Pos, CDefHandler* Imgs, int Color) PlayerFlag(SDL_Rect Pos, CDefHandler* Imgs, int Color)
:HighButton(Pos,Imgs,false,7),color(Color) :HighButton(Pos,Imgs,false,7),color(Color)
{selectable=false;highlightable=true;} {selectable=false;highlightable=true;}
void hover(bool on=true); void hover(bool on=true);
void press(bool down=true); void press(bool down=true);
void select(bool on=true){}; void select(bool on=true){};
}; };
struct PlayerOptions struct PlayerOptions
{ {
PlayerOptions(int serial, int player); PlayerOptions(int serial, int player);
Ecolor color; Ecolor color;
PlayerFlag flag; PlayerFlag flag;
//SDL_Surface * bg; //SDL_Surface * bg;
OptionSwitch Cleft, Cright, Hleft, Hright, Bleft, Bright; OptionSwitch Cleft, Cright, Hleft, Hright, Bleft, Bright;
int nr; int nr;
}; };
public: public:
std::set<int> usedHeroes; std::set<int> usedHeroes;
Slider * turnLength; Slider * turnLength;
SDL_Surface * bg, SDL_Surface * bg,
* rHero, * rCastle, * nHero, * nCastle; * rHero, * rCastle, * nHero, * nCastle;
std::vector<SDL_Surface*> bgs; std::vector<SDL_Surface*> bgs;
std::vector<CDefHandler*> flags; std::vector<CDefHandler*> flags;
CDefHandler //* castles, * heroes, * bonus, CDefHandler //* castles, * heroes, * bonus,
* left, * right, * left, * right,
* bonuses; * bonuses;
std::vector<PlayerOptions*> poptions; std::vector<PlayerOptions*> poptions;
void show(); void show();
void hide(); void hide();
void init(); void init();
void showIcon (int what, int nr, bool abs); //what: -1=castle, 0=hero, 1=bonus, 2=all; abs=true -> nr is absolute void showIcon (int what, int nr, bool abs); //what: -1=castle, 0=hero, 1=bonus, 2=all; abs=true -> nr is absolute
bool canUseThisHero(int ID); bool canUseThisHero(int ID);
int nextAllowedHero(int min, int max, int incl, int dir); //incl 0 - wlacznie; incl 1 - wylacznie; min-max - zakres szukania int nextAllowedHero(int min, int max, int incl, int dir); //incl 0 - wlacznie; incl 1 - wylacznie; min-max - zakres szukania
Options(){inited=showed=false;}; Options(){inited=showed=false;};
~Options(); ~Options();
}; };
class MapSel : public PreGameTab class MapSel : public PreGameTab
{ {
public: public:
ESortBy sortBy; ESortBy sortBy;
SDL_Surface * bg; SDL_Surface * bg;
int selected; //selected map int selected; //selected map
CDefHandler * Dtypes, * Dvic; CDefHandler * Dtypes, * Dvic;
CDefHandler *Dsizes, * Dloss, CDefHandler *Dsizes, * Dloss,
* sFlags; * sFlags;
std::vector<Mapa*> scenList; std::vector<Mapa*> scenList;
std::vector<SDL_Surface*> scenImgs; std::vector<SDL_Surface*> scenImgs;
//int current; //int current;
std::vector<CMapInfo> ourMaps; std::vector<CMapInfo> ourMaps;
std::vector<CMapInfo> ourGames; std::vector<CMapInfo> ourGames;
IntBut small, medium, large, xlarge, all; IntBut small, medium, large, xlarge, all;
SetrButton nrplayer, mapsize, type, name, viccon, loscon; SetrButton nrplayer, mapsize, type, name, viccon, loscon;
Slider *slid, *descslid; Slider *slid, *descslid;
int sizeFilter; int sizeFilter;
int whichWL(int nr); int whichWL(int nr);
int countWL(); int countWL();
void show(); void show();
void hide(); void hide();
void init(); void init();
std::string gdiff(std::string ss); std::string gdiff(std::string ss);
void printMaps(int from,int to=18, int at=0, bool abs=false); void printMaps(int from,int to=18, int at=0, bool abs=false);
void select(int which, bool updateMapsList=true, bool forceSettingsUpdate=false); void select(int which, bool updateMapsList=true, bool forceSettingsUpdate=false);
void moveByOne(bool up); void moveByOne(bool up);
void printSelectedInfo(); void printSelectedInfo();
void printFlags(); void printFlags();
void processMaps(std::vector<std::string> &pliczkiTemp, int &index); void processMaps(std::vector<std::string> &pliczkiTemp, int &index);
MapSel(); MapSel();
~MapSel(); ~MapSel();
}; };
class ScenSel class ScenSel
{ {
public: public:
CPoinGroup * difficulty; CPoinGroup * difficulty;
bool listShowed; bool listShowed;
//RanSel ransel; //RanSel ransel;
MapSel mapsel; MapSel mapsel;
SDL_Surface * background, *scenInf, *scenList, *randMap, *options ; SDL_Surface * background, *scenInf, *scenList, *randMap, *options ;
Button bScens, bOptions, bRandom, bBegin, bBack; Button bScens, bOptions, bRandom, bBegin, bBack;
IntSelBut bEasy, bNormal, bHard, bExpert, bImpossible; IntSelBut bEasy, bNormal, bHard, bExpert, bImpossible;
Button * pressed; Button * pressed;
std::vector<Mapa> maps; std::vector<Mapa> maps;
int selectedDiff; int selectedDiff;
void initRanSel(); void initRanSel();
void showRanSel(); void showRanSel();
void hideRanSel(); void hideRanSel();
void genScenList(); void genScenList();
ScenSel(); ScenSel();
~ScenSel(); ~ScenSel();
} ; } ;
class CPreGame class CPreGame
{ {
public: public:
std::string playerName; std::string playerName;
int playerColor; int playerColor;
HighButton * highlighted; HighButton * highlighted;
PreGameTab* currentTab; PreGameTab* currentTab;
StartInfo ret; StartInfo ret;
bool run; bool run;
bool first; //hasn't we showed the scensel bool first; //hasn't we showed the scensel
std::vector<Slider *> interested; std::vector<Slider *> interested;
CMusicHandler * mush; CMusicHandler * mush;
std::vector<HighButton *> btns; std::vector<HighButton *> btns;
SDL_Rect * currentMessage; SDL_Rect * currentMessage;
SDL_Surface * behindCurMes; SDL_Surface * behindCurMes;
CDefHandler *ok, *cancel; CDefHandler *ok, *cancel;
enum EState { //where are we? enum EState { //where are we?
mainMenu, newGame, loadGame, ScenarioList mainMenu, newGame, loadGame, ScenarioList
} state; } state;
struct menuItems { struct menuItems {
menuItems(); menuItems();
~menuItems(); ~menuItems();
SDL_Surface * background, *bgAd; SDL_Surface * background, *bgAd;
CDefHandler *newGame, *loadGame, *highScores,*credits, *quit; CDefHandler *newGame, *loadGame, *highScores,*credits, *quit;
SDL_Rect lNewGame, lLoadGame, lHighScores, lCredits, lQuit; SDL_Rect lNewGame, lLoadGame, lHighScores, lCredits, lQuit;
ttt fNewGame, fLoadGame, fHighScores, fCredits, fQuit; ttt fNewGame, fLoadGame, fHighScores, fCredits, fQuit;
int highlighted;//0=none; 1=new game; 2=load game; 3=high score; 4=credits; 5=quit int highlighted;//0=none; 1=new game; 2=load game; 3=high score; 4=credits; 5=quit
} * ourMainMenu, * ourNewMenu, * ourLoadMenu; } * ourMainMenu, * ourNewMenu, * ourLoadMenu;
ScenSel * ourScenSel; ScenSel * ourScenSel;
Options * ourOptions; Options * ourOptions;
std::string map; //selected map std::string map; //selected map
CPreGame(); //c-tor CPreGame(); //c-tor
~CPreGame();//d-tor ~CPreGame();//d-tor
std::string buttonText(int which); std::string buttonText(int which);
menuItems * currentItems(); menuItems * currentItems();
void(CPreGame::*handleOther)(SDL_Event&); void(CPreGame::*handleOther)(SDL_Event&);
void scenHandleEv(SDL_Event& sEvent); void scenHandleEv(SDL_Event& sEvent);
void begin(){run=false;ret.difficulty=ourScenSel->selectedDiff;}; void begin(){run=false;ret.difficulty=ourScenSel->selectedDiff;};
void quitAskBox(); void quitAskBox();
void quit(){exit(EXIT_SUCCESS);}; void quit(){exit(EXIT_SUCCESS);};
void initScenSel(); void initScenSel();
void showScenSel(); void showScenSel();
void showScenList(); void showScenList();
void initOptions(); void initOptions();
void showOptions(); void showOptions();
void initNewMenu(); void initNewMenu();
void initLoadMenu(); void initLoadMenu();
void showNewMenu(); void showNewMenu();
void showLoadMenu(); void showLoadMenu();
void showMainMenu(); void showMainMenu();
StartInfo runLoop(); // runs mainloop of PreGame StartInfo runLoop(); // runs mainloop of PreGame
void initMainMenu(); //loads components for main menu void initMainMenu(); //loads components for main menu
void highlightButton(int which, int on); //highlights one from 5 main menu buttons void highlightButton(int which, int on); //highlights one from 5 main menu buttons
void showCenBox (std::string data); // void showCenBox (std::string data); //
void showAskBox (std::string data, void(*f1)(),void(*f2)()); void showAskBox (std::string data, void(*f1)(),void(*f2)());
void hideBox (); void hideBox ();
void printRating(); void printRating();
void printMapsFrom(int from); void printMapsFrom(int from);
void setTurnLength(int on); void setTurnLength(int on);
void sortMaps(); void sortMaps();
}; };
#endif //CPREGAME_H
#endif // __CPREGAME_H__

85
CThreadHelper.h
View File

@ -1,42 +1,43 @@
#ifndef CTHREADHELPER_H #ifndef __CTHREADHELPER_H__
#define CTHREADHELPER_H #define __CTHREADHELPER_H__
#include "global.h" #include "global.h"
#include <boost/function.hpp> #include <boost/function.hpp>
#include <boost/thread.hpp> #include <boost/thread.hpp>
typedef boost::function<void()> Task; typedef boost::function<void()> Task;
class CThreadHelper class CThreadHelper
{ {
boost::mutex rtinm; boost::mutex rtinm;
int currentTask, amount, threads; int currentTask, amount, threads;
std::vector<Task> *tasks; std::vector<Task> *tasks;
void processTasks(); void processTasks();
public: public:
CThreadHelper(std::vector<boost::function<void()> > *Tasks, int Threads); CThreadHelper(std::vector<boost::function<void()> > *Tasks, int Threads);
void run(); void run();
}; };
template <typename T> inline void setData(T * data, boost::function<T()> func) template <typename T> inline void setData(T * data, boost::function<T()> func)
{ {
*data = func(); *data = func();
} }
#define GET_DATA(TYPE,DESTINATION,FUNCTION_TO_GET) \ #define GET_DATA(TYPE,DESTINATION,FUNCTION_TO_GET) \
(boost::bind(&setData<TYPE>,&DESTINATION,FUNCTION_TO_GET)) (boost::bind(&setData<TYPE>,&DESTINATION,FUNCTION_TO_GET))
#define GET_SURFACE(SUR_DESTINATION, SUR_NAME) \ #define GET_SURFACE(SUR_DESTINATION, SUR_NAME) \
(GET_DATA \ (GET_DATA \
(SDL_Surface*,SUR_DESTINATION,\ (SDL_Surface*,SUR_DESTINATION,\
boost::function<SDL_Surface*()>(boost::bind(&BitmapHandler::loadBitmap,SUR_NAME,true)))) boost::function<SDL_Surface*()>(boost::bind(&BitmapHandler::loadBitmap,SUR_NAME,true))))
#define GET_DEF(DESTINATION, DEF_NAME) \ #define GET_DEF(DESTINATION, DEF_NAME) \
(GET_DATA \ (GET_DATA \
(CDefHandler*,DESTINATION,\ (CDefHandler*,DESTINATION,\
boost::function<CDefHandler*()>(boost::bind(CDefHandler::giveDef,DEF_NAME,(CLodHandler*)NULL)))) boost::function<CDefHandler*()>(boost::bind(CDefHandler::giveDef,DEF_NAME,(CLodHandler*)NULL))))
#define GET_DEF_ESS(DESTINATION, DEF_NAME) \ #define GET_DEF_ESS(DESTINATION, DEF_NAME) \
(GET_DATA \ (GET_DATA \
(CDefEssential*,DESTINATION,\ (CDefEssential*,DESTINATION,\
boost::function<CDefEssential*()>(boost::bind(CDefHandler::giveDefEss,DEF_NAME,(CLodHandler*)NULL)))) boost::function<CDefEssential*()>(boost::bind(CDefHandler::giveDefEss,DEF_NAME,(CLodHandler*)NULL))))
#endif //CTHREADHELPER_H
#endif // __CTHREADHELPER_H__

113
SDL_Extensions.h
View File

@ -1,56 +1,57 @@
#ifndef SDL_EXTENSIONS_H #ifndef __SDL_EXTENSIONS_H__
#define SDL_EXTENSIONS_H #define __SDL_EXTENSIONS_H__
#include "SDL.h" #include "SDL.h"
#include "SDL_ttf.h" #include "SDL_ttf.h"
extern SDL_Surface * screen; extern SDL_Surface * screen;
extern SDL_Color tytulowy, tlo, zwykly ; extern SDL_Color tytulowy, tlo, zwykly ;
extern TTF_Font * TNRB16, *TNR, *GEOR13, *GEORXX, *GEORM; extern TTF_Font * TNRB16, *TNR, *GEOR13, *GEORXX, *GEORM;
void blitAtWR(SDL_Surface * src, int x, int y, SDL_Surface * dst=screen); void blitAtWR(SDL_Surface * src, int x, int y, SDL_Surface * dst=screen);
void blitAt(SDL_Surface * src, int x, int y, SDL_Surface * dst=screen); void blitAt(SDL_Surface * src, int x, int y, SDL_Surface * dst=screen);
void blitAtWR(SDL_Surface * src, SDL_Rect pos, SDL_Surface * dst=screen); void blitAtWR(SDL_Surface * src, SDL_Rect pos, SDL_Surface * dst=screen);
void blitAt(SDL_Surface * src, SDL_Rect pos, SDL_Surface * dst=screen); void blitAt(SDL_Surface * src, SDL_Rect pos, SDL_Surface * dst=screen);
void updateRect (SDL_Rect * rect, SDL_Surface * scr = screen); void updateRect (SDL_Rect * rect, SDL_Surface * scr = screen);
bool isItIn(const SDL_Rect * rect, int x, int y); bool isItIn(const SDL_Rect * rect, int x, int y);
template <typename T> int getIndexOf(const std::vector<T> & v, const T & val) template <typename T> int getIndexOf(const std::vector<T> & v, const T & val)
{ {
for(int i=0;i<v.size();i++) for(int i=0;i<v.size();i++)
if(v[i]==val) if(v[i]==val)
return i; return i;
return -1; return -1;
} }
inline SDL_Rect genRect(const int & hh, const int & ww, const int & xx, const int & yy); inline SDL_Rect genRect(const int & hh, const int & ww, const int & xx, const int & yy);
namespace CSDL_Ext namespace CSDL_Ext
{ {
extern SDL_Surface * std32bppSurface; extern SDL_Surface * std32bppSurface;
inline void SDL_PutPixel(SDL_Surface *ekran, const int & x, const int & y, const Uint8 & R, const Uint8 & G, const Uint8 & B, Uint8 A = 255); //myC influences the start of reading pixels inline void SDL_PutPixel(SDL_Surface *ekran, const int & x, const int & y, const Uint8 & R, const Uint8 & G, const Uint8 & B, Uint8 A = 255); //myC influences the start of reading pixels
inline void SDL_PutPixelWithoutRefresh(SDL_Surface *ekran, const int & x, const int & y, const Uint8 & R, const Uint8 & G, const Uint8 & B, Uint8 A = 255); //myC influences the start of reading pixels ; without refreshing inline void SDL_PutPixelWithoutRefresh(SDL_Surface *ekran, const int & x, const int & y, const Uint8 & R, const Uint8 & G, const Uint8 & B, Uint8 A = 255); //myC influences the start of reading pixels ; without refreshing
SDL_Surface * rotate01(SDL_Surface * toRot); //vertical flip SDL_Surface * rotate01(SDL_Surface * toRot); //vertical flip
SDL_Surface * hFlip(SDL_Surface * toRot); //horizontal flip SDL_Surface * hFlip(SDL_Surface * toRot); //horizontal flip
SDL_Surface * rotate02(SDL_Surface * toRot); //rotate 90 degrees left SDL_Surface * rotate02(SDL_Surface * toRot); //rotate 90 degrees left
SDL_Surface * rotate03(SDL_Surface * toRot); //rotate 180 degrees SDL_Surface * rotate03(SDL_Surface * toRot); //rotate 180 degrees
SDL_Cursor * SurfaceToCursor(SDL_Surface *image, int hx, int hy); SDL_Cursor * SurfaceToCursor(SDL_Surface *image, int hx, int hy);
Uint32 SDL_GetPixel(SDL_Surface *surface, const int & x, const int & y, bool colorByte = false); Uint32 SDL_GetPixel(SDL_Surface *surface, const int & x, const int & y, bool colorByte = false);
SDL_Color SDL_GetPixelColor(SDL_Surface *surface, int x, int y); SDL_Color SDL_GetPixelColor(SDL_Surface *surface, int x, int y);
SDL_Surface * alphaTransform(SDL_Surface * src); //adds transparency and shadows (partial handling only; see examples of using for details) SDL_Surface * alphaTransform(SDL_Surface * src); //adds transparency and shadows (partial handling only; see examples of using for details)
void blitWithRotate1(SDL_Surface *src,SDL_Rect * srcRect, SDL_Surface * dst, SDL_Rect * dstRect);//srcRect is not used, works with 8bpp sources and 24bpp dests void blitWithRotate1(SDL_Surface *src,SDL_Rect * srcRect, SDL_Surface * dst, SDL_Rect * dstRect);//srcRect is not used, works with 8bpp sources and 24bpp dests
void blitWithRotate2(SDL_Surface *src,SDL_Rect * srcRect, SDL_Surface * dst, SDL_Rect * dstRect);//srcRect is not used, works with 8bpp sources and 24bpp dests void blitWithRotate2(SDL_Surface *src,SDL_Rect * srcRect, SDL_Surface * dst, SDL_Rect * dstRect);//srcRect is not used, works with 8bpp sources and 24bpp dests
void blitWithRotate3(SDL_Surface *src,SDL_Rect * srcRect, SDL_Surface * dst, SDL_Rect * dstRect);//srcRect is not used, works with 8bpp sources and 24bpp dests void blitWithRotate3(SDL_Surface *src,SDL_Rect * srcRect, SDL_Surface * dst, SDL_Rect * dstRect);//srcRect is not used, works with 8bpp sources and 24bpp dests
int blit8bppAlphaTo24bpp(SDL_Surface * src, SDL_Rect * srcRect, SDL_Surface * dst, SDL_Rect * dstRect); //blits 8 bpp surface with alpha channel to 24 bpp surface int blit8bppAlphaTo24bpp(SDL_Surface * src, SDL_Rect * srcRect, SDL_Surface * dst, SDL_Rect * dstRect); //blits 8 bpp surface with alpha channel to 24 bpp surface
Uint32 colorToUint32(const SDL_Color * color); //little endian only Uint32 colorToUint32(const SDL_Color * color); //little endian only
void printTo(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor=tytulowy, SDL_Surface * dst=screen, unsigned char quality = 2);// quality: 0 - lowest, 1 - medium, 2 - highest; prints at right bottom corner of specific area. position of corner indicated by (x, y) void printTo(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor=tytulowy, SDL_Surface * dst=screen, unsigned char quality = 2);// quality: 0 - lowest, 1 - medium, 2 - highest; prints at right bottom corner of specific area. position of corner indicated by (x, y)
void printToWR(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor=tytulowy, SDL_Surface * dst=screen, unsigned char quality = 2);// quality: 0 - lowest, 1 - medium, 2 - highest; prints at right bottom corner of specific area. position of corner indicated by (x, y) void printToWR(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor=tytulowy, SDL_Surface * dst=screen, unsigned char quality = 2);// quality: 0 - lowest, 1 - medium, 2 - highest; prints at right bottom corner of specific area. position of corner indicated by (x, y)
void printAtMiddle(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor=tytulowy, SDL_Surface * dst=screen, unsigned char quality = 2, bool refresh = false); // quality: 0 - lowest, 1 - medium, 2 - highest void printAtMiddle(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor=tytulowy, SDL_Surface * dst=screen, unsigned char quality = 2, bool refresh = false); // quality: 0 - lowest, 1 - medium, 2 - highest
void printAtMiddleWB(const std::string & text, int x, int y, TTF_Font * font, int charpr, SDL_Color kolor=tytulowy, SDL_Surface * dst=screen); void printAtMiddleWB(const std::string & text, int x, int y, TTF_Font * font, int charpr, SDL_Color kolor=tytulowy, SDL_Surface * dst=screen);
void printAtWB(const std::string & text, int x, int y, TTF_Font * font, int charpr, SDL_Color kolor=tytulowy, SDL_Surface * dst=screen); void printAtWB(const std::string & text, int x, int y, TTF_Font * font, int charpr, SDL_Color kolor=tytulowy, SDL_Surface * dst=screen);
void printAt(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor=tytulowy, SDL_Surface * dst=screen, unsigned char quality = 2); // quality: 0 - lowest, 1 - medium, 2 - highest void printAt(const std::string & text, int x, int y, TTF_Font * font, SDL_Color kolor=tytulowy, SDL_Surface * dst=screen, unsigned char quality = 2); // quality: 0 - lowest, 1 - medium, 2 - highest
void update(SDL_Surface * what = screen); //updates whole surface (default - main screen) void update(SDL_Surface * what = screen); //updates whole surface (default - main screen)
void drawBorder(SDL_Surface * sur, int x, int y, int w, int h, int3 color); void drawBorder(SDL_Surface * sur, int x, int y, int w, int h, int3 color);
void setPlayerColor(SDL_Surface * sur, unsigned char player); //sets correct color of flags; -1 for neutral void setPlayerColor(SDL_Surface * sur, unsigned char player); //sets correct color of flags; -1 for neutral
std::string processStr(std::string str, std::vector<std::string> & tor); //replaces %s in string std::string processStr(std::string str, std::vector<std::string> & tor); //replaces %s in string
SDL_Surface * newSurface(int w, int h, SDL_Surface * mod=screen); //creates new surface, with flags/format same as in surface given SDL_Surface * newSurface(int w, int h, SDL_Surface * mod=screen); //creates new surface, with flags/format same as in surface given
SDL_Surface * copySurface(SDL_Surface * mod); //returns copy of given surface SDL_Surface * copySurface(SDL_Surface * mod); //returns copy of given surface
}; };
#endif // SDL_EXTENSIONS_H
#endif // __SDL_EXTENSIONS_H__

117
StartInfo.h
View File

@ -1,58 +1,59 @@
#ifndef STARTINFO_H #ifndef __STARTINFO_H__
#define STARTINFO_H #define __STARTINFO_H__
#include "global.h" #include "global.h"
#include <vector> #include <vector>
enum Ebonus {brandom=-1,bartifact, bgold, bresource}; enum Ebonus {brandom=-1,bartifact, bgold, bresource};
struct StartInfo struct StartInfo
{ {
struct PlayerSettings struct PlayerSettings
{ {
si32 castle, hero, //ID, if -1 then random, if -2 then none si32 castle, hero, //ID, if -1 then random, if -2 then none
heroPortrait; //-1 if default, else ID heroPortrait; //-1 if default, else ID
std::string heroName; std::string heroName;
si8 bonus; //usees enum type Ebonus si8 bonus; //usees enum type Ebonus
ui8 color; //from 0 - ui8 color; //from 0 -
ui8 serial; ui8 serial;
ui8 handicap;//0-no, 1-mild, 2-severe ui8 handicap;//0-no, 1-mild, 2-severe
std::string name; std::string name;
bool human; bool human;
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & castle; h & castle;
h & hero; h & hero;
h & heroPortrait; h & heroPortrait;
h & heroName; h & heroName;
h & bonus; h & bonus;
h & color; h & color;
h & serial; h & serial;
h & handicap; h & handicap;
h & name; h & name;
h & human; h & human;
} }
}; };
si32 difficulty; //0=easy; 4=impossible si32 difficulty; //0=easy; 4=impossible
std::vector<PlayerSettings> playerInfos; std::vector<PlayerSettings> playerInfos;
ui8 turnTime; //in minutes, 0=unlimited ui8 turnTime; //in minutes, 0=unlimited
std::string mapname; std::string mapname;
PlayerSettings & getIthPlayersSettings(int no) PlayerSettings & getIthPlayersSettings(int no)
{ {
for(unsigned int i=0; i<playerInfos.size(); ++i) for(unsigned int i=0; i<playerInfos.size(); ++i)
if(playerInfos[i].color == no) if(playerInfos[i].color == no)
return playerInfos[i]; return playerInfos[i];
tlog1 << "Cannot find info about player " << no <<". Throwing...\n"; tlog1 << "Cannot find info about player " << no <<". Throwing...\n";
throw std::string("Cannot find info about player"); throw std::string("Cannot find info about player");
} }
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & difficulty; h & difficulty;
h & playerInfos; h & playerInfos;
h & turnTime; h & turnTime;
h & mapname; h & mapname;
} }
}; };
#endif
#endif // __STARTINFO_H__

7
client/CBitmapHandler.h
View File

@ -1,5 +1,5 @@
#ifndef CBITMAPHANDLER_H #ifndef __CBITMAPHANDLER_H__
#define CBITMAPHANDLER_H #define __CBITMAPHANDLER_H__
@ -41,4 +41,5 @@ namespace BitmapHandler
extern CLodHandler *bitmaph; extern CLodHandler *bitmaph;
SDL_Surface * loadBitmap(std::string fname, bool setKey=false); SDL_Surface * loadBitmap(std::string fname, bool setKey=false);
}; };
#endif //CBITMAPHANDLER_H
#endif // __CBITMAPHANDLER_H__

7
client/CConfigHandler.h
View File

@ -1,5 +1,5 @@
#ifndef CCONFIGHANDLER_H #ifndef __CCONFIGHANDLER_H__
#define CCONFIGHANDLER_H #define __CCONFIGHANDLER_H__
#include "../global.h" #include "../global.h"
class CAdvMapInt; class CAdvMapInt;
namespace config namespace config
@ -63,4 +63,5 @@ namespace config
}; };
} }
extern config::CConfigHandler conf; extern config::CConfigHandler conf;
#endif //CCONFIGHANDLER_H
#endif // __CCONFIGHANDLER_H__

7
client/CCreatureAnimation.h
View File

@ -1,5 +1,5 @@
#ifndef CCREATUREANIMATION_H #ifndef __CCREATUREANIMATION_H__
#define CCREATUREANIMATION_H #define __CCREATUREANIMATION_H__
#include "../global.h" #include "../global.h"
@ -51,4 +51,5 @@ public:
int framesInGroup(int group) const; //retirns number of fromes in given group int framesInGroup(int group) const; //retirns number of fromes in given group
}; };
#endif //CCREATUREANIMATION_H
#endif // __CCREATUREANIMATION_H__

7
client/CSpellWindow.h
View File

@ -1,5 +1,5 @@
#ifndef CSPELLWINDOW_H #ifndef __CSPELLWINDOW_H__
#define CSPELLWINDOW_H #define __CSPELLWINDOW_H__
#include "../global.h" #include "../global.h"
@ -89,4 +89,5 @@ public:
void deactivate(); void deactivate();
void show(SDL_Surface * to = NULL); void show(SDL_Surface * to = NULL);
}; };
#endif //CSPELLWINDOW_H
#endif // __CSPELLWINDOW_H__

7
client/Client.h
View File

@ -1,5 +1,5 @@
#ifndef CLIENT_H #ifndef __CLIENT_H__
#define CLIENT_H #define __CLIENT_H__
#include "../global.h" #include "../global.h"
@ -59,4 +59,5 @@ public:
friend class CScriptCallback; //for objects scripts friend class CScriptCallback; //for objects scripts
friend void processCommand(const std::string &message, CClient *&client); //handling console friend void processCommand(const std::string &message, CClient *&client); //handling console
}; };
#endif //CLIENT_H
#endif // __CLIENT_H__

7
client/Graphics.h
View File

@ -1,5 +1,5 @@
#ifndef GRAPHICS_H #ifndef __GRAPHICS_H__
#define GRAPHICS_H #define __GRAPHICS_H__
#include "../global.h" #include "../global.h"
@ -63,4 +63,5 @@ public:
}; };
extern Graphics * graphics; extern Graphics * graphics;
#endif //GRAPHICS_H
#endif // __GRAPHICS_H__

541
global.h
View File

@ -1,270 +1,271 @@
#ifndef GLOBAL_H #ifndef __GLOBAL_H__
#define GLOBAL_H #define __GLOBAL_H__
#include <iostream> #include <iostream>
#include <algorithm> //std::find #include <algorithm> //std::find
#include <boost/logic/tribool.hpp> #include <boost/logic/tribool.hpp>
#include <boost/cstdint.hpp> #include <boost/cstdint.hpp>
typedef boost::uint64_t ui64; //unsigned int 64 bits (8 bytes) typedef boost::uint64_t ui64; //unsigned int 64 bits (8 bytes)
typedef boost::uint32_t ui32; //unsigned int 32 bits (4 bytes) typedef boost::uint32_t ui32; //unsigned int 32 bits (4 bytes)
typedef boost::uint16_t ui16; //unsigned int 16 bits (2 bytes) typedef boost::uint16_t ui16; //unsigned int 16 bits (2 bytes)
typedef boost::uint8_t ui8; //unsigned int 8 bits (1 byte) typedef boost::uint8_t ui8; //unsigned int 8 bits (1 byte)
typedef boost::int64_t si64; //signed int 64 bits (8 bytes) typedef boost::int64_t si64; //signed int 64 bits (8 bytes)
typedef boost::int32_t si32; //signed int 32 bits (4 bytes) typedef boost::int32_t si32; //signed int 32 bits (4 bytes)
typedef boost::int16_t si16; //signed int 16 bits (2 bytes) typedef boost::int16_t si16; //signed int 16 bits (2 bytes)
typedef boost::int8_t si8; //signed int 8 bits (1 byte) typedef boost::int8_t si8; //signed int 8 bits (1 byte)
#include "int3.h" #include "int3.h"
#define CHECKTIME 1 #define CHECKTIME 1
#if CHECKTIME #if CHECKTIME
#include "timeHandler.h" #include "timeHandler.h"
#define THC #define THC
#endif #endif
#define NAME_VER ("VCMI 0.65") #define NAME_VER ("VCMI 0.65")
#define CONSOLE_LOGGING_LEVEL 5 #define CONSOLE_LOGGING_LEVEL 5
#define FILE_LOGGING_LEVEL 6 #define FILE_LOGGING_LEVEL 6
#ifdef _WIN32 #ifdef _WIN32
#define PATHSEPARATOR "\\" #define PATHSEPARATOR "\\"
#define DATA_DIR "" #define DATA_DIR ""
#define SERVER_NAME "VCMI_server.exe" #define SERVER_NAME "VCMI_server.exe"
#else #else
#define PATHSEPARATOR "/" #define PATHSEPARATOR "/"
#define DATA_DIR "" #define DATA_DIR ""
#define SERVER_NAME "./vcmiserver" #define SERVER_NAME "./vcmiserver"
#endif #endif
enum Ecolor {RED, BLUE, TAN, GREEN, ORANGE, PURPLE, TEAL, PINK}; //player's colors enum Ecolor {RED, BLUE, TAN, GREEN, ORANGE, PURPLE, TEAL, PINK}; //player's colors
enum EterrainType {border=-1, dirt, sand, grass, snow, swamp, rough, subterranean, lava, water, rock}; enum EterrainType {border=-1, dirt, sand, grass, snow, swamp, rough, subterranean, lava, water, rock};
enum Eriver {noRiver=0, clearRiver, icyRiver, muddyRiver, lavaRiver}; enum Eriver {noRiver=0, clearRiver, icyRiver, muddyRiver, lavaRiver};
enum Eroad {dirtRoad=1, grazvelRoad, cobblestoneRoad}; enum Eroad {dirtRoad=1, grazvelRoad, cobblestoneRoad};
enum Eformat { WoG=0x33, AB=0x15, RoE=0x0e, SoD=0x1c}; enum Eformat { WoG=0x33, AB=0x15, RoE=0x0e, SoD=0x1c};
enum EvictoryConditions {artifact, gatherTroop, gatherResource, buildCity, buildGrail, beatHero, enum EvictoryConditions {artifact, gatherTroop, gatherResource, buildCity, buildGrail, beatHero,
captureCity, beatMonster, takeDwellings, takeMines, transportItem, winStandard=255}; captureCity, beatMonster, takeDwellings, takeMines, transportItem, winStandard=255};
enum ElossCon {lossCastle, lossHero, timeExpires, lossStandard=255}; enum ElossCon {lossCastle, lossHero, timeExpires, lossStandard=255};
enum EHeroClasses {HERO_KNIGHT, HERO_CLERIC, HERO_RANGER, HERO_DRUID, HERO_ALCHEMIST, HERO_WIZARD, enum EHeroClasses {HERO_KNIGHT, HERO_CLERIC, HERO_RANGER, HERO_DRUID, HERO_ALCHEMIST, HERO_WIZARD,
HERO_DEMONIAC, HERO_HERETIC, HERO_DEATHKNIGHT, HERO_NECROMANCER, HERO_WARLOCK, HERO_OVERLORD, HERO_DEMONIAC, HERO_HERETIC, HERO_DEATHKNIGHT, HERO_NECROMANCER, HERO_WARLOCK, HERO_OVERLORD,
HERO_BARBARIAN, HERO_BATTLEMAGE, HERO_BEASTMASTER, HERO_WITCH, HERO_PLANESWALKER, HERO_ELEMENTALIST}; HERO_BARBARIAN, HERO_BATTLEMAGE, HERO_BEASTMASTER, HERO_WITCH, HERO_PLANESWALKER, HERO_ELEMENTALIST};
enum EAbilities {DOUBLE_WIDE, FLYING, SHOOTER, TWO_HEX_ATTACK, SIEGE_ABILITY, SIEGE_WEAPON, enum EAbilities {DOUBLE_WIDE, FLYING, SHOOTER, TWO_HEX_ATTACK, SIEGE_ABILITY, SIEGE_WEAPON,
KING1, KING2, KING3, MIND_IMMUNITY, NO_OBSTACLE_PENALTY, NO_CLOSE_COMBAT_PENALTY, KING1, KING2, KING3, MIND_IMMUNITY, NO_OBSTACLE_PENALTY, NO_CLOSE_COMBAT_PENALTY,
JOUSTING, FIRE_IMMUNITY, TWICE_ATTACK, NO_ENEMY_RETALIATION, NO_MORAL_PENALTY, JOUSTING, FIRE_IMMUNITY, TWICE_ATTACK, NO_ENEMY_RETALIATION, NO_MORAL_PENALTY,
UNDEAD, MULTI_HEAD_ATTACK, EXTENDED_RADIOUS_SHOOTER, GHOST, RAISES_MORALE, UNDEAD, MULTI_HEAD_ATTACK, EXTENDED_RADIOUS_SHOOTER, GHOST, RAISES_MORALE,
LOWERS_MORALE, DRAGON, STRIKE_AND_RETURN, FEARLESS, REBIRTH}; //some flags are used only for battles LOWERS_MORALE, DRAGON, STRIKE_AND_RETURN, FEARLESS, REBIRTH}; //some flags are used only for battles
enum ECombatInfo{ALIVE = REBIRTH+1, SUMMONED, CLONED, HAD_MORALE, WAITING, MOVED, DEFENDING}; enum ECombatInfo{ALIVE = REBIRTH+1, SUMMONED, CLONED, HAD_MORALE, WAITING, MOVED, DEFENDING};
class CGameInfo; class CGameInfo;
extern CGameInfo* CGI; extern CGameInfo* CGI;
#define HEROI_TYPE (34) #define HEROI_TYPE (34)
#define TOWNI_TYPE (98) #define TOWNI_TYPE (98)
const int F_NUMBER = 9; //factions (town types) quantity const int F_NUMBER = 9; //factions (town types) quantity
const int PLAYER_LIMIT = 8; //player limit per map const int PLAYER_LIMIT = 8; //player limit per map
const int HEROES_PER_TYPE=8; //amount of heroes of each type const int HEROES_PER_TYPE=8; //amount of heroes of each type
const int SKILL_QUANTITY=28; const int SKILL_QUANTITY=28;
const int SKILL_PER_HERO=8; const int SKILL_PER_HERO=8;
const int ARTIFACTS_QUANTITY=171; const int ARTIFACTS_QUANTITY=171;
const int HEROES_QUANTITY=156; const int HEROES_QUANTITY=156;
const int SPELLS_QUANTITY=70; const int SPELLS_QUANTITY=70;
const int RESOURCE_QUANTITY=8; const int RESOURCE_QUANTITY=8;
const int TERRAIN_TYPES=10; const int TERRAIN_TYPES=10;
const int PRIMARY_SKILLS=4; const int PRIMARY_SKILLS=4;
const int NEUTRAL_PLAYER=255; const int NEUTRAL_PLAYER=255;
const int NAMES_PER_TOWN=16; const int NAMES_PER_TOWN=16;
const int CREATURES_PER_TOWN = 7; //without upgrades const int CREATURES_PER_TOWN = 7; //without upgrades
const int MAX_BUILDING_PER_TURN = 1; const int MAX_BUILDING_PER_TURN = 1;
const int SPELL_LEVELS = 5; const int SPELL_LEVELS = 5;
#define BFIELD_WIDTH (17) #define BFIELD_WIDTH (17)
#define BFIELD_HEIGHT (11) #define BFIELD_HEIGHT (11)
#define BFIELD_SIZE ((BFIELD_WIDTH) * (BFIELD_HEIGHT)) #define BFIELD_SIZE ((BFIELD_WIDTH) * (BFIELD_HEIGHT))
//uncomment to make it work //uncomment to make it work
//#define MARK_BLOCKED_POSITIONS //#define MARK_BLOCKED_POSITIONS
//#define MARK_VISITABLE_POSITIONS //#define MARK_VISITABLE_POSITIONS
#define DEFBYPASS #define DEFBYPASS
#ifdef _WIN32 #ifdef _WIN32
#ifdef VCMI_DLL #ifdef VCMI_DLL
#define DLL_EXPORT __declspec(dllexport) #define DLL_EXPORT __declspec(dllexport)
#else #else
#define DLL_EXPORT __declspec(dllimport) #define DLL_EXPORT __declspec(dllimport)
#endif #endif
#else #else
#if defined(__GNUC__) && __GNUC__ >= 4 #if defined(__GNUC__) && __GNUC__ >= 4
#define DLL_EXPORT __attribute__ ((visibility("default"))) #define DLL_EXPORT __attribute__ ((visibility("default")))
#else #else
#define DLL_EXPORT #define DLL_EXPORT
#endif #endif
#endif #endif
namespace vstd namespace vstd
{ {
template <typename Container, typename Item> template <typename Container, typename Item>
bool contains(const Container & c, const Item &i) bool contains(const Container & c, const Item &i)
{ {
return std::find(c.begin(),c.end(),i) != c.end(); return std::find(c.begin(),c.end(),i) != c.end();
} }
template <typename V, typename Item, typename Item2> template <typename V, typename Item, typename Item2>
bool contains(const std::map<Item,V> & c, const Item2 &i) bool contains(const std::map<Item,V> & c, const Item2 &i)
{ {
return c.find(i)!=c.end(); return c.find(i)!=c.end();
} }
template <typename Container1, typename Container2> template <typename Container1, typename Container2>
typename Container2::iterator findFirstNot(Container1 &c1, Container2 &c2)//returns first element of c2 not present in c1 typename Container2::iterator findFirstNot(Container1 &c1, Container2 &c2)//returns first element of c2 not present in c1
{ {
typename Container2::iterator itr = c2.begin(); typename Container2::iterator itr = c2.begin();
while(itr != c2.end()) while(itr != c2.end())
if(!contains(c1,*itr)) if(!contains(c1,*itr))
return itr; return itr;
else else
++itr; ++itr;
return c2.end(); return c2.end();
} }
template <typename Container, typename Item> template <typename Container, typename Item>
typename Container::iterator find(const Container & c, const Item &i) typename Container::iterator find(const Container & c, const Item &i)
{ {
return std::find(c.begin(),c.end(),i); return std::find(c.begin(),c.end(),i);
} }
template <typename T1, typename T2> template <typename T1, typename T2>
int findPos(const std::vector<T1> & c, const T2 &s) int findPos(const std::vector<T1> & c, const T2 &s)
{ {
for(size_t i=0; i < c.size(); ++i) for(size_t i=0; i < c.size(); ++i)
if(c[i] == s) if(c[i] == s)
return i; return i;
return -1; return -1;
} }
template <typename T1, typename T2, typename Func> template <typename T1, typename T2, typename Func>
int findPos(const std::vector<T1> & c, const T2 &s, const Func &f) //Func(T1,T2) must say if these elements matches int findPos(const std::vector<T1> & c, const T2 &s, const Func &f) //Func(T1,T2) must say if these elements matches
{ {
for(size_t i=0; i < c.size(); ++i) for(size_t i=0; i < c.size(); ++i)
if(f(c[i],s)) if(f(c[i],s))
return i; return i;
return -1; return -1;
} }
template <typename Container, typename Item> template <typename Container, typename Item>
typename Container::iterator find(Container & c, const Item &i) typename Container::iterator find(Container & c, const Item &i)
{ {
return std::find(c.begin(),c.end(),i); return std::find(c.begin(),c.end(),i);
} }
template <typename Container, typename Item> template <typename Container, typename Item>
bool operator-=(Container &c, const Item &i) bool operator-=(Container &c, const Item &i)
{ {
typename Container::iterator itr = find(c,i); typename Container::iterator itr = find(c,i);
if(itr == c.end()) if(itr == c.end())
return false; return false;
c.erase(itr); c.erase(itr);
return true; return true;
} }
template <typename t1> template <typename t1>
void delObj(t1 *a1) void delObj(t1 *a1)
{ {
delete a1; delete a1;
} }
template <typename t1, typename t2> template <typename t1, typename t2>
void assign(t1 &a1, const t2 &a2) void assign(t1 &a1, const t2 &a2)
{ {
a1 = a2; a1 = a2;
} }
template <typename t1, typename t2> template <typename t1, typename t2>
struct assigner struct assigner
{ {
public: public:
t1 &op1; t1 &op1;
t2 op2; t2 op2;
assigner(t1 &a1, t2 a2) assigner(t1 &a1, t2 a2)
:op1(a1), op2(a2) :op1(a1), op2(a2)
{} {}
void operator()() void operator()()
{ {
op1 = op2; op1 = op2;
} }
}; };
template <typename t1, typename t2> template <typename t1, typename t2>
assigner<t1,t2> assigno(t1 &a1, const t2 &a2) assigner<t1,t2> assigno(t1 &a1, const t2 &a2)
{ {
return assigner<t1,t2>(a1,a2); return assigner<t1,t2>(a1,a2);
} }
template <typename t1, typename t2, typename t3> template <typename t1, typename t2, typename t3>
bool equal(const t1 &a1, const t3 t1::* point, const t2 &a2) bool equal(const t1 &a1, const t3 t1::* point, const t2 &a2)
{ {
return a1.*point == a2; return a1.*point == a2;
} }
template <typename t1, typename t2> template <typename t1, typename t2>
bool equal(const t1 &a1, const t2 &a2) bool equal(const t1 &a1, const t2 &a2)
{ {
return a1 == a2; return a1 == a2;
} }
} }
using vstd::operator-=; using vstd::operator-=;
#include "CConsoleHandler.h" #include "CConsoleHandler.h"
extern DLL_EXPORT std::ostream *logfile; extern DLL_EXPORT std::ostream *logfile;
extern DLL_EXPORT CConsoleHandler *console; extern DLL_EXPORT CConsoleHandler *console;
template <int lvl> class CLogger template <int lvl> class CLogger
{ {
public: public:
CLogger<lvl>& operator<<(std::ostream& (*fun)(std::ostream&)) CLogger<lvl>& operator<<(std::ostream& (*fun)(std::ostream&))
{ {
if(lvl < CONSOLE_LOGGING_LEVEL) if(lvl < CONSOLE_LOGGING_LEVEL)
std::cout << fun; std::cout << fun;
if((lvl < FILE_LOGGING_LEVEL) && logfile) if((lvl < FILE_LOGGING_LEVEL) && logfile)
*logfile << fun; *logfile << fun;
return *this; return *this;
} }
template<typename T> template<typename T>
CLogger<lvl> & operator<<(const T & data) CLogger<lvl> & operator<<(const T & data)
{ {
if(lvl < CONSOLE_LOGGING_LEVEL) if(lvl < CONSOLE_LOGGING_LEVEL)
{ {
if(console) if(console)
{ {
console->print(data,lvl); console->print(data,lvl);
} }
else else
{ {
std::cout << data << std::flush; std::cout << data << std::flush;
} }
} }
if((lvl < FILE_LOGGING_LEVEL) && logfile) if((lvl < FILE_LOGGING_LEVEL) && logfile)
{ {
*logfile << data << std::flush; *logfile << data << std::flush;
} }
return *this; return *this;
} }
}; };
extern DLL_EXPORT CLogger<0> tlog0; //green - standard progress info extern DLL_EXPORT CLogger<0> tlog0; //green - standard progress info
extern DLL_EXPORT CLogger<1> tlog1; //red - big errors extern DLL_EXPORT CLogger<1> tlog1; //red - big errors
extern DLL_EXPORT CLogger<2> tlog2; //magenta - major warnings extern DLL_EXPORT CLogger<2> tlog2; //magenta - major warnings
extern DLL_EXPORT CLogger<3> tlog3; //yellow - minor warnings extern DLL_EXPORT CLogger<3> tlog3; //yellow - minor warnings
extern DLL_EXPORT CLogger<4> tlog4; //white - detailed log info extern DLL_EXPORT CLogger<4> tlog4; //white - detailed log info
extern DLL_EXPORT CLogger<5> tlog5; //gray - minor log info extern DLL_EXPORT CLogger<5> tlog5; //gray - minor log info
//XXX pls dont - 'debug macros' are usually more trubble then its worth //XXX pls dont - 'debug macros' are usually more trubble then its worth
#define HANDLE_EXCEPTION \ #define HANDLE_EXCEPTION \
catch (const std::exception& e) { \ catch (const std::exception& e) { \
tlog1 << e.what() << std::endl; \ tlog1 << e.what() << std::endl; \
} \ } \
catch (const std::exception * e) \ catch (const std::exception * e) \
{ \ { \
tlog1 << e->what()<< std::endl; \ tlog1 << e->what()<< std::endl; \
delete e; \ delete e; \
} \ } \
catch (const std::string& e) { \ catch (const std::string& e) { \
tlog1 << e << std::endl; \ tlog1 << e << std::endl; \
} }
#define HANDLE_EXCEPTIONC(COMMAND) \ #define HANDLE_EXCEPTIONC(COMMAND) \
catch (const std::exception& e) { \ catch (const std::exception& e) { \
COMMAND; \ COMMAND; \
tlog1 << e.what() << std::endl; \ tlog1 << e.what() << std::endl; \
} \ } \
catch (const std::exception * e) \ catch (const std::exception * e) \
{ \ { \
COMMAND; \ COMMAND; \
tlog1 << e->what()<< std::endl; \ tlog1 << e->what()<< std::endl; \
delete e; \ delete e; \
} }
#endif //GLOBAL_H
#endif // __GLOBAL_H__

55
hch/CAbilityHandler.h
View File

@ -1,27 +1,28 @@
#ifndef CABILITYHANDLER_H #ifndef __CABILITYHANDLER_H__
#define CABILITYHANDLER_H #define __CABILITYHANDLER_H__
#include <string> #include <string>
#include <vector> #include <vector>
class CDefHandler; class CDefHandler;
class CAbility class CAbility
{ {
public: public:
std::string name; std::string name;
std::vector <std::string> infoTexts; //0 - basic; 2 - advanced std::vector <std::string> infoTexts; //0 - basic; 2 - advanced
int idNumber; int idNumber;
bool isAllowed; //true if we can use this hero's ability (map information) bool isAllowed; //true if we can use this hero's ability (map information)
}; };
class CAbilityHandler class CAbilityHandler
{ {
public: public:
std::vector<CAbility *> abilities; std::vector<CAbility *> abilities;
CDefHandler * abils32, * abils44, * abils82; CDefHandler * abils32, * abils44, * abils82;
std::vector<std::string> levels; std::vector<std::string> levels;
void loadAbilities(); void loadAbilities();
}; };
#endif //CABILITYHANDLER_H
#endif // __CABILITYHANDLER_H__

39
hch/CAmbarCendamo.h
View File

@ -1,19 +1,20 @@
#ifndef CAMBARCENDAMO_H #ifndef __CAMBARCENDAMO_H__
#define CAMBARCENDAMO_H #define __CAMBARCENDAMO_H__
#include <iostream> #include <iostream>
#include <string> #include <string>
#include <vector> #include <vector>
#include "../global.h" #include "../global.h"
#include "../map.h" #include "../map.h"
#include "CCreatureHandler.h" #include "CCreatureHandler.h"
class DLL_EXPORT CAmbarCendamo class DLL_EXPORT CAmbarCendamo
{ {
public: public:
/////////////////member variables /////////////////member variables
//Mapa* map; //Mapa* map;
//CAmbarCendamo (unsigned char * data); // c-tor; data is pointer to decompressed h3m data //CAmbarCendamo (unsigned char * data); // c-tor; data is pointer to decompressed h3m data
//~CAmbarCendamo (); // d-tor //~CAmbarCendamo (); // d-tor
}; };
#endif //CAMBARCENDAMO_H
#endif // __CAMBARCENDAMO_H__

99
hch/CArtHandler.h
View File

@ -1,49 +1,50 @@
#ifndef CARTHANDLER_H #ifndef __CARTHANDLER_H__
#define CARTHANDLER_H #define __CARTHANDLER_H__
#include "../global.h" #include "../global.h"
#include <string> #include <string>
#include <vector> #include <vector>
enum EartClass {SartClass=0, TartClass, NartClass, JartClass, RartClass}; //artifact class (relict, treasure, strong, weak etc.) enum EartClass {SartClass=0, TartClass, NartClass, JartClass, RartClass}; //artifact class (relict, treasure, strong, weak etc.)
class CDefHandler; class CDefHandler;
class DLL_EXPORT CArtifact //container for artifacts class DLL_EXPORT CArtifact //container for artifacts
{ {
std::string name, description; //set if custom std::string name, description; //set if custom
public: public:
const std::string &Name() const; const std::string &Name() const;
const std::string &Description() const; const std::string &Description() const;
bool isAllowed; //true if we can use this artifact (map information) bool isAllowed; //true if we can use this artifact (map information)
//std::string desc2; //std::string desc2;
unsigned int price; unsigned int price;
std::vector<ui16> possibleSlots; //ids of slots where artifact can be placed std::vector<ui16> possibleSlots; //ids of slots where artifact can be placed
//bool spellBook, warMachine1, warMachine2, warMachine3, warMachine4, misc1, misc2, misc3, misc4, misc5, feet, lRing, rRing, torso, lHand, rHand, neck, shoulders, head; //bool spellBook, warMachine1, warMachine2, warMachine3, warMachine4, misc1, misc2, misc3, misc4, misc5, feet, lRing, rRing, torso, lHand, rHand, neck, shoulders, head;
EartClass aClass; EartClass aClass;
int id; int id;
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & isAllowed & name & description & price & possibleSlots & aClass & id ; h & isAllowed & name & description & price & possibleSlots & aClass & id ;
} }
}; };
class DLL_EXPORT CArtHandler //handles artifacts class DLL_EXPORT CArtHandler //handles artifacts
{ {
public: public:
std::vector<CArtifact*> treasures, minors, majors, relics; std::vector<CArtifact*> treasures, minors, majors, relics;
std::vector<CArtifact> artifacts; std::vector<CArtifact> artifacts;
void loadArtifacts(); void loadArtifacts();
void sortArts(); void sortArts();
static int convertMachineID(int id, bool creToArt); static int convertMachineID(int id, bool creToArt);
CArtHandler(); CArtHandler();
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & artifacts; h & artifacts;
if(!h.saving) if(!h.saving)
sortArts(); sortArts();
} }
}; };
#endif // CARTHANDLER_H
#endif // __CARTHANDLER_H__

77
hch/CBuildingHandler.h
View File

@ -1,38 +1,39 @@
#ifndef CBUILDINGHANDLER_H #ifndef __CBUILDINGHANDLER_H__
#define CBUILDINGHANDLER_H #define __CBUILDINGHANDLER_H__
#include "../global.h" #include "../global.h"
#include <map> #include <map>
#include <vector> #include <vector>
//enum EbuildingType {NEUTRAL=-1, CASTLE, RAMPART, TOWER, INFERNO, NECROPOLIS, DUNGEON, STRONGHOLD, FORTRESS, CONFLUX}; //enum EbuildingType {NEUTRAL=-1, CASTLE, RAMPART, TOWER, INFERNO, NECROPOLIS, DUNGEON, STRONGHOLD, FORTRESS, CONFLUX};
class DLL_EXPORT CBuilding //a typical building encountered in every castle ;] class DLL_EXPORT CBuilding //a typical building encountered in every castle ;]
{ {
public: public:
int tid, bid; //town ID and structure ID int tid, bid; //town ID and structure ID
std::vector<int> resources; std::vector<int> resources;
std::string name; std::string name;
std::string description; std::string description;
const std::string &Name(); const std::string &Name();
const std::string &Description(); const std::string &Description();
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & tid & bid & resources & name & description; h & tid & bid & resources & name & description;
} }
}; };
class DLL_EXPORT CBuildingHandler class DLL_EXPORT CBuildingHandler
{ {
public: public:
std::map<int, std::map<int, CBuilding*> > buildings; ///< first int is the castle ID, second the building ID (in ERM-U format) std::map<int, std::map<int, CBuilding*> > buildings; ///< first int is the castle ID, second the building ID (in ERM-U format)
std::map<int, std::pair<std::string,std::vector< std::vector< std::vector<int> > > > > hall; //map<castle ID, pair<hall bg name, std::vector< std::vector<building id> >[5]> - external vector is the vector of buildings in the row, internal is the list of buildings for the specific slot std::map<int, std::pair<std::string,std::vector< std::vector< std::vector<int> > > > > hall; //map<castle ID, pair<hall bg name, std::vector< std::vector<building id> >[5]> - external vector is the vector of buildings in the row, internal is the list of buildings for the specific slot
void loadBuildings(); //main loader void loadBuildings(); //main loader
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & buildings & hall; h & buildings & hall;
} }
}; };
#endif //CBUILDINGHANDLER_H
#endif // __CBUILDINGHANDLER_H__

171
hch/CCreatureHandler.h
View File

@ -1,85 +1,86 @@
#ifndef CCREATUREHANDLER_H #ifndef __CCREATUREHANDLER_H__
#define CCREATUREHANDLER_H #define __CCREATUREHANDLER_H__
#include "../global.h" #include "../global.h"
#include <string> #include <string>
#include <vector> #include <vector>
#include <map> #include <map>
#include <set> #include <set>
class CLodHandler; class CLodHandler;
class DLL_EXPORT CCreature class DLL_EXPORT CCreature
{ {
public: public:
std::string namePl, nameSing, nameRef; //name in singular and plural form; and reference name std::string namePl, nameSing, nameRef; //name in singular and plural form; and reference name
std::vector<ui32> cost; //cost[res_id] - amount of that resource std::vector<ui32> cost; //cost[res_id] - amount of that resource
std::set<ui32> upgrades; // IDs of creatures to which this creature can be upgraded std::set<ui32> upgrades; // IDs of creatures to which this creature can be upgraded
ui32 fightValue, AIValue, growth, hordeGrowth, hitPoints, speed, attack, defence, shots, spells; ui32 fightValue, AIValue, growth, hordeGrowth, hitPoints, speed, attack, defence, shots, spells;
ui32 damageMin, damageMax; ui32 damageMin, damageMax;
ui32 ammMin, ammMax; ui32 ammMin, ammMax;
ui8 level; // 0 - unknown ui8 level; // 0 - unknown
std::string abilityText; //description of abilities std::string abilityText; //description of abilities
std::string abilityRefs; //references to abilities, in textformat std::string abilityRefs; //references to abilities, in textformat
std::string animDefName; std::string animDefName;
ui32 idNumber; ui32 idNumber;
std::set<EAbilities> abilities; std::set<EAbilities> abilities;
si8 faction; //-1 = neutral si8 faction; //-1 = neutral
///animation info ///animation info
float timeBetweenFidgets, walkAnimationTime, attackAnimationTime, flightAnimationDistance; float timeBetweenFidgets, walkAnimationTime, attackAnimationTime, flightAnimationDistance;
int upperRightMissleOffsetX, rightMissleOffsetX, lowerRightMissleOffsetX, upperRightMissleOffsetY, rightMissleOffsetY, lowerRightMissleOffsetY; int upperRightMissleOffsetX, rightMissleOffsetX, lowerRightMissleOffsetX, upperRightMissleOffsetY, rightMissleOffsetY, lowerRightMissleOffsetY;
float missleFrameAngles[12]; float missleFrameAngles[12];
int troopCountLocationOffset, attackClimaxFrame; int troopCountLocationOffset, attackClimaxFrame;
///end of anim info ///end of anim info
bool isDoubleWide() const; //returns true if unit is double wide on battlefield bool isDoubleWide() const; //returns true if unit is double wide on battlefield
bool isFlying() const; //returns true if it is a flying unit bool isFlying() const; //returns true if it is a flying unit
bool isShooting() const; //returns true if unit can shoot bool isShooting() const; //returns true if unit can shoot
si32 maxAmount(const std::vector<si32> &res) const; //how many creatures can be bought si32 maxAmount(const std::vector<si32> &res) const; //how many creatures can be bought
static int getQuantityID(const int & quantity); //0 - a few, 1 - several, 2 - pack, 3 - lots, 4 - horde, 5 - throng, 6 - swarm, 7 - zounds, 8 - legion static int getQuantityID(const int & quantity); //0 - a few, 1 - several, 2 - pack, 3 - lots, 4 - horde, 5 - throng, 6 - swarm, 7 - zounds, 8 - legion
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & namePl & nameSing & nameRef h & namePl & nameSing & nameRef
& cost & upgrades & cost & upgrades
& fightValue & AIValue & growth & hordeGrowth & hitPoints & speed & attack & defence & shots & spells & fightValue & AIValue & growth & hordeGrowth & hitPoints & speed & attack & defence & shots & spells
& damageMin & damageMax & ammMin & ammMax & level & damageMin & damageMax & ammMin & ammMax & level
& abilityText & abilityRefs & animDefName & abilityText & abilityRefs & animDefName
& idNumber & abilities & faction & idNumber & abilities & faction
& timeBetweenFidgets & walkAnimationTime & attackAnimationTime & flightAnimationDistance & timeBetweenFidgets & walkAnimationTime & attackAnimationTime & flightAnimationDistance
& upperRightMissleOffsetX & rightMissleOffsetX & lowerRightMissleOffsetX & upperRightMissleOffsetY & rightMissleOffsetY & lowerRightMissleOffsetY & upperRightMissleOffsetX & rightMissleOffsetX & lowerRightMissleOffsetX & upperRightMissleOffsetY & rightMissleOffsetY & lowerRightMissleOffsetY
& missleFrameAngles & troopCountLocationOffset & attackClimaxFrame; & missleFrameAngles & troopCountLocationOffset & attackClimaxFrame;
} }
}; };
class DLL_EXPORT CCreatureHandler class DLL_EXPORT CCreatureHandler
{ {
public: public:
std::set<int> notUsedMonsters; std::set<int> notUsedMonsters;
std::vector<CCreature> creatures; //creature ID -> creature info std::vector<CCreature> creatures; //creature ID -> creature info
std::map<int,std::vector<CCreature*> > levelCreatures; //level -> list of creatures std::map<int,std::vector<CCreature*> > levelCreatures; //level -> list of creatures
std::map<std::string,int> nameToID; std::map<std::string,int> nameToID;
std::map<int,std::string> idToProjectile; std::map<int,std::string> idToProjectile;
std::map<int,bool> idToProjectileSpin; //if true, appropriate projectile is spinning during flight std::map<int,bool> idToProjectileSpin; //if true, appropriate projectile is spinning during flight
void loadCreatures(); void loadCreatures();
void loadAnimationInfo(); void loadAnimationInfo();
void loadUnitAnimInfo(CCreature & unit, std::string & src, int & i); void loadUnitAnimInfo(CCreature & unit, std::string & src, int & i);
CCreatureHandler(); CCreatureHandler();
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
//TODO: should be optimized, not all these informations needs to be serialized (same for ccreature) //TODO: should be optimized, not all these informations needs to be serialized (same for ccreature)
h & notUsedMonsters & creatures & nameToID & idToProjectile & idToProjectileSpin; h & notUsedMonsters & creatures & nameToID & idToProjectile & idToProjectileSpin;
if(!h.saving) if(!h.saving)
{ {
for (int i=0; i<creatures.size(); i++) //recreate levelCreatures map for (int i=0; i<creatures.size(); i++) //recreate levelCreatures map
{ {
levelCreatures[creatures[i].level].push_back(&creatures[i]); levelCreatures[creatures[i].level].push_back(&creatures[i]);
} }
} }
} }
}; };
#endif //CCREATUREHANDLER_H
#endif // __CCREATUREHANDLER_H__

121
hch/CDefHandler.h
View File

@ -1,60 +1,61 @@
#ifndef CDEFHANDLER_H #ifndef __CDEFHANDLER_H__
#define CDEFHANDLER_H #define __CDEFHANDLER_H__
#include "../client/CBitmapHandler.h" #include "../client/CBitmapHandler.h"
struct SDL_Surface; struct SDL_Surface;
class CDefEssential; class CDefEssential;
class CLodHandler; class CLodHandler;
struct Cimage struct Cimage
{ {
int groupNumber; int groupNumber;
std::string imName; //name without extension std::string imName; //name without extension
SDL_Surface * bitmap; SDL_Surface * bitmap;
}; };
class CDefHandler class CDefHandler
{ {
private: private:
int totalEntries, DEFType, totalBlocks; int totalEntries, DEFType, totalBlocks;
bool allowRepaint; bool allowRepaint;
int length; int length;
unsigned int * RWEntries; unsigned int * RWEntries;
struct SEntry struct SEntry
{ {
std::string name; std::string name;
int offset; int offset;
int group; int group;
} ; } ;
std::vector<SEntry> SEntries ; std::vector<SEntry> SEntries ;
public: public:
int width, height; //width and height int width, height; //width and height
static CLodHandler * Spriteh; static CLodHandler * Spriteh;
std::string defName, curDir; std::string defName, curDir;
std::vector<Cimage> ourImages; std::vector<Cimage> ourImages;
bool alphaTransformed; bool alphaTransformed;
bool notFreeImgs; bool notFreeImgs;
CDefHandler(); CDefHandler();
~CDefHandler(); ~CDefHandler();
static void print (std::ostream & stream, int nr, int bytcon); static void print (std::ostream & stream, int nr, int bytcon);
int readNormalNr (int pos, int bytCon, unsigned char * str=NULL, bool cyclic=false); int readNormalNr (int pos, int bytCon, unsigned char * str=NULL, bool cyclic=false);
static unsigned char *writeNormalNr (int nr, int bytCon); static unsigned char *writeNormalNr (int nr, int bytCon);
SDL_Surface * getSprite (int SIndex, unsigned char * FDef, BMPPalette * palette); //zapisuje klatke o zadanym numerze do "testtt.bmp" SDL_Surface * getSprite (int SIndex, unsigned char * FDef, BMPPalette * palette); //zapisuje klatke o zadanym numerze do "testtt.bmp"
void openDef(std::string name); void openDef(std::string name);
void expand(unsigned char N,unsigned char & BL, unsigned char & BR); void expand(unsigned char N,unsigned char & BL, unsigned char & BR);
void openFromMemory(unsigned char * table, std::string name); void openFromMemory(unsigned char * table, std::string name);
CDefEssential * essentialize(); CDefEssential * essentialize();
static CDefHandler * giveDef(std::string defName, CLodHandler * spriteh=NULL); static CDefHandler * giveDef(std::string defName, CLodHandler * spriteh=NULL);
static CDefEssential * giveDefEss(std::string defName, CLodHandler * spriteh=NULL); static CDefEssential * giveDefEss(std::string defName, CLodHandler * spriteh=NULL);
}; };
class CDefEssential //DefHandler with images only class CDefEssential //DefHandler with images only
{ {
public: public:
std::vector<Cimage> ourImages; std::vector<Cimage> ourImages;
~CDefEssential(); ~CDefEssential();
}; };
#endif // CDEFHANDLER_H
#endif // __CDEFHANDLER_H__

99
hch/CGeneralTextHandler.h
View File

@ -1,49 +1,50 @@
#ifndef CGENERALTEXTHANDLER_H #ifndef __CGENERALTEXTHANDLER_H__
#define CGENERALTEXTHANDLER_H #define __CGENERALTEXTHANDLER_H__
#include "../global.h" #include "../global.h"
#include <string> #include <string>
#include <vector> #include <vector>
DLL_EXPORT void loadToIt(std::string &dest, std::string &src, int &iter, int mode); DLL_EXPORT void loadToIt(std::string &dest, std::string &src, int &iter, int mode);
std::string readTo(std::string &in, unsigned int &it, char end); std::string readTo(std::string &in, unsigned int &it, char end);
class DLL_EXPORT CGeneralTextHandler //Handles general texts class DLL_EXPORT CGeneralTextHandler //Handles general texts
{ {
public: public:
class HeroTexts class HeroTexts
{ {
public: public:
std::string bonusName, shortBonus, longBonus; //for special abilities std::string bonusName, shortBonus, longBonus; //for special abilities
std::string biography; //biography, of course std::string biography; //biography, of course
}; };
std::vector<HeroTexts> hTxts; std::vector<HeroTexts> hTxts;
std::vector<std::string> allTexts; std::vector<std::string> allTexts;
std::vector<std::string> arraytxt; std::vector<std::string> arraytxt;
std::vector<std::string> primarySkillNames; std::vector<std::string> primarySkillNames;
std::vector<std::string> jktexts; std::vector<std::string> jktexts;
std::vector<std::string> heroscrn; std::vector<std::string> heroscrn;
//artifacts //artifacts
std::vector<std::string> artifEvents; std::vector<std::string> artifEvents;
std::vector<std::string> artifNames; std::vector<std::string> artifNames;
std::vector<std::string> artifDescriptions; std::vector<std::string> artifDescriptions;
//towns //towns
std::vector<std::string> tcommands, hcommands; //texts for town screen and town hall screen std::vector<std::string> tcommands, hcommands; //texts for town screen and town hall screen
std::vector<std::vector<std::string> > townNames; //[type id] => vec of names of instances std::vector<std::vector<std::string> > townNames; //[type id] => vec of names of instances
std::vector<std::string> townTypes; //castle, rampart, tower, etc std::vector<std::string> townTypes; //castle, rampart, tower, etc
std::map<int, std::map<int, std::pair<std::string, std::string> > > buildings; //map[town id][building id] => pair<name, description> std::map<int, std::map<int, std::pair<std::string, std::string> > > buildings; //map[town id][building id] => pair<name, description>
std::vector<std::pair<std::string,std::string> > zelp; std::vector<std::pair<std::string,std::string> > zelp;
std::string lossCondtions[4]; std::string lossCondtions[4];
std::string victoryConditions[14]; std::string victoryConditions[14];
std::string getTitle(std::string text); std::string getTitle(std::string text);
std::string getDescr(std::string text); std::string getDescr(std::string text);
void loadTexts(); void loadTexts();
void load(); void load();
}; };
#endif //CGENERALTEXTHANDLER_H
#endif // __CGENERALTEXTHANDLER_H__

165
hch/CHeroHandler.h
View File

@ -1,82 +1,83 @@
#ifndef CHEROHANDLER_H #ifndef __CHEROHANDLER_H__
#define CHEROHANDLER_H #define __CHEROHANDLER_H__
#include "../global.h" #include "../global.h"
#include <string> #include <string>
#include <vector> #include <vector>
#include <set> #include <set>
class CHeroClass; class CHeroClass;
class CDefHandler; class CDefHandler;
class CGameInfo; class CGameInfo;
class CGHeroInstance; class CGHeroInstance;
class DLL_EXPORT CHero class DLL_EXPORT CHero
{ {
public: public:
std::string name; std::string name;
int ID; int ID;
int lowStack[3], highStack[3]; //amount of units; described below int lowStack[3], highStack[3]; //amount of units; described below
std::string refTypeStack[3]; //reference names of units appearing in hero's army if he is recruited in tavern std::string refTypeStack[3]; //reference names of units appearing in hero's army if he is recruited in tavern
CHeroClass * heroClass; CHeroClass * heroClass;
EHeroClasses heroType; //hero class EHeroClasses heroType; //hero class
std::vector<std::pair<ui8,ui8> > secSkillsInit; //initial secondary skills; first - ID of skill, second - level of skill (1 - basic, 2 - adv., 3 - expert) std::vector<std::pair<ui8,ui8> > secSkillsInit; //initial secondary skills; first - ID of skill, second - level of skill (1 - basic, 2 - adv., 3 - expert)
//bool operator<(CHero& drugi){if (ID < drugi.ID) return true; else return false;} //bool operator<(CHero& drugi){if (ID < drugi.ID) return true; else return false;}
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & name & ID & lowStack & highStack & refTypeStack & heroType & ID; h & name & ID & lowStack & highStack & refTypeStack & heroType & ID;
//hero class pointer is restored by herohandler //hero class pointer is restored by herohandler
} }
}; };
class DLL_EXPORT CHeroClass class DLL_EXPORT CHeroClass
{ {
public: public:
ui32 skillLimit; //how many secondary skills can hero learn ui32 skillLimit; //how many secondary skills can hero learn
std::string name; std::string name;
float aggression; float aggression;
int initialAttack, initialDefence, initialPower, initialKnowledge; int initialAttack, initialDefence, initialPower, initialKnowledge;
std::vector<std::pair<int,int> > primChance;//primChance[PRIMARY_SKILL_ID] - first is for levels 2 - 9, second for 10+;;; probability (%) of getting point of primary skill when getting new level std::vector<std::pair<int,int> > primChance;//primChance[PRIMARY_SKILL_ID] - first is for levels 2 - 9, second for 10+;;; probability (%) of getting point of primary skill when getting new level
std::vector<int> proSec; //probabilities of gaining secondary skills (out of 112), in id order std::vector<int> proSec; //probabilities of gaining secondary skills (out of 112), in id order
int selectionProbability[9]; //probability of selection in towns int selectionProbability[9]; //probability of selection in towns
std::vector<int> terrCosts; //default costs of going through terrains: dirt, sand, grass, snow, swamp, rough, subterranean, lava, water, rock; -1 means terrain is imapassable std::vector<int> terrCosts; //default costs of going through terrains: dirt, sand, grass, snow, swamp, rough, subterranean, lava, water, rock; -1 means terrain is imapassable
CDefHandler * moveAnim; //added group 10: up - left, 11 - left and 12 - left down // 13 - up-left standing; 14 - left standing; 15 - left down standing CDefHandler * moveAnim; //added group 10: up - left, 11 - left and 12 - left down // 13 - up-left standing; 14 - left standing; 15 - left down standing
int chooseSecSkill(const std::set<int> & possibles) const; //picks secondary skill out from given possibilities int chooseSecSkill(const std::set<int> & possibles) const; //picks secondary skill out from given possibilities
CHeroClass(); CHeroClass();
~CHeroClass(); ~CHeroClass();
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & skillLimit & name & aggression & initialAttack & initialDefence & initialPower & initialKnowledge & primChance h & skillLimit & name & aggression & initialAttack & initialDefence & initialPower & initialKnowledge & primChance
& proSec & selectionProbability & terrCosts; & proSec & selectionProbability & terrCosts;
} }
}; };
class DLL_EXPORT CHeroHandler class DLL_EXPORT CHeroHandler
{ {
public: public:
std::vector<CHero*> heroes; //by³o nodrze std::vector<CHero*> heroes; //by³o nodrze
std::vector<CHeroClass *> heroClasses; std::vector<CHeroClass *> heroClasses;
std::vector<int> expPerLevel; //expPerLEvel[i] is amount of exp needed to reach level i; if it is not in this vector, multiplicate last value by 1,2 to get next value std::vector<int> expPerLevel; //expPerLEvel[i] is amount of exp needed to reach level i; if it is not in this vector, multiplicate last value by 1,2 to get next value
unsigned int level(unsigned int experience); unsigned int level(unsigned int experience);
unsigned int reqExp(unsigned int level); unsigned int reqExp(unsigned int level);
void loadHeroes(); void loadHeroes();
void loadHeroClasses(); void loadHeroClasses();
void initHeroClasses(); void initHeroClasses();
~CHeroHandler(); ~CHeroHandler();
void initTerrainCosts(); void initTerrainCosts();
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & heroClasses & heroes & expPerLevel; h & heroClasses & heroes & expPerLevel;
if(!h.saving) if(!h.saving)
{ {
//restore class pointers //restore class pointers
for (int i=0; i<heroes.size(); i++) for (int i=0; i<heroes.size(); i++)
{ {
heroes[i]->heroClass = heroClasses[heroes[i]->heroType]; heroes[i]->heroClass = heroClasses[heroes[i]->heroType];
} }
} }
} }
}; };
#endif //CHEROHANDLER_H
#endif // __CHEROHANDLER_H__

123
hch/CLodHandler.h
View File

@ -1,61 +1,62 @@
#ifndef CLODHANDLER_H #ifndef __CLODHANDLER_H__
#define CLODHANDLER_H #define __CLODHANDLER_H__
#include "../global.h" #include "../global.h"
#include <fstream> #include <fstream>
#include <vector> #include <vector>
#include <string> #include <string>
#include "../nodrze.h" #include "../nodrze.h"
struct SDL_Surface; struct SDL_Surface;
class CDefHandler; class CDefHandler;
class CDefEssential; class CDefEssential;
namespace boost namespace boost
{class mutex;}; {class mutex;};
namespace NLoadHandlerHelp namespace NLoadHandlerHelp
{ {
const int dmHelp=0, dmNoExtractingMask=1; const int dmHelp=0, dmNoExtractingMask=1;
//std::string P1,P2,CurDir; //std::string P1,P2,CurDir;
const int fCHUNK = 50000; const int fCHUNK = 50000;
}; };
struct Entry struct Entry
{ {
unsigned char name[12], //filename unsigned char name[12], //filename
hlam_1[4], //??? hlam_1[4], //???
hlam_2[4]; //probably type of file hlam_2[4]; //probably type of file
std::string nameStr; std::string nameStr;
int offset, //from beginning int offset, //from beginning
realSize, //size without compression realSize, //size without compression
size; //and with size; //and with
bool operator<(const std::string & comp) const bool operator<(const std::string & comp) const
{ {
return nameStr<comp; return nameStr<comp;
} }
bool operator<(const Entry & comp) const bool operator<(const Entry & comp) const
{ {
return nameStr<comp.nameStr; return nameStr<comp.nameStr;
} }
Entry(std::string con): nameStr(con){}; Entry(std::string con): nameStr(con){};
//Entry(unsigned char ): nameStr(con){}; //Entry(unsigned char ): nameStr(con){};
Entry(){}; Entry(){};
}; };
class DLL_EXPORT CLodHandler class DLL_EXPORT CLodHandler
{ {
public: public:
FILE* FLOD; FILE* FLOD;
nodrze<Entry> entries; nodrze<Entry> entries;
unsigned int totalFiles; unsigned int totalFiles;
boost::mutex *mutex; boost::mutex *mutex;
std::string myDir; //load files from this dir instead of .lod file std::string myDir; //load files from this dir instead of .lod file
int readNormalNr (unsigned char* bufor, int bytCon, bool cyclic=false); //lod header reading helper int readNormalNr (unsigned char* bufor, int bytCon, bool cyclic=false); //lod header reading helper
int infs(unsigned char * in, int size, int realSize, std::ofstream & out, int wBits=15); //zlib fast handler int infs(unsigned char * in, int size, int realSize, std::ofstream & out, int wBits=15); //zlib fast handler
int infs2(unsigned char * in, int size, int realSize, unsigned char*& out, int wBits=15); //zlib fast handler int infs2(unsigned char * in, int size, int realSize, unsigned char*& out, int wBits=15); //zlib fast handler
unsigned char * giveFile(std::string defName, int * length=NULL); //returns pointer to the decompressed data - it must be deleted when no longer needed! unsigned char * giveFile(std::string defName, int * length=NULL); //returns pointer to the decompressed data - it must be deleted when no longer needed!
std::string getTextFile(std::string name); //extracts one file std::string getTextFile(std::string name); //extracts one file
void extract(std::string FName); void extract(std::string FName);
void extractFile(std::string FName, std::string name); //extracts a specific file void extractFile(std::string FName, std::string name); //extracts a specific file
void init(std::string lodFile, std::string dirName); void init(std::string lodFile, std::string dirName);
}; };
#endif //CLODHANDLER_H
#endif // __CLODHANDLER_H__

41
hch/CMusicHandler.h
View File

@ -1,20 +1,21 @@
#ifndef CMUSICHANDLER_H #ifndef __CMUSICHANDLER_H__
#define CMUSICHANDLER_H #define __CMUSICHANDLER_H__
#include <SDL_mixer.h> #include <SDL_mixer.h>
#include "CSndHandler.h" #include "CSndHandler.h"
class CMusicHandler class CMusicHandler
{ {
protected: protected:
CSndHandler *sndh; CSndHandler *sndh;
public: public:
Mix_Music *AITheme0, *AITheme1, *AITheme2, *combat1, *combat2, *combat3, *combat4, *castleTown, *defendCastle, *dirt, *dungeon, *elemTown, *evilTheme, *fortressTown, *goodTheme, *grass, *infernoTown, *lava, *loopLepr, *loseCampain, *loseCastle, *loseCombat, *mainMenu, *mainMenuWoG, *necroTown, *neutralTheme, *rampart, *retreatBattle, *rough, *sand, *secretTheme, *snow, *stronghold, *surrenderBattle, *swamp, *towerTown, *ultimateLose, *underground, *water, *winScenario, *winBattle; Mix_Music *AITheme0, *AITheme1, *AITheme2, *combat1, *combat2, *combat3, *combat4, *castleTown, *defendCastle, *dirt, *dungeon, *elemTown, *evilTheme, *fortressTown, *goodTheme, *grass, *infernoTown, *lava, *loopLepr, *loseCampain, *loseCastle, *loseCombat, *mainMenu, *mainMenuWoG, *necroTown, *neutralTheme, *rampart, *retreatBattle, *rough, *sand, *secretTheme, *snow, *stronghold, *surrenderBattle, *swamp, *towerTown, *ultimateLose, *underground, *water, *winScenario, *winBattle;
Mix_Chunk * buildTown, *click; Mix_Chunk * buildTown, *click;
void initMusics(); void initMusics();
void playClick(); //plays click music ;] void playClick(); //plays click music ;]
void playLodSnd(std::string sndname); // plays sound wavs from Heroes3.snd void playLodSnd(std::string sndname); // plays sound wavs from Heroes3.snd
}; };
#endif //CMUSICHANDLER_H
#endif // __CMUSICHANDLER_H__

877
hch/CObjectHandler.h
View File

@ -1,438 +1,439 @@
#ifndef COBJECTHANDLER_H #ifndef __COBJECTHANDLER_H__
#define COBJECTHANDLER_H #define __COBJECTHANDLER_H__
#include "../global.h" #include "../global.h"
#include <string> #include <string>
#include <vector> #include <vector>
#include <set> #include <set>
#include <map> #include <map>
#include "CCreatureHandler.h" #include "CCreatureHandler.h"
using boost::logic::tribool; using boost::logic::tribool;
class IGameCallback; class IGameCallback;
struct BattleResult; struct BattleResult;
class CCPPObjectScript; class CCPPObjectScript;
class CGObjectInstance; class CGObjectInstance;
class CScript; class CScript;
class CObjectScript; class CObjectScript;
class CGHeroInstance; class CGHeroInstance;
class CTown; class CTown;
class CHero; class CHero;
class CBuilding; class CBuilding;
class CSpell; class CSpell;
class CGTownInstance; class CGTownInstance;
class CArtifact; class CArtifact;
class CGDefInfo; class CGDefInfo;
class CSpecObjInfo; class CSpecObjInfo;
class DLL_EXPORT CCastleEvent class DLL_EXPORT CCastleEvent
{ {
public: public:
std::string name, message; std::string name, message;
int wood, mercury, ore, sulfur, crystal, gems, gold; //gain / loss of resources int wood, mercury, ore, sulfur, crystal, gems, gold; //gain / loss of resources
unsigned char players; //players for whom this event can be applied unsigned char players; //players for whom this event can be applied
bool forHuman, forComputer; bool forHuman, forComputer;
int firstShow; //postpone of first encounter time in days int firstShow; //postpone of first encounter time in days
int forEvery; //every n days this event will occure int forEvery; //every n days this event will occure
unsigned char bytes[6]; //build specific buildings (raw format, similar to town's) unsigned char bytes[6]; //build specific buildings (raw format, similar to town's)
int gen[7]; //additional creatures in i-th level dwelling int gen[7]; //additional creatures in i-th level dwelling
bool operator<(const CCastleEvent &drugie) const bool operator<(const CCastleEvent &drugie) const
{ {
return firstShow<drugie.firstShow; return firstShow<drugie.firstShow;
} }
}; };
class DLL_EXPORT IObjectInterface class DLL_EXPORT IObjectInterface
{ {
public: public:
static IGameCallback *cb; static IGameCallback *cb;
IObjectInterface(); IObjectInterface();
virtual ~IObjectInterface(); virtual ~IObjectInterface();
virtual void onHeroVisit(const CGHeroInstance * h); virtual void onHeroVisit(const CGHeroInstance * h);
virtual void onHeroLeave(const CGHeroInstance * h); virtual void onHeroLeave(const CGHeroInstance * h);
virtual void newTurn(); virtual void newTurn();
virtual void initObj(); virtual void initObj();
}; };
class DLL_EXPORT CGObjectInstance : protected IObjectInterface class DLL_EXPORT CGObjectInstance : protected IObjectInterface
{ {
protected: protected:
public: public:
mutable std::string hoverName; mutable std::string hoverName;
int3 pos; //h3m pos int3 pos; //h3m pos
int ID, subID; //normal ID (this one from OH3 maps ;]) - eg. town=98; hero=34 int ID, subID; //normal ID (this one from OH3 maps ;]) - eg. town=98; hero=34
si32 id;//number of object in CObjectHandler's vector si32 id;//number of object in CObjectHandler's vector
CGDefInfo * defInfo; CGDefInfo * defInfo;
CCPPObjectScript * state; CCPPObjectScript * state;
CSpecObjInfo * info; CSpecObjInfo * info;
unsigned char animPhaseShift; unsigned char animPhaseShift;
ui8 tempOwner; //uzywane dla szybkosci, skrypt ma obowiazek aktualizowac te zmienna ui8 tempOwner; //uzywane dla szybkosci, skrypt ma obowiazek aktualizowac te zmienna
ui8 blockVisit; //if non-zero then blocks the tile but is visitable from neighbouring tile ui8 blockVisit; //if non-zero then blocks the tile but is visitable from neighbouring tile
int getOwner() const; int getOwner() const;
void setOwner(int ow); void setOwner(int ow);
int getWidth() const; //returns width of object graphic in tiles int getWidth() const; //returns width of object graphic in tiles
int getHeight() const; //returns height of object graphic in tiles int getHeight() const; //returns height of object graphic in tiles
bool visitableAt(int x, int y) const; //returns true if object is visitable at location (x, y) form left top tile of image (x, y in tiles) bool visitableAt(int x, int y) const; //returns true if object is visitable at location (x, y) form left top tile of image (x, y in tiles)
bool blockingAt(int x, int y) const; //returns true if object is blocking location (x, y) form left top tile of image (x, y in tiles) bool blockingAt(int x, int y) const; //returns true if object is blocking location (x, y) form left top tile of image (x, y in tiles)
bool operator<(const CGObjectInstance & cmp) const; //screen printing priority comparing bool operator<(const CGObjectInstance & cmp) const; //screen printing priority comparing
CGObjectInstance(); CGObjectInstance();
virtual ~CGObjectInstance(); virtual ~CGObjectInstance();
CGObjectInstance(const CGObjectInstance & right); CGObjectInstance(const CGObjectInstance & right);
CGObjectInstance& operator=(const CGObjectInstance & right); CGObjectInstance& operator=(const CGObjectInstance & right);
virtual const std::string & getHoverText() const; virtual const std::string & getHoverText() const;
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
void initObj(); void initObj();
friend class CGameHandler; friend class CGameHandler;
}; };
class DLL_EXPORT CArmedInstance: public CGObjectInstance class DLL_EXPORT CArmedInstance: public CGObjectInstance
{ {
public: public:
CCreatureSet army; //army CCreatureSet army; //army
virtual bool needsLastStack() const; //true if last stack cannot be taken virtual bool needsLastStack() const; //true if last stack cannot be taken
}; };
class DLL_EXPORT CGHeroInstance : public CArmedInstance class DLL_EXPORT CGHeroInstance : public CArmedInstance
{ {
public: public:
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
mutable int moveDir; //format: 123 mutable int moveDir; //format: 123
// 8 4 // 8 4
// 765 // 765
mutable ui8 isStanding, tacticFormationEnabled; mutable ui8 isStanding, tacticFormationEnabled;
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
CHero * type; CHero * type;
ui32 exp; //experience point ui32 exp; //experience point
int level; //current level of hero int level; //current level of hero
std::string name; //may be custom std::string name; //may be custom
std::string biography; //if custom std::string biography; //if custom
int portrait; //may be custom int portrait; //may be custom
int mana; // remaining spell points int mana; // remaining spell points
std::vector<int> primSkills; //0-attack, 1-defence, 2-spell power, 3-knowledge std::vector<int> primSkills; //0-attack, 1-defence, 2-spell power, 3-knowledge
std::vector<std::pair<ui8,ui8> > secSkills; //first - ID of skill, second - level of skill (1 - basic, 2 - adv., 3 - expert); if hero has ability (-1, -1) it meansthat it should have default secondary abilities std::vector<std::pair<ui8,ui8> > secSkills; //first - ID of skill, second - level of skill (1 - basic, 2 - adv., 3 - expert); if hero has ability (-1, -1) it meansthat it should have default secondary abilities
int movement; //remaining movement points int movement; //remaining movement points
int identifier; //from the map file int identifier; //from the map file
bool sex; bool sex;
struct DLL_EXPORT Patrol struct DLL_EXPORT Patrol
{ {
Patrol(){patrolling=false;patrolRadious=-1;}; Patrol(){patrolling=false;patrolRadious=-1;};
bool patrolling; bool patrolling;
int patrolRadious; int patrolRadious;
} patrol; } patrol;
bool inTownGarrison; // if hero is in town garrison bool inTownGarrison; // if hero is in town garrison
CGTownInstance * visitedTown; //set if hero is visiting town or in the town garrison CGTownInstance * visitedTown; //set if hero is visiting town or in the town garrison
std::vector<ui32> artifacts; //hero's artifacts from bag std::vector<ui32> artifacts; //hero's artifacts from bag
std::map<ui16,ui32> artifWorn; //map<position,artifact_id>; positions: 0 - head; 1 - shoulders; 2 - neck; 3 - right hand; 4 - left hand; 5 - torso; 6 - right ring; 7 - left ring; 8 - feet; 9 - misc1; 10 - misc2; 11 - misc3; 12 - misc4; 13 - mach1; 14 - mach2; 15 - mach3; 16 - mach4; 17 - spellbook; 18 - misc5 std::map<ui16,ui32> artifWorn; //map<position,artifact_id>; positions: 0 - head; 1 - shoulders; 2 - neck; 3 - right hand; 4 - left hand; 5 - torso; 6 - right ring; 7 - left ring; 8 - feet; 9 - misc1; 10 - misc2; 11 - misc3; 12 - misc4; 13 - mach1; 14 - mach2; 15 - mach3; 16 - mach4; 17 - spellbook; 18 - misc5
std::set<ui32> spells; //known spells (spell IDs) std::set<ui32> spells; //known spells (spell IDs)
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
const std::string &getBiography() const; const std::string &getBiography() const;
bool needsLastStack()const; bool needsLastStack()const;
unsigned int getTileCost(const EterrainType & ttype, const Eroad & rdtype, const Eriver & rvtype) const; unsigned int getTileCost(const EterrainType & ttype, const Eroad & rdtype, const Eriver & rvtype) const;
unsigned int getLowestCreatureSpeed() const; unsigned int getLowestCreatureSpeed() const;
unsigned int getAdditiveMoveBonus() const; unsigned int getAdditiveMoveBonus() const;
float getMultiplicativeMoveBonus() const; float getMultiplicativeMoveBonus() const;
int3 getPosition(bool h3m) const; //h3m=true - returns position of hero object; h3m=false - returns position of hero 'manifestation' int3 getPosition(bool h3m) const; //h3m=true - returns position of hero object; h3m=false - returns position of hero 'manifestation'
int getSightDistance() const; //returns sight distance of this hero int getSightDistance() const; //returns sight distance of this hero
int manaLimit() const; //maximum mana value for this hero (basically 10*knowledge) int manaLimit() const; //maximum mana value for this hero (basically 10*knowledge)
bool canWalkOnSea() const; bool canWalkOnSea() const;
int getCurrentLuck() const; int getCurrentLuck() const;
int getCurrentMorale() const; int getCurrentMorale() const;
int getPrimSkillLevel(int id) const; int getPrimSkillLevel(int id) const;
int getSecSkillLevel(const int & ID) const; //0 - no skill int getSecSkillLevel(const int & ID) const; //0 - no skill
int maxMovePoints(bool onLand) const; int maxMovePoints(bool onLand) const;
ui32 getArtAtPos(ui16 pos) const; //-1 - no artifact ui32 getArtAtPos(ui16 pos) const; //-1 - no artifact
void setArtAtPos(ui16 pos, int art); void setArtAtPos(ui16 pos, int art);
const CArtifact * getArt(int pos) const; const CArtifact * getArt(int pos) const;
int getSpellSecLevel(int spell) const; //returns level of secondary ability (fire, water, earth, air magic) known to this hero and applicable to given spell; -1 if error int getSpellSecLevel(int spell) const; //returns level of secondary ability (fire, water, earth, air magic) known to this hero and applicable to given spell; -1 if error
static int3 convertPosition(int3 src, bool toh3m); //toh3m=true: manifest->h3m; toh3m=false: h3m->manifest static int3 convertPosition(int3 src, bool toh3m); //toh3m=true: manifest->h3m; toh3m=false: h3m->manifest
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
void initHero(); void initHero();
void initHero(int SUBID); void initHero(int SUBID);
CGHeroInstance(); CGHeroInstance();
virtual ~CGHeroInstance(); virtual ~CGHeroInstance();
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
void initObj(); void initObj();
void onHeroVisit(const CGHeroInstance * h); void onHeroVisit(const CGHeroInstance * h);
}; };
class DLL_EXPORT CGTownInstance : public CArmedInstance class DLL_EXPORT CGTownInstance : public CArmedInstance
{ {
public: public:
CTown * town; CTown * town;
std::string name; // name of town std::string name; // name of town
int builded; //how many buildings has been built this turn int builded; //how many buildings has been built this turn
int destroyed; //how many buildings has been destroyed this turn int destroyed; //how many buildings has been destroyed this turn
const CGHeroInstance * garrisonHero, *visitingHero; const CGHeroInstance * garrisonHero, *visitingHero;
int identifier; //special identifier from h3m (only > RoE maps) int identifier; //special identifier from h3m (only > RoE maps)
int alignment; int alignment;
std::set<si32> forbiddenBuildings, builtBuildings; std::set<si32> forbiddenBuildings, builtBuildings;
std::vector<int> possibleSpells, obligatorySpells; std::vector<int> possibleSpells, obligatorySpells;
std::vector<std::vector<ui32> > spells; //spells[level] -> vector of spells, first will be available in guild std::vector<std::vector<ui32> > spells; //spells[level] -> vector of spells, first will be available in guild
struct StrInfo struct StrInfo
{ {
std::map<si32,ui32> creatures; //level - available amount std::map<si32,ui32> creatures; //level - available amount
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & creatures; h & creatures;
} }
} strInfo; } strInfo;
std::set<CCastleEvent> events; std::set<CCastleEvent> events;
bool needsLastStack() const; bool needsLastStack() const;
int getSightDistance() const; //returns sight distance int getSightDistance() const; //returns sight distance
int fortLevel() const; //0 - none, 1 - fort, 2 - citadel, 3 - castle int fortLevel() const; //0 - none, 1 - fort, 2 - citadel, 3 - castle
int hallLevel() const; // -1 - none, 0 - village, 1 - town, 2 - city, 3 - capitol int hallLevel() const; // -1 - none, 0 - village, 1 - town, 2 - city, 3 - capitol
int mageGuildLevel() const; // -1 - none, 0 - village, 1 - town, 2 - city, 3 - capitol int mageGuildLevel() const; // -1 - none, 0 - village, 1 - town, 2 - city, 3 - capitol
bool creatureDwelling(const int & level, bool upgraded=false) const; bool creatureDwelling(const int & level, bool upgraded=false) const;
int getHordeLevel(const int & HID) const; //HID - 0 or 1; returns creature level or -1 if that horde structure is not present int getHordeLevel(const int & HID) const; //HID - 0 or 1; returns creature level or -1 if that horde structure is not present
int creatureGrowth(const int & level) const; int creatureGrowth(const int & level) const;
bool hasFort() const; bool hasFort() const;
bool hasCapitol() const; bool hasCapitol() const;
int dailyIncome() const; int dailyIncome() const;
int spellsAtLevel(int level, bool checkGuild) const; //levels are counted from 1 (1 - 5) int spellsAtLevel(int level, bool checkGuild) const; //levels are counted from 1 (1 - 5)
CGTownInstance(); CGTownInstance();
virtual ~CGTownInstance(); virtual ~CGTownInstance();
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
void onHeroVisit(const CGHeroInstance * h); void onHeroVisit(const CGHeroInstance * h);
void onHeroLeave(const CGHeroInstance * h); void onHeroLeave(const CGHeroInstance * h);
void initObj(); void initObj();
}; };
class DLL_EXPORT CGVisitableOPH : public CGObjectInstance //objects visitable only once per hero class DLL_EXPORT CGVisitableOPH : public CGObjectInstance //objects visitable only once per hero
{ {
public: public:
std::set<si32> visitors; //ids of heroes who have visited this obj std::set<si32> visitors; //ids of heroes who have visited this obj
si8 ttype; //tree type - used only by trees of knowledge: 0 - give level for free; 1 - take 2000 gold; 2 - take 10 gems si8 ttype; //tree type - used only by trees of knowledge: 0 - give level for free; 1 - take 2000 gold; 2 - take 10 gems
const std::string & getHoverText() const; const std::string & getHoverText() const;
void onHeroVisit(const CGHeroInstance * h); void onHeroVisit(const CGHeroInstance * h);
void onNAHeroVisit(int heroID, bool alreadyVisited); void onNAHeroVisit(int heroID, bool alreadyVisited);
void initObj(); void initObj();
void treeSelected(int heroID, int resType, int resVal, int expVal, ui32 result); //handle player's anwer to the Tree of Knowledge dialog void treeSelected(int heroID, int resType, int resVal, int expVal, ui32 result); //handle player's anwer to the Tree of Knowledge dialog
}; };
class DLL_EXPORT CGEvent : public CGObjectInstance //event objects class DLL_EXPORT CGEvent : public CGObjectInstance //event objects
{ {
public: public:
bool areGuarders; //true if there are bool areGuarders; //true if there are
CCreatureSet guarders; CCreatureSet guarders;
bool isMessage; //true if there is a message bool isMessage; //true if there is a message
std::string message; std::string message;
unsigned int gainedExp; unsigned int gainedExp;
int manaDiff; //amount of gained / lost mana int manaDiff; //amount of gained / lost mana
int moraleDiff; //morale modifier int moraleDiff; //morale modifier
int luckDiff; //luck modifier int luckDiff; //luck modifier
int wood, mercury, ore, sulfur, crystal, gems, gold; //gained / lost resources int wood, mercury, ore, sulfur, crystal, gems, gold; //gained / lost resources
unsigned int attack; //added attack points unsigned int attack; //added attack points
unsigned int defence; //added defence points unsigned int defence; //added defence points
unsigned int power; //added power points unsigned int power; //added power points
unsigned int knowledge; //added knowledge points unsigned int knowledge; //added knowledge points
std::vector<int> abilities; //gained abilities std::vector<int> abilities; //gained abilities
std::vector<int> abilityLevels; //levels of gained abilities std::vector<int> abilityLevels; //levels of gained abilities
std::vector<int> artifacts; //gained artifacts std::vector<int> artifacts; //gained artifacts
std::vector<int> spells; //gained spells std::vector<int> spells; //gained spells
CCreatureSet creatures; //gained creatures CCreatureSet creatures; //gained creatures
unsigned char availableFor; //players whom this event is available for unsigned char availableFor; //players whom this event is available for
bool computerActivate; //true if computre player can activate this event bool computerActivate; //true if computre player can activate this event
bool humanActivate; //true if human player can activate this event bool humanActivate; //true if human player can activate this event
}; };
class DLL_EXPORT CGCreature : public CArmedInstance //creatures on map class DLL_EXPORT CGCreature : public CArmedInstance //creatures on map
{ {
public: public:
ui32 identifier; //unique code for this monster (used in missions) ui32 identifier; //unique code for this monster (used in missions)
ui8 character; //chracter of this set of creatures (0 - the most friendly, 4 - the most hostile) ui8 character; //chracter of this set of creatures (0 - the most friendly, 4 - the most hostile)
std::string message; //message printed for attacking hero std::string message; //message printed for attacking hero
std::vector<ui32> resources; //[res_id], resources given to hero that has won with monsters std::vector<ui32> resources; //[res_id], resources given to hero that has won with monsters
si32 gainedArtifact; //ID of artifact gained to hero, -1 if none si32 gainedArtifact; //ID of artifact gained to hero, -1 if none
ui8 neverFlees; //if true, the troops will never flee ui8 neverFlees; //if true, the troops will never flee
ui8 notGrowingTeam; //if true, number of units won't grow ui8 notGrowingTeam; //if true, number of units won't grow
void onHeroVisit(const CGHeroInstance * h); void onHeroVisit(const CGHeroInstance * h);
void endBattle(BattleResult *result); void endBattle(BattleResult *result);
void initObj(); void initObj();
}; };
class DLL_EXPORT CGSignBottle : public CGObjectInstance //signs and ocean bottles class DLL_EXPORT CGSignBottle : public CGObjectInstance //signs and ocean bottles
{ {
//TODO: generate default message if sign is 'empty' //TODO: generate default message if sign is 'empty'
public: public:
std::string message; std::string message;
}; };
class DLL_EXPORT CGSeerHut : public CGObjectInstance class DLL_EXPORT CGSeerHut : public CGObjectInstance
{ {
public: public:
unsigned char missionType; //type of mission: 0 - no mission; 1 - reach level; 2 - reach main statistics values; 3 - win with a certain hero; 4 - win with a certain creature; 5 - collect some atifacts; 6 - have certain troops in army; 7 - collect resources; 8 - be a certain hero; 9 - be a certain player unsigned char missionType; //type of mission: 0 - no mission; 1 - reach level; 2 - reach main statistics values; 3 - win with a certain hero; 4 - win with a certain creature; 5 - collect some atifacts; 6 - have certain troops in army; 7 - collect resources; 8 - be a certain hero; 9 - be a certain player
bool isDayLimit; //if true, there is a day limit bool isDayLimit; //if true, there is a day limit
int lastDay; //after this day (first day is 0) mission cannot be completed int lastDay; //after this day (first day is 0) mission cannot be completed
int m1level; //for mission 1 int m1level; //for mission 1
int m2attack, m2defence, m2power, m2knowledge;//for mission 2 int m2attack, m2defence, m2power, m2knowledge;//for mission 2
unsigned char m3bytes[4];//for mission 3 unsigned char m3bytes[4];//for mission 3
unsigned char m4bytes[4];//for mission 4 unsigned char m4bytes[4];//for mission 4
std::vector<int> m5arts;//for mission 5 - artifact ID std::vector<int> m5arts;//for mission 5 - artifact ID
std::vector<CCreature *> m6cre;//for mission 6 std::vector<CCreature *> m6cre;//for mission 6
std::vector<int> m6number; std::vector<int> m6number;
int m7wood, m7mercury, m7ore, m7sulfur, m7crystal, m7gems, m7gold; //for mission 7 int m7wood, m7mercury, m7ore, m7sulfur, m7crystal, m7gems, m7gold; //for mission 7
int m8hero;//for mission 8 - hero ID int m8hero;//for mission 8 - hero ID
int m9player; //for mission 9 - number; from 0 to 7 int m9player; //for mission 9 - number; from 0 to 7
std::string firstVisitText, nextVisitText, completedText; std::string firstVisitText, nextVisitText, completedText;
char rewardType; //type of reward: 0 - no reward; 1 - experience; 2 - mana points; 3 - morale bonus; 4 - luck bonus; 5 - resources; 6 - main ability bonus (attak, defence etd.); 7 - secondary ability gain; 8 - artifact; 9 - spell; 10 - creature char rewardType; //type of reward: 0 - no reward; 1 - experience; 2 - mana points; 3 - morale bonus; 4 - luck bonus; 5 - resources; 6 - main ability bonus (attak, defence etd.); 7 - secondary ability gain; 8 - artifact; 9 - spell; 10 - creature
//for reward 1 //for reward 1
int r1exp; int r1exp;
//for reward 2 //for reward 2
int r2mana; int r2mana;
//for reward 3 //for reward 3
int r3morale; int r3morale;
//for reward 4 //for reward 4
int r4luck; int r4luck;
//for reward 5 //for reward 5
unsigned char r5type; //0 - wood, 1 - mercury, 2 - ore, 3 - sulfur, 4 - crystal, 5 - gems, 6 - gold unsigned char r5type; //0 - wood, 1 - mercury, 2 - ore, 3 - sulfur, 4 - crystal, 5 - gems, 6 - gold
int r5amount; int r5amount;
//for reward 6 //for reward 6
unsigned char r6type; //0 - attack, 1 - defence, 2 - power, 3 - knowledge unsigned char r6type; //0 - attack, 1 - defence, 2 - power, 3 - knowledge
int r6amount; int r6amount;
//for reward 7 //for reward 7
int r7ability; //ability id int r7ability; //ability id
unsigned char r7level; //1 - basic, 2 - advanced, 3 - expert unsigned char r7level; //1 - basic, 2 - advanced, 3 - expert
//for reward 8 //for reward 8
int r8art;//artifact id int r8art;//artifact id
//for reward 9 //for reward 9
int r9spell;//spell id int r9spell;//spell id
//for reward 10 //for reward 10
int r10creature; //creature id int r10creature; //creature id
int r10amount; int r10amount;
}; };
class DLL_EXPORT CGWitchHut : public CGObjectInstance class DLL_EXPORT CGWitchHut : public CGObjectInstance
{ {
public: public:
std::vector<int> allowedAbilities; std::vector<int> allowedAbilities;
}; };
class DLL_EXPORT CGScholar : public CGObjectInstance class DLL_EXPORT CGScholar : public CGObjectInstance
{ {
public: public:
ui8 bonusType; //255 - random, 0 - primary skill, 1 - secondary skill, 2 - spell ui8 bonusType; //255 - random, 0 - primary skill, 1 - secondary skill, 2 - spell
ui8 r0type; ui8 r0type;
ui32 r1; //Ability ID ui32 r1; //Ability ID
ui32 r2; //Spell ID ui32 r2; //Spell ID
}; };
class DLL_EXPORT CGGarrison : public CArmedInstance class DLL_EXPORT CGGarrison : public CArmedInstance
{ {
public: public:
bool removableUnits; bool removableUnits;
}; };
class DLL_EXPORT CGArtifact : public CArmedInstance class DLL_EXPORT CGArtifact : public CArmedInstance
{ {
public: public:
std::string message; std::string message;
ui32 spell; //if it's spell scroll ui32 spell; //if it's spell scroll
}; };
class DLL_EXPORT CGResource : public CArmedInstance class DLL_EXPORT CGResource : public CArmedInstance
{ {
public: public:
int amount; //0 if random int amount; //0 if random
std::string message; std::string message;
}; };
class DLL_EXPORT CGShrine : public CGObjectInstance class DLL_EXPORT CGShrine : public CGObjectInstance
{ {
public: public:
unsigned char spell; //number of spell or 255 if random unsigned char spell; //number of spell or 255 if random
}; };
class DLL_EXPORT CGPandoraBox : public CArmedInstance class DLL_EXPORT CGPandoraBox : public CArmedInstance
{ {
public: public:
std::string message; std::string message;
//gained things: //gained things:
unsigned int gainedExp; unsigned int gainedExp;
int manaDiff; int manaDiff;
int moraleDiff; int moraleDiff;
int luckDiff; int luckDiff;
int wood, mercury, ore, sulfur, crystal, gems, gold; int wood, mercury, ore, sulfur, crystal, gems, gold;
int attack, defence, power, knowledge; int attack, defence, power, knowledge;
std::vector<int> abilities; std::vector<int> abilities;
std::vector<int> abilityLevels; std::vector<int> abilityLevels;
std::vector<int> artifacts; std::vector<int> artifacts;
std::vector<int> spells; std::vector<int> spells;
CCreatureSet creatures; CCreatureSet creatures;
}; };
class DLL_EXPORT CGQuestGuard : public CArmedInstance class DLL_EXPORT CGQuestGuard : public CArmedInstance
{ {
public: public:
char missionType; //type of mission: 0 - no mission; 1 - reach level; 2 - reach main statistics values; 3 - win with a certain hero; 4 - win with a certain creature; 5 - collect some atifacts; 6 - have certain troops in army; 7 - collect resources; 8 - be a certain hero; 9 - be a certain player char missionType; //type of mission: 0 - no mission; 1 - reach level; 2 - reach main statistics values; 3 - win with a certain hero; 4 - win with a certain creature; 5 - collect some atifacts; 6 - have certain troops in army; 7 - collect resources; 8 - be a certain hero; 9 - be a certain player
bool isDayLimit; //if true, there is a day limit bool isDayLimit; //if true, there is a day limit
int lastDay; //after this day (first day is 0) mission cannot be completed int lastDay; //after this day (first day is 0) mission cannot be completed
//for mission 1 //for mission 1
int m1level; int m1level;
//for mission 2 //for mission 2
int m2attack, m2defence, m2power, m2knowledge; int m2attack, m2defence, m2power, m2knowledge;
//for mission 3 //for mission 3
unsigned char m3bytes[4]; unsigned char m3bytes[4];
//for mission 4 //for mission 4
unsigned char m4bytes[4]; unsigned char m4bytes[4];
//for mission 5 //for mission 5
std::vector<int> m5arts; //artifacts id std::vector<int> m5arts; //artifacts id
//for mission 6 //for mission 6
std::vector<CCreature *> m6cre; std::vector<CCreature *> m6cre;
std::vector<int> m6number; std::vector<int> m6number;
//for mission 7 //for mission 7
int m7wood, m7mercury, m7ore, m7sulfur, m7crystal, m7gems, m7gold; int m7wood, m7mercury, m7ore, m7sulfur, m7crystal, m7gems, m7gold;
//for mission 8 //for mission 8
int m8hero; //hero id int m8hero; //hero id
//for mission 9 //for mission 9
int m9player; //number; from 0 to 7 int m9player; //number; from 0 to 7
std::string firstVisitText, nextVisitText, completedText; std::string firstVisitText, nextVisitText, completedText;
}; };
class DLL_EXPORT CObjectHandler class DLL_EXPORT CObjectHandler
{ {
public: public:
std::vector<std::string> names; //vector of objects; i-th object in vector has subnumber i std::vector<std::string> names; //vector of objects; i-th object in vector has subnumber i
std::vector<int> cregens; //type 17. dwelling subid -> creature ID std::vector<int> cregens; //type 17. dwelling subid -> creature ID
void loadObjects(); void loadObjects();
std::vector<std::string> creGens; //names of creatures' generators std::vector<std::string> creGens; //names of creatures' generators
std::vector<std::string> advobtxt; std::vector<std::string> advobtxt;
std::vector<std::string> xtrainfo; std::vector<std::string> xtrainfo;
std::vector<std::string> restypes; std::vector<std::string> restypes;
std::vector<std::pair<std::string,std::string> > mines; //first - name; second - event description std::vector<std::pair<std::string,std::string> > mines; //first - name; second - event description
}; };
#endif //COBJECTHANDLER_H
#endif // __COBJECTHANDLER_H__

119
hch/CSndHandler.h
View File

@ -1,59 +1,60 @@
#ifndef CSNDHANDLER_H #ifndef __CSNDHANDLER_H__
#define CSNDHANDLER_H #define __CSNDHANDLER_H__
#include <vector> #include <vector>
#include <fstream> #include <fstream>
#include <map> #include <map>
struct MemberFile struct MemberFile
{ {
std::ifstream * ifs; std::ifstream * ifs;
int length; int length;
}; };
class CSndHandler class CSndHandler
{ {
protected: protected:
const int CHUNK; const int CHUNK;
struct Entry struct Entry
{ {
std::string name; std::string name;
int size, offset; int size, offset;
}; };
std::ifstream file; std::ifstream file;
int readNormalNr (int pos, int bytCon); int readNormalNr (int pos, int bytCon);
bool opened; bool opened;
public: public:
std::vector<Entry> entries; std::vector<Entry> entries;
std::map<std::string, int> fimap; // map of wav file and index std::map<std::string, int> fimap; // map of wav file and index
~CSndHandler(); ~CSndHandler();
CSndHandler(std::string fname); CSndHandler(std::string fname);
void extract(std::string srcfile, std::string dstfile, bool caseSens=true); //saves selected file void extract(std::string srcfile, std::string dstfile, bool caseSens=true); //saves selected file
unsigned char * extract (std::string srcfile, int & size); //return selecte file data, NULL if file doesn't exist unsigned char * extract (std::string srcfile, int & size); //return selecte file data, NULL if file doesn't exist
void extract(int index, std::string dstfile); //saves selected file void extract(int index, std::string dstfile); //saves selected file
MemberFile getFile(std::string name);//nie testowane - sprawdzic MemberFile getFile(std::string name);//nie testowane - sprawdzic
unsigned char * extract (int index, int & size); //return selecte file - NIE TESTOWANE unsigned char * extract (int index, int & size); //return selecte file - NIE TESTOWANE
}; };
class CVidHandler class CVidHandler
{ {
protected: protected:
const int CHUNK; const int CHUNK;
struct Entry struct Entry
{ {
std::string name; std::string name;
int size, offset, something; int size, offset, something;
}; };
std::ifstream file; std::ifstream file;
int readNormalNr (int pos, int bytCon); int readNormalNr (int pos, int bytCon);
bool opened; bool opened;
public: public:
std::vector<Entry> entries; std::vector<Entry> entries;
~CVidHandler(); ~CVidHandler();
CVidHandler(std::string fname); CVidHandler(std::string fname);
std::ifstream & extract(std::string srcfile); std::ifstream & extract(std::string srcfile);
void extract(std::string srcfile, std::string dstfile, bool caseSens=true); //saves selected file void extract(std::string srcfile, std::string dstfile, bool caseSens=true); //saves selected file
unsigned char * extract (std::string srcfile, int & size); //return selecte file, unsigned char * extract (std::string srcfile, int & size); //return selecte file,
void extract(int index, std::string dstfile); //saves selected file void extract(int index, std::string dstfile); //saves selected file
MemberFile getFile(std::string name); //nie testowane - sprawdzic MemberFile getFile(std::string name); //nie testowane - sprawdzic
}; };
#endif //CSNDHANDLER_H
#endif // __CSNDHANDLER_H__

99
hch/CSpellHandler.h
View File

@ -1,49 +1,50 @@
#ifndef CSPELLHANDLER_H #ifndef __CSPELLHANDLER_H__
#define CSPELLHANDLER_H #define __CSPELLHANDLER_H__
#include <string> #include <string>
#include <vector> #include <vector>
class CSpell class CSpell
{ {
public: public:
ui32 id; ui32 id;
std::string name; std::string name;
std::string abbName; //abbreviated name std::string abbName; //abbreviated name
std::vector<std::string> descriptions; //descriptions of spell for skill levels: 0 - none, 1 - basic, etc std::vector<std::string> descriptions; //descriptions of spell for skill levels: 0 - none, 1 - basic, etc
si32 level; si32 level;
bool earth; bool earth;
bool water; bool water;
bool fire; bool fire;
bool air; bool air;
si32 power; //spell's power si32 power; //spell's power
std::vector<si32> costs; //per skill level: 0 - none, 1 - basic, etc std::vector<si32> costs; //per skill level: 0 - none, 1 - basic, etc
std::vector<si32> powers; //[er skill level: 0 - none, 1 - basic, etc std::vector<si32> powers; //[er skill level: 0 - none, 1 - basic, etc
std::vector<si32> probabilities; //% chance to gain for castles std::vector<si32> probabilities; //% chance to gain for castles
std::vector<si32> AIVals; //AI values: per skill level: 0 - none, 1 - basic, etc std::vector<si32> AIVals; //AI values: per skill level: 0 - none, 1 - basic, etc
std::string attributes; //reference only attributes std::string attributes; //reference only attributes
bool combatSpell; //is this spell combat (true) or adventure (false) bool combatSpell; //is this spell combat (true) or adventure (false)
bool creatureAbility; //if true, only creatures can use this spell bool creatureAbility; //if true, only creatures can use this spell
si8 positiveness; //1 if spell is positive for influenced stacks, 0 if it is indifferent, -1 if it's negative si8 positiveness; //1 if spell is positive for influenced stacks, 0 if it is indifferent, -1 if it's negative
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & id & name & abbName & descriptions & level & earth & water & fire & air & power & costs h & id & name & abbName & descriptions & level & earth & water & fire & air & power & costs
& powers & probabilities & AIVals & attributes & combatSpell & creatureAbility & positiveness; & powers & probabilities & AIVals & attributes & combatSpell & creatureAbility & positiveness;
} }
}; };
class DLL_EXPORT CSpellHandler class DLL_EXPORT CSpellHandler
{ {
public: public:
std::vector<CSpell> spells; std::vector<CSpell> spells;
void loadSpells(); void loadSpells();
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & spells; h & spells;
} }
}; };
#endif //CSPELLHANDLER_H
#endif // __CSPELLHANDLER_H__

145
hch/CTownHandler.h
View File

@ -1,72 +1,73 @@
#ifndef CTOWNHANDLER_H #ifndef __CTOWNHANDLER_H__
#define CTOWNHANDLER_H #define __CTOWNHANDLER_H__
#include "../global.h" #include "../global.h"
#include <set> #include <set>
class CBuilding; class CBuilding;
class CSpell; class CSpell;
class CHero; class CHero;
class CGTownInstance; class CGTownInstance;
class DLL_EXPORT CTown class DLL_EXPORT CTown
{ {
std::string name; //name of type std::string name; //name of type
public: public:
std::vector<std::string> names; //names of the town instances std::vector<std::string> names; //names of the town instances
std::vector<int> basicCreatures; //level (from 0) -> ID std::vector<int> basicCreatures; //level (from 0) -> ID
std::vector<int> upgradedCreatures; //level (from 0) -> ID std::vector<int> upgradedCreatures; //level (from 0) -> ID
std::map<int,int> hordeLvl; //[0] - first horde building creature level; [1] - second horde building (-1 if not present) std::map<int,int> hordeLvl; //[0] - first horde building creature level; [1] - second horde building (-1 if not present)
ui32 mageLevel; //max available mage guild level ui32 mageLevel; //max available mage guild level
int bonus; //pic number int bonus; //pic number
ui16 primaryRes, warMachine; ui16 primaryRes, warMachine;
ui8 typeID; ui8 typeID;
const std::vector<std::string> & Names() const; const std::vector<std::string> & Names() const;
const std::string & Name() const; const std::string & Name() const;
void Name(const std::string & val) { name = val; } void Name(const std::string & val) { name = val; }
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & names & basicCreatures & upgradedCreatures & hordeLvl & mageLevel & bonus h & names & basicCreatures & upgradedCreatures & hordeLvl & mageLevel & bonus
& primaryRes & warMachine & typeID; & primaryRes & warMachine & typeID;
} }
}; };
struct DLL_EXPORT Structure struct DLL_EXPORT Structure
{ {
int ID; int ID;
int3 pos; int3 pos;
std::string defName, borderName, areaName, name; std::string defName, borderName, areaName, name;
int townID, group; int townID, group;
bool operator<(const Structure & p2) const bool operator<(const Structure & p2) const
{ {
if(pos.z != p2.pos.z) if(pos.z != p2.pos.z)
return (pos.z) < (p2.pos.z); return (pos.z) < (p2.pos.z);
else else
return (ID) < (p2.ID); return (ID) < (p2.ID);
} }
}; };
class DLL_EXPORT CTownHandler class DLL_EXPORT CTownHandler
{ {
public: public:
std::vector<CTown> towns; std::vector<CTown> towns;
std::map<int,std::map<int, Structure*> > structures; // <town ID, <structure ID, structure>> std::map<int,std::map<int, Structure*> > structures; // <town ID, <structure ID, structure>>
std::map<int, std::map<int,std::set<int> > > requirements; //requirements[town_id][structure_id] -> set of required buildings std::map<int, std::map<int,std::set<int> > > requirements; //requirements[town_id][structure_id] -> set of required buildings
CTownHandler(); CTownHandler();
~CTownHandler(); ~CTownHandler();
void loadNames(); void loadNames();
void loadStructures(); void loadStructures();
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & towns & requirements; h & towns & requirements;
if(!h.saving) if(!h.saving)
loadStructures(); loadStructures();
} }
}; };
#endif //CTOWNHANDLER_H
#endif // __CTOWNHANDLER_H__

235
int3.h
View File

@ -1,117 +1,118 @@
#ifndef INT3_H #ifndef __INT3_H__
#define INT3_H #define __INT3_H__
#include <map> #include <map>
#include <vector> #include <vector>
#include <cmath> #include <cmath>
class CCreature; class CCreature;
class CCreatureSet //seven combined creatures class CCreatureSet //seven combined creatures
{ {
public: public:
std::map<si32,std::pair<ui32,si32> > slots; //slots[slot_id]=> pair(creature_id,creature_quantity) std::map<si32,std::pair<ui32,si32> > slots; //slots[slot_id]=> pair(creature_id,creature_quantity)
bool formation; //false - wide, true - tight bool formation; //false - wide, true - tight
si32 getSlotFor(ui32 creature, ui32 slotsAmount=7) //returns -1 if no slot available si32 getSlotFor(ui32 creature, ui32 slotsAmount=7) //returns -1 if no slot available
{ {
for(std::map<si32,std::pair<ui32,si32> >::iterator i=slots.begin(); i!=slots.end(); ++i) for(std::map<si32,std::pair<ui32,si32> >::iterator i=slots.begin(); i!=slots.end(); ++i)
{ {
if(i->second.first == creature) if(i->second.first == creature)
{ {
return i->first; //if there is already such creature we return its slot id return i->first; //if there is already such creature we return its slot id
} }
} }
for(ui32 i=0; i<slotsAmount; i++) for(ui32 i=0; i<slotsAmount; i++)
{ {
if(slots.find(i) == slots.end()) if(slots.find(i) == slots.end())
{ {
return i; //return first free slot return i; //return first free slot
} }
} }
return -1; //no slot available return -1; //no slot available
} }
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & slots & formation; h & slots & formation;
} }
}; };
class int3 class int3
{ {
public: public:
si32 x,y,z; si32 x,y,z;
inline int3():x(0),y(0),z(0){}; //c-tor, x/y/z initialized to 0 inline int3():x(0),y(0),z(0){}; //c-tor, x/y/z initialized to 0
inline int3(const si32 & X, const si32 & Y, const si32 & Z):x(X),y(Y),z(Z){}; //c-tor inline int3(const si32 & X, const si32 & Y, const si32 & Z):x(X),y(Y),z(Z){}; //c-tor
inline int3(const int3 & val) : x(val.x), y(val.y), z(val.z){} //copy c-tor inline int3(const int3 & val) : x(val.x), y(val.y), z(val.z){} //copy c-tor
inline int3 operator=(const int3 & val) {x = val.x; y = val.y; z = val.z; return *this;} //assignemt operator inline int3 operator=(const int3 & val) {x = val.x; y = val.y; z = val.z; return *this;} //assignemt operator
~int3() {} // d-tor - does nothing ~int3() {} // d-tor - does nothing
inline int3 operator+(const int3 & i) const //returns int3 with coordinates increased by corresponding coordinate of given int3 inline int3 operator+(const int3 & i) const //returns int3 with coordinates increased by corresponding coordinate of given int3
{return int3(x+i.x,y+i.y,z+i.z);} {return int3(x+i.x,y+i.y,z+i.z);}
inline int3 operator+(const si32 i) const //returns int3 with coordinates increased by given numer inline int3 operator+(const si32 i) const //returns int3 with coordinates increased by given numer
{return int3(x+i,y+i,z+i);} {return int3(x+i,y+i,z+i);}
inline int3 operator-(const int3 & i) const //returns int3 with coordinates decreased by corresponding coordinate of given int3 inline int3 operator-(const int3 & i) const //returns int3 with coordinates decreased by corresponding coordinate of given int3
{return int3(x-i.x,y-i.y,z-i.z);} {return int3(x-i.x,y-i.y,z-i.z);}
inline int3 operator-(const si32 i) const //returns int3 with coordinates decreased by given numer inline int3 operator-(const si32 i) const //returns int3 with coordinates decreased by given numer
{return int3(x-i,y-i,z-i);} {return int3(x-i,y-i,z-i);}
inline int3 operator-() const //returns opposite position inline int3 operator-() const //returns opposite position
{return int3(-x,-y,-z);} {return int3(-x,-y,-z);}
inline double dist2d(const int3 other) const //distance (z coord is not used) inline double dist2d(const int3 other) const //distance (z coord is not used)
{return std::sqrt((double)(x-other.x)*(x-other.x) + (y-other.y)*(y-other.y));} {return std::sqrt((double)(x-other.x)*(x-other.x) + (y-other.y)*(y-other.y));}
inline void operator+=(const int3 & i) inline void operator+=(const int3 & i)
{ {
x+=i.x; x+=i.x;
y+=i.y; y+=i.y;
z+=i.z; z+=i.z;
} }
inline void operator+=(const si32 & i) inline void operator+=(const si32 & i)
{ {
x+=i; x+=i;
y+=i; y+=i;
z+=i; z+=i;
} }
inline void operator-=(const int3 & i) inline void operator-=(const int3 & i)
{ {
x-=i.x; x-=i.x;
y-=i.y; y-=i.y;
z-=i.z; z-=i.z;
} }
inline void operator-=(const si32 & i) inline void operator-=(const si32 & i)
{ {
x+=i; x+=i;
y+=i; y+=i;
z+=i; z+=i;
} }
inline bool operator==(const int3 & i) const inline bool operator==(const int3 & i) const
{return (x==i.x) && (y==i.y) && (z==i.z);} {return (x==i.x) && (y==i.y) && (z==i.z);}
inline bool operator!=(const int3 & i) const inline bool operator!=(const int3 & i) const
{return !(*this==i);} {return !(*this==i);}
inline bool operator<(const int3 & i) const inline bool operator<(const int3 & i) const
{ {
if (z<i.z) if (z<i.z)
return true; return true;
if (z>i.z) if (z>i.z)
return false; return false;
if (y<i.y) if (y<i.y)
return true; return true;
if (y>i.y) if (y>i.y)
return false; return false;
if (x<i.x) if (x<i.x)
return true; return true;
if (x>i.x) if (x>i.x)
return false; return false;
return false; return false;
} }
template <typename Handler> void serialize(Handler &h, const int version) template <typename Handler> void serialize(Handler &h, const int version)
{ {
h & x & y & z; h & x & y & z;
} }
}; };
inline std::istream & operator>>(std::istream & str, int3 & dest) inline std::istream & operator>>(std::istream & str, int3 & dest)
{ {
str>>dest.x>>dest.y>>dest.z; str>>dest.x>>dest.y>>dest.z;
return str; return str;
} }
inline std::ostream & operator<<(std::ostream & str, const int3 & sth) inline std::ostream & operator<<(std::ostream & str, const int3 & sth)
{ {
return str<<sth.x<<' '<<sth.y<<' '<<sth.z; return str<<sth.x<<' '<<sth.y<<' '<<sth.z;
} }
#endif //INT3_H
#endif // __INT3_H__

7
lib/Connection.h
View File

@ -1,5 +1,5 @@
#ifndef CONNECTION_H #ifndef __CONNECTION_H__
#define CONNECTION_H #define __CONNECTION_H__
#include "../global.h" #include "../global.h"
#include <string> #include <string>
#include <vector> #include <vector>
@ -413,4 +413,5 @@ public:
void close(); void close();
~CConnection(void); ~CConnection(void);
}; };
#endif //CONNECTION_H
#endif // __CONNECTION_H__

91
lib/VCMI_Lib.h
View File

@ -1,45 +1,46 @@
#ifndef VCMI_LIB_H #ifndef __VCMI_LIB_H__
#define VCMI_LIB_H #define __VCMI_LIB_H__
#include "../global.h" #include "../global.h"
class CLodHandler; class CLodHandler;
class CArtHandler; class CArtHandler;
class CHeroHandler; class CHeroHandler;
class CCreatureHandler; class CCreatureHandler;
//class CAbilityHandler; //class CAbilityHandler;
class CSpellHandler; class CSpellHandler;
//class CPreGameTextHandler; //class CPreGameTextHandler;
class CBuildingHandler; class CBuildingHandler;
class CObjectHandler; class CObjectHandler;
//class CMusicHandler; //class CMusicHandler;
//class CSemiLodHandler; //class CSemiLodHandler;
class CDefObjInfoHandler; class CDefObjInfoHandler;
class CTownHandler; class CTownHandler;
class CGeneralTextHandler; class CGeneralTextHandler;
//class CConsoleHandler; //class CConsoleHandler;
//class CPathfinder; //class CPathfinder;
//class CGameState; //class CGameState;
class LibClasses class LibClasses
{ {
public: public:
CArtHandler * arth; CArtHandler * arth;
CHeroHandler * heroh; CHeroHandler * heroh;
CCreatureHandler * creh; CCreatureHandler * creh;
CSpellHandler * spellh; CSpellHandler * spellh;
CBuildingHandler * buildh; CBuildingHandler * buildh;
CObjectHandler * objh; CObjectHandler * objh;
CDefObjInfoHandler * dobjinfo; CDefObjInfoHandler * dobjinfo;
CTownHandler * townh; CTownHandler * townh;
CGeneralTextHandler * generaltexth; CGeneralTextHandler * generaltexth;
//CPathfinder * pathf; //CPathfinder * pathf;
}; };
extern DLL_EXPORT LibClasses * VLC; extern DLL_EXPORT LibClasses * VLC;
extern CLodHandler * bitmaph; extern CLodHandler * bitmaph;
DLL_EXPORT void loadToIt(std::string &dest, std::string &src, int &iter, int mode); DLL_EXPORT void loadToIt(std::string &dest, std::string &src, int &iter, int mode);
DLL_EXPORT void loadToIt(si32 &dest, std::string &src, int &iter, int mode); DLL_EXPORT void loadToIt(si32 &dest, std::string &src, int &iter, int mode);
DLL_EXPORT void initDLL(CLodHandler *b, CConsoleHandler *Console, std::ostream *Logfile); DLL_EXPORT void initDLL(CLodHandler *b, CConsoleHandler *Console, std::ostream *Logfile);
#endif //VCMI_LIB_H
#endif // __VCMI_LIB_H__

231
mapHandler.h
View File

@ -1,115 +1,116 @@
#ifndef MAPHANDLER_H #ifndef __MAPHANDLER_H__
#define MAPHANDLER_H #define __MAPHANDLER_H__
#include "global.h" #include "global.h"
#include <list> #include <list>
#include <set> #include <set>
const int Woff = 12; //width of map's frame const int Woff = 12; //width of map's frame
const int Hoff = 8; const int Hoff = 8;
class CGObjectInstance; class CGObjectInstance;
class CGHeroInstance; class CGHeroInstance;
struct Mapa; struct Mapa;
class CGDefInfo; class CGDefInfo;
class CGObjectInstance; class CGObjectInstance;
class CDefHandler; class CDefHandler;
struct TerrainTile; struct TerrainTile;
struct SDL_Surface; struct SDL_Surface;
struct SDL_Rect; struct SDL_Rect;
struct TerrainTile2 struct TerrainTile2
{ {
int3 pos; int3 pos;
const TerrainTile *tileInfo; const TerrainTile *tileInfo;
SDL_Surface * terbitmap; //frames of terrain animation SDL_Surface * terbitmap; //frames of terrain animation
std::vector<SDL_Surface *> rivbitmap; //frames of river animation std::vector<SDL_Surface *> rivbitmap; //frames of river animation
std::vector<SDL_Surface *> roadbitmap; //frames of road animation std::vector<SDL_Surface *> roadbitmap; //frames of road animation
std::vector < std::pair<const CGObjectInstance*,SDL_Rect> > objects; //poiters to objects being on this tile with rects to be easier to blit this tile on screen std::vector < std::pair<const CGObjectInstance*,SDL_Rect> > objects; //poiters to objects being on this tile with rects to be easier to blit this tile on screen
TerrainTile2(); TerrainTile2();
}; };
//pathfinder //pathfinder
// map<int,int> iDTerenu=>koszt_pola // map<int,int> iDTerenu=>koszt_pola
// map<int,int> IDdrogi=>koszt_drogi // map<int,int> IDdrogi=>koszt_drogi
template <typename T> class PseudoV template <typename T> class PseudoV
{ {
public: public:
int offset; int offset;
std::vector<T> inver; std::vector<T> inver;
PseudoV(){}; PseudoV(){};
PseudoV(std::vector<T> &src, int rest, int Offset, const T& fill) PseudoV(std::vector<T> &src, int rest, int Offset, const T& fill)
{ {
inver.resize(Offset*2+rest); inver.resize(Offset*2+rest);
offset=Offset; offset=Offset;
for(int i=0; i<offset;i++) for(int i=0; i<offset;i++)
inver[i] = fill; inver[i] = fill;
for(int i=0;i<src.size();i++) for(int i=0;i<src.size();i++)
inver[offset+i] = src[i]; inver[offset+i] = src[i];
for(int i=src.size(); i<src.size()+offset;i++) for(int i=src.size(); i<src.size()+offset;i++)
inver[offset+i] = fill; inver[offset+i] = fill;
} }
inline T & operator[](const int & n) inline T & operator[](const int & n)
{ {
return inver[n+offset]; return inver[n+offset];
} }
inline const T & operator[](const int & n) const inline const T & operator[](const int & n) const
{ {
return inver[n+offset]; return inver[n+offset];
} }
void resize(int rest,int Offset) void resize(int rest,int Offset)
{ {
inver.resize(Offset*2+rest); inver.resize(Offset*2+rest);
offset=Offset; offset=Offset;
} }
int size() const int size() const
{ {
return inver.size(); return inver.size();
} }
}; };
class CMapHandler class CMapHandler
{ {
public: public:
PseudoV< PseudoV< PseudoV<TerrainTile2> > > ttiles; PseudoV< PseudoV< PseudoV<TerrainTile2> > > ttiles;
int3 sizes; int3 sizes;
Mapa * map; Mapa * map;
std::set<int> usedHeroes; std::set<int> usedHeroes;
CDefHandler * fullHide; CDefHandler * fullHide;
CDefHandler * partialHide; CDefHandler * partialHide;
std::vector<std::vector<SDL_Surface *> > terrainGraphics; // [terrain id] [view type] [rotation type] std::vector<std::vector<SDL_Surface *> > terrainGraphics; // [terrain id] [view type] [rotation type]
std::vector<CDefHandler *> roadDefs; std::vector<CDefHandler *> roadDefs;
std::vector<CDefHandler *> staticRiverDefs; std::vector<CDefHandler *> staticRiverDefs;
std::vector<CDefHandler*> defs; std::vector<CDefHandler*> defs;
std::map<std::string, CDefHandler*> loadedDefs; //pointers to loaded defs (key is filename, uppercase) std::map<std::string, CDefHandler*> loadedDefs; //pointers to loaded defs (key is filename, uppercase)
std::vector<std::vector<std::vector<unsigned char> > > hideBitmap; //specifies number of graphic that should be used to fully hide a tile std::vector<std::vector<std::vector<unsigned char> > > hideBitmap; //specifies number of graphic that should be used to fully hide a tile
void loadDefs(); void loadDefs();
SDL_Surface * getVisBitmap(int x, int y, const std::vector< std::vector< std::vector<unsigned char> > > & visibilityMap, int lvl); SDL_Surface * getVisBitmap(int x, int y, const std::vector< std::vector< std::vector<unsigned char> > > & visibilityMap, int lvl);
int getCost(int3 & a, int3 & b, const CGHeroInstance * hero); int getCost(int3 & a, int3 & b, const CGHeroInstance * hero);
std::vector< std::string > getObjDescriptions(int3 pos); //returns desriptions of objects blocking given position std::vector< std::string > getObjDescriptions(int3 pos); //returns desriptions of objects blocking given position
//std::vector< CGObjectInstance * > getVisitableObjs(int3 pos); //returns vector of visitable objects at certain position //std::vector< CGObjectInstance * > getVisitableObjs(int3 pos); //returns vector of visitable objects at certain position
CGObjectInstance * createObject(int id, int subid, int3 pos, int owner=254); //creates a new object with a certain id and subid CGObjectInstance * createObject(int id, int subid, int3 pos, int owner=254); //creates a new object with a certain id and subid
std::string getDefName(int id, int subid); //returns name of def for object with given id and subid std::string getDefName(int id, int subid); //returns name of def for object with given id and subid
bool printObject(const CGObjectInstance * obj); //puts appropriate things to ttiles, so obj will be visible on map bool printObject(const CGObjectInstance * obj); //puts appropriate things to ttiles, so obj will be visible on map
bool hideObject(const CGObjectInstance * obj); //removes appropriate things from ttiles, so obj will be no longer visible on map (but still will exist) bool hideObject(const CGObjectInstance * obj); //removes appropriate things from ttiles, so obj will be no longer visible on map (but still will exist)
bool removeObject(CGObjectInstance * obj); //removes object from each place in VCMI (I hope) bool removeObject(CGObjectInstance * obj); //removes object from each place in VCMI (I hope)
void initHeroDef(CGHeroInstance * h); void initHeroDef(CGHeroInstance * h);
void init(); void init();
void calculateBlockedPos(); void calculateBlockedPos();
void initObjectRects(); void initObjectRects();
void borderAndTerrainBitmapInit(); void borderAndTerrainBitmapInit();
void roadsRiverTerrainInit(); void roadsRiverTerrainInit();
void prepareFOWDefs(); void prepareFOWDefs();
SDL_Surface * terrainRect(int x, int y, int dx, int dy, int level=0, unsigned char anim=0, std::vector< std::vector< std::vector<unsigned char> > > * visibilityMap = NULL, bool otherHeroAnim = false, unsigned char heroAnim = 0, SDL_Surface * extSurf = NULL, SDL_Rect * extRect = NULL); //if extSurf is specified, blit to it SDL_Surface * terrainRect(int x, int y, int dx, int dy, int level=0, unsigned char anim=0, std::vector< std::vector< std::vector<unsigned char> > > * visibilityMap = NULL, bool otherHeroAnim = false, unsigned char heroAnim = 0, SDL_Surface * extSurf = NULL, SDL_Rect * extRect = NULL); //if extSurf is specified, blit to it
void updateWater(); void updateWater();
unsigned char getHeroFrameNum(const unsigned char & dir, const bool & isMoving) const; //terrainRect helper function unsigned char getHeroFrameNum(const unsigned char & dir, const bool & isMoving) const; //terrainRect helper function
void validateRectTerr(SDL_Rect * val, const SDL_Rect * ext); //terrainRect helper void validateRectTerr(SDL_Rect * val, const SDL_Rect * ext); //terrainRect helper
static unsigned char getDir(const int3 & a, const int3 & b); //returns direction number in range 0 - 7 (0 is left top, clockwise) [direction: form a to b] static unsigned char getDir(const int3 & a, const int3 & b); //returns direction number in range 0 - 7 (0 is left top, clockwise) [direction: form a to b]
}; };
#endif //MAPHANDLER_H
#endif // __MAPHANDLER_H__

7
server/CGameHandler.h
View File

@ -1,5 +1,5 @@
#ifndef CGAMEHANDLER_H #ifndef __CGAMEHANDLER_H__
#define CGAMEHANDLER_H #define __CGAMEHANDLER_H__
#include "../global.h" #include "../global.h"
#include <set> #include <set>
@ -169,4 +169,5 @@ public:
friend class CVCMIServer; friend class CVCMIServer;
friend class CScriptCallback; friend class CScriptCallback;
}; };
#endif //CGAMEHANDLER_H
#endif // __CGAMEHANDLER_H__

3
stdafx.h
View File

@ -1,7 +1,5 @@
#ifndef __STDAFX_H__ #ifndef __STDAFX_H__
#define __STDAFX_H__ #define __STDAFX_H__
#ifndef __STDAFX_H__
#define __STDAFX_H__
// stdafx.h : include file for standard system include files, // stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but // or project specific include files that are used frequently, but
@ -24,4 +22,3 @@
// TODO: reference additional headers your program requires here // TODO: reference additional headers your program requires here
#endif // __STDAFX_H__ #endif // __STDAFX_H__
#endif // __STDAFX_H__

33
timeHandler.h
View File

@ -1,16 +1,17 @@
#ifndef TIMEHANDLER_H #ifndef __TIMEHANDLER_H__
#define TIMEHANDLER_H #define __TIMEHANDLER_H__
#include <ctime> #include <ctime>
class timeHandler class timeHandler
{ {
public: public:
clock_t start, last, mem; clock_t start, last, mem;
timeHandler():start(clock()){last=clock();mem=0;}; timeHandler():start(clock()){last=clock();mem=0;};
long getDif(){long ret=clock()-last;last=clock();return ret;}; long getDif(){long ret=clock()-last;last=clock();return ret;};
void update(){last=clock();}; void update(){last=clock();};
void remember(){mem=clock();}; void remember(){mem=clock();};
long memDif(){return mem-clock();}; long memDif(){return mem-clock();};
}; };
#endif //TIMEHANDLER_H
#endif // __TIMEHANDLER_H__