From 90e7e0064dc52d902ac7b33bbcc7897ad4e7e9e8 Mon Sep 17 00:00:00 2001 From: Relintai Date: Thu, 31 Oct 2019 01:35:29 +0100 Subject: [PATCH] Work on AI. --- SCsub | 3 ++ ai/ai_fsm_action.cpp | 56 ++++++++++++++++++++++++ ai/ai_fsm_action.h | 34 +++++++++++++++ ai/ai_spec_action.cpp | 45 +++++++++++++++++++ ai/ai_spec_action.h | 33 ++++++++++++++ entities/data/entity_class_data.cpp | 12 +++--- entities/data/entity_class_data.h | 8 ++-- entities/data/entity_data.cpp | 23 ++++++++++ entities/data/entity_data.h | 30 ++++++------- entities/entity.cpp | 44 +++++++++++++++---- entities/entity.h | 32 +++++++++----- entity_enums.cpp | 3 +- entity_enums.h | 18 +++++--- formations/ai_formation.cpp | 67 +++++++++++++++++++++++++++++ formations/ai_formation.h | 31 +++++++++++++ register_types.cpp | 8 ++++ 16 files changed, 393 insertions(+), 54 deletions(-) create mode 100644 ai/ai_fsm_action.cpp create mode 100644 ai/ai_fsm_action.h create mode 100644 ai/ai_spec_action.cpp create mode 100644 ai/ai_spec_action.h create mode 100644 formations/ai_formation.cpp create mode 100644 formations/ai_formation.h diff --git a/SCsub b/SCsub index f176cb9..1bb0705 100644 --- a/SCsub +++ b/SCsub @@ -111,7 +111,10 @@ module_env.add_source_files(env.modules_sources,"ai/ai_action.cpp") module_env.add_source_files(env.modules_sources,"ai/ai_spell_action.cpp") module_env.add_source_files(env.modules_sources,"ai/ai_action_container.cpp") module_env.add_source_files(env.modules_sources,"ai/ai_spell_action_container.cpp") +module_env.add_source_files(env.modules_sources,"ai/ai_fsm_action.cpp") +module_env.add_source_files(env.modules_sources,"ai/ai_spec_action.cpp") +module_env.add_source_files(env.modules_sources,"formations/ai_formation.cpp") env.add_source_files(env.modules_sources,"profile_manager/input/input_profile_modifier.cpp") env.add_source_files(env.modules_sources,"profile_manager/input/input_profile_modifier_entry.cpp") diff --git a/ai/ai_fsm_action.cpp b/ai/ai_fsm_action.cpp new file mode 100644 index 0000000..fb94bfb --- /dev/null +++ b/ai/ai_fsm_action.cpp @@ -0,0 +1,56 @@ +#include "ai_fsm_action.h" + +EntityEnums::AIStates AIFSMAction::get_state() { + return _state; +} +void AIFSMAction::set_state(EntityEnums::AIStates state) { + _state = state; +} + +EntityEnums::AIStates AIFSMAction::get_force_state() { + return _force_state; +} +void AIFSMAction::set_force_state(EntityEnums::AIStates state) { + _force_state = state; +} + +Ref AIFSMAction::get_action(const EntityEnums::AIStates index) { + return _states[index]; +} +void AIFSMAction::set_action(const EntityEnums::AIStates index, Ref action) { + _states[index] = action; +} + +AIFSMAction::AIFSMAction() { + _state = EntityEnums::AI_STATE_OFF; + _force_state = EntityEnums::AI_STATE_OFF; +} + +AIFSMAction::~AIFSMAction() { + for (int i = 0; i < EntityEnums::AI_STATE_MAX; ++i) { + _states[i].unref(); + } +} + +void AIFSMAction::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_state"), &AIFSMAction::get_state); + ClassDB::bind_method(D_METHOD("set_state", "state"), &AIFSMAction::set_state); + ADD_PROPERTY(PropertyInfo(Variant::INT, "state", PROPERTY_HINT_ENUM, "SpellCastInfo"), "set_state", "get_state"); + + ClassDB::bind_method(D_METHOD("get_force_state"), &AIFSMAction::get_force_state); + ClassDB::bind_method(D_METHOD("set_force_state", "state"), &AIFSMAction::set_force_state); + ADD_PROPERTY(PropertyInfo(Variant::INT, "force_state", PROPERTY_HINT_ENUM, "SpellCastInfo"), "set_force_state", "get_force_state"); + + ClassDB::bind_method(D_METHOD("get_action", "index"), &AIFSMAction::get_action); + ClassDB::bind_method(D_METHOD("set_action", "index", "action"), &AIFSMAction::set_action); + + ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "action_off", PROPERTY_HINT_RESOURCE_TYPE, "AIAction"), "set_action", "get_action", EntityEnums::AI_STATE_OFF); + ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "action_rest", PROPERTY_HINT_RESOURCE_TYPE, "AIAction"), "set_action", "get_action", EntityEnums::AI_STATE_REST); + ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "action_patrol", PROPERTY_HINT_RESOURCE_TYPE, "AIAction"), "set_action", "get_action", EntityEnums::AI_STATE_PATROL); + ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "action_follow_path", PROPERTY_HINT_RESOURCE_TYPE, "AIAction"), "set_action", "get_action", EntityEnums::AI_STATE_FOLLOW_PATH); + ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "action_regenerate", PROPERTY_HINT_RESOURCE_TYPE, "AIAction"), "set_action", "get_action", EntityEnums::AI_STATE_REGENERATE); + ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "action_attack", PROPERTY_HINT_RESOURCE_TYPE, "AIAction"), "set_action", "get_action", EntityEnums::AI_STATE_ATTACK); + ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "action_pet_follow", PROPERTY_HINT_RESOURCE_TYPE, "AIAction"), "set_action", "get_action", EntityEnums::AI_STATE_PET_FOLLOW); + ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "action_pet_stop", PROPERTY_HINT_RESOURCE_TYPE, "AIAction"), "set_action", "get_action", EntityEnums::AI_STATE_PET_STOP); + ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "action_pet_attack", PROPERTY_HINT_RESOURCE_TYPE, "AIAction"), "set_action", "get_action", EntityEnums::AI_STATE_PET_ATTACK); +} diff --git a/ai/ai_fsm_action.h b/ai/ai_fsm_action.h new file mode 100644 index 0000000..68c8c4c --- /dev/null +++ b/ai/ai_fsm_action.h @@ -0,0 +1,34 @@ +#ifndef AI_FSM_ACTION_H +#define AI_FSM_ACTION_H + +#include "ai_action.h" + +#include "../entity_enums.h" + +class AIFSMAction : public AIAction { + GDCLASS(AIFSMAction, AIAction); + +public: + EntityEnums::AIStates get_state(); + void set_state(EntityEnums::AIStates state); + + EntityEnums::AIStates get_force_state(); + void set_force_state(EntityEnums::AIStates state); + + Ref get_action(const EntityEnums::AIStates index); + void set_action(const EntityEnums::AIStates index, Ref action); + + AIFSMAction(); + ~AIFSMAction(); + +protected: + static void _bind_methods(); + +private: + EntityEnums::AIStates _state; + EntityEnums::AIStates _force_state; + + Ref _states[EntityEnums::AI_STATE_MAX]; +}; + +#endif diff --git a/ai/ai_spec_action.cpp b/ai/ai_spec_action.cpp new file mode 100644 index 0000000..4884fb7 --- /dev/null +++ b/ai/ai_spec_action.cpp @@ -0,0 +1,45 @@ +#include "ai_spec_action.h" + +Vector AISpecAction::get_spec_distribution() { + return _spec_distribution; +} +void AISpecAction::set_spec_distribution(Vector data) { + _spec_distribution = data; +} + +int AISpecAction::get_variance() { + return _variance; +} +void AISpecAction::set_variance(int value) { + _variance = value; +} + +Ref AISpecAction::get_action() { + return _action; +} +void AISpecAction::set_action(Ref action) { + _action = action; +} + +AISpecAction::AISpecAction() { + _variance = 0; +} + +AISpecAction::~AISpecAction() { + _spec_distribution.clear(); + _action.unref(); +} + +void AISpecAction::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_spec_distribution"), &AISpecAction::get_spec_distribution); + ClassDB::bind_method(D_METHOD("set_spec_distribution", "value"), &AISpecAction::set_spec_distribution); + ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "spec_distribution"), "set_spec_distribution", "get_spec_distribution"); + + ClassDB::bind_method(D_METHOD("get_variance"), &AISpecAction::get_variance); + ClassDB::bind_method(D_METHOD("set_variance", "value"), &AISpecAction::set_variance); + ADD_PROPERTY(PropertyInfo(Variant::INT, "variance"), "set_variance", "get_variance"); + + ClassDB::bind_method(D_METHOD("get_action"), &AISpecAction::get_action); + ClassDB::bind_method(D_METHOD("set_action", "value"), &AISpecAction::set_action); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "action", PROPERTY_HINT_RESOURCE_TYPE, "AIAction"), "set_action", "get_action"); +} diff --git a/ai/ai_spec_action.h b/ai/ai_spec_action.h new file mode 100644 index 0000000..fa92cf8 --- /dev/null +++ b/ai/ai_spec_action.h @@ -0,0 +1,33 @@ +#ifndef AI_SPEC_ACTION_H +#define AI_SPEC_ACTION_H + +#include "ai_action.h" + +#include "core/vector.h" + +class AISpecAction : public AIAction { + GDCLASS(AISpecAction, AIAction); + +public: + Vector get_spec_distribution(); + void set_spec_distribution(Vector data); + + int get_variance(); + void set_variance(int value); + + Ref get_action(); + void set_action(Ref action); + + AISpecAction(); + ~AISpecAction(); + +protected: + static void _bind_methods(); + +private: + Vector _spec_distribution; + int _variance; + Ref _action; +}; + +#endif diff --git a/entities/data/entity_class_data.cpp b/entities/data/entity_class_data.cpp index c1d8c35..715e20b 100644 --- a/entities/data/entity_class_data.cpp +++ b/entities/data/entity_class_data.cpp @@ -1,6 +1,6 @@ #include "entity_class_data.h" -#include "../../ai/ai_action.h" +#include "../../ai/ai_spec_action.h" #include "../../data/aura.h" #include "../../data/spell.h" #include "../../data/item_instance.h" @@ -269,16 +269,16 @@ void EntityClassData::set_num_ai_actions(int value) { _ai_actions.resize(value); } -Ref EntityClassData::get_ai_action(int index) { +Ref EntityClassData::get_ai_action(int index) { if (_ai_actions.size() == 0 && _inherits.is_valid()) { return _inherits->get_ai_action(index); } - ERR_FAIL_INDEX_V(index, _ai_actions.size(), Ref()); + ERR_FAIL_INDEX_V(index, _ai_actions.size(), Ref()); return _ai_actions[index]; } -void EntityClassData::set_ai_action(int index, Ref ai_action) { +void EntityClassData::set_ai_action(int index, Ref ai_action) { ERR_FAIL_INDEX(index, _ai_actions.size()); _ai_actions.set(index, ai_action); @@ -294,7 +294,7 @@ Vector EntityClassData::get_ai_actions() { void EntityClassData::set_ai_actions(const Vector &ai_actions) { _ai_actions.clear(); for (int i = 0; i < ai_actions.size(); i++) { - Ref ai_action = Ref(ai_actions[i]); + Ref ai_action = Ref(ai_actions[i]); _ai_actions.push_back(ai_action); } @@ -1135,5 +1135,5 @@ void EntityClassData::_bind_methods() { ClassDB::bind_method(D_METHOD("get_ai_actions"), &EntityClassData::get_ai_actions); ClassDB::bind_method(D_METHOD("set_ai_actions", "auras"), &EntityClassData::set_ai_actions); - ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "ai_actions", PROPERTY_HINT_NONE, "17/17:AIAction", PROPERTY_USAGE_DEFAULT, "AIAction"), "set_ai_actions", "get_ai_actions"); + ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "ai_actions", PROPERTY_HINT_NONE, "17/17:AISpecAction", PROPERTY_USAGE_DEFAULT, "AISpecAction"), "set_ai_actions", "get_ai_actions"); } diff --git a/entities/data/entity_class_data.h b/entities/data/entity_class_data.h index 147b647..f979357 100644 --- a/entities/data/entity_class_data.h +++ b/entities/data/entity_class_data.h @@ -24,7 +24,7 @@ class ItemInstance; class CharacterSpec; class Entity; class SpellCastInfo; -class AIAction; +class AISpecAction; class EntityClassData : public Resource { GDCLASS(EntityClassData, Resource); @@ -101,8 +101,8 @@ public: int get_num_ai_actions(); void set_num_ai_actions(int value); - Ref get_ai_action(int index); - void set_ai_action(int index, Ref aura); + Ref get_ai_action(int index); + void set_ai_action(int index, Ref aura); Vector get_ai_actions(); void set_ai_actions(const Vector &ai_actions); @@ -246,7 +246,7 @@ private: Vector > _start_spells; Vector > _specs; Vector > _auras; - Vector > _ai_actions; + Vector > _ai_actions; }; #endif diff --git a/entities/data/entity_data.cpp b/entities/data/entity_data.cpp index c7a738f..bb03f19 100644 --- a/entities/data/entity_data.cpp +++ b/entities/data/entity_data.cpp @@ -108,6 +108,20 @@ void EntityData::set_equipment_data(Ref data) { _equipment_data = data; } +Ref EntityData::get_fsm() const { + return _fsm; +} +void EntityData::set_fsm(const Ref fsm) { + _fsm = fsm; +} + +Ref EntityData::get_formation() const { + return _formation; +} +void EntityData::set_formation(const Ref data) { + _formation = data; +} + Ref EntityData::get_loot_db() const { return _lootdb; } @@ -1198,6 +1212,15 @@ void EntityData::_bind_methods() { ClassDB::bind_method(D_METHOD("set_equipment_data", "value"), &EntityData::set_equipment_data); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "equipment_data", PROPERTY_HINT_RESOURCE_TYPE, "EquipmentData"), "set_equipment_data", "get_equipment_data"); + //AI + ClassDB::bind_method(D_METHOD("get_fsm"), &EntityData::get_fsm); + ClassDB::bind_method(D_METHOD("set_fsm", "value"), &EntityData::set_fsm); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "fsm", PROPERTY_HINT_RESOURCE_TYPE, "AIFSMAction"), "set_fsm", "get_fsm"); + + ClassDB::bind_method(D_METHOD("get_formation"), &EntityData::get_formation); + ClassDB::bind_method(D_METHOD("set_formation", "value"), &EntityData::set_formation); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "formation", PROPERTY_HINT_RESOURCE_TYPE, "AIFormation"), "set_formation", "get_formation"); + // Loot DB ClassDB::bind_method(D_METHOD("get_loot_db"), &EntityData::get_loot_db); ClassDB::bind_method(D_METHOD("set_loot_db", "value"), &EntityData::set_loot_db); diff --git a/entities/data/entity_data.h b/entities/data/entity_data.h index 2f7938d..d79f6f4 100644 --- a/entities/data/entity_data.h +++ b/entities/data/entity_data.h @@ -25,6 +25,9 @@ #include "../../skeleton/entity_species_data.h" +#include "../../ai/ai_fsm_action.h" +#include "../../formations/ai_formation.h" + class Aura; class Spell; class Entity; @@ -81,6 +84,12 @@ public: Ref get_equipment_data(); void set_equipment_data(Ref data); + Ref get_fsm() const; + void set_fsm(const Ref fsm); + + Ref get_formation() const; + void set_formation(const Ref data); + Ref get_loot_db() const; void set_loot_db(const Ref data); @@ -99,19 +108,6 @@ public: Vector get_craft_recipes(); void set_craft_recipes(const Vector &recipe); - /* - Vector get_mob_party_ids(); - void set_mob_party_ids(Vector ids); - - Vector get_mob_dislike_ids(); - void set_mob_dislike_ids(Vector ids); - */ - //MobSpellData *getMobSpellData(); - //void setMobSpellData(MobSpellData *value); - - //int get_inspector_max_spells(); - //void set_inspector_max_spells(int value); - String generate_name(); //Setup @@ -261,15 +257,13 @@ private: Ref _entity_species_data; Ref _equipment_data; + Ref _fsm; + Ref _formation; + Ref _lootdb; Ref _vendor_item_data; Ref _item_container_data; Vector > _craft_recipes; - - //Vector _mob_party_ids; - //Vector _mob_dislike_ids; - - //MobSpellData *_mob_spell_data; }; #endif diff --git a/entities/entity.cpp b/entities/entity.cpp index c71d84c..5db596f 100644 --- a/entities/entity.cpp +++ b/entities/entity.cpp @@ -339,6 +339,23 @@ void Entity::_setup() { set_process(_s_entity_data.is_valid()); } +// AI + +int Entity::get_formation_index() { + return _formation_index; +} +void Entity::set_formation_index(int value) { + _formation_index = value; +} + +Ref Entity::get_ai() { + return _ai; +} +void Entity::set_ai(Ref value) { + _ai = value; +} + + //// Serialization //// bool Entity::is_deserialized() { @@ -804,11 +821,11 @@ void Entity::initialize(Ref info) { ////// Stat System ////// bool Entity::gets_is_dead() { - return sIsDead; + return _s_is_dead; } bool Entity::getc_is_dead() { - return sIsDead; + return _c_is_dead; } bool Entity::getc_has_global_cooldown() { @@ -4343,12 +4360,12 @@ Entity::Entity() { _s_state = PlayerStates::STATE_NORMAL; _c_state = PlayerStates::STATE_NORMAL; - sIsDead = false; - cIsDead = false; - _s_gcd = 0; _c_gcd = 0; + _s_is_dead = 0; + _c_is_dead = 0; + _s_interaction_type = EntityEnums::ENITIY_INTERACTION_TYPE_NORMAL; _c_interaction_type = EntityEnums::ENITIY_INTERACTION_TYPE_NORMAL; @@ -4359,9 +4376,6 @@ Entity::Entity() { _s_state = 0; _c_state = 0; - sRezTimer = 0; - cRezTimer = 0; - _s_active_category_cooldowns = 0; _c_active_category_cooldowns = 0; @@ -4393,6 +4407,8 @@ Entity::Entity() { _stats[i] = s; } + _formation_index = 0; + /* get_stat_enum(Stat::STAT_ID_HEALTH)->set_base(10000); get_stat_enum(Stat::STAT_ID_MANA)->set_base(100); @@ -4625,6 +4641,8 @@ Entity::~Entity() { _s_sees.clear(); _s_seen_by.clear(); + + _ai.unref(); } void Entity::_notification(int p_what) { @@ -5441,6 +5459,16 @@ void Entity::_bind_methods() { ClassDB::bind_method(D_METHOD("get_action_bar_profile"), &Entity::get_action_bar_profile); + // AI + + ClassDB::bind_method(D_METHOD("get_formation_index"), &Entity::get_formation_index); + ClassDB::bind_method(D_METHOD("set_formation_index", "value"), &Entity::set_formation_index); + ADD_PROPERTY(PropertyInfo(Variant::INT, "formation_index"), "set_formation_index", "get_formation_index"); + + ClassDB::bind_method(D_METHOD("get_ai"), &Entity::get_ai); + ClassDB::bind_method(D_METHOD("set_ai", "value"), &Entity::set_ai); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "ai", PROPERTY_HINT_RESOURCE_TYPE, "AIFSMAction"), "set_ai", "get_ai"); + //Serialization BIND_VMETHOD(MethodInfo("_from_dict", PropertyInfo(Variant::DICTIONARY, "dict"))); BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::DICTIONARY, "dict"), "_to_dict")); diff --git a/entities/entity.h b/entities/entity.h index 578bab4..712cb04 100644 --- a/entities/entity.h +++ b/entities/entity.h @@ -36,6 +36,8 @@ #include "../profile_manager/actionbar/action_bar_profile.h" +#include "../ai/ai_fsm_action.h" + class EntityData; class AuraData; class Spell; @@ -725,6 +727,15 @@ public: void setup(); virtual void _setup(); + //// AI //// + + int get_formation_index(); + void set_formation_index(int value); + + Ref get_ai(); + void set_ai(Ref value); + + //// Serialization //// bool is_deserialized(); @@ -735,7 +746,7 @@ public: virtual Dictionary _to_dict(); virtual void _from_dict(const Dictionary &dict); - //Networking + // Networking Entity *gets_sees(int index); void removes_sees_index(int index); void removes_sees(Entity *entity); @@ -808,6 +819,9 @@ private: EntityEnums::EntityInteractionType _s_interaction_type; EntityEnums::EntityInteractionType _c_interaction_type; + int _s_is_dead; + int _c_is_dead; + //// Stats //// Ref _stats[Stat::STAT_ID_TOTAL_STATS]; @@ -822,16 +836,6 @@ private: Vector > _s_resources; Vector > _c_resources; - //old - bool sIsDead; - bool cIsDead; - bool localClient; - - bool s; - bool c; - float sRezTimer; - float cRezTimer; - //// GCD //// float _s_gcd; @@ -932,7 +936,13 @@ private: Ref _s_target_bag; Ref _c_target_bag; + //AI + + int _formation_index; + Ref _ai; + //Networking + Vector _s_sees; Vector _s_seen_by; }; diff --git a/entity_enums.cpp b/entity_enums.cpp index f72e427..e0b9635 100644 --- a/entity_enums.cpp +++ b/entity_enums.cpp @@ -7,7 +7,7 @@ const String EntityEnums::BINDING_STRING_ENTITY_CONTOLLER = "None,Player,AI,Mob" const String EntityEnums::BINDING_STRING_ENTITY_FLAGS = "Untargetable,Hidden,Interactable,Hostile"; const String EntityEnums::BINDING_STRING_ENTITY_STATE_TYPES = "None,Stun,Root,Frozen,Silenced,Disoriented,Feared,Burning,Cold,Cursed,Pacified"; const String EntityEnums::BINDING_STRING_CHARCATER_SKELETON_POINTS = "Root,Pelvis,Spine,Spine 1,Spine 2,Neck,Head,Left Clavicle,Left upper Arm,Left Forearm,Left Hand,Left Thumb Base,Left Thumb End,Left Fingers Base,Left Fingers End,Right Clavicle,Right upper Arm,Right Forearm,Right Hand,Right Thumb Base,Right Thumb End,Right Fingers Base,Right Fingers End,Left Thigh,Left Calf,Left Foot,Right Thigh,Right Calf,Right Foot"; -const String EntityEnums::BINDING_STRING_AI_STATES = "Off,Rest,Patrol,Follow Path,Regenerate,Attack"; +const String EntityEnums::BINDING_STRING_AI_STATES = "Off,Rest,Patrol,Follow Path,Regenerate,Attack,Pet Follow,Pet Stop,Pet Attack"; const String EntityEnums::BINDING_STRING_ENTITY_IMMUNITY_FLAGS = "Stun,Root,Freeze,Silence,Disorient,Fear,Burning,Cold,Pacify,Magic,Poison,Physical,Curse,Bleed,Melee,Holy,Shadow,Nature,Fire,Frost,Lightning,Chaos,Slow,Crit,AOE,Damage,Fall Damage,Projectile,Debuff,Attacks"; const String EntityEnums::BINDING_STRING_ENTITY_INTERACTION_TYPE = "Normal,Speak,Loot,Use,None"; const String EntityEnums::BINDING_STRING_ENTITY_PLAYSTYLE_TYPE = "Melee,Spell,Hybrid,None"; @@ -121,6 +121,7 @@ void EntityEnums::_bind_methods() { BIND_ENUM_CONSTANT(AI_STATE_FOLLOW_PATH); BIND_ENUM_CONSTANT(AI_STATE_REGENERATE); BIND_ENUM_CONSTANT(AI_STATE_ATTACK); + BIND_ENUM_CONSTANT(AI_STATE_MAX); BIND_ENUM_CONSTANT(ENTITY_IMMUNITY_FLAG_NONE); diff --git a/entity_enums.h b/entity_enums.h index b35e3d0..f41fd28 100644 --- a/entity_enums.h +++ b/entity_enums.h @@ -192,12 +192,18 @@ public: }; enum AIStates { - AI_STATE_OFF, - AI_STATE_REST, - AI_STATE_PATROL, - AI_STATE_FOLLOW_PATH, - AI_STATE_REGENERATE, - AI_STATE_ATTACK, + AI_STATE_OFF = 0, + AI_STATE_REST = 1, + AI_STATE_PATROL = 2, + AI_STATE_FOLLOW_PATH = 3, + AI_STATE_REGENERATE = 4, + AI_STATE_ATTACK = 5, + + AI_STATE_PET_FOLLOW = 6, + AI_STATE_PET_STOP = 7, + AI_STATE_PET_ATTACK = 8, + + AI_STATE_MAX = 9, }; enum EntityInteractionType { diff --git a/formations/ai_formation.cpp b/formations/ai_formation.cpp new file mode 100644 index 0000000..18e1097 --- /dev/null +++ b/formations/ai_formation.cpp @@ -0,0 +1,67 @@ +#include "ai_formation.h" + +#include "../entities/entity.h" + +void AIFormation::set_owner(Entity *entity) { + _owner = entity; + + call("_on_set_owner"); +} + +void AIFormation::set_owner_bind(Node *entity) { + if (!entity) { + return; + } + + Entity *e = cast_to(entity); + + if (!e) { + return; + } + + return set_owner(e); +} + +Entity *AIFormation::get_owner() { + return _owner; +} + +void AIFormation::set_editor_description(const String &p_editor_description) { + set_meta("_editor_description_", p_editor_description); +} +String AIFormation::get_editor_description() const { + if (has_meta("_editor_description_")) { + return get_meta("_editor_description_"); + } else { + return ""; + } +} + +Vector3 AIFormation::get_position(int slot_index) { + ERR_FAIL_COND_V(!ObjectDB::instance_validate(_owner), Vector3()); + + if (has_method("_get_position")) + return call("_get_position", slot_index); + + return Vector3(); +} + +AIFormation::AIFormation() { + _owner = NULL; +} + +void AIFormation::_bind_methods() { + BIND_VMETHOD(MethodInfo("_on_set_owner")); + BIND_VMETHOD(MethodInfo(PropertyInfo(Variant::VECTOR3, "pos"), "_get_position", PropertyInfo(Variant::INT, "slot_index"))); + + ClassDB::bind_method(D_METHOD("get_owner"), &AIFormation::get_owner); + ClassDB::bind_method(D_METHOD("set_owner", "entity"), &AIFormation::set_owner_bind); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "owner", PROPERTY_HINT_RESOURCE_TYPE, "Entity", 0), "set_owner", "get_owner"); + + ClassDB::bind_method(D_METHOD("get_position", "slot_index"), &AIFormation::get_position); + + ClassDB::bind_method(D_METHOD("_set_editor_description", "editor_description"), &AIFormation::set_editor_description); + ClassDB::bind_method(D_METHOD("_get_editor_description"), &AIFormation::get_editor_description); + ADD_PROPERTY(PropertyInfo(Variant::STRING, "editor_description", PROPERTY_HINT_MULTILINE_TEXT, "", PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_INTERNAL), "_set_editor_description", "_get_editor_description"); + +} diff --git a/formations/ai_formation.h b/formations/ai_formation.h new file mode 100644 index 0000000..b7aa8d9 --- /dev/null +++ b/formations/ai_formation.h @@ -0,0 +1,31 @@ +#ifndef AI_FORMATION_H +#define AI_FORMATION_H + +#include "core/resource.h" +#include "scene/main/node.h" + +class Entity; + +class AIFormation : public Resource { + GDCLASS(AIFormation, Resource); + +public: + void set_owner(Entity *entity); + void set_owner_bind(Node *entity); + Entity *get_owner(); + + void set_editor_description(const String &p_editor_description); + String get_editor_description() const; + + Vector3 get_position(int slot_index); + + AIFormation(); + +protected: + static void _bind_methods(); + +private: + Entity *_owner; +}; + +#endif diff --git a/register_types.cpp b/register_types.cpp index 1827d69..4ab11b5 100644 --- a/register_types.cpp +++ b/register_types.cpp @@ -102,6 +102,10 @@ #include "ai/ai_spell_action.h" #include "ai/ai_action_container.h" #include "ai/ai_spell_action_container.h" +#include "ai/ai_fsm_action.h" +#include "ai/ai_spec_action.h" + +#include "formations/ai_formation.h" #include "profile_manager/input/input_profile_modifier.h" #include "profile_manager/input/input_profile_modifier_entry.h" @@ -235,6 +239,10 @@ void register_entity_spell_system_types() { ClassDB::register_class(); ClassDB::register_class(); ClassDB::register_class(); + ClassDB::register_class(); + ClassDB::register_class(); + + ClassDB::register_class(); //meshes ClassDB::register_class();