* splitted CGameState into general game state and battle game state

* added missing fields to serialize in CHero

AI/GeniusAI/BattleLogic.cpp

@@ -1,4 +1,5 @@
 #include "BattleLogic.h"
+#include "../../lib/BattleState.h"
 #include <math.h>
 #include <boost/lexical_cast.hpp>
 #include <boost/lambda/lambda.hpp>

AI/GeniusAI/CGeniusAI.cpp

@@ -3,6 +3,7 @@
 #include <iostream>
 #include <boost/lexical_cast.hpp>
 
+#include "../../lib/BattleState.h"
 #include "../../lib/CBuildingHandler.h"
 #include "../../lib/CHeroHandler.h"
 #include "../../lib/VCMI_Lib.h"

AI/StupidAI/StupidAI.cpp

@@ -1,6 +1,6 @@
 #include "stdafx.h"
 #include "StupidAI.h"
-#include "../../lib/CGameState.h"
+#include "../../lib/BattleState.h"
 
 CStupidAI::CStupidAI(void)
 	: side(-1), cb(NULL)

CCallback.cpp

@@ -3,6 +3,7 @@
 #include "lib/CCreatureHandler.h"
 #include "client/CGameInfo.h"
 #include "lib/CGameState.h"
+#include "lib/BattleState.h"
 #include "client/CPlayerInterface.h"
 #include "client/Client.h"
 #include "lib/map.h"

CCallback.h

@@ -43,6 +43,7 @@ class CMapHeader;
 struct CGPathNode;
 struct CGPath;
 class CGGarrison;
