2011-12-14 00:23:17 +03:00
# pragma once
2014-01-16 23:24:06 +03:00
# include "NetPacksBase.h"
2008-09-29 00:01:49 +03:00
# include "BattleAction.h"
2014-06-25 17:11:07 +03:00
//#include "HeroBonus.h"
2014-06-05 19:52:14 +03:00
# include "mapObjects/CGHeroInstance.h"
2014-06-25 17:11:07 +03:00
//#include "CCreatureSet.h"
//#include "mapping/CMapInfo.h"
//#include "StartInfo.h"
2010-12-14 23:55:23 +02:00
# include "ConstTransitivePtr.h"
2011-12-14 00:23:17 +03:00
# include "int3.h"
2011-07-05 09:14:07 +03:00
# include "ResourceSet.h"
2014-06-25 17:11:07 +03:00
//#include "CObstacleInstance.h"
# include "CGameStateFwd.h"
# include "mapping/CMap.h"
2012-05-05 00:16:39 +03:00
# include "CObstacleInstance.h"
2009-02-04 15:40:54 +02:00
2009-04-15 17:03:31 +03:00
/*
* NetPacks . 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
*
*/
2009-03-07 00:11:17 +02:00
class CClient ;
class CGameState ;
2009-03-09 12:37:49 +02:00
class CGameHandler ;
class CConnection ;
2010-08-20 16:34:39 +03:00
class CCampaignState ;
2010-06-26 19:02:10 +03:00
class CArtifact ;
2010-09-03 21:42:54 +03:00
class CSelectionScreen ;
2010-12-25 21:23:30 +02:00
class CGObjectInstance ;
2010-12-26 16:34:11 +02:00
class CArtifactInstance ;
2010-10-25 22:37:21 +03:00
//class CMapInfo;
2012-05-18 17:02:27 +03:00
struct StackLocation ;
2010-12-26 16:34:11 +02:00
struct ArtSlotInfo ;
2012-05-16 20:29:05 +03:00
struct QuestInfo ;
2014-06-25 17:11:07 +03:00
class CMapInfo ;
class StartInfo ;
2009-03-07 00:11:17 +02:00
2013-12-08 20:54:13 +03:00
2009-03-07 00:11:17 +02:00
struct CPackForClient : public CPack
2008-07-26 16:57:32 +03:00
{
2009-03-09 12:37:49 +02:00
CPackForClient ( ) { type = 1 ; } ;
2009-03-07 00:11:17 +02:00
2009-03-09 12:37:49 +02:00
CGameState * GS ( CClient * cl ) ;
2009-03-07 00:25:19 +02:00
void applyFirstCl ( CClient * cl ) //called before applying to gs
2014-02-19 04:04:27 +03:00
{ }
2009-03-07 00:25:19 +02:00
void applyCl ( CClient * cl ) //called after applying to gs
2014-02-19 04:04:27 +03:00
{ }
2009-03-09 12:37:49 +02:00
} ;
struct CPackForServer : public CPack
{
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-03-09 12:37:49 +02:00
CConnection * c ;
CGameState * GS ( CGameHandler * gh ) ;
2013-11-07 15:48:41 +03:00
CPackForServer ( ) :
player ( PlayerColor : : NEUTRAL ) ,
c ( nullptr )
2009-03-07 00:25:19 +02:00
{
2012-09-15 22:16:16 +03:00
type = 2 ;
2013-11-07 15:48:41 +03:00
}
2009-03-09 12:37:49 +02:00
2014-02-19 04:04:27 +03:00
bool applyGh ( CGameHandler * gh ) //called after applying to gs
{
logGlobal - > errorStream ( ) < < " Should not happen... applying plain CPackForServer " ;
return false ;
}
2008-07-26 16:57:32 +03:00
} ;
2009-03-07 00:11:17 +02:00
2009-03-09 12:37:49 +02:00
2009-03-07 00:11:17 +02:00
struct Query : public CPackForClient
2008-08-13 03:44:31 +03:00
{
2013-05-27 13:53:28 +03:00
QueryID queryID ; // equals to -1 if it is not an actual query (and should not be answered)
2012-09-15 22:16:16 +03:00
2012-07-15 18:34:00 +03:00
Query ( )
{
}
2008-08-13 03:44:31 +03:00
} ;
2009-02-03 07:28:05 +02:00
2009-07-09 22:15:22 +03:00
2009-02-03 07:28:05 +02:00
2012-05-18 17:02:27 +03:00
struct StackLocation
{
ConstTransitivePtr < CArmedInstance > army ;
2013-02-16 17:03:47 +03:00
SlotID slot ;
2012-05-18 17:02:27 +03:00
StackLocation ( )
2013-02-16 17:03:47 +03:00
{ }
2013-11-07 15:48:41 +03:00
StackLocation ( const CArmedInstance * Army , SlotID Slot ) :
army ( const_cast < CArmedInstance * > ( Army ) ) , //we are allowed here to const cast -> change will go through one of our packages... do not abuse!
slot ( Slot )
2012-05-18 17:02:27 +03:00
{
}
2012-08-30 19:01:19 +03:00
2012-05-18 17:02:27 +03:00
DLL_LINKAGE const CStackInstance * getStack ( ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & army & slot ;
}
} ;
2009-03-09 12:37:49 +02:00
/***********************************************************************************************************/
2011-05-22 21:46:52 +03:00
2009-04-16 03:28:54 +03:00
struct PackageApplied : public CPackForClient //94
{
PackageApplied ( ) { type = 94 ; }
PackageApplied ( ui8 Result ) : result ( Result ) { type = 94 ; }
void applyCl ( CClient * cl ) ;
ui8 result ; //0 - something went wrong, request hasn't been realized; 1 - OK
ui32 packType ; //type id of applied package
2012-03-26 01:46:14 +03:00
ui32 requestID ; //an ID given by client to the request that was applied
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-04-16 03:28:54 +03:00
2012-07-15 18:34:00 +03:00
2009-04-16 03:28:54 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2012-03-26 01:46:14 +03:00
h & result & packType & requestID & player ;
2009-04-16 03:28:54 +03:00
}
} ;
2009-03-07 00:11:17 +02:00
struct SystemMessage : public CPackForClient //95
2008-07-26 09:39:44 +03:00
{
2012-09-26 16:13:39 +03:00
SystemMessage ( const std : : string & Text ) : text ( Text ) { type = 95 ; } ;
2009-03-07 00:11:17 +02:00
SystemMessage ( ) { type = 95 ; } ;
void applyCl ( CClient * cl ) ;
2008-07-26 09:39:44 +03:00
2009-03-07 00:11:17 +02:00
std : : string text ;
2009-03-07 00:25:19 +02:00
2008-07-26 09:39:44 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2009-03-07 00:25:19 +02:00
h & text ;
2008-07-26 09:39:44 +03:00
}
2008-08-10 07:46:16 +03:00
} ;
2009-03-07 00:11:17 +02:00
2009-08-04 02:53:18 +03:00
struct PlayerBlocked : public CPackForClient //96
{
PlayerBlocked ( ) { type = 96 ; } ;
void applyCl ( CClient * cl ) ;
2013-09-28 02:46:58 +03:00
enum EReason { UPCOMING_BATTLE , ONGOING_MOVEMENT } ;
enum EMode { BLOCKADE_STARTED , BLOCKADE_ENDED } ;
2013-02-14 02:55:42 +03:00
EReason reason ;
2013-09-28 02:46:58 +03:00
EMode startOrEnd ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-08-04 02:53:18 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2013-09-28 02:46:58 +03:00
h & reason & startOrEnd & player ;
2009-08-04 02:53:18 +03:00
}
} ;
2009-03-07 00:11:17 +02:00
struct YourTurn : public CPackForClient //100
{
YourTurn ( ) { type = 100 ; } ;
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2008-07-26 09:39:44 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2009-03-07 00:25:19 +02:00
h & player ;
2008-07-26 09:39:44 +03:00
}
2008-08-10 07:46:16 +03:00
} ;
2009-03-07 00:11:17 +02:00
struct SetResource : public CPackForClient //102
2008-07-31 00:27:15 +03:00
{
SetResource ( ) { type = 102 ; } ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2008-07-31 00:27:15 +03:00
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2013-02-04 22:43:16 +03:00
Res : : ERes resid ;
2012-01-26 19:48:53 +03:00
TResourceCap val ;
2008-07-31 00:27:15 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & player & resid & val ;
}
2012-09-15 22:16:16 +03:00
} ;
2009-11-28 03:42:08 +02:00
struct SetResources : public CPackForClient //104
{
2011-07-05 09:14:07 +03:00
SetResources ( ) { type = 104 ; } ;
2009-11-28 03:42:08 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2012-09-15 22:16:16 +03:00
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2011-07-05 09:14:07 +03:00
TResources res ; //res[resid] => res amount
2012-09-15 22:16:16 +03:00
2009-11-28 03:42:08 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & player & res ;
}
} ;
2009-03-07 00:11:17 +02:00
struct SetPrimSkill : public CPackForClient //105
2008-08-04 18:56:36 +03:00
{
SetPrimSkill ( ) { type = 105 ; } ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2008-08-04 18:56:36 +03:00
ui8 abs ; //0 - changes by value; 1 - sets to value
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ;
2013-02-04 22:43:16 +03:00
PrimarySkill : : PrimarySkill which ;
2009-08-16 18:39:18 +03:00
si64 val ;
2008-08-04 18:56:36 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & abs & id & which & val ;
}
2012-09-15 22:16:16 +03:00
} ;
2009-03-07 00:11:17 +02:00
struct SetSecSkill : public CPackForClient //106
2008-08-13 03:44:31 +03:00
{
SetSecSkill ( ) { type = 106 ; } ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2008-08-13 03:44:31 +03:00
ui8 abs ; //0 - changes by value; 1 - sets to value
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ;
2013-02-12 22:49:40 +03:00
SecondarySkill which ;
2013-02-04 22:43:16 +03:00
ui16 val ;
2008-08-13 03:44:31 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & abs & id & which & val ;
}
2012-05-07 15:54:22 +03:00
} ;
2009-03-07 00:11:17 +02:00
struct HeroVisitCastle : public CPackForClient //108
2008-08-13 12:28:06 +03:00
{
HeroVisitCastle ( ) { flags = 0 ; type = 108 ; } ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2011-02-04 16:58:14 +02:00
ui8 flags ; //1 - start
2013-02-14 02:55:42 +03:00
ObjectInstanceID tid , hid ;
2008-08-13 12:28:06 +03:00
bool start ( ) //if hero is entering castle (if false - leaving)
{
return flags & 1 ;
}
2011-02-04 16:58:14 +02:00
// bool garrison() //if hero is entering/leaving garrison (if false - it's only visiting hero)
// {
// return flags & 2;
// }
2008-08-13 12:28:06 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & flags & tid & hid ;
}
2012-09-15 22:16:16 +03:00
} ;
2009-03-07 00:11:17 +02:00
struct ChangeSpells : public CPackForClient //109
2008-09-12 11:51:46 +03:00
{
ChangeSpells ( ) { type = 109 ; } ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2008-09-12 11:51:46 +03:00
ui8 learn ; //1 - gives spell, 0 - takes
2013-02-14 02:55:42 +03:00
ObjectInstanceID hid ;
2013-02-11 02:24:57 +03:00
std : : set < SpellID > spells ;
2008-09-12 11:51:46 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & learn & hid & spells ;
}
2012-09-15 22:16:16 +03:00
} ;
2008-10-19 02:20:48 +03:00
2009-03-07 00:11:17 +02:00
struct SetMana : public CPackForClient //110
2008-10-19 02:20:48 +03:00
{
SetMana ( ) { type = 110 ; } ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID hid ;
si32 val ;
2008-10-19 02:20:48 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & val & hid ;
}
2011-01-20 19:25:15 +02:00
} ;
2009-03-07 00:11:17 +02:00
struct SetMovePoints : public CPackForClient //111
2008-10-19 02:20:48 +03:00
{
SetMovePoints ( ) { type = 111 ; } ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID hid ;
si32 val ;
2008-10-19 02:20:48 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & val & hid ;
}
2011-01-20 19:25:15 +02:00
} ;
2009-03-07 00:11:17 +02:00
struct FoWChange : public CPackForClient //112
2008-10-19 02:20:48 +03:00
{
2014-06-21 16:41:05 +03:00
FoWChange ( ) { type = 112 ; waitForDialogs = false ; } ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-06-29 16:05:48 +03:00
std : : unordered_set < int3 , struct ShashInt3 > tiles ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
ui8 mode ; //mode==0 - hide, mode==1 - reveal
2014-06-21 16:41:05 +03:00
bool waitForDialogs ;
2008-10-19 02:20:48 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2014-06-21 16:41:05 +03:00
h & tiles & player & mode & waitForDialogs ;
2008-10-19 02:20:48 +03:00
}
2012-09-15 22:16:16 +03:00
} ;
2008-10-26 22:58:34 +02:00
2009-03-07 00:11:17 +02:00
struct SetAvailableHeroes : public CPackForClient //113
2008-10-26 22:58:34 +02:00
{
2010-07-08 08:52:11 +03:00
SetAvailableHeroes ( )
{
type = 113 ;
2011-12-14 00:23:17 +03:00
for ( int i = 0 ; i < GameConstants : : AVAILABLE_HEROES_PER_PLAYER ; i + + )
2011-01-28 04:11:58 +02:00
army [ i ] . clear ( ) ;
2010-07-08 08:52:11 +03:00
}
~ SetAvailableHeroes ( )
{
}
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2011-12-14 00:23:17 +03:00
si32 hid [ GameConstants : : AVAILABLE_HEROES_PER_PLAYER ] ; //-1 if no hero
CSimpleArmy army [ GameConstants : : AVAILABLE_HEROES_PER_PLAYER ] ;
2008-10-26 22:58:34 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2010-07-08 08:52:11 +03:00
h & player & hid & army ;
2008-10-26 22:58:34 +02:00
}
} ;
2009-03-07 00:11:17 +02:00
struct GiveBonus : public CPackForClient //115
2009-02-03 07:28:05 +02:00
{
2010-02-10 04:56:00 +02:00
GiveBonus ( ui8 Who = 0 )
{
2012-09-15 22:16:16 +03:00
who = Who ;
2010-02-10 04:56:00 +02:00
type = 115 ;
}
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-02-03 07:28:05 +02:00
2010-06-07 08:28:12 +03:00
enum { HERO , PLAYER , TOWN } ;
2010-02-10 04:56:00 +02:00
ui8 who ; //who receives bonus, uses enum above
2013-02-14 02:55:42 +03:00
si32 id ; //hero. town or player id - whoever receives it
2010-05-02 21:20:26 +03:00
Bonus bonus ;
2009-02-03 07:28:05 +02:00
MetaString bdescr ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
2010-02-10 04:56:00 +02:00
h & bonus & id & bdescr & who ;
2009-02-03 07:28:05 +02:00
}
} ;
2009-03-07 00:11:17 +02:00
struct ChangeObjPos : public CPackForClient //116
2009-02-20 12:36:15 +02:00
{
2010-03-11 01:16:30 +02:00
ChangeObjPos ( )
{
2012-09-15 22:16:16 +03:00
type = 116 ;
2010-03-11 01:16:30 +02:00
flags = 0 ;
}
2009-03-07 00:11:17 +02:00
void applyFirstCl ( CClient * cl ) ;
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-02-20 12:36:15 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID objid ;
2009-02-20 12:36:15 +02:00
int3 nPos ;
ui8 flags ; //bit flags: 1 - redraw
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & objid & nPos & flags ;
}
} ;
2010-01-29 22:52:45 +02:00
struct PlayerEndsGame : public CPackForClient //117
{
PlayerEndsGame ( )
{
type = 117 ;
}
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-01-29 22:52:45 +02:00
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2013-11-17 20:57:04 +03:00
EVictoryLossCheckResult victoryLossCheckResult ;
2010-01-29 22:52:45 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2013-11-17 20:57:04 +03:00
h & player & victoryLossCheckResult ;
2010-01-29 22:52:45 +02:00
}
} ;
2010-02-10 04:56:00 +02:00
struct RemoveBonus : public CPackForClient //118
{
RemoveBonus ( ui8 Who = 0 )
{
2012-09-15 22:16:16 +03:00
who = Who ;
2010-02-10 04:56:00 +02:00
type = 118 ;
}
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-02-10 04:56:00 +02:00
2010-06-13 16:59:59 +03:00
enum { HERO , PLAYER , TOWN } ;
2010-02-10 04:56:00 +02:00
ui8 who ; //who receives bonus, uses enum above
2010-06-13 16:59:59 +03:00
ui32 whoID ; //hero, town or player id - whoever loses bonus
2010-02-10 04:56:00 +02:00
//vars to identify bonus: its source
ui8 source ;
ui32 id ; //source id
//used locally: copy of removed bonus
2010-05-02 21:20:26 +03:00
Bonus bonus ;
2010-02-10 04:56:00 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & source & id & who & whoID ;
}
} ;
2010-08-20 16:34:39 +03:00
struct UpdateCampaignState : public CPackForClient //119
{
UpdateCampaignState ( )
{
type = 119 ;
}
2012-09-21 20:59:54 +03:00
shared_ptr < CCampaignState > camp ;
2010-08-20 16:34:39 +03:00
void applyCl ( CClient * cl ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & camp ;
}
} ;
2012-05-18 17:02:27 +03:00
struct SetCommanderProperty : public CPackForClient //120
2012-05-07 15:54:22 +03:00
{
2012-05-18 22:44:15 +03:00
enum ECommanderProperty { ALIVE , BONUS , SECONDARY_SKILL , EXPERIENCE , SPECIAL_SKILL } ;
2012-05-07 15:54:22 +03:00
2012-05-18 17:02:27 +03:00
SetCommanderProperty ( ) { type = 120 ; } ;
2012-05-07 15:54:22 +03:00
void applyCl ( CClient * cl ) { } ;
2012-05-18 17:02:27 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2013-02-14 02:55:42 +03:00
ObjectInstanceID heroid ; //for commander attached to hero
2012-05-18 17:02:27 +03:00
StackLocation sl ; //for commander not on the hero?
2012-05-07 15:54:22 +03:00
2013-02-04 22:43:16 +03:00
ECommanderProperty which ;
2012-09-23 21:01:04 +03:00
TExpType amount ; //0 for dead, >0 for alive
2012-05-18 17:02:27 +03:00
si32 additionalInfo ; //for secondary skills choice
2012-05-07 15:54:22 +03:00
Bonus accumulatedBonus ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
2012-05-18 17:02:27 +03:00
h & heroid & sl & which & amount & additionalInfo & accumulatedBonus ;
2012-05-07 15:54:22 +03:00
}
2012-05-16 20:29:05 +03:00
} ;
struct AddQuest : public CPackForClient //121
{
AddQuest ( ) { type = 121 ; } ;
void applyCl ( CClient * cl ) { } ;
2012-07-06 22:12:04 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2012-05-16 20:29:05 +03:00
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2012-05-16 20:29:05 +03:00
QuestInfo quest ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & player & quest ;
}
} ;
2010-08-20 16:34:39 +03:00
2013-02-09 21:18:55 +03:00
struct PrepareForAdvancingCampaign : public CPackForClient //122
{
PrepareForAdvancingCampaign ( ) { type = 122 ; }
void applyCl ( CClient * cl ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
}
} ;
2013-02-19 01:37:22 +03:00
struct UpdateArtHandlerLists : public CPackForClient //123
{
UpdateArtHandlerLists ( ) { type = 123 ; } ;
std : : vector < CArtifact * > treasures , minors , majors , relics ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & treasures & minors & majors & relics ;
}
} ;
struct UpdateMapEvents : public CPackForClient //124
{
UpdateMapEvents ( ) { type = 124 ; }
std : : list < CMapEvent > events ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & events ;
}
} ;
struct UpdateCastleEvents : public CPackForClient //125
{
UpdateCastleEvents ( ) { type = 125 ; }
ObjectInstanceID town ;
std : : list < CCastleEvent > events ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & town & events ;
}
} ;
2009-03-07 00:11:17 +02:00
struct RemoveObject : public CPackForClient //500
2008-08-02 00:41:38 +03:00
{
2008-08-13 07:41:11 +03:00
RemoveObject ( ) { type = 500 ; } ;
2013-02-14 02:55:42 +03:00
RemoveObject ( ObjectInstanceID ID ) { id = ID ; type = 500 ; } ;
2009-03-07 00:11:17 +02:00
void applyFirstCl ( CClient * cl ) ;
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ;
2008-08-02 00:41:38 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & id ;
}
2012-09-15 22:16:16 +03:00
} ;
2009-03-07 00:11:17 +02:00
struct TryMoveHero : public CPackForClient //501
2008-07-28 15:44:08 +03:00
{
2013-04-20 14:34:01 +03:00
TryMoveHero ( ) { type = 501 ; humanKnows = false ; } ;
2009-03-07 00:11:17 +02:00
void applyFirstCl ( CClient * cl ) ;
void applyCl ( CClient * cl ) ;
2009-03-07 17:54:12 +02:00
void applyGs ( CGameState * gs ) ;
2008-07-28 15:44:08 +03:00
2009-07-03 22:57:14 +03:00
enum EResult
{
2009-07-19 04:00:19 +03:00
FAILED , SUCCESS , TELEPORTATION , RESERVED___ , BLOCKING_VISIT , EMBARK , DISEMBARK
2009-07-03 22:57:14 +03:00
} ;
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ;
ui32 movePoints ;
2013-02-04 22:43:16 +03:00
EResult result ; //uses EResult
2010-03-21 00:17:19 +02:00
int3 start , end ; //h3m format
2013-06-29 16:05:48 +03:00
std : : unordered_set < int3 , ShashInt3 > fowRevealed ; //revealed tiles
2013-04-20 14:34:01 +03:00
boost : : optional < int3 > attackedFrom ; // Set when stepping into endangered tile.
2008-07-28 15:44:08 +03:00
2009-12-28 06:08:24 +02:00
bool humanKnows ; //used locally during applying to client
2008-07-28 15:44:08 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2010-05-06 15:13:31 +03:00
h & id & result & start & end & movePoints & fowRevealed & attackedFrom ;
2008-07-28 15:44:08 +03:00
}
2010-11-27 03:46:19 +02:00
} ;
2010-12-06 01:10:02 +02:00
// struct SetGarrisons : public CPackForClient //502
// {
// SetGarrisons(){type = 502;};
// void applyCl(CClient *cl);
2011-12-14 00:23:17 +03:00
// DLL_LINKAGE void applyGs(CGameState *gs);
2012-09-15 22:16:16 +03:00
//
2010-12-06 01:10:02 +02:00
// std::map<ui32,CCreatureSet> garrs;
2012-09-15 22:16:16 +03:00
//
2010-12-06 01:10:02 +02:00
// template <typename Handler> void serialize(Handler &h, const int version)
// {
// h & garrs;
// }
2012-09-15 22:16:16 +03:00
// };
2009-03-07 00:11:17 +02:00
struct NewStructures : public CPackForClient //504
2008-08-01 14:21:15 +03:00
{
2008-08-10 07:46:16 +03:00
NewStructures ( ) { type = 504 ; } ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2012-09-15 22:16:16 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID tid ;
2013-02-11 22:11:34 +03:00
std : : set < BuildingID > bid ;
2012-09-15 22:16:16 +03:00
si16 builded ;
2008-08-01 14:21:15 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2008-08-10 07:46:16 +03:00
h & tid & bid & builded ;
2008-08-01 14:21:15 +03:00
}
2009-09-22 17:27:46 +03:00
} ;
2009-09-24 20:54:02 +03:00
struct RazeStructures : public CPackForClient //505
2009-09-22 17:27:46 +03:00
{
RazeStructures ( ) { type = 505 ; } ;
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-09-22 17:27:46 +03:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID tid ;
2013-02-11 22:11:34 +03:00
std : : set < BuildingID > bid ;
2012-09-15 22:16:16 +03:00
si16 destroyed ;
2009-09-24 20:54:02 +03:00
2009-09-22 17:27:46 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2009-09-24 20:54:02 +03:00
h & tid & bid & destroyed ;
2009-09-22 17:27:46 +03:00
}
} ;
2009-03-07 00:11:17 +02:00
struct SetAvailableCreatures : public CPackForClient //506
2008-08-01 14:21:15 +03:00
{
2008-08-10 07:46:16 +03:00
SetAvailableCreatures ( ) { type = 506 ; } ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID tid ;
2013-02-11 02:24:57 +03:00
std : : vector < std : : pair < ui32 , std : : vector < CreatureID > > > creatures ;
2008-08-01 14:21:15 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2008-08-10 07:46:16 +03:00
h & tid & creatures ;
}
2012-09-15 22:16:16 +03:00
} ;
2009-03-07 00:11:17 +02:00
struct SetHeroesInTown : public CPackForClient //508
2008-08-16 11:47:41 +03:00
{
SetHeroesInTown ( ) { type = 508 ; } ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID tid , visiting , garrison ; //id of town, visiting hero, hero in garrison
2008-08-16 11:47:41 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & tid & visiting & garrison ;
}
2010-12-06 01:10:02 +02:00
} ;
2010-12-17 00:32:53 +02:00
2011-01-18 20:56:14 +02:00
// struct SetHeroArtifacts : public CPackForClient //509
// {
// SetHeroArtifacts(){type = 509;};
// void applyCl(CClient *cl);
2011-12-14 00:23:17 +03:00
// DLL_LINKAGE void applyGs(CGameState *gs);
// DLL_LINKAGE void setArtAtPos(ui16 pos, const CArtifact* art);
2012-09-15 22:16:16 +03:00
//
2011-01-18 20:56:14 +02:00
// si32 hid;
// std::vector<const CArtifact*> artifacts; //hero's artifacts from bag
// std::map<ui16, const CArtifact*> 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
2012-09-15 22:16:16 +03:00
//
2011-01-18 20:56:14 +02:00
// template <typename Handler> void serialize(Handler &h, const int version)
// {
// h & hid & artifacts & artifWorn;
// }
2012-09-15 22:16:16 +03:00
//
2011-09-24 04:15:36 +03:00
// std::vector<const CArtifact*> equipped, unequipped; //used locally
2011-01-18 20:56:14 +02:00
// BonusList gained, lost; //used locally as hlp when applying
2012-09-15 22:16:16 +03:00
// };
2008-12-27 03:01:59 +02:00
2009-03-07 00:11:17 +02:00
struct HeroRecruited : public CPackForClient //515
2008-10-26 22:58:34 +02:00
{
HeroRecruited ( ) { type = 515 ; } ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
si32 hid ; //subID of hero
ObjectInstanceID tid ;
2008-10-26 22:58:34 +02:00
int3 tile ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2008-10-26 22:58:34 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & hid & tid & tile & player ;
}
2012-09-15 22:16:16 +03:00
} ;
2009-02-14 21:12:40 +02:00
2009-03-07 00:11:17 +02:00
struct GiveHero : public CPackForClient //516
2009-02-14 21:12:40 +02:00
{
GiveHero ( ) { type = 516 ; } ;
2009-03-07 00:11:17 +02:00
void applyFirstCl ( CClient * cl ) ;
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ; //object id
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-02-14 21:12:40 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & id & player ;
}
2012-09-15 22:16:16 +03:00
} ;
2009-02-14 21:12:40 +02:00
2009-07-06 22:41:27 +03:00
struct OpenWindow : public CPackForClient //517
2009-06-16 14:18:14 +03:00
{
2009-07-06 22:41:27 +03:00
OpenWindow ( ) { type = 517 ; } ;
2009-06-16 14:18:14 +03:00
void applyCl ( CClient * cl ) ;
2010-07-22 03:32:45 +03:00
enum EWindow { EXCHANGE_WINDOW , RECRUITMENT_FIRST , RECRUITMENT_ALL , SHIPYARD_WINDOW , THIEVES_GUILD ,
UNIVERSITY_WINDOW , HILL_FORT_WINDOW , MARKET_WINDOW , PUZZLE_MAP , TAVERN_WINDOW } ;
2009-07-06 22:41:27 +03:00
ui8 window ;
2013-02-14 02:55:42 +03:00
si32 id1 , id2 ;
2009-06-16 14:18:14 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2009-07-06 22:41:27 +03:00
h & window & id1 & id2 ;
2009-06-16 14:18:14 +03:00
}
} ;
2009-07-26 06:33:13 +03:00
struct NewObject : public CPackForClient //518
{
2011-05-28 04:02:28 +03:00
NewObject ( )
{
type = 518 ;
}
2009-07-26 06:33:13 +03:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-07-26 06:33:13 +03:00
2013-02-11 02:24:57 +03:00
Obj ID ;
2013-02-07 20:34:50 +03:00
ui32 subID ;
2009-07-26 06:33:13 +03:00
int3 pos ;
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ; //used locally, filled during applyGs
2009-07-26 06:33:13 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & ID & subID & pos ;
}
} ;
2010-06-26 19:02:10 +03:00
struct SetAvailableArtifacts : public CPackForClient //519
{
SetAvailableArtifacts ( ) { type = 519 ; } ;
2010-06-27 19:03:01 +03:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-06-26 19:02:10 +03:00
si32 id ; //two variants: id < 0: set artifact pool for Artifact Merchants in towns; id >= 0: set pool for adv. map Black Market (id is the id of Black Market instance then)
std : : vector < const CArtifact * > arts ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & id & arts ;
}
} ;
2010-12-17 00:32:53 +02:00
struct NewArtifact : public CPackForClient //520
2010-11-10 02:06:25 +02:00
{
NewArtifact ( ) { type = 520 ; } ;
//void applyCl(CClient *cl);
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-11-10 02:06:25 +02:00
2010-12-26 16:34:11 +02:00
ConstTransitivePtr < CArtifactInstance > art ;
2010-11-10 02:06:25 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2010-12-26 16:34:11 +02:00
h & art ;
2010-11-10 02:06:25 +02:00
}
} ;
2010-11-27 22:17:28 +02:00
struct CGarrisonOperationPack : CPackForClient
{
} ;
2011-01-22 05:43:20 +02:00
struct CArtifactOperationPack : CPackForClient
{
} ;
2010-11-27 22:17:28 +02:00
struct ChangeStackCount : CGarrisonOperationPack //521
2010-11-27 03:46:19 +02:00
{
StackLocation sl ;
TQuantity count ;
ui8 absoluteValue ; //if not -> count will be added (or subtracted if negative)
2010-11-27 22:17:28 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-11-27 03:46:19 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2010-12-12 01:11:26 +02:00
h & sl & count & absoluteValue ;
2010-11-27 03:46:19 +02:00
}
} ;
2010-11-27 22:17:28 +02:00
struct SetStackType : CGarrisonOperationPack //522
2010-11-27 03:46:19 +02:00
{
StackLocation sl ;
CCreature * type ;
2010-11-27 22:17:28 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-11-27 03:46:19 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & sl & type ;
}
} ;
2010-11-27 22:17:28 +02:00
struct EraseStack : CGarrisonOperationPack //523
2010-11-27 03:46:19 +02:00
{
StackLocation sl ;
2010-11-27 22:17:28 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-11-27 03:46:19 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & sl ;
}
} ;
2010-11-27 22:17:28 +02:00
struct SwapStacks : CGarrisonOperationPack //524
2010-11-27 03:46:19 +02:00
{
StackLocation sl1 , sl2 ;
2010-11-27 22:17:28 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-11-27 03:46:19 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & sl1 & sl2 ;
}
} ;
2010-11-27 22:17:28 +02:00
struct InsertNewStack : CGarrisonOperationPack //525
2010-11-27 03:46:19 +02:00
{
StackLocation sl ;
2010-12-06 01:10:02 +02:00
CStackBasicDescriptor stack ;
2010-11-27 03:46:19 +02:00
2010-11-27 22:17:28 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-11-27 03:46:19 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & sl & stack ;
}
} ;
//moves creatures from src stack to dst slot, may be used for merging/splittint/moving stacks
2010-12-06 01:10:02 +02:00
struct RebalanceStacks : CGarrisonOperationPack //526
2010-11-27 03:46:19 +02:00
{
StackLocation src , dst ;
TQuantity count ;
2010-11-27 22:17:28 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-11-27 03:46:19 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & src & dst & count ;
}
} ;
2014-01-16 23:24:06 +03:00
2012-05-02 11:37:11 +03:00
2013-06-01 01:23:53 +03:00
struct GetEngagedHeroIds : boost : : static_visitor < boost : : optional < ObjectInstanceID > >
{
boost : : optional < ObjectInstanceID > operator ( ) ( const ConstTransitivePtr < CGHeroInstance > & h ) const
{
return h - > id ;
}
boost : : optional < ObjectInstanceID > operator ( ) ( const ConstTransitivePtr < CStackInstance > & s ) const
{
if ( s - > armyObj & & s - > armyObj - > ID = = Obj : : HERO )
return s - > armyObj - > id ;
return boost : : optional < ObjectInstanceID > ( ) ;
}
} ;
2011-01-22 05:43:20 +02:00
struct PutArtifact : CArtifactOperationPack //526
2010-12-17 00:32:53 +02:00
{
ArtifactLocation al ;
2010-12-26 16:34:11 +02:00
ConstTransitivePtr < CArtifactInstance > art ;
2010-12-17 00:32:53 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-12-17 00:32:53 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2010-12-26 16:34:11 +02:00
h & al & art ;
2010-12-17 00:32:53 +02:00
}
} ;
2011-01-22 05:43:20 +02:00
struct EraseArtifact : CArtifactOperationPack //527
2010-12-17 00:32:53 +02:00
{
ArtifactLocation al ;
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-12-17 00:32:53 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & al ;
}
} ;
2011-01-22 05:43:20 +02:00
struct MoveArtifact : CArtifactOperationPack //528
2010-12-17 00:32:53 +02:00
{
ArtifactLocation src , dst ;
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-12-17 00:32:53 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & src & dst ;
}
} ;
2011-01-22 05:43:20 +02:00
struct AssembledArtifact : CArtifactOperationPack //529
{
ArtifactLocation al ; //where assembly will be put
CArtifact * builtArt ;
//std::vector<CArtifactInstance *> constituents;
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2011-01-22 05:43:20 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & al & builtArt /* & constituents*/ ;
}
} ;
struct DisassembledArtifact : CArtifactOperationPack //530
{
ArtifactLocation al ;
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2011-01-22 05:43:20 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & al ;
}
} ;
2011-05-10 01:20:47 +03:00
struct HeroVisit : CPackForClient //531
{
const CGHeroInstance * hero ;
const CGObjectInstance * obj ;
2013-09-28 03:30:12 +03:00
PlayerColor player ; //if hero was killed during the visit, its color is already reset
2011-05-10 01:20:47 +03:00
bool starting ; //false -> ending
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2011-05-10 01:20:47 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2013-09-28 03:30:12 +03:00
h & hero & obj & player & starting ;
2011-05-10 01:20:47 +03:00
}
} ;
2009-03-07 00:11:17 +02:00
struct NewTurn : public CPackForClient //101
2008-08-10 07:46:16 +03:00
{
2011-08-26 23:32:05 +03:00
enum weekType { NORMAL , DOUBLE_GROWTH , BONUS_GROWTH , DEITYOFFIRE , PLAGUE , NO_ACTION } ;
2010-08-22 21:21:45 +03:00
2011-08-25 18:24:37 +03:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2008-08-10 07:46:16 +03:00
struct Hero
{
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ;
ui32 move , mana ; //id is a general serial id
2008-08-10 07:46:16 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & id & move & mana ;
}
bool operator < ( const Hero & h ) const { return id < h . id ; }
} ;
std : : set < Hero > heroes ; //updates movement and mana points
2009-11-28 03:42:08 +02:00
//std::vector<SetResources> res;//resource list
2013-03-03 20:06:03 +03:00
std : : map < PlayerColor , TResources > res ; //player ID => resource value[res_id]
2013-03-14 23:44:00 +03:00
std : : map < ObjectInstanceID , SetAvailableCreatures > cres ; //creatures to be placed in towns
2008-08-10 07:46:16 +03:00
ui32 day ;
bool resetBuilded ;
2010-08-26 10:23:08 +03:00
ui8 specialWeek ; //weekType
2013-02-11 02:24:57 +03:00
CreatureID creatureid ; //for creature weeks
2008-08-10 07:46:16 +03:00
NewTurn ( ) { type = 101 ; } ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
2010-08-26 10:23:08 +03:00
h & heroes & cres & res & day & resetBuilded & specialWeek & creatureid ;
2008-08-01 14:21:15 +03:00
}
2012-09-15 22:16:16 +03:00
} ;
2009-03-07 00:11:17 +02:00
struct InfoWindow : public CPackForClient //103 - displays simple info window
2008-07-31 00:27:15 +03:00
{
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2008-07-31 00:27:15 +03:00
MetaString text ;
std : : vector < Component > components ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-04-22 21:48:56 +03:00
ui16 soundID ;
2008-07-31 00:27:15 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2009-04-22 21:48:56 +03:00
h & text & components & player & soundID ;
2008-07-31 00:27:15 +03:00
}
2012-09-15 22:16:16 +03:00
InfoWindow ( )
{
2009-04-22 21:48:56 +03:00
type = 103 ;
2012-09-15 22:16:16 +03:00
soundID = 0 ;
2010-03-11 01:16:30 +02:00
}
2008-07-30 20:51:19 +03:00
} ;
2010-05-02 21:20:26 +03:00
namespace ObjProperty
{
2011-05-28 04:02:28 +03:00
enum { OWNER = 1 , BLOCKVIS = 2 , PRIMARY_STACK_COUNT = 3 , VISITORS = 4 , VISITED = 5 , ID = 6 , AVAILABLE_CREATURE = 7 , SUBID = 8 ,
2013-04-20 14:34:01 +03:00
MONSTER_COUNT = 10 , MONSTER_POWER = 11 , MONSTER_EXP = 12 , MONSTER_RESTORE_TYPE = 13 , MONSTER_REFUSED_JOIN ,
2013-02-14 16:19:03 +03:00
//town-specific
STRUCTURE_ADD_VISITING_HERO , STRUCTURE_CLEAR_VISITORS , STRUCTURE_ADD_GARRISONED_HERO , //changing buildings state
2013-02-19 01:37:22 +03:00
BONUS_VALUE_FIRST , BONUS_VALUE_SECOND , //used in Rampart for special building that generates resources (storing resource type and quantity)
2013-02-14 16:19:03 +03:00
2013-02-19 01:37:22 +03:00
//creature-bank specific
2014-06-22 13:39:40 +03:00
BANK_DAYCOUNTER , BANK_RESET , BANK_CLEAR ,
2013-09-17 15:02:33 +03:00
2014-04-07 20:32:15 +03:00
//object with reward
REWARD_RESET , REWARD_SELECT
2013-02-14 16:19:03 +03:00
} ;
2010-05-02 21:20:26 +03:00
}
2009-03-07 00:11:17 +02:00
struct SetObjectProperty : public CPackForClient //1001
2008-07-30 20:51:19 +03:00
{
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-07-30 15:49:45 +03:00
void applyCl ( CClient * cl ) ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ;
2014-04-07 20:32:15 +03:00
ui8 what ; // see ObjProperty enum
2008-07-30 20:51:19 +03:00
ui32 val ;
SetObjectProperty ( ) { type = 1001 ; } ;
2013-02-14 02:55:42 +03:00
SetObjectProperty ( ObjectInstanceID ID , ui8 What , ui32 Val ) : id ( ID ) , what ( What ) , val ( Val ) { type = 1001 ; } ;
2012-09-15 22:16:16 +03:00
2008-07-30 20:51:19 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & id & what & val ;
}
} ;
2014-04-07 20:32:15 +03:00
struct ChangeObjectVisitors : public CPackForClient // 1003
{
enum VisitMode
{
VISITOR_ADD , // mark hero as one that have visited this object
VISITOR_REMOVE , // unmark visitor, reversed to ADD
VISITOR_CLEAR // clear all visitors from this object (object reset)
} ;
ui32 mode ; // uses VisitMode enum
ObjectInstanceID object ;
ObjectInstanceID hero ; // note: hero owner will be also marked as "visited" this object
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2014-04-11 22:49:25 +03:00
ChangeObjectVisitors ( )
{ type = 1003 ; }
2014-04-07 20:32:15 +03:00
ChangeObjectVisitors ( ui32 mode , ObjectInstanceID object , ObjectInstanceID heroID = ObjectInstanceID ( - 1 ) ) :
mode ( mode ) ,
object ( object ) ,
hero ( heroID )
{ type = 1003 ; }
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & object & hero & mode ;
}
} ;
2009-03-07 00:11:17 +02:00
struct HeroLevelUp : public Query //2000
2008-08-04 18:56:36 +03:00
{
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-04-20 14:34:01 +03:00
const CGHeroInstance * hero ;
2013-02-04 22:43:16 +03:00
PrimarySkill : : PrimarySkill primskill ;
2013-02-12 22:49:40 +03:00
std : : vector < SecondarySkill > skills ;
2008-08-04 18:56:36 +03:00
HeroLevelUp ( ) { type = 2000 ; } ;
2012-09-15 22:16:16 +03:00
2008-08-04 18:56:36 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2014-04-10 20:11:09 +03:00
h & queryID & hero & primskill & skills ;
2008-08-04 18:56:36 +03:00
}
} ;
2008-08-13 03:44:31 +03:00
2012-05-07 15:54:22 +03:00
struct CommanderLevelUp : public Query
{
2012-05-16 20:29:05 +03:00
void applyCl ( CClient * cl ) ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2012-05-07 15:54:22 +03:00
2013-04-20 14:34:01 +03:00
const CGHeroInstance * hero ;
2012-05-18 17:02:27 +03:00
2012-07-03 11:07:34 +03:00
std : : vector < ui32 > skills ; //0-5 - secondary skills, val-100 - special skill
2012-05-07 15:54:22 +03:00
CommanderLevelUp ( ) { type = 2005 ; } ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
2013-04-20 14:34:01 +03:00
h & queryID & hero & skills ;
2012-05-07 15:54:22 +03:00
}
} ;
2009-09-21 12:00:33 +03:00
struct TradeComponents : public CPackForClient , public CPackForServer
{
2009-09-25 07:05:01 +03:00
///used to handle info about components available in shops
2009-09-21 12:00:33 +03:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-09-21 12:00:33 +03:00
si32 heroid ;
ui32 objectid ;
2009-09-25 07:05:01 +03:00
std : : map < ui16 , Component > available , chosen , bought ;
2009-09-21 12:00:33 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2009-10-03 14:16:42 +03:00
h & heroid & objectid & available & chosen & bought ;
2009-09-21 12:00:33 +03:00
}
} ;
2009-04-11 04:32:50 +03:00
//A dialog that requires making decision by player - it may contain components to choose between or has yes/no options
//Client responds with QueryReply, where answer: 0 - cancel pressed, choice doesn't matter; 1/2/... - first/second/... component selected and OK pressed
//Until sending reply player won't be allowed to take any actions
struct BlockingDialog : public Query //2003
2008-08-13 03:44:31 +03:00
{
2009-04-11 04:32:50 +03:00
enum { ALLOW_CANCEL = 1 , SELECTION = 2 } ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2008-08-13 03:44:31 +03:00
MetaString text ;
std : : vector < Component > components ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-04-11 04:32:50 +03:00
ui8 flags ;
2009-04-22 21:48:56 +03:00
ui16 soundID ;
2008-08-13 03:44:31 +03:00
2009-04-11 04:32:50 +03:00
bool cancel ( ) const
2008-08-13 03:44:31 +03:00
{
2009-04-11 04:32:50 +03:00
return flags & ALLOW_CANCEL ;
}
bool selection ( ) const
{
return flags & SELECTION ;
2008-08-13 03:44:31 +03:00
}
2008-08-22 15:21:09 +03:00
2009-04-11 04:32:50 +03:00
BlockingDialog ( bool yesno , bool Selection )
{
2009-04-14 13:46:42 +03:00
type = 2003 ;
flags = 0 ;
2009-04-22 21:48:56 +03:00
soundID = 0 ;
2009-04-11 04:32:50 +03:00
if ( yesno ) flags | = ALLOW_CANCEL ;
if ( Selection ) flags | = SELECTION ;
}
BlockingDialog ( )
{
type = 2003 ;
2009-04-14 13:46:42 +03:00
flags = 0 ;
2009-04-22 21:48:56 +03:00
soundID = 0 ;
2009-04-11 04:32:50 +03:00
} ;
2008-08-22 15:21:09 +03:00
2013-04-20 14:34:01 +03:00
void addResourceComponents ( TResources resources )
{
for ( TResources : : nziterator i ( resources ) ; i . valid ( ) ; i + + )
components . push_back ( Component ( Component : : RESOURCE , i - > resType , i - > resVal , 0 ) ) ;
}
2008-08-22 15:21:09 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2012-07-15 18:34:00 +03:00
h & queryID & text & components & player & flags & soundID ;
2008-08-22 15:21:09 +03:00
}
} ;
2009-04-12 03:58:41 +03:00
struct GarrisonDialog : public Query //2004
{
GarrisonDialog ( ) { type = 2004 ; }
void applyCl ( CClient * cl ) ;
2013-02-14 02:55:42 +03:00
ObjectInstanceID objid , hid ;
2009-09-09 20:49:03 +03:00
bool removableUnits ;
2009-04-12 03:58:41 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2012-07-15 18:34:00 +03:00
h & queryID & objid & hid & removableUnits ;
2009-04-12 03:58:41 +03:00
}
} ;
2013-05-27 13:53:28 +03:00
struct ExchangeDialog : public Query //2005
{
ExchangeDialog ( ) { type = 2005 ; }
void applyCl ( CClient * cl ) ;
std : : array < const CGHeroInstance * , 2 > heroes ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & queryID & heroes ;
}
} ;
2008-08-04 18:56:36 +03:00
struct BattleInfo ;
2009-03-07 00:11:17 +02:00
struct BattleStart : public CPackForClient //3000
2008-08-04 18:56:36 +03:00
{
2009-03-07 00:11:17 +02:00
BattleStart ( ) { type = 3000 ; } ;
2013-09-14 22:09:35 +03:00
void applyFirstCl ( CClient * cl ) ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2008-08-04 18:56:36 +03:00
BattleInfo * info ;
2012-09-15 22:16:16 +03:00
2008-08-04 18:56:36 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & info ;
}
} ;
2009-03-07 00:11:17 +02:00
struct BattleNextRound : public CPackForClient //3001
2012-09-15 22:16:16 +03:00
{
2009-03-07 00:11:17 +02:00
BattleNextRound ( ) { type = 3001 ; } ;
2010-05-07 15:29:41 +03:00
void applyFirstCl ( CClient * cl ) ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2008-08-04 18:56:36 +03:00
si32 round ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & round ;
}
} ;
2009-03-07 00:11:17 +02:00
struct BattleSetActiveStack : public CPackForClient //3002
2008-08-04 18:56:36 +03:00
{
2012-08-27 15:34:43 +03:00
BattleSetActiveStack ( )
{
type = 3002 ;
askPlayerInterface = true ;
}
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2008-08-04 18:56:36 +03:00
ui32 stack ;
2012-08-27 15:34:43 +03:00
ui8 askPlayerInterface ;
2008-08-04 18:56:36 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2012-08-27 15:34:43 +03:00
h & stack & askPlayerInterface ;
2008-08-04 18:56:36 +03:00
}
} ;
2009-03-07 00:11:17 +02:00
struct BattleResult : public CPackForClient //3003
2008-08-04 18:56:36 +03:00
{
2012-05-01 11:52:22 +03:00
enum EResult { NORMAL = 0 , ESCAPE = 1 , SURRENDER = 2 } ;
2009-03-07 00:11:17 +02:00
BattleResult ( ) { type = 3003 ; } ;
void applyFirstCl ( CClient * cl ) ;
2009-03-07 19:08:40 +02:00
void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-02-04 22:43:16 +03:00
EResult result ;
2008-08-04 18:56:36 +03:00
ui8 winner ; //0 - attacker, 1 - defender, [2 - draw (should be possible?)]
2009-09-24 16:23:52 +03:00
std : : map < ui32 , si32 > casualties [ 2 ] ; //first => casualties of attackers - map crid => number
2012-09-23 21:01:04 +03:00
TExpType exp [ 2 ] ; //exp for attacker and defender
2013-02-14 02:55:42 +03:00
std : : set < ArtifactInstanceID > artifacts ; //artifacts taken from loser to winner - currently unused
2008-08-04 18:56:36 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2008-09-08 14:32:16 +03:00
h & result & winner & casualties [ 0 ] & casualties [ 1 ] & exp & artifacts ;
2008-08-04 18:56:36 +03:00
}
} ;
2009-03-07 00:11:17 +02:00
struct BattleStackMoved : public CPackForClient //3004
2008-08-05 02:04:15 +03:00
{
2011-01-09 19:41:46 +02:00
ui32 stack ;
2011-12-22 16:05:19 +03:00
std : : vector < BattleHex > tilesToMove ;
2011-08-01 20:36:18 +03:00
ui8 distance , teleporting ;
2008-09-29 00:01:49 +03:00
BattleStackMoved ( ) { type = 3004 ; } ;
2009-03-07 00:11:17 +02:00
void applyFirstCl ( CClient * cl ) ;
2009-03-07 19:08:40 +02:00
void applyGs ( CGameState * gs ) ;
2008-08-05 02:04:15 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2011-08-01 20:36:18 +03:00
h & stack & tilesToMove & distance ;
2008-08-05 02:04:15 +03:00
}
} ;
2010-05-07 15:29:41 +03:00
struct StacksHealedOrResurrected : public CPackForClient //3013
{
StacksHealedOrResurrected ( ) { type = 3013 ; }
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-05-07 15:29:41 +03:00
void applyCl ( CClient * cl ) ;
struct HealInfo
{
ui32 stackID ;
ui32 healedHP ;
2011-10-02 10:16:34 +03:00
ui8 lowLevelResurrection ; //in case this stack is resurrected by this heal, it will be marked as SUMMONED //TODO: replace with separate counter
2010-05-07 15:29:41 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & stackID & healedHP & lowLevelResurrection ;
}
} ;
std : : vector < HealInfo > healedStacks ;
2013-02-12 22:49:40 +03:00
bool lifeDrain ; //if true, this heal is an effect of life drain
bool tentHealing ; //if true, than it's healing via First Aid Tent
2011-06-21 15:45:57 +03:00
si32 drainedFrom ; //if life drain - then stack life was drain from, if tentHealing - stack that is a healer
2010-05-07 15:29:41 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2011-06-21 15:45:57 +03:00
h & healedStacks & lifeDrain & tentHealing & drainedFrom ;
2010-05-07 15:29:41 +03:00
}
} ;
2009-03-07 00:11:17 +02:00
struct BattleStackAttacked : public CPackForClient //3005
2008-08-09 02:02:32 +03:00
{
2009-03-07 00:11:17 +02:00
BattleStackAttacked ( ) { flags = 0 ; type = 3005 ; } ;
2012-02-18 20:39:47 +03:00
void applyFirstCl ( CClient * cl ) ;
//void applyCl(CClient *cl);
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2009-09-15 15:20:11 +03:00
ui32 stackAttacked , attackerID ;
2008-08-09 02:02:32 +03:00
ui32 newAmount , newHP , killedAmount , damageAmount ;
2012-02-18 20:39:47 +03:00
enum EFlags { KILLED = 1 , EFFECT = 2 , SECONDARY = 4 , REBIRTH = 8 , CLONE_KILLED = 16 } ;
2011-02-24 17:33:03 +02:00
ui8 flags ; //uses EFlags (above)
ui32 effect ; //set only if flag EFFECT is set
2010-05-07 15:29:41 +03:00
std : : vector < StacksHealedOrResurrected > healedStacks ; //used when life drain
2008-08-09 02:02:32 +03:00
2011-02-24 17:33:03 +02:00
2009-03-24 23:28:17 +02:00
bool killed ( ) const //if target stack was killed
2008-08-09 02:02:32 +03:00
{
2012-02-18 20:39:47 +03:00
return flags & KILLED | | flags & CLONE_KILLED ;
}
bool cloneKilled ( ) const
{
return flags & CLONE_KILLED ;
2008-08-09 02:02:32 +03:00
}
2010-05-07 15:29:41 +03:00
bool isEffect ( ) const //if stack has been attacked by a spell
2008-10-18 14:41:24 +03:00
{
2011-02-24 17:33:03 +02:00
return flags & EFFECT ;
2008-10-18 14:41:24 +03:00
}
2011-07-02 19:49:22 +03:00
bool isSecondary ( ) const //if stack was not a primary target (receives no spell effects)
{
return flags & SECONDARY ;
}
2013-08-09 20:37:41 +03:00
bool willRebirth ( ) const //resurrection, e.g. Phoenix
2011-07-08 17:54:20 +03:00
{
return flags & REBIRTH ;
}
2010-05-07 15:29:41 +03:00
bool lifeDrain ( ) const //if this attack involves life drain effect
{
return healedStacks . size ( ) > 0 ;
}
2008-08-09 02:02:32 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2010-05-07 15:29:41 +03:00
h & stackAttacked & attackerID & newAmount & newHP & flags & killedAmount & damageAmount & effect
& healedStacks ;
2008-08-09 02:02:32 +03:00
}
2009-03-21 14:49:58 +02:00
bool operator < ( const BattleStackAttacked & b ) const
{
return stackAttacked < b . stackAttacked ;
}
2008-08-09 02:02:32 +03:00
} ;
2009-03-07 00:11:17 +02:00
struct BattleAttack : public CPackForClient //3006
2008-08-09 02:02:32 +03:00
{
2009-03-07 00:11:17 +02:00
BattleAttack ( ) { flags = 0 ; type = 3006 ; } ;
void applyFirstCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2010-02-20 15:24:38 +02:00
std : : vector < BattleStackAttacked > bsa ;
2008-08-09 02:02:32 +03:00
ui32 stackAttacking ;
2011-07-04 22:34:49 +03:00
ui8 flags ; //uses Eflags (below)
2011-07-06 20:00:45 +03:00
enum EFlags { SHOT = 1 , COUNTER = 2 , LUCKY = 4 , UNLUCKY = 8 , BALLISTA_DOUBLE_DMG = 16 , DEATH_BLOW = 32 } ;
2008-08-09 02:02:32 +03:00
2010-12-04 21:44:23 +02:00
bool shot ( ) const //distance attack - decrease number of shots
2008-08-09 02:02:32 +03:00
{
2011-02-24 17:33:03 +02:00
return flags & SHOT ;
2008-08-09 02:02:32 +03:00
}
2010-12-04 21:44:23 +02:00
bool counter ( ) const //is it counterattack?
2008-09-12 11:51:46 +03:00
{
2011-02-24 17:33:03 +02:00
return flags & COUNTER ;
2008-09-12 11:51:46 +03:00
}
2010-12-04 21:44:23 +02:00
bool lucky ( ) const
2009-03-21 14:49:58 +02:00
{
2011-02-24 17:33:03 +02:00
return flags & LUCKY ;
2009-03-21 14:49:58 +02:00
}
2010-12-04 21:44:23 +02:00
bool unlucky ( ) const
2008-08-09 02:02:32 +03:00
{
2011-02-24 17:33:03 +02:00
return flags & UNLUCKY ;
}
bool ballistaDoubleDmg ( ) const //if it's ballista attack and does double dmg
{
return flags & BALLISTA_DOUBLE_DMG ;
2008-08-09 02:02:32 +03:00
}
2011-07-06 20:00:45 +03:00
bool deathBlow ( ) const
{
return flags & DEATH_BLOW ;
}
2009-03-21 14:49:58 +02:00
//bool killed() //if target stack was killed
//{
// return bsa.killed();
//}
2008-08-09 02:02:32 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & bsa & stackAttacking & flags ;
}
} ;
2009-03-07 00:11:17 +02:00
struct StartAction : public CPackForClient //3007
2008-09-29 00:01:49 +03:00
{
StartAction ( ) { type = 3007 ; } ;
StartAction ( const BattleAction & act ) { ba = act ; type = 3007 ; } ;
2009-03-07 00:11:17 +02:00
void applyFirstCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
BattleAction ba ;
2008-09-29 00:01:49 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & ba ;
}
} ;
2009-03-07 00:11:17 +02:00
struct EndAction : public CPackForClient //3008
2008-10-18 14:41:24 +03:00
{
2009-03-07 00:11:17 +02:00
EndAction ( ) { type = 3008 ; } ;
void applyCl ( CClient * cl ) ;
2009-03-07 00:25:19 +02:00
2009-03-07 00:11:17 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
}
} ;
2010-05-16 16:42:19 +03:00
struct BattleSpellCast : public CPackForClient //3009
2008-10-18 14:41:24 +03:00
{
2010-05-16 16:42:19 +03:00
BattleSpellCast ( ) { type = 3009 ; } ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2009-11-08 16:44:58 +02:00
si32 dmgToDisplay ; //this amount will be displayed as amount of damage dealt by spell
2009-05-12 06:35:51 +03:00
ui8 side ; //which hero did cast spell: 0 - attacker, 1 - defender
2009-08-06 17:02:21 +03:00
ui32 id ; //id of spell
ui8 skill ; //caster's skill level
2011-10-09 14:23:24 +03:00
ui8 spellCost ;
ui8 manaGained ; //mana channeling ability
2011-12-22 16:05:19 +03:00
BattleHex tile ; //destination tile (may not be set in some global/mass spells
2009-07-26 15:15:38 +03:00
std : : vector < ui32 > resisted ; //ids of creatures that resisted this spell
2009-08-04 20:05:49 +03:00
std : : set < ui32 > affectedCres ; //ids of creatures affected by this spell, generally used if spell does not set any effect (like dispel or cure)
2013-02-11 02:24:57 +03:00
CreatureID attackerType ; //id of caster to generate console message; -1 if not set (eg. spell casted by artifact)
2013-02-04 22:43:16 +03:00
bool castedByHero ; //if true - spell has been casted by hero, otherwise by a creature
2008-10-18 14:41:24 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2011-10-09 14:23:24 +03:00
h & dmgToDisplay & side & id & skill & spellCost & manaGained & tile & resisted & affectedCres & attackerType & castedByHero ;
2008-10-18 14:41:24 +03:00
}
} ;
2009-03-07 00:11:17 +02:00
struct SetStackEffect : public CPackForClient //3010
2008-11-09 00:29:19 +02:00
{
2009-03-07 00:11:17 +02:00
SetStackEffect ( ) { type = 3010 ; } ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2010-02-20 15:24:38 +02:00
std : : vector < ui32 > stacks ; //affected stacks (IDs)
2011-01-20 21:57:12 +02:00
std : : vector < Bonus > effect ; //bonuses to apply
2011-04-23 13:27:44 +03:00
std : : vector < std : : pair < ui32 , Bonus > > uniqueBonuses ; //bonuses per single stack
2008-11-09 00:29:19 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2011-04-23 12:57:51 +03:00
h & stacks & effect & uniqueBonuses ;
2008-11-09 00:29:19 +02:00
}
} ;
2009-04-16 03:28:54 +03:00
struct StacksInjured : public CPackForClient //3011
{
StacksInjured ( ) { type = 3011 ; }
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-04-16 03:28:54 +03:00
void applyCl ( CClient * cl ) ;
2010-02-20 15:24:38 +02:00
std : : vector < BattleStackAttacked > stacks ;
2009-04-16 03:28:54 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & stacks ;
}
} ;
2009-08-04 02:53:18 +03:00
struct BattleResultsApplied : public CPackForClient //3012
{
BattleResultsApplied ( ) { type = 3012 ; }
2013-03-03 20:06:03 +03:00
PlayerColor player1 , player2 ;
2009-08-04 02:53:18 +03:00
void applyCl ( CClient * cl ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & player1 & player2 ;
}
} ;
2009-08-19 13:59:42 +03:00
struct ObstaclesRemoved : public CPackForClient //3014
{
ObstaclesRemoved ( ) { type = 3014 ; }
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-08-19 13:59:42 +03:00
void applyCl ( CClient * cl ) ;
std : : set < si32 > obstacles ; //uniqueIDs of removed obstacles
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & obstacles ;
}
2009-09-01 16:54:13 +03:00
} ;
2014-06-26 18:34:54 +03:00
struct ELF_VISIBILITY CatapultAttack : public CPackForClient //3015
2014-06-25 00:37:33 +03:00
2009-09-01 16:54:13 +03:00
{
2013-08-06 14:20:28 +03:00
struct AttackInfo
{
si16 destinationTile ;
ui8 attackedPart ;
ui8 damageDealt ;
2013-12-08 20:54:13 +03:00
DLL_LINKAGE std : : string toString ( ) const ;
2013-08-06 14:20:28 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & destinationTile & attackedPart & damageDealt ;
}
} ;
2014-06-24 17:17:25 +03:00
DLL_LINKAGE CatapultAttack ( ) ;
DLL_LINKAGE ~ CatapultAttack ( ) ;
2009-09-01 16:54:13 +03:00
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-09-01 16:54:13 +03:00
void applyCl ( CClient * cl ) ;
2013-12-08 20:54:13 +03:00
DLL_LINKAGE std : : string toString ( ) const override ;
2009-09-01 16:54:13 +03:00
2013-08-06 14:20:28 +03:00
std : : vector < AttackInfo > attackedParts ;
2009-09-24 16:44:55 +03:00
int attacker ; //if -1, then a spell caused this
2009-09-01 16:54:13 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2009-09-24 16:44:55 +03:00
h & attackedParts & attacker ;
2009-09-01 16:54:13 +03:00
}
2009-09-05 17:10:26 +03:00
} ;
2013-12-08 20:54:13 +03:00
DLL_LINKAGE std : : ostream & operator < < ( std : : ostream & out , const CatapultAttack : : AttackInfo & attackInfo ) ;
2009-09-05 17:10:26 +03:00
struct BattleStacksRemoved : public CPackForClient //3016
{
BattleStacksRemoved ( ) { type = 3016 ; }
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-09-05 17:10:26 +03:00
void applyCl ( CClient * cl ) ;
std : : set < ui32 > stackIDs ; //IDs of removed stacks
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & stackIDs ;
}
2009-08-19 13:59:42 +03:00
} ;
2011-10-01 22:56:54 +03:00
struct BattleStackAdded : public CPackForClient //3017
{
BattleStackAdded ( ) { type = 3017 ; } ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2011-10-01 22:56:54 +03:00
void applyCl ( CClient * cl ) ;
int attacker ; // if true, stack belongs to attacker
2013-02-11 02:24:57 +03:00
CreatureID creID ;
2011-10-01 22:56:54 +03:00
int amount ;
int pos ;
int summoned ; //if true, remove it afterwards
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & attacker & creID & amount & pos & summoned ;
}
} ;
2011-10-02 16:59:12 +03:00
struct BattleSetStackProperty : public CPackForClient //3018
{
2011-10-06 03:27:27 +03:00
BattleSetStackProperty ( ) { type = 3018 ; } ;
2011-10-02 16:59:12 +03:00
2012-02-10 16:13:24 +03:00
enum BattleStackProperty { CASTS , ENCHANTER_COUNTER , UNBIND , CLONED } ;
2011-10-02 16:59:12 +03:00
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2011-10-02 16:59:12 +03:00
//void applyCl(CClient *cl){};
int stackID ;
2013-02-04 22:43:16 +03:00
BattleStackProperty which ;
2011-10-02 16:59:12 +03:00
int val ;
int absolute ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & stackID & which & val & absolute ;
}
} ;
2011-10-08 16:02:58 +03:00
struct BattleTriggerEffect : public CPackForClient //3019
{ //activated at the beginning of turn
BattleTriggerEffect ( ) { type = 3019 ; } ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ; //effect
2011-10-08 16:02:58 +03:00
void applyCl ( CClient * cl ) ; //play animations & stuff
//enum BattleEffect {REGENERATION, MANA_DRAIN, FEAR, MANA_CHANNELING, ENCHANTER, UNBIND, POISON, ENCHANTED, SUMMONER};
int stackID ;
int effect ; //use enumBattleEffect or corresponding Bonus type for sanity?
int val ;
int additionalInfo ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & stackID & effect & val & additionalInfo ;
}
} ;
2012-05-05 00:16:39 +03:00
struct BattleObstaclePlaced : public CPackForClient //3020
{ //activated at the beginning of turn
BattleObstaclePlaced ( ) { type = 3020 ; } ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ; //effect
void applyCl ( CClient * cl ) ; //play animations & stuff
2012-05-18 23:50:16 +03:00
shared_ptr < CObstacleInstance > obstacle ;
2012-05-05 00:16:39 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & obstacle ;
}
} ;
2009-03-07 00:11:17 +02:00
struct ShowInInfobox : public CPackForClient //107
2008-08-04 18:56:36 +03:00
{
ShowInInfobox ( ) { type = 107 ; } ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2008-08-04 18:56:36 +03:00
Component c ;
MetaString text ;
2009-03-07 00:25:19 +02:00
void applyCl ( CClient * cl ) ;
2008-08-04 18:56:36 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & player & c & text ;
}
2010-05-16 16:42:19 +03:00
} ;
struct AdvmapSpellCast : public CPackForClient //108
{
AdvmapSpellCast ( ) { type = 108 ; }
const CGHeroInstance * caster ;
2013-03-03 20:06:03 +03:00
SpellID spellID ;
2010-05-16 16:42:19 +03:00
void applyCl ( CClient * cl ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & caster & spellID ;
}
2008-12-26 17:00:34 +02:00
} ;
2009-03-09 12:37:49 +02:00
/***********************************************************************************************************/
2011-05-22 21:46:52 +03:00
struct CommitPackage : public CPackForServer
{
2011-06-11 02:50:32 +03:00
bool freePack ; //for local usage, DO NOT serialize
2011-05-22 21:46:52 +03:00
bool applyGh ( CGameHandler * gh ) ;
CPackForClient * packToCommit ;
2011-06-11 02:50:32 +03:00
CommitPackage ( )
{
freePack = true ;
}
2011-05-22 21:46:52 +03:00
~ CommitPackage ( )
{
2011-06-11 02:50:32 +03:00
if ( freePack )
delete packToCommit ;
2011-05-22 21:46:52 +03:00
}
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & packToCommit ;
}
} ;
2009-03-09 12:37:49 +02:00
struct CloseServer : public CPackForServer
{
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{ }
} ;
struct EndTurn : public CPackForServer
{
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{ }
} ;
struct DismissHero : public CPackForServer
{
DismissHero ( ) { } ;
2013-02-14 02:55:42 +03:00
DismissHero ( ObjectInstanceID HID ) : hid ( HID ) { } ;
ObjectInstanceID hid ;
2009-03-09 12:37:49 +02:00
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & hid ;
}
} ;
struct MoveHero : public CPackForServer
{
MoveHero ( ) { } ;
2013-02-14 02:55:42 +03:00
MoveHero ( const int3 & Dest , ObjectInstanceID HID ) : dest ( Dest ) , hid ( HID ) { } ;
2009-03-09 12:37:49 +02:00
int3 dest ;
2013-02-14 02:55:42 +03:00
ObjectInstanceID hid ;
2009-03-09 12:37:49 +02:00
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2010-06-30 22:27:35 +03:00
{
h & dest & hid ;
}
} ;
struct CastleTeleportHero : public CPackForServer
{
CastleTeleportHero ( ) { } ;
2013-02-14 02:55:42 +03:00
CastleTeleportHero ( const ObjectInstanceID HID , ObjectInstanceID Dest , ui8 Source ) : dest ( Dest ) , hid ( HID ) , source ( Source ) { } ;
ObjectInstanceID dest ;
ObjectInstanceID hid ;
2010-06-30 22:27:35 +03:00
si8 source ; //who give teleporting, 1=castle gate
bool applyGh ( CGameHandler * gh ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
h & dest & hid ;
}
} ;
struct ArrangeStacks : public CPackForServer
{
ArrangeStacks ( ) { } ;
2013-02-16 17:03:47 +03:00
ArrangeStacks ( ui8 W , SlotID P1 , SlotID P2 , ObjectInstanceID ID1 , ObjectInstanceID ID2 , si32 VAL )
2009-03-09 12:37:49 +02:00
: what ( W ) , p1 ( P1 ) , p2 ( P2 ) , id1 ( ID1 ) , id2 ( ID2 ) , val ( VAL ) { } ;
ui8 what ; //1 - swap; 2 - merge; 3 - split
2013-02-16 17:03:47 +03:00
SlotID p1 , p2 ; //positions of first and second stack
2013-02-14 02:55:42 +03:00
ObjectInstanceID id1 , id2 ; //ids of objects with garrison
2009-03-09 12:37:49 +02:00
si32 val ;
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & what & p1 & p2 & id1 & id2 & val ;
}
} ;
struct DisbandCreature : public CPackForServer
{
DisbandCreature ( ) { } ;
2013-02-16 17:03:47 +03:00
DisbandCreature ( SlotID Pos , ObjectInstanceID ID ) : pos ( Pos ) , id ( ID ) { } ;
SlotID pos ; //stack pos
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ; //object id
2009-03-09 12:37:49 +02:00
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & pos & id ;
}
} ;
struct BuildStructure : public CPackForServer
{
BuildStructure ( ) { } ;
2013-02-14 02:55:42 +03:00
BuildStructure ( ObjectInstanceID TID , BuildingID BID ) : tid ( TID ) , bid ( BID ) { } ;
ObjectInstanceID tid ; //town id
2013-02-11 22:11:34 +03:00
BuildingID bid ; //structure id
2009-03-09 12:37:49 +02:00
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & tid & bid ;
}
} ;
2009-09-22 17:27:46 +03:00
struct RazeStructure : public BuildStructure
{
RazeStructure ( ) { } ;
//RazeStructure(si32 TID, si32 BID):bid(BID),tid(TID){};
2009-03-09 12:37:49 +02:00
2009-09-22 17:27:46 +03:00
bool applyGh ( CGameHandler * gh ) ;
} ;
2009-03-09 12:37:49 +02:00
struct RecruitCreatures : public CPackForServer
{
RecruitCreatures ( ) { } ;
2014-09-19 00:18:49 +03:00
RecruitCreatures ( ObjectInstanceID TID , ObjectInstanceID DST , CreatureID CRID , si32 Amount , si32 Level ) :
tid ( TID ) , dst ( DST ) , crid ( CRID ) , amount ( Amount ) , level ( Level ) { } ;
ObjectInstanceID tid ; //dwelling id, or town
ObjectInstanceID dst ; //destination ID, e.g. hero
2013-02-11 02:24:57 +03:00
CreatureID crid ;
2013-02-07 20:34:50 +03:00
ui32 amount ; //creature amount
2010-07-10 19:50:23 +03:00
si32 level ; //dwelling level to buy from, -1 if any
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2014-09-19 00:18:49 +03:00
h & tid & dst & crid & amount & level ;
2009-03-09 12:37:49 +02:00
}
} ;
struct UpgradeCreature : public CPackForServer
{
UpgradeCreature ( ) { } ;
2013-02-16 17:03:47 +03:00
UpgradeCreature ( SlotID Pos , ObjectInstanceID ID , CreatureID CRID ) : pos ( Pos ) , id ( ID ) , cid ( CRID ) { } ;
SlotID pos ; //stack pos
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ; //object id
2013-02-11 02:24:57 +03:00
CreatureID cid ; //id of type to which we want make upgrade
2009-03-09 12:37:49 +02:00
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & pos & id & cid ;
}
} ;
struct GarrisonHeroSwap : public CPackForServer
{
GarrisonHeroSwap ( ) { } ;
2013-02-14 02:55:42 +03:00
GarrisonHeroSwap ( ObjectInstanceID TID ) : tid ( TID ) { } ;
ObjectInstanceID tid ;
2009-03-09 12:37:49 +02:00
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & tid ;
}
} ;
struct ExchangeArtifacts : public CPackForServer
2012-01-30 19:07:52 +03:00
//TODO: allow exchange between heroes, stacks and commanders
2009-03-09 12:37:49 +02:00
{
2012-04-14 05:20:22 +03:00
ArtifactLocation src , dst ;
2009-03-09 12:37:49 +02:00
ExchangeArtifacts ( ) { } ;
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2012-04-14 05:20:22 +03:00
h & src & dst ;
2009-03-09 12:37:49 +02:00
}
} ;
2010-02-16 16:39:56 +02:00
struct AssembleArtifacts : public CPackForServer
{
AssembleArtifacts ( ) { } ;
2013-02-16 17:03:47 +03:00
AssembleArtifacts ( ObjectInstanceID _heroID , ArtifactPosition _artifactSlot , bool _assemble , ArtifactID _assembleTo )
2010-02-16 16:39:56 +02:00
: heroID ( _heroID ) , artifactSlot ( _artifactSlot ) , assemble ( _assemble ) , assembleTo ( _assembleTo ) { } ;
2013-02-14 02:55:42 +03:00
ObjectInstanceID heroID ;
2013-02-12 22:49:40 +03:00
ArtifactPosition artifactSlot ;
2010-02-16 16:39:56 +02:00
bool assemble ; // True to assemble artifact, false to disassemble.
2013-02-16 17:03:47 +03:00
ArtifactID assembleTo ; // Artifact to assemble into.
2010-02-16 16:39:56 +02:00
bool applyGh ( CGameHandler * gh ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & heroID & artifactSlot & assemble & assembleTo ;
}
} ;
2009-03-09 12:37:49 +02:00
struct BuyArtifact : public CPackForServer
{
BuyArtifact ( ) { } ;
2013-02-14 02:55:42 +03:00
BuyArtifact ( ObjectInstanceID HID , ArtifactID AID ) : hid ( HID ) , aid ( AID ) { } ;
ObjectInstanceID hid ;
2013-02-11 02:24:57 +03:00
ArtifactID aid ;
2009-03-09 12:37:49 +02:00
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & hid & aid ;
}
} ;
struct TradeOnMarketplace : public CPackForServer
{
TradeOnMarketplace ( ) { } ;
2010-05-18 10:01:54 +03:00
const CGObjectInstance * market ;
const CGHeroInstance * hero ; //needed when trading artifacts / creatures
2013-02-04 22:43:16 +03:00
EMarketMode : : EMarketMode mode ;
2010-07-23 15:02:15 +03:00
ui32 r1 , r2 ; //mode 0: r1 - sold resource, r2 - bought res (exception: when sacrificing art r1 is art id [todo: make r2 preferred slot?]
2009-03-09 12:37:49 +02:00
ui32 val ; //units of sold resource
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2010-05-18 10:01:54 +03:00
h & market & hero & mode & r1 & r2 & val ;
2009-03-09 12:37:49 +02:00
}
} ;
struct SetFormation : public CPackForServer
{
SetFormation ( ) { } ;
2013-02-14 02:55:42 +03:00
SetFormation ( ObjectInstanceID HID , ui8 Formation ) : hid ( HID ) , formation ( Formation ) { } ;
ObjectInstanceID hid ;
2009-03-09 12:37:49 +02:00
ui8 formation ;
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & hid & formation ;
}
} ;
struct HireHero : public CPackForServer
{
HireHero ( ) { } ;
2013-02-14 02:55:42 +03:00
HireHero ( si32 HID , ObjectInstanceID TID ) : hid ( HID ) , tid ( TID ) { } ;
si32 hid ; //available hero serial
ObjectInstanceID tid ; //town (tavern) id
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-03-09 12:37:49 +02:00
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2010-07-09 02:03:27 +03:00
h & hid & tid & player ;
2009-03-09 12:37:49 +02:00
}
} ;
2012-09-15 22:16:16 +03:00
struct BuildBoat : public CPackForServer
2009-07-26 06:33:13 +03:00
{
BuildBoat ( ) { } ;
2013-02-14 02:55:42 +03:00
ObjectInstanceID objid ; //where player wants to buy a boat
2009-07-26 06:33:13 +03:00
bool applyGh ( CGameHandler * gh ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & objid ;
}
} ;
2009-03-09 12:37:49 +02:00
struct QueryReply : public CPackForServer
{
2009-08-04 02:53:18 +03:00
QueryReply ( ) { type = 6000 ; } ;
2013-05-27 13:53:28 +03:00
QueryReply ( QueryID QID , ui32 Answer ) : qid ( QID ) , answer ( Answer ) { type = 6000 ; } ;
QueryID qid ;
ui32 answer ; //hero and artifact id
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-03-09 12:37:49 +02:00
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2011-09-06 09:00:32 +03:00
h & qid & answer & player ;
2009-03-09 12:37:49 +02:00
}
} ;
struct MakeAction : public CPackForServer
{
MakeAction ( ) { } ;
2009-03-09 21:40:43 +02:00
MakeAction ( const BattleAction & BA ) : ba ( BA ) { } ;
2009-03-09 12:37:49 +02:00
BattleAction ba ;
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & ba ;
}
} ;
struct MakeCustomAction : public CPackForServer
{
MakeCustomAction ( ) { } ;
2009-03-20 20:51:48 +02:00
MakeCustomAction ( const BattleAction & BA ) : ba ( BA ) { } ;
2009-03-09 12:37:49 +02:00
BattleAction ba ;
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & ba ;
}
} ;
2010-02-21 17:03:30 +02:00
struct DigWithHero : public CPackForServer
{
DigWithHero ( ) { }
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ; //digging hero id
2010-02-21 17:03:30 +02:00
bool applyGh ( CGameHandler * gh ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & id ;
}
} ;
2010-03-11 01:16:30 +02:00
struct CastAdvSpell : public CPackForServer
{
CastAdvSpell ( ) { }
2013-02-14 02:55:42 +03:00
ObjectInstanceID hid ; //hero id
2013-02-11 02:24:57 +03:00
SpellID sid ; //spell id
2010-03-11 01:16:30 +02:00
int3 pos ; //selected tile (not always used)
bool applyGh ( CGameHandler * gh ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & hid & sid & pos ;
}
} ;
2009-03-09 12:37:49 +02:00
/***********************************************************************************************************/
2009-03-28 20:46:20 +02:00
struct SaveGame : public CPackForClient , public CPackForServer
{
SaveGame ( ) { } ;
SaveGame ( const std : : string & Fname ) : fname ( Fname ) { } ;
std : : string fname ;
void applyCl ( CClient * cl ) ;
void applyGs ( CGameState * gs ) { } ;
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-28 20:46:20 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & fname ;
}
} ;
2009-03-09 12:37:49 +02:00
struct PlayerMessage : public CPackForClient , public CPackForServer //513
{
PlayerMessage ( ) { CPackForClient : : type = 513 ; } ;
2013-03-03 20:06:03 +03:00
PlayerMessage ( PlayerColor Player , const std : : string & Text )
2009-03-09 12:37:49 +02:00
: player ( Player ) , text ( Text )
{ CPackForClient : : type = 513 ; } ;
void applyCl ( CClient * cl ) ;
void applyGs ( CGameState * gs ) { } ;
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-03-09 12:37:49 +02:00
std : : string text ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & text & player ;
}
2012-09-15 22:16:16 +03:00
} ;
2009-03-09 12:37:49 +02:00
2009-08-13 04:03:11 +03:00
struct CenterView : public CPackForClient //515
2009-08-11 10:50:29 +03:00
{
2009-08-13 04:03:11 +03:00
CenterView ( ) { CPackForClient : : type = 515 ; } ;
2009-08-11 10:50:29 +03:00
void applyCl ( CClient * cl ) ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-08-13 04:03:11 +03:00
int3 pos ;
ui32 focusTime ; //ms
2009-08-11 10:50:29 +03:00
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2009-08-13 04:03:11 +03:00
h & pos & player & focusTime ;
2009-03-09 12:37:49 +02:00
}
2010-02-06 15:49:14 +02:00
} ;
2010-09-03 21:42:54 +03:00
/***********************************************************************************************************/
struct CPackForSelectionScreen : public CPack
{
void apply ( CSelectionScreen * selScreen ) { } ; //that functions are implemented in CPreGame.cpp
} ;
2010-10-24 14:35:14 +03:00
class CPregamePackToPropagate : public CPackForSelectionScreen
{ } ;
class CPregamePackToHost : public CPackForSelectionScreen
{ } ;
struct ChatMessage : public CPregamePackToPropagate
2010-09-03 21:42:54 +03:00
{
std : : string playerName , message ;
void apply ( CSelectionScreen * selScreen ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & playerName & message ;
}
} ;
2009-08-11 10:50:29 +03:00
2010-10-24 14:35:14 +03:00
struct QuitMenuWithoutStarting : public CPregamePackToPropagate
{
void apply ( CSelectionScreen * selScreen ) ; //that functions are implemented in CPreGame.cpp
template < typename Handler > void serialize ( Handler & h , const int version )
{ }
} ;
struct PlayerJoined : public CPregamePackToHost
{
std : : string playerName ;
ui8 connectionID ;
void apply ( CSelectionScreen * selScreen ) ; //that functions are implemented in CPreGame.cpp
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & playerName & connectionID ;
}
} ;
2014-06-26 18:34:54 +03:00
struct ELF_VISIBILITY SelectMap : public CPregamePackToPropagate
2010-10-24 14:35:14 +03:00
{
const CMapInfo * mapInfo ;
2014-06-26 19:49:18 +03:00
bool free ; //local flag, do not serialize
2010-10-24 14:35:14 +03:00
2014-06-26 19:41:27 +03:00
DLL_LINKAGE SelectMap ( const CMapInfo & src ) ;
DLL_LINKAGE SelectMap ( ) ;
2014-06-25 17:11:07 +03:00
DLL_LINKAGE ~ SelectMap ( ) ;
2010-10-24 14:35:14 +03:00
void apply ( CSelectionScreen * selScreen ) ; //that functions are implemented in CPreGame.cpp
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & mapInfo ;
}
} ;
2014-06-26 18:34:54 +03:00
struct ELF_VISIBILITY UpdateStartOptions : public CPregamePackToPropagate
2010-10-24 14:35:14 +03:00
{
StartInfo * options ;
2014-06-26 19:49:18 +03:00
bool free ; //local flag, do not serialize
2010-10-24 14:35:14 +03:00
void apply ( CSelectionScreen * selScreen ) ; //that functions are implemented in CPreGame.cpp
2014-06-26 19:41:27 +03:00
DLL_LINKAGE UpdateStartOptions ( StartInfo & src ) ;
DLL_LINKAGE UpdateStartOptions ( ) ;
2014-06-25 17:11:07 +03:00
DLL_LINKAGE ~ UpdateStartOptions ( ) ;
2010-10-24 14:35:14 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & options ;
}
} ;
struct PregameGuiAction : public CPregamePackToPropagate
{
2013-02-04 22:43:16 +03:00
enum { NO_TAB , OPEN_OPTIONS , OPEN_SCENARIO_LIST , OPEN_RANDOM_MAP_OPTIONS }
action ;
2010-10-24 14:35:14 +03:00
void apply ( CSelectionScreen * selScreen ) ; //that functions are implemented in CPreGame.cpp
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & action ;
}
} ;
struct RequestOptionsChange : public CPregamePackToHost
{
2013-02-04 22:43:16 +03:00
enum EWhat { TOWN , HERO , BONUS } ;
2010-10-24 14:35:14 +03:00
ui8 what ;
2012-09-15 22:16:16 +03:00
si8 direction ; //-1 or +1
2013-03-03 20:06:03 +03:00
ui8 playerID ;
2010-10-24 14:35:14 +03:00
2013-03-03 20:06:03 +03:00
RequestOptionsChange ( ui8 What , si8 Dir , ui8 Player )
2010-10-24 14:35:14 +03:00
: what ( What ) , direction ( Dir ) , playerID ( Player )
{ }
RequestOptionsChange ( ) { }
void apply ( CSelectionScreen * selScreen ) ; //that functions are implemented in CPreGame.cpp
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & what & direction & playerID ;
}
} ;
struct PlayerLeft : public CPregamePackToPropagate
{
2013-03-03 20:06:03 +03:00
ui8 playerID ;
2010-10-24 14:35:14 +03:00
void apply ( CSelectionScreen * selScreen ) ; //that functions are implemented in CPreGame.cpp
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & playerID ;
}
} ;
struct PlayersNames : public CPregamePackToPropagate
{
public :
2013-03-03 20:06:03 +03:00
std : : map < ui8 , std : : string > playerNames ;
2010-10-24 14:35:14 +03:00
void apply ( CSelectionScreen * selScreen ) ; //that functions are implemented in CPreGame.cpp
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & playerNames ;
}
} ;
struct StartWithCurrentSettings : public CPregamePackToPropagate
{
public :
void apply ( CSelectionScreen * selScreen ) ; //that functions are implemented in CPreGame.cpp
template < typename Handler > void serialize ( Handler & h , const int version )
{
//h & playerNames;
}
} ;