1.5.x Структура aipolicy

[Электрон]

File aipolicy.h:
ai_object;
ai_fix_magic_task;
typedef ai_fix_magic_task;
ai_fix_melee_task;
typedef ai_fix_melee_task;
ai_follow_master;
typedef ai_follow_master;
ai_follow_target;
typedef ai_follow_target;
ai_magic_melee_task;
typedef ai_magic_melee_task;
ai_magic_task;
typedef ai_magic_task;
ai_melee_task;
typedef ai_melee_task;
ai_object::target_info;
typedef ai_object::target_info;
ai_param;
typedef ai_param;
ai_patrol_task;
typedef ai_patrol_task;
ai_pet_follow_master;
typedef ai_pet_follow_master;
ai_pet_skill_task;
typedef ai_pet_skill_task;
ai_play_action_task;
typedef ai_play_action_task;
ai_policy;
typedef ai_policy;
ai_policy::__SKILLS_T;
typedef ai_policy::__SKILLS_T;
ai_range_task;
typedef ai_range_task;
ai_regeneration_task;
typedef ai_regeneration_task;
ai_rest_task;
typedef ai_rest_task;
ai_returnhome_task;
typedef ai_returnhome_task;
ai_runaway_task;
typedef ai_runaway_task;
ai_silent_runaway_task;
typedef ai_silent_runaway_task;
ai_silent_task;
typedef ai_silent_task;
ai_skill_task;
typedef ai_skill_task;
ai_skill_task_2;
typedef ai_skill_task_2;
ai_target_task;
typedef ai_target_task;
ai_task;
typedef ai_task;

Спойлер

type = class ai_object : public abase::ASmallObject {
public:
virtual ai_object * Clone() const;
~ai_object(int);
virtual class gactive_imp * GetImpl();
virtual float GetIgnoreRange();
virtual void GetID(XID&);
virtual void GetPos(A3DVECTOR&);
virtual int GetState();
virtual int GetHP();
virtual int GetMaxHP();
virtual int GenHP(int);
virtual int GetMP();
virtual void BeHurt(int);
virtual float GetAttackRange();
virtual float GetMagicRange(unsigned int, int);
virtual float GetBodySize();
virtual int GetFaction();
virtual int GetEnemyFaction();
virtual int GetAntiInvisibleDegree();
virtual size_t GetAggroCount();
virtual void ClearAggro();
virtual int GetAggroEntry(unsigned int, XID&);
virtual void RemoveAggroEntry(XID const&);
virtual void ChangeAggroEntry(XID const&, int);
virtual void ForwardFirstAggro(XID const&, int);
virtual void RegroupAggro();
virtual void SwapAggro(int, int);
virtual void BeTaunted(XID const&);
virtual void FadeTarget(XID const&);
virtual void AggroFade();
virtual int GetInhabitType();
virtual void HateTarget(XID const&);
virtual void ActiveCombatState(bool);
virtual bool GetCombatState();
virtual void ActiveInvisible(bool);
virtual void ClearDamageList();
virtual bool CanRest();
virtual bool IsInIdleHeartbeat();
virtual void GetPatrolPos(A3DVECTOR&);
virtual void GetPatrolPos(A3DVECTOR&, float);
virtual const XID & GetLeaderID();
virtual void SetLeaderID(XID const&);
virtual const XID & GetTargetID();
virtual void SetTargetID(XID const&);
virtual float GetSightRange();
virtual const A3DVECTOR & GetBirthPlace();
virtual bool IsReturnHome(A3DVECTOR&, float);
virtual void PetRelocatePos(bool);
virtual bool PetGetNearestTeammate(float, XID&);
virtual int GetLastDamage();
virtual void AddSession(act_session*);
virtual void ClearSession();
virtual bool HasSession();
virtual void SendMessage(XID const&, int);
virtual void ReturnHome(A3DVECTOR const&, float);
virtual void AddInvincibleFilter(XID const&);
virtual int GetAttackSpeed();
virtual void Say(XID const&, void const*, unsigned int, int, bool);
virtual void BattleFactionSay(void const*, unsigned int);
virtual void BattleSay(void const*, unsigned int);
virtual void BroadcastSay(void const*, unsigned int, bool);
virtual void SendClientTurretNotify(int);
virtual void InstanceSay(void const*, unsigned int);
virtual void SummonMonster(int, int, XID const&, int, int, char, int);
virtual void StartPlayAction(char*, int, int, int);
virtual void StopPlayAction();
virtual int QueryTarget(XID const&, ai_object::target_info&);
virtual bool CheckWorld();
virtual int GetSealMode();
static struct policy * CreatePolicy(int);
}
 
type = class ai_object::target_info {
public:
A3DVECTOR pos;
int race;
int faction;
int level;
int hp;
int mp;
float body_size;
int max_hp;
int invisible_degree;
}
 
type = class ai_param {
public:
int trigger_policy;
int policy_class;
int event[3];
int event_level[3];
int primary_strategy;
class {
public:
int as_count;
int bs_count;
int cs_count;
class {...} attack_skills[8];
class {...} bless_skills[8];
class {...} curse_skills[8];
} skills;
int path_id;
int path_type;
char patrol_mode;
char speed_flag;
char no_auto_fight;
}
 
type = class ai_policy::__SKILLS_T {
public:
int count;
int skill[8];
int level[8];
}
 
type = class ai_fix_magic_task : public ai_target_task {
public:
static ClassInfo m_classai_fix_magic_task;
 
protected:
ai_fix_magic_task(void);
public:
ai_fix_magic_task(const XID &);
static ai_fix_magic_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual void Execute();
}
 