+class CObstacleInstance;
 
 struct InfoAboutTown
 {

CGameInterface.cpp

@@ -1,6 +1,6 @@
 #include "stdafx.h"
 #include "CGameInterface.h"
-#include "lib/CGameState.h"
+#include "lib/BattleState.h"
 
 #ifdef _WIN32
 	#define WIN32_LEAN_AND_MEAN //excludes rarely used stuff from windows headers - delete this line if something is missing

client/CBattleInterface.cpp

@@ -13,7 +13,7 @@
 #include "CMessage.h"
 #include "CCursorHandler.h"
 #include "../CCallback.h"
-#include "../lib/CGameState.h"
+#include "../lib/BattleState.h"
 #include "../lib/CGeneralTextHandler.h"
 #include "CCreatureAnimation.h"
 #include "Graphics.h"

client/CPlayerInterface.cpp

@@ -25,6 +25,7 @@
 #include "../lib/Connection.h"
 #include "../lib/CSpellHandler.h"
 #include "../lib/CTownHandler.h"
+#include "../lib/BattleState.h"
 #include "CMusicHandler.h"
 #include "../lib/CondSh.h"
 #include "../lib/NetPacks.h"

client/Client.cpp

@@ -6,6 +6,7 @@
 #include "../lib/CGameState.h"
 #include "CPlayerInterface.h"
 #include "../StartInfo.h"
+#include "../lib/BattleState.h"
 #include "../lib/CArtHandler.h"
 #include "../lib/CDefObjInfoHandler.h"
 #include "../lib/CGeneralTextHandler.h"

client/NetPacksClient.cpp

@@ -23,6 +23,9 @@
 #include "SDL_Extensions.h"
 #include "CBattleInterface.h"
 #include "../lib/CCampaignHandler.h"
+#include "../lib/CGameState.h"
+#include "../lib/BattleState.h"
+
 
 //macro to avoid code duplication - calls given method with given arguments if interface for specific player is present
 #define INTERFACE_CALL_IF_PRESENT(player,function,...) 	\

lib/BattleAction.cpp

@@ -1,6 +1,16 @@
 #define VCMI_DLL
 #include "BattleAction.h"
-#include "CGameState.h"
+#include "BattleState.h"
+
+/*
+ * BattleAction.h, part of VCMI engine
+ *
+ * Authors: listed in file AUTHORS in main folder
+ *
+ * License: GNU General Public License v2.0 or later
+ * Full text of license available in license.txt file, in main folder
+ *
+ */
 
 BattleAction::BattleAction()
 {

lib/BattleState.h

@@ -0,0 +1,212 @@
+#pragma once
+
+#include "../global.h"
+#include "HeroBonus.h"
+#include "CCreatureSet.h"
+
+#include "ConstTransitivePtr.h"
+
+/*
+ * BattleState.h, part of VCMI engine
+ *
+ * Authors: listed in file AUTHORS in main folder
+ *
+ * License: GNU General Public License v2.0 or later
+ * Full text of license available in license.txt file, in main folder
+ *
+ */
+
+class CGHeroInstance;
+class CStack;
+class CArmedInstance;
+class CGTownInstance;
+class CStackInstance;
+
+
+struct DLL_EXPORT CObstacleInstance
+{
+	int uniqueID;
+	int ID; //ID of obstacle (defines type of it)
+	int pos; //position on battlefield
+	template <typename Handler> void serialize(Handler &h, const int version)
+	{
+		h & ID & pos & uniqueID;
+	}
+};
+
+//only for use in BattleInfo
+struct DLL_EXPORT SiegeInfo
+{
+	ui8 wallState[8]; //[0] - keep, [1] - bottom tower, [2] - bottom wall, [3] - below gate, [4] - over gate, [5] - upper wall, [6] - uppert tower, [7] - gate; 1 - intact, 2 - damaged, 3 - destroyed
+
+	template <typename Handler> void serialize(Handler &h, const int version)
+	{
+		h & wallState;
+	}
+};
+
+struct DLL_EXPORT BattleInfo : public CBonusSystemNode
+{
+	ui8 side1, side2; //side1 - attacker, side2 - defender
+	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
+	si32 tid; //used during town siege - id of attacked town; -1 if not town defence
+	int3 tile; //for background and bonuses
+	CGHeroInstance *heroes[2];
+	CArmedInstance *belligerents[2]; //may be same as heroes
+	std::vector<CStack*> stacks;
+	std::vector<CObstacleInstance> obstacles;
+	ui8 castSpells[2]; //[0] - attacker, [1] - defender
+	SiegeInfo si;
+	si32 battlefieldType;
+
+	template <typename Handler> void serialize(Handler &h, const int version)
+	{
+		h & side1 & side2 & round & activeStack & siege & tid & tile & stacks & belligerents & obstacles
+			& castSpells & si & battlefieldType;
+		h & heroes;
+		h & static_cast<CBonusSystemNode&>(*this);
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+	//void getBonuses(BonusList &out, const CSelector &selector, const CBonusSystemNode *root = NULL) const;
+	//////////////////////////////////////////////////////////////////////////
+
+	const CStack * getNextStack() const; //which stack will have turn after current one
+	void getStackQueue(std::vector<const CStack *> &out, int howMany, int turn = 0, int lastMoved = -1) const; //returns stack in order of their movement action
+	CStack * getStack(int stackID, bool onlyAlive = true);
+	const CStack * getStack(int stackID, bool onlyAlive = true) const;
+	CStack * getStackT(THex tileID, bool onlyAlive = true);
+	const CStack * getStackT(THex tileID, bool onlyAlive = true) const;
+	void getAccessibilityMap(bool *accessibility, bool twoHex, bool attackerOwned, bool addOccupiable, std::set<int> & occupyable, bool flying, int stackToOmmit=-1) const; //send pointer to at least 187 allocated bytes
+	static bool isAccessible(int hex, bool * accessibility, bool twoHex, bool attackerOwned, bool flying, bool lastPos); //helper for makeBFS
+	void makeBFS(int start, bool*accessibility, int *predecessor, int *dists, bool twoHex, bool attackerOwned, bool flying, bool fillPredecessors) const; //*accessibility must be prepared bool[187] array; last two pointers must point to the at least 187-elements int arrays - there is written result
+	std::pair< std::vector<int>, int > getPath(int start, int dest, bool*accessibility, bool flyingCreature, bool twoHex, bool attackerOwned); //returned value: pair<path, length>; length may be different than number of elements in path since flying vreatures jump between distant hexes
+	std::vector<int> getAccessibility(int stackID, bool addOccupiable) const; //returns vector of accessible tiles (taking into account the creature range)
+
+	bool isStackBlocked(int ID); //returns true if there is neighboring enemy stack
+	static signed char mutualPosition(THex hex1, THex 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 si8 getDistance(THex hex1, THex hex2); //returns distance between given hexes
+	ui32 calculateDmg(const CStack* attacker, const CStack* defender, const CGHeroInstance * attackerHero, const CGHeroInstance * defendingHero, bool shooting, ui8 charge, bool lucky); //charge - number of hexes travelled before attack (for champion's jousting)
+	std::pair<ui32, ui32> calculateDmgRange(const CStack* attacker, const CStack* defender, const CGHeroInstance * attackerHero, const CGHeroInstance * defendingHero, bool shooting, ui8 charge, bool lucky); //charge - number of hexes travelled before attack (for champion's jousting); returns pair <min dmg, max dmg>
+	void calculateCasualties(std::map<ui32,si32> *casualties) const; //casualties are array of maps size 2 (attacker, defeneder), maps are (crid => amount)
+	std::set<CStack*> getAttackedCreatures(const CSpell * s, int skillLevel, ui8 attackerOwner, int destinationTile); //calculates stack affected by given spell
+	static int calculateSpellDuration(const CSpell * spell, const CGHeroInstance * caster, int usedSpellPower);
+	CStack * generateNewStack(const CStackInstance &base, int stackID, bool attackerOwned, int slot, int position) const; //helper for CGameHandler::setupBattle and spells addign new stacks to the battlefield
+	CStack * generateNewStack(const CStackBasicDescriptor &base, int stackID, bool attackerOwned, int slot, int position) const; //helper for CGameHandler::setupBattle and spells addign new stacks to the battlefield
+	ui32 getSpellCost(const CSpell * sp, const CGHeroInstance * caster) const; //returns cost of given spell
+	int hexToWallPart(int hex) const; //returns part of destructible wall / gate / keep under given hex or -1 if not found
+	int lineToWallHex(int line) const; //returns hex with wall in given line
+	std::pair<const CStack *, int> getNearestStack(const CStack * closest, boost::logic::tribool attackerOwned) const; //if attackerOwned is indetermnate, returened stack is of any owner; hex is the number of hex we should be looking from; returns (nerarest creature, predecessorHex)
+	ui32 calculateSpellBonus(ui32 baseDamage, const CSpell * sp, const CGHeroInstance * caster, const CStack * affectedCreature) const;
+	ui32 calculateSpellDmg(const CSpell * sp, const CGHeroInstance * caster, const CStack * affectedCreature, int spellSchoolLevel, int usedSpellPower) const; //calculates damage inflicted by spell
+	ui32 calculateHealedHP(const CGHeroInstance * caster, const CSpell * spell, const CStack * stack) const;
+	si8 hasDistancePenalty(int stackID, int destHex); //determines if given stack has distance penalty shooting given pos
+	si8 sameSideOfWall(int pos1, int pos2); //determines if given positions are on the same side of wall
+	si8 hasWallPenalty(int stackID, int destHex); //determines if given stack has wall penalty shooting given pos
+	si8 canTeleportTo(int stackID, int destHex, int telportLevel); //determines if given stack can teleport to given place
+	void localInit();
+	static BattleInfo * BattleInfo::setupBattle( int3 tile, int terrain, int terType, const CArmedInstance *armies[2], const CGHeroInstance * heroes[2], bool creatureBank, const CGTownInstance *town );
+};
+
+class DLL_EXPORT CStack : public CBonusSystemNode, public CStackBasicDescriptor
+{ 
+public:
+	const CStackInstance *base;
+
+	ui32 ID; //unique ID of stack
+	ui32 baseAmount;
+	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 attackerOwned; //if true, this stack is owned by attakcer (this one from left hand side of battle)
+	THex position; //position on battlefield; -2 - keep, -3 - lower tower, -4 - upper tower
+	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
+
+	std::set<ECombatInfo> state;
+	//overrides
+	const CCreature* getCreature() const {return type;}
+
+	CStack(const CStackInstance *base, int O, int I, bool AO, int S); //c-tor
+	CStack(const CStackBasicDescriptor *stack, int O, int I, bool AO, int S = 255); //c-tor
+	CStack(); //c-tor
+	~CStack();
+	std::string nodeName() const OVERRIDE;
+
+	void init(); //set initial (invalid) values
+	void postInit(); //used to finish initialization when inheriting creature parameters is working
+	const Bonus * getEffect(ui16 id, int turn = 0) const; //effect id (SP)
+	ui8 howManyEffectsSet(ui16 id) const; //returns amount of effects with given id set for this stack
+	bool willMove(int turn = 0) const; //if stack has remaining move this turn
+	bool moved(int turn = 0) const; //if stack was already moved this turn
+	bool canMove(int turn = 0) const; //if stack can move
+	ui32 Speed(int turn = 0) const; //get speed of creature with all modificators
+	BonusList getSpellBonuses() const;
+	void stackEffectToFeature(BonusList & sf, const Bonus & sse);
+	std::vector<si32> activeSpells() const; //returns vector of active spell IDs sorted by time of cast
+	const CGHeroInstance *getMyHero() const; //if stack belongs to hero (directly or was by him summoned) returns hero, NULL otherwise
+
+	static inline Bonus *featureGenerator(Bonus::BonusType type, si16 subtype, si32 value, ui16 turnsRemain, si32 additionalInfo = 0, si32 limit = Bonus::NO_LIMIT)
+	{
+		Bonus *hb = makeFeature(type, Bonus::N_TURNS, subtype, value, Bonus::SPELL_EFFECT, turnsRemain, additionalInfo);
+		hb->effectRange = limit;
+		hb->source = Bonus::CASTED_SPELL; //right?
+		return hb;
+	}
+
+	static inline Bonus *featureGeneratorVT(Bonus::BonusType type, si16 subtype, si32 value, ui16 turnsRemain, ui8 valType)
+	{
+		Bonus *ret(makeFeature(type, Bonus::N_TURNS, subtype, value, Bonus::SPELL_EFFECT, turnsRemain));
+		ret->valType = valType;
+		ret->source = Bonus::CASTED_SPELL; //right?
+		return ret;
+	}
+
+	bool doubleWide() const;
+	int occupiedHex() const; //returns number of occupied hex (not the position) if stack is double wide; otherwise -1
+
+	template <typename Handler> void serialize(Handler &h, const int version)
+	{
+		assert(isIndependentNode());
+		h & static_cast<CBonusSystemNode&>(*this);
+		h & static_cast<CStackBasicDescriptor&>(*this);
+		h & ID & baseAmount & firstHPleft & owner & slot & attackerOwned & position & state & counterAttacks
+			& shots & count;
+
+		TSlot slot = (base ? base->armyObj->findStack(base) : -1);
+		const CArmedInstance *army = (base ? base->armyObj : NULL);
+		if(h.saving)
+		{
+			h & army & slot;
+		}
+		else
+		{
+			h & army & slot;
+			if(!army || slot == -1 || !army->hasStackAtSlot(slot))
+			{
+				base = NULL;
+				tlog3 << type->nameSing << " don't have a base stack!\n";
+			}
+			else
+			{
+				base = &army->getStack(slot);
+			}
+		}
+
+	}
+	bool alive() const //determines if stack is alive
+	{
+		return vstd::contains(state,ALIVE);
+	}
+};
+
+class DLL_EXPORT CMP_stack
+{
+	int phase; //rules of which phase will be used
+	int turn;
+public:
+
+	bool operator ()(const CStack* a, const CStack* b);
+	CMP_stack(int Phase = 1, int Turn = 0);
+};

lib/CCreatureSet.h

@@ -115,7 +115,7 @@ public:
 	int getArmyStrength() const; //sum of AI values of creatures
 	ui64 getPower (TSlot slot) const; //value of specific stack
 	std::string getRoughAmount (TSlot slot) const; //rough size of specific stack
-	bool hasStackAtSlot(TSlot slot) const;
+	bool hasStackAtSlot(TSlot slot) const;
 	
 	bool contains(const CStackInstance *stack) const;
 	bool canBeMergedWith(const CCreatureSet &cs, bool allowMergingStacks = true) const;

lib/CGameState.h

@@ -177,192 +177,7 @@ public:
 
 };
 
-struct DLL_EXPORT CObstacleInstance
-{
-	int uniqueID;
-	int ID; //ID of obstacle (defines type of it)
-	int pos; //position on battlefield
-	template <typename Handler> void serialize(Handler &h, const int version)
-	{
-		h & ID & pos & uniqueID;
-	}
-};
 
-//only for use in BattleInfo
-struct DLL_EXPORT SiegeInfo
-{
-	ui8 wallState[8]; //[0] - keep, [1] - bottom tower, [2] - bottom wall, [3] - below gate, [4] - over gate, [5] - upper wall, [6] - uppert tower, [7] - gate; 1 - intact, 2 - damaged, 3 - destroyed
-
-	template <typename Handler> void serialize(Handler &h, const int version)
-	{
-		h & wallState;
-	}
-};
-
-struct DLL_EXPORT BattleInfo : public CBonusSystemNode
-{
-	ui8 side1, side2; //side1 - attacker, side2 - defender
-	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
-	si32 tid; //used during town siege - id of attacked town; -1 if not town defence
-	int3 tile; //for background and bonuses
-	CGHeroInstance *heroes[2];
-	CArmedInstance *belligerents[2]; //may be same as heroes
-	std::vector<CStack*> stacks;
-	std::vector<CObstacleInstance> obstacles;
-	ui8 castSpells[2]; //[0] - attacker, [1] - defender
-	SiegeInfo si;
-	si32 battlefieldType;
-
-	template <typename Handler> void serialize(Handler &h, const int version)
-	{
-		h & side1 & side2 & round & activeStack & siege & tid & tile & stacks & belligerents & obstacles
-			& castSpells & si & battlefieldType;
-		h & heroes;
-		h & static_cast<CBonusSystemNode&>(*this);
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	//void getBonuses(BonusList &out, const CSelector &selector, const CBonusSystemNode *root = NULL) const;
-	//////////////////////////////////////////////////////////////////////////
-
-	const CStack * getNextStack() const; //which stack will have turn after current one
-	void getStackQueue(std::vector<const CStack *> &out, int howMany, int turn = 0, int lastMoved = -1) const; //returns stack in order of their movement action
-	CStack * getStack(int stackID, bool onlyAlive = true);
-	const CStack * getStack(int stackID, bool onlyAlive = true) const;
-	CStack * getStackT(THex tileID, bool onlyAlive = true);
-	const CStack * getStackT(THex tileID, bool onlyAlive = true) const;
-	void getAccessibilityMap(bool *accessibility, bool twoHex, bool attackerOwned, bool addOccupiable, std::set<int> & occupyable, bool flying, int stackToOmmit=-1) const; //send pointer to at least 187 allocated bytes
-	static bool isAccessible(int hex, bool * accessibility, bool twoHex, bool attackerOwned, bool flying, bool lastPos); //helper for makeBFS
-	void makeBFS(int start, bool*accessibility, int *predecessor, int *dists, bool twoHex, bool attackerOwned, bool flying, bool fillPredecessors) const; //*accessibility must be prepared bool[187] array; last two pointers must point to the at least 187-elements int arrays - there is written result
-	std::pair< std::vector<int>, int > getPath(int start, int dest, bool*accessibility, bool flyingCreature, bool twoHex, bool attackerOwned); //returned value: pair<path, length>; length may be different than number of elements in path since flying vreatures jump between distant hexes
-	std::vector<int> getAccessibility(int stackID, bool addOccupiable) const; //returns vector of accessible tiles (taking into account the creature range)
-
-	bool isStackBlocked(int ID); //returns true if there is neighboring enemy stack
-	static signed char mutualPosition(THex hex1, THex 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 si8 getDistance(THex hex1, THex hex2); //returns distance between given hexes
-	ui32 calculateDmg(const CStack* attacker, const CStack* defender, const CGHeroInstance * attackerHero, const CGHeroInstance * defendingHero, bool shooting, ui8 charge, bool lucky); //charge - number of hexes travelled before attack (for champion's jousting)
-	std::pair<ui32, ui32> calculateDmgRange(const CStack* attacker, const CStack* defender, const CGHeroInstance * attackerHero, const CGHeroInstance * defendingHero, bool shooting, ui8 charge, bool lucky); //charge - number of hexes travelled before attack (for champion's jousting); returns pair <min dmg, max dmg>
-	void calculateCasualties(std::map<ui32,si32> *casualties) const; //casualties are array of maps size 2 (attacker, defeneder), maps are (crid => amount)
-	std::set<CStack*> getAttackedCreatures(const CSpell * s, int skillLevel, ui8 attackerOwner, int destinationTile); //calculates stack affected by given spell
-	static int calculateSpellDuration(const CSpell * spell, const CGHeroInstance * caster, int usedSpellPower);
-	CStack * generateNewStack(const CStackInstance &base, int stackID, bool attackerOwned, int slot, int position) const; //helper for CGameHandler::setupBattle and spells addign new stacks to the battlefield
-	CStack * generateNewStack(const CStackBasicDescriptor &base, int stackID, bool attackerOwned, int slot, int position) const; //helper for CGameHandler::setupBattle and spells addign new stacks to the battlefield
-	ui32 getSpellCost(const CSpell * sp, const CGHeroInstance * caster) const; //returns cost of given spell
-	int hexToWallPart(int hex) const; //returns part of destructible wall / gate / keep under given hex or -1 if not found
-	int lineToWallHex(int line) const; //returns hex with wall in given line
-	std::pair<const CStack *, int> getNearestStack(const CStack * closest, boost::logic::tribool attackerOwned) const; //if attackerOwned is indetermnate, returened stack is of any owner; hex is the number of hex we should be looking from; returns (nerarest creature, predecessorHex)
-	ui32 calculateSpellBonus(ui32 baseDamage, const CSpell * sp, const CGHeroInstance * caster, const CStack * affectedCreature) const;
-	ui32 calculateSpellDmg(const CSpell * sp, const CGHeroInstance * caster, const CStack * affectedCreature, int spellSchoolLevel, int usedSpellPower) const; //calculates damage inflicted by spell
-	ui32 calculateHealedHP(const CGHeroInstance * caster, const CSpell * spell, const CStack * stack) const;
-	si8 hasDistancePenalty(int stackID, int destHex); //determines if given stack has distance penalty shooting given pos
-	si8 sameSideOfWall(int pos1, int pos2); //determines if given positions are on the same side of wall
-	si8 hasWallPenalty(int stackID, int destHex); //determines if given stack has wall penalty shooting given pos
-	si8 canTeleportTo(int stackID, int destHex, int telportLevel); //determines if given stack can teleport to given place
-	void localInit();
-};
-
-class DLL_EXPORT CStack : public CBonusSystemNode, public CStackBasicDescriptor
-{ 
-public:
-	const CStackInstance *base;
-
-	ui32 ID; //unique ID of stack
-	ui32 baseAmount;
-	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 attackerOwned; //if true, this stack is owned by attakcer (this one from left hand side of battle)
-	THex position; //position on battlefield; -2 - keep, -3 - lower tower, -4 - upper tower
-	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
-
-	std::set<ECombatInfo> state;
-	//overrides
-	const CCreature* getCreature() const {return type;}
-
-	CStack(const CStackInstance *base, int O, int I, bool AO, int S); //c-tor
-	CStack(const CStackBasicDescriptor *stack, int O, int I, bool AO, int S = 255); //c-tor
-	CStack(); //c-tor
-	~CStack();
-	std::string nodeName() const OVERRIDE;
-
-	void init(); //set initial (invalid) values
-	void postInit(); //used to finish initialization when inheriting creature parameters is working
-	const Bonus * getEffect(ui16 id, int turn = 0) const; //effect id (SP)
-	ui8 howManyEffectsSet(ui16 id) const; //returns amount of effects with given id set for this stack
-	bool willMove(int turn = 0) const; //if stack has remaining move this turn
-	bool moved(int turn = 0) const; //if stack was already moved this turn
-	bool canMove(int turn = 0) const; //if stack can move
-	ui32 Speed(int turn = 0) const; //get speed of creature with all modificators
-	BonusList getSpellBonuses() const;
-	void stackEffectToFeature(BonusList & sf, const Bonus & sse);
-	std::vector<si32> activeSpells() const; //returns vector of active spell IDs sorted by time of cast
-	const CGHeroInstance *getMyHero() const; //if stack belongs to hero (directly or was by him summoned) returns hero, NULL otherwise
-
-	static inline Bonus *featureGenerator(Bonus::BonusType type, si16 subtype, si32 value, ui16 turnsRemain, si32 additionalInfo = 0, si32 limit = Bonus::NO_LIMIT)
-	{
-		Bonus *hb = makeFeature(type, Bonus::N_TURNS, subtype, value, Bonus::SPELL_EFFECT, turnsRemain, additionalInfo);
-		hb->effectRange = limit;
-		hb->source = Bonus::CASTED_SPELL; //right?
-		return hb;
-	}
-
-	static inline Bonus *featureGeneratorVT(Bonus::BonusType type, si16 subtype, si32 value, ui16 turnsRemain, ui8 valType)
-	{
-		Bonus *ret(makeFeature(type, Bonus::N_TURNS, subtype, value, Bonus::SPELL_EFFECT, turnsRemain));
-		ret->valType = valType;
-		ret->source = Bonus::CASTED_SPELL; //right?
-		return ret;
-	}
-
-	bool doubleWide() const;
-	int occupiedHex() const; //returns number of occupied hex (not the position) if stack is double wide; otherwise -1
-
-	template <typename Handler> void serialize(Handler &h, const int version)
-	{
-		assert(isIndependentNode());
-		h & static_cast<CBonusSystemNode&>(*this);
-		h & static_cast<CStackBasicDescriptor&>(*this);
-		h & ID & baseAmount & firstHPleft & owner & slot & attackerOwned & position & state & counterAttacks
-			& shots & count;
-
-		TSlot slot = (base ? base->armyObj->findStack(base) : -1);
-		const CArmedInstance *army = (base ? base->armyObj : NULL);
-		if(h.saving)
-		{
-			h & army & slot;
-		}
-		else
-		{
-			h & army & slot;
-			if(!army || slot == -1 || !army->hasStackAtSlot(slot))
-			{
-				base = NULL;
-				tlog3 << type->nameSing << " don't have a base stack!\n";
-			}
-			else
-			{
-				base = &army->getStack(slot);
-			}
-		}
-
-	}
-	bool alive() const //determines if stack is alive
-	{
-		return vstd::contains(state,ALIVE);
-	}
-};
-
-class DLL_EXPORT CMP_stack
-{
-	int phase; //rules of which phase will be used
-	int turn;
-public:
-
-	bool operator ()(const CStack* a, const CStack* b);
-	CMP_stack(int Phase = 1, int Turn = 0);
-};
 
 struct UpgradeInfo
 {
@@ -432,6 +247,8 @@ struct DLL_EXPORT CPathsInfo
 	~CPathsInfo();
 };
 
+class BattleInfo;
+
 class DLL_EXPORT CGameState
 {
 public:

lib/CHeroHandler.h

@@ -26,6 +26,10 @@ struct SSpecialtyInfo
 	si32 val;
 	si32 subtype;
 	si32 additionalinfo;
+	template <typename Handler> void serialize(Handler &h, const int version)
+	{
+		h & type & val & subtype & additionalinfo;
+	}
 };
 
 class DLL_EXPORT CHero
@@ -52,7 +56,7 @@ public:
 
 	template <typename Handler> void serialize(Handler &h, const int version)
 	{
-		h & name & ID & lowStack & highStack & refTypeStack	& heroType & startingSpell & heroClass;
+		h & name & ID & lowStack & highStack & refTypeStack	& heroClass & heroType & secSkillsInit & spec & startingSpell & sex;
 	}
 };
 

lib/NetPacks.h

@@ -1,7 +1,6 @@
 #ifndef __NETPACKS_H__
 #define __NETPACKS_H__
 #include "../global.h"
-#include "CGameState.h"
 #include "BattleAction.h"
 #include "HeroBonus.h"
 #include <set>
@@ -27,6 +26,7 @@ class CConnection;
 class CCampaignState;
 class CArtifact;
 class CSelectionScreen;
+class CGObjectInstance;
 //class CMapInfo;
 
 struct CPack

lib/NetPacksLib.cpp

@@ -15,6 +15,8 @@
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/thread.hpp>
 #include <boost/thread/shared_mutex.hpp>
+#include "CGameState.h"
+#include "BattleState.h"
 
 #undef min
 #undef max

server/CGameHandler.cpp

@@ -11,6 +11,7 @@
 #include "../lib/CTownHandler.h"
 #include "../lib/CCreatureHandler.h"
 #include "../lib/CGameState.h"
+#include "../lib/BattleState.h"
 #include "../lib/CondSh.h"
 #include "../lib/NetPacks.h"
 #include "../lib/VCMI_Lib.h"

server/NetPacksServer.cpp

@@ -4,6 +4,8 @@
 #include "../lib/CObjectHandler.h"
 #include "../lib/IGameCallback.h"
 #include "../lib/map.h"
+#include "../lib/CGameState.h"
+#include "../lib/BattleState.h"
 
 
 #define PLAYER_OWNS(id) (gh->getPlayerAt(c)==gh->getOwner(id))