server/game2006
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1

Browse Source
This commit is contained in:
aozhiwei 2023-06-28 16:05:09 +08:00
parent e203e77ee3
commit d4ee9add0f
10 changed files with 456 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
server/bin/exported/behaviac_generated/types/internal/behaviac_agent_member_visitor.h
View File

@ -16,12 +16,30 @@ template<> inline bool BaseAgent::_Execute_Method_<METHOD_TYPE_BaseAgent_CanUseS
return this->BaseAgent::CanUseSkill(p0);
}
struct METHOD_TYPE_BaseAgent_CurrentTargetMoveCanReach { };
template<> inline bool BaseAgent::_Execute_Method_<METHOD_TYPE_BaseAgent_CurrentTargetMoveCanReach>()
{
return this->BaseAgent::CurrentTargetMoveCanReach();
}
struct METHOD_TYPE_BaseAgent_DoSkill { };
template<> inline behaviac::EBTStatus BaseAgent::_Execute_Method_<METHOD_TYPE_BaseAgent_DoSkill>(int p0)
{
return this->BaseAgent::DoSkill(p0);
}
struct METHOD_TYPE_BaseAgent_DoUseSkill { };
template<> inline behaviac::EBTStatus BaseAgent::_Execute_Method_<METHOD_TYPE_BaseAgent_DoUseSkill>(int p0)
{
return this->BaseAgent::DoUseSkill(p0);
}
struct METHOD_TYPE_BaseAgent_GetPos { };
template<> inline glm::vec3 BaseAgent::_Execute_Method_<METHOD_TYPE_BaseAgent_GetPos>()
{
return this->BaseAgent::GetPos();
}
struct METHOD_TYPE_BaseAgent_HasBuffEffect { };
template<> inline bool BaseAgent::_Execute_Method_<METHOD_TYPE_BaseAgent_HasBuffEffect>(int p0)
{
@ -34,6 +52,18 @@ template<> inline bool BaseAgent::_Execute_Method_<METHOD_TYPE_BaseAgent_HasTarg
return this->BaseAgent::HasTarget(p0);
}
struct METHOD_TYPE_BaseAgent_MoveCanReach { };
template<> inline bool BaseAgent::_Execute_Method_<METHOD_TYPE_BaseAgent_MoveCanReach>(const glm::vec3& p0)
{
return this->BaseAgent::MoveCanReach(p0);
}
struct METHOD_TYPE_BaseAgent_SelectUseableSkill { };
template<> inline behaviac::EBTStatus BaseAgent::_Execute_Method_<METHOD_TYPE_BaseAgent_SelectUseableSkill>(const behaviac::vector<int> p0)
{
return this->BaseAgent::SelectUseableSkill(p0);
}
struct METHOD_TYPE_BaseAgent_SetBulletTraceMode { };
template<> inline void BaseAgent::_Execute_Method_<METHOD_TYPE_BaseAgent_SetBulletTraceMode>(bool p0)
{

210
server/bin/exported/behaviac_generated/types/internal/behaviac_agent_meta.cpp
View File

@ -8,6 +8,42 @@
namespace behaviac
{
class CInstanceConst_glm_vec3 : public CInstanceConstBase<glm::vec3>
{
IInstanceMember* _x;
IInstanceMember* _y;
IInstanceMember* _z;
public:
CInstanceConst_glm_vec3(const char* valueStr) : CInstanceConstBase<glm::vec3>(valueStr)
{
behaviac::vector<behaviac::string> paramStrs = behaviac::StringUtils::SplitTokensForStruct(valueStr);
BEHAVIAC_ASSERT(paramStrs.size() == 3);
_x = AgentMeta::TParseProperty<float >(paramStrs[0].c_str());
_y = AgentMeta::TParseProperty<float >(paramStrs[1].c_str());
_z = AgentMeta::TParseProperty<float >(paramStrs[2].c_str());
}
~CInstanceConst_glm_vec3()
{
BEHAVIAC_DELETE _x;
BEHAVIAC_DELETE _y;
BEHAVIAC_DELETE _z;
}
virtual void run(Agent* self)
{
BEHAVIAC_ASSERT(_x != NULL);
BEHAVIAC_ASSERT(_y != NULL);
BEHAVIAC_ASSERT(_z != NULL);
_value.x = *(float*)_x->GetValue(self, behaviac::Meta::IsVector<float >::Result, behaviac::GetClassTypeNumberId<float >());
_value.y = *(float*)_y->GetValue(self, behaviac::Meta::IsVector<float >::Result, behaviac::GetClassTypeNumberId<float >());
_value.z = *(float*)_z->GetValue(self, behaviac::Meta::IsVector<float >::Result, behaviac::GetClassTypeNumberId<float >());
}
};
class CMethod_behaviac_Agent_VectorAdd : public CAgentMethodVoidBase
{
IInstanceMember* _param0;
@ -223,6 +259,106 @@ namespace behaviac
}
};
class CMethod_BaseAgent_MoveCanReach : public CAgentMethodBase<bool>
{
IInstanceMember* _target_pos;
public:
CMethod_BaseAgent_MoveCanReach() : _target_pos(0)
{
}
CMethod_BaseAgent_MoveCanReach(CMethod_BaseAgent_MoveCanReach &rhs) : CAgentMethodBase<bool>(rhs) , _target_pos(0)
{
}
~CMethod_BaseAgent_MoveCanReach()
{
BEHAVIAC_DELETE _target_pos;
}
virtual IInstanceMember* clone()
{
return BEHAVIAC_NEW CMethod_BaseAgent_MoveCanReach(*this);
}
virtual void load(const char* instance, behaviac::vector<behaviac::string>& paramStrs)
{
BEHAVIAC_ASSERT(paramStrs.size() == 1);
behaviac::StringUtils::StringCopySafe(kInstanceNameMax, _instance, instance);
if (behaviac::StringUtils::StartsWith(paramStrs[0].c_str(), "{"))
{
_target_pos = BEHAVIAC_NEW CInstanceConst_glm_vec3(paramStrs[0].c_str());
}
else
{
_target_pos = AgentMeta::TParseProperty<glm::vec3 >(paramStrs[0].c_str());
}
}
virtual void run(Agent* self)
{
BEHAVIAC_ASSERT(_target_pos != NULL);
_target_pos->run(self);
const glm::vec3& pValue_target_pos = *(const glm::vec3*)_target_pos->GetValue(self, behaviac::Meta::IsVector<const glm::vec3 >::Result, behaviac::GetClassTypeNumberId<const glm::vec3 >());
self = Agent::GetParentAgent(self, _instance);
_returnValue->value = ((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_MoveCanReach, bool, const glm::vec3& >(pValue_target_pos);
}
};
class CMethod_BaseAgent_ShotCanReach : public CAgentMethodBase<bool>
{
IInstanceMember* _target_pos;
public:
CMethod_BaseAgent_ShotCanReach() : _target_pos(0)
{
}
CMethod_BaseAgent_ShotCanReach(CMethod_BaseAgent_ShotCanReach &rhs) : CAgentMethodBase<bool>(rhs) , _target_pos(0)
{
}
~CMethod_BaseAgent_ShotCanReach()
{
BEHAVIAC_DELETE _target_pos;
}
virtual IInstanceMember* clone()
{
return BEHAVIAC_NEW CMethod_BaseAgent_ShotCanReach(*this);
}
virtual void load(const char* instance, behaviac::vector<behaviac::string>& paramStrs)
{
BEHAVIAC_ASSERT(paramStrs.size() == 1);
behaviac::StringUtils::StringCopySafe(kInstanceNameMax, _instance, instance);
if (behaviac::StringUtils::StartsWith(paramStrs[0].c_str(), "{"))
{
_target_pos = BEHAVIAC_NEW CInstanceConst_glm_vec3(paramStrs[0].c_str());
}
else
{
_target_pos = AgentMeta::TParseProperty<glm::vec3 >(paramStrs[0].c_str());
}
}
virtual void run(Agent* self)
{
BEHAVIAC_ASSERT(_target_pos != NULL);
_target_pos->run(self);
const glm::vec3& pValue_target_pos = *(const glm::vec3*)_target_pos->GetValue(self, behaviac::Meta::IsVector<const glm::vec3 >::Result, behaviac::GetClassTypeNumberId<const glm::vec3 >());
self = Agent::GetParentAgent(self, _instance);
_returnValue->value = ((BaseAgent*)self)->ShotCanReach(pValue_target_pos);
}
};
class BehaviorLoaderImplement : BehaviorLoader
{
public:
@ -237,11 +373,18 @@ namespace behaviac
virtual bool load()
{
AgentMeta::SetTotalSignature(3849912422u);
AgentMeta::SetTotalSignature(2003817338u);
AgentMeta* meta = NULL;
BEHAVIAC_UNUSED_VAR(meta);
// glm::vec3
meta = BEHAVIAC_NEW AgentMeta(854293875u);
AgentMeta::GetAgentMetas()[3393792830u] = meta;
meta->RegisterMemberProperty(784805480u, BEHAVIAC_NEW CMemberProperty< float >("x", Set_glm_vec3_x, Get_glm_vec3_x));
meta->RegisterMemberProperty(937172777u, BEHAVIAC_NEW CMemberProperty< float >("y", Set_glm_vec3_y, Get_glm_vec3_y));
meta->RegisterMemberProperty(485575914u, BEHAVIAC_NEW CMemberProperty< float >("z", Set_glm_vec3_z, Get_glm_vec3_z));
// behaviac::Agent
meta = BEHAVIAC_NEW AgentMeta(24743406u);
AgentMeta::GetAgentMetas()[1770892321u] = meta;
@ -253,18 +396,36 @@ namespace behaviac
meta->RegisterMethod(502968959u, BEHAVIAC_NEW CMethod_behaviac_Agent_VectorRemove());
// BaseAgent
meta = BEHAVIAC_NEW AgentMeta(1438906970u);
meta = BEHAVIAC_NEW AgentMeta(3706475328u);
AgentMeta::GetAgentMetas()[2774251291u] = meta;
meta->RegisterMemberProperty(2916366392u, BEHAVIAC_NEW CMemberProperty< int >("find_enemy_target_uniid", Set_BaseAgent_find_enemy_target_uniid, Get_BaseAgent_find_enemy_target_uniid));
meta->RegisterMemberProperty(2276820502u, BEHAVIAC_NEW CMemberProperty< int >("selected_skill_id", Set_BaseAgent_selected_skill_id, Get_BaseAgent_selected_skill_id));
meta->RegisterMethod(1672911688u, BEHAVIAC_NEW CAgentMethod_1< bool, int >(FunctionPointer_BaseAgent_CanUseSkill));
meta->RegisterMethod(513965041u, BEHAVIAC_NEW CAgentMethodVoid_1<int>(FunctionPointer_BaseAgent_ChaseToKill) /* ChaseToKill */);
meta->RegisterMethod(623091365u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, int >(FunctionPointer_BaseAgent_CoAttackTarget));
meta->RegisterMethod(1719017386u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, float >(FunctionPointer_BaseAgent_CoFindPathToCurrentTarget));
meta->RegisterMethod(1290650388u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, float >(FunctionPointer_BaseAgent_CoMoveToCurrentTarget));
meta->RegisterMethod(2039856097u, BEHAVIAC_NEW CAgentMethod< bool >(FunctionPointer_BaseAgent_CurrentTargetIsValid));
meta->RegisterMethod(1047842467u, BEHAVIAC_NEW CAgentMethod< bool >(FunctionPointer_BaseAgent_CurrentTargetMoveCanReach));
meta->RegisterMethod(2126763853u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, int >(FunctionPointer_BaseAgent_DoSkill));
meta->RegisterMethod(1528295926u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, int >(FunctionPointer_BaseAgent_DoUseSkill));
meta->RegisterMethod(2009627204u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, float >(FunctionPointer_BaseAgent_FindEnemy));
meta->RegisterMethod(32551668u, BEHAVIAC_NEW CAgentMethod< float >(FunctionPointer_BaseAgent_GetAttackRange));
meta->RegisterMethod(1110255456u, BEHAVIAC_NEW CAgentMethod< float >(FunctionPointer_BaseAgent_GetCurrentTargetDistance));
meta->RegisterMethod(2755845811u, BEHAVIAC_NEW CAgentMethod< float >(FunctionPointer_BaseAgent_GetFindEnemyResultTargetDistance));
meta->RegisterMethod(221940739u, BEHAVIAC_NEW CAgentMethod< glm::vec3 >(FunctionPointer_BaseAgent_GetFindEnemyResultTargetPos));
meta->RegisterMethod(2424678062u, BEHAVIAC_NEW CAgentMethod< int >(FunctionPointer_BaseAgent_GetFindEnemyResultTargetUniId));
meta->RegisterMethod(3533946671u, BEHAVIAC_NEW CAgentMethod< glm::vec3 >(FunctionPointer_BaseAgent_GetPos));
meta->RegisterMethod(3603629747u, BEHAVIAC_NEW CAgentMethod_1< bool, int >(FunctionPointer_BaseAgent_HasBuffEffect));
meta->RegisterMethod(3047011226u, BEHAVIAC_NEW CAgentMethod_1< bool, float >(FunctionPointer_BaseAgent_HasTarget));
meta->RegisterMethod(400482748u, BEHAVIAC_NEW CAgentMethod< bool >(FunctionPointer_BaseAgent_IsGameOver));
meta->RegisterMethod(1045109914u, BEHAVIAC_NEW CAgentStaticMethodVoid_1<char*>(FunctionPointer_BaseAgent_LogMessage));
meta->RegisterMethod(745495888u, BEHAVIAC_NEW CMethod_BaseAgent_MoveCanReach());
meta->RegisterMethod(3111585017u, BEHAVIAC_NEW CAgentMethodVoid_2<int, int>(FunctionPointer_BaseAgent_OnAttacked) /* OnAttacked */);
meta->RegisterMethod(4091391051u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, behaviac::vector<int> >(FunctionPointer_BaseAgent_SelectUseableSkill));
meta->RegisterMethod(1800373320u, BEHAVIAC_NEW CAgentMethodVoid_1<bool>(FunctionPointer_BaseAgent_SetBulletTraceMode));
meta->RegisterMethod(3066391950u, BEHAVIAC_NEW CAgentMethodVoid_1<int>(FunctionPointer_BaseAgent_SetCurrentTarget));
meta->RegisterMethod(197201453u, BEHAVIAC_NEW CMethod_BaseAgent_ShotCanReach());
meta->RegisterMethod(2521019022u, BEHAVIAC_NEW CMethod_behaviac_Agent_VectorAdd());
meta->RegisterMethod(2306090221u, BEHAVIAC_NEW CMethod_behaviac_Agent_VectorClear());
meta->RegisterMethod(3483755530u, BEHAVIAC_NEW CMethod_behaviac_Agent_VectorContains());
@ -272,24 +433,42 @@ namespace behaviac
meta->RegisterMethod(502968959u, BEHAVIAC_NEW CMethod_behaviac_Agent_VectorRemove());
// AndroidAgent
meta = BEHAVIAC_NEW AgentMeta(3563824725u);
meta = BEHAVIAC_NEW AgentMeta(683007333u);
AgentMeta::GetAgentMetas()[2475098143u] = meta;
meta->RegisterCustomizedProperty(2916366392u, BEHAVIAC_NEW CCustomizedProperty< int >(2916366392u, "find_enemy_target_uniid", "0"));
meta->RegisterCustomizedProperty(2276820502u, BEHAVIAC_NEW CCustomizedProperty< int >(2276820502u, "selected_skill_id", "0"));
meta->RegisterMethod(1672911688u, BEHAVIAC_NEW CAgentMethod_1< bool, int >(FunctionPointer_AndroidAgent_CanUseSkill));
meta->RegisterMethod(513965041u, BEHAVIAC_NEW CAgentMethodVoid_1<int>(FunctionPointer_AndroidAgent_ChaseToKill) /* ChaseToKill */);
meta->RegisterMethod(623091365u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, int >(FunctionPointer_AndroidAgent_CoAttackTarget));
meta->RegisterMethod(1719017386u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, float >(FunctionPointer_AndroidAgent_CoFindPathToCurrentTarget));
meta->RegisterMethod(1290650388u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, float >(FunctionPointer_AndroidAgent_CoMoveToCurrentTarget));
meta->RegisterMethod(2039856097u, BEHAVIAC_NEW CAgentMethod< bool >(FunctionPointer_AndroidAgent_CurrentTargetIsValid));
meta->RegisterMethod(1047842467u, BEHAVIAC_NEW CAgentMethod< bool >(FunctionPointer_AndroidAgent_CurrentTargetMoveCanReach));
meta->RegisterMethod(2886181657u, BEHAVIAC_NEW CAgentMethod< behaviac::EBTStatus >(FunctionPointer_AndroidAgent_DoAttack));
meta->RegisterMethod(2062982811u, BEHAVIAC_NEW CAgentMethod_2< behaviac::EBTStatus, int, int >(FunctionPointer_AndroidAgent_DoIdle));
meta->RegisterMethod(846782702u, BEHAVIAC_NEW CAgentMethod< behaviac::EBTStatus >(FunctionPointer_AndroidAgent_DoPursuit));
meta->RegisterMethod(1079343198u, BEHAVIAC_NEW CAgentMethod< behaviac::EBTStatus >(FunctionPointer_AndroidAgent_DoRandomShot));
meta->RegisterMethod(130097619u, BEHAVIAC_NEW CAgentMethod< behaviac::EBTStatus >(FunctionPointer_AndroidAgent_DoRandomWalk));
meta->RegisterMethod(2126763853u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, int >(FunctionPointer_AndroidAgent_DoSkill));
meta->RegisterMethod(1528295926u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, int >(FunctionPointer_AndroidAgent_DoUseSkill));
meta->RegisterMethod(2009627204u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, float >(FunctionPointer_AndroidAgent_FindEnemy));
meta->RegisterMethod(32551668u, BEHAVIAC_NEW CAgentMethod< float >(FunctionPointer_AndroidAgent_GetAttackRange));
meta->RegisterMethod(1110255456u, BEHAVIAC_NEW CAgentMethod< float >(FunctionPointer_AndroidAgent_GetCurrentTargetDistance));
meta->RegisterMethod(2755845811u, BEHAVIAC_NEW CAgentMethod< float >(FunctionPointer_AndroidAgent_GetFindEnemyResultTargetDistance));
meta->RegisterMethod(221940739u, BEHAVIAC_NEW CAgentMethod< glm::vec3 >(FunctionPointer_AndroidAgent_GetFindEnemyResultTargetPos));
meta->RegisterMethod(2424678062u, BEHAVIAC_NEW CAgentMethod< int >(FunctionPointer_AndroidAgent_GetFindEnemyResultTargetUniId));
meta->RegisterMethod(3533946671u, BEHAVIAC_NEW CAgentMethod< glm::vec3 >(FunctionPointer_AndroidAgent_GetPos));
meta->RegisterMethod(1666360340u, BEHAVIAC_NEW CAgentMethod< State_e >(FunctionPointer_AndroidAgent_GetState));
meta->RegisterMethod(3603629747u, BEHAVIAC_NEW CAgentMethod_1< bool, int >(FunctionPointer_AndroidAgent_HasBuffEffect));
meta->RegisterMethod(3047011226u, BEHAVIAC_NEW CAgentMethod_1< bool, float >(FunctionPointer_AndroidAgent_HasTarget));
meta->RegisterMethod(400482748u, BEHAVIAC_NEW CAgentMethod< bool >(FunctionPointer_AndroidAgent_IsGameOver));
meta->RegisterMethod(1045109914u, BEHAVIAC_NEW CAgentStaticMethodVoid_1<char*>(FunctionPointer_AndroidAgent_LogMessage));
meta->RegisterMethod(745495888u, BEHAVIAC_NEW CMethod_BaseAgent_MoveCanReach());
meta->RegisterMethod(3111585017u, BEHAVIAC_NEW CAgentMethodVoid_2<int, int>(FunctionPointer_AndroidAgent_OnAttacked) /* OnAttacked */);
meta->RegisterMethod(4091391051u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, behaviac::vector<int> >(FunctionPointer_AndroidAgent_SelectUseableSkill));
meta->RegisterMethod(1800373320u, BEHAVIAC_NEW CAgentMethodVoid_1<bool>(FunctionPointer_AndroidAgent_SetBulletTraceMode));
meta->RegisterMethod(3066391950u, BEHAVIAC_NEW CAgentMethodVoid_1<int>(FunctionPointer_AndroidAgent_SetCurrentTarget));
meta->RegisterMethod(197201453u, BEHAVIAC_NEW CMethod_BaseAgent_ShotCanReach());
meta->RegisterMethod(2521019022u, BEHAVIAC_NEW CMethod_behaviac_Agent_VectorAdd());
meta->RegisterMethod(2306090221u, BEHAVIAC_NEW CMethod_behaviac_Agent_VectorClear());
meta->RegisterMethod(3483755530u, BEHAVIAC_NEW CMethod_behaviac_Agent_VectorContains());
@ -297,10 +476,17 @@ namespace behaviac
meta->RegisterMethod(502968959u, BEHAVIAC_NEW CMethod_behaviac_Agent_VectorRemove());
// HeroAgent
meta = BEHAVIAC_NEW AgentMeta(1561120813u);
meta = BEHAVIAC_NEW AgentMeta(3564372298u);
AgentMeta::GetAgentMetas()[2270112014u] = meta;
meta->RegisterMemberProperty(2916366392u, BEHAVIAC_NEW CMemberProperty< int >("find_enemy_target_uniid", Set_BaseAgent_find_enemy_target_uniid, Get_BaseAgent_find_enemy_target_uniid));
meta->RegisterMemberProperty(2276820502u, BEHAVIAC_NEW CMemberProperty< int >("selected_skill_id", Set_BaseAgent_selected_skill_id, Get_BaseAgent_selected_skill_id));
meta->RegisterMethod(1672911688u, BEHAVIAC_NEW CAgentMethod_1< bool, int >(FunctionPointer_HeroAgent_CanUseSkill));
meta->RegisterMethod(513965041u, BEHAVIAC_NEW CAgentMethodVoid_1<int>(FunctionPointer_HeroAgent_ChaseToKill) /* ChaseToKill */);
meta->RegisterMethod(623091365u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, int >(FunctionPointer_HeroAgent_CoAttackTarget));
meta->RegisterMethod(1719017386u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, float >(FunctionPointer_HeroAgent_CoFindPathToCurrentTarget));
meta->RegisterMethod(1290650388u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, float >(FunctionPointer_HeroAgent_CoMoveToCurrentTarget));
meta->RegisterMethod(2039856097u, BEHAVIAC_NEW CAgentMethod< bool >(FunctionPointer_HeroAgent_CurrentTargetIsValid));
meta->RegisterMethod(1047842467u, BEHAVIAC_NEW CAgentMethod< bool >(FunctionPointer_HeroAgent_CurrentTargetMoveCanReach));
meta->RegisterMethod(2886181657u, BEHAVIAC_NEW CAgentMethod< behaviac::EBTStatus >(FunctionPointer_HeroAgent_DoAttack));
meta->RegisterMethod(542584570u, BEHAVIAC_NEW CAgentMethod< behaviac::EBTStatus >(FunctionPointer_HeroAgent_DoFlyToMasterAround));
meta->RegisterMethod(1239418881u, BEHAVIAC_NEW CAgentMethod< behaviac::EBTStatus >(FunctionPointer_HeroAgent_DoFollowMaster));
@ -309,16 +495,28 @@ namespace behaviac
meta->RegisterMethod(846782702u, BEHAVIAC_NEW CAgentMethod< behaviac::EBTStatus >(FunctionPointer_HeroAgent_DoPursuit));
meta->RegisterMethod(1079343198u, BEHAVIAC_NEW CAgentMethod< behaviac::EBTStatus >(FunctionPointer_HeroAgent_DoRandomShot));
meta->RegisterMethod(130097619u, BEHAVIAC_NEW CAgentMethod< behaviac::EBTStatus >(FunctionPointer_HeroAgent_DoRandomWalk));
meta->RegisterMethod(2126763853u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, int >(FunctionPointer_HeroAgent_DoSkill));
meta->RegisterMethod(1528295926u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, int >(FunctionPointer_HeroAgent_DoUseSkill));
meta->RegisterMethod(2009627204u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, float >(FunctionPointer_HeroAgent_FindEnemy));
meta->RegisterMethod(32551668u, BEHAVIAC_NEW CAgentMethod< float >(FunctionPointer_HeroAgent_GetAttackRange));
meta->RegisterMethod(1110255456u, BEHAVIAC_NEW CAgentMethod< float >(FunctionPointer_HeroAgent_GetCurrentTargetDistance));
meta->RegisterMethod(2755845811u, BEHAVIAC_NEW CAgentMethod< float >(FunctionPointer_HeroAgent_GetFindEnemyResultTargetDistance));
meta->RegisterMethod(221940739u, BEHAVIAC_NEW CAgentMethod< glm::vec3 >(FunctionPointer_HeroAgent_GetFindEnemyResultTargetPos));
meta->RegisterMethod(2424678062u, BEHAVIAC_NEW CAgentMethod< int >(FunctionPointer_HeroAgent_GetFindEnemyResultTargetUniId));
meta->RegisterMethod(3721974980u, BEHAVIAC_NEW CAgentMethod< float >(FunctionPointer_HeroAgent_GetMasterDistance));
meta->RegisterMethod(3533946671u, BEHAVIAC_NEW CAgentMethod< glm::vec3 >(FunctionPointer_HeroAgent_GetPos));
meta->RegisterMethod(3865393862u, BEHAVIAC_NEW CAgentMethod< glm::vec3 >(FunctionPointer_HeroAgent_GetSafeAreaCenter));
meta->RegisterMethod(3603629747u, BEHAVIAC_NEW CAgentMethod_1< bool, int >(FunctionPointer_HeroAgent_HasBuffEffect));
meta->RegisterMethod(3047011226u, BEHAVIAC_NEW CAgentMethod_1< bool, float >(FunctionPointer_HeroAgent_HasTarget));
meta->RegisterMethod(400482748u, BEHAVIAC_NEW CAgentMethod< bool >(FunctionPointer_HeroAgent_IsGameOver));
meta->RegisterMethod(1045109914u, BEHAVIAC_NEW CAgentStaticMethodVoid_1<char*>(FunctionPointer_HeroAgent_LogMessage));
meta->RegisterMethod(745495888u, BEHAVIAC_NEW CMethod_BaseAgent_MoveCanReach());
meta->RegisterMethod(3111585017u, BEHAVIAC_NEW CAgentMethodVoid_2<int, int>(FunctionPointer_HeroAgent_OnAttacked) /* OnAttacked */);
meta->RegisterMethod(4113176194u, BEHAVIAC_NEW CAgentMethodVoid_1<int>(FunctionPointer_HeroAgent_OnMasterAttackTarget) /* OnMasterAttackTarget */);
meta->RegisterMethod(4091391051u, BEHAVIAC_NEW CAgentMethod_1< behaviac::EBTStatus, behaviac::vector<int> >(FunctionPointer_HeroAgent_SelectUseableSkill));
meta->RegisterMethod(1800373320u, BEHAVIAC_NEW CAgentMethodVoid_1<bool>(FunctionPointer_HeroAgent_SetBulletTraceMode));
meta->RegisterMethod(3066391950u, BEHAVIAC_NEW CAgentMethodVoid_1<int>(FunctionPointer_HeroAgent_SetCurrentTarget));
meta->RegisterMethod(197201453u, BEHAVIAC_NEW CMethod_BaseAgent_ShotCanReach());
meta->RegisterMethod(2521019022u, BEHAVIAC_NEW CMethod_behaviac_Agent_VectorAdd());
meta->RegisterMethod(2306090221u, BEHAVIAC_NEW CMethod_behaviac_Agent_VectorClear());
meta->RegisterMethod(3483755530u, BEHAVIAC_NEW CMethod_behaviac_Agent_VectorContains());
@ -330,6 +528,8 @@ namespace behaviac
AgentMeta::Register<AndroidAgent>("AndroidAgent");
AgentMeta::Register<HeroAgent>("HeroAgent");
AgentMeta::Register<State_e>("State_e");
AgentMeta::Register<FindPathResult>("FindPathResult");
AgentMeta::Register<glm::vec3>("glm::vec3");
return true;
}
@ -341,6 +541,8 @@ namespace behaviac
AgentMeta::UnRegister<AndroidAgent>("AndroidAgent");
AgentMeta::UnRegister<HeroAgent>("HeroAgent");
AgentMeta::UnRegister<State_e>("State_e");
AgentMeta::UnRegister<FindPathResult>("FindPathResult");
AgentMeta::UnRegister<glm::vec3>("glm::vec3");
return true;
}

59
server/bin/exported/behaviac_generated/types/internal/behaviac_agent_meta.h
View File

@ -16,34 +16,74 @@ namespace behaviac
// ---------------------------------------------------------------------
inline void FunctionPointer_behaviac_Agent_LogMessage(char* param0) { behaviac::Agent::LogMessage(param0); }
inline void Set_BaseAgent_find_enemy_target_uniid(Agent* self, int value) { ((BaseAgent*)self)->find_enemy_target_uniid = value; };
inline const void* Get_BaseAgent_find_enemy_target_uniid(Agent* self) { return &((BaseAgent*)self)->find_enemy_target_uniid; };
inline void Set_BaseAgent_selected_skill_id(Agent* self, int value) { ((BaseAgent*)self)->selected_skill_id = value; };
inline const void* Get_BaseAgent_selected_skill_id(Agent* self) { return &((BaseAgent*)self)->selected_skill_id; };
inline bool FunctionPointer_BaseAgent_CanUseSkill(Agent* self, int skill_id) { return (bool)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_CanUseSkill, bool, int >(skill_id); }
inline void FunctionPointer_BaseAgent_ChaseToKill(Agent* self, int target_uniid) { } /* ChaseToKill */
inline behaviac::EBTStatus FunctionPointer_BaseAgent_CoAttackTarget(Agent* self, int target_id) { return ((BaseAgent*)self)->CoAttackTarget(target_id); }
inline behaviac::EBTStatus FunctionPointer_BaseAgent_CoFindPathToCurrentTarget(Agent* self, float distance) { return ((BaseAgent*)self)->CoFindPathToCurrentTarget(distance); }
inline behaviac::EBTStatus FunctionPointer_BaseAgent_CoMoveToCurrentTarget(Agent* self, float distance) { return ((BaseAgent*)self)->CoMoveToCurrentTarget(distance); }
inline bool FunctionPointer_BaseAgent_CurrentTargetIsValid(Agent* self) { return ((BaseAgent*)self)->CurrentTargetIsValid(); }
inline bool FunctionPointer_BaseAgent_CurrentTargetMoveCanReach(Agent* self) { return (bool)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_CurrentTargetMoveCanReach, bool >(); }
inline behaviac::EBTStatus FunctionPointer_BaseAgent_DoSkill(Agent* self, int skill_id) { return (behaviac::EBTStatus)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_DoSkill, behaviac::EBTStatus, int >(skill_id); }
inline behaviac::EBTStatus FunctionPointer_BaseAgent_DoUseSkill(Agent* self, int skill_id) { return (behaviac::EBTStatus)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_DoUseSkill, behaviac::EBTStatus, int >(skill_id); }
inline behaviac::EBTStatus FunctionPointer_BaseAgent_FindEnemy(Agent* self, float range) { return ((BaseAgent*)self)->FindEnemy(range); }
inline float FunctionPointer_BaseAgent_GetAttackRange(Agent* self) { return ((BaseAgent*)self)->GetAttackRange(); }
inline float FunctionPointer_BaseAgent_GetCurrentTargetDistance(Agent* self) { return ((BaseAgent*)self)->GetCurrentTargetDistance(); }
inline float FunctionPointer_BaseAgent_GetFindEnemyResultTargetDistance(Agent* self) { return ((BaseAgent*)self)->GetFindEnemyResultTargetDistance(); }
inline glm::vec3 FunctionPointer_BaseAgent_GetFindEnemyResultTargetPos(Agent* self) { return ((BaseAgent*)self)->GetFindEnemyResultTargetPos(); }
inline int FunctionPointer_BaseAgent_GetFindEnemyResultTargetUniId(Agent* self) { return ((BaseAgent*)self)->GetFindEnemyResultTargetUniId(); }
inline glm::vec3 FunctionPointer_BaseAgent_GetPos(Agent* self) { return (glm::vec3)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_GetPos, glm::vec3 >(); }
inline bool FunctionPointer_BaseAgent_HasBuffEffect(Agent* self, int buff_effect) { return (bool)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_HasBuffEffect, bool, int >(buff_effect); }
inline bool FunctionPointer_BaseAgent_HasTarget(Agent* self, float range) { return (bool)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_HasTarget, bool, float >(range); }
inline bool FunctionPointer_BaseAgent_IsGameOver(Agent* self) { return ((BaseAgent*)self)->IsGameOver(); }
inline void FunctionPointer_BaseAgent_LogMessage(char* param0) { BaseAgent::LogMessage(param0); }
inline void FunctionPointer_BaseAgent_OnAttacked(Agent* self, int sender, int time) { } /* OnAttacked */
inline behaviac::EBTStatus FunctionPointer_BaseAgent_SelectUseableSkill(Agent* self, behaviac::vector<int> skill_ids) { return (behaviac::EBTStatus)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_SelectUseableSkill, behaviac::EBTStatus, behaviac::vector<int> >(skill_ids); }
inline void FunctionPointer_BaseAgent_SetBulletTraceMode(Agent* self, bool mode) { ((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_SetBulletTraceMode, void, bool >(mode); }
inline void FunctionPointer_BaseAgent_SetCurrentTarget(Agent* self, int target_uniid) { ((BaseAgent*)self)->SetCurrentTarget(target_uniid); }
inline bool FunctionPointer_AndroidAgent_CanUseSkill(Agent* self, int skill_id) { return (bool)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_CanUseSkill, bool, int >(skill_id); }
inline void FunctionPointer_AndroidAgent_ChaseToKill(Agent* self, int target_uniid) { } /* ChaseToKill */
inline behaviac::EBTStatus FunctionPointer_AndroidAgent_CoAttackTarget(Agent* self, int target_id) { return ((AndroidAgent*)self)->CoAttackTarget(target_id); }
inline behaviac::EBTStatus FunctionPointer_AndroidAgent_CoFindPathToCurrentTarget(Agent* self, float distance) { return ((AndroidAgent*)self)->CoFindPathToCurrentTarget(distance); }
inline behaviac::EBTStatus FunctionPointer_AndroidAgent_CoMoveToCurrentTarget(Agent* self, float distance) { return ((AndroidAgent*)self)->CoMoveToCurrentTarget(distance); }
inline bool FunctionPointer_AndroidAgent_CurrentTargetIsValid(Agent* self) { return ((AndroidAgent*)self)->CurrentTargetIsValid(); }
inline bool FunctionPointer_AndroidAgent_CurrentTargetMoveCanReach(Agent* self) { return (bool)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_CurrentTargetMoveCanReach, bool >(); }
inline behaviac::EBTStatus FunctionPointer_AndroidAgent_DoAttack(Agent* self) { return ((AndroidAgent*)self)->DoAttack(); }
inline behaviac::EBTStatus FunctionPointer_AndroidAgent_DoIdle(Agent* self, int min_time, int max_time) { return ((AndroidAgent*)self)->DoIdle(min_time, max_time); }
inline behaviac::EBTStatus FunctionPointer_AndroidAgent_DoPursuit(Agent* self) { return ((AndroidAgent*)self)->DoPursuit(); }
inline behaviac::EBTStatus FunctionPointer_AndroidAgent_DoRandomShot(Agent* self) { return (behaviac::EBTStatus)((AndroidAgent*)self)->_Execute_Method_<METHOD_TYPE_AndroidAgent_DoRandomShot, behaviac::EBTStatus >(); }
inline behaviac::EBTStatus FunctionPointer_AndroidAgent_DoRandomWalk(Agent* self) { return ((AndroidAgent*)self)->DoRandomWalk(); }
inline behaviac::EBTStatus FunctionPointer_AndroidAgent_DoSkill(Agent* self, int skill_id) { return (behaviac::EBTStatus)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_DoSkill, behaviac::EBTStatus, int >(skill_id); }
inline behaviac::EBTStatus FunctionPointer_AndroidAgent_DoUseSkill(Agent* self, int skill_id) { return (behaviac::EBTStatus)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_DoUseSkill, behaviac::EBTStatus, int >(skill_id); }
inline behaviac::EBTStatus FunctionPointer_AndroidAgent_FindEnemy(Agent* self, float range) { return ((AndroidAgent*)self)->FindEnemy(range); }
inline float FunctionPointer_AndroidAgent_GetAttackRange(Agent* self) { return ((AndroidAgent*)self)->GetAttackRange(); }
inline float FunctionPointer_AndroidAgent_GetCurrentTargetDistance(Agent* self) { return ((AndroidAgent*)self)->GetCurrentTargetDistance(); }
inline float FunctionPointer_AndroidAgent_GetFindEnemyResultTargetDistance(Agent* self) { return ((AndroidAgent*)self)->GetFindEnemyResultTargetDistance(); }
inline glm::vec3 FunctionPointer_AndroidAgent_GetFindEnemyResultTargetPos(Agent* self) { return ((AndroidAgent*)self)->GetFindEnemyResultTargetPos(); }
inline int FunctionPointer_AndroidAgent_GetFindEnemyResultTargetUniId(Agent* self) { return ((AndroidAgent*)self)->GetFindEnemyResultTargetUniId(); }
inline glm::vec3 FunctionPointer_AndroidAgent_GetPos(Agent* self) { return (glm::vec3)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_GetPos, glm::vec3 >(); }
inline State_e FunctionPointer_AndroidAgent_GetState(Agent* self) { return (State_e)((AndroidAgent*)self)->_Execute_Method_<METHOD_TYPE_AndroidAgent_GetState, State_e >(); }
inline bool FunctionPointer_AndroidAgent_HasBuffEffect(Agent* self, int buff_effect) { return (bool)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_HasBuffEffect, bool, int >(buff_effect); }
inline bool FunctionPointer_AndroidAgent_HasTarget(Agent* self, float range) { return (bool)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_HasTarget, bool, float >(range); }
inline bool FunctionPointer_AndroidAgent_IsGameOver(Agent* self) { return ((AndroidAgent*)self)->IsGameOver(); }
inline void FunctionPointer_AndroidAgent_LogMessage(char* param0) { AndroidAgent::LogMessage(param0); }
inline void FunctionPointer_AndroidAgent_OnAttacked(Agent* self, int sender, int time) { } /* OnAttacked */
inline behaviac::EBTStatus FunctionPointer_AndroidAgent_SelectUseableSkill(Agent* self, behaviac::vector<int> skill_ids) { return (behaviac::EBTStatus)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_SelectUseableSkill, behaviac::EBTStatus, behaviac::vector<int> >(skill_ids); }
inline void FunctionPointer_AndroidAgent_SetBulletTraceMode(Agent* self, bool mode) { ((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_SetBulletTraceMode, void, bool >(mode); }
inline void FunctionPointer_AndroidAgent_SetCurrentTarget(Agent* self, int target_uniid) { ((AndroidAgent*)self)->SetCurrentTarget(target_uniid); }
inline bool FunctionPointer_HeroAgent_CanUseSkill(Agent* self, int skill_id) { return (bool)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_CanUseSkill, bool, int >(skill_id); }
inline void FunctionPointer_HeroAgent_ChaseToKill(Agent* self, int target_uniid) { } /* ChaseToKill */
inline behaviac::EBTStatus FunctionPointer_HeroAgent_CoAttackTarget(Agent* self, int target_id) { return ((HeroAgent*)self)->CoAttackTarget(target_id); }
inline behaviac::EBTStatus FunctionPointer_HeroAgent_CoFindPathToCurrentTarget(Agent* self, float distance) { return ((HeroAgent*)self)->CoFindPathToCurrentTarget(distance); }
inline behaviac::EBTStatus FunctionPointer_HeroAgent_CoMoveToCurrentTarget(Agent* self, float distance) { return ((HeroAgent*)self)->CoMoveToCurrentTarget(distance); }
inline bool FunctionPointer_HeroAgent_CurrentTargetIsValid(Agent* self) { return ((HeroAgent*)self)->CurrentTargetIsValid(); }
inline bool FunctionPointer_HeroAgent_CurrentTargetMoveCanReach(Agent* self) { return (bool)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_CurrentTargetMoveCanReach, bool >(); }
inline behaviac::EBTStatus FunctionPointer_HeroAgent_DoAttack(Agent* self) { return (behaviac::EBTStatus)((HeroAgent*)self)->_Execute_Method_<METHOD_TYPE_HeroAgent_DoAttack, behaviac::EBTStatus >(); }
inline behaviac::EBTStatus FunctionPointer_HeroAgent_DoFlyToMasterAround(Agent* self) { return (behaviac::EBTStatus)((HeroAgent*)self)->_Execute_Method_<METHOD_TYPE_HeroAgent_DoFlyToMasterAround, behaviac::EBTStatus >(); }
inline behaviac::EBTStatus FunctionPointer_HeroAgent_DoFollowMaster(Agent* self) { return (behaviac::EBTStatus)((HeroAgent*)self)->_Execute_Method_<METHOD_TYPE_HeroAgent_DoFollowMaster, behaviac::EBTStatus >(); }
@ -52,15 +92,34 @@ namespace behaviac
inline behaviac::EBTStatus FunctionPointer_HeroAgent_DoPursuit(Agent* self) { return ((HeroAgent*)self)->DoPursuit(); }
inline behaviac::EBTStatus FunctionPointer_HeroAgent_DoRandomShot(Agent* self) { return ((HeroAgent*)self)->DoRandomShot(); }
inline behaviac::EBTStatus FunctionPointer_HeroAgent_DoRandomWalk(Agent* self) { return ((HeroAgent*)self)->DoRandomWalk(); }
inline behaviac::EBTStatus FunctionPointer_HeroAgent_DoSkill(Agent* self, int skill_id) { return (behaviac::EBTStatus)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_DoSkill, behaviac::EBTStatus, int >(skill_id); }
inline behaviac::EBTStatus FunctionPointer_HeroAgent_DoUseSkill(Agent* self, int skill_id) { return (behaviac::EBTStatus)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_DoUseSkill, behaviac::EBTStatus, int >(skill_id); }
inline behaviac::EBTStatus FunctionPointer_HeroAgent_FindEnemy(Agent* self, float range) { return ((HeroAgent*)self)->FindEnemy(range); }
inline float FunctionPointer_HeroAgent_GetAttackRange(Agent* self) { return ((HeroAgent*)self)->GetAttackRange(); }
inline float FunctionPointer_HeroAgent_GetCurrentTargetDistance(Agent* self) { return ((HeroAgent*)self)->GetCurrentTargetDistance(); }
inline float FunctionPointer_HeroAgent_GetFindEnemyResultTargetDistance(Agent* self) { return ((HeroAgent*)self)->GetFindEnemyResultTargetDistance(); }
inline glm::vec3 FunctionPointer_HeroAgent_GetFindEnemyResultTargetPos(Agent* self) { return ((HeroAgent*)self)->GetFindEnemyResultTargetPos(); }
inline int FunctionPointer_HeroAgent_GetFindEnemyResultTargetUniId(Agent* self) { return ((HeroAgent*)self)->GetFindEnemyResultTargetUniId(); }
inline float FunctionPointer_HeroAgent_GetMasterDistance(Agent* self) { return ((HeroAgent*)self)->GetMasterDistance(); }
inline glm::vec3 FunctionPointer_HeroAgent_GetPos(Agent* self) { return (glm::vec3)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_GetPos, glm::vec3 >(); }
inline glm::vec3 FunctionPointer_HeroAgent_GetSafeAreaCenter(Agent* self) { return ((HeroAgent*)self)->GetSafeAreaCenter(); }
inline bool FunctionPointer_HeroAgent_HasBuffEffect(Agent* self, int buff_effect) { return (bool)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_HasBuffEffect, bool, int >(buff_effect); }
inline bool FunctionPointer_HeroAgent_HasTarget(Agent* self, float range) { return (bool)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_HasTarget, bool, float >(range); }
inline bool FunctionPointer_HeroAgent_IsGameOver(Agent* self) { return ((HeroAgent*)self)->IsGameOver(); }
inline void FunctionPointer_HeroAgent_LogMessage(char* param0) { HeroAgent::LogMessage(param0); }
inline void FunctionPointer_HeroAgent_OnAttacked(Agent* self, int sender, int time) { } /* OnAttacked */
inline void FunctionPointer_HeroAgent_OnMasterAttackTarget(Agent* self, int target_uniid) { } /* OnMasterAttackTarget */
inline behaviac::EBTStatus FunctionPointer_HeroAgent_SelectUseableSkill(Agent* self, behaviac::vector<int> skill_ids) { return (behaviac::EBTStatus)((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_SelectUseableSkill, behaviac::EBTStatus, behaviac::vector<int> >(skill_ids); }
inline void FunctionPointer_HeroAgent_SetBulletTraceMode(Agent* self, bool mode) { ((BaseAgent*)self)->_Execute_Method_<METHOD_TYPE_BaseAgent_SetBulletTraceMode, void, bool >(mode); }
inline void FunctionPointer_HeroAgent_SetCurrentTarget(Agent* self, int target_uniid) { ((HeroAgent*)self)->SetCurrentTarget(target_uniid); }
inline void Set_glm_vec3_x(Agent* self, float value) { ((glm::vec3*)self)->x = value; };
inline const void* Get_glm_vec3_x(Agent* self) { return &((glm::vec3*)self)->x; };
inline void Set_glm_vec3_y(Agent* self, float value) { ((glm::vec3*)self)->y = value; };
inline const void* Get_glm_vec3_y(Agent* self) { return &((glm::vec3*)self)->y; };
inline void Set_glm_vec3_z(Agent* self, float value) { ((glm::vec3*)self)->z = value; };
inline const void* Get_glm_vec3_z(Agent* self) { return &((glm::vec3*)self)->z; };
}
#endif // _BEHAVIAC_AGENT_PROPERTIES_H_

49
server/bin/exported/behaviac_generated/types/internal/behaviac_customized_types.h
View File

@ -23,4 +23,53 @@ DECLARE_BEHAVIAC_ENUM_EX(State_e, State_e);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(State_e);
// -------------------
// Customized structs
// -------------------
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(FindPathResult, false);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(FindPathResult);
template< typename SWAPPER >
inline void SwapByteImplement(FindPathResult& v)
{
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const FindPathResult& lhs, const FindPathResult& rhs)
{
return &lhs == &rhs;
}
}
}
BEHAVIAC_EXTEND_EXISTING_TYPE_EX(glm::vec3, false);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(glm::vec3);
template< typename SWAPPER >
inline void SwapByteImplement(glm::vec3& v)
{
SwapByteImplement< SWAPPER >(v.x);
SwapByteImplement< SWAPPER >(v.y);
SwapByteImplement< SWAPPER >(v.z);
}
namespace behaviac
{
namespace PrivateDetails
{
template<>
inline bool Equal(const glm::vec3& lhs, const glm::vec3& rhs)
{
return Equal(lhs.x, rhs.x)
&& Equal(lhs.y, rhs.y)
&& Equal(lhs.z, rhs.z);
}
}
}
#endif // _BEHAVIAC_CUSTOMIZED_TYPES_H_

19
server/bin/exported/boss_40101.xml
View File

@ -3,21 +3,22 @@
<!--Source File: boss_40101.xml-->
<behavior name="boss_40101" agenttype="HeroAgent" version="5">
<node class="IfElse" id="0">
<node class="Condition" id="1">
<property Operator="Equal" />
<property Opl="Self.BaseAgent::HasTarget(300)" />
<property Opr="const bool true" />
</node>
<node class="Action" id="7">
<property Method="Self.HeroAgent::DoPursuit()" />
<node class="Sequence" id="1">
<node class="Action" id="10">
<property Method="Self.BaseAgent::FindEnemy(300)" />
<property ResultOption="BT_INVALID" />
</node>
</node>
<node class="ReferencedBehavior" id="7">
<property ReferenceBehavior="const string &quot;boss_40101_chase_to_kill&quot;" />
<property Task="Self.BaseAgent::ChaseToKill(int Self.BaseAgent::find_enemy_target_uniid)" />
</node>
<node class="SelectorProbability" id="2">
<node class="DecoratorWeight" id="3">
<property DecorateWhenChildEnds="false" />
<property Weight="const int 60" />
<attachment class="Event" id="8" flag="event">
<property ReferenceFilename="boss_40101_attack" />
<property ReferenceFilename="boss_40101_counter_attack" />
<property Task="Self.BaseAgent::OnAttacked(0,0)" />
<property TriggeredOnce="false" />
<property TriggerMode="Return" />
@ -31,7 +32,7 @@
<property DecorateWhenChildEnds="false" />
<property Weight="const int 30" />
<attachment class="Event" id="9" flag="event">
<property ReferenceFilename="boss_40101_attack" />
<property ReferenceFilename="boss_40101_counter_attack" />
<property Task="Self.BaseAgent::OnAttacked(0,0)" />
<property TriggeredOnce="false" />
<property TriggerMode="Return" />

16
server/bin/exported/boss_40101_attack.xml
View File

@ -6,11 +6,19 @@
<par name="_$local_task_param_$_0" type="int" value="0" />
<par name="_$local_task_param_$_1" type="int" value="0" />
</pars>
<node class="Task" id="0">
<property Prototype="Self.BaseAgent::OnAttacked(0,0)" />
<property IsHTN="false" />
<node class="Selector" id="0">
<node class="Sequence" id="2">
<node class="Action" id="1">
<property Method="Self.BaseAgent::CoAttackTarget(int Self.HeroAgent::_$local_task_param_$_0)" />
<property Method="Self.BaseAgent::SelectUseableSkill(3:60101|60121|60111)" />
<property ResultOption="BT_INVALID" />
</node>
<node class="Action" id="3">
<property Method="Self.BaseAgent::DoSkill(int Self.BaseAgent::selected_skill_id)" />
<property ResultOption="BT_INVALID" />
</node>
</node>
<node class="Action" id="4">
<property Method="Self.BaseAgent::CoMoveToCurrentTarget(60)" />
<property ResultOption="BT_INVALID" />
</node>
</node>

51
server/bin/exported/boss_40101_chase_to_kill.xml Normal file
View File

@ -0,0 +1,51 @@
<?xml version="1.0" encoding="utf-8"?>
<!--EXPORTED BY TOOL, DON'T MODIFY IT!-->
<!--Source File: boss_40101_chase_to_kill.xml-->
<behavior name="boss_40101_chase_to_kill" agenttype="BaseAgent" version="5">
<pars>
<par name="_$local_task_param_$_0" type="int" value="0" />
</pars>
<node class="Task" id="0">
<property Prototype="Self.BaseAgent::ChaseToKill(0)" />
<property IsHTN="false" />
<node class="Sequence" id="1">
<node class="Action" id="2">
<property Method="Self.BaseAgent::SetCurrentTarget(int Self.BaseAgent::_$local_task_param_$_0)" />
<property ResultOption="BT_SUCCESS" />
</node>
<node class="DecoratorLoop" id="3">
<property Count="const int -1" />
<property DecorateWhenChildEnds="true" />
<property DoneWithinFrame="false" />
<attachment class="Precondition" id="4" flag="precondition">
<property BinaryOperator="And" />
<property Operator="Equal" />
<property Opl="Self.BaseAgent::CurrentTargetIsValid()" />
<property Opr2="const bool true" />
<property Phase="Both" />
</attachment>
<attachment class="Precondition" id="6" flag="precondition">
<property BinaryOperator="And" />
<property Operator="Less" />
<property Opl="Self.BaseAgent::GetCurrentTargetDistance()" />
<property Opr2="const float 400" />
<property Phase="Both" />
</attachment>
<node class="IfElse" id="5">
<node class="Condition" id="7">
<property Operator="Equal" />
<property Opl="Self.BaseAgent::CurrentTargetMoveCanReach()" />
<property Opr="const bool true" />
</node>
<node class="ReferencedBehavior" id="9">
<property ReferenceBehavior="const string &quot;boss_40101_attack&quot;" />
</node>
<node class="Action" id="8">
<property Method="Self.BaseAgent::CoFindPathToCurrentTarget(60)" />
<property ResultOption="BT_INVALID" />
</node>
</node>
</node>
</node>
</node>
</behavior>

17
server/bin/exported/boss_40101_counter_attack.xml Normal file
View File

@ -0,0 +1,17 @@
<?xml version="1.0" encoding="utf-8"?>
<!--EXPORTED BY TOOL, DON'T MODIFY IT!-->
<!--Source File: boss_40101_counter_attack.xml-->
<behavior name="boss_40101_counter_attack" agenttype="BaseAgent" version="5">
<pars>
<par name="_$local_task_param_$_0" type="int" value="0" />
<par name="_$local_task_param_$_1" type="int" value="0" />
</pars>
<node class="Task" id="0">
<property Prototype="Self.BaseAgent::OnAttacked(0,0)" />
<property IsHTN="false" />
<node class="ReferencedBehavior" id="1">
<property ReferenceBehavior="const string &quot;boss_40101_chase_to_kill&quot;" />
<property Task="Self.BaseAgent::ChaseToKill(int Self.BaseAgent::_$local_task_param_$_0)" />
</node>
</node>
</behavior>

21
server/bin/exported/meta/game2006.meta.xml
View File

@ -1,3 +1,22 @@
<?xml version="1.0" encoding="utf-8"?>
<!--EXPORTED BY TOOL, DON'T MODIFY IT!-->
<agents version="1" signature="3849912422" />
<agents version="1" signature="2003817338">
<agent type="BaseAgent" base="behaviac::Agent" signature="3706475328">
<properties>
<property name="find_enemy_target_uniid" type="int" member="false" static="false" defaultvalue="0" />
<property name="selected_skill_id" type="int" member="false" static="false" defaultvalue="0" />
</properties>
</agent>
<agent type="AndroidAgent" base="BaseAgent" signature="683007333">
<properties>
<property name="find_enemy_target_uniid" type="int" member="false" static="false" defaultvalue="0" />
<property name="selected_skill_id" type="int" member="false" static="false" defaultvalue="0" />
</properties>
</agent>
<agent type="HeroAgent" base="BaseAgent" signature="3564372298">
<properties>
<property name="find_enemy_target_uniid" type="int" member="false" static="false" defaultvalue="0" />
<property name="selected_skill_id" type="int" member="false" static="false" defaultvalue="0" />
</properties>
</agent>
</agents>

2
server/gameserver/human.cc
View File

@ -2666,7 +2666,7 @@ void Human::ProcLootWeapon(AddItemDTO& dto)
#endif
dto.handled = true;
} else {
#if 1
#if 0
if (GetBuffByEffectId(kBET_Passenger) ||
GetBuffByEffectId(kBET_Vertigo)) {
return;