type = class ai_fix_melee_task : public ai_target_task {
public:
static ClassInfo m_classai_fix_melee_task;
 
protected:
ai_fix_melee_task(void);
public:
ai_fix_melee_task(const XID &);
static ai_fix_melee_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual void Execute();
}
 
type = class ai_follow_master : public ai_target_task {
public:
static ClassInfo m_classai_follow_master;
 
private:
ai_follow_master(void);
public:
ai_follow_master(const XID &);
static ai_follow_master * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual bool StartTask();
virtual void Execute();
virtual void OnHeartbeat();
virtual void OnAggro();
virtual bool EndTask();
virtual void OnSessionEnd(int, int);
}
 
type = class ai_follow_target : public ai_target_task {
public:
static ClassInfo m_classai_follow_target;
 
private:
ai_follow_target(void);
public:
ai_follow_target(const XID &);
static ai_follow_target * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
~ai_follow_target(int);
virtual bool StartTask();
virtual void Execute();
virtual void OnHeartbeat();
virtual void OnAggro();
virtual bool EndTask();
virtual void OnSessionEnd(int, int);
}
 
type = class ai_magic_melee_task : public ai_target_task {
private:
int _skill;
int _skill_level;
int _state;
float _skill_range;
int _ko_count;
int _skill_type;
public:
static ClassInfo m_classai_magic_melee_task;
 
private:
ai_magic_melee_task(void);
public:
ai_magic_melee_task(const XID &);
static ai_magic_melee_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual bool StartTask();
virtual void Execute();
virtual bool Save(base_wrapper&);
virtual bool Load(base_wrapper&);
}
 
type = class ai_magic_task : public ai_target_task {
private:
int _skill;
int _skill_level;
int _state;
float _skill_range;
int _ko_count;
int _skill_type;
public:
static ClassInfo m_classai_magic_task;
 
protected:
ai_magic_task(void);
public:
ai_magic_task(const XID &);
static ai_magic_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual bool StartTask();
virtual void Execute();
virtual bool Save(base_wrapper&);
virtual bool Load(base_wrapper&);
}
 
type = class ai_melee_task : public ai_target_task {
public:
static ClassInfo m_classai_melee_task;
 
protected:
ai_melee_task(void);
public:
ai_melee_task(const XID &);
static ai_melee_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual void Execute();
}
 
type = class ai_patrol_task : public ai_task {
private:
A3DVECTOR _target;
A3DVECTOR _start;
public:
static ClassInfo m_classai_patrol_task;
 
private:
ai_patrol_task(void);
public:
ai_patrol_task(const A3DVECTOR &);
static ai_patrol_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual void OnAggro();
virtual bool StartTask();
virtual bool EndTask();
virtual void OnSessionEnd(int, int);
virtual void OnHeartbeat();
private:
void Execute();
virtual bool Save(base_wrapper&);
virtual bool Load(base_wrapper&);
}
 
type = class ai_pet_follow_master : public ai_target_task {
public:
static ClassInfo m_classai_pet_follow_master;
 
private:
ai_pet_follow_master(void);
public:
ai_pet_follow_master(const XID &);
static ai_pet_follow_master * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual bool StartTask();
virtual void Execute();
virtual void OnHeartbeat();
virtual void OnAggro();
virtual bool EndTask();
virtual void OnSessionEnd(int, int);
}
 
type = class ai_pet_skill_task : public ai_skill_task_2 {
public:
static ClassInfo m_classai_pet_skill_task;
 
private:
ai_pet_skill_task(void);
public:
ai_pet_skill_task(const XID &, int, int, int);
static ai_pet_skill_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual bool StartTask();
virtual bool UseCoolDown();
virtual bool UseMp();
virtual int GetTaskType();
}
 
type = class ai_play_action_task : public ai_task {
private:
char _action_name[128];
int _play_times;
int _action_last_time;
int _interval_time;
int _timeout;
public:
static ClassInfo m_classai_play_action_task;
 
private:
ai_play_action_task(void);
public:
ai_play_action_task(char *, int, int, int);
static ai_play_action_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual void OnAggro();
virtual bool StartTask();
virtual bool EndTask();
virtual void OnSessionEnd(int, int);
virtual void OnHeartbeat();
virtual bool Save(base_wrapper&);
virtual bool Load(base_wrapper&);
}
 
