Khaganat-NeL/khanat-opennel-code
2
0
Fork 0
Code Issues 21 Pull requests Projects Releases 1 Packages Wiki Activity
khanat-opennel-code/code/ryzom/common/src/game_share/r2_share_itf.h

1887 lines
77 KiB
C
Raw Normal View History

initial version
2010-05-06 00:08:41 +00:00
/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////
#ifndef R2_SHARE_ITF
#define R2_SHARE_ITF
#include "nel/misc/types_nl.h"
#if defined(NL_COMP_VC8) || defined(NL_COMP_VC9)
# include <memory>
#endif
#include "nel/misc/hierarchical_timer.h"
#include "nel/misc/string_conversion.h"
#include "nel/net/message.h"
#include "nel/net/module.h"
#include "nel/net/module_builder_parts.h"
#include "nel/net/module_message.h"
#include "nel/net/module_gateway.h"
#include "game_share/object.h"
#include "nel/misc/md5.h"
#include "game_share/r2_types.h"
namespace R2
{
class TRunningScenarioInfo;
class TCharMappedInfo;
struct TSessionLevel
{
enum TValues
{
sl_a = 1,
sl_b,
sl_c,
sl_d,
sl_e,
sl_f,
/// the highest valid value in the enum
last_enum_item = sl_f,
/// a value equal to the last enum item +1
end_of_enum,
invalid_val,
/// Number of enumerated values
nb_enum_items = 6
};
/// Index table to convert enum value to linear index table
const std::map<TValues, uint32> &getIndexTable() const
{
static std::map<TValues, uint32> indexTable;
static bool init = false;
if (!init)
{
// fill the index table
indexTable.insert(std::make_pair(sl_a, 0));
indexTable.insert(std::make_pair(sl_b, 1));
indexTable.insert(std::make_pair(sl_c, 2));
indexTable.insert(std::make_pair(sl_d, 3));
indexTable.insert(std::make_pair(sl_e, 4));
indexTable.insert(std::make_pair(sl_f, 5));
init = true;
}
return indexTable;
}
static const NLMISC::CStringConversion<TValues> &getConversionTable()
{
NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
NL_STRING_CONVERSION_TABLE_ENTRY(sl_a)
NL_STRING_CONVERSION_TABLE_ENTRY(sl_b)
NL_STRING_CONVERSION_TABLE_ENTRY(sl_c)
NL_STRING_CONVERSION_TABLE_ENTRY(sl_d)
NL_STRING_CONVERSION_TABLE_ENTRY(sl_e)
NL_STRING_CONVERSION_TABLE_ENTRY(sl_f)
NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
};
static NLMISC::CStringConversion<TValues>
conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
/ sizeof(TValues_nl_string_conversion_table[0]), invalid_val);
return conversionTable;
}
TValues _Value;
public:
TSessionLevel()
: _Value(invalid_val)
{
}
TSessionLevel(TValues value)
: _Value(value)
{
}
TSessionLevel(const std::string &str)
{
_Value = getConversionTable().fromString(str);
}
void serial(NLMISC::IStream &s)
{
s.serialEnum(_Value);
}
bool operator == (const TSessionLevel &other) const
{
return _Value == other._Value;
}
bool operator != (const TSessionLevel &other) const
{
return ! (_Value == other._Value);
}
bool operator < (const TSessionLevel &other) const
{
return _Value < other._Value;
}
bool operator <= (const TSessionLevel &other) const
{
return _Value <= other._Value;
}
bool operator > (const TSessionLevel &other) const
{
return !(_Value <= other._Value);
}
bool operator >= (const TSessionLevel &other) const
{
return !(_Value < other._Value);
}
const std::string &toString() const
{
return getConversionTable().toString(_Value);
}
static const std::string &toString(TValues value)
{
return getConversionTable().toString(value);
}
TValues getValue() const
{
return _Value;
}
// return true if the actual value of the enum is valid, otherwise false
bool isValid()
{
if (_Value == invalid_val)
return false;
// not invalid, check other enum value
return getConversionTable().isValid(_Value);
}
uint32 asIndex()
{
std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
nlassert(it != getIndexTable().end());
return it->second;
}
public:
void fromCharacterLevel(uint32 level)
{
if (level < 21)
_Value = sl_a; // 0..20
else if (level < 51)
_Value = sl_b; // 21..50
else if (level < 101)
_Value = sl_c; // 51..100
else if (level < 151)
_Value = sl_d; // 101..150
else if (level < 201)
_Value = sl_e; // 151..200
else
_Value = sl_f; // 201..oo
}
void fromSkillName(const std::string &skillName)
{
// we considere the lenght of the skill name to be proportional to the level
if (skillName.size() < 2)
{
// skill name too short
_Value = invalid_val;
}
uint32 size = skillName.size()-1;
if (size < end_of_enum)
_Value = TValues(size);
else
// max the level
_Value = sl_f;
}
// return a value corresponding to the top of the game level range for the given value
uint32 asLevel()
{
switch (_Value)
{
case sl_a: return 20;
case sl_b: return 50;
case sl_c: return 100;
case sl_d: return 150;
case sl_e: return 200;
case sl_f: return 250;
default: BOMB("Invalid value being converted to level - returning 1",return 1);
}
}
};
/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////
class TRunningScenarioInfo
{
protected:
//
NLMISC::CHashKeyMD5 _ScenarioKey;
//
std::string _ScenarioTitle;
//
std::string _ScenarioDesc;
//
TSessionLevel _SessionLevel;
//
std::string _ScenarioAuthorName;
//
uint32 _SessionAnimatorCharId;
//
bool _DMLess;
//
std::string _MissionTag;
public:
//
const NLMISC::CHashKeyMD5 &getScenarioKey() const
{
return _ScenarioKey;
}
NLMISC::CHashKeyMD5 &getScenarioKey()
{
return _ScenarioKey;
}
void setScenarioKey(const NLMISC::CHashKeyMD5 &value)
{
_ScenarioKey = value;
}
//
const std::string &getScenarioTitle() const
{
return _ScenarioTitle;
}
std::string &getScenarioTitle()
{
return _ScenarioTitle;
}
void setScenarioTitle(const std::string &value)
{
_ScenarioTitle = value;
}
//
const std::string &getScenarioDesc() const
{
return _ScenarioDesc;
}
std::string &getScenarioDesc()
{
return _ScenarioDesc;
}
void setScenarioDesc(const std::string &value)
{
_ScenarioDesc = value;
}
//
TSessionLevel getSessionLevel() const
{
return _SessionLevel;
}
void setSessionLevel(TSessionLevel value)
{
_SessionLevel = value;
}
//
const std::string &getScenarioAuthorName() const
{
return _ScenarioAuthorName;
}
std::string &getScenarioAuthorName()
{
return _ScenarioAuthorName;
}
void setScenarioAuthorName(const std::string &value)
{
_ScenarioAuthorName = value;
}
//
uint32 getSessionAnimatorCharId() const
{
return _SessionAnimatorCharId;
}
void setSessionAnimatorCharId(uint32 value)
{
_SessionAnimatorCharId = value;
}
//
bool getDMLess() const
{
return _DMLess;
}
void setDMLess(bool value)
{
_DMLess = value;
}
//
const std::string &getMissionTag() const
{
return _MissionTag;
}
std::string &getMissionTag()
{
return _MissionTag;
}
void setMissionTag(const std::string &value)
{
_MissionTag = value;
}
bool operator == (const TRunningScenarioInfo &other) const
{
return _ScenarioKey == other._ScenarioKey
&& _ScenarioTitle == other._ScenarioTitle
&& _ScenarioDesc == other._ScenarioDesc
&& _SessionLevel == other._SessionLevel
&& _ScenarioAuthorName == other._ScenarioAuthorName
&& _SessionAnimatorCharId == other._SessionAnimatorCharId
&& _DMLess == other._DMLess
&& _MissionTag == other._MissionTag;
}
// constructor
TRunningScenarioInfo()
{
}
void serial(NLMISC::IStream &s)
{
s.serial(_ScenarioKey);
s.serial(_ScenarioTitle);
s.serial(_ScenarioDesc);
s.serial(_SessionLevel);
s.serial(_ScenarioAuthorName);
s.serial(_SessionAnimatorCharId);
s.serial(_DMLess);
s.serial(_MissionTag);
}
private:
};
struct TPioneerRight
{
enum TValues
{
Tester = 0,
DM,
/// the highest valid value in the enum
last_enum_item = DM,
/// a value equal to the last enum item +1
end_of_enum,
invalid_val,
/// Number of enumerated values
nb_enum_items = 2
};
/// Index table to convert enum value to linear index table
const std::map<TValues, uint32> &getIndexTable() const
{
static std::map<TValues, uint32> indexTable;
static bool init = false;
if (!init)
{
// fill the index table
indexTable.insert(std::make_pair(Tester, 0));
indexTable.insert(std::make_pair(DM, 1));
init = true;
}
return indexTable;
}
static const NLMISC::CStringConversion<TValues> &getConversionTable()
{
NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
NL_STRING_CONVERSION_TABLE_ENTRY(Tester)
NL_STRING_CONVERSION_TABLE_ENTRY(DM)
NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
};
static NLMISC::CStringConversion<TValues>
conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
/ sizeof(TValues_nl_string_conversion_table[0]), invalid_val);
return conversionTable;
}
TValues _Value;
public:
TPioneerRight()
: _Value(invalid_val)
{
}
TPioneerRight(TValues value)
: _Value(value)
{
}
TPioneerRight(const std::string &str)
{
_Value = getConversionTable().fromString(str);
}
void serial(NLMISC::IStream &s)
{
s.serialEnum(_Value);
}
bool operator == (const TPioneerRight &other) const
{
return _Value == other._Value;
}
bool operator != (const TPioneerRight &other) const
{
return ! (_Value == other._Value);
}
bool operator < (const TPioneerRight &other) const
{
return _Value < other._Value;
}
bool operator <= (const TPioneerRight &other) const
{
return _Value <= other._Value;
}
bool operator > (const TPioneerRight &other) const
{
return !(_Value <= other._Value);
}
bool operator >= (const TPioneerRight &other) const
{
return !(_Value < other._Value);
}
const std::string &toString() const
{
return getConversionTable().toString(_Value);
}
static const std::string &toString(TValues value)
{
return getConversionTable().toString(value);
}
TValues getValue() const
{
return _Value;
}
// return true if the actual value of the enum is valid, otherwise false
bool isValid()
{
if (_Value == invalid_val)
return false;
// not invalid, check other enum value
return getConversionTable().isValid(_Value);
}
uint32 asIndex()
{
std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
nlassert(it != getIndexTable().end());
return it->second;
}
};
/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////
class CShareServerAnimationItfSkel
{
public:
/// the interceptor type
typedef NLNET::CInterceptorForwarder < CShareServerAnimationItfSkel> TInterceptor;
protected:
CShareServerAnimationItfSkel()
{
// do early run time check for message table
getMessageHandlers();
}
virtual ~CShareServerAnimationItfSkel()
{
}
void init(NLNET::IModule *module)
{
_Interceptor.init(this, module);
}
// unused interceptors
std::string fwdBuildModuleManifest() const { return std::string(); }
void fwdOnModuleUp(NLNET::IModuleProxy * /* moduleProxy */) {}
void fwdOnModuleDown(NLNET::IModuleProxy * /* moduleProxy */) {}
void fwdOnModuleSecurityChange(NLNET::IModuleProxy * /* moduleProxy */) {}
// process module message interceptor
bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
private:
typedef void (CShareServerAnimationItfSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
typedef std::map<std::string, TMessageHandler> TMessageHandlerMap;
const TMessageHandlerMap &getMessageHandlers() const;
void connectAnimationModePlay_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void askMissionItemsDescription_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void askActPositionDescriptions_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void askUserTriggerDescriptions_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onUserTriggerTriggered_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onDssTarget_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
// declare one interceptor member of the skeleton
TInterceptor _Interceptor;
// declare the interceptor forwarder as friend of this class
friend class NLNET::CInterceptorForwarder < CShareServerAnimationItfSkel>;
public:
/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////
// request the connection to play mode in an animation session
virtual void connectAnimationModePlay(NLNET::IModuleProxy *sender) =0;
// A client Message to register mission item of a scenario
virtual void askMissionItemsDescription(NLNET::IModuleProxy *sender) =0;
// A client Message to update client Act Position Description
virtual void askActPositionDescriptions(NLNET::IModuleProxy *sender) =0;
// A client Message to update client User Trigger Description
virtual void askUserTriggerDescriptions(NLNET::IModuleProxy *sender) =0;
// client wants to trigger an user trigger
virtual void onUserTriggerTriggered(NLNET::IModuleProxy *sender, uint32 actId, uint32 triggerId) =0;
// client wants to execute a dm action on its target
virtual void onDssTarget(NLNET::IModuleProxy *sender, const std::vector<std::string> &args) =0;
};
/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////
class CShareServerAnimationItfProxy
{
/// Smart pointer on the module proxy
NLNET::TModuleProxyPtr _ModuleProxy;
// Pointer on the local module that implement the interface (if the proxy is for a local module)
NLNET::TModulePtr _LocalModule;
// Direct pointer on the server implementation interface for collocated module
CShareServerAnimationItfSkel *_LocalModuleSkel;
public:
CShareServerAnimationItfProxy(NLNET::IModuleProxy *proxy)
{
nlassert(proxy->getModuleClassName() == "ServerAnimationModule");
_ModuleProxy = proxy;
// initialize collocated servant interface
if (proxy->getModuleDistance() == 0)
{
_LocalModule = proxy->getLocalModule();
nlassert(_LocalModule != NULL);
CShareServerAnimationItfSkel::TInterceptor *interceptor = NULL;
interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
nlassert(interceptor != NULL);
_LocalModuleSkel = interceptor->getParent();
nlassert(_LocalModuleSkel != NULL);
}
else
_LocalModuleSkel = 0;
}
virtual ~CShareServerAnimationItfProxy()
{
}
NLNET::IModuleProxy *getModuleProxy()
{
return _ModuleProxy;
}
// request the connection to play mode in an animation session
void connectAnimationModePlay(NLNET::IModule *sender);
// A client Message to register mission item of a scenario
void askMissionItemsDescription(NLNET::IModule *sender);
// A client Message to update client Act Position Description
void askActPositionDescriptions(NLNET::IModule *sender);
// A client Message to update client User Trigger Description
void askUserTriggerDescriptions(NLNET::IModule *sender);
// client wants to trigger an user trigger
void onUserTriggerTriggered(NLNET::IModule *sender, uint32 actId, uint32 triggerId);
// client wants to execute a dm action on its target
void onDssTarget(NLNET::IModule *sender, const std::vector<std::string> &args);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_connectAnimationModePlay(NLNET::CMessage &__message);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_askMissionItemsDescription(NLNET::CMessage &__message);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_askActPositionDescriptions(NLNET::CMessage &__message);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_askUserTriggerDescriptions(NLNET::CMessage &__message);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onUserTriggerTriggered(NLNET::CMessage &__message, uint32 actId, uint32 triggerId);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onDssTarget(NLNET::CMessage &__message, const std::vector<std::string> &args);
};
/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////
class CShareServerEditionItfSkel
{
public:
/// the interceptor type
typedef NLNET::CInterceptorForwarder < CShareServerEditionItfSkel> TInterceptor;
protected:
CShareServerEditionItfSkel()
{
// do early run time check for message table
getMessageHandlers();
}
virtual ~CShareServerEditionItfSkel()
{
}
void init(NLNET::IModule *module)
{
_Interceptor.init(this, module);
}
// unused interceptors
std::string fwdBuildModuleManifest() const { return std::string(); }
void fwdOnModuleUp(NLNET::IModuleProxy * /* moduleProxy */) {}
void fwdOnModuleDown(NLNET::IModuleProxy * /* moduleProxy */) {}
void fwdOnModuleSecurityChange(NLNET::IModuleProxy * /* moduleProxy */) {}
// process module message interceptor
bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
private:
typedef void (CShareServerEditionItfSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
typedef std::map<std::string, TMessageHandler> TMessageHandlerMap;
const TMessageHandlerMap &getMessageHandlers() const;
void startingScenario_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void startScenario_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void advConnACK_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onUserComponentRegistered_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onUserComponentDownloading_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onScenarioUploadAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onNodeSetAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onNodeInsertAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onNodeEraseAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onNodeMoveAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onMapConnectionAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onCharModeUpdateAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onTpPositionAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void tpToEntryPoint_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void setStartingAct_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onScenarioRingAccessUpdated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void saveScenarioFile_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void loadScenarioFile_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void saveUserComponentFile_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void loadUserComponentFile_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void teleportOneCharacterToAnother_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void teleportWhileUploadingScenario_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void multiPartMsgHead_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void multiPartMsgBody_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void multiPartMsgFoot_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void forwardToDss_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
// declare one interceptor member of the skeleton
TInterceptor _Interceptor;
// declare the interceptor forwarder as friend of this class
friend class NLNET::CInterceptorForwarder < CShareServerEditionItfSkel>;
public:
/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////
virtual void startingScenario(NLNET::IModuleProxy *sender) =0;
// Request the start of a test scenario
virtual void startScenario(NLNET::IModuleProxy *sender, bool ok, const TScenarioHeaderSerializer &header, const CObjectSerializerServer &data, uint32 startingAct) =0;
// Client has received the ADV_CONN message
virtual void advConnACK(NLNET::IModuleProxy *sender) =0;
// The client announce to the server that he has registered a component.
virtual void onUserComponentRegistered(NLNET::IModuleProxy *sender, const NLMISC::CHashKeyMD5 &md5) =0;
// The client announce to the server that he need a componennt so the server must uploading it.
virtual void onUserComponentDownloading(NLNET::IModuleProxy *sender, const NLMISC::CHashKeyMD5 &md5) =0;
// Upload the high level scenario.
virtual void onScenarioUploadAsked(NLNET::IModuleProxy *sender, uint32 msgId, const CObjectSerializerServer &hlScenario, bool mustBrodcast) =0;
// The client request to set a node on a hl scenario.
virtual void onNodeSetAsked(NLNET::IModuleProxy *sender, uint32 msgId, const std::string &instanceId, const std::string &attrName, const R2::CObjectSerializerServer &value) =0;
// The client request to insert a node on a hl scenario.
virtual void onNodeInsertAsked(NLNET::IModuleProxy *sender, uint32 msgId, const std::string &instanceId, const std::string &attrName, sint32 position, const std::string &key, const R2::CObjectSerializerServer &value) =0;
// The client request to erase a node on a hl scenario.
virtual void onNodeEraseAsked(NLNET::IModuleProxy *sender, uint32 msgId, const std::string &instanceId, const std::string &attrName, sint32 position) =0;
// The client request to move a node on a hl scenario.
virtual void onNodeMoveAsked(NLNET::IModuleProxy *sender, uint32 msgId, const std::string &instanceId1, const std::string &attrName1, sint32 position1, const std::string &instanceId2, const std::string &attrName2, sint32 position2) =0;
// Call by the client in order to download its current scenario (and tp).
virtual void onMapConnectionAsked(NLNET::IModuleProxy *sender, TSessionId scenarioId, bool updateHighLevel, bool mustTp, R2::TUserRole role) =0;
// Call by the client when he change its mode (Dm, Tester, Player)
virtual void onCharModeUpdateAsked(NLNET::IModuleProxy *sender, R2::TCharMode mode) =0;
// client wants to tp at a specific position (clicking in map)
virtual void onTpPositionAsked(NLNET::IModuleProxy *sender, float x, float y, float z) =0;
// Update the mode of the pioneer (DM/TEST).
virtual void tpToEntryPoint(NLNET::IModuleProxy *sender, uint32 actIndex) =0;
// Set the starting act of the scenario
virtual void setStartingAct(NLNET::IModuleProxy *sender, uint32 actIndex) =0;
// Update the the ring access of a scenario.
virtual void onScenarioRingAccessUpdated(NLNET::IModuleProxy *sender, bool ok, const std::string &ringAccess, const std::string &errMsg) =0;
// a message to validate a file waiting to be saved
virtual void saveScenarioFile(NLNET::IModuleProxy *sender, const std::string &md5, const R2::TScenarioHeaderSerializer &header) =0;
// a message to validate a file waiting to be loaded
virtual void loadScenarioFile(NLNET::IModuleProxy *sender, const std::string &md5, const std::string &signature) =0;
// a message to validate a user component file waiting to be saved
virtual void saveUserComponentFile(NLNET::IModuleProxy *sender, const std::string &md5, const R2::TScenarioHeaderSerializer &header) =0;
// a message to validate a user component file waiting to be loaded
virtual void loadUserComponentFile(NLNET::IModuleProxy *sender, const std::string &md5, const std::string &signature) =0;
// a message to ask the dss to teleport a character to another character
virtual void teleportOneCharacterToAnother(NLNET::IModuleProxy *sender, TSessionId sessionId, uint32 sourceId, uint32 destId) =0;
// teleport the player while uploading the scenario
virtual void teleportWhileUploadingScenario(NLNET::IModuleProxy *sender, const std::string &island, const std::string &entryPoint, const std::string &season) =0;
// send the header of a multi-part message
virtual void multiPartMsgHead(NLNET::IModuleProxy *sender, uint32 charId, const std::string &msgName, uint32 nbPacket, uint32 size) =0;
// send a part of a multi-part message
virtual void multiPartMsgBody(NLNET::IModuleProxy *sender, uint32 charId, uint32 partId, const std::vector<uint8> &data) =0;
// send the footer of a multi-part message
virtual void multiPartMsgFoot(NLNET::IModuleProxy *sender, uint32 charId) =0;
// simulate the forward of a message (to dss)
virtual void forwardToDss(NLNET::IModuleProxy *sender, uint32 charId, const NLNET::CMessage &msg) =0;
};
/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////
class CShareServerEditionItfProxy
{
/// Smart pointer on the module proxy
NLNET::TModuleProxyPtr _ModuleProxy;
// Pointer on the local module that implement the interface (if the proxy is for a local module)
NLNET::TModulePtr _LocalModule;
// Direct pointer on the server implementation interface for collocated module
CShareServerEditionItfSkel *_LocalModuleSkel;
public:
CShareServerEditionItfProxy(NLNET::IModuleProxy *proxy)
{
nlassert(proxy->getModuleClassName() == "ServerEditionModule");
_ModuleProxy = proxy;
// initialize collocated servant interface
if (proxy->getModuleDistance() == 0)
{
_LocalModule = proxy->getLocalModule();
nlassert(_LocalModule != NULL);
CShareServerEditionItfSkel::TInterceptor *interceptor = NULL;
interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
nlassert(interceptor != NULL);
_LocalModuleSkel = interceptor->getParent();
nlassert(_LocalModuleSkel != NULL);
}
else
_LocalModuleSkel = 0;
}
virtual ~CShareServerEditionItfProxy()
{
}
NLNET::IModuleProxy *getModuleProxy()
{
return _ModuleProxy;
}
void startingScenario(NLNET::IModule *sender);
// Request the start of a test scenario
void startScenario(NLNET::IModule *sender, bool ok, const TScenarioHeaderSerializer &header, const CObjectSerializerServer &data, uint32 startingAct);
// Client has received the ADV_CONN message
void advConnACK(NLNET::IModule *sender);
// The client announce to the server that he has registered a component.
void onUserComponentRegistered(NLNET::IModule *sender, const NLMISC::CHashKeyMD5 &md5);
// The client announce to the server that he need a componennt so the server must uploading it.
void onUserComponentDownloading(NLNET::IModule *sender, const NLMISC::CHashKeyMD5 &md5);
// Upload the high level scenario.
void onScenarioUploadAsked(NLNET::IModule *sender, uint32 msgId, const CObjectSerializerServer &hlScenario, bool mustBrodcast);
// The client request to set a node on a hl scenario.
void onNodeSetAsked(NLNET::IModule *sender, uint32 msgId, const std::string &instanceId, const std::string &attrName, const R2::CObjectSerializerServer &value);
// The client request to insert a node on a hl scenario.
void onNodeInsertAsked(NLNET::IModule *sender, uint32 msgId, const std::string &instanceId, const std::string &attrName, sint32 position, const std::string &key, const R2::CObjectSerializerServer &value);
// The client request to erase a node on a hl scenario.
void onNodeEraseAsked(NLNET::IModule *sender, uint32 msgId, const std::string &instanceId, const std::string &attrName, sint32 position);
// The client request to move a node on a hl scenario.
void onNodeMoveAsked(NLNET::IModule *sender, uint32 msgId, const std::string &instanceId1, const std::string &attrName1, sint32 position1, const std::string &instanceId2, const std::string &attrName2, sint32 position2);
// Call by the client in order to download its current scenario (and tp).
void onMapConnectionAsked(NLNET::IModule *sender, TSessionId scenarioId, bool updateHighLevel, bool mustTp, R2::TUserRole role);
// Call by the client when he change its mode (Dm, Tester, Player)
void onCharModeUpdateAsked(NLNET::IModule *sender, R2::TCharMode mode);
// client wants to tp at a specific position (clicking in map)
void onTpPositionAsked(NLNET::IModule *sender, float x, float y, float z);
// Update the mode of the pioneer (DM/TEST).
void tpToEntryPoint(NLNET::IModule *sender, uint32 actIndex);
// Set the starting act of the scenario
void setStartingAct(NLNET::IModule *sender, uint32 actIndex);
// Update the the ring access of a scenario.
void onScenarioRingAccessUpdated(NLNET::IModule *sender, bool ok, const std::string &ringAccess, const std::string &errMsg);
// a message to validate a file waiting to be saved
void saveScenarioFile(NLNET::IModule *sender, const std::string &md5, const R2::TScenarioHeaderSerializer &header);
// a message to validate a file waiting to be loaded
void loadScenarioFile(NLNET::IModule *sender, const std::string &md5, const std::string &signature);
// a message to validate a user component file waiting to be saved
void saveUserComponentFile(NLNET::IModule *sender, const std::string &md5, const R2::TScenarioHeaderSerializer &header);
// a message to validate a user component file waiting to be loaded
void loadUserComponentFile(NLNET::IModule *sender, const std::string &md5, const std::string &signature);
// a message to ask the dss to teleport a character to another character
void teleportOneCharacterToAnother(NLNET::IModule *sender, TSessionId sessionId, uint32 sourceId, uint32 destId);
// teleport the player while uploading the scenario
void teleportWhileUploadingScenario(NLNET::IModule *sender, const std::string &island, const std::string &entryPoint, const std::string &season);
// send the header of a multi-part message
void multiPartMsgHead(NLNET::IModule *sender, uint32 charId, const std::string &msgName, uint32 nbPacket, uint32 size);
// send a part of a multi-part message
void multiPartMsgBody(NLNET::IModule *sender, uint32 charId, uint32 partId, const std::vector<uint8> &data);
// send the footer of a multi-part message
void multiPartMsgFoot(NLNET::IModule *sender, uint32 charId);
// simulate the forward of a message (to dss)
void forwardToDss(NLNET::IModule *sender, uint32 charId, const NLNET::CMessage &msg);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_startingScenario(NLNET::CMessage &__message);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_startScenario(NLNET::CMessage &__message, bool ok, const TScenarioHeaderSerializer &header, const CObjectSerializerServer &data, uint32 startingAct);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_advConnACK(NLNET::CMessage &__message);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onUserComponentRegistered(NLNET::CMessage &__message, const NLMISC::CHashKeyMD5 &md5);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onUserComponentDownloading(NLNET::CMessage &__message, const NLMISC::CHashKeyMD5 &md5);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onScenarioUploadAsked(NLNET::CMessage &__message, uint32 msgId, const CObjectSerializerServer &hlScenario, bool mustBrodcast);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onNodeSetAsked(NLNET::CMessage &__message, uint32 msgId, const std::string &instanceId, const std::string &attrName, const R2::CObjectSerializerServer &value);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onNodeInsertAsked(NLNET::CMessage &__message, uint32 msgId, const std::string &instanceId, const std::string &attrName, sint32 position, const std::string &key, const R2::CObjectSerializerServer &value);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onNodeEraseAsked(NLNET::CMessage &__message, uint32 msgId, const std::string &instanceId, const std::string &attrName, sint32 position);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onNodeMoveAsked(NLNET::CMessage &__message, uint32 msgId, const std::string &instanceId1, const std::string &attrName1, sint32 position1, const std::string &instanceId2, const std::string &attrName2, sint32 position2);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onMapConnectionAsked(NLNET::CMessage &__message, TSessionId scenarioId, bool updateHighLevel, bool mustTp, R2::TUserRole role);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onCharModeUpdateAsked(NLNET::CMessage &__message, R2::TCharMode mode);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onTpPositionAsked(NLNET::CMessage &__message, float x, float y, float z);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_tpToEntryPoint(NLNET::CMessage &__message, uint32 actIndex);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_setStartingAct(NLNET::CMessage &__message, uint32 actIndex);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onScenarioRingAccessUpdated(NLNET::CMessage &__message, bool ok, const std::string &ringAccess, const std::string &errMsg);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_saveScenarioFile(NLNET::CMessage &__message, const std::string &md5, const R2::TScenarioHeaderSerializer &header);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_loadScenarioFile(NLNET::CMessage &__message, const std::string &md5, const std::string &signature);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_saveUserComponentFile(NLNET::CMessage &__message, const std::string &md5, const R2::TScenarioHeaderSerializer &header);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_loadUserComponentFile(NLNET::CMessage &__message, const std::string &md5, const std::string &signature);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_teleportOneCharacterToAnother(NLNET::CMessage &__message, TSessionId sessionId, uint32 sourceId, uint32 destId);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_teleportWhileUploadingScenario(NLNET::CMessage &__message, const std::string &island, const std::string &entryPoint, const std::string &season);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_multiPartMsgHead(NLNET::CMessage &__message, uint32 charId, const std::string &msgName, uint32 nbPacket, uint32 size);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_multiPartMsgBody(NLNET::CMessage &__message, uint32 charId, uint32 partId, const std::vector<uint8> &data);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_multiPartMsgFoot(NLNET::CMessage &__message, uint32 charId);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_forwardToDss(NLNET::CMessage &__message, uint32 charId, const NLNET::CMessage &msg);
};
/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////
class CShareClientEditionItfSkel
{
public:
/// the interceptor type
typedef NLNET::CInterceptorForwarder < CShareClientEditionItfSkel> TInterceptor;
protected:
CShareClientEditionItfSkel()
{
// do early run time check for message table
getMessageHandlers();
}
virtual ~CShareClientEditionItfSkel()
{
}
void init(NLNET::IModule *module)
{
_Interceptor.init(this, module);
}
// unused interceptors
std::string fwdBuildModuleManifest() const { return std::string(); }
void fwdOnModuleUp(NLNET::IModuleProxy * /* moduleProxy */) {}
void fwdOnModuleDown(NLNET::IModuleProxy * /* moduleProxy */) {}
void fwdOnModuleSecurityChange(NLNET::IModuleProxy * /* moduleProxy */) {}
// process module message interceptor
bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
private:
typedef void (CShareClientEditionItfSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
typedef std::map<std::string, TMessageHandler> TMessageHandlerMap;
const TMessageHandlerMap &getMessageHandlers() const;
void startingScenario_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void startScenario_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onUserComponentRegistered_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onUserComponentUploading_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onScenarioUploaded_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onNodeSet_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onNodeInserted_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onNodeErased_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onNodeMoved_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onQuotaUpdated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onCharModeUpdated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onTestModeDisconnected_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onTpPositionSimulated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onKicked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onDisconnected_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void scheduleStartAct_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onAnimationModePlayConnected_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void updateScenarioHeader_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void updateMissionItemsDescription_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void updateActPositionDescriptions_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void updateUserTriggerDescriptions_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onCurrentActIndexUpdated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void updateTalkingAsList_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void updateIncarningList_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void systemMsg_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void onRingAccessUpdated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void saveScenarioFileAccepted_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void loadScenarioFileAccepted_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void saveUserComponentFileAccepted_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void loadUserComponentFileAccepted_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void multiPartMsgHead_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void multiPartMsgBody_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void multiPartMsgFoot_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
void ackMsg_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
// declare one interceptor member of the skeleton
TInterceptor _Interceptor;
// declare the interceptor forwarder as friend of this class
friend class NLNET::CInterceptorForwarder < CShareClientEditionItfSkel>;
public:
/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////
// The start of a test has been requested
virtual void startingScenario(NLNET::IModuleProxy *sender, uint32 charId) =0;
// A Scenario has started
virtual void startScenario(NLNET::IModuleProxy *sender, bool ok, uint32 startingAct, const std::string &errorMsg) =0;
// A User component has been registered
virtual void onUserComponentRegistered(NLNET::IModuleProxy *sender, const NLMISC::CHashKeyMD5 &md5) =0;
// Request the upload of a component
virtual void onUserComponentUploading(NLNET::IModuleProxy *sender, const NLMISC::CHashKeyMD5 &md5) =0;
// The client request to upload an hl ata.
virtual void onScenarioUploaded(NLNET::IModuleProxy *sender, const R2::CObjectSerializerClient &hlScenario) =0;
// The client request to set a node on a hl scenario.
virtual void onNodeSet(NLNET::IModuleProxy *sender, const std::string &instanceId, const std::string &attrName, const R2::CObjectSerializerClient &value) =0;
// The ServerEditionMode inserts a node on a hl scenario.
virtual void onNodeInserted(NLNET::IModuleProxy *sender, const std::string &instanceId, const std::string &attrName, sint32 position, const std::string &key, const R2::CObjectSerializerClient &value) =0;
// The ServerEditionMode erases a node on a hl scenario.
virtual void onNodeErased(NLNET::IModuleProxy *sender, const std::string &instanceId, const std::string &attrName, sint32 position) =0;
// The ServerEditionMode a move node on a hl scenario.
virtual void onNodeMoved(NLNET::IModuleProxy *sender, const std::string &instanceId1, const std::string &attrName1, sint32 position1, const std::string &instanceId2, const std::string &attrName2, sint32 position2) =0;
// Updates the client quota
virtual void onQuotaUpdated(NLNET::IModuleProxy *sender, uint32 maxNpcs, uint32 maxStaticObjects) =0;
// Updates the client Mode (tester, dm, editor, player) be the speed
virtual void onCharModeUpdated(NLNET::IModuleProxy *sender, R2::TCharMode mode) =0;
// Indicates to the client that an animation has stop (animation, play, test)
virtual void onTestModeDisconnected(NLNET::IModuleProxy *sender, TSessionId sessionId, uint32 lastActIndex, R2::TScenarioSessionType animationType) =0;
// A DSS Message to make a local client tp (because egs can not do it)/
virtual void onTpPositionSimulated(NLNET::IModuleProxy *sender, TSessionId sessionId, uint64 characterId64, sint32 x, sint32 y, sint32 z, uint8 scenarioSeason) =0;
// A DSS Message to indicates that the client will be disconnect in secondes./
virtual void onKicked(NLNET::IModuleProxy *sender, uint32 timeBeforeDisconnection, bool mustKick) =0;
// A DSS Message to make to disconnect the client./
virtual void onDisconnected(NLNET::IModuleProxy *sender) =0;
// Tell to the client that an act begin in nbSeconds
virtual void scheduleStartAct(NLNET::IModuleProxy *sender, uint32 errorId, uint32 actId, uint32 nbSeconds) =0;
// Tell to the client that he is connected in play mode in an animation session
virtual void onAnimationModePlayConnected(NLNET::IModuleProxy *sender) =0;
// A DSS Message to update the scenario Header
virtual void updateScenarioHeader(NLNET::IModuleProxy *sender, const R2::TScenarioHeaderSerializer &scenarioHeader) =0;
// A DSS Message to update discription mission item of a scenario
virtual void updateMissionItemsDescription(NLNET::IModuleProxy *sender, TSessionId sessionId, const std::vector<R2::TMissionItem> &missionItem) =0;
// A DSS Message to update the discription of acts (name and positions)
virtual void updateActPositionDescriptions(NLNET::IModuleProxy *sender, const R2::TActPositionDescriptions &actPositionDescriptions) =0;
// A DSS Message to update the discription of acts (name and positions)
virtual void updateUserTriggerDescriptions(NLNET::IModuleProxy *sender, const R2::TUserTriggerDescriptions &userTriggerDescriptions) =0;
// A DSS Message to update the discription of acts (name and positions)
virtual void onCurrentActIndexUpdated(NLNET::IModuleProxy *sender, uint32 actIndex) =0;
// Update the Talking as list.
virtual void updateTalkingAsList(NLNET::IModuleProxy *sender, const std::vector<uint32> &botsId) =0;
// Update the Incarning list.
virtual void updateIncarningList(NLNET::IModuleProxy *sender, const std::vector<uint32> &botsId) =0;
// A message that will be printed an client
virtual void systemMsg(NLNET::IModuleProxy *sender, const std::string &msgType, const std::string &who, const std::string &msg) =0;
// Update the ring access of the client
virtual void onRingAccessUpdated(NLNET::IModuleProxy *sender, const std::string &ringAccess) =0;
// a message to validate a file waiting to be saved
virtual void saveScenarioFileAccepted(NLNET::IModuleProxy *sender, const std::string &md5, const std::string &signature, bool isAccepted) =0;
// a message to validate a file waiting to be loaded
virtual void loadScenarioFileAccepted(NLNET::IModuleProxy *sender, const std::string &md5, bool ok) =0;
// a message to validate a user component file waiting to be saved
virtual void saveUserComponentFileAccepted(NLNET::IModuleProxy *sender, const std::string &md5, const std::string &signature, bool isAccepted) =0;
// a message to validate a user component file waiting to be loaded
virtual void loadUserComponentFileAccepted(NLNET::IModuleProxy *sender, const std::string &md5, bool ok) =0;
// send the header of a multi-part message
virtual void multiPartMsgHead(NLNET::IModuleProxy *sender, const std::string &msgName, uint32 nbPacket, uint32 size) =0;
// send a part of a multi-part message
virtual void multiPartMsgBody(NLNET::IModuleProxy *sender, uint32 partId, uint32 packetSize) =0;
// send the footer of a multi-part message
virtual void multiPartMsgFoot(NLNET::IModuleProxy *sender) =0;
// send an ack messag to the client
virtual void ackMsg(NLNET::IModuleProxy *sender, uint32 msgId, bool ok) =0;
};
/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////
class CShareClientEditionItfProxy
{
/// Smart pointer on the module proxy
NLNET::TModuleProxyPtr _ModuleProxy;
// Pointer on the local module that implement the interface (if the proxy is for a local module)
NLNET::TModulePtr _LocalModule;
// Direct pointer on the server implementation interface for collocated module
CShareClientEditionItfSkel *_LocalModuleSkel;
public:
CShareClientEditionItfProxy(NLNET::IModuleProxy *proxy)
{
nlassert(proxy->getModuleClassName() == "ClientEditionModule");
_ModuleProxy = proxy;
// initialize collocated servant interface
if (proxy->getModuleDistance() == 0)
{
_LocalModule = proxy->getLocalModule();
nlassert(_LocalModule != NULL);
CShareClientEditionItfSkel::TInterceptor *interceptor = NULL;
interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
nlassert(interceptor != NULL);
_LocalModuleSkel = interceptor->getParent();
nlassert(_LocalModuleSkel != NULL);
}
else
_LocalModuleSkel = 0;
}
virtual ~CShareClientEditionItfProxy()
{
}
NLNET::IModuleProxy *getModuleProxy()
{
return _ModuleProxy;
}
// The start of a test has been requested
void startingScenario(NLNET::IModule *sender, uint32 charId);
// A Scenario has started
void startScenario(NLNET::IModule *sender, bool ok, uint32 startingAct, const std::string &errorMsg);
// A User component has been registered
void onUserComponentRegistered(NLNET::IModule *sender, const NLMISC::CHashKeyMD5 &md5);
// Request the upload of a component
void onUserComponentUploading(NLNET::IModule *sender, const NLMISC::CHashKeyMD5 &md5);
// The client request to upload an hl ata.
void onScenarioUploaded(NLNET::IModule *sender, const R2::CObjectSerializerClient &hlScenario);
// The client request to set a node on a hl scenario.
void onNodeSet(NLNET::IModule *sender, const std::string &instanceId, const std::string &attrName, const R2::CObjectSerializerClient &value);
// The ServerEditionMode inserts a node on a hl scenario.
void onNodeInserted(NLNET::IModule *sender, const std::string &instanceId, const std::string &attrName, sint32 position, const std::string &key, const R2::CObjectSerializerClient &value);
// The ServerEditionMode erases a node on a hl scenario.
void onNodeErased(NLNET::IModule *sender, const std::string &instanceId, const std::string &attrName, sint32 position);
// The ServerEditionMode a move node on a hl scenario.
void onNodeMoved(NLNET::IModule *sender, const std::string &instanceId1, const std::string &attrName1, sint32 position1, const std::string &instanceId2, const std::string &attrName2, sint32 position2);
// Updates the client quota
void onQuotaUpdated(NLNET::IModule *sender, uint32 maxNpcs, uint32 maxStaticObjects);
// Updates the client Mode (tester, dm, editor, player) be the speed
void onCharModeUpdated(NLNET::IModule *sender, R2::TCharMode mode);
// Indicates to the client that an animation has stop (animation, play, test)
void onTestModeDisconnected(NLNET::IModule *sender, TSessionId sessionId, uint32 lastActIndex, R2::TScenarioSessionType animationType);
// A DSS Message to make a local client tp (because egs can not do it)/
void onTpPositionSimulated(NLNET::IModule *sender, TSessionId sessionId, uint64 characterId64, sint32 x, sint32 y, sint32 z, uint8 scenarioSeason);
// A DSS Message to indicates that the client will be disconnect in secondes./
void onKicked(NLNET::IModule *sender, uint32 timeBeforeDisconnection, bool mustKick);
// A DSS Message to make to disconnect the client./
void onDisconnected(NLNET::IModule *sender);
// Tell to the client that an act begin in nbSeconds
void scheduleStartAct(NLNET::IModule *sender, uint32 errorId, uint32 actId, uint32 nbSeconds);
// Tell to the client that he is connected in play mode in an animation session
void onAnimationModePlayConnected(NLNET::IModule *sender);
// A DSS Message to update the scenario Header
void updateScenarioHeader(NLNET::IModule *sender, const R2::TScenarioHeaderSerializer &scenarioHeader);
// A DSS Message to update discription mission item of a scenario
void updateMissionItemsDescription(NLNET::IModule *sender, TSessionId sessionId, const std::vector<R2::TMissionItem> &missionItem);
// A DSS Message to update the discription of acts (name and positions)
void updateActPositionDescriptions(NLNET::IModule *sender, const R2::TActPositionDescriptions &actPositionDescriptions);
// A DSS Message to update the discription of acts (name and positions)
void updateUserTriggerDescriptions(NLNET::IModule *sender, const R2::TUserTriggerDescriptions &userTriggerDescriptions);
// A DSS Message to update the discription of acts (name and positions)
void onCurrentActIndexUpdated(NLNET::IModule *sender, uint32 actIndex);
// Update the Talking as list.
void updateTalkingAsList(NLNET::IModule *sender, const std::vector<uint32> &botsId);
// Update the Incarning list.
void updateIncarningList(NLNET::IModule *sender, const std::vector<uint32> &botsId);
// A message that will be printed an client
void systemMsg(NLNET::IModule *sender, const std::string &msgType, const std::string &who, const std::string &msg);
// Update the ring access of the client
void onRingAccessUpdated(NLNET::IModule *sender, const std::string &ringAccess);
// a message to validate a file waiting to be saved
void saveScenarioFileAccepted(NLNET::IModule *sender, const std::string &md5, const std::string &signature, bool isAccepted);
// a message to validate a file waiting to be loaded
void loadScenarioFileAccepted(NLNET::IModule *sender, const std::string &md5, bool ok);
// a message to validate a user component file waiting to be saved
void saveUserComponentFileAccepted(NLNET::IModule *sender, const std::string &md5, const std::string &signature, bool isAccepted);
// a message to validate a user component file waiting to be loaded
void loadUserComponentFileAccepted(NLNET::IModule *sender, const std::string &md5, bool ok);
// send the header of a multi-part message
void multiPartMsgHead(NLNET::IModule *sender, const std::string &msgName, uint32 nbPacket, uint32 size);
// send a part of a multi-part message
void multiPartMsgBody(NLNET::IModule *sender, uint32 partId, uint32 packetSize);
// send the footer of a multi-part message
void multiPartMsgFoot(NLNET::IModule *sender);
// send an ack messag to the client
void ackMsg(NLNET::IModule *sender, uint32 msgId, bool ok);
// The start of a test has been requested
// This is the broadcast version of the method.
template < class ProxyIterator >
static void broadcast_startingScenario(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, uint32 charId)
{
NLNET::CMessage message;
// create the message to send to multiple dest
buildMessageFor_startingScenario(message , charId);
for (; first != last; ++first)
{
NLNET::IModuleProxy *proxy = *first;
proxy->sendModuleMessage(sender, message);
}
}
// A Scenario has started
// This is the broadcast version of the method.
template < class ProxyIterator >
static void broadcast_startScenario(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, bool ok, uint32 startingAct, const std::string &errorMsg)
{
NLNET::CMessage message;
// create the message to send to multiple dest
buildMessageFor_startScenario(message , ok, startingAct, errorMsg);
for (; first != last; ++first)
{
NLNET::IModuleProxy *proxy = *first;
proxy->sendModuleMessage(sender, message);
}
}
// A User component has been registered
// This is the broadcast version of the method.
template < class ProxyIterator >
static void broadcast_onUserComponentRegistered(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, const NLMISC::CHashKeyMD5 &md5)
{
NLNET::CMessage message;
// create the message to send to multiple dest
buildMessageFor_onUserComponentRegistered(message , md5);
for (; first != last; ++first)
{
NLNET::IModuleProxy *proxy = *first;
proxy->sendModuleMessage(sender, message);
}
}
// The client request to upload an hl ata.
// This is the broadcast version of the method.
template < class ProxyIterator >
static void broadcast_onScenarioUploaded(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, const R2::CObjectSerializerClient &hlScenario)
{
NLNET::CMessage message;
// create the message to send to multiple dest
buildMessageFor_onScenarioUploaded(message , hlScenario);
for (; first != last; ++first)
{
NLNET::IModuleProxy *proxy = *first;
proxy->sendModuleMessage(sender, message);
}
}
// The client request to set a node on a hl scenario.
// This is the broadcast version of the method.
template < class ProxyIterator >
static void broadcast_onNodeSet(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, const std::string &instanceId, const std::string &attrName, const R2::CObjectSerializerClient &value)
{
NLNET::CMessage message;
// create the message to send to multiple dest
buildMessageFor_onNodeSet(message , instanceId, attrName, value);
for (; first != last; ++first)
{
NLNET::IModuleProxy *proxy = *first;
proxy->sendModuleMessage(sender, message);
}
}
// The ServerEditionMode inserts a node on a hl scenario.
// This is the broadcast version of the method.
template < class ProxyIterator >
static void broadcast_onNodeInserted(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, const std::string &instanceId, const std::string &attrName, sint32 position, const std::string &key, const R2::CObjectSerializerClient &value)
{
NLNET::CMessage message;
// create the message to send to multiple dest
buildMessageFor_onNodeInserted(message , instanceId, attrName, position, key, value);
for (; first != last; ++first)
{
NLNET::IModuleProxy *proxy = *first;
proxy->sendModuleMessage(sender, message);
}
}
// The ServerEditionMode erases a node on a hl scenario.
// This is the broadcast version of the method.
template < class ProxyIterator >
static void broadcast_onNodeErased(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, const std::string &instanceId, const std::string &attrName, sint32 position)
{
NLNET::CMessage message;
// create the message to send to multiple dest
buildMessageFor_onNodeErased(message , instanceId, attrName, position);
for (; first != last; ++first)
{
NLNET::IModuleProxy *proxy = *first;
proxy->sendModuleMessage(sender, message);
}
}
// The ServerEditionMode a move node on a hl scenario.
// This is the broadcast version of the method.
template < class ProxyIterator >
static void broadcast_onNodeMoved(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, const std::string &instanceId1, const std::string &attrName1, sint32 position1, const std::string &instanceId2, const std::string &attrName2, sint32 position2)
{
NLNET::CMessage message;
// create the message to send to multiple dest
buildMessageFor_onNodeMoved(message , instanceId1, attrName1, position1, instanceId2, attrName2, position2);
for (; first != last; ++first)
{
NLNET::IModuleProxy *proxy = *first;
proxy->sendModuleMessage(sender, message);
}
}
// Indicates to the client that an animation has stop (animation, play, test)
// This is the broadcast version of the method.
template < class ProxyIterator >
static void broadcast_onTestModeDisconnected(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, TSessionId sessionId, uint32 lastActIndex, R2::TScenarioSessionType animationType)
{
NLNET::CMessage message;
// create the message to send to multiple dest
buildMessageFor_onTestModeDisconnected(message , sessionId, lastActIndex, animationType);
for (; first != last; ++first)
{
NLNET::IModuleProxy *proxy = *first;
proxy->sendModuleMessage(sender, message);
}
}
// Tell to the client that an act begin in nbSeconds
// This is the broadcast version of the method.
template < class ProxyIterator >
static void broadcast_scheduleStartAct(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, uint32 errorId, uint32 actId, uint32 nbSeconds)
{
NLNET::CMessage message;
// create the message to send to multiple dest
buildMessageFor_scheduleStartAct(message , errorId, actId, nbSeconds);
for (; first != last; ++first)
{
NLNET::IModuleProxy *proxy = *first;
proxy->sendModuleMessage(sender, message);
}
}
// Tell to the client that he is connected in play mode in an animation session
// This is the broadcast version of the method.
template < class ProxyIterator >
static void broadcast_onAnimationModePlayConnected(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender)
{
NLNET::CMessage message;
// create the message to send to multiple dest
buildMessageFor_onAnimationModePlayConnected(message );
for (; first != last; ++first)
{
NLNET::IModuleProxy *proxy = *first;
proxy->sendModuleMessage(sender, message);
}
}
// A message that will be printed an client
// This is the broadcast version of the method.
template < class ProxyIterator >
static void broadcast_systemMsg(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, const std::string &msgType, const std::string &who, const std::string &msg)
{
NLNET::CMessage message;
// create the message to send to multiple dest
buildMessageFor_systemMsg(message , msgType, who, msg);
for (; first != last; ++first)
{
NLNET::IModuleProxy *proxy = *first;
proxy->sendModuleMessage(sender, message);
}
}
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_startingScenario(NLNET::CMessage &__message, uint32 charId);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_startScenario(NLNET::CMessage &__message, bool ok, uint32 startingAct, const std::string &errorMsg);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onUserComponentRegistered(NLNET::CMessage &__message, const NLMISC::CHashKeyMD5 &md5);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onUserComponentUploading(NLNET::CMessage &__message, const NLMISC::CHashKeyMD5 &md5);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onScenarioUploaded(NLNET::CMessage &__message, const R2::CObjectSerializerClient &hlScenario);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onNodeSet(NLNET::CMessage &__message, const std::string &instanceId, const std::string &attrName, const R2::CObjectSerializerClient &value);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onNodeInserted(NLNET::CMessage &__message, const std::string &instanceId, const std::string &attrName, sint32 position, const std::string &key, const R2::CObjectSerializerClient &value);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onNodeErased(NLNET::CMessage &__message, const std::string &instanceId, const std::string &attrName, sint32 position);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onNodeMoved(NLNET::CMessage &__message, const std::string &instanceId1, const std::string &attrName1, sint32 position1, const std::string &instanceId2, const std::string &attrName2, sint32 position2);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onQuotaUpdated(NLNET::CMessage &__message, uint32 maxNpcs, uint32 maxStaticObjects);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onCharModeUpdated(NLNET::CMessage &__message, R2::TCharMode mode);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onTestModeDisconnected(NLNET::CMessage &__message, TSessionId sessionId, uint32 lastActIndex, R2::TScenarioSessionType animationType);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onTpPositionSimulated(NLNET::CMessage &__message, TSessionId sessionId, uint64 characterId64, sint32 x, sint32 y, sint32 z, uint8 scenarioSeason);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onKicked(NLNET::CMessage &__message, uint32 timeBeforeDisconnection, bool mustKick);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onDisconnected(NLNET::CMessage &__message);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_scheduleStartAct(NLNET::CMessage &__message, uint32 errorId, uint32 actId, uint32 nbSeconds);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onAnimationModePlayConnected(NLNET::CMessage &__message);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_updateScenarioHeader(NLNET::CMessage &__message, const R2::TScenarioHeaderSerializer &scenarioHeader);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_updateMissionItemsDescription(NLNET::CMessage &__message, TSessionId sessionId, const std::vector<R2::TMissionItem> &missionItem);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_updateActPositionDescriptions(NLNET::CMessage &__message, const R2::TActPositionDescriptions &actPositionDescriptions);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_updateUserTriggerDescriptions(NLNET::CMessage &__message, const R2::TUserTriggerDescriptions &userTriggerDescriptions);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onCurrentActIndexUpdated(NLNET::CMessage &__message, uint32 actIndex);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_updateTalkingAsList(NLNET::CMessage &__message, const std::vector<uint32> &botsId);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_updateIncarningList(NLNET::CMessage &__message, const std::vector<uint32> &botsId);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_systemMsg(NLNET::CMessage &__message, const std::string &msgType, const std::string &who, const std::string &msg);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_onRingAccessUpdated(NLNET::CMessage &__message, const std::string &ringAccess);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_saveScenarioFileAccepted(NLNET::CMessage &__message, const std::string &md5, const std::string &signature, bool isAccepted);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_loadScenarioFileAccepted(NLNET::CMessage &__message, const std::string &md5, bool ok);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_saveUserComponentFileAccepted(NLNET::CMessage &__message, const std::string &md5, const std::string &signature, bool isAccepted);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_loadUserComponentFileAccepted(NLNET::CMessage &__message, const std::string &md5, bool ok);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_multiPartMsgHead(NLNET::CMessage &__message, const std::string &msgName, uint32 nbPacket, uint32 size);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_multiPartMsgBody(NLNET::CMessage &__message, uint32 partId, uint32 packetSize);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_multiPartMsgFoot(NLNET::CMessage &__message);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_ackMsg(NLNET::CMessage &__message, uint32 msgId, bool ok);
};
// Describe an user item in a ring session
/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////
class TCharMappedInfo
{
protected:
//
NLMISC::CSheetId _ItemSheet;
//
ucstring _Name;
public:
//
const NLMISC::CSheetId &getItemSheet() const
{
return _ItemSheet;
}
NLMISC::CSheetId &getItemSheet()
{
return _ItemSheet;
}
void setItemSheet(const NLMISC::CSheetId &value)
{
_ItemSheet = value;
}
//
const ucstring &getName() const
{
return _Name;
}
ucstring &getName()
{
return _Name;
}
void setName(const ucstring &value)
{
_Name = value;
}
bool operator == (const TCharMappedInfo &other) const
{
return _ItemSheet == other._ItemSheet
&& _Name == other._Name;
}
// constructor
TCharMappedInfo()
{
}
void serial(NLMISC::IStream &s)
{
s.serial(_ItemSheet);
s.serial(_Name);
}
private:
};
/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////
class CIOSRingItfSkel
{
public:
/// the interceptor type
typedef NLNET::CInterceptorForwarder < CIOSRingItfSkel> TInterceptor;
protected:
CIOSRingItfSkel()
{
// do early run time check for message table
getMessageHandlers();
}
virtual ~CIOSRingItfSkel()
{
}
void init(NLNET::IModule *module)
{
_Interceptor.init(this, module);
}
// unused interceptors
std::string fwdBuildModuleManifest() const { return std::string(); }
void fwdOnModuleUp(NLNET::IModuleProxy * /* moduleProxy */) {}
void fwdOnModuleDown(NLNET::IModuleProxy * /* moduleProxy */) {}
void fwdOnModuleSecurityChange(NLNET::IModuleProxy * /* moduleProxy */) {}
// process module message interceptor
bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
private:
typedef void (CIOSRingItfSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
typedef std::map<std::string, TMessageHandler> TMessageHandlerMap;
const TMessageHandlerMap &getMessageHandlers() const;
void storeItemNamesForAIInstance_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);
// declare one interceptor member of the skeleton
TInterceptor _Interceptor;
// declare the interceptor forwarder as friend of this class
friend class NLNET::CInterceptorForwarder < CIOSRingItfSkel>;
public:
/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////
// DSS send a list of ring names user item with a AI instance
virtual void storeItemNamesForAIInstance(NLNET::IModuleProxy *sender, uint32 aiInstance, const std::vector < TCharMappedInfo > &itemInfos) =0;
};
/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////
class CIOSRingItfProxy
{
/// Smart pointer on the module proxy
NLNET::TModuleProxyPtr _ModuleProxy;
// Pointer on the local module that implement the interface (if the proxy is for a local module)
NLNET::TModulePtr _LocalModule;
// Direct pointer on the server implementation interface for collocated module
CIOSRingItfSkel *_LocalModuleSkel;
public:
CIOSRingItfProxy(NLNET::IModuleProxy *proxy)
{
_ModuleProxy = proxy;
// initialize collocated servant interface
if (proxy->getModuleDistance() == 0)
{
_LocalModule = proxy->getLocalModule();
nlassert(_LocalModule != NULL);
CIOSRingItfSkel::TInterceptor *interceptor = NULL;
interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
nlassert(interceptor != NULL);
_LocalModuleSkel = interceptor->getParent();
nlassert(_LocalModuleSkel != NULL);
}
else
_LocalModuleSkel = 0;
}
virtual ~CIOSRingItfProxy()
{
}
NLNET::IModuleProxy *getModuleProxy()
{
return _ModuleProxy;
}
// DSS send a list of ring names user item with a AI instance
void storeItemNamesForAIInstance(NLNET::IModule *sender, uint32 aiInstance, const std::vector < TCharMappedInfo > &itemInfos);
// Message serializer. Return the message received in reference for easier integration
static const NLNET::CMessage &buildMessageFor_storeItemNamesForAIInstance(NLNET::CMessage &__message, uint32 aiInstance, const std::vector < TCharMappedInfo > &itemInfos);
};
}
#endif
Reference in a new issue Copy permalink