2023-10-19 16:19:09 +02:00
/*
2023-10-23 15:38:05 +02:00
* PacksForClient . h , part of VCMI engine
2023-10-19 16:19:09 +02:00
*
* 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
*
*/
# pragma once
2023-10-23 15:38:05 +02:00
# include "ArtifactLocation.h"
2023-10-23 12:59:15 +02:00
# include "Component.h"
# include "EInfoWindowMode.h"
2023-10-23 15:38:05 +02:00
# include "EOpenWindowMode.h"
2023-10-23 12:59:15 +02:00
# include "EntityChanges.h"
2023-10-23 15:38:05 +02:00
# include "NetPacksBase.h"
2023-11-06 18:27:16 +02:00
# include "ObjProperty.h"
2023-10-23 12:59:15 +02:00
# include "../CCreatureSet.h"
# include "../ResourceSet.h"
# include "../TurnTimerInfo.h"
# include "../gameState/EVictoryLossCheckResult.h"
2024-06-01 18:38:41 +02:00
# include "../gameState/RumorState.h"
2023-10-23 12:59:15 +02:00
# include "../gameState/QuestInfo.h"
# include "../gameState/TavernSlot.h"
2024-08-11 22:21:13 +02:00
# include "../gameState/GameStatistics.h"
2023-10-23 12:59:15 +02:00
# include "../int3.h"
# include "../mapping/CMapDefines.h"
# include "../spells/ViewSpellInt.h"
2023-10-19 16:19:09 +02:00
class CClient ;
class CGameHandler ;
VCMI_LIB_NAMESPACE_BEGIN
class CGameState ;
class CArtifact ;
class CGObjectInstance ;
class CArtifactInstance ;
struct StackLocation ;
struct ArtSlotInfo ;
struct QuestInfo ;
class IBattleState ;
class BattleInfo ;
// This one teleport-specific, but has to be available everywhere in callbacks and netpacks
// For now it's will be there till teleports code refactored and moved into own file
using TTeleportExitsList = std : : vector < std : : pair < ObjectInstanceID , int3 > > ;
/***********************************************************************************************************/
struct DLL_LINKAGE PackageApplied : public CPackForClient
{
PackageApplied ( ) = default ;
2023-10-23 12:59:15 +02:00
explicit PackageApplied ( ui8 Result )
2023-10-19 16:19:09 +02:00
: result ( Result )
{
}
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override { }
2023-10-19 16:19:09 +02:00
ui8 result = 0 ; //0 - something went wrong, request hasn't been realized; 1 - OK
ui32 packType = 0 ; //type id of applied package
ui32 requestID = 0 ; //an ID given by client to the request that was applied
PlayerColor player ;
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & result ;
h & packType ;
h & requestID ;
h & player ;
}
} ;
struct DLL_LINKAGE SystemMessage : public CPackForClient
{
2024-05-02 21:03:23 +02:00
explicit SystemMessage ( MetaString Text )
2023-10-19 16:19:09 +02:00
: text ( std : : move ( Text ) )
{
}
SystemMessage ( ) = default ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override { }
2023-10-19 16:19:09 +02:00
2024-05-02 21:03:23 +02:00
MetaString text ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & text ;
}
} ;
struct DLL_LINKAGE PlayerBlocked : public CPackForClient
{
enum EReason { UPCOMING_BATTLE , ONGOING_MOVEMENT } ;
enum EMode { BLOCKADE_STARTED , BLOCKADE_ENDED } ;
EReason reason = UPCOMING_BATTLE ;
EMode startOrEnd = BLOCKADE_STARTED ;
PlayerColor player ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override { }
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & reason ;
h & startOrEnd ;
h & player ;
}
} ;
struct DLL_LINKAGE PlayerCheated : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
PlayerColor player ;
bool losingCheatCode = false ;
bool winningCheatCode = false ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & player ;
h & losingCheatCode ;
h & winningCheatCode ;
}
} ;
struct DLL_LINKAGE TurnTimeUpdate : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
PlayerColor player ;
TurnTimerInfo turnTimer ;
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & player ;
h & turnTimer ;
}
} ;
struct DLL_LINKAGE PlayerStartsTurn : public Query
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
PlayerColor player ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & queryID ;
h & player ;
}
} ;
struct DLL_LINKAGE DaysWithoutTown : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
PlayerColor player ;
std : : optional < int32_t > daysWithoutCastle ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & player ;
h & daysWithoutCastle ;
}
} ;
struct DLL_LINKAGE EntitiesChanged : public CPackForClient
{
std : : vector < EntityChanges > changes ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & changes ;
}
} ;
struct DLL_LINKAGE SetResources : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
bool abs = true ; //false - changes by value; 1 - sets to value
PlayerColor player ;
2023-10-23 12:59:15 +02:00
ResourceSet res ; //res[resid] => res amount
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & abs ;
h & player ;
h & res ;
}
} ;
struct DLL_LINKAGE SetPrimSkill : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
ui8 abs = 0 ; //0 - changes by value; 1 - sets to value
ObjectInstanceID id ;
PrimarySkill which = PrimarySkill : : ATTACK ;
si64 val = 0 ;
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & abs ;
h & id ;
h & which ;
h & val ;
}
} ;
struct DLL_LINKAGE SetSecSkill : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
ui8 abs = 0 ; //0 - changes by value; 1 - sets to value
ObjectInstanceID id ;
SecondarySkill which ;
ui16 val = 0 ;
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & abs ;
h & id ;
h & which ;
h & val ;
}
} ;
struct DLL_LINKAGE HeroVisitCastle : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
ui8 flags = 0 ; //1 - start
2024-01-10 00:38:54 +02:00
ObjectInstanceID tid ;
ObjectInstanceID hid ;
2023-10-19 16:19:09 +02:00
bool start ( ) const //if hero is entering castle (if false - leaving)
{
return flags & 1 ;
}
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & flags ;
h & tid ;
h & hid ;
}
} ;
struct DLL_LINKAGE ChangeSpells : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
ui8 learn = 1 ; //1 - gives spell, 0 - takes
ObjectInstanceID hid ;
std : : set < SpellID > spells ;
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & learn ;
h & hid ;
h & spells ;
}
} ;
2024-09-28 15:05:13 +02:00
struct DLL_LINKAGE SetResearchedSpells : public CPackForClient
2024-09-27 22:47:22 +02:00
{
void applyGs ( CGameState * gs ) override ;
void visitTyped ( ICPackVisitor & visitor ) override ;
ui8 level = 0 ;
ObjectInstanceID tid ;
std : : vector < SpellID > spells ;
2024-09-28 15:05:13 +02:00
bool accepted ;
2024-09-27 22:47:22 +02:00
template < typename Handler > void serialize ( Handler & h )
{
h & level ;
h & tid ;
h & spells ;
2024-09-28 15:05:13 +02:00
h & accepted ;
2024-09-27 22:47:22 +02:00
}
} ;
2023-10-19 16:19:09 +02:00
struct DLL_LINKAGE SetMana : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-08-25 23:35:32 +02:00
SetMana ( ) = default ;
SetMana ( ObjectInstanceID hid , si32 val , bool absolute )
: hid ( hid )
, val ( val )
, absolute ( absolute )
{ }
2023-10-19 16:19:09 +02:00
ObjectInstanceID hid ;
si32 val = 0 ;
bool absolute = true ;
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & val ;
h & hid ;
h & absolute ;
}
} ;
struct DLL_LINKAGE SetMovePoints : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2024-08-25 23:35:32 +02:00
SetMovePoints ( ) = default ;
SetMovePoints ( ObjectInstanceID hid , si32 val , bool absolute )
: hid ( hid )
, val ( val )
, absolute ( absolute )
{ }
2023-10-19 16:19:09 +02:00
ObjectInstanceID hid ;
si32 val = 0 ;
bool absolute = true ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & val ;
h & hid ;
h & absolute ;
}
} ;
struct DLL_LINKAGE FoWChange : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
std : : unordered_set < int3 > tiles ;
PlayerColor player ;
2023-10-22 17:36:41 +02:00
ETileVisibility mode ;
2023-10-19 16:19:09 +02:00
bool waitForDialogs = false ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & tiles ;
h & player ;
h & mode ;
h & waitForDialogs ;
}
} ;
struct DLL_LINKAGE SetAvailableHero : public CPackForClient
{
SetAvailableHero ( )
{
army . clearSlots ( ) ;
}
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
TavernHeroSlot slotID ;
TavernSlotRole roleID ;
PlayerColor player ;
HeroTypeID hid ; //HeroTypeID::NONE if no hero
CSimpleArmy army ;
2024-01-15 22:25:52 +02:00
bool replenishPoints ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & slotID ;
h & roleID ;
h & player ;
h & hid ;
h & army ;
2024-01-15 22:25:52 +02:00
h & replenishPoints ;
2023-10-19 16:19:09 +02:00
}
} ;
struct DLL_LINKAGE GiveBonus : public CPackForClient
{
2023-11-06 18:27:16 +02:00
enum class ETarget : int8_t { OBJECT , PLAYER , BATTLE } ;
2023-10-19 16:19:09 +02:00
2023-11-06 18:27:16 +02:00
explicit GiveBonus ( ETarget Who = ETarget : : OBJECT )
2023-10-19 16:19:09 +02:00
: who ( Who )
{
}
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-11-06 18:27:16 +02:00
ETarget who = ETarget : : OBJECT ;
VariantIdentifier < ObjectInstanceID , PlayerColor , BattleID > id ;
2023-10-19 16:19:09 +02:00
Bonus bonus ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & bonus ;
h & id ;
h & who ;
2023-11-06 18:27:16 +02:00
assert ( id . getNum ( ) ! = - 1 ) ;
2023-10-19 16:19:09 +02:00
}
} ;
struct DLL_LINKAGE ChangeObjPos : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
/// Object to move
ObjectInstanceID objid ;
/// New position of visitable tile of an object
int3 nPos ;
/// Player that initiated this action, if any
PlayerColor initiator ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & objid ;
h & nPos ;
h & initiator ;
}
} ;
struct DLL_LINKAGE PlayerEndsTurn : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
PlayerColor player ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & player ;
}
} ;
struct DLL_LINKAGE PlayerEndsGame : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
PlayerColor player ;
EVictoryLossCheckResult victoryLossCheckResult ;
2024-08-11 22:21:13 +02:00
StatisticDataSet statistic ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & player ;
h & victoryLossCheckResult ;
2024-08-14 21:51:08 +02:00
if ( h . version > = Handler : : Version : : STATISTICS_SCREEN )
2024-08-11 22:21:13 +02:00
h & statistic ;
2023-10-19 16:19:09 +02:00
}
} ;
struct DLL_LINKAGE PlayerReinitInterface : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
std : : vector < PlayerColor > players ;
ui8 playerConnectionId ; //PLAYER_AI for AI player
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & players ;
h & playerConnectionId ;
}
} ;
struct DLL_LINKAGE RemoveBonus : public CPackForClient
{
2023-11-06 18:27:16 +02:00
explicit RemoveBonus ( GiveBonus : : ETarget Who = GiveBonus : : ETarget : : OBJECT )
2023-10-19 16:19:09 +02:00
: who ( Who )
{
}
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
GiveBonus : : ETarget who ; //who receives bonus
2023-11-06 18:27:16 +02:00
VariantIdentifier < HeroTypeID , PlayerColor , BattleID , ObjectInstanceID > whoID ;
2023-10-19 16:19:09 +02:00
//vars to identify bonus: its source
2023-10-22 17:36:41 +02:00
BonusSource source ;
BonusSourceID id ; //source id
2023-10-19 16:19:09 +02:00
//used locally: copy of removed bonus
Bonus bonus ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & source ;
h & id ;
h & who ;
h & whoID ;
}
} ;
struct DLL_LINKAGE SetCommanderProperty : public CPackForClient
{
enum ECommanderProperty { ALIVE , BONUS , SECONDARY_SKILL , EXPERIENCE , SPECIAL_SKILL } ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
ObjectInstanceID heroid ;
ECommanderProperty which = ALIVE ;
TExpType amount = 0 ; //0 for dead, >0 for alive
si32 additionalInfo = 0 ; //for secondary skills choice
Bonus accumulatedBonus ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & heroid ;
h & which ;
h & amount ;
h & additionalInfo ;
h & accumulatedBonus ;
}
} ;
struct DLL_LINKAGE AddQuest : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
PlayerColor player ;
QuestInfo quest ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & player ;
h & quest ;
}
} ;
struct DLL_LINKAGE UpdateArtHandlerLists : public CPackForClient
{
2023-10-22 17:36:41 +02:00
std : : map < ArtifactID , int > allocatedArtifacts ;
2023-10-19 16:19:09 +02:00
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
2023-10-22 17:36:41 +02:00
h & allocatedArtifacts ;
2023-10-19 16:19:09 +02:00
}
} ;
struct DLL_LINKAGE ChangeFormation : public CPackForClient
{
ObjectInstanceID hid ;
2023-11-06 18:27:16 +02:00
EArmyFormation formation { } ;
2023-10-19 16:19:09 +02:00
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & hid ;
h & formation ;
}
} ;
struct DLL_LINKAGE RemoveObject : public CPackForClient
{
RemoveObject ( ) = default ;
RemoveObject ( const ObjectInstanceID & objectID , const PlayerColor & initiator )
: objectID ( objectID )
, initiator ( initiator )
{
}
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
/// ID of removed object
ObjectInstanceID objectID ;
/// Player that initiated this action, if any
PlayerColor initiator ;
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & objectID ;
h & initiator ;
}
} ;
struct DLL_LINKAGE TryMoveHero : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
enum EResult
{
FAILED ,
SUCCESS ,
TELEPORTATION ,
BLOCKING_VISIT ,
EMBARK ,
DISEMBARK
} ;
ObjectInstanceID id ;
ui32 movePoints = 0 ;
EResult result = FAILED ; //uses EResult
2024-01-10 00:38:54 +02:00
int3 start ; //h3m format
int3 end ;
2023-10-19 16:19:09 +02:00
std : : unordered_set < int3 > fowRevealed ; //revealed tiles
std : : optional < int3 > attackedFrom ; // Set when stepping into endangered tile.
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
bool stopMovement ( ) const
{
return result ! = SUCCESS & & result ! = EMBARK & & result ! = DISEMBARK & & result ! = TELEPORTATION ;
}
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & id ;
h & result ;
h & start ;
h & end ;
h & movePoints ;
h & fowRevealed ;
h & attackedFrom ;
}
} ;
struct DLL_LINKAGE NewStructures : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
ObjectInstanceID tid ;
std : : set < BuildingID > bid ;
2024-06-24 03:23:26 +02:00
si16 built = 0 ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & tid ;
h & bid ;
2024-06-24 03:23:26 +02:00
h & built ;
2023-10-19 16:19:09 +02:00
}
} ;
struct DLL_LINKAGE RazeStructures : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
ObjectInstanceID tid ;
std : : set < BuildingID > bid ;
si16 destroyed = 0 ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & tid ;
h & bid ;
h & destroyed ;
}
} ;
struct DLL_LINKAGE SetAvailableCreatures : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
ObjectInstanceID tid ;
std : : vector < std : : pair < ui32 , std : : vector < CreatureID > > > creatures ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & tid ;
h & creatures ;
}
} ;
struct DLL_LINKAGE SetHeroesInTown : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2024-01-10 00:38:54 +02:00
ObjectInstanceID tid ; //id of town
ObjectInstanceID visiting ; //id of visiting hero
ObjectInstanceID garrison ; //id of hero in garrison
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & tid ;
h & visiting ;
h & garrison ;
}
} ;
struct DLL_LINKAGE HeroRecruited : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
HeroTypeID hid ; //subID of hero
ObjectInstanceID tid ;
ObjectInstanceID boatId ;
int3 tile ;
PlayerColor player ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & hid ;
h & tid ;
h & boatId ;
h & tile ;
h & player ;
}
} ;
struct DLL_LINKAGE GiveHero : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
ObjectInstanceID id ; //object id
ObjectInstanceID boatId ;
PlayerColor player ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & id ;
h & boatId ;
h & player ;
}
} ;
struct DLL_LINKAGE OpenWindow : public Query
{
EOpenWindowMode window ;
ObjectInstanceID object ;
ObjectInstanceID visitor ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override { }
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & queryID ;
h & window ;
h & object ;
h & visitor ;
}
} ;
struct DLL_LINKAGE NewObject : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
/// Object ID to create
2024-07-12 18:51:27 +02:00
CGObjectInstance * newObject ;
2023-10-19 16:19:09 +02:00
/// Which player initiated creation of this object
PlayerColor initiator ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
2024-07-12 18:51:27 +02:00
h & newObject ;
2023-10-19 16:19:09 +02:00
h & initiator ;
}
} ;
struct DLL_LINKAGE SetAvailableArtifacts : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-11-06 18:27:16 +02:00
//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)
ObjectInstanceID id ;
2023-10-19 16:19:09 +02:00
std : : vector < const CArtifact * > arts ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & id ;
h & arts ;
}
} ;
struct DLL_LINKAGE CGarrisonOperationPack : CPackForClient
{
} ;
struct DLL_LINKAGE ChangeStackCount : CGarrisonOperationPack
{
ObjectInstanceID army ;
SlotID slot ;
TQuantity count ;
bool absoluteValue ; //if not -> count will be added (or subtracted if negative)
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & army ;
h & slot ;
h & count ;
h & absoluteValue ;
}
} ;
struct DLL_LINKAGE SetStackType : CGarrisonOperationPack
{
ObjectInstanceID army ;
SlotID slot ;
CreatureID type ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & army ;
h & slot ;
h & type ;
}
} ;
struct DLL_LINKAGE EraseStack : CGarrisonOperationPack
{
ObjectInstanceID army ;
SlotID slot ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & army ;
h & slot ;
}
} ;
struct DLL_LINKAGE SwapStacks : CGarrisonOperationPack
{
ObjectInstanceID srcArmy ;
ObjectInstanceID dstArmy ;
SlotID srcSlot ;
SlotID dstSlot ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & srcArmy ;
h & dstArmy ;
h & srcSlot ;
h & dstSlot ;
}
} ;
struct DLL_LINKAGE InsertNewStack : CGarrisonOperationPack
{
ObjectInstanceID army ;
SlotID slot ;
CreatureID type ;
TQuantity count = 0 ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & army ;
h & slot ;
h & type ;
h & count ;
}
} ;
///moves creatures from src stack to dst slot, may be used for merging/splittint/moving stacks
struct DLL_LINKAGE RebalanceStacks : CGarrisonOperationPack
{
ObjectInstanceID srcArmy ;
ObjectInstanceID dstArmy ;
SlotID srcSlot ;
SlotID dstSlot ;
TQuantity count ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & srcArmy ;
h & dstArmy ;
h & srcSlot ;
h & dstSlot ;
h & count ;
}
} ;
struct DLL_LINKAGE BulkRebalanceStacks : CGarrisonOperationPack
{
std : : vector < RebalanceStacks > moves ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
template < typename Handler >
2024-01-20 20:34:51 +02:00
void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & moves ;
}
} ;
struct DLL_LINKAGE BulkSmartRebalanceStacks : CGarrisonOperationPack
{
std : : vector < RebalanceStacks > moves ;
std : : vector < ChangeStackCount > changes ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
template < typename Handler >
2024-01-20 20:34:51 +02:00
void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & moves ;
h & changes ;
}
} ;
struct DLL_LINKAGE CArtifactOperationPack : CPackForClient
{
} ;
struct DLL_LINKAGE PutArtifact : CArtifactOperationPack
{
PutArtifact ( ) = default ;
2024-09-06 16:59:40 +02:00
explicit PutArtifact ( const ArtifactInstanceID & id , const ArtifactLocation & dst , bool askAssemble = true )
2024-09-19 15:51:59 +02:00
: al ( dst ) , askAssemble ( askAssemble ) , id ( id )
2023-10-19 16:19:09 +02:00
{
}
ArtifactLocation al ;
2023-11-08 19:54:02 +02:00
bool askAssemble ;
2024-09-06 16:59:40 +02:00
ArtifactInstanceID id ;
2023-10-19 16:19:09 +02:00
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & al ;
h & askAssemble ;
2024-09-06 16:59:40 +02:00
h & id ;
2023-10-19 16:19:09 +02:00
}
} ;
struct DLL_LINKAGE NewArtifact : public CArtifactOperationPack
{
2024-09-04 15:25:30 +02:00
ObjectInstanceID artHolder ;
2024-09-04 19:39:13 +02:00
ArtifactID artId ;
SpellID spellId ;
2024-09-04 15:25:30 +02:00
ArtifactPosition pos ;
2023-10-19 16:19:09 +02:00
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
2024-09-04 15:25:30 +02:00
h & artHolder ;
2024-09-04 19:39:13 +02:00
h & artId ;
h & spellId ;
2024-09-04 15:25:30 +02:00
h & pos ;
2023-10-19 16:19:09 +02:00
}
} ;
2024-08-29 17:47:06 +02:00
struct DLL_LINKAGE BulkEraseArtifacts : CArtifactOperationPack
2023-10-19 16:19:09 +02:00
{
2024-08-29 17:47:06 +02:00
ObjectInstanceID artHolder ;
std : : vector < ArtifactPosition > posPack ;
std : : optional < SlotID > creature ;
2023-10-19 16:19:09 +02:00
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
2024-08-29 17:47:06 +02:00
h & artHolder ;
h & posPack ;
h & creature ;
2023-10-19 16:19:09 +02:00
}
} ;
struct DLL_LINKAGE BulkMoveArtifacts : CArtifactOperationPack
{
struct LinkedSlots
{
ArtifactPosition srcPos ;
ArtifactPosition dstPos ;
2024-06-22 18:29:39 +02:00
bool askAssemble ;
2023-10-19 16:19:09 +02:00
LinkedSlots ( ) = default ;
2024-06-22 18:29:39 +02:00
LinkedSlots ( const ArtifactPosition & srcPos , const ArtifactPosition & dstPos , bool askAssemble = false )
2023-10-19 16:19:09 +02:00
: srcPos ( srcPos )
, dstPos ( dstPos )
2024-06-22 18:29:39 +02:00
, askAssemble ( askAssemble )
2023-10-19 16:19:09 +02:00
{
}
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & srcPos ;
h & dstPos ;
2024-06-22 18:29:39 +02:00
h & askAssemble ;
2023-10-19 16:19:09 +02:00
}
} ;
2024-03-07 16:52:50 +02:00
PlayerColor interfaceOwner ;
2023-10-23 18:39:12 +02:00
ObjectInstanceID srcArtHolder ;
ObjectInstanceID dstArtHolder ;
2023-11-07 22:12:32 +02:00
std : : optional < SlotID > srcCreature ;
std : : optional < SlotID > dstCreature ;
2023-10-19 16:19:09 +02:00
BulkMoveArtifacts ( )
2024-03-07 16:52:50 +02:00
: interfaceOwner ( PlayerColor : : NEUTRAL )
, srcArtHolder ( ObjectInstanceID : : NONE )
2023-10-23 18:39:12 +02:00
, dstArtHolder ( ObjectInstanceID : : NONE )
2023-11-07 22:12:32 +02:00
, srcCreature ( std : : nullopt )
, dstCreature ( std : : nullopt )
2023-10-19 16:19:09 +02:00
{
}
2024-03-07 16:52:50 +02:00
BulkMoveArtifacts ( const PlayerColor & interfaceOwner , const ObjectInstanceID srcArtHolder , const ObjectInstanceID dstArtHolder , bool swap )
: interfaceOwner ( interfaceOwner )
2024-03-08 14:21:29 +02:00
, srcArtHolder ( srcArtHolder )
, dstArtHolder ( dstArtHolder )
2023-11-07 22:12:32 +02:00
, srcCreature ( std : : nullopt )
, dstCreature ( std : : nullopt )
2023-10-19 16:19:09 +02:00
{
}
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
std : : vector < LinkedSlots > artsPack0 ;
std : : vector < LinkedSlots > artsPack1 ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
2024-03-07 16:52:50 +02:00
h & interfaceOwner ;
2023-10-19 16:19:09 +02:00
h & artsPack0 ;
h & artsPack1 ;
h & srcArtHolder ;
h & dstArtHolder ;
2023-11-07 22:12:32 +02:00
h & srcCreature ;
h & dstCreature ;
2023-10-19 16:19:09 +02:00
}
} ;
struct DLL_LINKAGE AssembledArtifact : CArtifactOperationPack
{
2024-10-12 12:33:46 +02:00
ArtifactLocation al ;
ArtifactID artId ;
2023-10-19 16:19:09 +02:00
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & al ;
2024-10-12 12:33:46 +02:00
h & artId ;
2023-10-19 16:19:09 +02:00
}
} ;
struct DLL_LINKAGE DisassembledArtifact : CArtifactOperationPack
{
ArtifactLocation al ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & al ;
}
} ;
struct DLL_LINKAGE HeroVisit : public CPackForClient
{
PlayerColor player ;
ObjectInstanceID heroId ;
ObjectInstanceID objId ;
bool starting ; //false -> ending
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & player ;
h & heroId ;
h & objId ;
h & starting ;
}
} ;
2024-08-26 15:49:50 +02:00
struct DLL_LINKAGE InfoWindow : public CPackForClient //103 - displays simple info window
{
EInfoWindowMode type = EInfoWindowMode : : MODAL ;
MetaString text ;
std : : vector < Component > components ;
PlayerColor player ;
ui16 soundID = 0 ;
void visitTyped ( ICPackVisitor & visitor ) override ;
2024-08-28 15:12:11 +02:00
void applyGs ( CGameState * gs ) override { }
2024-08-26 15:49:50 +02:00
template < typename Handler > void serialize ( Handler & h )
{
h & type ;
h & text ;
h & components ;
h & player ;
h & soundID ;
}
InfoWindow ( ) = default ;
} ;
2023-10-19 16:19:09 +02:00
struct DLL_LINKAGE NewTurn : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
ui32 day = 0 ;
CreatureID creatureid ; //for creature weeks
2024-08-25 23:35:32 +02:00
EWeekType specialWeek = EWeekType : : NORMAL ;
std : : vector < SetMovePoints > heroesMovement ;
std : : vector < SetMana > heroesMana ;
std : : vector < SetAvailableCreatures > availableCreatures ;
std : : map < PlayerColor , ResourceSet > playerIncome ;
2024-06-01 18:38:41 +02:00
std : : optional < RumorState > newRumor ; // only on new weeks
2024-08-26 15:49:50 +02:00
std : : optional < InfoWindow > newWeekNotification ; // only on new week
2023-10-19 16:19:09 +02:00
NewTurn ( ) = default ;
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & day ;
h & creatureid ;
2024-08-25 23:35:32 +02:00
h & specialWeek ;
h & heroesMovement ;
h & heroesMana ;
h & availableCreatures ;
h & playerIncome ;
2024-06-01 18:38:41 +02:00
h & newRumor ;
2024-08-26 15:49:50 +02:00
h & newWeekNotification ;
2023-10-19 16:19:09 +02:00
}
} ;
struct DLL_LINKAGE SetObjectProperty : public CPackForClient
{
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
ObjectInstanceID id ;
2023-11-06 18:27:16 +02:00
ObjProperty what { } ;
ObjPropertyID identifier ;
2023-10-19 16:19:09 +02:00
SetObjectProperty ( ) = default ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & id ;
h & what ;
2023-11-06 18:27:16 +02:00
h & identifier ;
2023-10-19 16:19:09 +02:00
}
} ;
struct DLL_LINKAGE ChangeObjectVisitors : public CPackForClient
{
enum VisitMode
{
2024-08-30 17:24:13 +02:00
VISITOR_ADD_HERO , // mark hero as one that have visited this object
VISITOR_ADD_PLAYER , // mark player as one that have visited this object instance
VISITOR_GLOBAL , // mark player as one that have visited object of this type
VISITOR_SCOUTED , // marks targeted team as having scouted this object
VISITOR_CLEAR , // clear all visitors from this object (object reset)
2023-10-19 16:19:09 +02:00
} ;
2023-11-17 21:18:34 +02:00
VisitMode mode = VISITOR_CLEAR ; // uses VisitMode enum
2023-10-19 16:19:09 +02:00
ObjectInstanceID object ;
ObjectInstanceID hero ; // note: hero owner will be also marked as "visited" this object
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
ChangeObjectVisitors ( ) = default ;
2023-11-17 21:18:34 +02:00
ChangeObjectVisitors ( VisitMode mode , const ObjectInstanceID & object , const ObjectInstanceID & heroID = ObjectInstanceID ( - 1 ) )
2023-10-19 16:19:09 +02:00
: mode ( mode )
, object ( object )
, hero ( heroID )
{
}
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & object ;
h & hero ;
h & mode ;
}
} ;
2024-03-30 17:18:50 +02:00
struct DLL_LINKAGE ChangeArtifactsCostume : public CPackForClient
{
std : : map < ArtifactPosition , ArtifactID > costumeSet ;
2024-04-27 01:08:47 +02:00
uint32_t costumeIdx = 0 ;
2024-04-19 16:14:41 +02:00
const PlayerColor player = PlayerColor : : NEUTRAL ;
2024-03-30 17:18:50 +02:00
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2024-03-30 17:18:50 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
ChangeArtifactsCostume ( ) = default ;
2024-04-27 01:08:47 +02:00
ChangeArtifactsCostume ( const PlayerColor & player , const uint32_t costumeIdx )
2024-03-30 17:18:50 +02:00
: costumeIdx ( costumeIdx )
, player ( player )
{
}
template < typename Handler > void serialize ( Handler & h )
{
h & costumeSet ;
h & costumeIdx ;
h & player ;
}
} ;
2023-10-19 16:19:09 +02:00
struct DLL_LINKAGE HeroLevelUp : public Query
{
PlayerColor player ;
ObjectInstanceID heroId ;
PrimarySkill primskill = PrimarySkill : : ATTACK ;
std : : vector < SecondarySkill > skills ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & queryID ;
h & player ;
h & heroId ;
h & primskill ;
h & skills ;
}
} ;
struct DLL_LINKAGE CommanderLevelUp : public Query
{
PlayerColor player ;
ObjectInstanceID heroId ;
std : : vector < ui32 > skills ; //0-5 - secondary skills, val-100 - special skill
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override ;
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & queryID ;
h & player ;
h & heroId ;
h & skills ;
}
} ;
//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 DLL_LINKAGE BlockingDialog : public Query
{
2024-04-17 01:08:27 +02:00
enum { ALLOW_CANCEL = 1 , SELECTION = 2 , SAFE_TO_AUTOACCEPT = 4 } ;
2023-10-19 16:19:09 +02:00
MetaString text ;
std : : vector < Component > components ;
PlayerColor player ;
ui8 flags = 0 ;
ui16 soundID = 0 ;
bool cancel ( ) const
{
return flags & ALLOW_CANCEL ;
}
bool selection ( ) const
{
return flags & SELECTION ;
}
2024-04-17 01:08:27 +02:00
bool safeToAutoaccept ( ) const
{
return flags & SAFE_TO_AUTOACCEPT ;
}
2023-10-19 16:19:09 +02:00
BlockingDialog ( bool yesno , bool Selection )
{
if ( yesno ) flags | = ALLOW_CANCEL ;
if ( Selection ) flags | = SELECTION ;
}
BlockingDialog ( ) = default ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override { }
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & queryID ;
h & text ;
h & components ;
h & player ;
h & flags ;
h & soundID ;
}
} ;
struct DLL_LINKAGE GarrisonDialog : public Query
{
2024-01-10 00:38:54 +02:00
ObjectInstanceID objid ;
ObjectInstanceID hid ;
2023-10-19 16:19:09 +02:00
bool removableUnits = false ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override { }
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & queryID ;
h & objid ;
h & hid ;
h & removableUnits ;
}
} ;
struct DLL_LINKAGE ExchangeDialog : public Query
{
PlayerColor player ;
ObjectInstanceID hero1 ;
ObjectInstanceID hero2 ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override { }
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & queryID ;
h & player ;
h & hero1 ;
h & hero2 ;
}
} ;
struct DLL_LINKAGE TeleportDialog : public Query
{
TeleportDialog ( ) = default ;
TeleportDialog ( const ObjectInstanceID & hero , const TeleportChannelID & Channel )
: hero ( hero )
, channel ( Channel )
{
}
ObjectInstanceID hero ;
TeleportChannelID channel ;
TTeleportExitsList exits ;
bool impassable = false ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override { }
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & queryID ;
h & hero ;
h & channel ;
h & exits ;
h & impassable ;
}
} ;
struct DLL_LINKAGE MapObjectSelectDialog : public Query
{
PlayerColor player ;
Component icon ;
MetaString title ;
MetaString description ;
std : : vector < ObjectInstanceID > objects ;
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override { }
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & queryID ;
h & player ;
h & icon ;
h & title ;
h & description ;
h & objects ;
}
} ;
2023-10-23 12:59:15 +02:00
struct DLL_LINKAGE AdvmapSpellCast : public CPackForClient
2023-10-19 16:19:09 +02:00
{
2023-10-23 12:59:15 +02:00
ObjectInstanceID casterID ;
SpellID spellID ;
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
2023-10-23 12:59:15 +02:00
h & casterID ;
2023-10-19 16:19:09 +02:00
h & spellID ;
}
2023-10-23 12:59:15 +02:00
protected :
void visitTyped ( ICPackVisitor & visitor ) override ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override { }
2023-10-19 16:19:09 +02:00
} ;
2023-10-23 12:59:15 +02:00
struct DLL_LINKAGE ShowWorldViewEx : public CPackForClient
2023-10-19 16:19:09 +02:00
{
2023-10-23 12:59:15 +02:00
PlayerColor player ;
bool showTerrain ; // TODO: send terrain state
2023-10-19 16:19:09 +02:00
2023-10-23 12:59:15 +02:00
std : : vector < ObjectPosInfo > objectPositions ;
2023-10-19 16:19:09 +02:00
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override { }
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
2023-10-23 12:59:15 +02:00
h & player ;
h & showTerrain ;
h & objectPositions ;
2023-10-19 16:19:09 +02:00
}
protected :
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2023-10-19 16:19:09 +02:00
} ;
struct DLL_LINKAGE PlayerMessageClient : public CPackForClient
{
PlayerMessageClient ( ) = default ;
PlayerMessageClient ( const PlayerColor & Player , std : : string Text )
: player ( Player )
, text ( std : : move ( Text ) )
{
}
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override { }
2023-10-19 16:19:09 +02:00
PlayerColor player ;
std : : string text ;
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & player ;
h & text ;
}
} ;
struct DLL_LINKAGE CenterView : public CPackForClient
{
PlayerColor player ;
int3 pos ;
ui32 focusTime = 0 ; //ms
2023-10-23 12:59:15 +02:00
void visitTyped ( ICPackVisitor & visitor ) override ;
2024-08-23 22:56:32 +02:00
void applyGs ( CGameState * gs ) override { }
2023-10-19 16:19:09 +02:00
2024-01-20 20:34:51 +02:00
template < typename Handler > void serialize ( Handler & h )
2023-10-19 16:19:09 +02:00
{
h & pos ;
h & player ;
h & focusTime ;
}
} ;
VCMI_LIB_NAMESPACE_END