type = class ai_policy : public substance {
protected:
class ai_object *_self;
int _tick;
int _task_id;
ai_task *_cur_task;
abase::vector<ai_task*, abase::fast_alloc<4, 128> > _task_list;
int _cur_event_hp;
int _quarter_hp;
int _event_list[3];
int _event_level[3];
int _primary_strategy;
int _life;
ai_policy::__SKILLS_T _attack_skills;
ai_policy::__SKILLS_T _bless_skills;
ai_policy::__SKILLS_T _curse_skills;
ai_trigger::policy *_at_policy;
bool _idle_mode;
bool _in_combat_mode;
bool _patrol_mode;
bool _fast_regen;
bool _speed_flag;
char _policy_flag;
bool _no_auto_fight;
patrol_agent *_path_agent;
public:
static ClassInfo m_classai_policy;
 
void AddPosTask<ai_returnhome_task>(A3DVECTOR const&amp;);
void AddTask<ai_rest_task>();
void AddPosTask<ai_patrol_task>(A3DVECTOR const&amp;);
void AddTargetTask<ai_follow_master>(XID const&amp;);
ai_policy(void);
protected:
static bool GetSelfSkill(ai_policy::__SKILLS_T const&amp;, int&amp;, int&amp;);
virtual void HaveRest();
public:
static ai_policy * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
~ai_policy(int);
void SetAITrigger(int);
virtual bool Save(base_wrapper&amp;);
virtual bool Load(base_wrapper&amp;);
virtual void Init(ai_object const&amp;, ai_param const&amp;);
void SetPathAgent(patrol_agent*);
void ChangePath(int, int, char);
int GetPrimarySkill(int&amp;, int&amp;);
void ReInit(ai_object const&amp;);
void SetIdleMode(bool);
void SetSealMode(int);
bool InCombat();
bool IsFastRegen();
void SetFastRegen(bool);
patrol_agent * GetPathAgent();
bool GetSpeedFlag();
int GetTaskID();
void SessionStart(int, int);
void SessionEnd(int, int, int);
void SessionUpdateChaseInfo(int, void const*, unsigned int);
virtual void TaskEnd();
virtual bool KeepMagicCastRange();
void CancelTask();
void StartTask();
bool HasNextTask();
void AddTask(ai_task*);
void AddPrimaryTask(XID const&amp;, int);
void AddEventTask(XID const&amp;, int, int);
bool IsFixStrategy();
void AddPetSkillTask(int, int, XID const&amp;, int);
void ClearTask();
void Clear();
void ClearNextTask();
void CheckNPCData();
protected:
void ClearCurTask();
bool TriggerEvent(int, XID&amp;);
virtual void RollBack();
public:
virtual void OnAggro();
virtual void OnHeartbeat();
virtual void Reborn();
virtual void OnDeath(XID const&amp;);
virtual void OnDamage();
virtual void SetLife(int);
virtual void SetDieWithWho(char);
virtual float GetReturnHomeRange();
void EnableCombat(bool);
void KillTarget(XID const&amp;);
virtual bool ChangeTurretMaster(XID const&amp;);
virtual void UpdateChaseInfo(CChaseInfo const*);
virtual void FollowMasterResult(int);
virtual void ChangeAggroState(int);
virtual void ChangeStayMode(int);
virtual int GetInvincibleTimeout();
virtual void SetPetAutoSkill(int, int, int);
virtual void DeterminePolicy(XID const&amp;);
virtual bool DetermineTarget(XID&amp;);
}
 
type = class ai_range_task : public ai_target_task {
private:
int _state;
int _ko_count;
public:
static ClassInfo m_classai_range_task;
 
protected:
ai_range_task(void);
public:
ai_range_task(const XID &amp;);
static ai_range_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual void Execute();
virtual bool Save(base_wrapper&amp;);
virtual bool Load(base_wrapper&amp;);
}
 
type = class ai_regeneration_task : public ai_task {
private:
int _timer;
public:
static ClassInfo m_classai_regeneration_task;
 
ai_regeneration_task(void);
static ai_regeneration_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual void OnAggro();
virtual bool StartTask();
virtual bool EndTask();
virtual void OnSessionEnd(int, int);
virtual void OnHeartbeat();
virtual bool Save(base_wrapper&amp;);
virtual bool Load(base_wrapper&amp;);
}
 
type = class ai_rest_task : public ai_task {
private:
int _timeout;
public:
static ClassInfo m_classai_rest_task;
 
ai_rest_task(void);
static ai_rest_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual void OnAggro();
virtual bool StartTask();
virtual bool EndTask();
virtual void OnSessionEnd(int, int);
virtual void OnHeartbeat();
private:
void Execute();
virtual bool Save(base_wrapper&amp;);
virtual bool Load(base_wrapper&amp;);
}
 
type = class ai_returnhome_task : public ai_task {
private:
A3DVECTOR _target;
int _timeout;
public:
static ClassInfo m_classai_returnhome_task;
 
private:
ai_returnhome_task(void);
public:
ai_returnhome_task(const A3DVECTOR &amp;);
static ai_returnhome_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual void OnAggro();
virtual bool StartTask();
virtual bool EndTask();
virtual void OnSessionEnd(int, int);
virtual void OnHeartbeat();
private:
virtual bool Save(base_wrapper&amp;);
virtual bool Load(base_wrapper&amp;);
}
 
type = class ai_runaway_task : public ai_target_task {
public:
static ClassInfo m_classai_runaway_task;
 
protected:
ai_runaway_task(void);
public:
ai_runaway_task(const XID &amp;);
static ai_runaway_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual bool StartTask();
virtual bool ChangeTarget(XID const&amp;);
virtual void OnSessionEnd(int, int);
virtual void Execute();
}
 
type = class ai_silent_runaway_task : public ai_runaway_task {
public:
static ClassInfo m_classai_silent_runaway_task;
 
private:
ai_silent_runaway_task(void);
public:
ai_silent_runaway_task(const XID &amp;);
static ai_silent_runaway_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual bool StartTask();
}
 
type = class ai_silent_task : public ai_task {
private:
int _timeout;
public:
static ClassInfo m_classai_silent_task;
 
ai_silent_task(void);
static ai_silent_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual void OnAggro();
virtual bool StartTask();
virtual bool EndTask();
virtual void OnSessionEnd(int, int);
virtual void OnHeartbeat();
virtual bool Save(base_wrapper&amp;);
virtual bool Load(base_wrapper&amp;);
}
 
type = class ai_skill_task : public ai_target_task {
private:
int _skill;
int _level;
public:
static ClassInfo m_classai_skill_task;
 
private:
ai_skill_task(void);
public:
ai_skill_task(const XID &amp;, int, int);
static ai_skill_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual bool StartTask();
virtual bool ChangeTarget(XID const&amp;);
virtual void OnSessionEnd(int, int);
virtual void Execute();
virtual bool Save(base_wrapper&amp;);
virtual bool Load(base_wrapper&amp;);
}
 
