mirror of
https://github.com/Relintai/pandemonium_engine.git
synced 2024-12-21 11:26:53 +01:00
1318 lines
38 KiB
C++
1318 lines
38 KiB
C++
#ifndef ENTITY_H
|
|
#define ENTITY_H
|
|
|
|
/*************************************************************************/
|
|
/* entity.h */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* PANDEMONIUM ENGINE */
|
|
/* https://github.com/Relintai/pandemonium_engine */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2022-present Péter Magyar. */
|
|
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
|
|
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
|
|
#include "core/containers/vector.h"
|
|
#include "core/object/object.h"
|
|
#include "core/string/ustring.h"
|
|
|
|
#include "core/io/networked_multiplayer_peer.h"
|
|
|
|
#include "scene/main/node.h"
|
|
|
|
#include "../data/items/craft_recipe.h"
|
|
#include "../data/items/item_instance.h"
|
|
#include "../data/spells/spell.h"
|
|
|
|
#include "core/io/json.h"
|
|
#include "core/math/transform.h"
|
|
#include "core/math/transform_2d.h"
|
|
|
|
#include "../data/spells/spell.h"
|
|
#include "./resources/entity_resource.h"
|
|
|
|
#include "../entity_enums.h"
|
|
#include "../utility/entity_create_info.h"
|
|
|
|
#include "../inventory/bag.h"
|
|
#include "./data/entity_data_container.h"
|
|
|
|
#include "../profiles/actionbar/action_bar_profile.h"
|
|
#include "../profiles/input/input_profile.h"
|
|
|
|
#include "./ai/entity_ai.h"
|
|
|
|
#include "../data/auras/aura_group.h"
|
|
|
|
#include "../defines.h"
|
|
|
|
#include "scene/main/spatial.h"
|
|
|
|
class EntityData;
|
|
class AuraData;
|
|
class Spell;
|
|
class SpellDamageInfo;
|
|
class SpellHealInfo;
|
|
class SpellCastInfo;
|
|
class EntityCreateInfo;
|
|
class CharacterSpec;
|
|
class EntitySkill;
|
|
class ClassProfile;
|
|
class Spatial;
|
|
class Node2D;
|
|
class EntityData;
|
|
|
|
enum SpellCastDataSignals {
|
|
CastFailed,
|
|
StartCasting,
|
|
CastFinished,
|
|
SetTarget
|
|
};
|
|
|
|
VARIANT_ENUM_CAST(SpellCastDataSignals);
|
|
|
|
enum PlayerStates {
|
|
STATE_FREEZE,
|
|
STATE_NORMAL
|
|
};
|
|
|
|
VARIANT_ENUM_CAST(PlayerStates);
|
|
|
|
enum PlayerSendFlags {
|
|
SEND_FLAG_NONE,
|
|
SEND_FLAG_INVENTORY,
|
|
SEND_FLAG_SPELL_DATA,
|
|
SEND_FLAG_AURAS,
|
|
};
|
|
|
|
struct EntityStat {
|
|
bool dirty;
|
|
|
|
float base;
|
|
float base_calculated;
|
|
float bonus;
|
|
float percent;
|
|
|
|
float scurrent;
|
|
float ccurrent;
|
|
|
|
EntityStat() {
|
|
dirty = false;
|
|
|
|
base = 0;
|
|
base_calculated = 0;
|
|
bonus = 0;
|
|
percent = 100;
|
|
|
|
scurrent = 0;
|
|
ccurrent = 0;
|
|
}
|
|
};
|
|
|
|
#define ISSERVER() (is_inside_tree() && (!get_tree()->has_network_peer() || (get_tree()->has_network_peer() && get_tree()->is_network_server())))
|
|
#define ISCLIENT() (is_inside_tree() && get_tree()->has_network_peer() && !get_tree()->is_network_server())
|
|
|
|
#define SET_RPC_OFF(p_method_name) rpc_config(p_method_name, MultiplayerAPI::RPC_MODE_DISABLED);
|
|
#define SET_RPC_REMOTE(p_method_name) rpc_config(p_method_name, MultiplayerAPI::RPC_MODE_REMOTE);
|
|
#define SET_RPC_MASTER(p_method_name) rpc_config(p_method_name, MultiplayerAPI::RPC_MODE_MASTER);
|
|
#define SET_RPC_PUPPET(p_method_name) rpc_config(p_method_name, MultiplayerAPI::RPC_MODE_PUPPET);
|
|
#define SET_RPC_REMOTESYNC(p_method_name) rpc_config(p_method_name, MultiplayerAPI::RPC_MODE_REMOTESYNC);
|
|
#define SET_RPC_MASTERSYNC(p_method_name) rpc_config(p_method_name, MultiplayerAPI::RPC_MODE_MASTERSYNC);
|
|
#define SET_RPC_PUPPETSYNC(p_method_name) rpc_config(p_method_name, MultiplayerAPI::RPC_MODE_PUPPETSYNC);
|
|
|
|
// f.e. RPC(method, arg0, arg1, etc)
|
|
#define RPC(func, ...) \
|
|
if (is_network_server()) { \
|
|
rpc(#func, ##__VA_ARGS__); \
|
|
} \
|
|
func(__VA_ARGS__);
|
|
|
|
#define VRPC(func, ...) \
|
|
if (is_network_server()) { \
|
|
vrpc(#func, ##__VA_ARGS__); \
|
|
} \
|
|
func(__VA_ARGS__);
|
|
|
|
#define ORPC(func, ...) \
|
|
if (has_network_peer()) { \
|
|
if (get_tree()->is_network_server()) { \
|
|
if (get_network_master() != 1) { \
|
|
rpc_id(get_network_master(), #func, ##__VA_ARGS__); \
|
|
} else { \
|
|
func(__VA_ARGS__); \
|
|
} \
|
|
} \
|
|
} else { \
|
|
func(__VA_ARGS__); \
|
|
}
|
|
|
|
#define RPCS(func, ...) \
|
|
if (has_network_peer()) { \
|
|
if (get_tree()->is_network_server()) { \
|
|
func(__VA_ARGS__); \
|
|
} else { \
|
|
rpc_id(1, #func, ##__VA_ARGS__); \
|
|
} \
|
|
} else { \
|
|
func(__VA_ARGS__); \
|
|
}
|
|
|
|
//RPC Objects
|
|
|
|
#define RPCOBJ(rpcfunc, rpc_var, normalfunc, normal_var) \
|
|
if (has_network_peer()) { \
|
|
rpc(#rpcfunc, rpc_var); \
|
|
} \
|
|
normalfunc(normal_var);
|
|
|
|
#define VRPCOBJ(rpcfunc, rpc_var, normalfunc, normal_var) \
|
|
if (has_network_peer()) { \
|
|
vrpc(#rpcfunc, rpc_var); \
|
|
} \
|
|
normalfunc(normal_var);
|
|
|
|
#define VRPCOBJ12(rpcfunc, rpc_var, normalfunc, normal_var1, normal_var2) \
|
|
if (is_network_server()) { \
|
|
vrpc(#rpcfunc, rpc_var); \
|
|
} \
|
|
normalfunc(normal_var1, normal_var2);
|
|
|
|
#define VRPCOBJP(rpcfunc, rpc_var1, rpc_var2, normalfunc, normal_var1, normal_var2) \
|
|
if (is_network_server()) { \
|
|
vrpc(#rpcfunc, rpc_var1, rpc_var2); \
|
|
} \
|
|
normalfunc(normal_var1, normal_var2);
|
|
|
|
#define ORPCOBJ(rpcfunc, rpc_var, normalfunc, normal_var) \
|
|
if (has_network_peer()) { \
|
|
if (get_tree()->is_network_server() && get_network_master() != 1) \
|
|
rpc_id(get_network_master(), #rpcfunc, rpc_var); \
|
|
} \
|
|
normalfunc(normal_var);
|
|
|
|
#define RPCSOBJ(rpcfunc, rpc_var, normalfunc, normal_var) \
|
|
if (has_network_peer()) { \
|
|
if (get_tree()->is_network_server()) { \
|
|
normalfunc(normal_var); \
|
|
} else { \
|
|
rpc_id(1, #rpcfunc, rpc_var); \
|
|
} \
|
|
} else { \
|
|
normalfunc(normal_var); \
|
|
}
|
|
|
|
#define ORPCOBJP(rpcfunc, rpc_var1, rpc_var2, normalfunc, normal_var1, normal_var2) \
|
|
if (has_network_peer()) { \
|
|
if (get_tree()->is_network_server() && get_network_master() != 1) \
|
|
rpc_id(get_network_master(), #rpcfunc, rpc_var1, rpc_var2); \
|
|
} \
|
|
normalfunc(normal_var1, normal_var2);
|
|
|
|
class Entity : public Node {
|
|
GDCLASS(Entity, Node);
|
|
|
|
public:
|
|
//// Base ////
|
|
|
|
NodePath body_get_path();
|
|
void body_set_path(NodePath value);
|
|
Node *body_get();
|
|
Spatial *body_get_3d();
|
|
Node2D *body_get_2d();
|
|
void body_set(Node *body);
|
|
|
|
void body_instance(const Ref<EntityData> &data, const int model_index);
|
|
void _body_instance(const Ref<EntityData> &data, const int model_index);
|
|
void body_on_changed();
|
|
|
|
NodePath character_skeleton_path_get();
|
|
void character_skeleton_path_set(NodePath value);
|
|
Node *character_skeleton_get();
|
|
void character_skeleton_set(Node *skeleton);
|
|
|
|
//Transforms
|
|
Transform get_transform_3d(bool only_stored = false) const;
|
|
void set_transform_3d(const Transform &transform, bool only_stored = false);
|
|
|
|
Transform2D get_transform_2d(bool only_stored = false) const;
|
|
void set_transform_2d(const Transform2D &transform, bool only_stored = false);
|
|
|
|
//GUID
|
|
int gets_guid();
|
|
void sets_guid(int value);
|
|
|
|
int getc_guid();
|
|
void setc_guid(int value);
|
|
|
|
//EntityPlayerType
|
|
int gets_entity_player_type();
|
|
void sets_entity_player_type(int value);
|
|
|
|
int getc_entity_player_type();
|
|
void setc_entity_player_type(int value);
|
|
|
|
//EntityType
|
|
int gets_entity_type();
|
|
void sets_entity_type(int value);
|
|
|
|
int getc_entity_type();
|
|
void setc_entity_type(int value);
|
|
|
|
//Relations
|
|
EntityEnums::EntityRelationType gets_relation_to_bind(Node *to);
|
|
EntityEnums::EntityRelationType gets_relation_to(Entity *to);
|
|
|
|
EntityEnums::EntityRelationType _gets_relation_to(Node *to);
|
|
|
|
EntityEnums::EntityRelationType getc_relation_to_bind(Node *to);
|
|
EntityEnums::EntityRelationType getc_relation_to(Entity *to);
|
|
|
|
EntityEnums::EntityRelationType _getc_relation_to(Node *to);
|
|
|
|
//EntityInteractionType
|
|
EntityEnums::EntityInteractionType gets_entity_interaction_type();
|
|
void sets_entity_interaction_type(EntityEnums::EntityInteractionType value);
|
|
|
|
EntityEnums::EntityInteractionType getc_entity_interaction_type();
|
|
void setc_entity_interaction_type(EntityEnums::EntityInteractionType value);
|
|
|
|
int gets_immunity_flags();
|
|
void sets_immunity_flags(int value);
|
|
|
|
int gets_entity_flags();
|
|
void sets_entity_flags(int value);
|
|
|
|
int getc_entity_flags();
|
|
void setc_entity_flags(int value);
|
|
|
|
String gets_entity_name();
|
|
void sets_entity_name(String value);
|
|
|
|
String getc_entity_name();
|
|
void setc_entity_name(String value);
|
|
|
|
int gets_model_index();
|
|
void sets_model_index(int value);
|
|
|
|
int getc_model_index();
|
|
void setc_model_index(int value);
|
|
|
|
int gets_level();
|
|
void sets_level(int value);
|
|
int getc_level();
|
|
void setc_level(int value);
|
|
|
|
int gets_xp();
|
|
void sets_xp(int value);
|
|
int getc_xp();
|
|
void setc_xp(int value);
|
|
|
|
int gets_money();
|
|
void sets_money(int value);
|
|
int getc_money();
|
|
void setc_money(int value);
|
|
|
|
Ref<EntityData> entity_data_gets();
|
|
void entity_data_sets(Ref<EntityData> value);
|
|
|
|
Ref<EntityData> entity_data_getc();
|
|
void entity_data_setc(Ref<EntityData> value);
|
|
|
|
int entity_data_id_gets();
|
|
void entity_data_id_sets(int value);
|
|
|
|
int entity_data_id_getc();
|
|
void entity_data_id_setc(int value);
|
|
|
|
StringName entity_data_path_gets();
|
|
void entity_data_path_sets(const StringName &value);
|
|
|
|
EntityEnums::AIStates ai_state_gets() const;
|
|
void ai_state_sets(EntityEnums::AIStates state);
|
|
|
|
EntityEnums::AIStates ai_state_stored_gets() const;
|
|
void ai_state_stored_sets(EntityEnums::AIStates state);
|
|
|
|
int gets_seed();
|
|
void sets_seed(int value);
|
|
|
|
int getc_seed();
|
|
void setc_seed(int value);
|
|
|
|
//// Stats ////
|
|
|
|
EntityStat stat_get(const int stat_id) const;
|
|
void stat_set(const int stat_id, const EntityStat &entry);
|
|
|
|
bool stat_get_dirty(const int stat_id) const;
|
|
void stat_set_dirty(const int stat_id, const bool value);
|
|
|
|
float stat_get_base(const int stat_id) const;
|
|
void stat_set_base(const int stat_id, const float value);
|
|
void stat_mod_base(const int stat_id, const float value);
|
|
|
|
float stat_get_base_calculated(const int stat_id) const;
|
|
void stat_set_base_calculated(const int stat_id, const float value);
|
|
|
|
float stat_get_bonus(const int stat_id) const;
|
|
void stat_set_bonus(const int stat_id, const float value);
|
|
void stat_mod_bonus(const int stat_id, const float value);
|
|
|
|
float stat_get_percent(const int stat_id) const;
|
|
void stat_set_percent(const int stat_id, const float value);
|
|
void stat_mod_percent(const int stat_id, const float value);
|
|
|
|
void stat_mod(const int stat_id, const float base, const float bonus, const float percent);
|
|
|
|
float stat_gets_current(const int stat_id) const;
|
|
void stat_sets_current(const int stat_id, const float value);
|
|
|
|
float stat_getc_current(const int stat_id) const;
|
|
void stat_setc_current(const int stat_id, const float value);
|
|
|
|
void stat_recalculate(const int stat_id);
|
|
|
|
void notification_sstat_changed(const int statid, const float current);
|
|
void notification_cstat_changed(const int statid, const float current);
|
|
|
|
void stat_ssend(int id, int ccurrent);
|
|
void stat_creceive(int id, int ccurrent);
|
|
|
|
void dies();
|
|
void diec();
|
|
|
|
//// Equip Slots ////
|
|
|
|
bool equip_should_deny(int equip_slot, Ref<ItemInstance> item);
|
|
|
|
void equip_son_success(int equip_slot, Ref<ItemInstance> item, Ref<ItemInstance> old_item, int bag_slot);
|
|
void equip_son_fail(int equip_slot, Ref<ItemInstance> item, Ref<ItemInstance> old_item, int bag_slot);
|
|
|
|
void equip_con_success(int equip_slot, Ref<ItemInstance> item, Ref<ItemInstance> old_item, int bag_slot);
|
|
void equip_con_fail(int equip_slot, Ref<ItemInstance> item, Ref<ItemInstance> old_item, int bag_slot);
|
|
|
|
void equip_crequest(int equip_slot, int bag_slot);
|
|
void equips(int equip_slot, int bag_slot);
|
|
void _equips(int equip_slot, int bag_slot);
|
|
|
|
void equip_csuccess(int equip_slot, int bag_slot);
|
|
void equip_cfail(int equip_slot, int bag_slot);
|
|
|
|
Ref<ItemInstance> equip_gets_slot(int index);
|
|
void equip_sets_slot(int index, Ref<ItemInstance> item);
|
|
|
|
Ref<ItemInstance> equip_getc_slot(int index);
|
|
void equip_setc_slot(int index, Ref<ItemInstance> item);
|
|
|
|
bool equip_can_equip_item(int equip_slot, Ref<ItemInstance> item);
|
|
bool _equip_can_equip_item(int equip_slot, Ref<ItemInstance> item);
|
|
|
|
void equip_applys_item(Ref<ItemInstance> item);
|
|
void equip_deapplys_item(Ref<ItemInstance> item);
|
|
|
|
void _equip_applys_item(Ref<ItemInstance> item);
|
|
void _equip_deapplys_item(Ref<ItemInstance> item);
|
|
|
|
void equip_applyc_item(Ref<ItemInstance> item);
|
|
void equip_deapplyc_item(Ref<ItemInstance> item);
|
|
|
|
void _equip_applyc_item(Ref<ItemInstance> item);
|
|
void _equip_deapplyc_item(Ref<ItemInstance> item);
|
|
|
|
//// Resources ////
|
|
|
|
Ref<EntityResource> resource_gets_index(int index);
|
|
Ref<EntityResource> resource_gets_id(int id);
|
|
void resource_adds(Ref<EntityResource> resource);
|
|
int resource_gets_count();
|
|
void resource_removes(int index);
|
|
void resource_clears();
|
|
|
|
Ref<EntityResource> resource_getc_index(int index);
|
|
Ref<EntityResource> resource_getc_id(int id);
|
|
void resource_addc(int index, Ref<EntityResource> resource);
|
|
int resource_getc_count();
|
|
void resource_removec(int index);
|
|
void resource_clearc();
|
|
|
|
void resource_addc_rpc(int index, String data);
|
|
|
|
void resource_sends_current(int index, int current);
|
|
void resource_sends_curr_max(int index, int current, int max);
|
|
void resource_sends_data(int index, String data);
|
|
|
|
void resource_creceive_current(int index, int current);
|
|
void resource_creceive_curr_max(int index, int current, int max);
|
|
void resource_creceive_data(int index, String data);
|
|
|
|
Ref<EntityResource> gets_health();
|
|
Ref<EntityResource> gets_speed();
|
|
Ref<EntityResource> getc_health();
|
|
Ref<EntityResource> getc_speed();
|
|
|
|
Vector<Variant> sresources_get();
|
|
void sresources_set(const Vector<Variant> &resources);
|
|
|
|
//// Global Cooldown ////
|
|
|
|
bool gcd_hasc() const;
|
|
bool gcd_hass() const;
|
|
|
|
float gcd_getc() const;
|
|
void gcd_setc(const float value);
|
|
|
|
float gcd_gets() const;
|
|
void gcd_sets(const float value);
|
|
|
|
void gcd_starts(const float value);
|
|
void gcd_startc(const float value);
|
|
|
|
//// States ////
|
|
int state_getc();
|
|
void state_setc(int state);
|
|
|
|
int state_gets();
|
|
void state_sets(int state);
|
|
|
|
void state_ref_adds(int state_index);
|
|
void state_ref_removes(int state_index);
|
|
|
|
PoolIntArray states_gets() const;
|
|
void states_sets(const PoolIntArray &data);
|
|
|
|
//// Crafting System ////
|
|
|
|
void craft_crequest(int id);
|
|
void crafts(int id);
|
|
|
|
bool craft_hass_recipe(Ref<CraftRecipe> craft_recipe);
|
|
bool craft_hass_recipe_id(int id);
|
|
void craft_adds_recipe(Ref<CraftRecipe> craft_recipe);
|
|
void craft_adds_recipe_id(int id);
|
|
void craft_removes_recipe(Ref<CraftRecipe> craft_recipe);
|
|
void craft_removes_recipe_id(int id);
|
|
Ref<CraftRecipe> craft_gets_recipe(int index);
|
|
Ref<CraftRecipe> craft_gets_recipe_id(int id);
|
|
int craft_gets_recipe_count();
|
|
|
|
bool craft_hasc_recipe(Ref<CraftRecipe> craft_recipe);
|
|
bool craft_hasc_recipe_id(int id);
|
|
void craft_addc_recipe(Ref<CraftRecipe> craft_recipe);
|
|
void craft_addc_recipe_id(int id);
|
|
void craft_removec_recipe(Ref<CraftRecipe> craft_recipe);
|
|
void craft_removec_recipe_id(int id);
|
|
Ref<CraftRecipe> craft_getc_recipe(int index);
|
|
int craft_getc_recipe_count();
|
|
|
|
Vector<Variant> scraft_recipes_get();
|
|
void scraft_recipes_set(const Vector<Variant> &data);
|
|
|
|
//// SpellSystem ////
|
|
|
|
//EventHandlers
|
|
void notification_saura(int what, Ref<AuraData> data);
|
|
void notification_sheal(int what, Ref<SpellHealInfo> info);
|
|
void notification_scast(int what, Ref<SpellCastInfo> info);
|
|
void notification_sdamage(int what, Ref<SpellDamageInfo> info);
|
|
|
|
void notification_scooldown_added(int id, float value);
|
|
void notification_scooldown_removed(int id, float value);
|
|
|
|
void notification_scategory_cooldown_added(int id, float value);
|
|
void notification_scategory_cooldown_removed(int id, float value);
|
|
|
|
void notification_sentity_resource_added(Ref<EntityResource> resource);
|
|
void notification_sentity_resource_removed(Ref<EntityResource> resource);
|
|
|
|
void notification_sxp_gained(int value);
|
|
void notification_slevel_up(int value);
|
|
|
|
void notification_sdeath();
|
|
|
|
void son_physics_process(float delta);
|
|
|
|
//Clientside EventHandlers
|
|
void notification_caura(int what, Ref<AuraData> data);
|
|
void notification_cheal(int what, Ref<SpellHealInfo> info);
|
|
void notification_ccast(int what, Ref<SpellCastInfo> info);
|
|
void notification_cdamage(int what, Ref<SpellDamageInfo> info);
|
|
|
|
void notification_ccooldown_added(int id, float value);
|
|
void notification_ccooldown_removed(int id, float value);
|
|
|
|
void notification_ccategory_cooldown_added(int id, float value);
|
|
void notification_ccategory_cooldown_removed(int id, float value);
|
|
|
|
void notification_centity_resource_added(Ref<EntityResource> resource);
|
|
void notification_centity_resource_removed(Ref<EntityResource> resource);
|
|
|
|
void notification_cxp_gained(int value);
|
|
void notification_clevel_up(int value);
|
|
|
|
void notification_cdeath();
|
|
|
|
//gcd
|
|
void notification_sgcd_started();
|
|
void notification_sgcd_finished();
|
|
void notification_cgcd_started();
|
|
void notification_cgcd_finished();
|
|
|
|
//Modifiers/Requesters
|
|
void sapply_passives_damage_receive(Ref<SpellDamageInfo> info);
|
|
void sapply_passives_damage_deal(Ref<SpellDamageInfo> info);
|
|
|
|
void sapply_passives_heal_receive(Ref<SpellHealInfo> info);
|
|
void sapply_passives_heal_deal(Ref<SpellHealInfo> info);
|
|
|
|
//Spell operations
|
|
void spell_casts(int spell_id);
|
|
void spell_crequest_cast(int spell_id);
|
|
|
|
void item_uses(int item_id);
|
|
void item_crequest_use(int item_id);
|
|
void _item_uses(int item_id);
|
|
|
|
//Damage Operations
|
|
void stake_damage(Ref<SpellDamageInfo> info);
|
|
void sdeal_damage_to(Ref<SpellDamageInfo> info);
|
|
|
|
//Heal Operations
|
|
void stake_heal(Ref<SpellHealInfo> info);
|
|
void sdeal_heal_to(Ref<SpellHealInfo> info);
|
|
|
|
//Damage, Heal RPCs
|
|
void cdamage_dealt_rpc(String data);
|
|
void cdealt_damage_rpc(String data);
|
|
void cheal_dealt_rpc(String data);
|
|
void cdealt_heal_rpc(String data);
|
|
|
|
//Interactions
|
|
bool cans_interact();
|
|
void sinteract();
|
|
|
|
bool canc_interact();
|
|
void crequest_interact();
|
|
|
|
void ssend_open_window(int window_id);
|
|
void copen_window(int window_id);
|
|
|
|
bool iss_target_in_interact_range();
|
|
bool isc_target_in_interact_range();
|
|
virtual bool _iss_target_in_interact_range();
|
|
virtual bool _isc_target_in_interact_range();
|
|
|
|
//XP Operations
|
|
void xp_adds(int value);
|
|
void xp_addc(int value);
|
|
void levelups(int value);
|
|
void levelupc(int value);
|
|
|
|
//Aura Manipulation
|
|
void aura_adds(Ref<AuraData> aura);
|
|
void aura_removes(Ref<AuraData> aura);
|
|
void aura_removes_exact(Ref<AuraData> aura);
|
|
void aura_removes_expired(Ref<AuraData> aura);
|
|
void aura_removes_dispelled(Ref<AuraData> aura);
|
|
void aura_refresheds(Ref<AuraData> aura);
|
|
|
|
void aura_addc_rpc(String data);
|
|
void aura_removec_rpc(String data);
|
|
void aura_removec_exact_rpc(String data);
|
|
void aura_removec_expired_rpc(String data);
|
|
void aura_removec_dispelled_rpc(String data);
|
|
void aura_refreshedc_rpc(String data);
|
|
|
|
void aura_addc(Ref<AuraData> aura);
|
|
void aura_removec(Ref<AuraData> aura);
|
|
void aura_removec_exact(Ref<AuraData> aura);
|
|
void aura_removec_expired(Ref<AuraData> aura);
|
|
void aura_removec_dispelled(Ref<AuraData> aura);
|
|
void aura_refreshedc(Ref<AuraData> aura);
|
|
|
|
void aura_removess_with_group(Ref<AuraGroup> aura_group);
|
|
|
|
//NOTE: No reason for shas_aura_by, just query it, and check for null.
|
|
int aura_gets_count();
|
|
Ref<AuraData> aura_gets(int index);
|
|
Ref<AuraData> aura_gets_by(Entity *caster, int aura_id);
|
|
Ref<AuraData> aura_gets_by_bind(Node *caster, int aura_id);
|
|
|
|
Ref<AuraData> aura_gets_with_group_by(Entity *caster, Ref<AuraGroup> aura_group);
|
|
Ref<AuraData> aura_gets_with_group_by_bind(Node *caster, Ref<AuraGroup> aura_group);
|
|
|
|
int aura_getc_count();
|
|
Ref<AuraData> aura_getc(int index);
|
|
|
|
Vector<Variant> sauras_get();
|
|
void sauras_set(const Vector<Variant> &data);
|
|
|
|
//Hooks
|
|
void moved();
|
|
|
|
void notification_cmouse_enter();
|
|
void notification_cmouse_exit();
|
|
|
|
void notification_ctargeted();
|
|
void notification_cuntargeted();
|
|
|
|
//Update
|
|
void update_auras(float delta);
|
|
|
|
bool gets_is_dead();
|
|
bool getc_is_dead();
|
|
|
|
//// Casting System ////
|
|
|
|
bool cast_is_castings();
|
|
bool cast_is_castingc();
|
|
|
|
Ref<SpellCastInfo> spell_gets_cast_info();
|
|
void sets_spell_cast_info(Ref<SpellCastInfo> info);
|
|
|
|
Ref<SpellCastInfo> spell_getc_cast_info();
|
|
void setc_spell_cast_info(Ref<SpellCastInfo> info);
|
|
|
|
void cast_starts(Ref<SpellCastInfo> info);
|
|
void cast_fails();
|
|
void cast_delays();
|
|
void cast_finishs();
|
|
void cast_interrupts();
|
|
|
|
void cast_startc_rpc(String data);
|
|
void cast_startc(Ref<SpellCastInfo> info);
|
|
void cast_failc();
|
|
void cast_delayc();
|
|
void cast_finishc();
|
|
void cast_interruptc();
|
|
|
|
void cast_spell_successs(Ref<SpellCastInfo> info);
|
|
|
|
void cast_spell_successc_rpc(String data);
|
|
void cast_spell_successc(Ref<SpellCastInfo> info);
|
|
|
|
//// Cooldowns ////
|
|
|
|
bool cooldown_hass(int spell_id);
|
|
void cooldown_adds(int spell_id, float value);
|
|
void cooldown_removes(int spell_id);
|
|
float cooldown_gets(int spell_id);
|
|
float cooldown_gets_index(int index);
|
|
int cooldown_gets_count();
|
|
|
|
bool cooldown_hasc(int spell_id);
|
|
void cooldown_addc(int spell_id, float value);
|
|
void cooldown_removec(int spell_id);
|
|
float cooldown_getc(int spell_id);
|
|
float cooldown_getc_index(int index);
|
|
int cooldown_getc_count();
|
|
|
|
Vector<Variant> scooldowns_get();
|
|
void scooldowns_set(const Vector<Variant> &data);
|
|
|
|
//Category Cooldowns
|
|
|
|
bool category_cooldown_hass(int category_id);
|
|
void category_cooldown_adds(int category_id, float value);
|
|
void category_cooldown_removes(int category_id);
|
|
float category_cooldown_gets(int category_id);
|
|
float category_cooldown_gets_index(int index);
|
|
int category_cooldown_gets_count();
|
|
|
|
bool category_cooldown_hasc(int category_id);
|
|
void category_cooldown_addc(int category_id, float value);
|
|
void category_cooldown_removec(int spell_id);
|
|
float category_cooldown_getc(int category_id);
|
|
float category_cooldown_getc_index(int index);
|
|
int category_cooldown_getc_count();
|
|
|
|
Vector<Variant> scategory_cooldowns_get();
|
|
void scategory_cooldowns_set(const Vector<Variant> &data);
|
|
|
|
//Known Spells
|
|
|
|
int spell_points_gets_free();
|
|
void spell_points_sets_free(int value);
|
|
|
|
int spell_points_getc_free();
|
|
void spell_points_setc_free(int value);
|
|
|
|
void spell_learn_requestc(int id);
|
|
void spell_learns(int id);
|
|
|
|
bool spell_hass(Ref<Spell> spell);
|
|
bool spell_hass_id(int id);
|
|
void spell_adds(Ref<Spell> spell);
|
|
void spell_adds_id(int id);
|
|
void spell_removes(Ref<Spell> spell);
|
|
Ref<Spell> spell_gets(int index);
|
|
int spell_gets_count();
|
|
|
|
bool spell_hasc(Ref<Spell> spell);
|
|
bool spell_hasc_id(int id);
|
|
void spell_addc(Ref<Spell> spell);
|
|
void spell_removec(Ref<Spell> spell);
|
|
Ref<Spell> spell_getc(int index);
|
|
int spell_getc_count();
|
|
|
|
void spell_addc_rpc(int id);
|
|
void spell_removec_rpc(int id);
|
|
|
|
Vector<Variant> sspells_get();
|
|
void sspells_set(const Vector<Variant> &data);
|
|
|
|
//Skills
|
|
|
|
bool skill_hass_id(int id);
|
|
bool skill_hass(Ref<EntitySkill> skill);
|
|
void skill_adds(Ref<EntitySkill> skill);
|
|
void skill_removes(Ref<EntitySkill> skill);
|
|
Ref<EntitySkill> skill_gets(int skill);
|
|
int skill_gets_count();
|
|
|
|
bool skill_hasc_id(int id);
|
|
bool skill_hasc(Ref<EntitySkill> skill);
|
|
void skill_addc(Ref<EntitySkill> skill);
|
|
void skill_removec(Ref<EntitySkill> skill);
|
|
Ref<EntitySkill> skill_getc(int index);
|
|
int skill_getc_count();
|
|
|
|
void skill_scurrent_changed(Ref<EntitySkill> skill);
|
|
void skill_smax_changed(Ref<EntitySkill> skill);
|
|
|
|
void skill_addc_id(int skill_id, int value, int max_value);
|
|
void skill_removec_id(int skill_id);
|
|
void skill_changec(int skill_id, int value);
|
|
void skill_changec_max(int skill_id, int value);
|
|
|
|
Vector<Variant> sskills_get();
|
|
void sskills_set(const Vector<Variant> &data);
|
|
|
|
//// Target ////
|
|
|
|
void target_crequest_change(NodePath path);
|
|
void target_net_sets(NodePath path);
|
|
void target_net_setc(NodePath path);
|
|
|
|
Entity *target_gets();
|
|
void target_sets(Node *p_target);
|
|
|
|
Entity *target_getc();
|
|
void target_setc(Node *p_target);
|
|
|
|
//// Class Talents ////
|
|
|
|
int class_talent_points_gets_free();
|
|
void class_talent_points_sets_free(int value);
|
|
|
|
int class_talent_points_getc_free();
|
|
void class_talent_points_setc_free(int value);
|
|
|
|
void class_talent_crequest_learn(int spec_index, int class_talent_row, int class_talent_culomn);
|
|
void class_talent_sreceive_learn_request(int spec_index, int class_talent_row, int class_talent_culomn);
|
|
void _class_talent_sreceive_learn_request(int spec_index, int class_talent_row, int class_talent_culomn);
|
|
|
|
void class_talent_crequest_reset();
|
|
void class_talent_sreceive_reset_request();
|
|
void _class_talent_sreceive_reset_request();
|
|
|
|
void class_talent_sreset();
|
|
void class_talent_creset();
|
|
|
|
void class_talent_adds(int class_talent);
|
|
void class_talent_removes(int class_talent);
|
|
bool class_talent_hass(int class_talent);
|
|
int class_talent_gets(int index);
|
|
int class_talent_gets_count();
|
|
void class_talents_sclear();
|
|
|
|
void class_talent_addc(int class_talent);
|
|
void class_talent_removec(int class_talent);
|
|
bool class_talent_hasc(int class_talent);
|
|
int class_talent_getc(int index);
|
|
int class_talent_getc_count();
|
|
void class_talent_cclear();
|
|
|
|
PoolIntArray sclass_talents_get();
|
|
void sclass_talents_set(const PoolIntArray &data);
|
|
|
|
//// Character Talents ////
|
|
|
|
int character_talent_points_gets_free();
|
|
void character_talent_points_sets_free(int value);
|
|
|
|
int character_talent_points_getc_free();
|
|
void character_talent_points_setc_free(int value);
|
|
|
|
void character_talent_crequest_learn(int spec_index, int character_talent_row, int character_talent_culomn);
|
|
void character_talent_sreceive_learn_request(int spec_index, int character_talent_row, int character_talent_culomn);
|
|
void _character_talent_sreceive_learn_request(int spec_index, int character_talent_row, int character_talent_culomn);
|
|
|
|
void character_talent_crequest_reset();
|
|
void character_talent_sreceive_reset_request();
|
|
void _character_talent_sreceive_reset_request();
|
|
|
|
void character_talent_sreset();
|
|
void character_talent_creset();
|
|
|
|
void character_talent_adds(int character_talent);
|
|
void character_talent_removes(int character_talent);
|
|
bool character_talent_hass(int character_talent);
|
|
int character_talent_gets(int index);
|
|
int character_talent_gets_count();
|
|
void character_talents_sclear();
|
|
|
|
void character_talent_addc(int character_talent);
|
|
void character_talent_removec(int character_talent);
|
|
bool character_talent_hasc(int character_talent);
|
|
int character_talent_getc(int index);
|
|
int character_talent_getc_count();
|
|
void character_talent_cclear();
|
|
|
|
PoolIntArray scharacter_talents_get();
|
|
void scharacter_talents_set(const PoolIntArray &data);
|
|
|
|
//// Inventory ////
|
|
|
|
Ref<Bag> bag_gets() const;
|
|
void bag_sets(const Ref<Bag> bag);
|
|
|
|
Ref<Bag> bag_getc() const;
|
|
void bag_setc(const Ref<Bag> bag);
|
|
|
|
Ref<Bag> target_bag_gets() const;
|
|
void target_bag_sets(const Ref<Bag> bag);
|
|
|
|
Ref<Bag> target_bag_getc() const;
|
|
void target_bag_setc(const Ref<Bag> bag);
|
|
|
|
void bag_setc_rpc(String data);
|
|
void target_bag_setc_rpc(String data);
|
|
|
|
void loot_crequest(int index);
|
|
void loots(int index);
|
|
void lootc(int index);
|
|
|
|
void item_addc_rpc(int slot_id, String item_data);
|
|
void item_addc(int slot_id, Ref<ItemInstance> item);
|
|
|
|
//Bag
|
|
void item_removes(const int slot_id);
|
|
void item_removec(const int slot_id);
|
|
void item_cdeny_remove(const int slot_id);
|
|
void item_crequest_remove(const int slot_id);
|
|
|
|
void items_swaps(int slot_id_1, int slot_id_2);
|
|
void items_swapc(int slot_id_1, int slot_id_2);
|
|
void item_cdeny_swap(int slot_id_1, int slot_id_2);
|
|
void item_crequest_swap(int slot_id_1, int slot_id_2);
|
|
|
|
void item_cchange_count(int slot_id, int new_count);
|
|
|
|
void notification_item_sadded(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id);
|
|
void notification_item_sremoved(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id);
|
|
void notification_items_sswapped(Ref<Bag> bag, int slot_id_1, int slot_id_2);
|
|
void notification_item_sscount_changed(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id);
|
|
void notification_soverburdened(Ref<Bag> bag);
|
|
void notification_soverburden_removed(Ref<Bag> bag);
|
|
|
|
//Target Bag
|
|
|
|
void target_item_addc_rpc(int slot_id, String item_data);
|
|
void target_item_addc(int slot_id, Ref<ItemInstance> item);
|
|
|
|
void target_item_removes(const int slot_id);
|
|
void target_item_removec(const int slot_id);
|
|
void target_item_cdeny_remove(const int slot_id);
|
|
void target_remove_crequest_item(const int slot_id);
|
|
|
|
void target_items_sswap(int slot_id_1, int slot_id_2);
|
|
void target_items_cswap(int slot_id_1, int slot_id_2);
|
|
void target_item_cdeny_swap(int slot_id_1, int slot_id_2);
|
|
void target_item_crequest_swap(int slot_id_1, int slot_id_2);
|
|
|
|
void target_item_cchange_count(int slot_id, int new_count);
|
|
|
|
void notification_target_item_sadded(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id);
|
|
void notification_target_item_sremoved(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id);
|
|
void notification_target_items_sswapped(Ref<Bag> bag, int slot_id_1, int slot_id_2);
|
|
void notification_target_item_sscount_changed(Ref<Bag> bag, Ref<ItemInstance> item, int slot_id);
|
|
|
|
//Vendors
|
|
void vendor_item_buy_crequest(const int index, const int count);
|
|
void vendor_item_sbuy(const int index, const int count);
|
|
void vendor_item_sell_crequest(const int slot_id);
|
|
void vendor_item_ssell(const int slot_id);
|
|
|
|
//// Data ////
|
|
|
|
void data_adds(Ref<EntityDataContainer> data);
|
|
void data_removes(int index);
|
|
Ref<EntityDataContainer> data_gets(int index);
|
|
int data_gets_count();
|
|
|
|
void data_addc(Ref<EntityDataContainer> data);
|
|
void data_removec(int index);
|
|
Ref<EntityDataContainer> data_getc(int index);
|
|
int data_getc_count();
|
|
|
|
Vector<Variant> sdatas_get();
|
|
void sdatas_set(const Vector<Variant> &data);
|
|
|
|
//// Actionbars ////
|
|
|
|
bool get_actionbar_locked();
|
|
void set_actionbar_locked(bool value);
|
|
|
|
Ref<ActionBarProfile> get_action_bar_profile();
|
|
|
|
void loaded();
|
|
|
|
String random_name();
|
|
|
|
virtual void _initialize();
|
|
void setup(Ref<EntityCreateInfo> info);
|
|
virtual void _setup();
|
|
void setup_actionbars();
|
|
|
|
//// AI ////
|
|
|
|
bool pet_gets_is();
|
|
bool pet_getc_is();
|
|
|
|
Entity *pet_gets_owner();
|
|
void pet_sets_owner(Entity *entity);
|
|
void pet_sets_owner_bind(Node *entity);
|
|
|
|
int pet_gets_formation_index();
|
|
void pet_sets_formation_index(int value);
|
|
|
|
EntityEnums::AIStates pet_ai_state_gets();
|
|
void pet_ai_state_sets(EntityEnums::AIStates value);
|
|
|
|
EntityEnums::EntityController original_entity_controller_gets();
|
|
void original_entity_controller_sets(EntityEnums::EntityController value);
|
|
|
|
EntityEnums::EntityController entity_controller_gets();
|
|
void entity_controller_sets(EntityEnums::EntityController value);
|
|
|
|
EntityEnums::EntityController entity_controller_getc();
|
|
void entity_controller_setc(EntityEnums::EntityController value);
|
|
|
|
bool getc_is_controlled();
|
|
|
|
Ref<EntityAI> ai_gets();
|
|
void ai_sets(Ref<EntityAI> value);
|
|
|
|
//// Pets ////
|
|
|
|
void pet_adds(Entity *entity);
|
|
void pet_adds_bind(Node *entity);
|
|
Entity *pet_gets(int index);
|
|
void pet_removes_index(int index);
|
|
void pet_removes(Entity *entity);
|
|
void pet_removes_bind(Node *entity);
|
|
int pet_gets_count();
|
|
|
|
void pet_addc_path(NodePath path);
|
|
|
|
void pet_addc(Entity *entity);
|
|
void pet_addc_bind(Node *entity);
|
|
Entity *pet_getc(int index);
|
|
void pet_removec_index(int index);
|
|
void pet_removec(Entity *entity);
|
|
void pet_removec_bind(Node *entity);
|
|
int pet_getc_count();
|
|
|
|
//void pets_attack();
|
|
//void pets_follow();
|
|
//void pets_stop();
|
|
|
|
//// Profiles ////
|
|
|
|
Ref<ClassProfile> get_class_profile();
|
|
|
|
//// Serialization ////
|
|
|
|
bool is_deserialized();
|
|
|
|
Dictionary to_dict();
|
|
void from_dict(const Dictionary &dict);
|
|
|
|
virtual Dictionary _to_dict();
|
|
virtual void _from_dict(const Dictionary &dict);
|
|
|
|
// Networking
|
|
Dictionary data_as_dict(String &data);
|
|
|
|
void register_for_physics_process(Ref<SpellCastInfo> info);
|
|
|
|
bool get_maunal_process() const;
|
|
void set_maunal_process(bool value);
|
|
|
|
void update(float delta);
|
|
|
|
Entity();
|
|
~Entity();
|
|
|
|
protected:
|
|
void _crafts(int id);
|
|
void _notification_sxp_gained(int value);
|
|
void _notification_slevel_up(int level);
|
|
void _moved();
|
|
void _con_target_changed(Node *p_entity, Node *p_old_target);
|
|
void _notification_sdeath();
|
|
void _spell_learns(int id);
|
|
void _vendor_item_sbuy(const int index, const int count);
|
|
void _vendor_item_ssell(const int slot_id);
|
|
|
|
bool _set(const StringName &p_name, const Variant &p_value);
|
|
bool _get(const StringName &p_name, Variant &r_ret) const;
|
|
void _get_property_list(List<PropertyInfo> *p_list) const;
|
|
void _validate_property(PropertyInfo &property) const;
|
|
static void _bind_methods();
|
|
virtual void _notification(int p_what);
|
|
|
|
protected:
|
|
struct Cooldown {
|
|
int id;
|
|
StringName path;
|
|
float cooldown;
|
|
|
|
Cooldown() {
|
|
id = 0;
|
|
cooldown = 0;
|
|
}
|
|
};
|
|
|
|
private:
|
|
bool _maunal_process;
|
|
|
|
const float SAVE_BASE_SECONDS = 10.0;
|
|
bool _deserialized;
|
|
|
|
//// Paths ////
|
|
|
|
NodePath _body_path;
|
|
Node *_body;
|
|
Spatial *_body_3d;
|
|
Node2D *_body_2d;
|
|
|
|
NodePath _character_skeleton_path;
|
|
Node *_character_skeleton;
|
|
|
|
//// Transforms ////
|
|
|
|
Transform _transform;
|
|
Transform2D _transform_2d;
|
|
|
|
//// PlayerData ////
|
|
|
|
int _s_guid;
|
|
int _c_guid;
|
|
|
|
int _s_class_id;
|
|
int _c_class_id;
|
|
|
|
StringName _s_entity_data_path;
|
|
|
|
int _s_entity_player_type;
|
|
int _c_entity_player_type;
|
|
|
|
int _s_type;
|
|
int _c_type;
|
|
|
|
int _s_model_index;
|
|
int _c_model_index;
|
|
|
|
int _s_level;
|
|
int _c_level;
|
|
|
|
int _s_xp;
|
|
int _c_xp;
|
|
|
|
int _s_money;
|
|
int _c_money;
|
|
|
|
Ref<EntityData> _s_entity_data;
|
|
Ref<EntityData> _c_entity_data;
|
|
|
|
int _s_send_flag;
|
|
|
|
String _s_entity_name;
|
|
String _c_entity_name;
|
|
|
|
EntityEnums::EntityInteractionType _s_interaction_type;
|
|
EntityEnums::EntityInteractionType _c_interaction_type;
|
|
|
|
int _s_is_dead;
|
|
int _c_is_dead;
|
|
|
|
int _s_seed;
|
|
int _c_seed;
|
|
|
|
//// Stats ////
|
|
|
|
Vector<EntityStat> _stats;
|
|
|
|
//// Equipment ////
|
|
|
|
Vector<Ref<ItemInstance>> _s_equipment;
|
|
Vector<Ref<ItemInstance>> _c_equipment;
|
|
|
|
//// Resources ////
|
|
|
|
Vector<Ref<EntityResource>> _s_resources;
|
|
Vector<Ref<EntityResource>> _c_resources;
|
|
|
|
//// GCD ////
|
|
|
|
float _s_gcd;
|
|
float _c_gcd;
|
|
|
|
//// States ////
|
|
|
|
int _s_states[EntityEnums::ENTITY_STATE_TYPE_INDEX_MAX];
|
|
|
|
int _s_state;
|
|
int _c_state;
|
|
|
|
//// SpellCastData ////
|
|
|
|
Ref<SpellCastInfo> _s_spell_cast_info;
|
|
Ref<SpellCastInfo> _c_spell_cast_info;
|
|
|
|
//// AuraComponent ////
|
|
|
|
Vector<Ref<AuraData>> _s_auras;
|
|
Vector<Ref<AuraData>> _c_auras;
|
|
|
|
int _s_entity_type;
|
|
int _c_entity_type;
|
|
|
|
int _s_immunity_flags;
|
|
|
|
int _s_entity_flags;
|
|
int _c_entity_flags;
|
|
|
|
//// Cooldowns ////
|
|
Vector<Cooldown> _s_cooldowns;
|
|
Vector<Cooldown> _c_cooldowns;
|
|
|
|
Vector<Cooldown> _s_category_cooldowns;
|
|
Vector<Cooldown> _c_category_cooldowns;
|
|
|
|
int _s_active_category_cooldowns;
|
|
int _c_active_category_cooldowns;
|
|
|
|
//// Targeting ////
|
|
|
|
Entity *_s_target;
|
|
Entity *_c_target;
|
|
|
|
//// Class Talents ////
|
|
|
|
int _s_free_class_talent_points;
|
|
int _c_free_class_talent_points;
|
|
|
|
Vector<int> _s_class_talents;
|
|
Vector<int> _c_class_talents;
|
|
|
|
//// Character Talents ////
|
|
|
|
int _s_free_character_talent_points;
|
|
int _c_free_character_talent_points;
|
|
|
|
Vector<int> _s_character_talents;
|
|
Vector<int> _c_character_talents;
|
|
|
|
//// Data ////
|
|
|
|
Vector<Ref<EntityDataContainer>> _s_data;
|
|
Vector<Ref<EntityDataContainer>> _c_data;
|
|
|
|
//// Actionbars ////
|
|
|
|
bool _actionbar_locked;
|
|
Ref<ActionBarProfile> _action_bar_profile;
|
|
|
|
//// Crafting System ////
|
|
|
|
Vector<Ref<CraftRecipe>> _s_craft_recipes;
|
|
Vector<Ref<CraftRecipe>> _c_craft_recipes;
|
|
|
|
//// Known Spells ////
|
|
|
|
int _s_free_spell_points;
|
|
int _c_free_spell_points;
|
|
|
|
Vector<Ref<Spell>> _s_spells;
|
|
Vector<Ref<Spell>> _c_spells;
|
|
|
|
//// Skills ////
|
|
|
|
Vector<Ref<EntitySkill>> _s_skills;
|
|
Vector<Ref<EntitySkill>> _c_skills;
|
|
|
|
//// Stat Allocations ////
|
|
|
|
//int _unallocated_stats;
|
|
//int _stat_allocations[ESS::get_singleton()->stat_get_count()];
|
|
|
|
//// Inventory ////
|
|
|
|
Ref<Bag> _s_bag;
|
|
Ref<Bag> _c_bag;
|
|
|
|
Ref<Bag> _s_target_bag;
|
|
Ref<Bag> _c_target_bag;
|
|
|
|
// AI
|
|
|
|
EntityEnums::AIStates _sai_state;
|
|
EntityEnums::AIStates _sai_state_stored;
|
|
|
|
EntityEnums::EntityController _s_original_entity_controller;
|
|
EntityEnums::EntityController _s_entity_controller;
|
|
EntityEnums::EntityController _c_entity_controller;
|
|
bool _c_is_controlled;
|
|
Ref<EntityAI> _s_ai;
|
|
|
|
//Pets
|
|
|
|
Entity *_s_pet_owner;
|
|
Entity *_c_pet_owner;
|
|
|
|
int _s_pet_formation_index;
|
|
|
|
EntityEnums::AIStates _s_pet_ai_state;
|
|
|
|
Vector<Entity *> _s_pets;
|
|
Vector<Entity *> _c_pets;
|
|
|
|
// Callbacks
|
|
|
|
Vector<Ref<SpellCastInfo>> _physics_process_scis;
|
|
};
|
|
|
|
#endif
|