type = class ai_skill_task_2 : public ai_target_task {
protected:
int _skill;
int _level;
int _skill_range_type;
float _skill_range;
int _state;
int _trace_count;
public:
static ClassInfo m_classai_skill_task_2;
 
protected:
ai_skill_task_2(void);
public:
ai_skill_task_2(const XID &amp;, int, int);
static ai_skill_task_2 * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
virtual bool StartTask();
virtual bool ChangeTarget(XID const&amp;);
virtual void OnSessionEnd(int, int);
virtual void Execute();
virtual bool UseCoolDown();
virtual bool UseMp();
virtual void OnHeartbeat();
virtual bool Save(base_wrapper&amp;);
virtual bool Load(base_wrapper&amp;);
}
 
type = class ai_target_task : public ai_task {
protected:
XID _target;
 
ai_target_task(void);
public:
ai_target_task(const XID &amp;);
virtual bool StartTask();
virtual bool EndTask();
virtual bool ChangeTarget(XID const&amp;);
virtual void OnSessionEnd(int, int);
virtual void OnHeartbeat();
virtual void Execute();
virtual bool Save(base_wrapper&amp;);
virtual bool Load(base_wrapper&amp;);
}
 
type = class ai_task : public substance {
protected:
class ai_object *_self;
ai_policy *_apolicy;
int _session_id;
CChaseInfo _chase_info;
public:
static ClassInfo m_classai_task;
 
ai_task(void);
protected:
virtual bool Save(base_wrapper&amp;);
virtual bool Load(base_wrapper&amp;);
void ClearChaseInfo();
public:
static ai_task * CreateObject();
static ClassInfo * GetClass();
virtual ClassInfo * GetRunTimeClass();
static size_t GetSubstanceSize();
void Init(ai_object*, ai_policy*);
~ai_task(int);
virtual int GetTaskType();
virtual void OnHeartbeat();
virtual void OnAggro();
virtual bool StartTask();
virtual bool EndTask();
virtual bool CancelTask();
virtual bool ChangeTarget(XID const&amp;);
virtual bool ChangePos(A3DVECTOR const&amp;);
virtual bool DetermineTarget(XID&amp;);
void SetChaseInfo(CChaseInfo const*);
virtual void OnSessionStart(int);
virtual void OnSessionEnd(int, int);
virtual void OnSessionChaseInfo(void const*, unsigned int);
virtual void OnDeath();
}

File aitrigger.h:
ai_trigger::op_active_spawner;
typedef ai_trigger::op_active_spawner;
ai_trigger::op_add_common_data;
typedef ai_trigger::op_add_common_data;
ai_trigger::op_aggro_fade;
typedef ai_trigger::op_aggro_fade;
ai_trigger::op_attack;
typedef ai_trigger::op_attack;
ai_trigger::op_be_taunted;
typedef ai_trigger::op_be_taunted;
ai_trigger::op_change_path;
typedef ai_trigger::op_change_path;
ai_trigger::op_create_timer;
typedef ai_trigger::op_create_timer;
ai_trigger::op_enable_trigger;
typedef ai_trigger::op_enable_trigger;
ai_trigger::op_exec_trigger;
typedef ai_trigger::op_exec_trigger;
ai_trigger::op_fade_target;
typedef ai_trigger::op_fade_target;
ai_trigger::op_flee;
typedef ai_trigger::op_flee;
ai_trigger::op_play_action;
typedef ai_trigger::op_play_action;
ai_trigger::op_remove_timer;
typedef ai_trigger::op_remove_timer;
ai_trigger::op_reset_aggro;
typedef ai_trigger::op_reset_aggro;
ai_trigger::op_say;
typedef ai_trigger::op_say;
ai_trigger::op_set_common_data;
typedef ai_trigger::op_set_common_data;
ai_trigger::op_skill;
typedef ai_trigger::op_skill;
ai_trigger::op_summon_monster;
typedef ai_trigger::op_summon_monster;
ai_trigger::op_swap_aggro;
typedef ai_trigger::op_swap_aggro;
ai_trigger::operation;
typedef ai_trigger::operation;
ai_trigger::policy;
typedef ai_trigger::policy;
ai_trigger::policy::timer;
typedef ai_trigger::policy::timer;
ai_trigger::target;
typedef ai_trigger::target;
ai_trigger::target_aggro_first;
typedef ai_trigger::target_aggro_first;
ai_trigger::target_aggro_second;
typedef ai_trigger::target_aggro_second;
ai_trigger::target_aggro_second_rand;
typedef ai_trigger::target_aggro_second_rand;
ai_trigger::target_class_combo;
typedef ai_trigger::target_class_combo;
ai_trigger::target_least_hp;
typedef ai_trigger::target_least_hp;
ai_trigger::target_most_hp;
typedef ai_trigger::target_most_hp;
ai_trigger::target_most_mp;
typedef ai_trigger::target_most_mp;
ai_trigger::target_self;
typedef ai_trigger::target_self;
ai_trigger::trigger;
typedef ai_trigger::trigger;
File ../aitrigger.h:
ai_trigger::cond_and;
typedef ai_trigger::cond_and;
ai_trigger::cond_binary;
typedef ai_trigger::cond_binary;
ai_trigger::cond_compare_equal;
typedef ai_trigger::cond_compare_equal;
ai_trigger::cond_compare_greater;
typedef ai_trigger::cond_compare_greater;
ai_trigger::cond_compare_less;
typedef ai_trigger::cond_compare_less;
ai_trigger::cond_kill_target;
typedef ai_trigger::cond_kill_target;
ai_trigger::cond_not;
typedef ai_trigger::cond_not;
ai_trigger::cond_on_death;
typedef ai_trigger::cond_on_death;
ai_trigger::cond_or;
typedef ai_trigger::cond_or;
ai_trigger::cond_start_combat;
typedef ai_trigger::cond_start_combat;
ai_trigger::cond_unary;
typedef ai_trigger::cond_unary;
ai_trigger::condition;
typedef ai_trigger::condition;
ai_trigger::expr;
typedef ai_trigger::expr;
ai_trigger::expr::Exception;
typedef ai_trigger::expr::Exception;
ai_trigger::expr_constant;
typedef ai_trigger::expr_constant;
ai_trigger::expr_divide;
typedef ai_trigger::expr_divide;
ai_trigger::expr_minus;
typedef ai_trigger::expr_minus;
ai_trigger::expr_multiply;
typedef ai_trigger::expr_multiply;
ai_trigger::expr_plus;
typedef ai_trigger::expr_plus;
File aitrigger.h:
ai_trigger::cond_hp_less;
typedef ai_trigger::cond_hp_less;
ai_trigger::cond_on_damage;
typedef ai_trigger::cond_on_damage;
ai_trigger::cond_random;
typedef ai_trigger::cond_random;
ai_trigger::cond_time_point;
typedef ai_trigger::cond_time_point;
ai_trigger::cond_timer;
typedef ai_trigger::cond_timer;
ai_trigger::condition;
typedef ai_trigger::condition;
ai_trigger::expr;
typedef ai_trigger::expr;
ai_trigger::expr::Exception;
typedef ai_trigger::expr::Exception;
ai_trigger::expr_common_data;
typedef ai_trigger::expr_common_data;
File ../aitrigger.h:
ai_trigger::op_break;
typedef ai_trigger::op_break;
ai_trigger::operation;
typedef ai_trigger::operation;
ai_trigger::policy;
typedef ai_trigger::policy;
ai_trigger::policy::timer;
typedef ai_trigger::policy::timer;
ai_trigger::target;
typedef ai_trigger::target;
ai_trigger::trigger;
typedef ai_trigger::trigger;

Спойлер

type = class ai_trigger::op_active_spawner : public ai_trigger::operation {
private:
bool _is_active_spawner;
int _ctrl_id;
 
public:
void op_active_spawner(int, bool);
virtual ai_trigger::operation * Clone() const;
virtual bool RequireTarget();
virtual bool DoSomething(ai_trigger::policy*);
}
 
type = class ai_trigger::op_add_common_data : public ai_trigger::operation {
private:
int _key;
int _add_value;
 
public:
void op_add_common_data(int, int);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_add_common_data : public ai_trigger::operation {
private:
int _key;
int _add_value;
 
public:
void op_add_common_data(int, int);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
(gdb) ptype ai_trigger::op_aggro_fade
type = class ai_trigger::op_aggro_fade : public ai_trigger::operation {
public:
void op_aggro_fade(void);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_attack : public ai_trigger::operation {
private:
int _attack_strategy;
 
public:
void op_attack(int);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_attack : public ai_trigger::operation {
private:
int _attack_strategy;
 
public:
void op_attack(int);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
(gdb) ptype ai_trigger::op_be_taunted
type = class ai_trigger::op_be_taunted : public ai_trigger::operation {
public:
void op_be_taunted(void);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_be_taunted : public ai_trigger::operation {
public:
void op_be_taunted(void);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_change_path : public ai_trigger::operation {
private:
int _world_tag;
int _global_path_id;
int _path_type;
char _speed_flag;
 
public:
void op_change_path(int, int, int, char);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_create_timer : public ai_trigger::operation {
private:
int _timerid;
int _interval;
int _count;
 
public:
void op_create_timer(int, int, int);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_enable_trigger : public ai_trigger::operation {
private:
int _trigger_id;
bool _is_enable;
 
public:
void op_enable_trigger(int, bool);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::policy : public abase::ASmallObject {
private:
 
abase::vector<ai_trigger::trigger*, abase::fast_alloc<4, 128> > _trigger_list;
 
abase::vector<ai_trigger::trigger*, abase::fast_alloc<4, 128> > _hb_tri_list;
 
abase::vector<ai_trigger::trigger*, abase::fast_alloc<4, 128> > _tm_tri_list;
 
abase::vector<ai_trigger::trigger*, abase::fast_alloc<4, 128> > _st_bat_list;
 
abase::vector<ai_trigger::trigger*, abase::fast_alloc<4, 128> > _kl_ply_list;
 
abase::vector<ai_trigger::trigger*, abase::fast_alloc<4, 128> > _death_list;
 
abase::vector<ai_trigger::trigger*, abase::fast_alloc<4, 128> > _on_damage_list;
abase::vector<ai_trigger::policy::timer, abase::default_alloc> _timer_list;
int _timer_flag;
class ai_object *_self;
class ai_policy *_aip;
int _id;
int _peace_trigger_count;
 
public:
void AddTrigger(ai_trigger::trigger*);
void policy(int);
void policy(const ai_trigger::policy &amp;);
~policy(int);
void Reset();
void ResetAll();
void SetParent(ai_object*, ai_policy*);
int GetID();
class ai_object * GetAIObject();
class ai_policy * GetAIPolicy();
void EnableTrigger(int, bool);
void CreateTimer(int, int, int);
void RefreshTimer();
void RemoveTimer(int);
void RemoveEmptyTimer();
bool CheckTimer(int);
 
void CheckTriggers(abase::vector<ai_trigger::trigger*, abase::fast_alloc<4, 128> >&amp;);
 
void CheckPeaceTriggers(abase::vector<ai_trigger::trigger*, abase::fast_alloc<4, 128> >&amp;);
 
void CheckTriggersNoBreak(abase::vector<ai_trigger::trigger*, abase::fast_alloc<4, 128> >&amp;);
 
void CheckTriggersNoTest(abase::vector<ai_trigger::trigger*, abase::fast_alloc<4, 128> >&amp;);
void OnHeartbeat();
void OnPeaceHeartbeat();
void OnPeaceHeartbeatInCombat();
void StartCombat();
void KillTarget(XID const&amp;);
void OnDeath();
void OnDamage();
}
 
type = class ai_trigger::op_exec_trigger : public ai_trigger::operation {
private:
ai_trigger::trigger *_trigger;
 
public:
void op_exec_trigger(ai_trigger::trigger *);
void op_exec_trigger(const ai_trigger::op_exec_trigger &amp;);
~op_exec_trigger(int);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_exec_trigger : public ai_trigger::operation {
private:
ai_trigger::trigger *_trigger;
 
public:
void op_exec_trigger(ai_trigger::trigger *);
void op_exec_trigger(const ai_trigger::op_exec_trigger &amp;);
~op_exec_trigger(int);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
(gdb) ptype ai_trigger::op_fade_target
type = class ai_trigger::op_fade_target : public ai_trigger::operation {
public:
void op_fade_target(void);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::operation : public substance {
protected:
ai_trigger::target *_target;
ai_trigger::operation *_next;
 
public:
virtual ai_trigger::operation * Clone() const;
void operation(void);
void operation(const ai_trigger::operation &amp;);
~operation(int);
void SetTarget(ai_trigger::target*);
void SetNext(ai_trigger::operation*);
ai_trigger::operation * GetNext();
virtual bool DoSomething(ai_trigger::policy*);
virtual void Reset();
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_fade_target : public ai_trigger::operation {
public:
void op_fade_target(void);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_flee : public ai_trigger::operation {
public:
void op_flee(void);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_play_action : public ai_trigger::operation {
private:
char _action_name[128];
int _play_times;
int _action_last_time;
int _interval_time;
 
public:
void op_play_action(char *, int, int, int);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_remove_timer : public ai_trigger::operation {
private:
int _timerid;
 
public:
void op_remove_timer(int);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_reset_aggro : public ai_trigger::operation {
public:
void op_reset_aggro(void);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_say : public ai_trigger::operation {
private:
void *_msg;
size_t _size;
 
public:
void op_say(const char *);
void op_say(const void *, unsigned int);
void op_say(const ai_trigger::op_say &amp;);
~op_say(int);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_set_common_data : public ai_trigger::operation {
private:
int _key;
int _set_value;
bool _is_value;
 
public:
void op_set_common_data(int, int, bool);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_skill : public ai_trigger::operation {
private:
int _skill_id;
int _skill_lvl;
 
public:
void op_skill(int, int);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_summon_monster : public ai_trigger::operation {
private:
int _mob_id;
int _count;
int _target_distance;
int _remain_time;
char _die_with_who;
int _path_id;
 
public:
void op_summon_monster(int, int, int, int, char, int);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::op_swap_aggro : public ai_trigger::operation {
private:
size_t _index1;
size_t _index2;
 
public:
void op_swap_aggro(unsigned int, unsigned int);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}
 
type = class ai_trigger::operation : public substance {
protected:
ai_trigger::target *_target;
ai_trigger::operation *_next;
 
public:
virtual ai_trigger::operation * Clone() const;
void operation(void);
void operation(const ai_trigger::operation &amp;);
~operation(int);
void SetTarget(ai_trigger::target*);
void SetNext(ai_trigger::operation*);
ai_trigger::operation * GetNext();
virtual bool DoSomething(ai_trigger::policy*);
virtual void Reset();
virtual bool RequireTarget();
}
 
type = class ai_trigger::policy::timer {
public:
int id;
int timeout;
int period;
int times;
 
void timer(int, int, int, int);
}
 
type = class ai_trigger::policy::timer {
public:
int id;
int timeout;
int period;
int times;
 
void timer(int, int, int, int);
}
(gdb) ptype ai_trigger::target
type = class ai_trigger::target : public substance {
public:
virtual ai_trigger::target * Clone() const;
~target(int);
virtual void GetTarget(ai_trigger::policy*, XID&amp;);
}
 
type = class ai_trigger::target : public substance {
public:
virtual ai_trigger::target * Clone() const;
~target(int);
virtual void GetTarget(ai_trigger::policy*, XID&amp;);
}
(gdb) ptype ai_trigger::target_aggro_first
type = class ai_trigger::target_aggro_first : public ai_trigger::target {
public:
virtual ai_trigger::target * Clone() const;
virtual void GetTarget(ai_trigger::policy*, XID&amp;);
}
 
type = class ai_trigger::target_aggro_second : public ai_trigger::target {
public:
virtual ai_trigger::target * Clone() const;
virtual void GetTarget(ai_trigger::policy*, XID&amp;);
}
 
type = class ai_trigger::target_aggro_second_rand : public ai_trigger::target {
public:
virtual ai_trigger::target * Clone() const;
virtual void GetTarget(ai_trigger::policy*, XID&amp;);
}
 
type = class ai_trigger::target_class_combo : public ai_trigger::target {
private:
int _combo_state;
 
public:
void target_class_combo(int);
virtual ai_trigger::target * Clone() const;
virtual void GetTarget(ai_trigger::policy*, XID&amp;);
}
 
type = class ai_trigger::target_class_combo : public ai_trigger::target {
private:
int _combo_state;
 
public:
void target_class_combo(int);
virtual ai_trigger::target * Clone() const;
virtual void GetTarget(ai_trigger::policy*, XID&amp;);
}
(gdb) ptype ai_trigger::target_least_hp
type = class ai_trigger::target_least_hp : public ai_trigger::target {
public:
virtual ai_trigger::target * Clone() const;
virtual void GetTarget(ai_trigger::policy*, XID&amp;);
}
 
type = class ai_trigger::target_least_hp : public ai_trigger::target {
public:
virtual ai_trigger::target * Clone() const;
virtual void GetTarget(ai_trigger::policy*, XID&amp;);
}
(gdb) ptype ai_trigger::target_most_hp
type = class ai_trigger::target_most_hp : public ai_trigger::target {
public:
virtual ai_trigger::target * Clone() const;
virtual void GetTarget(ai_trigger::policy*, XID&amp;);
}
 
type = class ai_trigger::target_most_mp : public ai_trigger::target {
public:
virtual ai_trigger::target * Clone() const;
virtual void GetTarget(ai_trigger::policy*, XID&amp;);
}
 
type = class ai_trigger::target_self : public ai_trigger::target {
public:
virtual ai_trigger::target * Clone() const;
virtual void GetTarget(ai_trigger::policy*, XID&amp;);
}
 
type = class ai_trigger::trigger : public abase::ASmallObject {
protected:
int _id;
struct condition *_cond;
struct operation *_ops;
bool _enable;
bool _default_enable;
bool _battle_trigger;
 
public:
void trigger(void);
void trigger(const ai_trigger::trigger &amp;);
~trigger(int);
void SetData(int, ai_trigger::condition*);
void AddOp(ai_trigger::operation*);
bool IsEnable();
bool IsBattleTrigger();
void EnableTrigger(bool);
void SetBattleEnable(bool);
void SetDefaultEnable(bool);
int GetTriggerID();
int GetCondType();
bool TestTrigger(ai_trigger::policy*);
void Reset();
}
 
type = class ai_trigger::cond_and : public ai_trigger::cond_binary {
public:
void cond_and(ai_trigger::condition *, ai_trigger::condition *);
virtual ai_trigger::condition * Clone() const;
virtual bool Check(ai_trigger::policy*);
virtual bool IsAutoDisable();
}
 
type = class ai_trigger::cond_binary : public ai_trigger::condition {
protected:
ai_trigger::condition *_left;
ai_trigger::condition *_right;
 
public:
void cond_binary(ai_trigger::condition *, ai_trigger::condition *);
void cond_binary(const ai_trigger::cond_binary &amp;);
~cond_binary(int);
virtual int GetConditionType();
}
 
type = class ai_trigger::cond_compare_equal : public ai_trigger::condition {
private:
ai_trigger::expr *_left;
ai_trigger::expr *_right;
 
public:
void cond_compare_equal(ai_trigger::expr *, ai_trigger::expr *);
void cond_compare_equal(const ai_trigger::cond_compare_equal &amp;);
virtual ai_trigger::condition * Clone() const;
~cond_compare_equal(int);
virtual bool Check(ai_trigger::policy*);
virtual int GetConditionType();
virtual bool IsAutoDisable();
}
 
type = class ai_trigger::cond_compare_greater : public ai_trigger::condition {
private:
ai_trigger::expr *_left;
ai_trigger::expr *_right;
 
public:
void cond_compare_greater(ai_trigger::expr *, ai_trigger::expr *);
void cond_compare_greater(const ai_trigger::cond_compare_greater &amp;);
virtual ai_trigger::condition * Clone() const;
~cond_compare_greater(int);
virtual bool Check(ai_trigger::policy*);
virtual int GetConditionType();
virtual bool IsAutoDisable();
}
 
type = class ai_trigger::cond_compare_less : public ai_trigger::condition {
private:
ai_trigger::expr *_left;
ai_trigger::expr *_right;
 
public:
void cond_compare_less(ai_trigger::expr *, ai_trigger::expr *);
void cond_compare_less(const ai_trigger::cond_compare_less &amp;);
virtual ai_trigger::condition * Clone() const;
~cond_compare_less(int);
virtual bool Check(ai_trigger::policy*);
virtual int GetConditionType();
virtual bool IsAutoDisable();
}
 
type = class ai_trigger::cond_kill_target : public ai_trigger::condition {
public:
virtual ai_trigger::condition * Clone() const;
virtual bool Check(ai_trigger::policy*);
virtual int GetConditionType();
virtual bool IsAutoDisable();
}
 
type = class ai_trigger::cond_not : public ai_trigger::cond_unary {
public:
void cond_not(ai_trigger::condition *);
virtual ai_trigger::condition * Clone() const;
virtual bool Check(ai_trigger::policy*);
virtual bool IsAutoDisable();
}
 
type = class ai_trigger::cond_on_death : public ai_trigger::condition {
public:
virtual ai_trigger::condition * Clone() const;
virtual bool Check(ai_trigger::policy*);
virtual int GetConditionType();
virtual bool IsAutoDisable();
}
 
type = class ai_trigger::cond_or : public ai_trigger::cond_binary {
public:
void cond_or(ai_trigger::condition *, ai_trigger::condition *);
virtual ai_trigger::condition * Clone() const;
virtual bool Check(ai_trigger::policy*);
virtual bool IsAutoDisable();
}
 
type = class ai_trigger::cond_start_combat : public ai_trigger::condition {
public:
virtual ai_trigger::condition * Clone() const;
virtual bool Check(ai_trigger::policy*);
virtual int GetConditionType();
virtual bool IsAutoDisable();
}
 
type = class ai_trigger::cond_unary : public ai_trigger::condition {
protected:
ai_trigger::condition *_cond;
 
public:
void cond_unary(ai_trigger::condition *);
void cond_unary(const ai_trigger::cond_unary &amp;);
~cond_unary(int);
virtual bool Check(ai_trigger::policy*);
virtual int GetConditionType();
}
 
type = class ai_trigger::condition : public substance {
public:
virtual ai_trigger::condition * Clone() const;
~condition(int);
virtual bool Check(ai_trigger::policy*);
virtual int GetConditionType();
virtual bool IsAutoDisable();
virtual void Reset();
}
 
type = class ai_trigger::expr {
public:
void expr(void);
virtual ai_trigger::expr * Clone() const;
~expr(int);
virtual int GetValue(ai_trigger::policy*);
virtual int GetExprType();
}
 
type = class ai_trigger::expr::Exception {
}
 
type = class ai_trigger::expr_constant : public ai_trigger::expr {
private:
int _value;
 
public:
void expr_constant(int);
void expr_constant(const ai_trigger::expr_constant &amp;);
virtual ai_trigger::expr * Clone() const;
virtual int GetValue(ai_trigger::policy*);
virtual int GetExprType();
}
 
type = class ai_trigger::expr_divide : public ai_trigger::expr {
private:
ai_trigger::expr *_left;
ai_trigger::expr *_right;
 
public:
void expr_divide(ai_trigger::expr *, ai_trigger::expr *);
void expr_divide(const ai_trigger::expr_divide &amp;);
virtual ai_trigger::expr * Clone() const;
~expr_divide(int);
virtual int GetValue(ai_trigger::policy*);
virtual int GetExprType();
}
 
type = class ai_trigger::expr_minus : public ai_trigger::expr {
private:
ai_trigger::expr *_left;
ai_trigger::expr *_right;
 
public:
void expr_minus(ai_trigger::expr *, ai_trigger::expr *);
void expr_minus(const ai_trigger::expr_minus &amp;);
virtual ai_trigger::expr * Clone() const;
~expr_minus(int);
virtual int GetValue(ai_trigger::policy*);
virtual int GetExprType();
}
 
type = class ai_trigger::expr_multiply : public ai_trigger::expr {
private:
ai_trigger::expr *_left;
ai_trigger::expr *_right;
 
public:
void expr_multiply(ai_trigger::expr *, ai_trigger::expr *);
void expr_multiply(const ai_trigger::expr_multiply &amp;);
virtual ai_trigger::expr * Clone() const;
~expr_multiply(int);
virtual int GetValue(ai_trigger::policy*);
virtual int GetExprType();
}
 
type = class ai_trigger::expr_plus : public ai_trigger::expr {
private:
ai_trigger::expr *_left;
ai_trigger::expr *_right;
 
public:
void expr_plus(ai_trigger::expr *, ai_trigger::expr *);
void expr_plus(const ai_trigger::expr_plus &amp;);
virtual ai_trigger::expr * Clone() const;
~expr_plus(int);
virtual int GetValue(ai_trigger::policy*);
virtual int GetExprType();
}
 
type = class ai_trigger::cond_hp_less : public ai_trigger::condition {
private:
float _ratio;
 
public:
void cond_hp_less(float);
virtual ai_trigger::condition * Clone() const;
virtual bool Check(ai_trigger::policy*);
virtual int GetConditionType();
virtual bool IsAutoDisable();
}
 
type = class ai_trigger::cond_on_damage : public ai_trigger::condition {
private:
int _min_damage;
int _max_damage;
 
public:
void cond_on_damage(int, int);
virtual ai_trigger::condition * Clone() const;
virtual bool Check(ai_trigger::policy*);
virtual int GetConditionType();
virtual bool IsAutoDisable();
}
 
type = class ai_trigger::cond_random : public ai_trigger::condition {
private:
float _rate;
 
public:
void cond_random(float);
virtual ai_trigger::condition * Clone() const;
virtual bool Check(ai_trigger::policy*);
virtual int GetConditionType();
virtual bool IsAutoDisable();
}
 
type = class ai_trigger::cond_time_point : public ai_trigger::condition {
private:
int _hour;
int _minute;
 
public:
void cond_time_point(int, int);
virtual ai_trigger::condition * Clone() const;
virtual bool Check(ai_trigger::policy*);
virtual int GetConditionType();
virtual bool IsAutoDisable();
}
 
type = class ai_trigger::cond_timer : public ai_trigger::condition {
private:
int _timer_id;
 
public:
void cond_timer(int);
virtual ai_trigger::condition * Clone() const;
virtual bool Check(ai_trigger::policy*);
virtual int GetConditionType();
virtual bool IsAutoDisable();
}
 
type = class ai_trigger::condition : public substance {
public:
virtual ai_trigger::condition * Clone() const;
~condition(int);
virtual bool Check(ai_trigger::policy*);
virtual int GetConditionType();
virtual bool IsAutoDisable();
virtual void Reset();
}
 
type = class ai_trigger::expr_common_data : public ai_trigger::expr {
private:
int _key;
 
public:
void expr_common_data(int);
void expr_common_data(const ai_trigger::expr_common_data &amp;);
virtual ai_trigger::expr * Clone() const;
virtual int GetValue(ai_trigger::policy*);
virtual int GetExprType();
}
 
type = class ai_trigger::op_break : public ai_trigger::operation {
public:
void op_break(void);
virtual ai_trigger::operation * Clone() const;
virtual bool DoSomething(ai_trigger::policy*);
virtual bool RequireTarget();
}